@powersync/web 0.0.0-dev-20250922104723 → 0.0.0-dev-20250922105207

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

@@ -59,6 +59,7 @@ export const DEFAULT_MODULE_FACTORIES = {
     },
     [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
         let module;
+        options.logger?.debug(`Opening VFS with options`, JSON.stringify(options));
         if (options.encryptionKey) {
             module = await MultiCipherSyncWASQLiteModuleFactory();
         }
@@ -67,9 +68,26 @@ export const DEFAULT_MODULE_FACTORIES = {
         }
         // @ts-expect-error The types for this static method are missing upstream
         const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
+        const vfs = new AccessHandlePoolVFS(options.dbFileName, module);
+        // Allow extra logs
+        const proxiedVFS = new Proxy(vfs, {
+            get(target, prop, receiver) {
+                const value = Reflect.get(target, prop, receiver);
+                // Only wrap methods, not properties
+                if (typeof value === 'function') {
+                    return function (...args) {
+                        options.logger?.debug(`VFS: Called ${String(prop)} with:`, args);
+                        return value.apply(vfs, args);
+                    };
+                }
+                return value;
+            }
+        });
+        await vfs.isReady();
+        // const vfs = await AccessHandlePoolVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
+            vfs: proxiedVFS
         };
     },
     [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
@@ -142,7 +160,9 @@ export class WASqliteConnection extends BaseObserver {
     async openSQLiteAPI() {
         const { module, vfs } = await this._moduleFactory({
             dbFileName: this.options.dbFilename,
-            encryptionKey: this.options.encryptionKey
+            encryptionKey: this.options.encryptionKey,
+            debugMode: this.options.debugMode,
+            logger: this.options.logger
         });
         const sqlite3 = SQLite.Factory(module);
         sqlite3.vfs_register(vfs, true);
@@ -180,6 +200,7 @@ export class WASqliteConnection extends BaseObserver {
         }
     }
     async init() {
+        this.options.logger?.debug('Opening WASQLite connection for', this.options.dbFilename);
         this._sqliteAPI = await this.openSQLiteAPI();
         await this.openDB();
         this.registerBroadcastListeners();
@@ -277,6 +298,7 @@ export class WASqliteConnection extends BaseObserver {
         });
     }
     async close() {
+        this.options.logger?.debug('Closing WASQLite connection', this.options.dbFilename);
         this.broadcastChannel?.close();
         await this.sqliteAPI.close(this.dbP);
     }
@@ -325,6 +347,10 @@ export class WASqliteConnection extends BaseObserver {
         return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
     }
     async _execute(sql, bindings) {
+        // TODO, this might be redundant
+        if (this.options.debugMode) {
+            this.options.logger?.debug(`Executing SQL: ${sql}`);
+        }
         const results = [];
         for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
             let columns;

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

@@ -9,7 +9,7 @@ export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
 export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
     vfs: WASQLiteVFS;
 }
-export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+export interface WorkerDBOpenerOptions extends Omit<ResolvedWASQLiteOpenFactoryOptions, 'logger'> {
     logLevel: ILogLevel;
 }
 /**

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

@@ -52,8 +52,12 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                     cacheSizeKb,
                     flags: this.resolvedFlags,
                     encryptionKey: encryptionKey,
-                    logLevel: this.logger.getLevel()
-                }),
+                    logLevel: this.logger.getLevel(),
+                    debugMode: this.options.debugMode
+                }, Comlink.proxy((event) => {
+                    // TODO
+                    this.logger[event.logLevel.toLocaleLowerCase()]('[DB Worker] ', ...event.messages);
+                })),
                 identifier: this.options.dbFilename,
                 onClose: () => {
                     if (workerPort instanceof Worker) {

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

@@ -41,8 +41,4 @@ 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,8 +58,4 @@ 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, SubscribedStream, SyncStatusOptions } from '@powersync/common';
+import { PowerSyncConnectionOptions, PowerSyncCredentials, 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,16 +30,12 @@ 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<WorkerClient>;
+    protected syncManager: Comlink.Remote<SharedSyncImplementation>;
     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
@@ -51,7 +47,6 @@ 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,7 +3,6 @@ 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.
@@ -76,16 +75,12 @@ 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;
@@ -138,7 +133,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
                 retryDelayMs,
                 flags: flags
             }
-        }, options.subscriptions);
+        });
         /**
          * Pass along any sync status updates to this listener
          */
@@ -151,17 +146,6 @@ 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
@@ -200,7 +184,6 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
             };
             this.messagePort.postMessage(closeMessagePayload);
         });
-        this.abortOnClose.abort();
         // Release the proxy
         this.syncManager[Comlink.releaseProxy]();
         this.messagePort.close();
@@ -208,14 +191,11 @@ 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/db/LogHandler.d.ts

