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

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.35.0",
+    "version": "1.37.2",
     "description": "PowerSync Web SDK",
     "main": "lib/src/index.js",
     "module": "lib/src/index.js",
@@ -63,21 +63,20 @@
         "real-time data stream",
         "live data"
     ],
-    "author": "JOURNEYAPPS",
+    "author": "PowerSync",
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "catalog:",
-        "@powersync/common": "workspace:^1.48.0"
+        "@powersync/common": "workspace:^1.52.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
-        "async-mutex": "catalog:",
         "bson": "catalog:",
         "comlink": "catalog:",
         "commander": "^12.1.0"
     },
     "devDependencies": {
-        "@journeyapps/wa-sqlite": "^1.5.0",
+        "@journeyapps/wa-sqlite": "^1.7.0",
         "@types/uuid": "catalog:",
         "crypto-browserify": "^3.12.0",
         "glob": "catalog:",

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -1,8 +1,8 @@
-import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, StreamingSyncImplementation, TriggerManagerConfig, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type RequiredAdditionalConnectionOptions } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, StreamingSyncImplementation, TriggerManagerConfig, Mutex, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type RequiredAdditionalConnectionOptions } from '@powersync/common';
 import { ResolvedWebSQLOpenOptions, WebSQLFlags } from './adapters/web-sql-flags.js';
 export interface WebPowerSyncFlags extends WebSQLFlags {
     /**
+     * @deprecated This flag is no longer used. Navigator locks now handle tab detection automatically.
      * Externally unload open PowerSync database instances when the window closes.
      * Setting this to `true` requires calling `close` on all open PowerSyncDatabase
      * instances before the window unloads
@@ -55,7 +55,6 @@ export declare const resolveWebPowerSyncFlags: (flags?: WebPowerSyncFlags) => Re
 export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     protected options: WebPowerSyncDatabaseOptions;
     static SHARED_MUTEX: Mutex;
-    protected unloadListener?: () => Promise<void>;
     protected resolvedFlags: WebPowerSyncFlags;
     constructor(options: WebPowerSyncDatabaseOptionsWithAdapter);
     constructor(options: WebPowerSyncDatabaseOptionsWithOpenFactory);

package/lib/src/db/PowerSyncDatabase.js

@@ -1,14 +1,13 @@
-import { AbstractPowerSyncDatabase, SqliteBucketStorage, isDBAdapter, isSQLOpenFactory } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { AbstractPowerSyncDatabase, SqliteBucketStorage, isDBAdapter, isSQLOpenFactory, Mutex } from '@powersync/common';
 import { getNavigatorLocks } from '../shared/navigator.js';
 import { NAVIGATOR_TRIGGER_CLAIM_MANAGER } from './NavigatorTriggerClaimManager.js';
-import { LockedAsyncDatabaseAdapter } from './adapters/LockedAsyncDatabaseAdapter.js';
 import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import { DEFAULT_WEB_SQL_FLAGS, isServerSide, resolveWebSQLFlags } from './adapters/web-sql-flags.js';
 import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation.js';
 import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation.js';
 import { WebRemote } from './sync/WebRemote.js';
 import { WebStreamingSyncImplementation } from './sync/WebStreamingSyncImplementation.js';
+import { AsyncDbAdapter } from './adapters/AsyncWebAdapter.js';
 export const DEFAULT_POWERSYNC_FLAGS = {
     ...DEFAULT_WEB_SQL_FLAGS,
     externallyUnload: false
@@ -48,20 +47,15 @@ function assertValidDatabaseOptions(options) {
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     options;
     static SHARED_MUTEX = new Mutex();
-    unloadListener;
     resolvedFlags;
     constructor(options) {
         super(options);
         this.options = options;
         assertValidDatabaseOptions(options);
         this.resolvedFlags = resolveWebPowerSyncFlags(options.flags);
-        if (this.resolvedFlags.enableMultiTabs && !this.resolvedFlags.externallyUnload) {
-            this.unloadListener = () => this.close({ disconnect: false });
-            window.addEventListener('unload', this.unloadListener);
-        }
     }
     async _initialize() {
-        if (this.database instanceof LockedAsyncDatabaseAdapter) {
+        if (this.database instanceof AsyncDbAdapter) {
             /**
              * While init is done automatically,
              * LockedAsyncDatabaseAdapter only exposes config after init.
@@ -99,9 +93,6 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * multiple tabs are not enabled.
      */
     close(options) {
-        if (this.unloadListener) {
-            window.removeEventListener('unload', this.unloadListener);
-        }
         return super.close({
             // Don't disconnect by default if multiple tabs are enabled
             disconnect: options?.disconnect ?? !this.resolvedFlags.enableMultiTabs

package/lib/src/db/adapters/AsyncWebAdapter.d.ts

@@ -0,0 +1,50 @@
+import { ConnectionPool, DBAdapterListener, DBLockOptions, LockContext } from '@powersync/common';
+import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
+import { DatabaseClient } from './wa-sqlite/DatabaseClient.js';
+/**
+ * A connection pool implementation delegating to another pool opened asynchronnously.
+ */
+declare class AsyncConnectionPool implements ConnectionPool {
+    readonly name: string;
+    protected readonly state: Promise<PoolState>;
+    protected resolvedWriter?: DatabaseClient;
+    private readonly pendingListeners;
+    constructor(inner: Promise<PoolConnection>, name: string);
+    init(): Promise<void>;
+    close(): Promise<void>;
+    readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    refreshSchema(): Promise<void>;
+    registerListener(listener: Partial<DBAdapterListener>): () => void;
+}
+export interface PoolConnection {
+    writer: DatabaseClient;
+    additionalReaders: DatabaseClient[];
+}
+interface PoolState {
+    writer: DatabaseClient;
+    withConnection<T>(allowReadOnly: boolean, fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    close(): Promise<void>;
+    refreshSchema(): Promise<void>;
+}
+declare const AsyncDbAdapter_base: (new (...args: any[]) => {
+    readTransaction<T>(fn: (tx: import("@powersync/common").Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    writeTransaction<T>(fn: (tx: import("@powersync/common").Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
+    getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
+    get<T>(sql: string, parameters?: any[]): Promise<T>;
+    execute(query: string, params?: any[]): Promise<import("@powersync/common").QueryResult>;
+    executeRaw(query: string, params?: any[]): Promise<any[][]>;
+    executeBatch(query: string, params?: any[][]): Promise<import("@powersync/common").QueryResult>;
+    name: string;
+    close: () => void | Promise<void>;
+    readLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
+    writeLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
+    refreshSchema: () => Promise<void>;
+    registerListener(listener: Partial<DBAdapterListener>): () => void;
+}) & typeof AsyncConnectionPool;
+export declare class AsyncDbAdapter extends AsyncDbAdapter_base implements WebDBAdapter {
+    shareConnection(): Promise<SharedConnectionWorker>;
+    getConfiguration(): WebDBAdapterConfiguration;
+}
+export {};

package/lib/src/db/adapters/AsyncWebAdapter.js

@@ -0,0 +1,163 @@
+import { DBAdapterDefaultMixin, Mutex, Semaphore } from '@powersync/common';
+/**
+ * A connection pool implementation delegating to another pool opened asynchronnously.
+ */
+class AsyncConnectionPool {
+    name;
+    state;
+    resolvedWriter;
+    pendingListeners = new Set();
+    constructor(inner, name) {
+        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);
+                }
+            };
+        }
+    }
+}
+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()));
+        }
+    };
+}
+export class AsyncDbAdapter extends DBAdapterDefaultMixin(AsyncConnectionPool) {
+    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.');
+    }
+}

