@powersync/web 1.36.0 → 1.37.0

package/dist/worker/WASQLiteDB.umd.js

@@ -3,317 +3,6 @@ var sdk_web;
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ "../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs"
-/*!*************************************************************************************!*\
-  !*** ../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs ***!
-  \*************************************************************************************/
-(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
-
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   E_ALREADY_LOCKED: () => (/* binding */ E_ALREADY_LOCKED),
-/* harmony export */   E_CANCELED: () => (/* binding */ E_CANCELED),
-/* harmony export */   E_TIMEOUT: () => (/* binding */ E_TIMEOUT),
-/* harmony export */   Mutex: () => (/* binding */ Mutex),
-/* harmony export */   Semaphore: () => (/* binding */ Semaphore),
-/* harmony export */   tryAcquire: () => (/* binding */ tryAcquire),
-/* harmony export */   withTimeout: () => (/* binding */ withTimeout)
-/* harmony export */ });
-const E_TIMEOUT = new Error('timeout while waiting for mutex to become available');
-const E_ALREADY_LOCKED = new Error('mutex already locked');
-const E_CANCELED = new Error('request for lock canceled');
-
-var __awaiter$2 = ( false) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-class Semaphore {
-    constructor(_value, _cancelError = E_CANCELED) {
-        this._value = _value;
-        this._cancelError = _cancelError;
-        this._queue = [];
-        this._weightedWaiters = [];
-    }
-    acquire(weight = 1, priority = 0) {
-        if (weight <= 0)
-            throw new Error(`invalid weight ${weight}: must be positive`);
-        return new Promise((resolve, reject) => {
-            const task = { resolve, reject, weight, priority };
-            const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
-            if (i === -1 && weight <= this._value) {
-                // Needs immediate dispatch, skip the queue
-                this._dispatchItem(task);
-            }
-            else {
-                this._queue.splice(i + 1, 0, task);
-            }
-        });
-    }
-    runExclusive(callback_1) {
-        return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
-            const [value, release] = yield this.acquire(weight, priority);
-            try {
-                return yield callback(value);
-            }
-            finally {
-                release();
-            }
-        });
-    }
-    waitForUnlock(weight = 1, priority = 0) {
-        if (weight <= 0)
-            throw new Error(`invalid weight ${weight}: must be positive`);
-        if (this._couldLockImmediately(weight, priority)) {
-            return Promise.resolve();
-        }
-        else {
-            return new Promise((resolve) => {
-                if (!this._weightedWaiters[weight - 1])
-                    this._weightedWaiters[weight - 1] = [];
-                insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });
-            });
-        }
-    }
-    isLocked() {
-        return this._value <= 0;
-    }
-    getValue() {
-        return this._value;
-    }
-    setValue(value) {
-        this._value = value;
-        this._dispatchQueue();
-    }
-    release(weight = 1) {
-        if (weight <= 0)
-            throw new Error(`invalid weight ${weight}: must be positive`);
-        this._value += weight;
-        this._dispatchQueue();
-    }
-    cancel() {
-        this._queue.forEach((entry) => entry.reject(this._cancelError));
-        this._queue = [];
-    }
-    _dispatchQueue() {
-        this._drainUnlockWaiters();
-        while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
-            this._dispatchItem(this._queue.shift());
-            this._drainUnlockWaiters();
-        }
-    }
-    _dispatchItem(item) {
-        const previousValue = this._value;
-        this._value -= item.weight;
-        item.resolve([previousValue, this._newReleaser(item.weight)]);
-    }
-    _newReleaser(weight) {
-        let called = false;
-        return () => {
-            if (called)
-                return;
-            called = true;
-            this.release(weight);
-        };
-    }
-    _drainUnlockWaiters() {
-        if (this._queue.length === 0) {
-            for (let weight = this._value; weight > 0; weight--) {
-                const waiters = this._weightedWaiters[weight - 1];
-                if (!waiters)
-                    continue;
-                waiters.forEach((waiter) => waiter.resolve());
-                this._weightedWaiters[weight - 1] = [];
-            }
-        }
-        else {
-            const queuedPriority = this._queue[0].priority;
-            for (let weight = this._value; weight > 0; weight--) {
-                const waiters = this._weightedWaiters[weight - 1];
-                if (!waiters)
-                    continue;
-                const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
-                (i === -1 ? waiters : waiters.splice(0, i))
-                    .forEach((waiter => waiter.resolve()));
-            }
-        }
-    }
-    _couldLockImmediately(weight, priority) {
-        return (this._queue.length === 0 || this._queue[0].priority < priority) &&
-            weight <= this._value;
-    }
-}
-function insertSorted(a, v) {
-    const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
-    a.splice(i + 1, 0, v);
-}
-function findIndexFromEnd(a, predicate) {
-    for (let i = a.length - 1; i >= 0; i--) {
-        if (predicate(a[i])) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-var __awaiter$1 = ( false) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-class Mutex {
-    constructor(cancelError) {
-        this._semaphore = new Semaphore(1, cancelError);
-    }
-    acquire() {
-        return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
-            const [, releaser] = yield this._semaphore.acquire(1, priority);
-            return releaser;
-        });
-    }
-    runExclusive(callback, priority = 0) {
-        return this._semaphore.runExclusive(() => callback(), 1, priority);
-    }
-    isLocked() {
-        return this._semaphore.isLocked();
-    }
-    waitForUnlock(priority = 0) {
-        return this._semaphore.waitForUnlock(1, priority);
-    }
-    release() {
-        if (this._semaphore.isLocked())
-            this._semaphore.release();
-    }
-    cancel() {
-        return this._semaphore.cancel();
-    }
-}
-
-var __awaiter = ( false) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-function withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {
-    return {
-        acquire: (weightOrPriority, priority) => {
-            let weight;
-            if (isSemaphore(sync)) {
-                weight = weightOrPriority;
-            }
-            else {
-                weight = undefined;
-                priority = weightOrPriority;
-            }
-            if (weight !== undefined && weight <= 0) {
-                throw new Error(`invalid weight ${weight}: must be positive`);
-            }
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                let isTimeout = false;
-                const handle = setTimeout(() => {
-                    isTimeout = true;
-                    reject(timeoutError);
-                }, timeout);
-                try {
-                    const ticket = yield (isSemaphore(sync)
-                        ? sync.acquire(weight, priority)
-                        : sync.acquire(priority));
-                    if (isTimeout) {
-                        const release = Array.isArray(ticket) ? ticket[1] : ticket;
-                        release();
-                    }
-                    else {
-                        clearTimeout(handle);
-                        resolve(ticket);
-                    }
-                }
-                catch (e) {
-                    if (!isTimeout) {
-                        clearTimeout(handle);
-                        reject(e);
-                    }
-                }
-            }));
-        },
-        runExclusive(callback, weight, priority) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let release = () => undefined;
-                try {
-                    const ticket = yield this.acquire(weight, priority);
-                    if (Array.isArray(ticket)) {
-                        release = ticket[1];
-                        return yield callback(ticket[0]);
-                    }
-                    else {
-                        release = ticket;
-                        return yield callback();
-                    }
-                }
-                finally {
-                    release();
-                }
-            });
-        },
-        release(weight) {
-            sync.release(weight);
-        },
-        cancel() {
-            return sync.cancel();
-        },
-        waitForUnlock: (weightOrPriority, priority) => {
-            let weight;
-            if (isSemaphore(sync)) {
-                weight = weightOrPriority;
-            }
-            else {
-                weight = undefined;
-                priority = weightOrPriority;
-            }
-            if (weight !== undefined && weight <= 0) {
-                throw new Error(`invalid weight ${weight}: must be positive`);
-            }
-            return new Promise((resolve, reject) => {
-                const handle = setTimeout(() => reject(timeoutError), timeout);
-                (isSemaphore(sync)
-                    ? sync.waitForUnlock(weight, priority)
-                    : sync.waitForUnlock(priority)).then(() => {
-                    clearTimeout(handle);
-                    resolve();
-                });
-            });
-        },
-        isLocked: () => sync.isLocked(),
-        getValue: () => sync.getValue(),
-        setValue: (value) => sync.setValue(value),
-    };
-}
-function isSemaphore(sync) {
-    return sync.getValue !== undefined;
-}
-
-// eslint-disable-next-lisne @typescript-eslint/explicit-module-boundary-types
-function tryAcquire(sync, alreadyAcquiredError = E_ALREADY_LOCKED) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return withTimeout(sync, 0, alreadyAcquiredError);
-}
-
-
-
-
-/***/ },
-
 /***/ "../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs"
 /*!****************************************************************************************!*\
   !*** ../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs ***!
@@ -2409,10 +2098,470 @@ const SQLITE_PREPARE_NO_VTAB = 0x04;
 
 /***/ },
 
