@powersync/web 0.0.0-dev-20260311103504 → 0.0.0-dev-20260503073249

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,55 +50,85 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
         if (!enableMultiTabs) {
             this.logger.warn('Multiple tabs are not enabled in this browser');
         }
+        const resolveOptions = (isReadOnly) => ({
+            dbFilename: this.options.dbFilename,
+            dbLocation: this.options.dbLocation,
+            debugMode: this.options.debugMode,
+            vfs,
+            temporaryStorage,
+            cacheSizeKb,
+            flags: this.resolvedFlags,
+            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 workerDBOpener = Comlink.wrap(workerPort);
-            return new WorkerWrappedAsyncDatabaseConnection({
-                remote: workerDBOpener,
-                // 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: () => {
-                    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
-            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 resolvedOptions = resolveOptions(false);
+            const connection = await localServer.openConnectionLocally(resolvedOptions);
+            client = new DatabaseClient({ connection, source: null, remoteCanCloseUnexpectedly: false }, {
+                ...resolvedOptions,
+                requiresPersistentTriggers
             });
         }
+        return {
+            writer: client,
+            additionalReaders
+        };
     }
 }
 /**
@@ -89,7 +138,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,50 @@
+import type * as SQLite from '@journeyapps/wa-sqlite';
+/**
+ * List of currently tested virtual filesystems
+ */
+export declare enum WASQLiteVFS {
+    IDBBatchAtomicVFS = "IDBBatchAtomicVFS",
+    OPFSCoopSyncVFS = "OPFSCoopSyncVFS",
+    AccessHandlePoolVFS = "AccessHandlePoolVFS",
+    OPFSWriteAheadVFS = "OPFSWriteAheadVFS"
+}
+export declare function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS): vfs is WASQLiteVFS.OPFSCoopSyncVFS | WASQLiteVFS.AccessHandlePoolVFS | WASQLiteVFS.OPFSWriteAheadVFS;
+/**
+ * @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 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;
+    }>;
+    OPFSWriteAheadVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
+        module: any;
+        vfs: any;
+    }>;
+};

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

@@ -0,0 +1,76 @@
+/**
+ * List of currently tested virtual filesystems
+ */
+export var WASQLiteVFS;
+(function (WASQLiteVFS) {
+    WASQLiteVFS["IDBBatchAtomicVFS"] = "IDBBatchAtomicVFS";
+    WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
+    WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
+    WASQLiteVFS["OPFSWriteAheadVFS"] = "OPFSWriteAheadVFS";
+})(WASQLiteVFS || (WASQLiteVFS = {}));
+export function vfsRequiresDedicatedWorkers(vfs) {
+    return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
+}
+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) => {
+        const module = await asyncModuleFactory(options.encryptionKey);
+        const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
+        return {
+            module,
+            // @ts-expect-error The types for this static method are missing upstream
+            vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
+        };
+    },
+    [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
+        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 {
+            module,
+            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
+        };
+    },
+    [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
+        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);
+        return {
+            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/adapters/web-sql-flags.d.ts

@@ -62,6 +62,11 @@ export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
      * or a factory method that returns a worker.
      */
     worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
+    /**
+     * Use an existing port to an initialized worker.
+     * A worker will be initialized if none is provided
+     */
+    workerPort?: MessagePort;
     logger?: ILogger;
     /**
      * Where to store SQLite temporary files. Defaults to 'MEMORY'.

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

@@ -1,5 +1,4 @@
-import { AbstractStreamingSyncImplementationOptions, BaseObserver, LockOptions, PowerSyncConnectionOptions, StreamingSyncImplementation, SyncStatus, SyncStatusOptions } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { AbstractStreamingSyncImplementationOptions, BaseObserver, LockOptions, Mutex, PowerSyncConnectionOptions, StreamingSyncImplementation, SyncStatus, SyncStatusOptions } from '@powersync/common';
 export declare class SSRStreamingSyncImplementation extends BaseObserver implements StreamingSyncImplementation {
     syncMutex: Mutex;
     crudMutex: Mutex;
@@ -45,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

@@ -1,5 +1,4 @@
-import { BaseObserver, LockType, SyncStatus } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { BaseObserver, LockType, Mutex, SyncStatus } from '@powersync/common';
 export class SSRStreamingSyncImplementation extends BaseObserver {
     syncMutex;
     crudMutex;
@@ -15,7 +14,7 @@ export class SSRStreamingSyncImplementation extends BaseObserver {
     }
     obtainLock(lockOptions) {
         const mutex = lockOptions.type == LockType.CRUD ? this.crudMutex : this.syncMutex;
-        return mutex.runExclusive(lockOptions.callback);
+        return mutex.runExclusive(lockOptions.callback, lockOptions.signal);
     }
     /**
      * This is a no-op in SSR mode
@@ -62,4 +61,8 @@ export class SSRStreamingSyncImplementation extends BaseObserver {
      * No-op in SSR mode.
      */
     updateSubscriptions() { }
+    /**
+     * No-op in SSR mode.
+     */
+    markConnectionMayHaveChanged() { }
 }

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

