@powersync/web 0.0.0-dev-20260414110516 → 0.0.0-dev-20260504100448

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.37.1",
+    "version": "1.37.2",
     "description": "PowerSync Web SDK",
     "main": "lib/src/index.js",
     "module": "lib/src/index.js",
@@ -67,26 +67,23 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "catalog:",
-        "@powersync/common": "workspace:^1.51.0"
+        "@powersync/common": "workspace:^1.52.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
-        "bson": "catalog:",
         "comlink": "catalog:",
         "commander": "^12.1.0"
     },
     "devDependencies": {
-        "@journeyapps/wa-sqlite": "^1.5.0",
+        "@journeyapps/wa-sqlite": "^1.7.0",
         "@types/uuid": "catalog:",
-        "crypto-browserify": "^3.12.0",
+        "bson": "catalog:",
         "glob": "catalog:",
         "p-defer": "catalog:",
         "source-map-loader": "^5.0.0",
-        "stream-browserify": "^3.0.0",
         "terser-webpack-plugin": "^5.3.9",
         "uuid": "catalog:",
         "vite": "catalog:",
-        "vm-browserify": "^1.1.2",
         "webpack": "^5.90.1",
         "webpack-cli": "^5.1.4",
         "webpack-node-externals": "^3.0.0"

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -2,6 +2,7 @@ import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSy
 import { ResolvedWebSQLOpenOptions, WebSQLFlags } from './adapters/web-sql-flags.js';
 export interface WebPowerSyncFlags extends WebSQLFlags {
     /**
+     * @deprecated This flag is no longer used. Navigator locks now handle tab detection automatically.
      * Externally unload open PowerSync database instances when the window closes.
      * Setting this to `true` requires calling `close` on all open PowerSyncDatabase
      * instances before the window unloads
@@ -54,7 +55,6 @@ export declare const resolveWebPowerSyncFlags: (flags?: WebPowerSyncFlags) => Re
 export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     protected options: WebPowerSyncDatabaseOptions;
     static SHARED_MUTEX: Mutex;
-    protected unloadListener?: () => Promise<void>;
     protected resolvedFlags: WebPowerSyncFlags;
     constructor(options: WebPowerSyncDatabaseOptionsWithAdapter);
     constructor(options: WebPowerSyncDatabaseOptionsWithOpenFactory);

package/lib/src/db/PowerSyncDatabase.js

@@ -47,17 +47,12 @@ function assertValidDatabaseOptions(options) {
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     options;
     static SHARED_MUTEX = new Mutex();
-    unloadListener;
     resolvedFlags;
     constructor(options) {
         super(options);
         this.options = options;
         assertValidDatabaseOptions(options);
         this.resolvedFlags = resolveWebPowerSyncFlags(options.flags);
-        if (this.resolvedFlags.enableMultiTabs && !this.resolvedFlags.externallyUnload) {
-            this.unloadListener = () => this.close({ disconnect: false });
-            window.addEventListener('unload', this.unloadListener);
-        }
     }
     async _initialize() {
         if (this.database instanceof AsyncDbAdapter) {
@@ -98,9 +93,6 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * multiple tabs are not enabled.
      */
     close(options) {
-        if (this.unloadListener) {
-            window.removeEventListener('unload', this.unloadListener);
-        }
         return super.close({
             // Don't disconnect by default if multiple tabs are enabled
             disconnect: options?.disconnect ?? !this.resolvedFlags.enableMultiTabs

package/lib/src/db/adapters/AsyncWebAdapter.d.ts

@@ -6,10 +6,10 @@ import { DatabaseClient } from './wa-sqlite/DatabaseClient.js';
  */
 declare class AsyncConnectionPool implements ConnectionPool {
     readonly name: string;
-    protected readonly inner: Promise<DatabaseClient>;
-    protected resolvedClient?: DatabaseClient;
+    protected readonly state: Promise<PoolState>;
+    protected resolvedWriter?: DatabaseClient;
     private readonly pendingListeners;
-    constructor(inner: Promise<DatabaseClient>, name: string);
+    constructor(inner: Promise<PoolConnection>, name: string);
     init(): Promise<void>;
     close(): Promise<void>;
     readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
@@ -17,6 +17,16 @@ declare class AsyncConnectionPool implements ConnectionPool {
     refreshSchema(): Promise<void>;
     registerListener(listener: Partial<DBAdapterListener>): () => void;
 }
+export interface PoolConnection {
+    writer: DatabaseClient;
+    additionalReaders: DatabaseClient[];
+}
+interface PoolState {
+    writer: DatabaseClient;
+    withConnection<T>(allowReadOnly: boolean, fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    close(): Promise<void>;
+    refreshSchema(): Promise<void>;
+}
 declare const AsyncDbAdapter_base: (new (...args: any[]) => {
     readTransaction<T>(fn: (tx: import("@powersync/common").Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
     writeTransaction<T>(fn: (tx: import("@powersync/common").Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;

package/lib/src/db/adapters/AsyncWebAdapter.js

@@ -1,44 +1,48 @@
-import { DBAdapterDefaultMixin } from '@powersync/common';
+import { DBAdapterDefaultMixin, Mutex, Semaphore } from '@powersync/common';
 /**
  * A connection pool implementation delegating to another pool opened asynchronnously.
  */
 class AsyncConnectionPool {
     name;
-    inner;
-    resolvedClient;
+    state;
+    resolvedWriter;
     pendingListeners = new Set();
     constructor(inner, name) {
         this.name = name;
-        this.inner = inner.then((client) => {
+        this.state = inner.then((client) => {
             for (const pending of this.pendingListeners) {
-                pending.closeAfterRegisteredOnResolvedPool = client.registerListener(pending.listener);
+                pending.closeAfterRegisteredOnResolvedPool = client.writer.registerListener(pending.listener);
             }
             this.pendingListeners.clear();
-            this.resolvedClient = client;
-            return client;
+            this.resolvedWriter = client.writer;
+            if (client.additionalReaders.length) {
+                return readWritePoolState(client.writer, client.additionalReaders);
+            }
+            return singleConnectionPoolState(client.writer);
         });
     }
     async init() {
-        await this.inner;
+        await this.state;
     }
     async close() {
-        const inner = await this.inner;
-        return await inner.close();
+        const state = await this.state;
+        await state.close();
     }
     async readLock(fn, options) {
-        const inner = await this.inner;
-        return await inner.readLock(fn, options);
+        const state = await this.state;
+        return state.withConnection(true, fn, options);
     }
     async writeLock(fn, options) {
-        const inner = await this.inner;
-        return await inner.writeLock(fn, options);
+        const state = await this.state;
+        return state.withConnection(false, fn, options);
     }
     async refreshSchema() {
-        await (await this.inner).refreshSchema();
+        const state = await this.state;
+        await state.refreshSchema();
     }
     registerListener(listener) {
-        if (this.resolvedClient) {
-            return this.resolvedClient.registerListener(listener);
+        if (this.resolvedWriter) {
+            return this.resolvedWriter.registerListener(listener);
         }
         else {
             const pending = { listener };
@@ -55,14 +59,104 @@ class AsyncConnectionPool {
         }
     }
 }
+function singleConnectionPoolState(connection) {
+    return {
+        writer: connection,
+        withConnection: (allowReadOnly, fn, options) => {
+            if (allowReadOnly) {
+                return connection.readLock(fn, options);
+            }
+            else {
+                return connection.writeLock(fn, options);
+            }
+        },
+        close: () => connection.close(),
+        refreshSchema: () => connection.refreshSchema()
+    };
+}
+function readWritePoolState(writer, readers) {
+    // DatabaseClients have locks internally, so these aren't necessary for correctness. However, our mutex and semaphore
+    // implementations are very cheap to cancel, which we use to dispatch reads to the first available connection (by
+    // simply requesting all of them and sticking with the first connection we get).
+    const writerMutex = new Mutex();
+    const readerSemaphore = new Semaphore(readers);
+    return {
+        writer,
+        async withConnection(allowReadOnly, fn, options) {
+            const abortController = new AbortController();
+            const abortSignal = abortController.signal;
+            let timeout = null;
+            let release;
+            if (options?.timeoutMs) {
+                timeout = setTimeout(() => abortController.abort, options.timeoutMs);
+            }
+            try {
+                if (allowReadOnly) {
+                    let connection;
+                    // Even if we have a pool of read connections, it's typically very small and we assume that most queries are
+                    // reads. So, we want to request any connection from the read pool and the dedicated write connection (which
+                    // can also serve reads). We race for the first connection we can obtain this way, and then abort the other
+                    // request.
+                    [connection, release] = await new Promise((resolve, reject) => {
+                        let didComplete = false;
+                        function complete() {
+                            didComplete = true;
+                            abortController.abort();
+                        }
+                        function completeSuccess(connection, returnFn) {
+                            if (didComplete) {
+                                // We're not going to use this connection, so return it immediately.
+                                returnFn();
+                            }
+                            else {
+                                complete();
+                                resolve([connection, returnFn]);
+                            }
+                        }
+                        function completeError(error) {
+                            // We either have a working connection already, or we've rejected the promise. Either way, we don't need
+                            // to do either thing again.
+                            if (didComplete)
+                                return;
+                            complete();
+                            reject(error);
+                        }
+                        writerMutex.acquire(abortSignal).then((unlock) => completeSuccess(writer, unlock), completeError);
+                        readerSemaphore
+                            .requestOne(abortSignal)
+                            .then(({ item, release }) => completeSuccess(item, release), completeError);
+                    });
+                    return await connection.readLock(fn);
+                }
+                else {
+                    return await writerMutex.runExclusive(() => writer.writeLock(fn), abortSignal);
+                }
+            }
+            finally {
+                if (timeout != null) {
+                    clearTimeout(timeout);
+                }
+                release?.();
+            }
+        },
+        async close() {
+            await writer.close();
+            await Promise.all(readers.map((r) => r.close()));
+        },
+        async refreshSchema() {
+            await writer.refreshSchema();
+            await Promise.all(readers.map((r) => r.refreshSchema()));
+        }
+    };
+}
 export class AsyncDbAdapter extends DBAdapterDefaultMixin(AsyncConnectionPool) {
     async shareConnection() {
-        const inner = await this.inner;
-        return inner.shareConnection();
+        const state = await this.state;
+        return state.writer.shareConnection();
     }
     getConfiguration() {
-        if (this.resolvedClient) {
-            return this.resolvedClient.getConfiguration();
+        if (this.resolvedWriter) {
+            return this.resolvedWriter.getConfiguration();
         }
         throw new Error('AsyncDbAdapter.getConfiguration() can only be called after initializing it.');
     }

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

@@ -85,8 +85,7 @@ export class DatabaseServer {
             },
             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();
+                const lease = await this.#inner.acquireConnection(timeoutMs != null ? AbortSignal.timeout(timeoutMs) : undefined);
                 if (!isOpen) {
                     // Race between requestAccess and close(), the connection was closed while we tried to acquire a lease.
                     await lease.returnLease();

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

@@ -23,7 +23,7 @@ export class RawSqliteConnection {
     }
     async init() {
         const api = (this._sqliteAPI = await this.openSQLiteAPI());
-        this.db = await api.open_v2(this.options.dbFilename);
+        this.db = await api.open_v2(this.options.dbFilename, this.options.isReadOnly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */);
         await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
         if (this.options.encryptionKey) {
             const escapedKey = this.options.encryptionKey.replace("'", "''");

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

@@ -1,12 +1,26 @@
 import { DBAdapter, SQLOpenFactory, type ILogLevel } from '@powersync/common';
 import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags.js';
 import { WASQLiteVFS } from './vfs.js';
-import { DatabaseClient } from './DatabaseClient.js';
+import { PoolConnection } from '../AsyncWebAdapter.js';
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
     vfs?: WASQLiteVFS;
+    /**
+     * If the {@link vfs} supports it, an additional amount of read-only connections to open. Using additional read
+     * connections can speed up queries by dispatching them to multiple workers running them concurrently.
+     *
+     * {@link WASQLiteVFS.OPFSWriteAheadVFS} is the only VFS with support for multiple connections, so this option is
+     * ignored for other VFS implementations.
+     *
+     * Defaults to 1.
+     */
+    additionalReaders?: number;
 }
 export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
     vfs: WASQLiteVFS;
+    /**
+     * Whether this is a read-only connection opened for the `OPFSWriteAheadVFS` file system.
+     */
+    isReadOnly: boolean;
 }
 export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
     logLevel: ILogLevel;
@@ -27,5 +41,5 @@ export declare class WASQLiteOpenFactory implements SQLOpenFactory {
     get waOptions(): WASQLiteOpenFactoryOptions;
     protected openAdapter(): DBAdapter;
     openDB(): DBAdapter;
-    openConnection(): Promise<DatabaseClient>;
+    openConnection(): Promise<PoolConnection>;
 }

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

@@ -50,7 +50,7 @@ export class WASQLiteOpenFactory {
         if (!enableMultiTabs) {
             this.logger.warn('Multiple tabs are not enabled in this browser');
         }
-        const resolvedOptions = {
+        const resolveOptions = (isReadOnly) => ({
             dbFilename: this.options.dbFilename,
             dbLocation: this.options.dbLocation,
             debugMode: this.options.debugMode,
@@ -58,55 +58,77 @@ export class WASQLiteOpenFactory {
             temporaryStorage,
             cacheSizeKb,
             flags: this.resolvedFlags,
-            encryptionKey: encryptionKey
-        };
-        let clientOptions;
+            encryptionKey: encryptionKey,
+            isReadOnly
+        });
+        let client;
+        let additionalReaders = [];
         let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
         if (useWebWorker) {
             const optionsDbWorker = this.options.worker;
-            const workerPort = typeof optionsDbWorker == 'function'
-                ? resolveWorkerDatabasePortFactory(() => optionsDbWorker({
-                    ...this.options,
-                    temporaryStorage,
-                    cacheSizeKb,
-                    flags: this.resolvedFlags,
-                    encryptionKey
-                }))
-                : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
-            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,
-                onClose: () => {
-                    closeSignal.abort();
-                    if (workerPort instanceof Worker) {
-                        workerPort.terminate();
-                    }
-                    else {
-                        workerPort.close();
+            const openDatabaseWorker = async (resolvedOptions) => {
+                const workerPort = typeof optionsDbWorker == 'function'
+                    ? resolveWorkerDatabasePortFactory(() => optionsDbWorker({
+                        ...this.options,
+                        temporaryStorage,
+                        cacheSizeKb,
+                        flags: this.resolvedFlags,
+                        encryptionKey
+                    }))
+                    : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
+                const source = Comlink.wrap(workerPort);
+                const closeSignal = new AbortController();
+                const connection = await source.connect({
+                    ...resolvedOptions,
+                    logLevel: this.logger.getLevel(),
+                    lockName: await generateTabCloseSignal(closeSignal.signal)
+                });
+                const clientOptions = {
+                    connection,
+                    source,
+                    // This tab owns the worker, so we're guaranteed to outlive it.
+                    remoteCanCloseUnexpectedly: false,
+                    onClose: () => {
+                        closeSignal.abort();
+                        if (workerPort instanceof Worker) {
+                            workerPort.terminate();
+                        }
+                        else {
+                            workerPort.close();
+                        }
                     }
-                }
+                };
+                return new DatabaseClient(clientOptions, {
+                    ...resolvedOptions,
+                    requiresPersistentTriggers
+                });
             };
+            client = await openDatabaseWorker(resolveOptions(false));
+            if (vfs == WASQLiteVFS.OPFSWriteAheadVFS) {
+                // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
+                // concurrent reads / writes.
+                const additionalReadersCount = this.options.additionalReaders ?? 1;
+                for (let i = 0; i < additionalReadersCount; i++) {
+                    const reader = await openDatabaseWorker(resolveOptions(true));
+                    additionalReaders.push(reader);
+                }
+            }
         }
         else {
             // Don't use a web worker. Instead, open the MultiDatabaseServer a worker would use locally.
             const localServer = new MultiDatabaseServer(this.logger);
             requiresPersistentTriggers = true;
+            const resolvedOptions = resolveOptions(false);
             const connection = await localServer.openConnectionLocally(resolvedOptions);
-            clientOptions = { connection, source: null, remoteCanCloseUnexpectedly: false };
+            client = new DatabaseClient({ connection, source: null, remoteCanCloseUnexpectedly: false }, {
+                ...resolvedOptions,
+                requiresPersistentTriggers
+            });
         }
-        return new DatabaseClient(clientOptions, {
-            ...resolvedOptions,
-            requiresPersistentTriggers
-        });
+        return {
+            writer: client,
+            additionalReaders
+        };
     }
 }
 /**

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

@@ -5,9 +5,10 @@ import type * as SQLite from '@journeyapps/wa-sqlite';
 export declare enum WASQLiteVFS {
     IDBBatchAtomicVFS = "IDBBatchAtomicVFS",
     OPFSCoopSyncVFS = "OPFSCoopSyncVFS",
-    AccessHandlePoolVFS = "AccessHandlePoolVFS"
+    AccessHandlePoolVFS = "AccessHandlePoolVFS",
+    OPFSWriteAheadVFS = "OPFSWriteAheadVFS"
 }
-export declare function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS): vfs is WASQLiteVFS.OPFSCoopSyncVFS | WASQLiteVFS.AccessHandlePoolVFS;
+export declare function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS): vfs is WASQLiteVFS.OPFSCoopSyncVFS | WASQLiteVFS.AccessHandlePoolVFS | WASQLiteVFS.OPFSWriteAheadVFS;
 /**
  * @internal
  */
@@ -26,22 +27,6 @@ export type WASQLiteModuleFactory = (options: WASQLiteModuleFactoryOptions) => P
     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
  */
@@ -58,4 +43,8 @@ export declare const DEFAULT_MODULE_FACTORIES: {
         module: any;
         vfs: any;
     }>;
+    OPFSWriteAheadVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
+        module: any;
+        vfs: any;
+    }>;
 };

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

@@ -6,50 +6,37 @@ export var WASQLiteVFS;
     WASQLiteVFS["IDBBatchAtomicVFS"] = "IDBBatchAtomicVFS";
     WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
     WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
+    WASQLiteVFS["OPFSWriteAheadVFS"] = "OPFSWriteAheadVFS";
 })(WASQLiteVFS || (WASQLiteVFS = {}));
 export function vfsRequiresDedicatedWorkers(vfs) {
     return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
 }
-/**
- * @internal
- */
-export const AsyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const MultiCipherAsyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const SyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const MultiCipherSyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
-    return factory();
-};
+async function asyncModuleFactory(encryptionKey) {
+    if (encryptionKey) {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
+        return factory();
+    }
+    else {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
+        return factory();
+    }
+}
+async function syncModuleFactory(encryptionKey) {
+    if (encryptionKey) {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
+        return factory();
+    }
+    else {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
+        return factory();
+    }
+}
 /**
  * @internal
  */
 export const DEFAULT_MODULE_FACTORIES = {
     [WASQLiteVFS.IDBBatchAtomicVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherAsyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await AsyncWASQLiteModuleFactory();
-        }
+        const module = await asyncModuleFactory(options.encryptionKey);
         const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
         return {
             module,
@@ -58,13 +45,7 @@ export const DEFAULT_MODULE_FACTORIES = {
         };
     },
     [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherSyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await SyncWASQLiteModuleFactory();
-        }
+        const module = await syncModuleFactory(options.encryptionKey);
         // @ts-expect-error The types for this static method are missing upstream
         const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
         return {
@@ -73,13 +54,7 @@ export const DEFAULT_MODULE_FACTORIES = {
         };
     },
     [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherSyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await SyncWASQLiteModuleFactory();
-        }
+        const module = await syncModuleFactory(options.encryptionKey);
         // @ts-expect-error The types for this static method are missing upstream
         const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
         const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
@@ -87,5 +62,15 @@ export const DEFAULT_MODULE_FACTORIES = {
             module,
             vfs
         };
+    },
+    [WASQLiteVFS.OPFSWriteAheadVFS]: async (options) => {
+        const module = await syncModuleFactory(options.encryptionKey);
+        // @ts-expect-error The types for this static method are missing upstream
+        const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
+        const vfs = await OPFSWriteAheadVFS.create(options.dbFileName, module, {});
+        return {
+            module,
+            vfs
+        };
     }
 };

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.d.ts

@@ -44,4 +44,8 @@ export declare class SSRStreamingSyncImplementation extends BaseObserver impleme
      * No-op in SSR mode.
      */
     updateSubscriptions(): void;
+    /**
+     * No-op in SSR mode.
+     */
+    markConnectionMayHaveChanged(): void;
 }

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.js

@@ -61,4 +61,8 @@ export class SSRStreamingSyncImplementation extends BaseObserver {
      * No-op in SSR mode.
      */
     updateSubscriptions() { }
+    /**
+     * No-op in SSR mode.
+     */
+    markConnectionMayHaveChanged() { }
 }