@powersync/web 1.39.0 → 2.1.0

package/src/db/adapters/wa-sqlite/vfs.ts

@@ -1,5 +1,5 @@
 import type * as SQLite from '@journeyapps/wa-sqlite';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+import { RawWaSqliteDatabaseOptions } from './RawSqliteConnection.js';
 
 /**
  * List of currently tested virtual filesystems
@@ -32,6 +32,11 @@ export function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS) {
   return vfs != WASQLiteVFS.IDBBatchAtomicVFS && vfs != WASQLiteVFS.InMemoryVfs;
 }
 
+/**
+ * @internal
+ */
+export type WASQLiteModuleFactoryOptions = { dbFileName: string; encryptionKey?: string };
+
 /**
  * @internal
  */
@@ -62,9 +67,9 @@ async function syncModuleFactory(encryptionKey: string | undefined): Promise<SQL
  */
 export async function loadModuleAndVfs({
   vfs,
-  dbFilename,
+  filename,
   encryptionKey
-}: ResolvedWASQLiteOpenFactoryOptions): Promise<{ module: SQLiteModule; vfs: SQLiteVFS }> {
+}: RawWaSqliteDatabaseOptions): Promise<{ module: SQLiteModule; vfs: SQLiteVFS }> {
   let moduleFactory = syncModuleFactory;
   let resolveVfs: (module: any) => Promise<SQLiteVFS>;
 
@@ -74,32 +79,32 @@ export async function loadModuleAndVfs({
       const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
       resolveVfs = (module) => {
         // @ts-expect-error The types for this static method are missing upstream
-        return IDBBatchAtomicVFS.create(dbFilename, module, { lockPolicy: 'exclusive' });
+        return IDBBatchAtomicVFS.create(filename, module, { lockPolicy: 'exclusive' });
       };
       break;
     }
     case WASQLiteVFS.AccessHandlePoolVFS: {
       // @ts-expect-error The types for this import are missing upstream
       const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
-      resolveVfs = (module) => AccessHandlePoolVFS.create(dbFilename, module);
+      resolveVfs = (module) => AccessHandlePoolVFS.create(filename, module);
       break;
     }
     case WASQLiteVFS.OPFSCoopSyncVFS: {
       // @ts-expect-error The types for this import are missing upstream
       const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
-      resolveVfs = (module) => OPFSCoopSyncVFS.create(dbFilename, module);
+      resolveVfs = (module) => OPFSCoopSyncVFS.create(filename, module);
       break;
     }
     case WASQLiteVFS.OPFSWriteAheadVFS: {
       // @ts-expect-error The types for this import are missing upstream
       const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
-      resolveVfs = (module) => OPFSWriteAheadVFS.create(dbFilename, module, {});
+      resolveVfs = (module) => OPFSWriteAheadVFS.create(filename, module, {});
       break;
     }
     case WASQLiteVFS.InMemoryVfs: {
       const { MemoryVFS } = await import('@journeyapps/wa-sqlite/src/examples/MemoryVFS.js');
       // @ts-expect-error The types for this static method are missing upstream
-      resolveVfs = (module) => MemoryVFS.create(dbFilename, module);
+      resolveVfs = (module) => MemoryVFS.create(filename, module);
       break;
     }
   }

package/src/db/sync/SSRWebStreamingSyncImplementation.ts

@@ -1,14 +1,5 @@
-import {
-  AbstractStreamingSyncImplementationOptions,
-  BaseObserver,
-  LockOptions,
-  LockType,
-  Mutex,
-  PowerSyncConnectionOptions,
-  StreamingSyncImplementation,
-  SyncStatus,
-  SyncStatusOptions
-} from '@powersync/common';
+import { BaseObserver, SyncStatus } from '@powersync/common';
+import { Mutex, StreamingSyncImplementation, LockOptions, LockType } from '@powersync/shared-internals';
 
 export class SSRStreamingSyncImplementation extends BaseObserver implements StreamingSyncImplementation {
   syncMutex: Mutex;
@@ -16,13 +7,11 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
 
   isConnected: boolean;
   lastSyncedAt?: Date | undefined;
-  syncStatus: SyncStatus;
 
-  constructor(options: AbstractStreamingSyncImplementationOptions) {
+  constructor() {
     super();
     this.syncMutex = new Mutex();
     this.crudMutex = new Mutex();
-    this.syncStatus = new SyncStatus({});
     this.isConnected = false;
   }
 
@@ -34,7 +23,7 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
   /**
    * This is a no-op in SSR mode
    */
-  async connect(options?: PowerSyncConnectionOptions): Promise<void> {}
+  async connect(): Promise<void> {}
 
   async dispose() {}
 
@@ -48,13 +37,6 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
    */
   async waitForReady() {}
 
-  /**
-   * This will never resolve in SSR Mode.
-   */
-  async waitForStatus(status: SyncStatusOptions) {
-    return this.waitUntilStatusMatches(() => false);
-  }
-
   /**
    * This will never resolve in SSR Mode.
    */

package/src/db/sync/SharedWebStreamingSyncImplementation.ts

@@ -1,21 +1,16 @@
-import {
-  PowerSyncConnectionOptions,
-  PowerSyncCredentials,
-  SubscribedStream,
-  SyncStatusOptions
-} from '@powersync/common';
+import { LogRecord, PowerSyncCredentials } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator.js';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
 import { ManualSharedSyncPayload, SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation.js';
 import { WorkerClient } from '../../worker/sync/WorkerClient.js';
 import { WebDBAdapter } from '../adapters/WebDBAdapter.js';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags.js';
 import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
 } from './WebStreamingSyncImplementation.js';
 import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
+import { SubscribedStream, SyncStatusJson, ResolvedSyncOptions } from '@powersync/shared-internals';
+import { connectToExistingWorker, connectToWorker, WorkerConnection } from '../../worker/client.js';
 
 /**
  * The shared worker will trigger methods on this side of the message port
@@ -24,7 +19,7 @@ import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
 class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
   constructor(
     protected options: WebStreamingSyncImplementationOptions,
-    public statusChanged: (status: SyncStatusOptions) => void,
+    public statusChanged: (status: SyncStatusJson) => void,
     protected webDB: WebDBAdapter
   ) {
     super();
@@ -68,34 +63,15 @@ class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
     return this.options.logger;
   }
 
-  trace(...x: any[]): void {
-    this.logger?.trace(...x);
-  }
-  debug(...x: any[]): void {
-    this.logger?.debug(...x);
-  }
-  info(...x: any[]): void {
-    this.logger?.info(...x);
-  }
-  log(...x: any[]): void {
-    this.logger?.log(...x);
-  }
-  warn(...x: any[]): void {
-    this.logger?.warn(...x);
-  }
-  error(...x: any[]): void {
-    this.logger?.error(...x);
-  }
-  time(label: string): void {
-    this.logger?.time(label);
-  }
-  timeEnd(label: string): void {
-    this.logger?.timeEnd(label);
+  log(record: LogRecord): void {
+    this.logger.log(record);
   }
 }
 
 export interface SharedWebStreamingSyncImplementationOptions extends WebStreamingSyncImplementationOptions {
+  logLevel: number;
   db: WebDBAdapter;
+  enableBroadcastLogs: boolean;
 }
 
 /**
@@ -104,46 +80,31 @@ export interface SharedWebStreamingSyncImplementationOptions extends WebStreamin
 export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
   protected syncManager: Comlink.Remote<WorkerClient>;
   protected clientProvider: SharedSyncClientProvider;
-  protected messagePort: MessagePort;
+  protected worker: WorkerConnection;
 
   protected isInitialized: Promise<void>;
   protected dbAdapter: WebDBAdapter;
   private abortOnClose = new AbortController();
+  private logLevel: number;
+  private enableBroadcastLogs: boolean;
 
   constructor(options: SharedWebStreamingSyncImplementationOptions) {
     super(options);
     this.dbAdapter = options.db;
-    /**
-     * Configure or connect to the shared sync worker.
-     * This worker will manage all syncing operations remotely.
-     */
-    const resolvedWorkerOptions = {
-      dbFilename: this.options.identifier!,
-      temporaryStorage: TemporaryStorageOption.MEMORY,
-      cacheSizeKb: DEFAULT_CACHE_SIZE_KB,
-      ...options,
-      flags: resolveWebSQLFlags(options.flags)
-    };
+    this.logLevel = options.logLevel;
+    this.enableBroadcastLogs = options.enableBroadcastLogs;
 
     const syncWorker = options.sync?.worker;
-    if (syncWorker) {
-      if (typeof syncWorker === 'function') {
-        this.messagePort = syncWorker(resolvedWorkerOptions).port;
-      } else {
-        this.messagePort = new SharedWorker(`${syncWorker}`, {
-          /* @vite-ignore */
-          name: `shared-sync-${this.webOptions.identifier}`
-        }).port;
-      }
+    if (typeof syncWorker === 'function') {
+      this.worker = connectToExistingWorker(syncWorker(), options.logger, 'sync');
     } else {
-      this.messagePort = new SharedWorker(
-        new URL('../../worker/sync/SharedSyncImplementation.worker.js', import.meta.url),
-        {
-          /* @vite-ignore */
-          name: `shared-sync-${this.webOptions.identifier}`,
-          type: 'module'
-        }
-      ).port;
+      this.worker = connectToWorker({
+        service: 'sync',
+        databaseIdentifier: this.webOptions.identifier!,
+        shared: true,
+        customWorker: syncWorker,
+        loggerForErrors: options.logger
+      });
     }
 
     /**
@@ -151,21 +112,21 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      */
     this.clientProvider = new SharedSyncClientProvider(
       this.webOptions,
-      (status) => {
-        this.updateSyncStatus(status);
+      ({ core, dataFlow }) => {
+        this.updateSyncStatus(core, dataFlow);
       },
       options.db
     );
 
-    this.syncManager = Comlink.wrap<WorkerClient>(this.messagePort);
+    this.syncManager = Comlink.wrap<WorkerClient>(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.messagePort);
+    Comlink.expose(this.clientProvider, this.worker.endpoint);
 
-    this.syncManager.setLogLevel(this.logger.getLevel());
+    this.syncManager.setLogLevel(this.logLevel);
 
     this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
 
@@ -197,18 +158,16 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     // Awaiting here ensures the worker is waiting for the lock
     await this.syncManager.addLockBasedCloseSignal(closeSignal);
 
-    const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
-    const flags = { ...this.webOptions.flags, workers: undefined };
+    const { identifier } = this.options;
 
     await this.syncManager.setParams(
       {
         dbParams: this.dbAdapter.getConfiguration(),
         streamOptions: {
-          crudUploadThrottleMs,
           identifier,
-          retryDelayMs,
-          flags: flags
-        }
+          serializedSchema: this.options.serializedSchema
+        },
+        enableBroadcastLogs: this.enableBroadcastLogs
       },
       this.options.subscriptions
     );
@@ -218,9 +177,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
    * Starts the sync process, this effectively acts as a call to
    * `connect` if not yet connected.
    */
-  async connect(options?: PowerSyncConnectionOptions): Promise<void> {
+  async connect(options: ResolvedSyncOptions): Promise<void> {
     await this.waitForReady();
-    return this.syncManager.connect(options);
+    return this.syncManager.connect(options, this.options.serializedSchema);
   }
 
   async disconnect(): Promise<void> {
@@ -237,8 +196,11 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     await this.waitForReady();
 
     await new Promise<void>((resolve) => {
+      // This will always be a message port since we use shared workers.
+      const messagePort = this.worker.endpoint as MessagePort;
+
       // Listen for the close acknowledgment from the worker
-      this.messagePort.addEventListener('message', (event) => {
+      messagePort.addEventListener('message', (event) => {
         const payload = event.data as ManualSharedSyncPayload;
         if (payload?.event === SharedSyncClientEvent.CLOSE_ACK) {
           resolve();
@@ -250,7 +212,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         event: SharedSyncClientEvent.CLOSE_CLIENT,
         data: {}
       };
-      this.messagePort.postMessage(closeMessagePayload);
+      messagePort.postMessage(closeMessagePayload);
     });
 
     await super.dispose();
@@ -259,7 +221,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
 
     // Release the proxy
     this.syncManager[Comlink.releaseProxy]();
-    this.messagePort.close();
+    this.worker.close();
   }
 
   async waitForReady() {

package/src/db/sync/TabLocalStreamingSyncImplementation.ts

@@ -0,0 +1,90 @@
+import {
+  LockOptions,
+  LockType,
+  SubscribedStream,
+  SyncStatusJson,
+  SyncStatusSnapshot
+} from '@powersync/shared-internals';
+import {
+  WebStreamingSyncImplementation,
+  WebStreamingSyncImplementationOptions
+} from './WebStreamingSyncImplementation.js';
+
+/**
+ * When multi-tab support is disabled and we don't use a shared worker for sync, only a single tab will be able to
+ * acquire the sync navigator lock and start a sync iteration.
+ *
+ * To be able to provide _some_ multi-tab support in that configuration, this utility:
+ *
+ * 1. Sends sync status updates from the syncing tab to others.
+ * 2. Allows other tabs to send notifications when their active sync stream subscriptions update, allowing the active
+ *    tab to take those subscriptions into account.
+ */
+export class TabLocalStreamingSyncImplementation extends WebStreamingSyncImplementation {
+  #statusUpdated: BroadcastChannel;
+  #subscriptionsChanged: BroadcastChannel;
+  #hasSyncLock = false;
+
+  constructor(options: WebStreamingSyncImplementationOptions) {
+    super(options);
+
+    const identifier = options.identifier;
+    this.#statusUpdated = new BroadcastChannel(`sync-status-${identifier}`);
+    this.#subscriptionsChanged = new BroadcastChannel(`subscription-change-${identifier}`);
+
+    this.#statusUpdated.onmessage = (event) => {
+      if (event.data == 'ping') {
+        this.#sendStatus(this.syncStatus);
+        return;
+      }
+
+      const { core, dataFlow } = event.data as SyncStatusJson;
+      this.updateSyncStatus(core, dataFlow);
+    };
+
+    // Request other tabs to share their sync status.
+    this.#statusUpdated.postMessage('ping');
+    this.#subscriptionsChanged.onmessage = () => {
+      // We can't update activeStreams since we don't know when another tab referencing them is closed. However,
+      // clients will update an internal table listing streams after subscribing, and updateSubscriptions() will
+      // scan that table.
+      super.updateSubscriptions(this.activeStreams);
+    };
+
+    this.registerListener({
+      statusChanged: (status) => this.#sendStatus(status)
+    });
+  }
+
+  #sendStatus(status: SyncStatusSnapshot) {
+    // Don't share sync status if this is not the tab currently syncing.
+    if (this.#hasSyncLock) {
+      this.#statusUpdated.postMessage(status.toJSON());
+    }
+  }
+
+  override updateSubscriptions(subscriptions: SubscribedStream[]): void {
+    super.updateSubscriptions(subscriptions);
+    this.#subscriptionsChanged.postMessage('');
+  }
+
+  override obtainLock<T>({ callback, type, signal }: LockOptions<T>): Promise<T> {
+    const wrappedCallback = async (): Promise<T> => {
+      this.#hasSyncLock = true;
+
+      try {
+        return await callback();
+      } finally {
+        this.#hasSyncLock = false;
+      }
+    };
+
+    return super.obtainLock({ callback: type == LockType.SYNC ? wrappedCallback : callback, type, signal });
+  }
+
+  override async dispose(): Promise<void> {
+    this.#statusUpdated.close();
+    this.#subscriptionsChanged.close();
+    await super.dispose();
+  }
+}

package/src/db/sync/WebRemote.ts

@@ -1,43 +1,40 @@
-import {
-  AbstractRemote,
-  AbstractRemoteOptions,
-  DEFAULT_REMOTE_LOGGER,
-  FetchImplementation,
-  FetchImplementationProvider,
-  ILogger,
-  RemoteConnector
-} from '@powersync/common';
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
+import { AbstractRemote, FetchOptions, RemoteConnector } from '@powersync/shared-internals';
 
 import { getUserAgentInfo } from './userAgent.js';
-
-/*
- * Depends on browser's implementation of global fetch.
- */
-class WebFetchProvider extends FetchImplementationProvider {
-  getFetch(): FetchImplementation {
-    return fetch.bind(globalThis);
-  }
-}
+import type { WebSocketSyncStreamPlatform, WebSocketSupport } from '@powersync/shared-internals/websockets';
 
 export class WebRemote extends AbstractRemote {
   constructor(
     protected connector: RemoteConnector,
-    protected logger: ILogger = DEFAULT_REMOTE_LOGGER,
-    options?: Partial<AbstractRemoteOptions>
+    logger: PowerSyncLogger
   ) {
-    super(connector, logger, {
-      ...(options ?? {}),
-      fetchImplementation: options?.fetchImplementation ?? new WebFetchProvider()
-    });
+    super(connector, logger);
+  }
+
+  protected fetch({ resource, request }: FetchOptions): Promise<Response> {
+    return fetch(resource, request);
+  }
+
+  protected async loadWebSocketSupport(platform: WebSocketSyncStreamPlatform): Promise<WebSocketSupport> {
+    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(): string {
     let ua = [super.getUserAgent(), `powersync-web`];
     try {
       ua.push(...getUserAgentInfo());
-    } catch (e) {
-      this.logger.warn('Failed to get user agent info', e);
+    } catch (error) {
+      this.logger.log({ level: LogLevels.warn, message: 'Failed to get user agent info', error });
     }
     return ua.join(' ');
   }
 }
+
+let websockets: WebSocketSupport | undefined;

package/src/db/sync/WebStreamingSyncImplementation.ts

@@ -1,16 +1,15 @@
+import { LogLevels } from '@powersync/common';
 import {
   AbstractStreamingSyncImplementation,
   AbstractStreamingSyncImplementationOptions,
   LockOptions,
   LockType
-} from '@powersync/common';
+} from '@powersync/shared-internals';
 import { getNavigatorLocks } from '../../shared/navigator.js';
-import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags.js';
 
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
-  flags?: WebSQLFlags;
   sync?: {
-    worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => SharedWorker);
+    worker?: string | URL | (() => SharedWorker);
   };
 }
 
@@ -27,7 +26,7 @@ export class WebStreamingSyncImplementation extends AbstractStreamingSyncImpleme
   async obtainLock<T>(lockOptions: LockOptions<T>): Promise<T> {
     const identifier = `streaming-sync-${lockOptions.type}-${this.webOptions.identifier}`;
     if (lockOptions.type == LockType.SYNC) {
-      this.logger.debug('requesting lock for ', identifier);
+      this.logger.log({ level: LogLevels.debug, message: `requesting lock for ${identifier}` });
     }
     return getNavigatorLocks().request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
   }

package/src/index.ts

@@ -1,10 +1,8 @@
 export * from '@powersync/common';
 export * from './attachments/IndexDBFileSystemAdapter.js';
-export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
 export { WASQLiteVFS } from './db/adapters/wa-sqlite/vfs.js';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
-export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
-export * from './db/adapters/web-sql-flags.js';
+export * from './db/adapters/options.js';
 export * from './db/PowerSyncDatabase.js';
 export * from './db/sync/SharedWebStreamingSyncImplementation.js';
 export * from './db/sync/WebRemote.js';

package/src/worker/SharedWorkerConnectionRequest.ts

@@ -0,0 +1,6 @@
+export type WorkerService = 'database' | 'sync';
+
+export interface SharedWorkerConnectionRequest {
+  service: WorkerService;
+  port: MessagePort;
+}

package/src/worker/client.ts

@@ -0,0 +1,121 @@
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
+import { SharedWorkerConnectionRequest, WorkerService } from './SharedWorkerConnectionRequest.js';
+
+export interface OpenWorkerOptions {
+  service: WorkerService;
+  databaseIdentifier: string;
+  customWorker?: string | URL;
+  shared: boolean;
+  loggerForErrors: PowerSyncLogger;
+}
+
+export interface WorkerConnection {
+  endpoint: MessagePort | Worker;
+  worker: Worker | SharedWorker;
+  close: () => void;
+}
+
+export function connectToWorker({
+  service,
+  databaseIdentifier,
+  customWorker,
+  shared,
+  loggerForErrors
+}: OpenWorkerOptions): WorkerConnection {
+  const name = `${shared ? 'shared-' : ''}powersync-${databaseIdentifier}`;
+  let worker: Worker | SharedWorker;
+
+  if (customWorker) {
+    worker = shared
+      ? new SharedWorker(customWorker, {
+          /* @vite-ignore */
+          name,
+          type: 'module'
+        })
+      : new Worker(customWorker, {
+          /* @vite-ignore */
+          name,
+          type: 'module'
+        });
+  } else {
+    worker = spawnDefaultPowerSyncWorker(shared, name);
+  }
+
+  return connectToExistingWorker(worker, loggerForErrors, service);
+}
+
+/**
+ * Opens the default PowerSync worker.
+ *
+ * When users depend on the web SDK, we assume they use their own bundler (either vite or webpack). Both recognize the
+ * syntax of worker constructors with a string literal and will rewrite the URL as part of their bundling processes.
+ *
+ * React Native / Metro users can't rely on this on the web, as their app is not a JavaScript module and import.meta.url
+ * is not rewritten by Metro. For those users, we include a pre-bundled worker they can copy into a static assets
+ * directory and load with a custom URI. This also means that defaultWorker cannot work with Metro for React Native Web.
+ * We have a custom rollup plugin and conditional exports that replaces this function with a throwing stub for that
+ * platform. This allows a helpful error message.
+ */
+// Note: When changing this function, also update disableDefaultWorkers in rollup.config.ts.
+function spawnDefaultPowerSyncWorker(shared: boolean, name: string): Worker | SharedWorker {
+  return shared
+    ? new SharedWorker(new URL('./worker.js', import.meta.url), {
+        /* @vite-ignore */
+        name,
+        type: 'module'
+      })
+    : new Worker(new URL('./worker.js', import.meta.url), {
+        /* @vite-ignore */
+        name,
+        type: 'module'
+      });
+}
+
+export function connectToExistingWorker(
+  worker: Worker | SharedWorker,
+  logger: PowerSyncLogger,
+  service: WorkerService
+): WorkerConnection {
+  function logError(event: ErrorEvent) {
+    // TODO: Ideally, we should be able to handle worker errors by forwarding them to async Comlink callers.
+    // Currently, comlink calls on errored workers would just be stuck forever.
+    logger.log({
+      level: LogLevels.error,
+      error: event.error,
+      message: 'Error in database or sync worker, this likely disrupts PowerSync.'
+    });
+  }
+
+  (worker as AbstractWorker).addEventListener('error', logError);
+
+  const isShared = isSharedWorker(worker);
+  if (isShared) {
+    const { port1, port2 } = new MessageChannel();
+    const mainPort = (worker as SharedWorker).port;
+    mainPort.start();
+    mainPort.postMessage({ port: port1, service } satisfies SharedWorkerConnectionRequest, [port1]);
+
+    port2.start();
+    return {
+      endpoint: port2,
+      worker,
+      close() {
+        worker.removeEventListener('error', logError);
+        port2.close();
+      }
+    };
+  } else {
+    return {
+      endpoint: worker as Worker,
+      worker,
+      close() {
+        worker.removeEventListener('error', logError);
+        worker.terminate();
+      }
+    };
+  }
+}
+
+export function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker {
+  return 'port' in worker;
+}