@powersync/web 0.0.0-dev-20260708104358 → 0.0.0-dev-20260917074240

package/dist/index.react_native_web.js

@@ -0,0 +1,2095 @@
+import { DBAdapter, LockContext, LogLevels, queryResultWithoutRows, BaseObserver } from '@powersync/common';
+export * from '@powersync/common';
+import * as Comlink from 'comlink';
+import { Mutex, ConnectionClosedError, Semaphore, LockType, AbstractRemote, AbstractStreamingSyncImplementation, BasePowerSyncDatabase, openDatabase } from '@powersync/shared-internals';
+import { Factory, SQLITE_ROW } from '@journeyapps/wa-sqlite';
+
+/**
+ * IndexDBFileSystemStorageAdapter implements LocalStorageAdapter using IndexedDB.
+ * Suitable for web browsers and web-based environments.
+ */
+class IndexDBFileSystemStorageAdapter {
+    databaseName;
+    dbPromise;
+    constructor(databaseName = 'PowerSyncFiles') {
+        this.databaseName = databaseName;
+    }
+    async initialize() {
+        this.dbPromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.databaseName, 1);
+            request.onupgradeneeded = () => {
+                request.result.createObjectStore('files');
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async clear() {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('files', 'readwrite');
+            const store = tx.objectStore('files');
+            const req = store.clear();
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    getLocalUri(filename) {
+        return `indexeddb://${this.databaseName}/files/${filename}`;
+    }
+    async getStore(mode = 'readonly') {
+        const db = await this.dbPromise;
+        const tx = db.transaction('files', mode);
+        return tx.objectStore('files');
+    }
+    async saveFile(filePath, data) {
+        const store = await this.getStore('readwrite');
+        let dataToStore;
+        let size;
+        if (typeof data === 'string') {
+            const binaryString = atob(data);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            dataToStore = bytes.buffer;
+            size = bytes.byteLength;
+        }
+        else {
+            dataToStore = data;
+            size = dataToStore.byteLength;
+        }
+        return await new Promise((resolve, reject) => {
+            const req = store.put(dataToStore, filePath);
+            req.onsuccess = () => resolve(size);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async readFile(fileUri, options) {
+        const store = await this.getStore();
+        return new Promise((resolve, reject) => {
+            const req = store.get(fileUri);
+            req.onsuccess = async () => {
+                if (!req.result) {
+                    reject(new Error('File not found'));
+                    return;
+                }
+                resolve(req.result);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async deleteFile(uri, options) {
+        const store = await this.getStore('readwrite');
+        await new Promise((resolve, reject) => {
+            const req = store.delete(uri);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async fileExists(fileUri) {
+        const store = await this.getStore();
+        return new Promise((resolve, reject) => {
+            const req = store.get(fileUri);
+            req.onsuccess = () => resolve(!!req.result);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async makeDir(path) {
+        // No-op for IndexedDB as it does not have a directory structure
+    }
+    async rmDir(path) {
+        const store = await this.getStore('readwrite');
+        const range = IDBKeyRange.bound(path + '/', path + '/\uffff', false, false);
+        await new Promise((resolve, reject) => {
+            const req = store.delete(range);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+}
+
+/**
+ * List of currently tested virtual filesystems
+ */
+var WASQLiteVFS;
+(function (WASQLiteVFS) {
+    WASQLiteVFS["IDBBatchAtomicVFS"] = "IDBBatchAtomicVFS";
+    WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
+    WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
+    WASQLiteVFS["OPFSWriteAheadVFS"] = "OPFSWriteAheadVFS";
+    /**
+     * A virtual file system storing data in-memory only, without persistence.
+     *
+     * This file system can be used in three configurations:
+     *
+     * 1. In shared workers (the default when available): All tabs share the same in-memory database, which is cleared
+     *    once the last tab is closed.
+     * 2. In dedicated workers (used when `enableMultiTabs` is disabled). Each tab has its own in-memory database cleared
+     *    when the tab is closed. Queries are offloaded to a dedicated worker.
+     * 3. In the context of the tab itself (used when both `enableMultiTabs` and `useWebWorker` are disabled). The per-tab
+     *    database is hosted in the tab itself, and queries run synchronously. This is _a lot_ faster than any other
+     *    single-threadedVFS, but can block JavaScript for computationally-intensive queries.
+     *
+     * This VFS primarily intended for development, but it also useful for online-first deployments not syncing large
+     * amounts of data, as it is quicker to start up.
+     */
+    WASQLiteVFS["InMemoryVfs"] = "InMemoryVFS";
+})(WASQLiteVFS || (WASQLiteVFS = {}));
+function vfsRequiresDedicatedWorkers(vfs) {
+    return vfs != WASQLiteVFS.IDBBatchAtomicVFS && vfs != WASQLiteVFS.InMemoryVfs;
+}
+async function asyncModuleFactory(encryptionKey) {
+    if (encryptionKey) {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
+        return factory();
+    }
+    else {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
+        return factory();
+    }
+}
+async function syncModuleFactory(encryptionKey) {
+    if (encryptionKey) {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
+        return factory();
+    }
+    else {
+        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
+        return factory();
+    }
+}
+/**
+ * @internal
+ */
+async function loadModuleAndVfs({ vfs, filename, encryptionKey }) {
+    let moduleFactory = syncModuleFactory;
+    let resolveVfs;
+    switch (vfs) {
+        case WASQLiteVFS.IDBBatchAtomicVFS: {
+            moduleFactory = asyncModuleFactory;
+            const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
+            resolveVfs = (module) => {
+                // @ts-expect-error The types for this static method are missing upstream
+                return IDBBatchAtomicVFS.create(filename, module, { lockPolicy: 'exclusive' });
+            };
+            break;
+        }
+        case WASQLiteVFS.AccessHandlePoolVFS: {
+            // @ts-expect-error The types for this import are missing upstream
+            const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
+            resolveVfs = (module) => AccessHandlePoolVFS.create(filename, module);
+            break;
+        }
+        case WASQLiteVFS.OPFSCoopSyncVFS: {
+            // @ts-expect-error The types for this import are missing upstream
+            const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
+            resolveVfs = (module) => OPFSCoopSyncVFS.create(filename, module);
+            break;
+        }
+        case WASQLiteVFS.OPFSWriteAheadVFS: {
+            // @ts-expect-error The types for this import are missing upstream
+            const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
+            resolveVfs = (module) => OPFSWriteAheadVFS.create(filename, module, {});
+            break;
+        }
+        case WASQLiteVFS.InMemoryVfs: {
+            const { MemoryVFS } = await import('@journeyapps/wa-sqlite/src/examples/MemoryVFS.js');
+            // @ts-expect-error The types for this static method are missing upstream
+            resolveVfs = (module) => MemoryVFS.create(filename, module);
+            break;
+        }
+    }
+    const module = await moduleFactory(encryptionKey);
+    return { module, vfs: await resolveVfs(module) };
+}
+
+const MOCK_QUERY_RESPONSE = {
+    rowsAffected: 0,
+    columnNames: [],
+    rawRows: []
+};
+/**
+ * Implements a Mock DB adapter for use in Server Side Rendering (SSR).
+ * This adapter will return empty results for queries, which will allow
+ * server rendered views to initially generate scaffolding components
+ */
+class SSRDBAdapter extends DBAdapter {
+    name;
+    readMutex;
+    writeMutex;
+    constructor() {
+        super();
+        this.name = 'SSR DB';
+        this.readMutex = new Mutex();
+        this.writeMutex = new Mutex();
+    }
+    close() { }
+    async readLock(fn, options) {
+        return fn(new StubLockContext());
+    }
+    async writeLock(fn, options) {
+        return fn(new StubLockContext());
+    }
+    async refreshSchema() { }
+}
+class StubLockContext extends LockContext {
+    async executeRaw() {
+        return MOCK_QUERY_RESPONSE;
+    }
+}
+
+/**
+ * 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.filename}-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.log({ level: LogLevels.debug, message: `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.log({
+                        level: LogLevels.debug,
+                        message: '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();
+                const lease = await this.#inner.acquireConnection(timeoutMs != null ? AbortSignal.timeout(timeoutMs) : undefined);
+                if (!isOpen) {
+                    // Race between requestAccess and close(), the connection was closed while we tried to acquire a lease.
+                    await lease.returnLease();
+                    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 { rawRows } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
+                        if (rawRows.length) {
+                            const updatedTables = JSON.parse(rawRows[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.log({
+            level: LogLevels.debug,
+            message: `Closing connection to ${JSON.stringify(this.#inner.options)}.`
+        });
+        const connection = this.#inner;
+        this.#options.onClose();
+        this.#updateBroadcastChannel.close();
+        await connection.close();
+    }
+}
+
+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.');
+};
+
+var TemporaryStorageOption;
+(function (TemporaryStorageOption) {
+    TemporaryStorageOption["MEMORY"] = "memory";
+    TemporaryStorageOption["FILESYSTEM"] = "file";
+})(TemporaryStorageOption || (TemporaryStorageOption = {}));
+
+/**
+ * The maximum length of a db filename we support.
+ *
+ * We configure the same on WA-SQLite (which otherwise defaults to a maximum length of 64). We don't want to support
+ * very long path names as Safari maps OPFS files directly to OS files, and APFS has a 255-byte filename limit. Since
+ * some VFS append additional characters for pooled file access handles, we want to stay well below that.
+ */
+const maxPathNameLength = 128;
+/**
+ * @internal
+ */
+function resolveAndValidateOptions(options) {
+    const defaults = {
+        disableSSRWarning: false,
+        ssrMode: !('window' in globalThis),
+        /**
+         * Multiple tabs are by default not supported on Android, iOS and Safari.
+         * Other platforms will have multiple tabs enabled by default.
+         */
+        enableMultiTabs: typeof globalThis.navigator !== 'undefined' && // For SSR purposes
+            typeof SharedWorker !== 'undefined' &&
+            !navigator.userAgent.match(/(Android|iPhone|iPod|iPad)/i) &&
+            !window.safari,
+        useWebWorker: true,
+        databaseWorkerLogLevel: LogLevels.info,
+        temporaryStorage: TemporaryStorageOption.MEMORY,
+        cacheSizeKb: 50 * 1024,
+        encryptionKey: undefined,
+        vfs: WASQLiteVFS.IDBBatchAtomicVFS,
+        additionalReaders: 1
+    };
+    const resolved = Object.assign(defaults, options);
+    if (vfsRequiresDedicatedWorkers(resolved.vfs) && !resolved.useWebWorker) {
+        throw new Error(`Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${resolved.vfs}).`);
+    }
+    return resolved;
+}
+
+class PreparedStatementCache {
+    #size;
+    // Note that Map preserves insertion order, which allows using it as an LRU
+    // cache (with the first element being the first element to evict).
+    #statements = new Map();
+    constructor(size) {
+        this.#size = size;
+    }
+    /**
+     * Attempts to look up the cached sql statement, if it's currently cached.
+     */
+    lookup(sql) {
+        const foundStatement = this.#statements.get(sql);
+        if (foundStatement != null) {
+            // Delete and re-insert to move to the end (most-recently-used position).
+            this.#statements.delete(sql);
+            this.#statements.set(sql, foundStatement);
+            return foundStatement;
+        }
+        return null;
+    }
+    /**
+     * Adds a new statement into the cache.
+     *
+     * If that exceeds the target size of the statement cache, returns an old statement to evict.
+     * The caller is responsible for freeing that statement.
+     */
+    addStatement(sql, statement) {
+        this.#statements.set(sql, statement);
+        if (this.#statements.size > this.#size) {
+            for (const [k, v] of this.#statements.entries()) {
+                this.#statements.delete(k);
+                return v;
+            }
+        }
+        return null;
+    }
+    drain() {
+        const values = [...this.#statements.values()];
+        this.#statements.clear();
+        return values;
+    }
+}
+
+/**
+ * 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;
+    sqlite3_stmt_isexplain;
+    /**
+     * The `sqlite3*` connection pointer.
+     */
+    db = 0;
+    statementCache;
+    constructor(options) {
+        this.options = options;
+        this.statementCache =
+            options.preparedStatementsCache > 0 ? new PreparedStatementCache(options.preparedStatementsCache) : null;
+    }
+    get isOpen() {
+        return this.db != 0;
+    }
+    async init() {
+        const { module, vfs } = await loadModuleAndVfs(this.options);
+        await this.initWithModule(module, vfs);
+    }
+    async initWithModule(module, vfs) {
+        const api = (this._sqliteAPI = await this.openSQLiteAPI(module, vfs));
+        this.db = await api.open_v2(this.options.filename, this.options.readonly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */);
+        await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
+        if (this.options.encryptionKey) {
+            const escapedKey = this.options.encryptionKey.replaceAll("'", "''");
+            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(module, vfs) {
+        vfs.mxPathname = maxPathNameLength;
+        this.sqlite3_stmt_isexplain = module.cwrap('sqlite3_stmt_isexplain', 'int', ['int']);
+        const sqlite3 = Factory(module);
+        sqlite3.vfs_register(vfs, true);
+        /**
+         * Register the PowerSync core SQLite extension
+         */
+        module.ccall('powersync_init_static', 'int', []);
+        /**
+         * Create the multiple cipher vfs if an encryption key is provided
+         */
+        if (this.options.encryptionKey) {
+            const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.filename, 1]);
+            if (createResult !== 0) {
+                throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
+            }
+        }
+        return sqlite3;
+    }
+    requireSqlite() {
+        if (!this._sqliteAPI) {
+            throw new Error(`Initialization has not completed`);
+        }
+        return this._sqliteAPI;
+    }
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    isAutoCommit() {
+        return this.requireSqlite().get_autocommit(this.db) != 0;
+    }
+    async execute(sql, bindings) {
+        const resultSet = await this.executeSingleStatementRaw(sql, bindings);
+        return this.wrapQueryResults(this.requireSqlite(), resultSet);
+    }
+    async executeBatch(sql, bindings) {
+        const results = [];
+        const api = this.requireSqlite();
+        for await (const stmt of api.statements(this.db, sql)) {
+            let columns;
+            for (const parameterSet of bindings) {
+                const rs = await this.stepThroughStatement(api, stmt, parameterSet, columns, false);
+                results.push(this.wrapQueryResults(api, rs));
+            }
+            // executeBatch can only use a single statement
+            break;
+        }
+        return results;
+    }
+    wrapQueryResults(api, { rawRows, columnNames }) {
+        return {
+            rowsAffected: api.changes(this.db),
+            insertId: api.last_insert_id(this.db),
+            autocommit: api.get_autocommit(this.db) != 0,
+            rawRows,
+            columnNames
+        };
+    }
+    /**
+     * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
+     */
+    async executeSingleStatementRaw(sql, bindings) {
+        const results = await this.executeRaw(sql, bindings);
+        return results.length ? results[0] : { columnNames: [], rawRows: [] };
+    }
+    async executeRaw(sql, bindings) {
+        const results = [];
+        const api = this.requireSqlite();
+        for await (const stmt of this.cachedStatements(api, sql)) {
+            let columns;
+            const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
+            columns = rs.columnNames;
+            if (columns.length) {
+                results.push(rs);
+            }
+            // When binding parameters, only a single statement is executed.
+            if (bindings) {
+                break;
+            }
+        }
+        return results;
+    }
+    async stepThroughStatement(api, stmt, bindings, knownColumns, includeResults = true) {
+        // TODO not sure why this is needed currently, but booleans break
+        bindings.forEach((b, index, arr) => {
+            if (typeof b == 'boolean') {
+                arr[index] = b ? 1 : 0;
+            }
+        });
+        api.reset(stmt);
+        if (bindings) {
+            api.bind_collection(stmt, bindings);
+        }
+        const rows = [];
+        while ((await api.step(stmt)) === SQLITE_ROW) {
+            if (includeResults) {
+                const row = api.row(stmt);
+                rows.push(row);
+            }
+        }
+        knownColumns ??= api.column_names(stmt);
+        return { columnNames: knownColumns, rawRows: rows };
+    }
+    async close() {
+        if (this.isOpen) {
+            const api = this.requireSqlite();
+            if (this.statementCache) {
+                for (const stmt of this.statementCache.drain()) {
+                    await api.finalize(stmt);
+                }
+            }
+            await api.close(this.db);
+            this.db = 0;
+        }
+    }
+    async *cachedStatements(api, sql) {
+        {
+            const existing = this.statementCache?.lookup(sql);
+            if (existing != null) {
+                yield existing;
+                return;
+            }
+        }
+        const inner = api.statements(this.db, sql, { unscoped: true });
+        const preparedStatements = [];
+        try {
+            for await (const stmt of inner) {
+                preparedStatements.push(stmt);
+                yield stmt;
+            }
+        }
+        finally {
+            // We can only cache statements if the sql text corresponds to a single statement, otherwise it's not clear what
+            // portion of the original sql text to use as a key.
+            if (preparedStatements.length === 1 && this.statementCache) {
+                const stmt = preparedStatements[0];
+                // Don't cache EXPLAIN statements, their result becomes invalid after schema changes.
+                if (this.sqlite3_stmt_isexplain(stmt) == 0) {
+                    const evicted = this.statementCache.addStatement(sql, stmt);
+                    if (evicted != null) {
+                        await api.finalize(evicted);
+                    }
+                    return;
+                }
+            }
+            // We're not caching statements, so finalize them.
+            for (const stmt of preparedStatements) {
+                await api.finalize(stmt);
+            }
+        }
+    }
+}
+
+/**
+ * A wrapper around a {@link RawSqliteConnection} allowing multiple tabs to access it.
+ *
+ * To allow potentially concurrent accesses from different clients, this requires a local mutex implementation here.
+ *
+ * Note that instances of this class are not safe to proxy across context boundaries with comlink! We need to be able to
+ * rely on mutexes being returned reliably, so additional checks to detect say a client tab closing are required to
+ * avoid deadlocks.
+ */
+class ConcurrentSqliteConnection {
+    inner;
+    /**
+     * An outer mutex ensuring at most one {@link ConnectionLeaseToken} can exist for this connection at a time.
+     *
+     * If null, we'll use navigator locks instead.
+     */
+    leaseMutex;
+    /**
+     * @param needsNavigatorLocks Whether access to the database needs an additional navigator lock guard.
+     *
+     * While {@link ConcurrentSqliteConnection} prevents concurrent access to a database _connection_, it's possible we
+     * might have multiple connections to the same physical database (e.g. if multiple tabs use dedicated workers).
+     * In those setups, we use navigator locks instead of an internal mutex to guard access..
+     */
+    constructor(inner, needsNavigatorLocks) {
+        this.inner = inner;
+        this.leaseMutex = needsNavigatorLocks ? null : new Mutex();
+    }
+    get options() {
+        return this.inner.options;
+    }
+    acquireMutex(abort) {
+        if (this.leaseMutex) {
+            return this.leaseMutex.acquire(abort);
+        }
+        return new Promise((resolve, reject) => {
+            const options = { signal: abort };
+            navigator.locks
+                .request(`db-lock-${this.options.filename}`, options, (_) => {
+                return new Promise((returnLock) => {
+                    return resolve(() => {
+                        returnLock();
+                    });
+                });
+            })
+                .catch(reject);
+        });
+    }
+    // Unsafe, unguarded access to the SQLite connection.
+    unsafeUseInner() {
+        return this.inner;
+    }
+    /**
+     * @returns A {@link ConnectionLeaseToken}. Until that token is returned, no other client can use the database.
+     */
+    async acquireConnection(abort) {
+        const returnMutex = await this.acquireMutex(abort);
+        const token = new ConnectionLeaseToken(returnMutex, this.inner);
+        try {
+            // Assert that the inner connection is initialized at this point, fail early if it's not.
+            this.inner.requireSqlite();
+            // If a previous client was interrupted in the middle of a transaction AND this is a shared worker, it's possible
+            // for the connection to still be in a transaction. To avoid inconsistent state, we roll back connection leases
+            // that haven't been comitted.
+            if (!this.inner.isAutoCommit()) {
+                await this.inner.executeRaw('ROLLBACK');
+            }
+        }
+        catch (e) {
+            returnMutex();
+            throw e;
+        }
+        return token;
+    }
+    async close() {
+        const returnMutex = await this.acquireMutex();
+        try {
+            await this.inner.close();
+        }
+        finally {
+            returnMutex();
+        }
+    }
+}
+/**
+ * An instance representing temporary exclusive access to a {@link ConcurrentSqliteConnection}.
+ */
+class ConnectionLeaseToken {
+    returnMutex;
+    connection;
+    /** Ensures that the client with access to this token can't run statements concurrently. */
+    useMutex = new Mutex();
+    closed = false;
+    constructor(returnMutex, connection) {
+        this.returnMutex = returnMutex;
+        this.connection = connection;
+    }
+    /**
+     * Returns this lease, allowing another client to use the database connection.
+     */
+    async returnLease() {
+        await this.useMutex.runExclusive(async () => {
+            if (!this.closed) {
+                this.closed = true;
+                this.returnMutex();
+            }
+        });
+    }
+    /**
+     * This should only be used internally, since the callback must not use the raw connection after resolving.
+     */
+    async use(callback) {
+        return await this.useMutex.runExclusive(async () => {
+            if (this.closed) {
+                throw new Error('lease token has already been closed');
+            }
+            return await callback(this.connection);
+        });
+    }
+}
+
+const OPEN_DB_LOCK = 'open-wasqlite-db';
+/**
+ * Shared state to manage multiple database connections hosted by a worker.
+ */
+class MultiDatabaseServer {
+    logger;
+    #activeDatabases = new Map();
+    #localOpenLock = new Mutex();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async handleConnection({ logLevel, database, lockName }) {
+        const logger = {
+            log: (record) => {
+                if (record.level >= logLevel)
+                    this.logger.log(record);
+            }
+        };
+        return Comlink.proxy(await this.openConnectionLocally(logger, database, lockName));
+    }
+    async connectToExisting(name, lockName) {
+        return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
+            const server = this.#activeDatabases.get(name);
+            if (server == null) {
+                throw new Error(`connectToExisting(${name}) failed because the worker doesn't own a database with that name.`);
+            }
+            return Comlink.proxy(await server.connect(lockName));
+        });
+    }
+    async openConnectionLocally(logger, 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(logger, options);
+            }
+            catch (error) {
+                this.logger.log({
+                    level: LogLevels.warn,
+                    message: `Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`,
+                    error
+                });
+                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(logger, options);
+        return server.connect(lockName);
+    }
+    async #databaseOpenAttempt(logger, options) {
+        const { filename, readonly, vfs } = options;
+        // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
+        // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
+        // fine). In-memory databases either run in a shared worker or aren't shared across tabs at all, so the internal
+        // lock is enough.
+        const needsNavigatorLocks = !(isSharedWorker$1 || readonly || vfs == WASQLiteVFS.InMemoryVfs);
+        const activeDatabases = this.#activeDatabases;
+        async function openDatabase() {
+            let server = activeDatabases.get(filename);
+            if (server == null) {
+                const connection = new RawSqliteConnection(options);
+                const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
+                // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want
+                // to do that in an exclusive lock. Note that OPEN_DB_LOCK is not enough for that, as another tab might have
+                // already created a connection (and is thus outside of OPEN_DB_LOCK) while currently writing to it.
+                const returnLease = await withSafeConcurrency.acquireMutex();
+                try {
+                    await connection.init();
+                }
+                catch (e) {
+                    returnLease();
+                    await connection.close();
+                    throw e;
+                }
+                returnLease();
+                const onClose = () => activeDatabases.delete(filename);
+                server = new DatabaseServer({
+                    inner: withSafeConcurrency,
+                    logger,
+                    onClose
+                });
+                activeDatabases.set(filename, server);
+            }
+            return server;
+        }
+        if (needsNavigatorLocks) {
+            return getNavigatorLocks().request(OPEN_DB_LOCK, openDatabase);
+        }
+        else {
+            // Even if we don't need navigator locks, this avoids a race between the activeDatabases.get() call, the async
+            // open logic and the final activeDatabases.set() step.
+            return this.#localOpenLock.runExclusive(openDatabase);
+        }
+    }
+    closeAll() {
+        const existingDatabases = [...this.#activeDatabases.values()];
+        return Promise.all(existingDatabases.map((db) => {
+            db.forceClose();
+        }));
+    }
+}
+const isSharedWorker$1 = 'SharedWorkerGlobalScope' in globalThis;
+
+/**
+ * A single-connection {@link ConnectionPool} implementation based on a worker connection.
+ */
+class DatabaseClient extends DBAdapter {
+    options;
+    config;
+    #connection;
+    #shareConnectionAbortController = new AbortController();
+    #receiveTableUpdates;
+    constructor(options, config) {
+        super();
+        this.options = options;
+        this.config = config;
+        this.#connection = {
+            connection: options.connection,
+            notifyRemoteClosed: options.remoteCanCloseUnexpectedly ? new AbortController() : undefined,
+            traceQueries: config.debugMode === true
+        };
+        const { port1, port2 } = new MessageChannel();
+        options.connection.setUpdateListener(Comlink.transfer(port1, [port1]));
+        this.#receiveTableUpdates = port2;
+        port2.onmessage = (event) => {
+            const tables = event.data;
+            const notification = {
+                tables
+            };
+            this.iterateListeners((l) => {
+                l.tablesUpdated && l.tablesUpdated(notification);
+            });
+        };
+    }
+    get name() {
+        return this.config.dbFilename;
+    }
+    /**
+     * Marks the remote as closed.
+     *
+     * This can sometimes happen outside of our control, e.g. when a shared worker requests a connection from a tab. When
+     * it happens, all outstanding requests on this pool would never resolve. To avoid livelocks in this scenario, we
+     * throw on all outstanding promises and forbid new calls.
+     */
+    markRemoteClosed() {
+        // Can non-null assert here because this function is only supposed to be called when remoteCanCloseUnexpectedly was
+        // set.
+        this.#connection.notifyRemoteClosed.abort();
+    }
+    async close() {
+        // This connection is no longer shared, so we can close locks held for shareConnection calls.
+        this.#shareConnectionAbortController.abort();
+        this.#receiveTableUpdates.close();
+        await useConnectionState(this.#connection, (c) => c.close(), true);
+        this.options.onClose?.();
+        this.options.source?.[Comlink.releaseProxy]();
+    }
+    readLock(fn, options) {
+        return this.#lock(false, fn, options);
+    }
+    writeLock(fn, options) {
+        return this.#lock(true, fn, options);
+    }
+    async #lock(write, fn, options) {
+        const token = await useConnectionState(this.#connection, (c) => c.requestAccess(write, options?.timeoutMs));
+        try {
+            return await fn(new ClientLockContext(this.#connection, token));
+        }
+        finally {
+            await useConnectionState(this.#connection, (c) => c.completeAccess(token));
+        }
+    }
+    async refreshSchema() {
+        // Currently a no-op on the web.
+    }
+    async shareConnection() {
+        /**
+         * Hold a navigator lock in order to avoid features such as Chrome's frozen tabs,
+         * or Edge's sleeping tabs from pausing the thread for this connection.
+         * This promise resolves once a lock is obtained.
+         * This lock will be held as long as this connection is open.
+         * The `shareConnection` method should not be called on multiple tabs concurrently.
+         */
+        const abort = this.#shareConnectionAbortController;
+        const source = this.options.source;
+        if (source == null) {
+            throw new Error(`shareConnection() is only available for connections based by workers.`);
+        }
+        await new Promise((resolve, reject) => navigator.locks
+            .request(`shared-connection-${this.name}-${Date.now()}-${Math.round(Math.random() * 10000)}`, {
+            signal: abort.signal
+        }, async () => {
+            resolve();
+            // Free the lock when the connection is already closed.
+            if (abort.signal.aborted) {
+                return;
+            }
+            // Hold the lock while the shared connection is in use.
+            await new Promise((releaseLock) => {
+                abort.signal.addEventListener('abort', () => {
+                    releaseLock();
+                });
+            });
+        })
+            // We aren't concerned with abort errors here
+            .catch((ex) => {
+            if (ex.name == 'AbortError') {
+                resolve();
+            }
+            else {
+                reject(ex);
+            }
+        }));
+        const newPort = await source[Comlink.createEndpoint]();
+        return { port: newPort, identifier: this.name };
+    }
+    getConfiguration() {
+        return this.config;
+    }
+}
+/**
+ * A {@link LockContext} implemented by sending commands to a worker.
+ *
+ * While an instance is active, it has exclusive access to the underlying database connection (as represented by its
+ * token).
+ */
+class ClientLockContext extends LockContext {
+    #connection;
+    #token;
+    constructor(connection, token) {
+        super();
+        this.#connection = connection;
+        this.#token = token;
+    }
+    /**
+     * Requests an operation from the worker, potentially tracing it if that option has been enabled.
+     */
+    async maybeTrace(fn, describeForTrace) {
+        if (this.#connection.traceQueries) {
+            const start = performance.now();
+            const description = describeForTrace();
+            try {
+                const r = await useConnectionState(this.#connection, fn);
+                performance.measure(`[SQL] ${description}`, { start });
+                return r;
+            }
+            catch (e) {
+                performance.measure(`[SQL] [ERROR: ${e.message}] ${description}`, { start });
+                throw e;
+            }
+        }
+        else {
+            return useConnectionState(this.#connection, fn);
+        }
+    }
+    async executeRaw(query, params) {
+        return await this.#executeOnWorker(query, params);
+    }
+    async #executeOnWorker(query, params) {
+        return this.maybeTrace((c) => c.execute(this.#token, query, params), () => query);
+    }
+    async executeBatch(query, params = []) {
+        const results = await this.maybeTrace((c) => c.executeBatch(this.#token, query, params), () => `${query} (batch of ${params.length})`);
+        const result = { insertId: undefined, rowsAffected: 0 };
+        for (const source of results) {
+            result.insertId = source.insertId;
+            result.rowsAffected = (result.rowsAffected ?? 0) + source.rowsAffected;
+        }
+        return queryResultWithoutRows(result);
+    }
+}
+async function useConnectionState(state, workerPromise, fireActionOnAbort = false) {
+    const controller = state.notifyRemoteClosed;
+    if (controller) {
+        return new Promise((resolve, reject) => {
+            if (controller.signal.aborted) {
+                reject(new ConnectionClosedError('Called operation on closed remote'));
+                if (!fireActionOnAbort) {
+                    // Don't run the operation if we're going to reject
+                    // We might want to fire-and-forget the operation in some cases (like a close operation)
+                    return;
+                }
+            }
+            function handleAbort() {
+                reject(new ConnectionClosedError('Remote peer closed with request in flight'));
+            }
+            function completePromise(action) {
+                controller.signal.removeEventListener('abort', handleAbort);
+                action();
+            }
+            controller.signal.addEventListener('abort', handleAbort);
+            workerPromise(state.connection)
+                .then((data) => completePromise(() => resolve(data)))
+                .catch((e) => completePromise(() => reject(e)));
+        });
+    }
+    else {
+        // Can't close, so just return the inner worker promise unguarded.
+        return workerPromise(state.connection);
+    }
+}
+
+/**
+ * Requests a random lock that will be released once the optional signal is aborted (or, if no signal is given, when the
+ * tab is closed).
+ *
+ * This allows sending the name of the lock to another context (e.g. a shared worker), which will also attempt to
+ * acquire it. Since the lock is returned when the tab is closed, this allows the shared worker to free resources
+ * assocatiated with this tab.
+ *
+ *  We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
+ */
+function generateTabCloseSignal(abort) {
+    return new Promise((resolve, reject) => {
+        const options = { signal: abort };
+        getNavigatorLocks()
+            .request(`tab-close-signal-${crypto.randomUUID()}`, options, (lock) => {
+            resolve(lock.name);
+            return new Promise((resolve) => {
+                if (abort) {
+                    abort.addEventListener('abort', () => resolve());
+                }
+            });
+        })
+            .catch(reject);
+    });
+}
+
+/**
+ * Internal helper function to acquire a connection from a pool that has a designated writer, additional readers, and
+ * also allows dispatching reads to the writer.
+ */
+async function acquireFromPool(writerMutex, writer, readers, callback, options, allowReadOnly) {
+    const abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    let timeout = null;
+    let release;
+    if (options?.timeoutMs) {
+        timeout = setTimeout(() => abortController.abort('requesting database timed out'), options.timeoutMs);
+    }
+    try {
+        if (allowReadOnly) {
+            let connection;
+            // Even if we have a pool of read connections, it's typically very small and we assume that most queries are
+            // reads. So, we want to request any connection from the read pool and the dedicated write connection (which
+            // can also serve reads). We race for the first connection we can obtain this way, and then abort the other
+            // request.
+            [connection, release] = await new Promise((resolve, reject) => {
+                let didComplete = false;
+                function complete() {
+                    didComplete = true;
+                    abortController.abort();
+                }
+                function completeSuccess(connection, returnFn) {
+                    if (didComplete) {
+                        // We're not going to use this connection, so return it immediately.
+                        returnFn();
+                    }
+                    else {
+                        complete();
+                        resolve([connection, returnFn]);
+                    }
+                }
+                function completeError(error) {
+                    // We either have a working connection already, or we've rejected the promise. Either way, we don't need
+                    // to do either thing again.
+                    if (didComplete)
+                        return;
+                    complete();
+                    reject(error);
+                }
+                writerMutex.acquire(abortSignal).then((unlock) => completeSuccess(writer, unlock), completeError);
+                readers?.requestOne(abortSignal).then(({ item, release }) => completeSuccess(item, release), completeError);
+            });
+            return await callback(connection);
+        }
+        else {
+            return await writerMutex.runExclusive(() => callback(writer), abortSignal);
+        }
+    }
+    finally {
+        if (timeout != null) {
+            clearTimeout(timeout);
+        }
+        release?.();
+    }
+}
+
+/**
+ * A connection pool implementation delegating to another pool opened asynchronnously.
+ */
+class AsyncDbAdapter extends DBAdapter {
+    name;
+    state;
+    resolvedWriter;
+    pendingListeners = new Set();
+    constructor(inner, name) {
+        super();
+        this.name = name;
+        this.state = inner.then((client) => {
+            for (const pending of this.pendingListeners) {
+                pending.closeAfterRegisteredOnResolvedPool = client.writer.registerListener(pending.listener);
+            }
+            this.pendingListeners.clear();
+            this.resolvedWriter = client.writer;
+            if (client.additionalReaders.length) {
+                return readWritePoolState(client.writer, client.additionalReaders);
+            }
+            return singleConnectionPoolState(client.writer);
+        });
+    }
+    async init() {
+        await this.state;
+    }
+    async close() {
+        const state = await this.state;
+        await state.close();
+    }
+    async readLock(fn, options) {
+        const state = await this.state;
+        return state.withConnection(true, fn, options);
+    }
+    async writeLock(fn, options) {
+        const state = await this.state;
+        return state.withConnection(false, fn, options);
+    }
+    async refreshSchema() {
+        const state = await this.state;
+        await state.refreshSchema();
+    }
+    registerListener(listener) {
+        if (this.resolvedWriter) {
+            return this.resolvedWriter.registerListener(listener);
+        }
+        else {
+            const pending = { listener };
+            this.pendingListeners.add(pending);
+            return () => {
+                if (pending.closeAfterRegisteredOnResolvedPool) {
+                    return pending.closeAfterRegisteredOnResolvedPool();
+                }
+                else {
+                    // Has not been registered yet, we can just remove the pending listener.
+                    this.pendingListeners.delete(pending);
+                }
+            };
+        }
+    }
+    async shareConnection() {
+        const state = await this.state;
+        return state.writer.shareConnection();
+    }
+    getConfiguration() {
+        if (this.resolvedWriter) {
+            return this.resolvedWriter.getConfiguration();
+        }
+        throw new Error('AsyncDbAdapter.getConfiguration() can only be called after initializing it.');
+    }
+}
+function singleConnectionPoolState(connection) {
+    return {
+        writer: connection,
+        withConnection: (allowReadOnly, fn, options) => {
+            if (allowReadOnly) {
+                return connection.readLock(fn, options);
+            }
+            else {
+                return connection.writeLock(fn, options);
+            }
+        },
+        close: () => connection.close(),
+        refreshSchema: () => connection.refreshSchema()
+    };
+}
+function readWritePoolState(writer, readers) {
+    // DatabaseClients have locks internally, so these aren't necessary for correctness. However, our mutex and semaphore
+    // implementations are very cheap to cancel, which we use to dispatch reads to the first available connection (by
+    // simply requesting all of them and sticking with the first connection we get).
+    const writerMutex = new Mutex();
+    const readerSemaphore = new Semaphore(readers);
+    return {
+        writer,
+        async withConnection(allowReadOnly, fn, options) {
+            return acquireFromPool(writerMutex, writer, readerSemaphore, (connection) => {
+                return allowReadOnly ? connection.readLock(fn) : connection.writeLock(fn);
+            }, options, allowReadOnly);
+        },
+        async close() {
+            await writer.close();
+            await Promise.all(readers.map((r) => r.close()));
+        },
+        async refreshSchema() {
+            await writer.refreshSchema();
+            await Promise.all(readers.map((r) => r.refreshSchema()));
+        }
+    };
+}
+
+function connectToWorker({ service, databaseIdentifier, customWorker, shared, loggerForErrors }) {
+    const name = `${shared ? 'shared-' : ''}powersync-${databaseIdentifier}`;
+    let worker;
+    if (customWorker) {
+        worker = shared
+            ? new SharedWorker(customWorker, {
+                /* @vite-ignore */
+                name,
+                type: 'module'
+            })
+            : new Worker(customWorker, {
+                /* @vite-ignore */
+                name,
+                type: 'module'
+            });
+    }
+    else {
+        worker = spawnDefaultPowerSyncWorker();
+    }
+    return connectToExistingWorker(worker, loggerForErrors, service);
+}
+/**
+ * Opens the default PowerSync worker.
+ *
+ * When users depend on the web SDK, we assume they use their own bundler (either vite or webpack). Both recognize the
+ * syntax of worker constructors with a string literal and will rewrite the URL as part of their bundling processes.
+ *
+ * React Native / Metro users can't rely on this on the web, as their app is not a JavaScript module and import.meta.url
+ * is not rewritten by Metro. For those users, we include a pre-bundled worker they can copy into a static assets
+ * directory and load with a custom URI. This also means that defaultWorker cannot work with Metro for React Native Web.
+ * We have a custom rollup plugin and conditional exports that replaces this function with a throwing stub for that
+ * platform. This allows a helpful error message.
+ */
+// Note: When changing this function, also update disableDefaultWorkers in rollup.config.ts.
+function spawnDefaultPowerSyncWorker(shared, name) {
+  throw new Error('You are using the React Native web build of the PowerSync SDK, which requires custom worker URLs. Please see the documentation at https://docs.powersync.com/client-sdks/frameworks/react-native-web-support for details.');
+}
+
+function connectToExistingWorker(worker, logger, service) {
+    function logError(event) {
+        // TODO: Ideally, we should be able to handle worker errors by forwarding them to async Comlink callers.
+        // Currently, comlink calls on errored workers would just be stuck forever.
+        logger.log({
+            level: LogLevels.error,
+            error: event.error,
+            message: 'Error in database or sync worker, this likely disrupts PowerSync.'
+        });
+    }
+    worker.addEventListener('error', logError);
+    const isShared = isSharedWorker(worker);
+    if (isShared) {
+        const { port1, port2 } = new MessageChannel();
+        const mainPort = worker.port;
+        mainPort.start();
+        mainPort.postMessage({ port: port1, service }, [port1]);
+        port2.start();
+        return {
+            endpoint: port2,
+            worker,
+            close() {
+                worker.removeEventListener('error', logError);
+                port2.close();
+            }
+        };
+    }
+    else {
+        return {
+            endpoint: worker,
+            worker,
+            close() {
+                worker.removeEventListener('error', logError);
+                worker.terminate();
+            }
+        };
+    }
+}
+function isSharedWorker(worker) {
+    return 'port' in worker;
+}
+
+/**
+ * Opens a SQLite connection using WA-SQLite.
+ */
+class WASQLiteOpenFactory {
+    options;
+    logger;
+    constructor(options) {
+        this.options = resolveAndValidateOptions(options.open);
+        // Account for the fact that SQLite might append -journal suffixes
+        const maxLength = maxPathNameLength - 16;
+        if (this.options.dbFilename.length > maxLength) {
+            throw new Error(`dbFilename too long (max length is ${maxLength})`);
+        }
+        this.logger = options.logger;
+    }
+    openAdapter() {
+        return new AsyncDbAdapter(this.openConnection(), this.options.dbFilename);
+    }
+    openDB() {
+        const { disableSSRWarning, enableMultiTabs, ssrMode } = this.options;
+        if (ssrMode) {
+            if (!disableSSRWarning) {
+                this.logger.log({
+                    level: LogLevels.warn,
+                    message: `
+      Running PowerSync in SSR mode.
+      Only empty query results will be returned.
+      Disable this warning by setting 'disableSSRWarning: true' in options.`
+                });
+            }
+            return new SSRDBAdapter();
+        }
+        if (!enableMultiTabs) {
+            this.logger.log({
+                level: LogLevels.warn,
+                message: 'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
+            });
+        }
+        return this.openAdapter();
+    }
+    async openConnection() {
+        const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb, preparedStatementsCache } = this.options;
+        if (!enableMultiTabs) {
+            this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
+        }
+        let client;
+        let additionalReaders = [];
+        let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
+        function resolveRawWaSqliteDatabaseOptions(readonly) {
+            return {
+                filename: dbFilename,
+                readonly,
+                vfs,
+                encryptionKey,
+                temporaryStorage,
+                cacheSizeKb,
+                // TODO: Enable prepared statement cache by default?
+                preparedStatementsCache: preparedStatementsCache ?? 0
+            };
+        }
+        if (useWebWorker) {
+            const optionsDbWorker = this.options.worker;
+            const openDatabaseWorker = async (readonly) => {
+                let workerConnection;
+                if (typeof optionsDbWorker == 'function') {
+                    const worker = optionsDbWorker(this.options);
+                    workerConnection = connectToExistingWorker(worker, this.logger, 'database');
+                }
+                else {
+                    const needsDedicated = vfsRequiresDedicatedWorkers(vfs);
+                    const useShared = !needsDedicated && enableMultiTabs;
+                    workerConnection = connectToWorker({
+                        service: 'database',
+                        databaseIdentifier: this.options.dbFilename,
+                        shared: useShared,
+                        customWorker: optionsDbWorker,
+                        loggerForErrors: this.logger
+                    });
+                }
+                const source = Comlink.wrap(workerConnection.endpoint);
+                const closeSignal = new AbortController();
+                const connection = await source.connect({
+                    database: resolveRawWaSqliteDatabaseOptions(readonly),
+                    logLevel: this.options.databaseWorkerLogLevel,
+                    lockName: await generateTabCloseSignal(closeSignal.signal)
+                });
+                const clientOptions = {
+                    connection,
+                    source,
+                    // This tab owns the worker, so we're guaranteed to outlive it.
+                    remoteCanCloseUnexpectedly: false,
+                    onClose: () => {
+                        closeSignal.abort();
+                        workerConnection.close();
+                    }
+                };
+                return new DatabaseClient(clientOptions, {
+                    ...this.options,
+                    requiresPersistentTriggers
+                });
+            };
+            client = await openDatabaseWorker(false);
+            if (vfs == WASQLiteVFS.OPFSWriteAheadVFS) {
+                // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
+                // concurrent reads / writes.
+                const additionalReadersCount = this.options.additionalReaders ?? 1;
+                const additionalReaderPromises = [];
+                for (let i = 0; i < additionalReadersCount; i++) {
+                    additionalReaderPromises.push(openDatabaseWorker(true));
+                }
+                additionalReaders.push(...(await Promise.all(additionalReaderPromises)));
+            }
+        }
+        else {
+            // Don't use a web worker. Instead, open the MultiDatabaseServer a worker would use locally.
+            const localServer = new MultiDatabaseServer(this.logger);
+            requiresPersistentTriggers = true;
+            const connection = await localServer.openConnectionLocally(this.logger, resolveRawWaSqliteDatabaseOptions(false));
+            client = new DatabaseClient({ connection, source: null, remoteCanCloseUnexpectedly: false }, {
+                ...this.options,
+                requiresPersistentTriggers
+            });
+        }
+        return {
+            writer: client,
+            additionalReaders
+        };
+    }
+}
+
+/**
+ * @internal
+ * @experimental
+ */
+const NAVIGATOR_TRIGGER_CLAIM_MANAGER = {
+    async obtainClaim(identifier) {
+        return new Promise((resolveReleaser) => {
+            getNavigatorLocks().request(identifier, async () => {
+                await new Promise((releaseLock) => {
+                    resolveReleaser(async () => releaseLock());
+                });
+            });
+        });
+    },
+    async checkClaim(identifier) {
+        const currentState = await getNavigatorLocks().query();
+        return currentState.held?.find((heldLock) => heldLock.name == identifier) != null;
+    }
+};
+
+class SSRStreamingSyncImplementation extends BaseObserver {
+    syncMutex;
+    crudMutex;
+    isConnected;
+    lastSyncedAt;
+    constructor() {
+        super();
+        this.syncMutex = new Mutex();
+        this.crudMutex = new Mutex();
+        this.isConnected = false;
+    }
+    obtainLock(lockOptions) {
+        const mutex = lockOptions.type == LockType.CRUD ? this.crudMutex : this.syncMutex;
+        return mutex.runExclusive(lockOptions.callback, lockOptions.signal);
+    }
+    /**
+     * This is a no-op in SSR mode
+     */
+    async connect() { }
+    async dispose() { }
+    /**
+     * This is a no-op in SSR mode
+     */
+    async disconnect() { }
+    /**
+     * This SSR Mode implementation is immediately ready.
+     */
+    async waitForReady() { }
+    /**
+     * This will never resolve in SSR Mode.
+     */
+    waitUntilStatusMatches(_predicate) {
+        return new Promise(() => { });
+    }
+    /**
+     * This is a no-op in SSR mode.
+     */
+    triggerCrudUpload() { }
+    /**
+     * No-op in SSR mode.
+     */
+    updateSubscriptions() { }
+    /**
+     * No-op in SSR mode.
+     */
+    markConnectionMayHaveChanged() { }
+    requestCheckpoint() {
+        throw new Error('Sub sync implementation does not support request checkpoints');
+    }
+}
+
+/**
+ * The client side port should provide these methods.
+ */
+class AbstractSharedSyncClientProvider {
+}
+
+/**
+ * Get a minimal representation of browser, version and operating system.
+ *
+ * The goal is to get enough environemnt info to reproduce issues, but no
+ * more.
+ */
+function getUserAgentInfo(nav) {
+    nav ??= navigator;
+    const browser = getBrowserInfo(nav);
+    const os = getOsInfo(nav);
+    // The cast below is to cater for TypeScript < 5.5.0
+    return [browser, os].filter((v) => v != null);
+}
+function getBrowserInfo(nav) {
+    const brands = nav.userAgentData?.brands;
+    if (brands != null) {
+        const tests = [
+            { name: 'Google Chrome', value: 'Chrome' },
+            { name: 'Opera', value: 'Opera' },
+            { name: 'Edge', value: 'Edge' },
+            { name: 'Chromium', value: 'Chromium' }
+        ];
+        for (let { name, value } of tests) {
+            const brand = brands.find((b) => b.brand == name);
+            if (brand != null) {
+                return `${value}/${brand.version}`;
+            }
+        }
+    }
+    const ua = nav.userAgent;
+    const regexps = [
+        { re: /(?:firefox|fxios)\/(\d+)/i, value: 'Firefox' },
+        { re: /(?:edg|edge|edga|edgios)\/(\d+)/i, value: 'Edge' },
+        { re: /opr\/(\d+)/i, value: 'Opera' },
+        { re: /(?:chrome|chromium|crios)\/(\d+)/i, value: 'Chrome' },
+        { re: /version\/(\d+).*safari/i, value: 'Safari' }
+    ];
+    for (let { re, value } of regexps) {
+        const match = re.exec(ua);
+        if (match != null) {
+            return `${value}/${match[1]}`;
+        }
+    }
+    return null;
+}
+function getOsInfo(nav) {
+    if (nav.userAgentData?.platform != null) {
+        return nav.userAgentData.platform.toLowerCase();
+    }
+    const ua = nav.userAgent;
+    const regexps = [
+        { re: /windows/i, value: 'windows' },
+        { re: /android/i, value: 'android' },
+        { re: /linux/i, value: 'linux' },
+        { re: /iphone|ipad|ipod/i, value: 'ios' },
+        { re: /macintosh|mac os x/i, value: 'macos' }
+    ];
+    for (let { re, value } of regexps) {
+        if (re.test(ua)) {
+            return value;
+        }
+    }
+    return null;
+}
+
+class WebRemote extends AbstractRemote {
+    connector;
+    constructor(connector, logger) {
+        super(connector, logger);
+        this.connector = connector;
+    }
+    fetch({ resource, request }) {
+        return fetch(resource, request);
+    }
+    async loadWebSocketSupport(platform) {
+        if (!websockets) {
+            // loadWebSocketSupport being called concurrently is safe, the import resolves to the same module in that case.
+            const module = await import('@powersync/shared-internals/websockets');
+            websockets = new module.WebSocketSupport(platform);
+        }
+        return websockets;
+    }
+    getUserAgent() {
+        let ua = [super.getUserAgent(), `powersync-web`];
+        try {
+            ua.push(...getUserAgentInfo());
+        }
+        catch (error) {
+            this.logger.log({ level: LogLevels.warn, message: 'Failed to get user agent info', error });
+        }
+        return ua.join(' ');
+    }
+}
+let websockets;
+
+class WebStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+    constructor(options) {
+        // Super will store and provide default values for options
+        super(options);
+    }
+    get webOptions() {
+        return this.options;
+    }
+    async obtainLock(lockOptions) {
+        const identifier = `streaming-sync-${lockOptions.type}-${this.webOptions.identifier}`;
+        if (lockOptions.type == LockType.SYNC) {
+            this.logger.log({ level: LogLevels.debug, message: `requesting lock for ${identifier}` });
+        }
+        return getNavigatorLocks().request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
+    }
+}
+
+/**
+ * @internal
+ * Manual message events for shared sync clients
+ */
+var SharedSyncClientEvent;
+(function (SharedSyncClientEvent) {
+    /**
+     * This client requests the shared sync manager should
+     * close it's connection to the client.
+     */
+    SharedSyncClientEvent["CLOSE_CLIENT"] = "close-client";
+    SharedSyncClientEvent["CLOSE_ACK"] = "close-ack";
+})(SharedSyncClientEvent || (SharedSyncClientEvent = {}));
+
+/**
+ * The shared worker will trigger methods on this side of the message port
+ * via this client provider.
+ */
+class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
+    options;
+    statusChanged;
+    webDB;
+    constructor(options, statusChanged, webDB) {
+        super();
+        this.options = options;
+        this.statusChanged = statusChanged;
+        this.webDB = webDB;
+    }
+    async getDBWorkerPort() {
+        const { port } = await this.webDB.shareConnection();
+        return Comlink.transfer(port, [port]);
+    }
+    invalidateCredentials() {
+        this.options.remote.invalidateCredentials();
+    }
+    async fetchCredentials() {
+        const credentials = await this.options.remote.getCredentials();
+        if (credentials == null) {
+            return null;
+        }
+        /**
+         * The credentials need to be serializable.
+         * Users might extend [PowerSyncCredentials] to contain
+         * items which are not serializable.
+         * This returns only the essential fields.
+         */
+        return {
+            endpoint: credentials.endpoint,
+            token: credentials.token
+        };
+    }
+    async uploadCrud() {
+        /**
+         * Don't return anything here, just incase something which is not
+         * serializable is returned from the `uploadCrud` function.
+         */
+        await this.options.uploadCrud();
+    }
+    async postCheckpointRequest(clientId, requestId) {
+        return await this.options.postCheckpointRequest(clientId, requestId);
+    }
+    get logger() {
+        return this.options.logger;
+    }
+    log(record) {
+        this.logger.log(record);
+    }
+}
+/**
+ * The local part of the sync implementation on the web, which talks to a sync implementation hosted in a shared worker.
+ */
+class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
+    syncManager;
+    clientProvider;
+    worker;
+    isInitialized;
+    dbAdapter;
+    abortOnClose = new AbortController();
+    logLevel;
+    enableBroadcastLogs;
+    constructor(options) {
+        super(options);
+        this.dbAdapter = options.db;
+        this.logLevel = options.logLevel;
+        this.enableBroadcastLogs = options.enableBroadcastLogs;
+        const syncWorker = options.sync?.worker;
+        if (typeof syncWorker === 'function') {
+            this.worker = connectToExistingWorker(syncWorker(), options.logger, 'sync');
+        }
+        else {
+            this.worker = connectToWorker({
+                service: 'sync',
+                databaseIdentifier: this.webOptions.identifier,
+                shared: true,
+                customWorker: syncWorker,
+                loggerForErrors: options.logger
+            });
+        }
+        /**
+         * Pass along any sync status updates to this listener
+         */
+        this.clientProvider = new SharedSyncClientProvider(this.webOptions, ({ core, dataFlow }) => {
+            this.updateSyncStatus(core, dataFlow);
+        }, options.db);
+        this.syncManager = Comlink.wrap(this.worker.endpoint);
+        /**
+         * The sync worker will call this client provider when it needs
+         * to fetch credentials or upload data.
+         * This performs bi-directional method calling.
+         */
+        Comlink.expose(this.clientProvider, this.worker.endpoint);
+        this.syncManager.setLogLevel(this.logLevel);
+        this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
+        /**
+         * Opens MessagePort to the existing shared DB worker.
+         * The sync worker cannot initiate connections directly to the
+         * DB worker, but a port to the DB worker can be transferred to the
+         * sync worker.
+         */
+        this.isInitialized = this._init();
+    }
+    async _init() {
+        /**
+         * The general flow of initialization is:
+         *  - The client requests a unique navigator lock.
+         *    - Once the lock is acquired, we register the lock with the shared worker.
+         *    - The shared worker can then request the same lock. The client has been closed if the shared worker can acquire the lock.
+         *    - Once the shared worker knows the client's lock, we can guarentee that the shared worker will detect if the client has been closed.
+         *    - This makes the client safe for the shared worker to use.
+         *    - The client is only added to the SharedSyncImplementation once the lock has been registered.
+         *      This ensures we don't ever keep track of dead clients (tabs that closed before the lock was registered).
+         *    - The client side lock is held until the client is disposed.
+         *    - We resolve the top-level promise after the lock has been registered with the shared worker.
+         * - The client sends the params to the shared worker after locks have been registered.
+         */
+        const closeSignal = await generateTabCloseSignal(this.abortOnClose.signal);
+        // Awaiting here ensures the worker is waiting for the lock
+        await this.syncManager.addLockBasedCloseSignal(closeSignal);
+        const { identifier } = this.options;
+        await this.syncManager.setParams({
+            dbParams: this.dbAdapter.getConfiguration(),
+            streamOptions: {
+                identifier,
+                serializedSchema: this.options.serializedSchema
+            },
+            enableBroadcastLogs: this.enableBroadcastLogs
+        }, this.options.subscriptions);
+    }
+    /**
+     * Starts the sync process, this effectively acts as a call to
+     * `connect` if not yet connected.
+     */
+    async connect(options) {
+        await this.waitForReady();
+        return this.syncManager.connect(options, this.options.serializedSchema);
+    }
+    async disconnect() {
+        await this.waitForReady();
+        return this.syncManager.disconnect();
+    }
+    async dispose() {
+        await this.waitForReady();
+        await new Promise((resolve) => {
+            // This will always be a message port since we use shared workers.
+            const messagePort = this.worker.endpoint;
+            // Listen for the close acknowledgment from the worker
+            messagePort.addEventListener('message', (event) => {
+                const payload = event.data;
+                if (payload?.event === SharedSyncClientEvent.CLOSE_ACK) {
+                    resolve();
+                }
+            });
+            // Signal the shared worker that this client is closing its connection to the worker
+            const closeMessagePayload = {
+                event: SharedSyncClientEvent.CLOSE_CLIENT,
+                data: {}
+            };
+            messagePort.postMessage(closeMessagePayload);
+        });
+        await super.dispose();
+        this.abortOnClose.abort();
+        // Release the proxy
+        this.syncManager[Comlink.releaseProxy]();
+        this.worker.close();
+    }
+    async waitForReady() {
+        return this.isInitialized;
+    }
+    requestCheckpoint() {
+        return this.syncManager.requestCheckpoint();
+    }
+    updateSubscriptions(subscriptions) {
+        this.syncManager.updateSubscriptions(subscriptions);
+    }
+}
+
+/**
+ * When multi-tab support is disabled and we don't use a shared worker for sync, only a single tab will be able to
+ * acquire the sync navigator lock and start a sync iteration.
+ *
+ * To be able to provide _some_ multi-tab support in that configuration, this utility:
+ *
+ * 1. Sends sync status updates from the syncing tab to others.
+ * 2. Allows other tabs to send notifications when their active sync stream subscriptions update, allowing the active
+ *    tab to take those subscriptions into account.
+ */
+class TabLocalStreamingSyncImplementation extends WebStreamingSyncImplementation {
+    #statusUpdated;
+    #subscriptionsChanged;
+    #hasSyncLock = false;
+    constructor(options) {
+        super(options);
+        const identifier = options.identifier;
+        this.#statusUpdated = new BroadcastChannel(`sync-status-${identifier}`);
+        this.#subscriptionsChanged = new BroadcastChannel(`subscription-change-${identifier}`);
+        this.#statusUpdated.onmessage = (event) => {
+            if (event.data == 'ping') {
+                this.#sendStatus(this.syncStatus);
+                return;
+            }
+            const { core, dataFlow } = event.data;
+            this.updateSyncStatus(core, dataFlow);
+        };
+        // Request other tabs to share their sync status.
+        this.#statusUpdated.postMessage('ping');
+        this.#subscriptionsChanged.onmessage = () => {
+            // We can't update activeStreams since we don't know when another tab referencing them is closed. However,
+            // clients will update an internal table listing streams after subscribing, and updateSubscriptions() will
+            // scan that table.
+            super.updateSubscriptions(this.activeStreams);
+        };
+        this.registerListener({
+            statusChanged: (status) => this.#sendStatus(status)
+        });
+    }
+    #sendStatus(status) {
+        // Don't share sync status if this is not the tab currently syncing.
+        if (this.#hasSyncLock) {
+            this.#statusUpdated.postMessage(status.toJSON());
+        }
+    }
+    updateSubscriptions(subscriptions) {
+        super.updateSubscriptions(subscriptions);
+        this.#subscriptionsChanged.postMessage('');
+    }
+    obtainLock({ callback, type, signal }) {
+        const wrappedCallback = async () => {
+            this.#hasSyncLock = true;
+            try {
+                return await callback();
+            }
+            finally {
+                this.#hasSyncLock = false;
+            }
+        };
+        return super.obtainLock({ callback: type == LockType.SYNC ? wrappedCallback : callback, type, signal });
+    }
+    async dispose() {
+        this.#statusUpdated.close();
+        this.#subscriptionsChanged.close();
+        await super.dispose();
+    }
+}
+
+/**
+ * @internal Use {@link PowerSyncDatabase} instead, this class is only used by other SDKs also needing web support.
+ */
+class WebPowerSyncDatabase extends BasePowerSyncDatabase {
+    static SHARED_MUTEX = new Mutex();
+    resolvedOpenOptions;
+    enableBroadcastLogs;
+    constructor(options) {
+        const resolvedOpenOptions = resolveAndValidateOptions('database' in options ? options.database : {});
+        super(options);
+        this.resolvedOpenOptions = resolvedOpenOptions;
+        this.enableBroadcastLogs = options.broadcastLogs ?? true;
+    }
+    async _initialize() {
+        if (this.database instanceof AsyncDbAdapter) {
+            /**
+             * While init is done automatically,
+             * LockedAsyncDatabaseAdapter only exposes config after init.
+             * We can explicitly wait for init here in order to access config.
+             */
+            await this.database.init();
+        }
+        // In some cases, like the SQLJs adapter, we don't pass a WebDBAdapter, so we need to check.
+        if (typeof this.database.getConfiguration == 'function') {
+            const config = this.database.getConfiguration();
+            if (config.requiresPersistentTriggers) {
+                this.triggersImpl.updateDefaults({
+                    useStorageByDefault: true
+                });
+            }
+        }
+    }
+    generateTriggerManagerConfig() {
+        return {
+            // We need to share hold information between tabs for web
+            claimManager: NAVIGATOR_TRIGGER_CLAIM_MANAGER
+        };
+    }
+    openDBAdapter() {
+        return openDatabase(this.options, (options) => {
+            const defaultFactory = new WASQLiteOpenFactory({
+                logger: this.logger,
+                open: options
+            });
+            return defaultFactory.openDB();
+        });
+    }
+    /**
+     * Closes the database connection.
+     * By default the sync stream client is only disconnected if
+     * multiple tabs are not enabled.
+     */
+    close(options) {
+        return super.close({
+            // Don't disconnect by default if multiple tabs are enabled
+            disconnect: options?.disconnect ?? !this.resolvedOpenOptions.enableMultiTabs
+        });
+    }
+    async loadVersion() {
+        if (this.resolvedOpenOptions.ssrMode) {
+            return;
+        }
+        return super.loadVersion();
+    }
+    async resolveOfflineSyncStatus() {
+        if (this.resolvedOpenOptions.ssrMode) {
+            return;
+        }
+        return super.resolveOfflineSyncStatus();
+    }
+    async runExclusive(cb) {
+        if (this.resolvedOpenOptions.ssrMode) {
+            return WebPowerSyncDatabase.SHARED_MUTEX.runExclusive(cb);
+        }
+        return getNavigatorLocks().request(`lock-${this.database.name}`, cb);
+    }
+    generateSyncStreamImplementation(connector, options) {
+        const remote = new WebRemote(connector, this.logger);
+        const syncOptions = {
+            ...this.options,
+            ...this.commonSyncOptions(connector, options),
+            remote
+        };
+        if (this.resolvedOpenOptions.ssrMode) {
+            return new SSRStreamingSyncImplementation();
+        }
+        else if (this.resolvedOpenOptions.enableMultiTabs) {
+            if (!this.enableBroadcastLogs) {
+                const warning = `
+            Multiple tabs are enabled, but broadcasting of logs is disabled.
+            Logs for shared sync worker will only be available in the shared worker context
+          `;
+                const logger = this.options.logger;
+                logger ? logger.log({ level: LogLevels.warn, message: warning }) : console.warn(warning);
+            }
+            if ('shareConnection' in this.database) {
+                return new SharedWebStreamingSyncImplementation({
+                    ...syncOptions,
+                    db: this.database, // This should always be the case
+                    logLevel: this.options.sync?.logLevel ?? LogLevels.info,
+                    enableBroadcastLogs: this.enableBroadcastLogs
+                });
+            }
+            this.logger.log({
+                level: LogLevels.warn,
+                message: "Not using a shared sync worker because the database adapter doesn't support it."
+            });
+        }
+        return new TabLocalStreamingSyncImplementation(syncOptions);
+    }
+}
+/**
+ * A PowerSync database which provides SQLite functionality
+ * which is automatically synced.
+ *
+ * @example
+ * ```typescript
+ * export const db = new PowerSyncDatabase({
+ *  schema: AppSchema,
+ *  database: {
+ *    dbFilename: 'example.db'
+ *  }
+ * });
+ * ```
+ */
+// Typed constructor to avoid leaking AbstractPowerSyncDatabase into the public interface
+const PowerSyncDatabase = WebPowerSyncDatabase;
+
+export { IndexDBFileSystemStorageAdapter, PowerSyncDatabase, SharedWebStreamingSyncImplementation, TemporaryStorageOption, WASQLiteOpenFactory, WASQLiteVFS, WebPowerSyncDatabase, WebRemote, WebStreamingSyncImplementation };
+//# sourceMappingURL=index.react_native_web.js.map