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

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,205 +2098,355 @@ 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 */   AsyncWASQLiteModuleFactory: () => (/* binding */ AsyncWASQLiteModuleFactory),
-/* harmony export */   DEFAULT_MODULE_FACTORIES: () => (/* binding */ DEFAULT_MODULE_FACTORIES),
-/* harmony export */   MultiCipherAsyncWASQLiteModuleFactory: () => (/* binding */ MultiCipherAsyncWASQLiteModuleFactory),
-/* harmony export */   MultiCipherSyncWASQLiteModuleFactory: () => (/* binding */ MultiCipherSyncWASQLiteModuleFactory),
-/* harmony export */   SyncWASQLiteModuleFactory: () => (/* binding */ SyncWASQLiteModuleFactory),
-/* harmony export */   WASQLiteVFS: () => (/* binding */ WASQLiteVFS),
-/* harmony export */   WASqliteConnection: () => (/* binding */ WASqliteConnection)
+/* harmony export */   ConcurrentSqliteConnection: () => (/* binding */ ConcurrentSqliteConnection),
+/* harmony export */   ConnectionLeaseToken: () => (/* binding */ ConnectionLeaseToken)
 /* 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");
+/* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
 
-
-
-/**
- * List of currently tested virtual filesystems
- */
-var WASQLiteVFS;
-(function (WASQLiteVFS) {
-    WASQLiteVFS["IDBBatchAtomicVFS"] = "IDBBatchAtomicVFS";
-    WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
-    WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
-})(WASQLiteVFS || (WASQLiteVFS = {}));
-/**
- * @internal
- */
-const AsyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_wa-sqli-cc5fcc").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs"));
-    return factory();
-};
-/**
- * @internal
- */
-const MultiCipherAsyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_mc-wa-s-c99c07").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs"));
-    return factory();
-};
-/**
- * @internal
- */
-const SyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_wa-sqlite_mjs").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/wa-sqlite.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/wa-sqlite.mjs"));
-    return factory();
-};
-/**
- * @internal
- */
-const MultiCipherSyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_mc-wa-s-b9c070").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs"));
-    return factory();
-};
-/**
- * @internal
- */
-const DEFAULT_MODULE_FACTORIES = {
-    [WASQLiteVFS.IDBBatchAtomicVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherAsyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await AsyncWASQLiteModuleFactory();
-        }
-        const { IDBBatchAtomicVFS } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_src_examples-0df390").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js"));
-        return {
-            module,
-            // @ts-expect-error The types for this static method are missing upstream
-            vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
-        };
-    },
-    [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherSyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await SyncWASQLiteModuleFactory();
-        }
-        // @ts-expect-error The types for this static method are missing upstream
-        const { AccessHandlePoolVFS } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_src_examples-151024").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js"));
-        return {
-            module,
-            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
-        };
-    },
-    [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherSyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await SyncWASQLiteModuleFactory();
-        }
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSCoopSyncVFS } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_src_examples-c01ef0").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js"));
-        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
-        return {
-            module,
-            vfs
-        };
-    }
-};
 /**
- * @internal
- * WA-SQLite connection which directly interfaces with WA-SQLite.
- * This is usually instantiated inside a worker.
+ * 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 WASqliteConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_1__.BaseObserver {
-    options;
-    _sqliteAPI = null;
-    _dbP = null;
-    _moduleFactory;
-    updatedTables;
-    updateTimer;
-    statementMutex;
-    broadcastChannel;
+class ConcurrentSqliteConnection {
+    inner;
     /**
-     * Unique id for this specific connection. This is used to prevent broadcast table change
-     * notification loops.
+     * 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.
      */
-    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;
-    }
+    leaseMutex;
     /**
-     * Gets the id for the current hold.
-     * This can be used to check for invalid states.
+     * @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..
      */
-    get currentHoldId() {
-        return this._holdId;
+    constructor(inner, needsNavigatorLocks) {
+        this.inner = inner;
+        this.leaseMutex = needsNavigatorLocks ? null : new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.Mutex();
     }
-    get sqliteAPI() {
-        if (!this._sqliteAPI) {
-            throw new Error(`Initialization has not completed`);
-        }
-        return this._sqliteAPI;
+    get options() {
+        return this.inner.options;
     }
-    get dbP() {
-        if (!this._dbP) {
-            throw new Error(`Initialization has not completed`);
+    acquireMutex(abort) {
+        if (this.leaseMutex) {
+            return this.leaseMutex.acquire(abort);
         }
-        return this._dbP;
+        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;
     }
     /**
-     * Checks if the database connection is in autocommit mode.
-     * @returns true if in autocommit mode, false if in a transaction
+     * @returns A {@link ConnectionLeaseToken}. Until that token is returned, no other client can use the database.
      */
-    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));
+    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');
+            }
         }
-        return this._holdId;
+        catch (e) {
+            returnMutex();
+            throw e;
+        }
+        return token;
     }
-    async releaseHold(holdId) {
-        if (holdId != this._holdId) {
-            throw new Error(`Invalid hold state, expected ${this._holdId} but got ${holdId}`);
+    async close() {
+        const returnMutex = await this.acquireMutex();
+        try {
+            await this.inner.close();
+        }
+        finally {
+            returnMutex();
         }
-        this._holdId = null;
     }
-    async openDB() {
-        this._dbP = await this.sqliteAPI.open_v2(this.options.dbFilename);
-        return this._dbP;
+}
+/**
+ * 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;
     }
-    async executeEncryptionPragma() {
-        if (this.options.encryptionKey) {
-            await this.executeSingleStatement(`PRAGMA key = "${this.options.encryptionKey}"`);
-        }
-        return;
+    /**
+     * 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 = _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory(module);
+        const sqlite3 = (0,_journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory)(module);
         sqlite3.vfs_register(vfs, true);
         /**
          * Register the PowerSync core SQLite extension
@@ -2624,202 +2463,61 @@ class WASqliteConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_1__.
         }
         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
-            });
+    requireSqlite() {
+        if (!this._sqliteAPI) {
+            throw new Error(`Initialization has not completed`);
         }
-        this.updatedTables.clear();
-        this.iterateListeners((cb) => cb.tablesUpdated?.(event));
+        return this._sqliteAPI;
     }
     /**
-     * This executes SQL statements in a batch.
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
      */
-    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;
-        });
+    isAutoCommit() {
+        return this.requireSqlite().get_autocommit(this.db) != 0;
     }
-    /**
-     * 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)
-        });
+        const resultSet = await this.executeSingleStatementRaw(sql, bindings);
+        return this.wrapQueryResults(this.requireSqlite(), resultSet);
     }
-    /**
-     * 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);
+    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;
         }
-        const result = {
-            insertId: this.sqliteAPI.last_insert_id(this.dbP),
-            rowsAffected: this.sqliteAPI.changes(this.dbP),
-            rows: {
-                _array: rows,
-                length: rows.length
-            }
+        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
         };
-        return result;
     }
     /**
-     * This executes a single statement using SQLite3 and returns the results as an array of arrays.
+     * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
      */
     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])));
+        const results = await this.executeRaw(sql, bindings);
+        return results.length ? results[0] : undefined;
     }
-    async _execute(sql, bindings) {
+    async executeRaw(sql, bindings) {
         const results = [];
-        for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
+        const api = this.requireSqlite();
+        for await (const stmt of api.statements(this.db, 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 });
-                }
+            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) {
@@ -2828,159 +2526,271 @@ class WASqliteConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_1__.
         }
         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/shared/navigator.js"
-/*!*************************************!*\
-  !*** ./lib/src/shared/navigator.js ***!
-  \*************************************/
+/***/ "./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__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   getNavigatorLocks: () => (/* binding */ getNavigatorLocks)
+/* harmony export */   AsyncWASQLiteModuleFactory: () => (/* binding */ AsyncWASQLiteModuleFactory),
+/* harmony export */   DEFAULT_MODULE_FACTORIES: () => (/* binding */ DEFAULT_MODULE_FACTORIES),
+/* harmony export */   MultiCipherAsyncWASQLiteModuleFactory: () => (/* binding */ MultiCipherAsyncWASQLiteModuleFactory),
+/* harmony export */   MultiCipherSyncWASQLiteModuleFactory: () => (/* binding */ MultiCipherSyncWASQLiteModuleFactory),
+/* harmony export */   SyncWASQLiteModuleFactory: () => (/* binding */ SyncWASQLiteModuleFactory),
+/* harmony export */   WASQLiteVFS: () => (/* binding */ WASQLiteVFS),
+/* harmony export */   vfsRequiresDedicatedWorkers: () => (/* binding */ vfsRequiresDedicatedWorkers)
 /* harmony export */ });
