@powersync/web 0.0.0-dev-20260630141119 → 0.0.0-dev-20260708103617

package/dist/index.react_native_web.js

@@ -1,1879 +0,0 @@
-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, SqliteBucketStorage } 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";
-})(WASQLiteVFS || (WASQLiteVFS = {}));
-function vfsRequiresDedicatedWorkers(vfs) {
-    return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
-}
-async function asyncModuleFactory(encryptionKey) {
-    if (encryptionKey) {
-        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
-        return factory();
-    }
-    else {
-        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
-        return factory();
-    }
-}
-async function syncModuleFactory(encryptionKey) {
-    if (encryptionKey) {
-        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
-        return factory();
-    }
-    else {
-        const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
-        return factory();
-    }
-}
-/**
- * @internal
- */
-const DEFAULT_MODULE_FACTORIES = {
-    [WASQLiteVFS.IDBBatchAtomicVFS]: async (options) => {
-        const module = await asyncModuleFactory(options.encryptionKey);
-        const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
-        return {
-            module,
-            // @ts-expect-error The types for this static method are missing upstream
-            vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
-        };
-    },
-    [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
-        const module = await syncModuleFactory(options.encryptionKey);
-        // @ts-expect-error The types for this static method are missing upstream
-        const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
-        return {
-            module,
-            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
-        };
-    },
-    [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
-        const module = await syncModuleFactory(options.encryptionKey);
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
-        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
-        return {
-            module,
-            vfs
-        };
-    },
-    [WASQLiteVFS.OPFSWriteAheadVFS]: async (options) => {
-        const module = await syncModuleFactory(options.encryptionKey);
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
-        const vfs = await OPFSWriteAheadVFS.create(options.dbFileName, module, {});
-        return {
-            module,
-            vfs
-        };
-    }
-};
-
-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 ${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.');
-};
-
-/**
- * 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 = 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.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.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.filename,
-            encryptionKey: this.options.encryptionKey
-        });
-        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 api.statements(this.db, 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) {
-            await this.requireSqlite().close(this.db);
-            this.db = 0;
-        }
-    }
-}
-
-/**
- * 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();
-    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) {
-        return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-            const { filename } = options;
-            let server = this.activeDatabases.get(filename);
-            if (server == null) {
-                // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
-                // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
-                // fine).
-                const needsNavigatorLocks = !(isSharedWorker$1 || options.readonly);
-                const connection = new RawSqliteConnection(options);
-                const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
-                // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want
-                // to do that in an exclusive lock. Note that OPEN_DB_LOCK is not enough for that, as another tab might have
-                // already created a connection (and is thus outside of OPEN_DB_LOCK) while currently writing to it.
-                const returnLease = await withSafeConcurrency.acquireMutex();
-                try {
-                    await connection.init();
-                }
-                catch (e) {
-                    returnLease();
-                    await connection.close();
-                    throw e;
-                }
-                returnLease();
-                const onClose = () => this.activeDatabases.delete(filename);
-                server = new DatabaseServer({
-                    inner: withSafeConcurrency,
-                    logger,
-                    onClose
-                });
-                this.activeDatabases.set(filename, server);
-            }
-            return server;
-        });
-    }
-    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);
-    });
-}
-
-/**
- * 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) {
-            const abortController = new AbortController();
-            const abortSignal = abortController.signal;
-            let timeout = null;
-            let release;
-            if (options?.timeoutMs) {
-                timeout = setTimeout(() => abortController.abort, 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);
-                        readerSemaphore
-                            .requestOne(abortSignal)
-                            .then(({ item, release }) => completeSuccess(item, release), completeError);
-                    });
-                    return await connection.readLock(fn);
-                }
-                else {
-                    return await writerMutex.runExclusive(() => writer.writeLock(fn), abortSignal);
-                }
-            }
-            finally {
-                if (timeout != null) {
-                    clearTimeout(timeout);
-                }
-                release?.();
-            }
-        },
-        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()));
-        }
-    };
-}
-
-var TemporaryStorageOption;
-(function (TemporaryStorageOption) {
-    TemporaryStorageOption["MEMORY"] = "memory";
-    TemporaryStorageOption["FILESYSTEM"] = "file";
-})(TemporaryStorageOption || (TemporaryStorageOption = {}));
-
-/**
- * @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;
-}
-
-function connectToWorker({ service, databaseIdentifier, customWorker, shared }) {
-    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, 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, service) {
-    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() {
-                port2.close();
-            }
-        };
-    }
-    else {
-        return {
-            endpoint: worker,
-            worker,
-            close() {
-                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);
-        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 } = 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
-            };
-        }
-        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, 'database');
-                }
-                else {
-                    const needsDedicated = vfsRequiresDedicatedWorkers(vfs);
-                    const useShared = !needsDedicated && enableMultiTabs;
-                    workerConnection = connectToWorker({
-                        service: 'database',
-                        databaseIdentifier: this.options.dbFilename,
-                        shared: useShared,
-                        customWorker: optionsDbWorker
-                    });
-                }
-                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;
-                for (let i = 0; i < additionalReadersCount; i++) {
-                    const reader = await openDatabaseWorker(true);
-                    additionalReaders.push(reader);
-                }
-            }
-        }
-        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(() => { });
-    }
-    /**
-     * Returns a placeholder checkpoint. This should not be used.
-     */
-    async getWriteCheckpoint() {
-        return '1';
-    }
-    /**
-     * The SSR mode adapter will never complete syncing.
-     */
-    async hasCompletedSync() {
-        return false;
-    }
-    /**
-     * This is a no-op in SSR mode.
-     */
-    triggerCrudUpload() { }
-    /**
-     * No-op in SSR mode.
-     */
-    updateSubscriptions() { }
-    /**
-     * No-op in SSR mode.
-     */
-    markConnectionMayHaveChanged() { }
-}
-
-/**
- * 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();
-    }
-    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(), 'sync');
-        }
-        else {
-            this.worker = connectToWorker({
-                service: 'sync',
-                databaseIdentifier: this.webOptions.identifier,
-                shared: true,
-                customWorker: syncWorker
-            });
-        }
-        /**
-         * 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 getWriteCheckpoint() {
-        await this.waitForReady();
-        return this.syncManager.getWriteCheckpoint();
-    }
-    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;
-    }
-    updateSubscriptions(subscriptions) {
-        this.syncManager.updateSubscriptions(subscriptions);
-    }
-}
-
-/**
- * @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();
-    }
-    generateBucketStorageAdapter() {
-        return new SqliteBucketStorage(this.database, this.logger);
-    }
-    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,
-            ...options,
-            adapter: this.bucketStorageAdapter,
-            remote,
-            uploadCrud: async () => {
-                await this.waitForReady();
-                await connector.uploadData(this);
-            },
-            identifier: this.database.name,
-            logger: this.logger
-        };
-        switch (true) {
-            case this.resolvedOpenOptions.ssrMode:
-                return new SSRStreamingSyncImplementation();
-            case 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);
-                }
-                return new SharedWebStreamingSyncImplementation({
-                    ...syncOptions,
-                    db: this.database, // This should always be the case
-                    logLevel: this.options.sync?.logLevel ?? LogLevels.info,
-                    enableBroadcastLogs: this.enableBroadcastLogs
-                });
-            default:
-                return new WebStreamingSyncImplementation(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