@@ -0,0 +1,12 @@
+import { BaseListener, BaseObserver } from '@powersync/common';
+export type LogEvent = {
+    loggerName: string;
+    logLevel: string;
+    messages: string[];
+};
+export interface LogHandlerListener extends BaseListener {
+    onLog: (event: LogEvent) => void;
+}
+export declare class LogHandler extends BaseObserver<LogHandlerListener> {
+    pushLog(entry: LogEvent): void;
+}

package/lib/src/worker/db/LogHandler.js

@@ -0,0 +1,6 @@
+import { BaseObserver } from '@powersync/common';
+export class LogHandler extends BaseObserver {
+    pushLog(entry) {
+        this.iterateListeners((l) => l.onLog?.(entry));
+    }
+}

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -2,21 +2,70 @@
  * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
  */
 import '@journeyapps/wa-sqlite';
-import { createBaseLogger, createLogger } from '@powersync/common';
+import { createBaseLogger, createLogger, LogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
-const baseLogger = createBaseLogger();
-baseLogger.useDefaults();
-const logger = createLogger('db-worker');
+import { LogHandler } from './LogHandler';
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
+function logToAll(logLevel, ...messages) {
+    for (const dbFilename of DBMap.keys()) {
+        logBroadcaster.pushLog({
+            loggerName: dbFilename,
+            logLevel,
+            messages
+        });
+    }
+}
 let nextClientId = 1;
+function logUnhandledException(error) {
+    const errorMessage = `
+  Name: ${error.name}
+  Cause: ${error.cause}
+  Message: ${error.message}
+  Stack: ${error.stack}`.trim();
+    logToAll(LogLevel.ERROR.name, 'Uncaught Exception in DB worker', errorMessage);
+}
+// Report unhandled exceptions to all loggers
+addEventListener('unhandledrejection', (event) => {
+    logUnhandledException(event.reason);
+});
+addEventListener('error', (event) => {
+    logUnhandledException(event.error);
+});
+addEventListener('unload', () => {
+    logToAll(LogLevel.INFO.name, 'DB worker is unloading');
+    Array.from(DBMap.values()).forEach(async (dbConnection) => {
+        const { db, clientIds } = dbConnection;
+        logToAll(LogLevel.INFO.name, `closing db with ids ${clientIds}`);
+        db.close();
+    });
+});
+const baseLogger = createBaseLogger();
+const logBroadcaster = new LogHandler();
+const defaultHandler = baseLogger.createDefaultHandler();
+const logHandler = (messages, context) => {
+    logBroadcaster.pushLog({
+        loggerName: context.name ?? 'unknown',
+        logLevel: context.level.name,
+        messages: messages.map((m) => String(m))
+    });
+    defaultHandler(messages, context);
+};
+baseLogger.useDefaults({
+    formatter: logHandler
+});
+const workerLogger = createLogger('db-worker');
 const openWorkerConnection = async (options) => {
     const connection = new WASqliteConnection(options);
     return {
         init: Comlink.proxy(() => connection.init()),
-        getConfig: Comlink.proxy(() => connection.getConfig()),
+        getConfig: Comlink.proxy(async () => {
+            // Can't send the logger over
+            const { logger, ...rest } = await connection.getConfig();
+            return rest;
+        }),
         close: Comlink.proxy(() => connection.close()),
         execute: Comlink.proxy(async (sql, params) => connection.execute(sql, params)),
         executeRaw: Comlink.proxy(async (sql, params) => connection.executeRaw(sql, params)),
@@ -27,15 +76,34 @@ const openWorkerConnection = async (options) => {
         })
     };
 };