-const getNavigatorLocks = () => {
-    if ('locks' in navigator && navigator.locks) {
-        return navigator.locks;
-    }
-    throw new Error('Navigator locks are not available in an insecure context. Use a secure context such as HTTPS or http://localhost.');
+/**
+ * List of currently tested virtual filesystems
+ */
+var WASQLiteVFS;
+(function (WASQLiteVFS) {
+    WASQLiteVFS["IDBBatchAtomicVFS"] = "IDBBatchAtomicVFS";
+    WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
+    WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
+})(WASQLiteVFS || (WASQLiteVFS = {}));
+function vfsRequiresDedicatedWorkers(vfs) {
+    return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
+}
+/**
+ * @internal
+ */
+const AsyncWASQLiteModuleFactory = async () => {
+    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_wa-sqli-cc5fcc").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs"));
+    return factory();
 };
-
-
-/***/ },
-
-/***/ "./lib/src/worker/db/SharedWASQLiteConnection.js"
-/*!*******************************************************!*\
-  !*** ./lib/src/worker/db/SharedWASQLiteConnection.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 */ });
-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);
+/**
+ * @internal
+ */
+const MultiCipherAsyncWASQLiteModuleFactory = async () => {
+    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_mc-wa-s-c99c07").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs"));
+    return factory();
+};
+/**
+ * @internal
+ */
+const SyncWASQLiteModuleFactory = async () => {
+    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_wa-sqlite_mjs").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/wa-sqlite.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/wa-sqlite.mjs"));
+    return factory();
+};
+/**
+ * @internal
+ */
+const MultiCipherSyncWASQLiteModuleFactory = async () => {
+    const { default: factory } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_dist_mc-wa-s-b9c070").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs"));
+    return factory();
+};
+/**
+ * @internal
+ */
+const DEFAULT_MODULE_FACTORIES = {
+    [WASQLiteVFS.IDBBatchAtomicVFS]: async (options) => {
+        let module;
+        if (options.encryptionKey) {
+            module = await MultiCipherAsyncWASQLiteModuleFactory();
         }
-        finally {
-            this.activeHoldId = null;
+        else {
+            module = await AsyncWASQLiteModuleFactory();
         }
-    }
-    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.`);
+        const { IDBBatchAtomicVFS } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_src_examples-0df390").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js"));
+        return {
+            module,
+            // @ts-expect-error The types for this static method are missing upstream
+            vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
+        };
+    },
+    [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
+        let module;
+        if (options.encryptionKey) {
+            module = await MultiCipherSyncWASQLiteModuleFactory();
         }
-        if (clientIds.size == 0) {
-            logger.debug(`Closing connection to ${this.options}.`);
-            const connection = this.connection;
-            dbMap.delete(dbFilename);
-            await connection.close();
-            return;
+        else {
+            module = await SyncWASQLiteModuleFactory();
         }
-        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');
+        // @ts-expect-error The types for this static method are missing upstream
+        const { AccessHandlePoolVFS } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_src_examples-151024").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js"));
+        return {
+            module,
+            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
+        };
+    },
+    [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
+        let module;
+        if (options.encryptionKey) {
+            module = await MultiCipherSyncWASQLiteModuleFactory();
         }
-        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);
+        else {
+            module = await SyncWASQLiteModuleFactory();
+        }
+        // @ts-expect-error The types for this static method are missing upstream
+        const { OPFSCoopSyncVFS } = await __webpack_require__.e(/*! import() */ "node_modules_pnpm_journeyapps_wa-sqlite_1_5_0_node_modules_journeyapps_wa-sqlite_src_examples-c01ef0").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.5.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js"));
+        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
+        return {
+            module,
+            vfs
+        };
     }
-    getConfig() {
-        return this.connection.getConfig();
+};
+
+
+/***/ },
+
+/***/ "./lib/src/shared/navigator.js"
+/*!*************************************!*\
+  !*** ./lib/src/shared/navigator.js ***!
+  \*************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getNavigatorLocks: () => (/* binding */ getNavigatorLocks)
+/* harmony export */ });
+const getNavigatorLocks = () => {
+    if ('locks' in navigator && navigator.locks) {
+        return navigator.locks;
     }
-}
+    throw new Error('Navigator locks are not available in an insecure context. Use a secure context such as HTTPS or http://localhost.');
+};
 
 
 /***/ },
 
-/***/ "./lib/src/worker/db/WorkerWASQLiteConnection.js"
-/*!*******************************************************!*\
-  !*** ./lib/src/worker/db/WorkerWASQLiteConnection.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 */   WorkerWASQLiteConnection: () => (/* binding */ WorkerWASQLiteConnection)
+/* harmony export */   MultiDatabaseServer: () => (/* binding */ MultiDatabaseServer),
+/* harmony export */   isSharedWorker: () => (/* binding */ isSharedWorker)
 /* 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");
+/* 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");
+
+
 
 
+
+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;
 
 
 /***/ },
@@ -3015,6 +2825,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   CrudBatch: () => (/* binding */ CrudBatch),
 /* harmony export */   CrudEntry: () => (/* binding */ CrudEntry),
 /* harmony export */   CrudTransaction: () => (/* binding */ CrudTransaction),
+/* harmony export */   DBAdapterDefaultMixin: () => (/* binding */ DBAdapterDefaultMixin),
+/* harmony export */   DBGetUtilsDefaultMixin: () => (/* binding */ DBGetUtilsDefaultMixin),
 /* harmony export */   DEFAULT_CRUD_BATCH_LIMIT: () => (/* binding */ DEFAULT_CRUD_BATCH_LIMIT),
 /* harmony export */   DEFAULT_CRUD_UPLOAD_THROTTLE_MS: () => (/* binding */ DEFAULT_CRUD_UPLOAD_THROTTLE_MS),
 /* harmony export */   DEFAULT_INDEX_COLUMN_OPTIONS: () => (/* binding */ DEFAULT_INDEX_COLUMN_OPTIONS),
@@ -3022,7 +2834,6 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   DEFAULT_LOCK_TIMEOUT_MS: () => (/* binding */ DEFAULT_LOCK_TIMEOUT_MS),
 /* harmony export */   DEFAULT_POWERSYNC_CLOSE_OPTIONS: () => (/* binding */ DEFAULT_POWERSYNC_CLOSE_OPTIONS),
 /* harmony export */   DEFAULT_POWERSYNC_DB_OPTIONS: () => (/* binding */ DEFAULT_POWERSYNC_DB_OPTIONS),
-/* harmony export */   DEFAULT_PRESSURE_LIMITS: () => (/* binding */ DEFAULT_PRESSURE_LIMITS),
 /* harmony export */   DEFAULT_REMOTE_LOGGER: () => (/* binding */ DEFAULT_REMOTE_LOGGER),
 /* harmony export */   DEFAULT_REMOTE_OPTIONS: () => (/* binding */ DEFAULT_REMOTE_OPTIONS),
 /* harmony export */   DEFAULT_RETRY_DELAY_MS: () => (/* binding */ DEFAULT_RETRY_DELAY_MS),
@@ -3033,7 +2844,6 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   DEFAULT_TABLE_OPTIONS: () => (/* binding */ DEFAULT_TABLE_OPTIONS),
 /* harmony export */   DEFAULT_WATCH_QUERY_OPTIONS: () => (/* binding */ DEFAULT_WATCH_QUERY_OPTIONS),
 /* harmony export */   DEFAULT_WATCH_THROTTLE_MS: () => (/* binding */ DEFAULT_WATCH_THROTTLE_MS),
-/* harmony export */   DataStream: () => (/* binding */ DataStream),
 /* harmony export */   DiffTriggerOperation: () => (/* binding */ DiffTriggerOperation),
 /* harmony export */   DifferentialQueryProcessor: () => (/* binding */ DifferentialQueryProcessor),
 /* harmony export */   EMPTY_DIFFERENTIAL: () => (/* binding */ EMPTY_DIFFERENTIAL),
@@ -3050,6 +2860,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),
@@ -3058,6 +2869,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   PowerSyncControlCommand: () => (/* binding */ PowerSyncControlCommand),
 /* harmony export */   RowUpdateType: () => (/* binding */ RowUpdateType),
 /* harmony export */   Schema: () => (/* binding */ Schema),
+/* harmony export */   Semaphore: () => (/* binding */ Semaphore),
 /* harmony export */   SqliteBucketStorage: () => (/* binding */ SqliteBucketStorage),
 /* harmony export */   SyncClientImplementation: () => (/* binding */ SyncClientImplementation),
 /* harmony export */   SyncDataBatch: () => (/* binding */ SyncDataBatch),
@@ -3091,15 +2903,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) {
@@ -3757,7 +3566,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;
             }
@@ -3835,17 +3644,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
@@ -3883,32 +3691,198 @@ class SyncingService {
 }
 
 /**
- * Wrapper for async-mutex runExclusive, which allows for a timeout on each exclusive lock.
+ * A simple fixed-capacity queue implementation.
+ *
+ * Unlike a naive queue implemented by `array.push()` and `array.shift()`, this avoids moving array elements around
+ * and is `O(1)` for {@link addLast} and {@link removeFirst}.
+ */
+class Queue {
+    table;
+    // Index of the first element in the table.
+    head;
+    // Amount of items currently in the queue.
+    _length;
+    constructor(initialItems) {
+        this.table = [...initialItems];
+        this.head = 0;
+        this._length = this.table.length;
+    }
+    get isEmpty() {
+        return this.length == 0;
+    }
+    get length() {
+        return this._length;
+    }
+    removeFirst() {
+        if (this.isEmpty) {
+            throw new Error('Queue is empty');
+        }
+        const result = this.table[this.head];
+        this._length--;
+        this.table[this.head] = undefined;
+        this.head = (this.head + 1) % this.table.length;
+        return result;
+    }
+    addLast(element) {
+        if (this.length == this.table.length) {
+            throw new Error('Queue is full');
+        }
+        this.table[(this.head + this._length) % this.table.length] = element;
+        this._length++;
+    }
+}
+
+/**
+ * An asynchronous semaphore implementation with associated items per lease.
+ *
+ * @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 Semaphore {
+    // Available items that are not currently assigned to a waiter.
+    available;
+    size;
+    // 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;
+    constructor(elements) {
+        this.available = new Queue(elements);
+        this.size = this.available.length;
+    }
+    addWaiter(requestedItems, onAcquire) {
+        const node = {
+            isActive: true,
+            acquiredItems: [],
+            remainingItems: requestedItems,
+            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;
+    }
+    requestPermits(amount, abort) {
+        if (amount <= 0 || amount > this.size) {
+            throw new Error(`Invalid amount of items requested (${amount}), must be between 1 and ${this.size}`);
+        }
+        return new Promise((resolve, reject) => {
+            function rejectAborted() {
+                reject(abort?.reason ?? new Error('Semaphore acquire aborted'));
             }
-            if (timedOut)
-                return;
-            try {
-                resolve(await callback());
+            if (abort?.aborted) {
+                return rejectAborted();
             }
-            catch (ex) {
-                reject(ex);
+            let waiter;
+            const markCompleted = () => {
+                const items = waiter.acquiredItems;
+                waiter.acquiredItems = []; // Avoid releasing items twice.
+                for (const element of items) {
+                    // Give to next waiter, if possible.
+                    const nextWaiter = this.firstWaiter;
+                    if (nextWaiter) {
+                        nextWaiter.acquiredItems.push(element);
+                        nextWaiter.remainingItems--;
+                        if (nextWaiter.remainingItems == 0) {
+                            nextWaiter.onAcquire();
+                        }
+                    }
+                    else {
+                        // No pending waiter, return lease into pool.
+                        this.available.addLast(element);
+                    }
+                }
+            };
+            const onAbort = () => {
+                abort?.removeEventListener('abort', onAbort);
+                if (waiter.isActive) {
+                    this.deactivateWaiter(waiter);
+                    rejectAborted();
+                }
+            };
+            const resolvePromise = () => {
+                this.deactivateWaiter(waiter);
+                abort?.removeEventListener('abort', onAbort);
+                const items = waiter.acquiredItems;
+                resolve({ items, release: markCompleted });
+            };
+            waiter = this.addWaiter(amount, resolvePromise);
+            // If there are items in the pool that haven't been assigned, we can pull them into this waiter. Note that this is
+            // only the case if we're the first waiter (otherwise, items would have been assigned to an earlier waiter).
+            while (!this.available.isEmpty && waiter.remainingItems > 0) {
+                waiter.acquiredItems.push(this.available.removeFirst());
+                waiter.remainingItems--;
             }
+            if (waiter.remainingItems == 0) {
+                return resolvePromise();
+            }
+            abort?.addEventListener('abort', onAbort);
         });
-    });
+    }
+    /**
+     * Requests a single item from the pool.
+     *
+     * The returned `release` callback must be invoked to return the item into the pool.
+     */
+    async requestOne(abort) {
+        const { items, release } = await this.requestPermits(1, abort);
+        return { release, item: items[0] };
+    }
+    /**
+     * Requests access to all items from the pool.
+     *
+     * The returned `release` callback must be invoked to return items into the pool.
+     */
+    requestAll(abort) {
+        return this.requestPermits(this.size, abort);
+    }
+}
+/**
+ * An asynchronous mutex implementation.
+ *
+ * @internal This class is meant to be used in PowerSync SDKs only, and is not part of the public API.
+ */
+class Mutex {
+    inner = new Semaphore([null]);
+    async acquire(abort) {
+        const { release } = await this.inner.requestOne(abort);
+        return release;
+    }
+    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;
 }
 
 /**
@@ -3920,7 +3894,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;
@@ -3957,7 +3931,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);
         });
     }
@@ -3993,9 +3967,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;
@@ -4019,8 +3999,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
      */
@@ -4327,6 +4307,8 @@ var EncodingType;
     EncodingType["Base64"] = "base64";
 })(EncodingType || (EncodingType = {}));
 
+const symbolAsyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -4407,7 +4389,7 @@ function requireEventIterator () {
 	                this.removeCallback();
 	        });
 	    }
-	    [Symbol.asyncIterator]() {
+	    [symbolAsyncIterator]() {
 	        return {
 	            next: (value) => {
 	                const result = this.pushQueue.shift();
@@ -4454,7 +4436,7 @@ function requireEventIterator () {
 	                    queue.eventHandlers[event] = fn;
 	                },
 	            }) || (() => { });
-	        this[Symbol.asyncIterator] = () => queue[Symbol.asyncIterator]();
+	        this[symbolAsyncIterator] = () => queue[symbolAsyncIterator]();
 	        Object.freeze(this);
 	    }
 	}
@@ -4781,6 +4763,49 @@ var Logger = /*@__PURE__*/getDefaultExportFromCjs(loggerExports);
  * Set of generic interfaces to allow PowerSync compatibility with
  * different SQLite DB implementations.
  */
+/**
+ * Implements {@link DBGetUtils} on a {@link SqlRunner}.
+ */
+function DBGetUtilsDefaultMixin(Base) {
+    return class extends Base {
+        async getAll(sql, parameters) {
+            const res = await this.execute(sql, parameters);
+            return res.rows?._array ?? [];
+        }
+        async getOptional(sql, parameters) {
+            const res = await this.execute(sql, parameters);
+            return res.rows?.item(0) ?? null;
+        }
+        async get(sql, parameters) {
+            const res = await this.execute(sql, parameters);
+            const first = res.rows?.item(0);
+            if (!first) {
+                throw new Error('Result set is empty');
+            }
+            return first;
+        }
+        async executeBatch(query, params = []) {
+            // If this context can run batch statements natively, use that.
+            // @ts-ignore
+            if (super.executeBatch) {
+                // @ts-ignore
+                return super.executeBatch(query, params);
+            }
+            // Emulate executeBatch by running statements individually.
+            let lastInsertId;
+            let rowsAffected = 0;
+            for (const set of params) {
+                const result = await this.execute(query, set);
+                lastInsertId = result.insertId;
+                rowsAffected += result.rowsAffected;
+            }
+            return {
+                rowsAffected,
+                insertId: lastInsertId
+            };
+        }
+    };
+}
 /**
  * Update table operation numbers from SQLite
  */
@@ -4790,6 +4815,89 @@ var RowUpdateType;
     RowUpdateType[RowUpdateType["SQLITE_DELETE"] = 9] = "SQLITE_DELETE";
     RowUpdateType[RowUpdateType["SQLITE_UPDATE"] = 23] = "SQLITE_UPDATE";
 })(RowUpdateType || (RowUpdateType = {}));
+/**
+ * A mixin to implement {@link DBAdapter} by delegating to {@link ConnectionPool.readLock} and
+ * {@link ConnectionPool.writeLock}.
+ */
+function DBAdapterDefaultMixin(Base) {
+    return class extends Base {
+        readTransaction(fn, options) {
+            return this.readLock((ctx) => TransactionImplementation.runWith(ctx, fn), options);
+        }
+        writeTransaction(fn, options) {
+            return this.writeLock((ctx) => TransactionImplementation.runWith(ctx, fn), options);
+        }
+        getAll(sql, parameters) {
+            return this.readLock((ctx) => ctx.getAll(sql, parameters));
+        }
+        getOptional(sql, parameters) {
+            return this.readLock((ctx) => ctx.getOptional(sql, parameters));
+        }
+        get(sql, parameters) {
+            return this.readLock((ctx) => ctx.get(sql, parameters));
+        }
+        execute(query, params) {
+            return this.writeLock((ctx) => ctx.execute(query, params));
+        }
+        executeRaw(query, params) {
+            return this.writeLock((ctx) => ctx.executeRaw(query, params));
+        }
+        executeBatch(query, params) {
+            return this.writeTransaction((tx) => tx.executeBatch(query, params));
+        }
+    };
+}
+class BaseTransaction {
+    inner;
+    finalized = false;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    async commit() {
+        if (this.finalized) {
+            return { rowsAffected: 0 };
+        }
+        this.finalized = true;
+        return this.inner.execute('COMMIT');
+    }
+    async rollback() {
+        if (this.finalized) {
+            return { rowsAffected: 0 };
+        }
+        this.finalized = true;
+        return this.inner.execute('ROLLBACK');
+    }
+    execute(query, params) {
+        return this.inner.execute(query, params);
+    }
+    executeRaw(query, params) {
+        return this.inner.executeRaw(query, params);
+    }
+    executeBatch(query, params) {
+        return this.inner.executeBatch(query, params);
+    }
+}
+class TransactionImplementation extends DBGetUtilsDefaultMixin(BaseTransaction) {
+    static async runWith(ctx, fn) {
+        let tx = new TransactionImplementation(ctx);
+        try {
+            await ctx.execute('BEGIN IMMEDIATE');
+            const result = await fn(tx);
+            await tx.commit();
+            return result;
+        }
+        catch (ex) {
+            try {
+                await tx.rollback();
+            }
+            catch (ex2) {
+                // In rare cases, a rollback may fail.
+                // Safe to ignore.
+            }
+            throw ex;
+        }
+    }
+}
 function isBatchedUpdateNotification(update) {
     return 'tables' in update;
 }
@@ -5210,15 +5318,6 @@ class ControlledExecutor {
     }
 }
 
-/**
- * A ponyfill for `Symbol.asyncIterator` that is compatible with the
- * [recommended polyfill](https://github.com/Azure/azure-sdk-for-js/blob/%40azure/core-asynciterator-polyfill_1.0.2/sdk/core/core-asynciterator-polyfill/src/index.ts#L4-L6)
- * we recommend for React Native.
- *
- * As long as we use this symbol (instead of `for await` and `async *`) in this package, we can be compatible with async
- * iterators without requiring them.
- */
-const symbolAsyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
 /**
  * Throttle a function to be called at most once every "wait" milliseconds,
  * on the trailing edge.
@@ -13540,192 +13639,25 @@ function requireDist () {
 		};
 		Object.defineProperty(exports$1, "__esModule", { value: true });
 		__exportStar(requireCodecs(), exports$1);
-		__exportStar(requireCommon(), exports$1);
-		__exportStar(requireDeferred(), exports$1);
-		__exportStar(requireErrors(), exports$1);
-		__exportStar(requireFrames(), exports$1);
-		__exportStar(requireRSocket(), exports$1);
-		__exportStar(requireRSocketConnector(), exports$1);
-		__exportStar(requireRSocketServer(), exports$1);
-		__exportStar(requireTransport(), exports$1);
-		
-	} (dist));
-	return dist;
-}
-
-var distExports = requireDist();
-
-var version = "1.48.0";
-var PACKAGE = {
-	version: version};
-
-const DEFAULT_PRESSURE_LIMITS = {
-    highWater: 10,
-    lowWater: 0
-};
-/**
- * A very basic implementation of a data stream with backpressure support which does not use
- * native JS streams or async iterators.
- * This is handy for environments such as React Native which need polyfills for the above.
- */
-class DataStream extends BaseObserver {
-    options;
-    dataQueue;
-    isClosed;
-    processingPromise;
-    notifyDataAdded;
-    logger;
-    mapLine;
-    constructor(options) {
-        super();
-        this.options = options;
-        this.processingPromise = null;
-        this.isClosed = false;
-        this.dataQueue = [];
-        this.mapLine = options?.mapLine ?? ((line) => line);
-        this.logger = options?.logger ?? Logger.get('DataStream');
-        if (options?.closeOnError) {
-            const l = this.registerListener({
-                error: (ex) => {
-                    l?.();
-                    this.close();
-                }
-            });
-        }
-    }
-    get highWatermark() {
-        return this.options?.pressure?.highWaterMark ?? DEFAULT_PRESSURE_LIMITS.highWater;
-    }
-    get lowWatermark() {
-        return this.options?.pressure?.lowWaterMark ?? DEFAULT_PRESSURE_LIMITS.lowWater;
-    }
-    get closed() {
-        return this.isClosed;
-    }
-    async close() {
-        this.isClosed = true;
-        await this.processingPromise;
-        this.iterateListeners((l) => l.closed?.());
-        // Discard any data in the queue
-        this.dataQueue = [];
-        this.listeners.clear();
-    }
-    /**
-     * Enqueues data for the consumers to read
-     */
-    enqueueData(data) {
-        if (this.isClosed) {
-            throw new Error('Cannot enqueue data into closed stream.');
-        }
-        this.dataQueue.push(data);
-        this.notifyDataAdded?.();
-        this.processQueue();
-    }
-    /**
-     * Reads data once from the data stream
-     * @returns a Data payload or Null if the stream closed.
-     */
-    async read() {
-        if (this.closed) {
-            return null;
-        }
-        // Wait for any pending processing to complete first.
-        // This ensures we register our listener before calling processQueue(),
-        // avoiding a race where processQueue() sees no reader and returns early.
-        if (this.processingPromise) {
-            await this.processingPromise;
-        }
-        // Re-check after await - stream may have closed while we were waiting
-        if (this.closed) {
-            return null;
-        }
-        return new Promise((resolve, reject) => {
-            const l = this.registerListener({
-                data: async (data) => {
-                    resolve(data);
-                    // Remove the listener
-                    l?.();
-                },
-                closed: () => {
-                    resolve(null);
-                    l?.();
-                },
-                error: (ex) => {
-                    reject(ex);
-                    l?.();
-                }
-            });
-            this.processQueue();
-        });
-    }
-    /**
-     * Executes a callback for each data item in the stream
-     */
-    forEach(callback) {
-        if (this.dataQueue.length <= this.lowWatermark) {
-            this.iterateAsyncErrored(async (l) => l.lowWater?.());
-        }
-        return this.registerListener({
-            data: callback
-        });
-    }
-    processQueue() {
-        if (this.processingPromise) {
-            return;
-        }
-        const promise = (this.processingPromise = this._processQueue());
-        promise.finally(() => {
-            this.processingPromise = null;
-        });
-        return promise;
-    }
-    hasDataReader() {
-        return Array.from(this.listeners.values()).some((l) => !!l.data);
-    }
-    async _processQueue() {
-        /**
-         * Allow listeners to mutate the queue before processing.
-         * This allows for operations such as dropping or compressing data
-         * on high water or requesting more data on low water.
-         */
-        if (this.dataQueue.length >= this.highWatermark) {
-            await this.iterateAsyncErrored(async (l) => l.highWater?.());
-        }
-        if (this.isClosed || !this.hasDataReader()) {
-            return;
-        }
-        if (this.dataQueue.length) {
-            const data = this.dataQueue.shift();
-            const mapped = this.mapLine(data);
-            await this.iterateAsyncErrored(async (l) => l.data?.(mapped));
-        }
-        if (this.dataQueue.length <= this.lowWatermark) {
-            const dataAdded = new Promise((resolve) => {
-                this.notifyDataAdded = resolve;
-            });
-            await Promise.race([this.iterateAsyncErrored(async (l) => l.lowWater?.()), dataAdded]);
-            this.notifyDataAdded = null;
-        }
-        if (this.dataQueue.length > 0) {
-            setTimeout(() => this.processQueue());
-        }
-    }
-    async iterateAsyncErrored(cb) {
-        // Important: We need to copy the listeners, as calling a listener could result in adding another
-        // listener, resulting in infinite loops.
-        const listeners = Array.from(this.listeners.values());
-        for (let i of listeners) {
-            try {
-                await cb(i);
-            }
-            catch (ex) {
-                this.logger.error(ex);
-                this.iterateListeners((l) => l.error?.(ex));
-            }
-        }
-    }
+		__exportStar(requireCommon(), exports$1);
+		__exportStar(requireDeferred(), exports$1);
+		__exportStar(requireErrors(), exports$1);
+		__exportStar(requireFrames(), exports$1);
+		__exportStar(requireRSocket(), exports$1);
+		__exportStar(requireRSocketConnector(), exports$1);
+		__exportStar(requireRSocketServer(), exports$1);
+		__exportStar(requireTransport(), exports$1);
+		
+	} (dist));
+	return dist;
 }
 
+var distExports = requireDist();
+
+var version = "1.51.0";
+var PACKAGE = {
+	version: version};
+
 var WebsocketDuplexConnection = {};
 
 var hasRequiredWebsocketDuplexConnection;
@@ -13888,8 +13820,215 @@ class WebsocketClientTransport {
     }
 }
 
+const doneResult = { done: true, value: undefined };
+function valueResult(value) {
+    return { done: false, value };
+}
+/**
+ * A variant of {@link Array.map} for async iterators.
+ */
+function map(source, map) {
+    return {
+        next: async () => {
+            const value = await source.next();
+            if (value.done) {
+                return value;
+            }
+            else {
+                return { value: map(value.value) };
+            }
+        }
+    };
+}
+/**
+ * Expands a source async iterator by allowing to inject events asynchronously.
+ *
+ * The resulting iterator will emit all events from its source. Additionally though, events can be injected. These
+ * events are dropped once the main iterator completes, but are otherwise forwarded.
+ *
+ * The iterator completes when its source completes, and it supports backpressure by only calling `next()` on the source
+ * in response to a `next()` call from downstream if no pending injected events can be dispatched.
+ */
+function injectable(source) {
+    let sourceIsDone = false;
+    let waiter = undefined; // An active, waiting next() call.
+    // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
+    let pendingSourceEvent = null;
+    let pendingInjectedEvents = [];
+    const consumeWaiter = () => {
+        const pending = waiter;
+        waiter = undefined;
+        return pending;
+    };
+    const fetchFromSource = () => {
+        const resolveWaiter = (propagate) => {
+            const active = consumeWaiter();
+            if (active) {
+                propagate(active);
+            }
+            else {
+                pendingSourceEvent = propagate;
+            }
+        };
+        const nextFromSource = source.next();
+        nextFromSource.then((value) => {
+            sourceIsDone = value.done == true;
+            resolveWaiter((w) => w.resolve(value));
+        }, (error) => {
+            resolveWaiter((w) => w.reject(error));
+        });
+    };
+    return {
+        next: () => {
+            return new Promise((resolve, reject) => {
+                // First priority: Dispatch ready upstream events.
+                if (sourceIsDone) {
+                    return resolve(doneResult);
+                }
+                if (pendingSourceEvent) {
+                    pendingSourceEvent({ resolve, reject });
+                    pendingSourceEvent = null;
+                    return;
+                }
+                // Second priority: Dispatch injected events
+                if (pendingInjectedEvents.length) {
+                    return resolve(valueResult(pendingInjectedEvents.shift()));
+                }
+                // Nothing pending? Fetch from source
+                waiter = { resolve, reject };
+                return fetchFromSource();
+            });
+        },
+        inject: (event) => {
+            const pending = consumeWaiter();
+            if (pending != null) {
+                pending.resolve(valueResult(event));
+            }
+            else {
+                pendingInjectedEvents.push(event);
+            }
+        }
+    };
+}
+/**
+ * Splits a byte stream at line endings, emitting each line as a string.
+ */
+function extractJsonLines(source, decoder) {
+    let buffer = '';
+    const pendingLines = [];
+    let isFinalEvent = false;
+    return {
+        next: async () => {
+            while (true) {
+                if (isFinalEvent) {
+                    return doneResult;
+                }
+                {
+                    const first = pendingLines.shift();
+                    if (first) {
+                        return { done: false, value: first };
+                    }
+                }
+                const { done, value } = await source.next();
+                if (done) {
+                    const remaining = buffer.trim();
+                    if (remaining.length != 0) {
+                        isFinalEvent = true;
+                        return { done: false, value: remaining };
+                    }
+                    return doneResult;
+                }
+                const data = decoder.decode(value, { stream: true });
+                buffer += data;
+                const lines = buffer.split('\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const l = lines[i].trim();
+                    if (l.length > 0) {
+                        pendingLines.push(l);
+                    }
+                }
+                buffer = lines[lines.length - 1];
+            }
+        }
+    };
+}
+/**
+ * Splits a concatenated stream of BSON objects by emitting individual objects.
+ */
+function extractBsonObjects(source) {
+    // Fully read but not emitted yet.
+    const completedObjects = [];
+    // Whether source has returned { done: true }. We do the same once completed objects have been emitted.
+    let isDone = false;
+    const lengthBuffer = new DataView(new ArrayBuffer(4));
+    let objectBody = null;
+    // If we're parsing the length field, a number between 1 and 4 (inclusive) describing remaining bytes in the header.
+    // If we're consuming a document, the bytes remaining.
+    let remainingLength = 4;
+    return {
+        async next() {
+            while (true) {
+                // Before fetching new data from upstream, return completed objects.
+                if (completedObjects.length) {
+                    return valueResult(completedObjects.shift());
+                }
+                if (isDone) {
+                    return doneResult;
+                }
+                const upstreamEvent = await source.next();
+                if (upstreamEvent.done) {
+                    isDone = true;
+                    if (objectBody || remainingLength != 4) {
+                        throw new Error('illegal end of stream in BSON object');
+                    }
+                    return doneResult;
+                }
+                const chunk = upstreamEvent.value;
+                for (let i = 0; i < chunk.length;) {
+                    const availableInData = chunk.length - i;
+                    if (objectBody) {
+                        // We're in the middle of reading a BSON document.
+                        const bytesToRead = Math.min(availableInData, remainingLength);
+                        const copySource = new Uint8Array(chunk.buffer, chunk.byteOffset + i, bytesToRead);
+                        objectBody.set(copySource, objectBody.length - remainingLength);
+                        i += bytesToRead;
+                        remainingLength -= bytesToRead;
+                        if (remainingLength == 0) {
+                            completedObjects.push(objectBody);
+                            // Prepare to read another document, starting with its length
+                            objectBody = null;
+                            remainingLength = 4;
+                        }
+                    }
+                    else {
+                        // Copy up to 4 bytes into lengthBuffer, depending on how many we still need.
+                        const bytesToRead = Math.min(availableInData, remainingLength);
+                        for (let j = 0; j < bytesToRead; j++) {
+                            lengthBuffer.setUint8(4 - remainingLength + j, chunk[i + j]);
+                        }
+                        i += bytesToRead;
+                        remainingLength -= bytesToRead;
+                        if (remainingLength == 0) {
+                            // Transition from reading length header to reading document. Subtracting 4 because the length of the
+                            // header is included in length.
+                            const length = lengthBuffer.getInt32(0, true /* little endian */);
+                            remainingLength = length - 4;
+                            if (remainingLength < 1) {
+                                throw new Error(`invalid length for bson: ${length}`);
+                            }
+                            objectBody = new Uint8Array(length);
+                            new DataView(objectBody.buffer).setInt32(0, length, true);
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+
 const POWERSYNC_TRAILING_SLASH_MATCH = /\/+$/;
 const POWERSYNC_JS_VERSION = PACKAGE.version;
+const SYNC_QUEUE_REQUEST_HIGH_WATER = 10;
 const SYNC_QUEUE_REQUEST_LOW_WATER = 5;
 // Keep alive message is sent every period
 const KEEP_ALIVE_MS = 20_000;
@@ -14069,13 +14208,14 @@ class AbstractRemote {
         return new WebSocket(url);
     }
     /**
-     * Returns a data stream of sync line data.
+     * Returns a data stream of sync line data, fetched via RSocket-over-WebSocket.
+     *
+     * The only mechanism to abort the returned stream is to use the abort signal in {@link SocketSyncStreamOptions}.
      *
-     * @param map Maps received payload frames to the typed event value.
      * @param bson A BSON encoder and decoder. When set, the data stream will be requested with a BSON payload
      * (required for compatibility with older sync services).
      */
-    async socketStreamRaw(options, map, bson) {
+    async socketStreamRaw(options, bson) {
         const { path, fetchStrategy = FetchStrategy.Buffered } = options;
         const mimeType = bson == null ? 'application/json' : 'application/bson';
         function toBuffer(js) {
@@ -14090,52 +14230,55 @@ class AbstractRemote {
         }
         const syncQueueRequestSize = fetchStrategy == FetchStrategy.Buffered ? 10 : 1;
         const request = await this.buildRequest(path);
+        const url = this.options.socketUrlTransformer(request.url);
         // Add the user agent in the setup payload - we can't set custom
         // headers with websockets on web. The browser userAgent is however added
         // automatically as a header.
         const userAgent = this.getUserAgent();
-        const stream = new DataStream({
-            logger: this.logger,
-            pressure: {
-                lowWaterMark: SYNC_QUEUE_REQUEST_LOW_WATER
-            },
-            mapLine: map
-        });
+        // While we're connecting (a process that can't be aborted in RSocket), the WebSocket instance to close if we wanted
+        // to abort the connection.
+        let pendingSocket = null;
+        let keepAliveTimeout;
+        let rsocket = null;
+        let queue = null;
+        let didClose = false;
+        const abortRequest = () => {
+            if (didClose) {
+                return;
+            }
+            didClose = true;
+            clearTimeout(keepAliveTimeout);
+            if (pendingSocket) {
+                pendingSocket.close();
+            }
+            if (rsocket) {
+                rsocket.close();
+            }
+            if (queue) {
+                queue.stop();
+            }
+        };
         // Handle upstream abort
-        if (options.abortSignal?.aborted) {
+        if (options.abortSignal.aborted) {
             throw new AbortOperation('Connection request aborted');
         }
         else {
-            options.abortSignal?.addEventListener('abort', () => {
-                stream.close();
-            }, { once: true });
+            options.abortSignal.addEventListener('abort', abortRequest);
         }
-        let keepAliveTimeout;
         const resetTimeout = () => {
             clearTimeout(keepAliveTimeout);
             keepAliveTimeout = setTimeout(() => {
                 this.logger.error(`No data received on WebSocket in ${SOCKET_TIMEOUT_MS}ms, closing connection.`);
-                stream.close();
+                abortRequest();
             }, SOCKET_TIMEOUT_MS);
         };
         resetTimeout();
-        // Typescript complains about this being `never` if it's not assigned here.
-        // This is assigned in `wsCreator`.
-        let disposeSocketConnectionTimeout = () => { };
-        const url = this.options.socketUrlTransformer(request.url);
         const connector = new distExports.RSocketConnector({
             transport: new WebsocketClientTransport({
                 url,
                 wsCreator: (url) => {
-                    const socket = this.createSocket(url);
-                    disposeSocketConnectionTimeout = stream.registerListener({
-                        closed: () => {
-                            // Allow closing the underlying WebSocket if the stream was closed before the
-                            // RSocket connect completed. This should effectively abort the request.
-                            socket.close();
-                        }
-                    });
-                    socket.addEventListener('message', (event) => {
+                    const socket = (pendingSocket = this.createSocket(url));
+                    socket.addEventListener('message', () => {
                         resetTimeout();
                     });
                     return socket;
@@ -14155,43 +14298,40 @@ class AbstractRemote {
                 }
             }
         });
-        let rsocket;
         try {
             rsocket = await connector.connect();
             // The connection is established, we no longer need to monitor the initial timeout
-            disposeSocketConnectionTimeout();
+            pendingSocket = null;
         }
         catch (ex) {
             this.logger.error(`Failed to connect WebSocket`, ex);
-            clearTimeout(keepAliveTimeout);
-            if (!stream.closed) {
-                await stream.close();
-            }
+            abortRequest();
             throw ex;
         }
         resetTimeout();
-        let socketIsClosed = false;
-        const closeSocket = () => {
-            clearTimeout(keepAliveTimeout);
-            if (socketIsClosed) {
-                return;
-            }
-            socketIsClosed = true;
-            rsocket.close();
-        };
         // Helps to prevent double close scenarios
-        rsocket.onClose(() => (socketIsClosed = true));
-        // We initially request this amount and expect these to arrive eventually
-        let pendingEventsCount = syncQueueRequestSize;
-        const disposeClosedListener = stream.registerListener({
-            closed: () => {
-                closeSocket();
-                disposeClosedListener();
-            }
-        });
-        const socket = await new Promise((resolve, reject) => {
+        rsocket.onClose(() => (rsocket = null));
+        return await new Promise((resolve, reject) => {
             let connectionEstablished = false;
-            const res = rsocket.requestStream({
+            let pendingEventsCount = syncQueueRequestSize;
+            let paused = false;
+            let res = null;
+            function requestMore() {
+                const delta = syncQueueRequestSize - pendingEventsCount;
+                if (!paused && delta > 0) {
+                    res?.request(delta);
+                    pendingEventsCount = syncQueueRequestSize;
+                }
+            }
+            const events = new domExports.EventIterator((q) => {
+                queue = q;
+                q.on('highWater', () => (paused = true));
+                q.on('lowWater', () => {
+                    paused = false;
+                    requestMore();
+                });
+            }, { highWaterMark: SYNC_QUEUE_REQUEST_HIGH_WATER, lowWaterMark: SYNC_QUEUE_REQUEST_LOW_WATER })[symbolAsyncIterator]();
+            res = rsocket.requestStream({
                 data: toBuffer(options.data),
                 metadata: toBuffer({
                     path
@@ -14216,7 +14356,7 @@ class AbstractRemote {
                     }
                     // RSocket will close the RSocket stream automatically
                     // Close the downstream stream as well - this will close the RSocket connection and WebSocket
-                    stream.close();
+                    abortRequest();
                     // Handles cases where the connection failed e.g. auth error or connection error
                     if (!connectionEstablished) {
                         reject(e);
@@ -14226,41 +14366,40 @@ class AbstractRemote {
                     // The connection is active
                     if (!connectionEstablished) {
                         connectionEstablished = true;
-                        resolve(res);
+                        resolve(events);
                     }
                     const { data } = payload;
+                    if (data) {
+                        queue.push(data);
+                    }
                     // Less events are now pending
                     pendingEventsCount--;
-                    if (!data) {
-                        return;
-                    }
-                    stream.enqueueData(data);
+                    // Request another event (unless the downstream consumer is paused).
+                    requestMore();
                 },
                 onComplete: () => {
-                    stream.close();
+                    abortRequest(); // this will also emit a done event
                 },
                 onExtension: () => { }
             });
         });
-        const l = stream.registerListener({
-            lowWater: async () => {
-                // Request to fill up the queue
-                const required = syncQueueRequestSize - pendingEventsCount;
-                if (required > 0) {
-                    socket.request(syncQueueRequestSize - pendingEventsCount);
-                    pendingEventsCount = syncQueueRequestSize;
-                }
-            },
-            closed: () => {
-                l();
-            }
-        });
-        return stream;
     }
     /**
-     * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
+     * @returns Whether the HTTP implementation on this platform can receive streamed binary responses. This is true on
+     * all platforms except React Native (who would have guessed...), where we must not request BSON responses.
+     *
+     * @see https://github.com/react-native-community/fetch?tab=readme-ov-file#motivation
+     */
+    get supportsStreamingBinaryResponses() {
+        return true;
+    }
+    /**
+     * Posts a `/sync/stream` request, asserts that it completes successfully and returns the streaming response as an
+     * async iterator of byte blobs.
+     *
+     * To cancel the async iterator, use the abort signal from {@link SyncStreamOptions} passed to this method.
      */
-    async postStreamRaw(options, mapLine) {
+    async fetchStreamRaw(options) {
         const { data, path, headers, abortSignal } = options;
         const request = await this.buildRequest(path);
         /**
@@ -14272,119 +14411,94 @@ class AbstractRemote {
          *  Aborting the active fetch request while it is being consumed seems to throw
          *  an unhandled exception on the window level.
          */
-        if (abortSignal?.aborted) {
-            throw new AbortOperation('Abort request received before making postStreamRaw request');
+        if (abortSignal.aborted) {
+            throw new AbortOperation('Abort request received before making fetchStreamRaw request');
         }
         const controller = new AbortController();
-        let requestResolved = false;
-        abortSignal?.addEventListener('abort', () => {
-            if (!requestResolved) {
+        let reader = null;
+        abortSignal.addEventListener('abort', () => {
+            const reason = abortSignal.reason ??
+                new AbortOperation('Cancelling network request before it resolves. Abort signal has been received.');
+            if (reader == null) {
                 // Only abort via the abort controller if the request has not resolved yet
-                controller.abort(abortSignal.reason ??
-                    new AbortOperation('Cancelling network request before it resolves. Abort signal has been received.'));
+                controller.abort(reason);
+            }
+            else {
+                reader.cancel(reason).catch(() => {
+                    // Cancelling the reader might rethrow an exception we would have handled by throwing in next(). So we can
+                    // ignore it here.
+                });
             }
         });
-        const res = await this.fetch(request.url, {
-            method: 'POST',
-            headers: { ...headers, ...request.headers },
-            body: JSON.stringify(data),
-            signal: controller.signal,
-            cache: 'no-store',
-            ...(this.options.fetchOptions ?? {}),
-            ...options.fetchOptions
-        }).catch((ex) => {
+        let res;
+        let responseIsBson = false;
+        try {
+            const ndJson = 'application/x-ndjson';
+            const bson = 'application/vnd.powersync.bson-stream';
+            res = await this.fetch(request.url, {
+                method: 'POST',
+                headers: {
+                    ...headers,
+                    ...request.headers,
+                    accept: this.supportsStreamingBinaryResponses ? `${bson};q=0.9,${ndJson};q=0.8` : ndJson
+                },
+                body: JSON.stringify(data),
+                signal: controller.signal,
+                cache: 'no-store',
+                ...(this.options.fetchOptions ?? {}),
+                ...options.fetchOptions
+            });
+            if (!res.ok || !res.body) {
+                const text = await res.text();
+                this.logger.error(`Could not POST streaming to ${path} - ${res.status} - ${res.statusText}: ${text}`);
+                const error = new Error(`HTTP ${res.statusText}: ${text}`);
+                error.status = res.status;
+                throw error;
+            }
+            const contentType = res.headers.get('content-type');
+            responseIsBson = contentType == bson;
+        }
+        catch (ex) {
             if (ex.name == 'AbortError') {
                 throw new AbortOperation(`Pending fetch request to ${request.url} has been aborted.`);
             }
             throw ex;
-        });
-        if (!res) {
-            throw new Error('Fetch request was aborted');
         }
-        requestResolved = true;
-        if (!res.ok || !res.body) {
-            const text = await res.text();
-            this.logger.error(`Could not POST streaming to ${path} - ${res.status} - ${res.statusText}: ${text}`);
-            const error = new Error(`HTTP ${res.statusText}: ${text}`);
-            error.status = res.status;
-            throw error;
-        }
-        // Create a new stream splitting the response at line endings while also handling cancellations
-        // by closing the reader.
-        const reader = res.body.getReader();
-        let readerReleased = false;
-        // This will close the network request and read stream
-        const closeReader = async () => {
-            try {
-                readerReleased = true;
-                await reader.cancel();
-            }
-            catch (ex) {
-                // an error will throw if the reader hasn't been used yet
-            }
-            reader.releaseLock();
-        };
-        const stream = new DataStream({
-            logger: this.logger,
-            mapLine: mapLine,
-            pressure: {
-                highWaterMark: 20,
-                lowWaterMark: 10
-            }
-        });
-        abortSignal?.addEventListener('abort', () => {
-            closeReader();
-            stream.close();
-        });
-        const decoder = this.createTextDecoder();
-        let buffer = '';
-        const consumeStream = async () => {
-            while (!stream.closed && !abortSignal?.aborted && !readerReleased) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    const remaining = buffer.trim();
-                    if (remaining.length != 0) {
-                        stream.enqueueData(remaining);
-                    }
-                    stream.close();
-                    await closeReader();
-                    return;
+        reader = res.body.getReader();
+        const stream = {
+            next: async () => {
+                if (controller.signal.aborted) {
+                    return doneResult;
                 }
-                const data = decoder.decode(value, { stream: true });
-                buffer += data;
-                const lines = buffer.split('\n');
-                for (var i = 0; i < lines.length - 1; i++) {
-                    var l = lines[i].trim();
-                    if (l.length > 0) {
-                        stream.enqueueData(l);
-                    }
+                try {
+                    return await reader.read();
                 }
-                buffer = lines[lines.length - 1];
-                // Implement backpressure by waiting for the low water mark to be reached
-                if (stream.dataQueue.length > stream.highWatermark) {
-                    await new Promise((resolve) => {
-                        const dispose = stream.registerListener({
-                            lowWater: async () => {
-                                resolve();
-                                dispose();
-                            },
-                            closed: () => {
-                                resolve();
-                                dispose();
-                            }
-                        });
-                    });
+                catch (ex) {
+                    if (controller.signal.aborted) {
+                        // .read() completes with an error if we cancel the reader, which we do to disconnect. So this is just
+                        // things working as intended, we can return a done event and consider the exception handled.
+                        return doneResult;
+                    }
+                    throw ex;
                 }
             }
         };
-        consumeStream().catch(ex => this.logger.error('Error consuming stream', ex));
-        const l = stream.registerListener({
-            closed: () => {
-                closeReader();
-                l?.();
-            }
-        });
-        return stream;
+        return { isBson: responseIsBson, stream };
+    }
+    /**
+     * Posts a `/sync/stream` request.
+     *
+     * Depending on the `Content-Type` of the response, this returns strings for sync lines or encoded BSON documents as
+     * {@link Uint8Array}s.
+     */
+    async fetchStream(options) {
+        const { isBson, stream } = await this.fetchStreamRaw(options);
+        if (isBson) {
+            return extractBsonObjects(stream);
+        }
+        else {
+            return extractJsonLines(stream, this.createTextDecoder());
+        }
     }
 }
 
@@ -14892,6 +15006,19 @@ The next upload iteration will be delayed.`);
             }
         });
     }