@@ -1,9 +1,9 @@
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator.js';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation.js';
 import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags.js';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation.js';
+import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -156,24 +156,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          *    - We resolve the top-level promise after the lock has been registered with the shared worker.
          * - The client sends the params to the shared worker after locks have been registered.
          */
-        await new Promise((resolve) => {
-            // Request a random lock until this client is disposed. The name of the lock is sent to the shared worker, which
-            // will also attempt to acquire it. Since the lock is returned when the tab is closed, this allows the share worker
-            // to free resources associated with this tab.
-            // We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
-            getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
-                if (this.abortOnClose.signal.aborted) {
-                    return;
-                }
-                // Awaiting here ensures the worker is waiting for the lock
-                await this.syncManager.addLockBasedCloseSignal(lock.name);
-                // The lock has been registered, we can continue with the initialization
-                resolve();
-                await new Promise((r) => {
-                    this.abortOnClose.signal.onabort = () => r();
-                });
-            });
-        });
+        const closeSignal = await generateTabCloseSignal(this.abortOnClose.signal);
+        // Awaiting here ensures the worker is waiting for the lock
+        await this.syncManager.addLockBasedCloseSignal(closeSignal);
         const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
         const flags = { ...this.webOptions.flags, workers: undefined };
         await this.syncManager.setParams({

package/lib/src/index.d.ts

@@ -1,10 +1,7 @@
 export * from '@powersync/common';
 export * from './attachments/IndexDBFileSystemAdapter.js';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
-export * from './db/adapters/AbstractWebSQLOpenFactory.js';
-export * from './db/adapters/AsyncDatabaseConnection.js';
-export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.js';
+export { WASQLiteVFS } from './db/adapters/wa-sqlite/vfs.js';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
 export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
 export * from './db/adapters/web-sql-flags.js';

package/lib/src/index.js

@@ -1,10 +1,7 @@
 export * from '@powersync/common';
 export * from './attachments/IndexDBFileSystemAdapter.js';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
-export * from './db/adapters/AbstractWebSQLOpenFactory.js';
-export * from './db/adapters/AsyncDatabaseConnection.js';
-export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.js';
+export { WASQLiteVFS } from './db/adapters/wa-sqlite/vfs.js';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
 export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
 export * from './db/adapters/web-sql-flags.js';

package/lib/src/shared/tab_close_signal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Requests a random lock that will be released once the optional signal is aborted (or, if no signal is given, when the
+ * tab is closed).
+ *
+ * This allows sending the name of the lock to another context (e.g. a shared worker), which will also attempt to
+ * acquire it. Since the lock is returned when the tab is closed, this allows the shared worker to free resources
+ * assocatiated with this tab.
+ *
+ *  We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
+ */
+export declare function generateTabCloseSignal(abort?: AbortSignal): Promise<string>;

package/lib/src/shared/tab_close_signal.js

@@ -0,0 +1,26 @@
+import { getNavigatorLocks } from './navigator.js';
+/**
+ * Requests a random lock that will be released once the optional signal is aborted (or, if no signal is given, when the
+ * tab is closed).
+ *
+ * This allows sending the name of the lock to another context (e.g. a shared worker), which will also attempt to
+ * acquire it. Since the lock is returned when the tab is closed, this allows the shared worker to free resources
+ * assocatiated with this tab.
+ *
+ *  We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
+ */
+export function generateTabCloseSignal(abort) {
+    return new Promise((resolve, reject) => {
+        const options = { signal: abort };
+        getNavigatorLocks()
+            .request(`tab-close-signal-${crypto.randomUUID()}`, options, (lock) => {
+            resolve(lock.name);
+            return new Promise((resolve) => {
+                if (abort) {
+                    abort.addEventListener('abort', () => resolve());
+                }
+            });
+        })
+            .catch(reject);
+    });
+}

package/lib/src/worker/db/MultiDatabaseServer.d.ts

@@ -0,0 +1,17 @@
+import { ILogger } from '@powersync/common';
+import { ClientConnectionView } from '../../db/adapters/wa-sqlite/DatabaseServer.js';
+import { ResolvedWASQLiteOpenFactoryOptions, WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+/**
+ * Shared state to manage multiple database connections hosted by a worker.
+ */
+export declare class MultiDatabaseServer {
+    readonly logger: ILogger;
+    private activeDatabases;
+    constructor(logger: ILogger);
+    handleConnection(options: WorkerDBOpenerOptions): Promise<ClientConnectionView>;
+    connectToExisting(name: string, lockName: string): Promise<ClientConnectionView>;
+    openConnectionLocally(options: ResolvedWASQLiteOpenFactoryOptions, lockName?: string): Promise<ClientConnectionView>;
+    private databaseOpenAttempt;
+    closeAll(): Promise<void[]>;
+}
+export declare const isSharedWorker: boolean;

package/lib/src/worker/db/MultiDatabaseServer.js

@@ -0,0 +1,89 @@
+import * as Comlink from 'comlink';
+import { DatabaseServer } from '../../db/adapters/wa-sqlite/DatabaseServer.js';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { RawSqliteConnection } from '../../db/adapters/wa-sqlite/RawSqliteConnection.js';
+import { ConcurrentSqliteConnection } from '../../db/adapters/wa-sqlite/ConcurrentConnection.js';
+const OPEN_DB_LOCK = 'open-wasqlite-db';
+/**
+ * Shared state to manage multiple database connections hosted by a worker.
+ */
+export class MultiDatabaseServer {
+    logger;
+    activeDatabases = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async handleConnection(options) {
+        this.logger.setLevel(options.logLevel);
+        return Comlink.proxy(await this.openConnectionLocally(options, options.lockName));
+    }
+    async connectToExisting(name, lockName) {
+        return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
+            const server = this.activeDatabases.get(name);
+            if (server == null) {
+                throw new Error(`connectToExisting(${name}) failed because the worker doesn't own a database with that name.`);
+            }
+            return Comlink.proxy(await server.connect(lockName));
+        });
+    }
+    async openConnectionLocally(options, lockName) {
+        // Especially on Firefox, we're sometimes seeing "NoModificationAllowedError"s when opening OPFS databases we can
+        // work around by retrying.
+        const maxAttempts = 3;
+        let server;
+        for (let count = 0; count < maxAttempts - 1; count++) {
+            try {
+                server = await this.databaseOpenAttempt(options);
+            }
+            catch (ex) {
+                this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        // Final attempt if we haven't been able to open the server - rethrow errors if we still can't open.
+        server ??= await this.databaseOpenAttempt(options);
+        return server.connect(lockName);
+    }
+    async databaseOpenAttempt(options) {
+        return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
+            const { dbFilename } = options;
+            let server = this.activeDatabases.get(dbFilename);
+            if (server == null) {
+                // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
+                // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
+                // fine).
+                const needsNavigatorLocks = !(isSharedWorker || options.isReadOnly);
+                const connection = new RawSqliteConnection(options);
+                const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
+                // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want
+                // to do that in an exclusive lock. Note that OPEN_DB_LOCK is not enough for that, as another tab might have
+                // already created a connection (and is thus outside of OPEN_DB_LOCK) while currently writing to it.
+                const returnLease = await withSafeConcurrency.acquireMutex();
+                try {
+                    await connection.init();
+                }
+                catch (e) {
+                    returnLease();
+                    await connection.close();
+                    throw e;
+                }
+                returnLease();
+                const onClose = () => this.activeDatabases.delete(dbFilename);
+                server = new DatabaseServer({
+                    inner: withSafeConcurrency,
+                    logger: this.logger,
+                    onClose
+                });
+                this.activeDatabases.set(dbFilename, server);
+            }
+            return server;
+        });
+    }
+    closeAll() {
+        const existingDatabases = [...this.activeDatabases.values()];
+        return Promise.all(existingDatabases.map((db) => {
+            db.forceClose();
+        }));
+    }
+}
+export const isSharedWorker = 'SharedWorkerGlobalScope' in globalThis;