-const openDBShared = async (options) => {
+const openDBShared = async (options, logHandler) => {
     // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
         const { dbFilename, logLevel } = options;
-        logger.setLevel(logLevel);
+        logToAll(`Worker opening DB connection for`, JSON.stringify(options));
+        // This updates the log level for the worker-level logger
+        // The DB connection logger will automatically track the main context logger
+        // since it passes logs to it.
+        workerLogger.setLevel(logLevel);
+        let disposeLogListener = logHandler
+            ? logBroadcaster.registerListener({
+                onLog: (event) => {
+                    if (event.loggerName !== dbFilename) {
+                        return;
+                    }
+                    logHandler(event);
+                }
+            })
+            : null;
         if (!DBMap.has(dbFilename)) {
             const clientIds = new Set();
-            const connection = await openWorkerConnection(options);
+            const logger = createLogger(dbFilename);
+            logger.debug(`Worker opened a new connection`);
+            const connection = await openWorkerConnection({
+                ...options,
+                logger
+            });
             await connection.init();
             DBMap.set(dbFilename, {
                 clientIds,
@@ -52,14 +120,15 @@ const openDBShared = async (options) => {
             }),
             close: Comlink.proxy(async () => {
                 const { clientIds } = dbEntry;
-                logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+                disposeLogListener?.();
+                workerLogger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
                 clientIds.delete(clientId);
                 if (clientIds.size == 0) {
-                    logger.debug(`Closing connection to ${dbFilename}.`);
+                    workerLogger.debug(`Closing connection to ${dbFilename}.`);
                     DBMap.delete(dbFilename);
                     return db.close?.();
                 }
-                logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+                workerLogger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
                 return;
             })
         };
@@ -78,9 +147,3 @@ else {
     // A dedicated worker can be shared externally
     Comlink.expose(openDBShared);
 }
-addEventListener('unload', () => {
-    Array.from(DBMap.values()).forEach(async (dbConnection) => {
-        const { db } = dbConnection;
-        db.close?.();
-    });
-});

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, SubscribedStream, SyncStatus } from '@powersync/common';
+import { type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, ConnectionManager, DBAdapter, 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' | 'subscriptions'>;
+    streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote'>;
     dbParams: ResolvedWebSQLOpenOptions;
 };
 /**
@@ -43,7 +43,6 @@ export type WrappedSyncPort = {
     port: MessagePort;
     clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
     db?: DBAdapter;
-    currentSubscriptions: SubscribedStream[];
 };
 /**
  * @internal
@@ -56,7 +55,7 @@ export type RemoteOperationAbortController = {
  * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
-export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> {
+export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> implements StreamingSyncImplementation {
     protected ports: WrappedSyncPort[];
     protected isInitialized: Promise<void>;
     protected statusListener?: () => void;
@@ -67,7 +66,6 @@ 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;
@@ -77,8 +75,6 @@ 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.
@@ -96,16 +92,12 @@ 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<{
-        port: MessagePort;
-        clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
-        currentSubscriptions: never[];
-    }>;
+    addPort(port: MessagePort): Promise<void>;
     /**
      * Removes a message port client from this manager's managed
      * clients.
      */
-    removePort(port: WrappedSyncPort): Promise<() => void>;
+    removePort(port: MessagePort): Promise<() => void>;
     triggerCrudUpload(): void;
     hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
@@ -121,5 +113,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
      */
-    _testUpdateAllStatuses(status: SyncStatusOptions): Promise<void>;
+    private _testUpdateAllStatuses;
 }

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

@@ -40,7 +40,6 @@ export class SharedSyncImplementation extends BaseObserver {
     logger;
     lastConnectOptions;
     portMutex;
-    subscriptions = [];
     connectionManager;
     syncStatus;
     broadCastLogger;
@@ -103,23 +102,6 @@ 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);
@@ -129,7 +111,6 @@ 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.
@@ -175,11 +156,10 @@ export class SharedSyncImplementation extends BaseObserver {
      * Adds a new client tab's message port to the list of connected ports
      */
     async addPort(port) {
-        return await this.portMutex.runExclusive(() => {
+        await this.portMutex.runExclusive(() => {
             const portProvider = {
                 port,
-                clientProvider: Comlink.wrap(port),
-                currentSubscriptions: []
+                clientProvider: Comlink.wrap(port)
             };
             this.ports.push(portProvider);
             // Give the newly connected client the latest status
@@ -187,7 +167,6 @@ export class SharedSyncImplementation extends BaseObserver {
             if (status) {
                 portProvider.clientProvider.statusChanged(status.toJSON());
             }
-            return portProvider;
         });
     }
     /**
@@ -199,7 +178,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);
+            const index = this.ports.findIndex((p) => p.port == port);
             if (index < 0) {
                 this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
                 return {};
@@ -212,7 +191,7 @@ export class SharedSyncImplementation extends BaseObserver {
              * not resolve. Abort them here.
              */
             [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-                if (abortController?.activePort == port) {
+                if (abortController?.activePort.port == port) {
                     abortController.controller.abort(new AbortOperation('Closing pending requests after client port is removed'));
                 }
             });
@@ -239,8 +218,6 @@ export class SharedSyncImplementation extends BaseObserver {
         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]();
     }
@@ -335,7 +312,6 @@ export class SharedSyncImplementation extends BaseObserver {
                 });
             },
             ...syncParams.streamOptions,
-            subscriptions: this.subscriptions,
             // Logger cannot be transferred just yet
             logger: this.logger
         });

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

@@ -1,11 +1,27 @@
 import { createBaseLogger } from '@powersync/common';
-import { SharedSyncImplementation } from './SharedSyncImplementation';
-import { WorkerClient } from './WorkerClient';
+import * as Comlink from 'comlink';
+import { SharedSyncClientEvent, SharedSyncImplementation } from './SharedSyncImplementation';
 const _self = self;
 const logger = createBaseLogger();
 logger.useDefaults();
 const sharedSyncImplementation = new SharedSyncImplementation();
 _self.onconnect = async function (event) {
     const port = event.ports[0];
-    await new WorkerClient(sharedSyncImplementation, port).initialize();
+    /**
+     * 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);
 };