package/lib/src/db/adapters/SSRDBAdapter.d.ts

@@ -1,5 +1,4 @@
-import { BaseObserver, DBAdapterListener, DBAdapter, DBLockOptions, LockContext, QueryResult, Transaction } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { BaseObserver, DBAdapterListener, DBAdapter, DBLockOptions, LockContext, QueryResult, Transaction, Mutex } from '@powersync/common';
 /**
  * Implements a Mock DB adapter for use in Server Side Rendering (SSR).
  * This adapter will return empty results for queries, which will allow

package/lib/src/db/adapters/SSRDBAdapter.js

@@ -1,5 +1,4 @@
-import { BaseObserver } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { BaseObserver, Mutex, timeoutSignal } from '@powersync/common';
 const MOCK_QUERY_RESPONSE = {
     rowsAffected: 0
 };
@@ -20,16 +19,16 @@ export class SSRDBAdapter extends BaseObserver {
     }
     close() { }
     async readLock(fn, options) {
-        return this.readMutex.runExclusive(() => fn(this));
+        return this.readMutex.runExclusive(() => fn(this), timeoutSignal(options?.timeoutMs));
     }
     async readTransaction(fn, options) {
-        return this.readLock(() => fn(this.generateMockTransactionContext()));
+        return this.readLock(() => fn(this.generateMockTransactionContext()), options);
     }
     async writeLock(fn, options) {
-        return this.writeMutex.runExclusive(() => fn(this));
+        return this.writeMutex.runExclusive(() => fn(this), timeoutSignal(options?.timeoutMs));
     }
     async writeTransaction(fn, options) {
-        return this.writeLock(() => fn(this.generateMockTransactionContext()));
+        return this.writeLock(() => fn(this.generateMockTransactionContext()), options);
     }
     async execute(query, params) {
         return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);

package/lib/src/db/adapters/wa-sqlite/ConcurrentConnection.d.ts

@@ -0,0 +1,56 @@
+import { UnlockFn } from '@powersync/common';
+import { RawSqliteConnection } from './RawSqliteConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+/**
+ * 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.
+ */
+export declare class ConcurrentSqliteConnection {
+    private readonly 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.
+     */
+    private 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: RawSqliteConnection, needsNavigatorLocks: boolean);
+    get options(): ResolvedWASQLiteOpenFactoryOptions;
+    acquireMutex(abort?: AbortSignal): Promise<UnlockFn>;
+    unsafeUseInner(): RawSqliteConnection;
+    /**
+     * @returns A {@link ConnectionLeaseToken}. Until that token is returned, no other client can use the database.
+     */
+    acquireConnection(abort?: AbortSignal): Promise<ConnectionLeaseToken>;
+    close(): Promise<void>;
+}
+/**
+ * An instance representing temporary exclusive access to a {@link ConcurrentSqliteConnection}.
+ */
+export declare class ConnectionLeaseToken {
+    private returnMutex;
+    private connection;
+    /** Ensures that the client with access to this token can't run statements concurrently. */
+    private useMutex;
+    private closed;
+    constructor(returnMutex: UnlockFn, connection: RawSqliteConnection);
+    /**
+     * Returns this lease, allowing another client to use the database connection.
+     */
+    returnLease(): Promise<void>;
+    /**
+     * This should only be used internally, since the callback must not use the raw connection after resolving.
+     */
+    use<T>(callback: (conn: RawSqliteConnection) => Promise<T>): Promise<T>;
+}

