@powersync/web 1.26.2 → 1.27.0

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.26.2",
+    "version": "1.27.0",
     "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
@@ -60,8 +60,8 @@
     "author": "JOURNEYAPPS",
     "license": "Apache-2.0",
     "peerDependencies": {
-        "@journeyapps/wa-sqlite": "^1.3.1",
-        "@powersync/common": "workspace:^1.38.1"
+        "@journeyapps/wa-sqlite": "^1.3.2",
+        "@powersync/common": "workspace:^1.39.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
@@ -71,7 +71,7 @@
         "commander": "^12.1.0"
     },
     "devDependencies": {
-        "@journeyapps/wa-sqlite": "^1.3.1",
+        "@journeyapps/wa-sqlite": "^1.3.2",
         "@types/uuid": "^9.0.6",
         "crypto-browserify": "^3.12.0",
         "p-defer": "^4.0.1",

package/lib/src/db/PowerSyncDatabase.js

@@ -94,8 +94,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         const remote = new WebRemote(connector, this.logger);
         const syncOptions = {
             ...this.options,
-            retryDelayMs: options.retryDelayMs,
-            crudUploadThrottleMs: options.crudUploadThrottleMs,
+            ...options,
             flags: this.resolvedFlags,
             adapter: this.bucketStorageAdapter,
             remote,

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

@@ -8,6 +8,7 @@ export type SharedConnectionWorker = {
 export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> = {
     baseConnection: AsyncDatabaseConnection;
     identifier: string;
+    remoteCanCloseUnexpectedly: boolean;
     /**
      * Need a remote in order to keep a reference to the Proxied worker
      */
@@ -21,9 +22,19 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
 export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> implements AsyncDatabaseConnection {
     protected options: WrappedWorkerConnectionOptions<Config>;
     protected lockAbortController: AbortController;
+    protected notifyRemoteClosed: AbortController | undefined;
     constructor(options: WrappedWorkerConnectionOptions<Config>);
     protected get baseConnection(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
     init(): Promise<void>;
+    /**
+     * 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 methods on the {@link baseConnection} would never resolve. To avoid livelocks in this scenario, we
+     * throw on all outstanding promises and forbid new calls.
+     */
+    markRemoteClosed(): void;
+    private withRemote;
     /**
      * Get a MessagePort which can be used to share the internals of this connection.
      */

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

@@ -5,10 +5,13 @@ import * as Comlink from 'comlink';
  */
 export class WorkerWrappedAsyncDatabaseConnection {
     options;
-    lockAbortController;
+    lockAbortController = new AbortController();
+    notifyRemoteClosed;
     constructor(options) {
         this.options = options;
-        this.lockAbortController = new AbortController();
+        if (options.remoteCanCloseUnexpectedly) {
+            this.notifyRemoteClosed = new AbortController();
+        }
     }
     get baseConnection() {
         return this.options.baseConnection;
@@ -16,6 +19,43 @@ export class WorkerWrappedAsyncDatabaseConnection {
     init() {
         return this.baseConnection.init();
     }
+    /**
+     * 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 methods on the {@link baseConnection} 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.notifyRemoteClosed.abort();
+    }
+    withRemote(workerPromise) {
+        const controller = this.notifyRemoteClosed;
+        if (controller) {
+            return new Promise((resolve, reject) => {
+                if (controller.signal.aborted) {
+                    reject(new Error('Called operation on closed remote'));
+                }
+                function handleAbort() {
+                    reject(new Error('Remote peer closed with request in flight'));
+                }
+                function completePromise(action) {
+                    controller.signal.removeEventListener('abort', handleAbort);
+                    action();
+                }
+                controller.signal.addEventListener('abort', handleAbort);
+                workerPromise()
+                    .then((data) => completePromise(() => resolve(data)))
+                    .catch((e) => completePromise(() => reject(e)));
+            });
+        }
+        else {
+            // Can't close, so just return the inner worker promise unguarded.
+            return workerPromise();
+        }
+    }
     /**
      * Get a MessagePort which can be used to share the internals of this connection.
      */
@@ -66,20 +106,24 @@ export class WorkerWrappedAsyncDatabaseConnection {
     async close() {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
-        await this.baseConnection.close();
-        this.options.remote[Comlink.releaseProxy]();
-        this.options.onClose?.();
+        try {
+            await this.withRemote(() => this.baseConnection.close());
+        }
+        finally {
+            this.options.remote[Comlink.releaseProxy]();
+            this.options.onClose?.();
+        }
     }
     execute(sql, params) {
-        return this.baseConnection.execute(sql, params);
+        return this.withRemote(() => this.baseConnection.execute(sql, params));
     }
     executeRaw(sql, params) {
-        return this.baseConnection.executeRaw(sql, params);
+        return this.withRemote(() => this.baseConnection.executeRaw(sql, params));
     }
     executeBatch(sql, params) {
-        return this.baseConnection.executeBatch(sql, params);
+        return this.withRemote(() => this.baseConnection.executeBatch(sql, params));
     }
     getConfig() {
-        return this.baseConnection.getConfig();
+        return this.withRemote(() => this.baseConnection.getConfig());
     }
 }

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

@@ -17,6 +17,7 @@ export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
                     const remote = Comlink.wrap(workerPort);
                     return new WorkerWrappedAsyncDatabaseConnection({
                         remote,
+                        remoteCanCloseUnexpectedly: false,
                         identifier: options.dbFilename,
                         baseConnection: await remote({
                             ...options,

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

@@ -45,6 +45,8 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
             const workerDBOpener = Comlink.wrap(workerPort);
             return new WorkerWrappedAsyncDatabaseConnection({
                 remote: workerDBOpener,
+                // This tab owns the worker, so we're guaranteed to outlive it.
+                remoteCanCloseUnexpectedly: false,
                 baseConnection: await workerDBOpener({
                     dbFilename: this.options.dbFilename,
                     vfs,

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.d.ts

@@ -41,4 +41,8 @@ export declare class SSRStreamingSyncImplementation extends BaseObserver impleme
      * This is a no-op in SSR mode.
      */
     triggerCrudUpload(): void;
+    /**
+     * No-op in SSR mode.
+     */
+    updateSubscriptions(): void;
 }

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.js

@@ -58,4 +58,8 @@ export class SSRStreamingSyncImplementation extends BaseObserver {
      * This is a no-op in SSR mode.
      */
     triggerCrudUpload() { }
+    /**
+     * No-op in SSR mode.
+     */
+    updateSubscriptions() { }
 }

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.d.ts

@@ -1,9 +1,9 @@
-import { PowerSyncConnectionOptions, PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import { PowerSyncConnectionOptions, PowerSyncCredentials, SubscribedStream, SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { SharedSyncImplementation } from '../../worker/sync/SharedSyncImplementation';
 import { WebDBAdapter } from '../adapters/WebDBAdapter';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
+import { WorkerClient } from '../../worker/sync/WorkerClient';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -30,12 +30,16 @@ declare class SharedSyncClientProvider extends AbstractSharedSyncClientProvider
 export interface SharedWebStreamingSyncImplementationOptions extends WebStreamingSyncImplementationOptions {
     db: WebDBAdapter;
 }
+/**
+ * The local part of the sync implementation on the web, which talks to a sync implementation hosted in a shared worker.
+ */
 export declare class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
-    protected syncManager: Comlink.Remote<SharedSyncImplementation>;
+    protected syncManager: Comlink.Remote<WorkerClient>;
     protected clientProvider: SharedSyncClientProvider;
     protected messagePort: MessagePort;
     protected isInitialized: Promise<void>;
     protected dbAdapter: WebDBAdapter;
+    private abortOnClose;
     constructor(options: SharedWebStreamingSyncImplementationOptions);
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -47,6 +51,7 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     hasCompletedSync(): Promise<boolean>;
     dispose(): Promise<void>;
     waitForReady(): Promise<void>;
+    updateSubscriptions(subscriptions: SubscribedStream[]): void;
     /**
      * Used in tests to force a connection states
      */

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -3,6 +3,7 @@ import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractShar
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
 import { DEFAULT_CACHE_SIZE_KB, resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
+import { getNavigatorLocks } from '../../shared/navigator';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -75,12 +76,16 @@ class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
         this.logger?.timeEnd(label);
     }
 }
+/**
+ * The local part of the sync implementation on the web, which talks to a sync implementation hosted in a shared worker.
+ */
 export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
     syncManager;
     clientProvider;
     messagePort;
     isInitialized;
     dbAdapter;
+    abortOnClose = new AbortController();
     constructor(options) {
         super(options);
         this.dbAdapter = options.db;
@@ -133,7 +138,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
                 retryDelayMs,
                 flags: flags
             }
-        });
+        }, options.subscriptions);
         /**
          * Pass along any sync status updates to this listener
          */
@@ -146,6 +151,17 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * This performs bi-directional method calling.
          */
         Comlink.expose(this.clientProvider, this.messagePort);
+        // Request a random lock until this client is disposed. The name of the lock is sent to the shared worker, which
+        // will also attempt to acquire it. Since the lock is returned when the tab is closed, this allows the share worker
+        // to free resources associated with this tab.
+        getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
+            if (!this.abortOnClose.signal.aborted) {
+                this.syncManager.addLockBasedCloseSignal(lock.name);
+                await new Promise((r) => {
+                    this.abortOnClose.signal.onabort = () => r();
+                });
+            }
+        });
     }
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -184,6 +200,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
             };
             this.messagePort.postMessage(closeMessagePayload);
         });
+        this.abortOnClose.abort();
         // Release the proxy
         this.syncManager[Comlink.releaseProxy]();
         this.messagePort.close();
@@ -191,11 +208,14 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     async waitForReady() {
         return this.isInitialized;
     }
+    updateSubscriptions(subscriptions) {
+        this.syncManager.updateSubscriptions(subscriptions);
+    }
     /**
      * Used in tests to force a connection states
      */
     async _testUpdateStatus(status) {
         await this.isInitialized;
-        return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
+        return this.syncManager._testUpdateAllStatuses(status.toJSON());
     }
 }

package/lib/src/worker/sync/SharedSyncImplementation.d.ts

@@ -1,4 +1,4 @@
-import { type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, ConnectionManager, DBAdapter, SyncStatus } from '@powersync/common';
+import { type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
@@ -27,7 +27,7 @@ export type ManualSharedSyncPayload = {
  * @internal
  */
 export type SharedSyncInitOptions = {
-    streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote'>;
+    streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote' | 'subscriptions'>;
     dbParams: ResolvedWebSQLOpenOptions;
 };
 /**
@@ -43,6 +43,8 @@ export type WrappedSyncPort = {
     port: MessagePort;
     clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
     db?: DBAdapter;
+    currentSubscriptions: SubscribedStream[];
+    closeListeners: (() => void)[];
 };
 /**
  * @internal
@@ -55,7 +57,7 @@ export type RemoteOperationAbortController = {
  * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
-export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> implements StreamingSyncImplementation {
+export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> {
     protected ports: WrappedSyncPort[];
     protected isInitialized: Promise<void>;
     protected statusListener?: () => void;
@@ -66,6 +68,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected logger: ILogger;
     protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
     protected portMutex: Mutex;
+    private subscriptions;
     protected connectionManager: ConnectionManager;
     syncStatus: SyncStatus;
     broadCastLogger: ILogger;
@@ -75,6 +78,8 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
     waitForReady(): Promise<void>;
+    private collectActiveSubscriptions;
+    updateSubscriptions(port: WrappedSyncPort, subscriptions: SubscribedStream[]): void;
     setLogLevel(level: ILogLevel): void;
     /**
      * Configures the DBAdapter connection and a streaming sync client.
@@ -92,12 +97,17 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     /**
      * Adds a new client tab's message port to the list of connected ports
      */
-    addPort(port: MessagePort): Promise<void>;
+    addPort(port: MessagePort): Promise<{
+        port: MessagePort;
+        clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
+        currentSubscriptions: never[];
+        closeListeners: never[];
+    }>;
     /**
      * Removes a message port client from this manager's managed
      * clients.
      */
-    removePort(port: MessagePort): Promise<() => void>;
+    removePort(port: WrappedSyncPort): Promise<() => void>;
     triggerCrudUpload(): void;
     hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
@@ -113,5 +123,5 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      * A function only used for unit tests which updates the internal
      * sync stream client and all tab client's sync status
      */
-    private _testUpdateAllStatuses;
+    _testUpdateAllStatuses(status: SyncStatusOptions): Promise<void>;
 }

package/lib/src/worker/sync/SharedSyncImplementation.js

@@ -40,6 +40,7 @@ export class SharedSyncImplementation extends BaseObserver {
     logger;
     lastConnectOptions;
     portMutex;
+    subscriptions = [];
     connectionManager;
     syncStatus;
     broadCastLogger;
@@ -102,6 +103,23 @@ export class SharedSyncImplementation extends BaseObserver {
     async waitForReady() {
         return this.isInitialized;
     }
+    collectActiveSubscriptions() {
+        this.logger.debug('Collecting active stream subscriptions across tabs');
+        const active = new Map();
+        for (const port of this.ports) {
+            for (const stream of port.currentSubscriptions) {
+                const serializedKey = JSON.stringify(stream);
+                active.set(serializedKey, stream);
+            }
+        }
+        this.subscriptions = [...active.values()];
+        this.logger.debug('Collected stream subscriptions', this.subscriptions);
+        this.connectionManager.syncStreamImplementation?.updateSubscriptions(this.subscriptions);
+    }
+    updateSubscriptions(port, subscriptions) {
+        port.currentSubscriptions = subscriptions;
+        this.collectActiveSubscriptions();
+    }
     setLogLevel(level) {
         this.logger.setLevel(level);
         this.broadCastLogger.setLevel(level);
@@ -111,6 +129,7 @@ export class SharedSyncImplementation extends BaseObserver {
      */
     async setParams(params) {
         await this.portMutex.runExclusive(async () => {
+            this.collectActiveSubscriptions();
             if (this.syncParams) {
                 // Cannot modify already existing sync implementation params
                 // But we can ask for a DB adapter, if required, at this point.
@@ -156,10 +175,12 @@ export class SharedSyncImplementation extends BaseObserver {
      * Adds a new client tab's message port to the list of connected ports
      */
     async addPort(port) {
-        await this.portMutex.runExclusive(() => {
+        return await this.portMutex.runExclusive(() => {
             const portProvider = {
                 port,
-                clientProvider: Comlink.wrap(port)
+                clientProvider: Comlink.wrap(port),
+                currentSubscriptions: [],
+                closeListeners: []
             };
             this.ports.push(portProvider);
             // Give the newly connected client the latest status
@@ -167,6 +188,7 @@ export class SharedSyncImplementation extends BaseObserver {
             if (status) {
                 portProvider.clientProvider.statusChanged(status.toJSON());
             }
+            return portProvider;
         });
     }
     /**
@@ -178,7 +200,7 @@ export class SharedSyncImplementation extends BaseObserver {
         // Warns if the port is not found. This should not happen in practice.
         // We return early if the port is not found.
         const { trackedPort, shouldReconnect } = await this.portMutex.runExclusive(async () => {
-            const index = this.ports.findIndex((p) => p.port == port);
+            const index = this.ports.findIndex((p) => p == port);
             if (index < 0) {
                 this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
                 return {};
@@ -191,7 +213,7 @@ export class SharedSyncImplementation extends BaseObserver {
              * not resolve. Abort them here.
              */
             [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-                if (abortController?.activePort.port == port) {
+                if (abortController?.activePort == port) {
                     abortController.controller.abort(new AbortOperation('Closing pending requests after client port is removed'));
                 }
             });
@@ -205,19 +227,20 @@ export class SharedSyncImplementation extends BaseObserver {
             // We could not find the port to remove
             return () => { };
         }
+        for (const closeListener of trackedPort.closeListeners) {
+            closeListener();
+        }
         if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
-            if (shouldReconnect) {
-                await this.connectionManager.disconnect();
-            }
+            // Unconditionally close the connection because the database it's writing to has just been closed.
+            await this.connectionManager.disconnect();
             // Clearing the adapter will result in a new one being opened in connect
             this.dbAdapter = null;
             if (shouldReconnect) {
                 await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions ?? {});
             }
         }
-        if (trackedPort.db) {
-            await trackedPort.db.close();
-        }
+        // Re-index subscriptions, the subscriptions of the removed port would no longer be considered.
+        this.collectActiveSubscriptions();
         // Release proxy
         return () => trackedPort.clientProvider[Comlink.releaseProxy]();
     }
@@ -312,6 +335,7 @@ export class SharedSyncImplementation extends BaseObserver {
                 });
             },
             ...syncParams.streamOptions,
+            subscriptions: this.subscriptions,
             // Logger cannot be transferred just yet
             logger: this.logger
         });
@@ -329,11 +353,20 @@ export class SharedSyncImplementation extends BaseObserver {
         const locked = new LockedAsyncDatabaseAdapter({
             name: identifier,
             openConnection: async () => {
-                return new WorkerWrappedAsyncDatabaseConnection({
+                const wrapped = new WorkerWrappedAsyncDatabaseConnection({
                     remote,
                     baseConnection: db,
-                    identifier
+                    identifier,
+                    // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
+                    // that and ensure pending requests are aborted when the tab is closed.
+                    remoteCanCloseUnexpectedly: true
+                });
+                lastClient.closeListeners.push(() => {
+                    this.logger.info('Aborting open connection because associated tab closed.');
+                    wrapped.close();
+                    wrapped.markRemoteClosed();
                 });
+                return wrapped;
             },
             logger: this.logger
         });

package/lib/src/worker/sync/SharedSyncImplementation.worker.js

@@ -1,27 +1,11 @@
 import { createBaseLogger } from '@powersync/common';
-import * as Comlink from 'comlink';
-import { SharedSyncClientEvent, SharedSyncImplementation } from './SharedSyncImplementation';
+import { SharedSyncImplementation } from './SharedSyncImplementation';
+import { WorkerClient } from './WorkerClient';
 const _self = self;
 const logger = createBaseLogger();
 logger.useDefaults();
 const sharedSyncImplementation = new SharedSyncImplementation();
 _self.onconnect = async function (event) {
     const port = event.ports[0];
-    /**
-     * Adds an extra listener which can remove this port
-     * from the list of monitored ports.
-     */
-    port.addEventListener('message', async (event) => {
-        const payload = event.data;
-        if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
-            const release = await sharedSyncImplementation.removePort(port);
-            port.postMessage({
-                event: SharedSyncClientEvent.CLOSE_ACK,
-                data: {}
-            });
-            release?.();
-        }
-    });
-    await sharedSyncImplementation.addPort(port);
-    Comlink.expose(sharedSyncImplementation, port);
+    await new WorkerClient(sharedSyncImplementation, port).initialize();
 };

package/lib/src/worker/sync/WorkerClient.d.ts

@@ -0,0 +1,32 @@
+import { SharedSyncImplementation, SharedSyncInitOptions } from './SharedSyncImplementation';
+import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream, SyncStatusOptions } from '@powersync/common';
+/**
+ * A client to the shared sync worker.
+ *
+ * The shared sync implementation needs a per-client view of subscriptions so that subscriptions of closed tabs can
+ * automatically be evicted later.
+ */
+export declare class WorkerClient {
+    private readonly sync;
+    private readonly port;
+    private resolvedPort;
+    constructor(sync: SharedSyncImplementation, port: MessagePort);
+    initialize(): Promise<void>;
+    private removePort;
+    /**
+     * Called by a client after obtaining a lock with a random name.
+     *
+     * When the client tab is closed, its lock will be returned. So when the shared worker attempts to acquire the lock,
+     * it can consider the connection to be closed.
+     */
+    addLockBasedCloseSignal(name: string): void;
+    setLogLevel(level: ILogLevel): void;
+    triggerCrudUpload(): void;
+    setParams(params: SharedSyncInitOptions, subscriptions: SubscribedStream[]): Promise<void>;
+    getWriteCheckpoint(): Promise<string>;
+    hasCompletedSync(): Promise<boolean>;
+    connect(options?: PowerSyncConnectionOptions): Promise<void>;
+    updateSubscriptions(subscriptions: SubscribedStream[]): void;
+    disconnect(): Promise<void>;
+    _testUpdateAllStatuses(status: SyncStatusOptions): Promise<void>;
+}