-/***/ "./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js"
-/*!*************************************************************!*\
-  !*** ./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js ***!
-  \*************************************************************/
+/***/ "./lib/src/db/adapters/wa-sqlite/ConcurrentConnection.js"
+/*!***************************************************************!*\
+  !*** ./lib/src/db/adapters/wa-sqlite/ConcurrentConnection.js ***!
+  \***************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ConcurrentSqliteConnection: () => (/* binding */ ConcurrentSqliteConnection),
+/* harmony export */   ConnectionLeaseToken: () => (/* binding */ ConnectionLeaseToken)
+/* harmony export */ });
+/* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
+
+/**
+ * A wrapper around a {@link RawSqliteConnection} allowing multiple tabs to access it.
+ *
+ * To allow potentially concurrent accesses from different clients, this requires a local mutex implementation here.
+ *
+ * Note that instances of this class are not safe to proxy across context boundaries with comlink! We need to be able to
+ * rely on mutexes being returned reliably, so additional checks to detect say a client tab closing are required to
+ * avoid deadlocks.
+ */
+class ConcurrentSqliteConnection {
+    inner;
+    /**
+     * An outer mutex ensuring at most one {@link ConnectionLeaseToken} can exist for this connection at a time.
+     *
+     * If null, we'll use navigator locks instead.
+     */
+    leaseMutex;
+    /**
+     * @param needsNavigatorLocks Whether access to the database needs an additional navigator lock guard.
+     *
+     * While {@link ConcurrentSqliteConnection} prevents concurrent access to a database _connection_, it's possible we
+     * might have multiple connections to the same physical database (e.g. if multiple tabs use dedicated workers).
+     * In those setups, we use navigator locks instead of an internal mutex to guard access..
+     */
+    constructor(inner, needsNavigatorLocks) {
+        this.inner = inner;
+        this.leaseMutex = needsNavigatorLocks ? null : new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.Mutex();
+    }
+    get options() {
+        return this.inner.options;
+    }
+    acquireMutex(abort) {
+        if (this.leaseMutex) {
+            return this.leaseMutex.acquire(abort);
+        }
+        return new Promise((resolve, reject) => {
+            const options = { signal: abort };
+            navigator.locks
+                .request(`db-lock-${this.options.dbFilename}`, options, (_) => {
+                return new Promise((returnLock) => {
+                    return resolve(() => {
+                        returnLock();
+                    });
+                });
+            })
+                .catch(reject);
+        });
+    }
+    // Unsafe, unguarded access to the SQLite connection.
+    unsafeUseInner() {
+        return this.inner;
+    }
+    /**
+     * @returns A {@link ConnectionLeaseToken}. Until that token is returned, no other client can use the database.
+     */
+    async acquireConnection(abort) {
+        const returnMutex = await this.acquireMutex(abort);
+        const token = new ConnectionLeaseToken(returnMutex, this.inner);
+        try {
+            // Assert that the inner connection is initialized at this point, fail early if it's not.
+            this.inner.requireSqlite();
+            // If a previous client was interrupted in the middle of a transaction AND this is a shared worker, it's possible
+            // for the connection to still be in a transaction. To avoid inconsistent state, we roll back connection leases
+            // that haven't been comitted.
+            if (!this.inner.isAutoCommit()) {
+                await this.inner.executeRaw('ROLLBACK');
+            }
+        }
+        catch (e) {
+            returnMutex();
+            throw e;
+        }
+        return token;
+    }
+    async close() {
+        const returnMutex = await this.acquireMutex();
+        try {
+            await this.inner.close();
+        }
+        finally {
+            returnMutex();
+        }
+    }
+}
+/**
+ * An instance representing temporary exclusive access to a {@link ConcurrentSqliteConnection}.
+ */
+class ConnectionLeaseToken {
+    returnMutex;
+    connection;
+    /** Ensures that the client with access to this token can't run statements concurrently. */
+    useMutex = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.Mutex();
+    closed = false;
+    constructor(returnMutex, connection) {
+        this.returnMutex = returnMutex;
+        this.connection = connection;
+    }
+    /**
+     * Returns this lease, allowing another client to use the database connection.
+     */
+    async returnLease() {
+        await this.useMutex.runExclusive(async () => {
+            if (!this.closed) {
+                this.closed = true;
+                this.returnMutex();
+            }
+        });
+    }
+    /**
+     * This should only be used internally, since the callback must not use the raw connection after resolving.
+     */
+    async use(callback) {
+        return await this.useMutex.runExclusive(async () => {
+            if (this.closed) {
+                throw new Error('lease token has already been closed');
+            }
+            return await callback(this.connection);
+        });
+    }
+}
+
+
+/***/ },
+
+/***/ "./lib/src/db/adapters/wa-sqlite/DatabaseServer.js"
+/*!*********************************************************!*\
+  !*** ./lib/src/db/adapters/wa-sqlite/DatabaseServer.js ***!
+  \*********************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DatabaseServer: () => (/* binding */ DatabaseServer)
+/* harmony export */ });
+/**
+ * Access to a WA-sqlite connection that can be shared with multiple clients sending queries over an RPC protocol built
+ * with the Comlink package.
+ */
+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();
+    }
+}
+
+
+/***/ },
+
+/***/ "./lib/src/db/adapters/wa-sqlite/RawSqliteConnection.js"
+/*!**************************************************************!*\
+  !*** ./lib/src/db/adapters/wa-sqlite/RawSqliteConnection.js ***!
+  \**************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   RawSqliteConnection: () => (/* binding */ RawSqliteConnection)
+/* harmony export */ });
+/* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
+/* harmony import */ var _vfs_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./vfs.js */ "./lib/src/db/adapters/wa-sqlite/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.
+ */
+class RawSqliteConnection {
+    options;
+    _sqliteAPI = null;
+    /**
+     * The `sqlite3*` connection pointer.
+     */
+    db = 0;
+    _moduleFactory;
+    constructor(options) {
+        this.options = options;
+        this._moduleFactory = _vfs_js__WEBPACK_IMPORTED_MODULE_1__.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 = (0,_journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory)(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)) === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.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;
+        }
+    }
+}
+
+
+/***/ },
+
+/***/ "./lib/src/db/adapters/wa-sqlite/vfs.js"
+/*!**********************************************!*\
+  !*** ./lib/src/db/adapters/wa-sqlite/vfs.js ***!
+  \**********************************************/
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
 __webpack_require__.r(__webpack_exports__);