package/lib/src/db/adapters/wa-sqlite/ConcurrentConnection.js

@@ -0,0 +1,121 @@
+import { Mutex } from '@powersync/common';
+/**
+ * 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.
+ */
+export 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.dbFilename}`, options, (_) => {
+                return new Promise((returnLock) => {
+                    return resolve(() => {
+                        returnLock();
+                    });
+                });
+            })
+                .catch(reject);
+        });
+    }
+    // Unsafe, unguarded access to the SQLite connection.
+    unsafeUseInner() {
+        return this.inner;
+    }
+    /**
+     * @returns A {@link ConnectionLeaseToken}. Until that token is returned, no other client can use the database.
+     */
+    async acquireConnection(abort) {
+        const returnMutex = await this.acquireMutex(abort);
+        const token = new ConnectionLeaseToken(returnMutex, this.inner);
+        try {
+            // Assert that the inner connection is initialized at this point, fail early if it's not.
+            this.inner.requireSqlite();
+            // If a previous client was interrupted in the middle of a transaction AND this is a shared worker, it's possible
+            // for the connection to still be in a transaction. To avoid inconsistent state, we roll back connection leases
+            // that haven't been comitted.
+            if (!this.inner.isAutoCommit()) {
+                await this.inner.executeRaw('ROLLBACK');
+            }
+        }
+        catch (e) {
+            returnMutex();
+            throw e;
+        }
+        return token;
+    }
+    async close() {
+        const returnMutex = await this.acquireMutex();
+        try {
+            await this.inner.close();
+        }
+        finally {
+            returnMutex();
+        }
+    }
+}
+/**
+ * An instance representing temporary exclusive access to a {@link ConcurrentSqliteConnection}.
+ */
+export 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);
+        });
+    }
+}

package/lib/src/db/adapters/wa-sqlite/DatabaseClient.d.ts

@@ -0,0 +1,54 @@
+import { LockContext, DBLockOptions, DBAdapterListener, ConnectionPool, BaseObserver, SQLOpenOptions } from '@powersync/common';
+import { SharedConnectionWorker, WebDBAdapterConfiguration } from '../WebDBAdapter.js';
+import { ClientConnectionView } from './DatabaseServer.js';
+import * as Comlink from 'comlink';
+import { WorkerDBOpenerOptions } from './WASQLiteOpenFactory.js';
+export interface OpenWorkerConnection {
+    connect(config: WorkerDBOpenerOptions): Promise<ClientConnectionView>;
+    connectToExisting(options: {
+        identifier: string;
+        lockName: string;
+    }): Promise<ClientConnectionView>;
+}
+export interface ClientOptions {
+    connection: ClientConnectionView;
+    /**
+     * The remote from which the {@link connection} has been obtained.
+     *
+     * We use this to be able to expose this port to other clients wanting to connect to the database (e.g. the shared
+     * sync worker).
+     *
+     * For sources not based on workers, returns null.
+     */
+    source: Comlink.Remote<OpenWorkerConnection> | null;
+    /**
+     * Whether the remote we're connecting to can close unexpectedly (e.g. because we're a shared worker connecting to a
+     * dedicated worker handle we've received from a tab).
+     */
+    remoteCanCloseUnexpectedly: boolean;
+    onClose?: () => void;
+}
+/**
+ * A single-connection {@link ConnectionPool} implementation based on a worker connection.
+ */
+export declare class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration> extends BaseObserver<DBAdapterListener> implements ConnectionPool {
+    #private;
+    private readonly options;
+    private readonly config;
+    constructor(options: ClientOptions, config: Config);
+    get name(): string;
+    /**
+     * 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(): void;
+    close(): Promise<void>;
+    readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    refreshSchema(): Promise<void>;
+    shareConnection(): Promise<SharedConnectionWorker>;
+    getConfiguration(): Config;
+}