+    async receiveSyncLines(data) {
+        const { options, connection, bson } = data;
+        const remote = this.options.remote;
+        if (connection.connectionMethod == SyncStreamConnectionMethod.HTTP) {
+            return await remote.fetchStream(options);
+        }
+        else {
+            return await this.options.remote.socketStreamRaw({
+                ...options,
+                ...{ fetchStrategy: connection.fetchStrategy }
+            }, bson);
+        }
+    }
     async legacyStreamingSyncIteration(signal, resolvedOptions) {
         const rawTables = resolvedOptions.serializedSchema?.raw_tables;
         if (rawTables != null && rawTables.length) {
@@ -14921,42 +15048,27 @@ The next upload iteration will be delayed.`);
                 client_id: clientId
             }
         };
-        let stream;
-        if (resolvedOptions?.connectionMethod == SyncStreamConnectionMethod.HTTP) {
-            stream = await this.options.remote.postStreamRaw(syncOptions, (line) => {
-                if (typeof line == 'string') {
-                    return JSON.parse(line);
-                }
-                else {
-                    // Directly enqueued by us
-                    return line;
-                }
-            });
-        }
-        else {
-            const bson = await this.options.remote.getBSON();
-            stream = await this.options.remote.socketStreamRaw({
-                ...syncOptions,
-                ...{ fetchStrategy: resolvedOptions.fetchStrategy }
-            }, (payload) => {
-                if (payload instanceof Uint8Array) {
-                    return bson.deserialize(payload);
-                }
-                else {
-                    // Directly enqueued by us
-                    return payload;
-                }
-            }, bson);
-        }
+        const bson = await this.options.remote.getBSON();
+        const source = await this.receiveSyncLines({
+            options: syncOptions,
+            connection: resolvedOptions,
+            bson
+        });
+        const stream = injectable(map(source, (line) => {
+            if (typeof line == 'string') {
+                return JSON.parse(line);
+            }
+            else {
+                return bson.deserialize(line);
+            }
+        }));
         this.logger.debug('Stream established. Processing events');
         this.notifyCompletedUploads = () => {
-            if (!stream.closed) {
-                stream.enqueueData({ crud_upload_completed: null });
-            }
+            stream.inject({ crud_upload_completed: null });
         };
-        while (!stream.closed) {
-            const line = await stream.read();
-            if (!line) {
+        while (true) {
+            const { value: line, done } = await stream.next();
+            if (done) {
                 // The stream has closed while waiting
                 return;
             }
@@ -15135,14 +15247,17 @@ The next upload iteration will be delayed.`);
         const syncImplementation = this;
         const adapter = this.options.adapter;
         const remote = this.options.remote;
+        const controller = new AbortController();
+        const abort = () => {
+            return controller.abort(signal.reason);
+        };
+        signal.addEventListener('abort', abort);
         let receivingLines = null;
         let hadSyncLine = false;
         let hideDisconnectOnRestart = false;
         if (signal.aborted) {
             throw new AbortOperation('Connection request has been aborted');
         }
-        const abortController = new AbortController();
-        signal.addEventListener('abort', () => abortController.abort());
         // Pending sync lines received from the service, as well as local events that trigger a powersync_control
         // invocation (local events include refreshed tokens and completed uploads).
         // This is a single data stream so that we can handle all control calls from a single place.
@@ -15150,49 +15265,36 @@ The next upload iteration will be delayed.`);
         async function connect(instr) {
             const syncOptions = {
                 path: '/sync/stream',
-                abortSignal: abortController.signal,
+                abortSignal: controller.signal,
                 data: instr.request
             };
-            if (resolvedOptions.connectionMethod == SyncStreamConnectionMethod.HTTP) {
-                controlInvocations = await remote.postStreamRaw(syncOptions, (line) => {
-                    if (typeof line == 'string') {
-                        return {
-                            command: PowerSyncControlCommand.PROCESS_TEXT_LINE,
-                            payload: line
-                        };
-                    }
-                    else {
-                        // Directly enqueued by us
-                        return line;
-                    }
-                });
-            }
-            else {
-                controlInvocations = await remote.socketStreamRaw({
-                    ...syncOptions,
-                    fetchStrategy: resolvedOptions.fetchStrategy
-                }, (payload) => {
-                    if (payload instanceof Uint8Array) {
-                        return {
-                            command: PowerSyncControlCommand.PROCESS_BSON_LINE,
-                            payload: payload
-                        };
-                    }
-                    else {
-                        // Directly enqueued by us
-                        return payload;
-                    }
-                });
-            }
+            controlInvocations = injectable(map(await syncImplementation.receiveSyncLines({
+                options: syncOptions,
+                connection: resolvedOptions
+            }), (line) => {
+                if (typeof line == 'string') {
+                    return {
+                        command: PowerSyncControlCommand.PROCESS_TEXT_LINE,
+                        payload: line
+                    };
+                }
+                else {
+                    return {
+                        command: PowerSyncControlCommand.PROCESS_BSON_LINE,
+                        payload: line
+                    };
+                }
+            }));
             // The rust client will set connected: true after the first sync line because that's when it gets invoked, but
             // we're already connected here and can report that.
             syncImplementation.updateSyncStatus({ connected: true });
             try {
-                while (!controlInvocations.closed) {
-                    const line = await controlInvocations.read();
-                    if (line == null) {
-                        return;
+                while (true) {
+                    let event = await controlInvocations.next();
+                    if (event.done) {
+                        break;
                     }
+                    const line = event.value;
                     await control(line.command, line.payload);
                     if (!hadSyncLine) {
                         syncImplementation.triggerCrudUpload();
@@ -15201,12 +15303,8 @@ The next upload iteration will be delayed.`);
                 }
             }
             finally {
-                const activeInstructions = controlInvocations;
-                // We concurrently add events to the active data stream when e.g. a CRUD upload is completed or a token is
-                // refreshed. That would throw after closing (and we can't handle those events either way), so set this back
-                // to null.
-                controlInvocations = null;
-                await activeInstructions.close();
+                abort();
+                signal.removeEventListener('abort', abort);
             }
         }
         async function stop() {
@@ -15250,14 +15348,14 @@ The next upload iteration will be delayed.`);
                     remote.invalidateCredentials();
                     // Restart iteration after the credentials have been refreshed.
                     remote.fetchCredentials().then((_) => {
-                        controlInvocations?.enqueueData({ command: PowerSyncControlCommand.NOTIFY_TOKEN_REFRESHED });
+                        controlInvocations?.inject({ command: PowerSyncControlCommand.NOTIFY_TOKEN_REFRESHED });
                     }, (err) => {
                         syncImplementation.logger.warn('Could not prefetch credentials', err);
                     });
                 }
             }
             else if ('CloseSyncStream' in instruction) {
-                abortController.abort();
+                controller.abort();
                 hideDisconnectOnRestart = instruction.CloseSyncStream.hide_disconnect;
             }
             else if ('FlushFileSystem' in instruction) ;
@@ -15286,17 +15384,13 @@ The next upload iteration will be delayed.`);
             }
             await control(PowerSyncControlCommand.START, JSON.stringify(options));
             this.notifyCompletedUploads = () => {
-                if (controlInvocations && !controlInvocations?.closed) {
-                    controlInvocations.enqueueData({ command: PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
-                }
+                controlInvocations?.inject({ command: PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
             };
             this.handleActiveStreamsChange = () => {
-                if (controlInvocations && !controlInvocations?.closed) {
-                    controlInvocations.enqueueData({
-                        command: PowerSyncControlCommand.UPDATE_SUBSCRIPTIONS,
-                        payload: JSON.stringify(this.activeStreams)
-                    });
-                }
+                controlInvocations?.inject({
+                    command: PowerSyncControlCommand.UPDATE_SUBSCRIPTIONS,
+                    payload: JSON.stringify(this.activeStreams)
+                });
             };
             await receivingLines;
         }
@@ -15947,7 +16041,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),
@@ -16412,6 +16506,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
@@ -16508,7 +16606,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 });
@@ -17664,9 +17762,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()).
  */
@@ -17674,67 +17770,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();
 });
 
 })();