@@ -2423,14 +2572,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   MultiCipherSyncWASQLiteModuleFactory: () => (/* binding */ MultiCipherSyncWASQLiteModuleFactory),
 /* harmony export */   SyncWASQLiteModuleFactory: () => (/* binding */ SyncWASQLiteModuleFactory),
 /* harmony export */   WASQLiteVFS: () => (/* binding */ WASQLiteVFS),
-/* harmony export */   WASqliteConnection: () => (/* binding */ WASqliteConnection)
+/* harmony export */   vfsRequiresDedicatedWorkers: () => (/* binding */ vfsRequiresDedicatedWorkers)
 /* harmony export */ });
-/* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
-/* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
-/* harmony import */ var async_mutex__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! async-mutex */ "../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs");
-
-
-
 /**
  * List of currently tested virtual filesystems
  */
@@ -2440,6 +2583,9 @@ var WASQLiteVFS;
     WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
     WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
 })(WASQLiteVFS || (WASQLiteVFS = {}));
+function vfsRequiresDedicatedWorkers(vfs) {
+    return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
+}
 /**
  * @internal
  */
@@ -2519,316 +2665,6 @@ const DEFAULT_MODULE_FACTORIES = {
         };
     }
 };
-/**
- * @internal
- * WA-SQLite connection which directly interfaces with WA-SQLite.
- * This is usually instantiated inside a worker.
- */
-class WASqliteConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_1__.BaseObserver {
-    options;
-    _sqliteAPI = null;
-    _dbP = null;
-    _moduleFactory;
-    updatedTables;
-    updateTimer;
-    statementMutex;
-    broadcastChannel;
-    /**
-     * Unique id for this specific connection. This is used to prevent broadcast table change
-     * notification loops.
-     */
-    connectionId;
-    _holdCounter;
-    _holdId;
-    constructor(options) {
-        super();
-        this.options = options;
-        this.updatedTables = new Set();
-        this.updateTimer = null;
-        this.broadcastChannel = null;
-        this.connectionId = new Date().valueOf() + Math.random();
-        this.statementMutex = new async_mutex__WEBPACK_IMPORTED_MODULE_2__.Mutex();
-        this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
-        this._holdCounter = 0;
-        this._holdId = null;
-    }
-    /**
-     * Gets the id for the current hold.
-     * This can be used to check for invalid states.
-     */
-    get currentHoldId() {
-        return this._holdId;
-    }
-    get sqliteAPI() {
-        if (!this._sqliteAPI) {
-            throw new Error(`Initialization has not completed`);
-        }
-        return this._sqliteAPI;
-    }
-    get dbP() {
-        if (!this._dbP) {
-            throw new Error(`Initialization has not completed`);
-        }
-        return this._dbP;
-    }
-    /**
-     * Checks if the database connection is in autocommit mode.
-     * @returns true if in autocommit mode, false if in a transaction
-     */
-    async isAutoCommit() {
-        return this.sqliteAPI.get_autocommit(this.dbP) != 0;
-    }
-    async markHold() {
-        const previousHoldId = this._holdId;
-        this._holdId = `${++this._holdCounter}`;
-        if (previousHoldId) {
-            await this.iterateAsyncListeners(async (cb) => cb.holdOverwritten?.(previousHoldId));
-        }
-        return this._holdId;
-    }
-    async releaseHold(holdId) {
-        if (holdId != this._holdId) {
-            throw new Error(`Invalid hold state, expected ${this._holdId} but got ${holdId}`);
-        }
-        this._holdId = null;
-    }
-    async openDB() {
-        this._dbP = await this.sqliteAPI.open_v2(this.options.dbFilename);
-        return this._dbP;
-    }
-    async executeEncryptionPragma() {
-        if (this.options.encryptionKey) {
-            await this.executeSingleStatement(`PRAGMA key = "${this.options.encryptionKey}"`);
-        }
-        return;
-    }
-    async openSQLiteAPI() {
-        const { module, vfs } = await this._moduleFactory({
-            dbFileName: this.options.dbFilename,
-            encryptionKey: this.options.encryptionKey
-        });
-        const sqlite3 = _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory(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;
-    }
-    registerBroadcastListeners() {
-        this.broadcastChannel = new BroadcastChannel(`${this.options.dbFilename}-table-updates`);
-        this.broadcastChannel.addEventListener('message', (event) => {
-            const data = event.data;
-            if (this.connectionId == data.connectionId) {
-                // Ignore messages from the same connection
-                return;
-            }
-            // Ensuring that we don't rebroadcast the same message
-            this.queueTableUpdate(data.changedTables, false);
-        });
-    }
-    queueTableUpdate(tableNames, shouldBroadcast = true) {
-        tableNames.forEach((tableName) => this.updatedTables.add(tableName));
-        if (this.updateTimer == null) {
-            this.updateTimer = setTimeout(() => this.fireUpdates(shouldBroadcast), 0);
-        }
-    }
-    async init() {
-        this._sqliteAPI = await this.openSQLiteAPI();
-        await this.openDB();
-        this.registerBroadcastListeners();
-        await this.executeSingleStatement(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
-        await this.executeEncryptionPragma();
-        await this.executeSingleStatement(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
-        this.sqliteAPI.update_hook(this.dbP, (updateType, dbName, tableName) => {
-            if (!tableName) {
-                return;
-            }
-            const changedTables = new Set([tableName]);
-            this.queueTableUpdate(changedTables);
-        });
-    }
-    async getConfig() {
-        return this.options;
-    }
-    fireUpdates(shouldBroadcast = true) {
-        this.updateTimer = null;
-        const event = { tables: [...this.updatedTables], groupedUpdates: {}, rawUpdates: [] };
-        // Share to other connections
-        if (shouldBroadcast) {
-            this.broadcastChannel.postMessage({
-                changedTables: this.updatedTables,
-                connectionId: this.connectionId
-            });
-        }
-        this.updatedTables.clear();
-        this.iterateListeners((cb) => cb.tablesUpdated?.(event));
-    }
-    /**
-     * This executes SQL statements in a batch.
-     */
-    async executeBatch(sql, bindings) {
-        return this.acquireExecuteLock(async () => {
-            let affectedRows = 0;
-            try {
-                await this.executeSingleStatement('BEGIN TRANSACTION');
-                const wrappedBindings = bindings ? bindings : [];
-                for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
-                    if (stmt === null) {
-                        return {
-                            rowsAffected: 0,
-                            rows: { _array: [], length: 0 }
-                        };
-                    }
-                    //Prepare statement once
-                    for (const binding of wrappedBindings) {
-                        // TODO not sure why this is needed currently, but booleans break
-                        for (let i = 0; i < binding.length; i++) {
-                            const b = binding[i];
-                            if (typeof b == 'boolean') {
-                                binding[i] = b ? 1 : 0;
-                            }
-                        }
-                        if (bindings) {
-                            this.sqliteAPI.bind_collection(stmt, binding);
-                        }
-                        const result = await this.sqliteAPI.step(stmt);
-                        if (result === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE) {
-                            //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
-                            affectedRows += this.sqliteAPI.changes(this.dbP);
-                        }
-                        this.sqliteAPI.reset(stmt);
-                    }
-                }
-                await this.executeSingleStatement('COMMIT');
-            }
-            catch (err) {
-                await this.executeSingleStatement('ROLLBACK');
-                return {
-                    rowsAffected: 0,
-                    rows: { _array: [], length: 0 }
-                };
-            }
-            const result = {
-                rowsAffected: affectedRows,
-                rows: { _array: [], length: 0 }
-            };
-            return result;
-        });
-    }
-    /**
-     * This executes single SQL statements inside a requested lock.
-     */
-    async execute(sql, bindings) {
-        // Running multiple statements on the same connection concurrently should not be allowed
-        return this.acquireExecuteLock(async () => {
-            return this.executeSingleStatement(sql, bindings);
-        });
-    }
-    async executeRaw(sql, bindings) {
-        return this.acquireExecuteLock(async () => {
-            return this.executeSingleStatementRaw(sql, bindings);
-        });
-    }
-    async close() {
-        this.broadcastChannel?.close();
-        await this.acquireExecuteLock(async () => {
-            /**
-             * Running the close operation inside the same execute mutex prevents errors like:
-             * ```
-             * unable to close due to unfinalized statements or unfinished backups
-             * ```
-             */
-            await this.sqliteAPI.close(this.dbP);
-        });
-    }
-    async registerOnTableChange(callback) {
-        return this.registerListener({
-            tablesUpdated: (event) => callback(event)
-        });
-    }
-    /**
-     * This requests a lock for executing statements.
-     * Should only be used internally.
-     */
-    acquireExecuteLock = (callback) => {
-        return this.statementMutex.runExclusive(callback);
-    };
-    /**
-     * This executes a single statement using SQLite3.
-     */
-    async executeSingleStatement(sql, bindings) {
-        const results = await this._execute(sql, bindings);
-        const rows = [];
-        for (const resultSet of results) {
-            for (const row of resultSet.rows) {
-                const outRow = {};
-                resultSet.columns.forEach((key, index) => {
-                    outRow[key] = row[index];
-                });
-                rows.push(outRow);
-            }
-        }
-        const result = {
-            insertId: this.sqliteAPI.last_insert_id(this.dbP),
-            rowsAffected: this.sqliteAPI.changes(this.dbP),
-            rows: {
-                _array: rows,
-                length: rows.length
-            }
-        };
-        return result;
-    }
-    /**
-     * This executes a single statement using SQLite3 and returns the results as an array of arrays.
-     */
-    async executeSingleStatementRaw(sql, bindings) {
-        const results = await this._execute(sql, bindings);
-        return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
-    }
-    async _execute(sql, bindings) {
-        const results = [];
-        for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
-            let columns;
-            const wrappedBindings = bindings ? [bindings] : [[]];
-            for (const binding of wrappedBindings) {
-                // TODO not sure why this is needed currently, but booleans break
-                binding.forEach((b, index, arr) => {
-                    if (typeof b == 'boolean') {
-                        arr[index] = b ? 1 : 0;
-                    }
-                });
-                this.sqliteAPI.reset(stmt);
-                if (bindings) {
-                    this.sqliteAPI.bind_collection(stmt, binding);
-                }
-                const rows = [];
-                while ((await this.sqliteAPI.step(stmt)) === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW) {
-                    const row = this.sqliteAPI.row(stmt);
-                    rows.push(row);
-                }
-                columns = columns ?? this.sqliteAPI.column_names(stmt);
-                if (columns.length) {
-                    results.push({ columns, rows });
-                }
-            }
-            // When binding parameters, only a single statement is executed.
-            if (bindings) {
-                break;
-            }
-        }
-        return results;
-    }
-}
 
 
 /***/ },
