@powersync/web 0.0.0-dev-20251127205344 → 0.0.0-dev-20251129133952

package/dist/index.umd.js

@@ -38680,7 +38680,15 @@ class AbstractWebSQLOpenFactory {
 
 "use strict";
 __webpack_require__.r(__webpack_exports__);
-
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ConnectionClosedError: () => (/* binding */ ConnectionClosedError)
+/* harmony export */ });
+class ConnectionClosedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConnectionClosedError';
+    }
+}
 
 
 /***/ }),
@@ -38699,8 +38707,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "@powersync/common");
 /* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_powersync_common__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../..//shared/navigator */ "./lib/src/shared/navigator.js");
-/* harmony import */ var _WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./WorkerWrappedAsyncDatabaseConnection */ "./lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js");
-/* harmony import */ var _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./wa-sqlite/WASQLiteConnection */ "./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js");
+/* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
+/* harmony import */ var _WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./WorkerWrappedAsyncDatabaseConnection */ "./lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js");
+/* harmony import */ var _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./wa-sqlite/WASQLiteConnection */ "./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js");
+
 
 
 
@@ -38722,6 +38732,8 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
     _config = null;
     pendingAbortControllers;
     requiresHolds;
+    requiresReOpen;
+    databaseOpenPromise = null;
     closing;
     closed;
     constructor(options) {
@@ -38733,6 +38745,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         this.closed = false;
         this.closing = false;
         this.requiresHolds = null;
+        this.requiresReOpen = false;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -38771,16 +38784,26 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
     async init() {
         return this.initPromise;
     }
-    async _init() {
+    async openInternalDB() {
+        // Dispose any previous table change listener.
+        this._disposeTableChangeListener?.();
+        this._disposeTableChangeListener = null;
+        const isReOpen = !!this._db;
         this._db = await this.options.openConnection();
         await this._db.init();
         this._config = await this._db.getConfig();
         await this.registerOnChangeListener(this._db);
-        this.iterateListeners((cb) => cb.initialized?.());
+        if (isReOpen) {
+            this.iterateListeners((cb) => cb.databaseReOpened?.());
+        }
         /**
          * This is only required for the long-lived shared IndexedDB connections.
          */
-        this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_3__.WASQLiteVFS.IDBBatchAtomicVFS;
+        this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.WASQLiteVFS.IDBBatchAtomicVFS;
+    }
+    async _init() {
+        await this.openInternalDB();
+        this.iterateListeners((cb) => cb.initialized?.());
     }
     getConfiguration() {
         if (!this._config) {
@@ -38793,7 +38816,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         await this.initPromise;
     }
     async shareConnection() {
-        if (false == this._db instanceof _WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.WorkerWrappedAsyncDatabaseConnection) {
+        if (false == this._db instanceof _WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_3__.WorkerWrappedAsyncDatabaseConnection) {
             throw new Error(`Only worker connections can be shared`);
         }
         return this._db.shareConnection();
@@ -38847,13 +38870,13 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
     async readLock(fn, options) {
         await this.waitForInitialized();
         return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
-            timeoutMs: options?.timeoutMs
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
     async writeLock(fn, options) {
         await this.waitForInitialized();
         return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
-            timeoutMs: options?.timeoutMs
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
     async acquireLock(callback, options) {
@@ -38864,7 +38887,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         const abortController = new AbortController();
         this.pendingAbortControllers.add(abortController);
         const { timeoutMs } = options ?? {};
-        const timoutId = timeoutMs
+        const timeoutId = timeoutMs
             ? setTimeout(() => {
                 abortController.abort(`Timeout after ${timeoutMs}ms`);
                 this.pendingAbortControllers.delete(abortController);
@@ -38872,13 +38895,37 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
             : null;
         return (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_1__.getNavigatorLocks)().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, async () => {
             this.pendingAbortControllers.delete(abortController);
-            if (timoutId) {
-                clearTimeout(timoutId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
             }
-            const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
+            let holdId = null;
             try {
+                // The database is being opened in the background. Wait for it here.
+                if (this.databaseOpenPromise) {
+                    try {
+                        await this.databaseOpenPromise;
+                    }
+                    catch (ex) {
+                        // This will cause a retry of opening the database.
+                        const wrappedError = new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError('Could not open database');
+                        wrappedError.cause = ex;
+                        throw wrappedError;
+                    }
+                }
+                holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
                 return await callback();
             }
+            catch (ex) {
+                if (ex instanceof _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError) {
+                    if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
+                        // Immediately re-open the database. We need to miss as little table updates as possible.
+                        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+                            this.databaseOpenPromise = null;
+                        });
+                    }
+                }
+                throw ex;
+            }
             finally {
                 if (holdId) {
                     await this.baseDB.releaseHold(holdId);
@@ -39102,6 +39149,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! comlink */ "comlink");
 /* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(comlink__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
+
 
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
@@ -39149,12 +39198,12 @@ class WorkerWrappedAsyncDatabaseConnection {
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
-                    reject(new Error('Called operation on closed remote'));
+                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError('Called operation on closed remote'));
                     // Don't run the operation if we're going to reject
                     return;
                 }
                 function handleAbort() {
-                    reject(new Error('Remote peer closed with request in flight'));
+                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError('Remote peer closed with request in flight'));
                 }
                 function completePromise(action) {
                     controller.signal.removeEventListener('abort', handleAbort);
@@ -40172,7 +40221,19 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
                 type: undefined
             }).port;
         }
+        /**
+         * Pass along any sync status updates to this listener
+         */
+        this.clientProvider = new SharedSyncClientProvider(this.webOptions, (status) => {
+            this.updateSyncStatus(status);
+        }, options.db);
         this.syncManager = comlink__WEBPACK_IMPORTED_MODULE_0__.wrap(this.messagePort);
+        /**
+         * The sync worker will call this client provider when it needs
+         * to fetch credentials or upload data.
+         * This performs bi-directional method calling.
+         */
+        comlink__WEBPACK_IMPORTED_MODULE_0__.expose(this.clientProvider, this.messagePort);
         this.syncManager.setLogLevel(this.logger.getLevel());
         this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
         /**
@@ -40181,22 +40242,41 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
          * DB worker, but a port to the DB worker can be transferred to the
          * sync worker.
          */
-        const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
-        const flags = { ...this.webOptions.flags, workers: undefined };
-        // 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.
-        (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_1__.getNavigatorLocks)().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
-            if (!this.abortOnClose.signal.aborted) {
+        this.isInitialized = this._init();
+    }
+    async _init() {
+        /**
+         * The general flow of initialization is:
+         *  - The client requests a unique navigator lock.
+         *    - Once the lock is acquired, we register the lock with the shared worker.
+         *    - The shared worker can then request the same lock. The client has been closed if the shared worker can acquire the lock.
+         *    - Once the shared worker knows the client's lock, we can guarentee that the shared worker will detect if the client has been closed.
+         *    - This makes the client safe for the shared worker to use.
+         *    - The client side lock is held until the client is disposed.
+         *    - 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.
+            (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_1__.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();
                 });
-            }
+            });
         });
-        this.isInitialized = this.syncManager.setParams({
+        const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
+        const flags = { ...this.webOptions.flags, workers: undefined };
+        await this.syncManager.setParams({
             dbParams: this.dbAdapter.getConfiguration(),
             streamOptions: {
                 crudUploadThrottleMs,
@@ -40204,19 +40284,7 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
                 retryDelayMs,
                 flags: flags
             }
-        }, options.subscriptions);
-        /**
-         * Pass along any sync status updates to this listener
-         */
-        this.clientProvider = new SharedSyncClientProvider(this.webOptions, (status) => {
-            this.iterateListeners((l) => this.updateSyncStatus(status));
-        }, options.db);
-        /**
-         * The sync worker will call this client provider when it needs
-         * to fetch credentials or upload data.
-         * This performs bi-directional method calling.
-         */
-        comlink__WEBPACK_IMPORTED_MODULE_0__.expose(this.clientProvider, this.messagePort);
+        }, this.options.subscriptions);
     }
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -40774,7 +40842,6 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     statusListener;
     fetchCredentialsController;
     uploadDataController;
-    dbAdapter;
     syncParams;
     logger;
     lastConnectOptions;
@@ -40783,10 +40850,10 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     connectionManager;
     syncStatus;
     broadCastLogger;
+    distributedDB;
     constructor() {
         super();
         this.ports = [];
-        this.dbAdapter = null;
         this.syncParams = null;
         this.logger = (0,_powersync_common__WEBPACK_IMPORTED_MODULE_0__.createLogger)('shared-sync');
         this.lastConnectOptions = undefined;
@@ -40799,26 +40866,23 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 }
             });
         });
+        // Should be configured once we get params
+        this.distributedDB = null;
         this.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus({});
         this.broadCastLogger = new _BroadcastLogger__WEBPACK_IMPORTED_MODULE_7__.BroadcastLogger(this.ports);
         this.connectionManager = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.ConnectionManager({
             createSyncImplementation: async () => {
-                return this.portMutex.runExclusive(async () => {
-                    await this.waitForReady();
-                    if (!this.dbAdapter) {
-                        await this.openInternalDB();
+                await this.waitForReady();
+                const sync = this.generateStreamingImplementation();
+                const onDispose = sync.registerListener({
+                    statusChanged: (status) => {
+                        this.updateAllStatuses(status.toJSON());
                     }
-                    const sync = this.generateStreamingImplementation();
-                    const onDispose = sync.registerListener({
-                        statusChanged: (status) => {
-                            this.updateAllStatuses(status.toJSON());
-                        }
-                    });
-                    return {
-                        sync,
-                        onDispose
-                    };
                 });
+                return {
+                    sync,
+                    onDispose
+                };
             },
             logger: this.logger
         });
@@ -40829,6 +40893,18 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     get isConnected() {
         return this.connectionManager.syncStreamImplementation?.isConnected ?? false;
     }
+    /**
+     * Gets the last client port which we know is safe from unexpected closes.
+     */
+    get lastWrappedPort() {
+        // Find the last port which is protected from close
+        for (let i = this.ports.length - 1; i >= 0; i--) {
+            if (this.ports[i].isProtectedFromClose && !this.ports[i].isClosing) {
+                return this.ports[i];
+            }
+        }
+        return;
+    }
     async waitForStatus(status) {
         return this.withSyncImplementation(async (sync) => {
             return sync.waitForStatus(status);
@@ -40871,10 +40947,6 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             this.collectActiveSubscriptions();
             if (this.syncParams) {
                 // Cannot modify already existing sync implementation params
-                // But we can ask for a DB adapter, if required, at this point.
-                if (!this.dbAdapter) {
-                    await this.openInternalDB();
-                }
                 return;
             }
             // First time setting params
@@ -40882,13 +40954,28 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             if (params.streamOptions?.flags?.broadcastLogs) {
                 this.logger = this.broadCastLogger;
             }
+            const lockedAdapter = new _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_5__.LockedAsyncDatabaseAdapter({
+                name: params.dbParams.dbFilename,
+                openConnection: async () => {
+                    // Gets a connection from the clients when a new connection is requested.
+                    return await this.openInternalDB();
+                },
+                logger: this.logger,
+                reOpenOnConnectionClosed: true
+            });
+            this.distributedDB = lockedAdapter;
+            await lockedAdapter.init();
+            lockedAdapter.registerListener({
+                databaseReOpened: () => {
+                    // We may have missed some table updates while the database was closed.
+                    // We can poke the crud in case we missed any updates.
+                    this.connectionManager.syncStreamImplementation?.triggerCrudUpload();
+                }
+            });
             self.onerror = (event) => {
                 // Share any uncaught events on the broadcast logger
                 this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
             };
-            if (!this.dbAdapter) {
-                await this.openInternalDB();
-            }
             this.iterateListeners((l) => l.initialized?.());
         });
     }
@@ -40919,7 +41006,9 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 port,
                 clientProvider: comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(port),
                 currentSubscriptions: [],
-                closeListeners: []
+                closeListeners: [],
+                isProtectedFromClose: false,
+                isClosing: false
             };
             this.ports.push(portProvider);
             // Give the newly connected client the latest status
@@ -40935,14 +41024,16 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * clients.
      */
     async removePort(port) {
+        // Ports might be removed faster than we can process them.
+        port.isClosing = true;
         // Remove the port within a mutex context.
         // Warns if the port is not found. This should not happen in practice.
         // We return early if the port is not found.
-        const { trackedPort, shouldReconnect } = await this.portMutex.runExclusive(async () => {
+        return await this.portMutex.runExclusive(async () => {
             const index = this.ports.findIndex((p) => p == port);
             if (index < 0) {
                 this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
-                return {};
+                return () => { };
             }
             const trackedPort = this.ports[index];
             // Remove from the list of active ports
@@ -40956,40 +41047,13 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     abortController.controller.abort(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Closing pending requests after client port is removed'));
                 }
             });
-            const shouldReconnect = !!this.connectionManager.syncStreamImplementation && this.ports.length > 0;
-            /**
-             * If the current database adapter is the one that is being closed, we need to disconnect from the backend.
-             * We can disconnect in the portMutex lock. This ensures the disconnect is not affected by potential other
-             * connect operations coming from other tabs.
-             */
-            if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
-                this.logger.debug(`Disconnecting due to closed database: should reconnect: ${shouldReconnect}`);
-                this.dbAdapter = null;
-                // Unconditionally close the connection because the database it's writing to has just been closed.
-                // The connection has been closed previously, this might throw. We should be able to ignore it.
-                await this.connectionManager
-                    .disconnect()
-                    .catch((ex) => this.logger.warn('Error while disconnecting. Will attempt to reconnect.', ex));
+            // Close the worker wrapped database connection, we can't accurately rely on this connection
+            for (const closeListener of trackedPort.closeListeners) {
+                await closeListener();
             }
-            return {
-                shouldReconnect,
-                trackedPort
-            };
+            this.collectActiveSubscriptions();
+            return () => trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
         });
-        if (!trackedPort) {
-            // We could not find the port to remove
-            return () => { };
-        }
-        for (const closeListener of trackedPort.closeListeners) {
-            await closeListener();
-        }
-        if (shouldReconnect) {
-            await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions ?? {});
-        }
-        // Re-index subscriptions, the subscriptions of the removed port would no longer be considered.
-        this.collectActiveSubscriptions();
-        // Release proxy
-        return () => trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
     }
     triggerCrudUpload() {
         this.withSyncImplementation(async (sync) => {
@@ -41026,10 +41090,13 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         const syncParams = this.syncParams;
         // Create a new StreamingSyncImplementation for each connect call. This is usually done is all SDKs.
         return new _db_sync_WebStreamingSyncImplementation__WEBPACK_IMPORTED_MODULE_4__.WebStreamingSyncImplementation({
-            adapter: new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SqliteBucketStorage(this.dbAdapter, this.logger),
+            adapter: new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SqliteBucketStorage(this.distributedDB, this.logger),
             remote: new _db_sync_WebRemote__WEBPACK_IMPORTED_MODULE_3__.WebRemote({
                 invalidateCredentials: async () => {
-                    const lastPort = this.ports[this.ports.length - 1];
+                    const lastPort = this.lastWrappedPort;
+                    if (!lastPort) {
+                        throw new Error('No client port found to invalidate credentials');
+                    }
                     try {
                         this.logger.log('calling the last port client provider to invalidate credentials');
                         lastPort.clientProvider.invalidateCredentials();
@@ -41039,7 +41106,10 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     }
                 },
                 fetchCredentials: async () => {
-                    const lastPort = this.ports[this.ports.length - 1];
+                    const lastPort = this.lastWrappedPort;
+                    if (!lastPort) {
+                        throw new Error('No client port found to fetch credentials');
+                    }
                     return new Promise(async (resolve, reject) => {
                         const abortController = new AbortController();
                         this.fetchCredentialsController = {
@@ -41061,7 +41131,10 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 }
             }, this.logger),
             uploadCrud: async () => {
-                const lastPort = this.ports[this.ports.length - 1];
+                const lastPort = this.lastWrappedPort;
+                if (!lastPort) {
+                    throw new Error('No client port found to upload crud');
+                }
                 return new Promise(async (resolve, reject) => {
                     const abortController = new AbortController();
                     this.uploadDataController = {
@@ -41087,19 +41160,47 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             logger: this.logger
         });
     }
+    /**
+     * Opens a worker wrapped database connection. Using the last connected client port.
+     */
     async openInternalDB() {
-        const lastClient = this.ports[this.ports.length - 1];
-        if (!lastClient) {
-            // Should not really happen in practice
-            throw new Error(`Could not open DB connection since no client is connected.`);
-        }
-        const workerPort = await lastClient.clientProvider.getDBWorkerPort();
-        const remote = comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(workerPort);
-        const identifier = this.syncParams.dbParams.dbFilename;
-        const db = await remote(this.syncParams.dbParams);
-        const locked = new _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_5__.LockedAsyncDatabaseAdapter({
-            name: identifier,
-            openConnection: async () => {
+        while (true) {
+            try {
+                const lastClient = this.lastWrappedPort;
+                if (!lastClient) {
+                    // Should not really happen in practice
+                    throw new Error(`Could not open DB connection since no client is connected.`);
+                }
+                /**
+                 * Handle cases where the client might close while opening a connection.
+                 */
+                const abortController = new AbortController();
+                const closeListener = () => {
+                    abortController.abort();
+                };
+                const removeCloseListener = () => {
+                    const index = lastClient.closeListeners.indexOf(closeListener);
+                    if (index >= 0) {
+                        lastClient.closeListeners.splice(index, 1);
+                    }
+                };
+                lastClient.closeListeners.push(closeListener);
+                const workerPort = await withAbort(() => lastClient.clientProvider.getDBWorkerPort(), abortController.signal).catch((ex) => {
+                    removeCloseListener();
+                    throw ex;
+                });
+                const remote = comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(workerPort);
+                const identifier = this.syncParams.dbParams.dbFilename;
+                /**
+                 * The open could fail if the tab is closed while we're busy opening the database.
+                 * This operation is typically executed inside an exclusive portMutex lock.
+                 * We typically execute the closeListeners using the portMutex in a different context.
+                 * We can't rely on the closeListeners to abort the operation if the tab is closed.
+                 */
+                const db = await withAbort(() => remote(this.syncParams.dbParams), abortController.signal).finally(() => {
+                    // We can remove the close listener here since we no longer need it past this point.
+                    removeCloseListener();
+                });
                 const wrapped = new _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_6__.WorkerWrappedAsyncDatabaseConnection({
                     remote,
                     baseConnection: db,
@@ -41119,11 +41220,12 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     wrapped.markRemoteClosed();
                 });
                 return wrapped;
-            },
-            logger: this.logger
-        });
-        await locked.init();
-        this.dbAdapter = lastClient.db = locked;
+            }
+            catch (ex) {
+                this.logger.warn('Error opening internal DB', ex);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
     }
     /**
      * A method to update the all shared statuses for each
@@ -41146,6 +41248,29 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         this.updateAllStatuses(status);
     }
 }
+/**
+ * Runs the action with an abort controller.
+ */
+function withAbort(action, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Operation aborted by abort controller'));
+            return;
+        }
+        function handleAbort() {
+            signal.removeEventListener('abort', handleAbort);
+            reject(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Operation aborted by abort controller'));
+        }
+        signal.addEventListener('abort', handleAbort, { once: true });
+        function completePromise(action) {
+            signal.removeEventListener('abort', handleAbort);
+            action();
+        }
+        action()
+            .then((data) => completePromise(() => resolve(data)))
+            .catch((e) => completePromise(() => reject(e)));
+    });
+}
 
 
 /***/ }),
@@ -41502,6 +41627,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   AbstractWebPowerSyncDatabaseOpenFactory: () => (/* reexport safe */ _db_adapters_AbstractWebPowerSyncDatabaseOpenFactory__WEBPACK_IMPORTED_MODULE_2__.AbstractWebPowerSyncDatabaseOpenFactory),
 /* harmony export */   AbstractWebSQLOpenFactory: () => (/* reexport safe */ _db_adapters_AbstractWebSQLOpenFactory__WEBPACK_IMPORTED_MODULE_3__.AbstractWebSQLOpenFactory),
 /* harmony export */   AsyncWASQLiteModuleFactory: () => (/* reexport safe */ _db_adapters_wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.AsyncWASQLiteModuleFactory),
+/* harmony export */   ConnectionClosedError: () => (/* reexport safe */ _db_adapters_AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError),
 /* harmony export */   DEFAULT_CACHE_SIZE_KB: () => (/* reexport safe */ _db_adapters_web_sql_flags__WEBPACK_IMPORTED_MODULE_8__.DEFAULT_CACHE_SIZE_KB),
 /* harmony export */   DEFAULT_MODULE_FACTORIES: () => (/* reexport safe */ _db_adapters_wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.DEFAULT_MODULE_FACTORIES),
 /* harmony export */   DEFAULT_POWERSYNC_FLAGS: () => (/* reexport safe */ _db_PowerSyncDatabase__WEBPACK_IMPORTED_MODULE_9__.DEFAULT_POWERSYNC_FLAGS),