@@ -2853,134 +2689,108 @@ const getNavigatorLocks = () => {
 
 /***/ },
 
-/***/ "./lib/src/worker/db/SharedWASQLiteConnection.js"
-/*!*******************************************************!*\
-  !*** ./lib/src/worker/db/SharedWASQLiteConnection.js ***!
-  \*******************************************************/
+/***/ "./lib/src/worker/db/MultiDatabaseServer.js"
+/*!**************************************************!*\
+  !*** ./lib/src/worker/db/MultiDatabaseServer.js ***!
+  \**************************************************/
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   SharedWASQLiteConnection: () => (/* binding */ SharedWASQLiteConnection)
+/* harmony export */   MultiDatabaseServer: () => (/* binding */ MultiDatabaseServer),
+/* harmony export */   isSharedWorker: () => (/* binding */ isSharedWorker)
 /* harmony export */ });
-class SharedWASQLiteConnection {
-    options;
-    isClosing;
-    // Keeps track if this current hold if the shared connection has a hold
-    activeHoldId;
-    constructor(options) {
-        this.options = options;
-        // Add this client ID to the set of known clients
-        this.clientIds.add(options.clientId);
-        this.isClosing = false;
-        this.activeHoldId = null;
-    }
-    get logger() {
-        return this.options.logger;
-    }
-    get dbEntry() {
-        return this.options.dbMap.get(this.options.dbFilename);
-    }
-    get connection() {
-        return this.dbEntry.db;
-    }
-    get clientIds() {
-        return this.dbEntry.clientIds;
-    }
-    async init() {
-        // No-op since the connection is already initialized when it was created
-    }
-    async markHold() {
-        this.activeHoldId = await this.connection.markHold();
-        return this.activeHoldId;
-    }
-    async releaseHold(id) {
-        try {
-            await this.connection.releaseHold(id);
-        }
-        finally {
-            this.activeHoldId = null;
-        }
-    }
-    async isAutoCommit() {
-        return this.connection.isAutoCommit();
-    }
-    /**
-     * Handles closing of a shared connection.
-     * The connection is only closed if there are no active clients using it.
-     */
-    async close() {
-        // This prevents further statements on this connection from being executed
-        this.isClosing = true;
-        const { clientIds, logger } = this;
-        const { clientId, dbFilename, dbMap } = this.options;
-        logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
-        clientIds.delete(clientId);
-        if (this.activeHoldId) {
-            // We can't cleanup here since we're not in a lock context.
-            // The cleanup will occur once a new hold is acquired.
-            this.logger.info(`Hold ${this.activeHoldId} was still active when the connection was closed. Cleanup will occur once a new hold is acquired.`);
-        }
-        if (clientIds.size == 0) {
-            logger.debug(`Closing connection to ${this.options}.`);
-            const connection = this.connection;
-            dbMap.delete(dbFilename);
-            await connection.close();
-            return;
-        }
-        logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
-        return;
-    }
-    async withClosing(action) {
-        if (this.isClosing) {
-            throw new Error('Connection is closing');
-        }
-        return action();
-    }
-    async execute(sql, params) {
-        return this.withClosing(() => this.connection.execute(sql, params));
-    }
-    async executeRaw(sql, params) {
-        return this.withClosing(() => this.connection.executeRaw(sql, params));
-    }
-    executeBatch(sql, params) {
-        return this.withClosing(() => this.connection.executeBatch(sql, params));
-    }
-    registerOnTableChange(callback) {
-        return this.connection.registerOnTableChange(callback);
-    }
-    getConfig() {
-        return this.connection.getConfig();
-    }
-}
-
+/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! comlink */ "../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs");
+/* harmony import */ var _db_adapters_wa_sqlite_DatabaseServer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/DatabaseServer.js */ "./lib/src/db/adapters/wa-sqlite/DatabaseServer.js");
+/* harmony import */ var _shared_navigator_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../shared/navigator.js */ "./lib/src/shared/navigator.js");
+/* harmony import */ var _db_adapters_wa_sqlite_RawSqliteConnection_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/RawSqliteConnection.js */ "./lib/src/db/adapters/wa-sqlite/RawSqliteConnection.js");
+/* harmony import */ var _db_adapters_wa_sqlite_ConcurrentConnection_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/ConcurrentConnection.js */ "./lib/src/db/adapters/wa-sqlite/ConcurrentConnection.js");
 
-/***/ },
 
-/***/ "./lib/src/worker/db/WorkerWASQLiteConnection.js"
-/*!*******************************************************!*\
-  !*** ./lib/src/worker/db/WorkerWASQLiteConnection.js ***!
-  \*******************************************************/
-(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   WorkerWASQLiteConnection: () => (/* binding */ WorkerWASQLiteConnection)
-/* harmony export */ });
-/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! comlink */ "../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs");
-/* harmony import */ var _db_adapters_wa_sqlite_WASQLiteConnection_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/WASQLiteConnection.js */ "./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js");
 
 
+const OPEN_DB_LOCK = 'open-wasqlite-db';
 /**
- * A Small proxy wrapper around the WASqliteConnection.
- * This ensures that certain return types are properly proxied.
+ * Shared state to manage multiple database connections hosted by a worker.
  */
-class WorkerWASQLiteConnection extends _db_adapters_wa_sqlite_WASQLiteConnection_js__WEBPACK_IMPORTED_MODULE_1__.WASqliteConnection {
-    async registerOnTableChange(callback) {
-        // Proxy the callback remove function
-        return comlink__WEBPACK_IMPORTED_MODULE_0__.proxy(await super.registerOnTableChange(callback));
+class MultiDatabaseServer {
+    logger;
+    activeDatabases = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async handleConnection(options) {
+        this.logger.setLevel(options.logLevel);
+        return comlink__WEBPACK_IMPORTED_MODULE_0__.proxy(await this.openConnectionLocally(options, options.lockName));
+    }
+    async connectToExisting(name, lockName) {
+        return (0,_shared_navigator_js__WEBPACK_IMPORTED_MODULE_2__.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__WEBPACK_IMPORTED_MODULE_0__.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 (0,_shared_navigator_js__WEBPACK_IMPORTED_MODULE_2__.getNavigatorLocks)().request(OPEN_DB_LOCK, async () => {
+            const { dbFilename } = options;
+            let server = this.activeDatabases.get(dbFilename);
+            if (server == null) {
+                const needsNavigatorLocks = !isSharedWorker;
+                const connection = new _db_adapters_wa_sqlite_RawSqliteConnection_js__WEBPACK_IMPORTED_MODULE_3__.RawSqliteConnection(options);
+                const withSafeConcurrency = new _db_adapters_wa_sqlite_ConcurrentConnection_js__WEBPACK_IMPORTED_MODULE_4__.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 _db_adapters_wa_sqlite_DatabaseServer_js__WEBPACK_IMPORTED_MODULE_1__.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();
+        }));
     }
 }
+const isSharedWorker = 'SharedWorkerGlobalScope' in globalThis;
 
 
 /***/ },
@@ -3052,6 +2862,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   MAX_AMOUNT_OF_COLUMNS: () => (/* binding */ MAX_AMOUNT_OF_COLUMNS),
 /* harmony export */   MAX_OP_ID: () => (/* binding */ MAX_OP_ID),
 /* harmony export */   MEMORY_TRIGGER_CLAIM_MANAGER: () => (/* binding */ MEMORY_TRIGGER_CLAIM_MANAGER),
+/* harmony export */   Mutex: () => (/* binding */ Mutex),
 /* harmony export */   OnChangeQueryProcessor: () => (/* binding */ OnChangeQueryProcessor),
 /* harmony export */   OpType: () => (/* binding */ OpType),
 /* harmony export */   OpTypeEnum: () => (/* binding */ OpTypeEnum),
@@ -3093,15 +2904,12 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   isStreamingSyncCheckpointPartiallyComplete: () => (/* binding */ isStreamingSyncCheckpointPartiallyComplete),
 /* harmony export */   isStreamingSyncData: () => (/* binding */ isStreamingSyncData),
 /* harmony export */   isSyncNewCheckpointRequest: () => (/* binding */ isSyncNewCheckpointRequest),
-/* harmony export */   mutexRunExclusive: () => (/* binding */ mutexRunExclusive),
 /* harmony export */   parseQuery: () => (/* binding */ parseQuery),
 /* harmony export */   runOnSchemaChange: () => (/* binding */ runOnSchemaChange),
 /* harmony export */   sanitizeSQL: () => (/* binding */ sanitizeSQL),
-/* harmony export */   sanitizeUUID: () => (/* binding */ sanitizeUUID)
+/* harmony export */   sanitizeUUID: () => (/* binding */ sanitizeUUID),
+/* harmony export */   timeoutSignal: () => (/* binding */ timeoutSignal)
 /* harmony export */ });
-/* harmony import */ var async_mutex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! async-mutex */ "../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs");
-
-
 // https://www.sqlite.org/lang_expr.html#castexpr
 var ColumnType;
 (function (ColumnType) {
@@ -3759,7 +3567,7 @@ class SyncingService {
                     updatedAttachments.push(downloaded);
                     break;
                 case AttachmentState.QUEUED_DELETE:
-                    const deleted = await this.deleteAttachment(attachment);
+                    const deleted = await this.deleteAttachment(attachment, context);
                     updatedAttachments.push(deleted);
                     break;
             }
@@ -3837,17 +3645,16 @@ class SyncingService {
      * On failure, defers to error handler or archives.
      *
      * @param attachment - The attachment record to delete
+     * @param context - Attachment context for database operations
      * @returns Updated attachment record
      */
-    async deleteAttachment(attachment) {
+    async deleteAttachment(attachment, context) {
         try {
             await this.remoteStorage.deleteFile(attachment);
             if (attachment.localUri) {
                 await this.localStorage.deleteFile(attachment.localUri);
             }
-            await this.attachmentService.withContext(async (ctx) => {
-                await ctx.deleteAttachment(attachment.id);
-            });
+            await context.deleteAttachment(attachment.id);
             return {
                 ...attachment,
                 state: AttachmentState.ARCHIVED
@@ -3885,32 +3692,108 @@ class SyncingService {
 }
 
 /**
- * Wrapper for async-mutex runExclusive, which allows for a timeout on each exclusive lock.
+ * An asynchronous mutex implementation.
+ *
+ * @internal This class is meant to be used in PowerSync SDKs only, and is not part of the public API.
  */
-async function mutexRunExclusive(mutex, callback, options) {
-    return new Promise((resolve, reject) => {
-        const timeout = options?.timeoutMs;
-        let timedOut = false;
-        const timeoutId = timeout
-            ? setTimeout(() => {
-                timedOut = true;
-                reject(new Error('Timeout waiting for lock'));
-            }, timeout)
-            : undefined;
-        mutex.runExclusive(async () => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
+class Mutex {
+    inCriticalSection = false;
+    // Linked list of waiters. We don't expect the wait list to become particularly large, and this allows removing
+    // aborted waiters from the middle of the list efficiently.
+    firstWaiter;
+    lastWaiter;
+    addWaiter(onAcquire) {
+        const node = {
+            isActive: true,
+            onAcquire,
+            prev: this.lastWaiter
+        };
+        if (this.lastWaiter) {
+            this.lastWaiter.next = node;
+            this.lastWaiter = node;
+        }
+        else {
+            // First waiter
+            this.lastWaiter = this.firstWaiter = node;
+        }
+        return node;
+    }
+    deactivateWaiter(waiter) {
+        const { prev, next } = waiter;
+        waiter.isActive = false;
+        if (prev)
+            prev.next = next;
+        if (next)
+            next.prev = prev;
+        if (waiter == this.firstWaiter)
+            this.firstWaiter = next;
+        if (waiter == this.lastWaiter)
+            this.lastWaiter = prev;
+    }
+    acquire(abort) {
+        return new Promise((resolve, reject) => {
+            function rejectAborted() {
+                reject(abort?.reason ?? new Error('Mutex acquire aborted'));
             }
-            if (timedOut)
-                return;
-            try {
-                resolve(await callback());
+            if (abort?.aborted) {
+                return rejectAborted();
             }
-            catch (ex) {
-                reject(ex);
+            let holdsMutex = false;
+            const markCompleted = () => {
+                if (!holdsMutex)
+                    return;
+                holdsMutex = false;
+                const waiter = this.firstWaiter;
+                if (waiter) {
+                    this.deactivateWaiter(waiter);
+                    // Still in critical section, but owned by next waiter now.
+                    waiter.onAcquire();
+                }
+                else {
+                    this.inCriticalSection = false;
+                }
+            };
+            if (!this.inCriticalSection) {
+                this.inCriticalSection = true;
+                holdsMutex = true;
+                return resolve(markCompleted);
+            }
+            else {
+                let node;
+                const onAbort = () => {
+                    abort?.removeEventListener('abort', onAbort);
+                    if (node.isActive) {
+                        this.deactivateWaiter(node);
+                        rejectAborted();
+                    }
+                };
+                node = this.addWaiter(() => {
+                    abort?.removeEventListener('abort', onAbort);
+                    holdsMutex = true;
+                    resolve(markCompleted);
+                });
+                abort?.addEventListener('abort', onAbort);
             }
         });
-    });
+    }
+    async runExclusive(fn, abort) {
+        const returnMutex = await this.acquire(abort);
+        try {
+            return await fn();
+        }
+        finally {
+            returnMutex();
+        }
+    }
+}
+function timeoutSignal(timeout) {
+    if (timeout == null)
+        return;
+    if ('timeout' in AbortSignal)
+        return AbortSignal.timeout(timeout);
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(new Error('Timeout waiting for lock')), timeout);
+    return controller.signal;
 }
 
 /**
@@ -3922,7 +3805,7 @@ class AttachmentService {
     db;
     logger;
     tableName;
-    mutex = new async_mutex__WEBPACK_IMPORTED_MODULE_0__.Mutex();
+    mutex = new Mutex();
     context;
     constructor(db, logger, tableName = 'attachments', archivedCacheLimit = 100) {
         this.db = db;
@@ -3959,7 +3842,7 @@ class AttachmentService {
      * Executes a callback with exclusive access to the attachment context.
      */
     async withContext(callback) {
-        return mutexRunExclusive(this.mutex, async () => {
+        return this.mutex.runExclusive(async () => {
             return callback(this.context);
         });
     }
@@ -3995,9 +3878,15 @@ class AttachmentQueue {
     tableName;
     /** Logger instance for diagnostic information */
     logger;
-    /** Interval in milliseconds between periodic sync operations. Default: 30000 (30 seconds) */
+    /** Interval in milliseconds between periodic sync operations. Acts as a polling timer to retry
+     *  failed uploads/downloads, especially after the app goes offline. Default: 30000 (30 seconds) */
     syncIntervalMs = 30 * 1000;
-    /** Duration in milliseconds to throttle sync operations */
+    /** Throttle duration in milliseconds for the reactive watch query on the attachments table.
+     *  When attachment records change, a watch query detects the change and triggers a sync.
+     *  This throttle prevents the sync from firing too rapidly when many changes happen in
+     *  quick succession (e.g., bulk inserts). This is distinct from syncIntervalMs — it controls
+     *  how quickly the queue reacts to changes, while syncIntervalMs controls how often it polls
+     *  for retries. Default: 30 (from DEFAULT_WATCH_THROTTLE_MS) */
     syncThrottleDuration;
     /** Whether to automatically download remote attachments. Default: true */
     downloadAttachments = true;
@@ -4021,8 +3910,8 @@ class AttachmentQueue {
      * @param options.watchAttachments - Callback for monitoring attachment changes in your data model
      * @param options.tableName - Name of the table to store attachment records. Default: 'ps_attachment_queue'
      * @param options.logger - Logger instance. Defaults to db.logger
-     * @param options.syncIntervalMs - Interval between automatic syncs in milliseconds. Default: 30000
-     * @param options.syncThrottleDuration - Throttle duration for sync operations in milliseconds. Default: 1000
+     * @param options.syncIntervalMs - Periodic polling interval in milliseconds for retrying failed uploads/downloads. Default: 30000
+     * @param options.syncThrottleDuration - Throttle duration in milliseconds for the reactive watch query that detects attachment changes. Prevents rapid-fire syncs during bulk changes. Default: 30
      * @param options.downloadAttachments - Whether to automatically download remote attachments. Default: true
      * @param options.archivedCacheLimit - Maximum archived attachments before cleanup. Default: 100
      */
@@ -13683,7 +13572,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.49.0";
+var version = "1.50.0";
 var PACKAGE = {
 	version: version};
 
@@ -16075,7 +15964,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
         this._schema = schema;
         this.ready = false;
         this.sdkVersion = '';
-        this.runExclusiveMutex = new async_mutex__WEBPACK_IMPORTED_MODULE_0__.Mutex();
+        this.runExclusiveMutex = new Mutex();
         // Start async init
         this.subscriptions = {
             firstStatusMatching: (predicate, abort) => this.waitForStatus(predicate, abort),
@@ -16540,6 +16429,10 @@ SELECT * FROM crud_entries;
      * Execute a SQL write (INSERT/UPDATE/DELETE) query
      * and optionally return results.
      *
+     * When using the default client-side [JSON-based view system](https://docs.powersync.com/architecture/client-architecture#client-side-schema-and-sqlite-database-structure),
+     * the returned result's `rowsAffected` may be `0` for successful `UPDATE` and `DELETE` statements.
+     * Use a `RETURNING` clause and inspect `result.rows` when you need to confirm which rows changed.
+     *
      * @param sql The SQL query to execute
      * @param parameters Optional array of parameters to bind to the query
      * @returns The query result as an object with structured key-value pairs
@@ -16636,7 +16529,7 @@ SELECT * FROM crud_entries;
     async readTransaction(callback, lockTimeout = DEFAULT_LOCK_TIMEOUT_MS) {
         await this.waitForReady();
         return this.database.readTransaction(async (tx) => {
-            const res = await callback({ ...tx });
+            const res = await callback(tx);
             await tx.rollback();
             return res;
         }, { timeoutMs: lockTimeout });
@@ -17792,9 +17685,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
 /* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
 /* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs");
-/* harmony import */ var _shared_navigator_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../shared/navigator.js */ "./lib/src/shared/navigator.js");
-/* harmony import */ var _SharedWASQLiteConnection_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./SharedWASQLiteConnection.js */ "./lib/src/worker/db/SharedWASQLiteConnection.js");
-/* harmony import */ var _WorkerWASQLiteConnection_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./WorkerWASQLiteConnection.js */ "./lib/src/worker/db/WorkerWASQLiteConnection.js");
+/* harmony import */ var _MultiDatabaseServer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./MultiDatabaseServer.js */ "./lib/src/worker/db/MultiDatabaseServer.js");
 /**
  * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
  */
@@ -17802,67 +17693,28 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
-
 const baseLogger = (0,_powersync_common__WEBPACK_IMPORTED_MODULE_1__.createBaseLogger)();
 baseLogger.useDefaults();
 const logger = (0,_powersync_common__WEBPACK_IMPORTED_MODULE_1__.createLogger)('db-worker');
-const DBMap = new Map();
-const OPEN_DB_LOCK = 'open-wasqlite-db';
-let nextClientId = 1;
-const openDBShared = async (options) => {
-    // Prevent multiple simultaneous opens from causing race conditions
-    return (0,_shared_navigator_js__WEBPACK_IMPORTED_MODULE_3__.getNavigatorLocks)().request(OPEN_DB_LOCK, async () => {
-        const clientId = nextClientId++;
-        const { dbFilename, logLevel } = options;
-        logger.setLevel(logLevel);
-        if (!DBMap.has(dbFilename)) {
-            const clientIds = new Set();
-            // This format returns proxy objects for function callbacks
-            const connection = new _WorkerWASQLiteConnection_js__WEBPACK_IMPORTED_MODULE_5__.WorkerWASQLiteConnection(options);
-            await connection.init();
-            connection.registerListener({
-                holdOverwritten: async () => {
-                    /**
-                     * The previous hold has been overwritten, without being released.
-                     * we need to cleanup any resources associated with it.
-                     * We can perform a rollback to release any potential transactions that were started.
-                     */
-                    await connection.execute('ROLLBACK').catch(() => { });
-                }
-            });
-            DBMap.set(dbFilename, {
-                clientIds,
-                db: connection
-            });
-        }
-        // Associates this clientId with the shared connection entry
-        const sharedConnection = new _SharedWASQLiteConnection_js__WEBPACK_IMPORTED_MODULE_4__.SharedWASQLiteConnection({
-            dbMap: DBMap,
-            dbFilename,
-            clientId,
-            logger
-        });
-        return comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(sharedConnection);
-    });
+const server = new _MultiDatabaseServer_js__WEBPACK_IMPORTED_MODULE_3__.MultiDatabaseServer(logger);
+const exposedFunctions = {
+    connect: (config) => server.handleConnection(config),
+    connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
 };
 // Check if we're in a SharedWorker context
-if (typeof SharedWorkerGlobalScope !== 'undefined') {
+if (_MultiDatabaseServer_js__WEBPACK_IMPORTED_MODULE_3__.isSharedWorker) {
     const _self = self;
     _self.onconnect = function (event) {
         const port = event.ports[0];
-        comlink__WEBPACK_IMPORTED_MODULE_2__.expose(openDBShared, port);
+        comlink__WEBPACK_IMPORTED_MODULE_2__.expose(exposedFunctions, port);
     };
 }
 else {
     // A dedicated worker can be shared externally
-    comlink__WEBPACK_IMPORTED_MODULE_2__.expose(openDBShared);
+    comlink__WEBPACK_IMPORTED_MODULE_2__.expose(exposedFunctions);
 }
 addEventListener('unload', () => {
-    Array.from(DBMap.values()).forEach(async (dbConnection) => {
-        const { db } = dbConnection;
-        db.close?.();
-    });
+    server.closeAll();
 });
 
 })();