@powersync/web 0.0.0-dev-20260504100448 → 0.0.0-dev-20260630144038

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

@@ -1,70 +1,31 @@
-import { createLogger, DBAdapter, ILogger, SQLOpenFactory, type ILogLevel } from '@powersync/common';
+import { DBAdapter, LogLevels, PowerSyncLogger, SQLOpenFactory } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
-import {
-  DEFAULT_CACHE_SIZE_KB,
-  isServerSide,
-  ResolvedWebSQLFlags,
-  ResolvedWebSQLOpenOptions,
-  resolveWebSQLFlags,
-  TemporaryStorageOption,
-  WebSQLOpenFactoryOptions
-} from '../web-sql-flags.js';
+import { ResolvedWebSQLOpenOptions, WebSQLOpenOptions } from '../options.js';
 import { SSRDBAdapter } from '../SSRDBAdapter.js';
 import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './vfs.js';
 import { MultiDatabaseServer } from '../../../worker/db/MultiDatabaseServer.js';
 import { DatabaseClient, OpenWorkerConnection } from './DatabaseClient.js';
 import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
 import { AsyncDbAdapter, PoolConnection } from '../AsyncWebAdapter.js';
+import { RawWaSqliteDatabaseOptions } from './RawSqliteConnection.js';
+import { resolveAndValidateOptions } from '../resolveAndValidateOptions.js';
+import { connectToExistingWorker, connectToWorker, WorkerConnection } from '../../../worker/client.js';
 
-export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
-  vfs?: WASQLiteVFS;
-  /**
-   * If the {@link vfs} supports it, an additional amount of read-only connections to open. Using additional read
-   * connections can speed up queries by dispatching them to multiple workers running them concurrently.
-   *
-   * {@link WASQLiteVFS.OPFSWriteAheadVFS} is the only VFS with support for multiple connections, so this option is
-   * ignored for other VFS implementations.
-   *
-   * Defaults to 1.
-   */
-  additionalReaders?: number;
-}
-
-export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
-  vfs: WASQLiteVFS;
-
-  /**
-   * Whether this is a read-only connection opened for the `OPFSWriteAheadVFS` file system.
-   */
-  isReadOnly: boolean;
-}
-
-export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
-  logLevel: ILogLevel;
-  /**
-   * A lock that is currently held by the client. When the lock is returned, we know the client is gone and that we need
-   * to clean up resources.
-   */
-  lockName: string;
+export interface WASQLiteOpenFactoryOptions {
+  open: WebSQLOpenOptions;
+  logger: PowerSyncLogger;
 }
 
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
 export class WASQLiteOpenFactory implements SQLOpenFactory {
-  private resolvedFlags: ResolvedWebSQLFlags;
-  private logger: ILogger;
-
-  constructor(private options: WASQLiteOpenFactoryOptions) {
-    assertValidWASQLiteOpenFactoryOptions(options);
-    this.resolvedFlags = resolveWebSQLFlags(options.flags);
-    this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
-  }
+  private options: ResolvedWebSQLOpenOptions;
+  private logger: PowerSyncLogger;
 
-  get waOptions(): WASQLiteOpenFactoryOptions {
-    // Cast to extended type
-    return this.options;
+  constructor(options: WASQLiteOpenFactoryOptions) {
+    this.options = resolveAndValidateOptions(options.open);
+    this.logger = options.logger;
   }
 
   protected openAdapter(): DBAdapter {
@@ -72,84 +33,80 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
   }
 
   openDB(): DBAdapter {
-    const {
-      resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() }
-    } = this;
+    const { disableSSRWarning, enableMultiTabs, ssrMode } = this.options;
+
     if (ssrMode) {
       if (!disableSSRWarning) {
-        this.logger.warn(
-          `
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `
       Running PowerSync in SSR mode.
       Only empty query results will be returned.
       Disable this warning by setting 'disableSSRWarning: true' in options.`
-        );
+        });
       }
 
       return new SSRDBAdapter();
     }
 
     if (!enableMultiTabs) {
-      this.logger.warn(
-        'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
-      );
+      this.logger.log({
+        level: LogLevels.warn,
+        message: 'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
+      });
     }
 
     return this.openAdapter();
   }
 
   async openConnection(): Promise<PoolConnection> {
-    const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
-    const {
-      vfs = WASQLiteVFS.IDBBatchAtomicVFS,
-      temporaryStorage = TemporaryStorageOption.MEMORY,
-      cacheSizeKb = DEFAULT_CACHE_SIZE_KB,
-      encryptionKey
-    } = this.waOptions;
+    const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb } =
+      this.options;
 
     if (!enableMultiTabs) {
-      this.logger.warn('Multiple tabs are not enabled in this browser');
+      this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
     }
 
-    const resolveOptions = (isReadOnly: boolean): ResolvedWASQLiteOpenFactoryOptions => ({
-      dbFilename: this.options.dbFilename,
-      dbLocation: this.options.dbLocation,
-      debugMode: this.options.debugMode,
-      vfs,
-      temporaryStorage,
-      cacheSizeKb,
-      flags: this.resolvedFlags,
-      encryptionKey: encryptionKey,
-      isReadOnly
-    });
-
     let client: DatabaseClient;
     let additionalReaders: DatabaseClient[] = [];
     let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
 
+    function resolveRawWaSqliteDatabaseOptions(readonly: boolean): RawWaSqliteDatabaseOptions {
+      return {
+        filename: dbFilename,
+        readonly,
+        vfs,
+        encryptionKey,
+        temporaryStorage,
+        cacheSizeKb
+      };
+    }
+
     if (useWebWorker) {
       const optionsDbWorker = this.options.worker;
 
-      const openDatabaseWorker = async (
-        resolvedOptions: ResolvedWASQLiteOpenFactoryOptions
-      ): Promise<DatabaseClient> => {
-        const workerPort =
-          typeof optionsDbWorker == 'function'
-            ? resolveWorkerDatabasePortFactory(() =>
-                optionsDbWorker({
-                  ...this.options,
-                  temporaryStorage,
-                  cacheSizeKb,
-                  flags: this.resolvedFlags,
-                  encryptionKey
-                })
-              )
-            : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
-
-        const source = Comlink.wrap<OpenWorkerConnection>(workerPort);
+      const openDatabaseWorker = async (readonly: boolean): Promise<DatabaseClient> => {
+        let workerConnection: WorkerConnection;
+        if (typeof optionsDbWorker == 'function') {
+          const worker = optionsDbWorker(this.options);
+          workerConnection = connectToExistingWorker(worker, 'database');
+        } else {
+          const needsDedicated = vfsRequiresDedicatedWorkers(vfs);
+          const useShared = !needsDedicated && enableMultiTabs;
+
+          workerConnection = connectToWorker({
+            service: 'database',
+            databaseIdentifier: this.options.dbFilename,
+            shared: useShared,
+            customWorker: optionsDbWorker
+          });
+        }
+
+        const source = Comlink.wrap<OpenWorkerConnection>(workerConnection.endpoint);
         const closeSignal = new AbortController();
         const connection = await source.connect({
-          ...resolvedOptions,
-          logLevel: this.logger.getLevel(),
+          database: resolveRawWaSqliteDatabaseOptions(readonly),
+          logLevel: this.options.databaseWorkerLogLevel,
           lockName: await generateTabCloseSignal(closeSignal.signal)
         });
         const clientOptions = {
@@ -159,28 +116,24 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
           remoteCanCloseUnexpectedly: false,
           onClose: () => {
             closeSignal.abort();
-            if (workerPort instanceof Worker) {
-              workerPort.terminate();
-            } else {
-              workerPort.close();
-            }
+            workerConnection.close();
           }
         };
 
         return new DatabaseClient(clientOptions, {
-          ...resolvedOptions,
+          ...this.options,
           requiresPersistentTriggers
         });
       };
 
-      client = await openDatabaseWorker(resolveOptions(false));
+      client = await openDatabaseWorker(false);
 
       if (vfs == WASQLiteVFS.OPFSWriteAheadVFS) {
         // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
         // concurrent reads / writes.
         const additionalReadersCount = this.options.additionalReaders ?? 1;
         for (let i = 0; i < additionalReadersCount; i++) {
-          const reader = await openDatabaseWorker(resolveOptions(true));
+          const reader = await openDatabaseWorker(true);
           additionalReaders.push(reader);
         }
       }
@@ -189,12 +142,11 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
       const localServer = new MultiDatabaseServer(this.logger);
       requiresPersistentTriggers = true;
 
-      const resolvedOptions = resolveOptions(false);
-      const connection = await localServer.openConnectionLocally(resolvedOptions);
+      const connection = await localServer.openConnectionLocally(this.logger, resolveRawWaSqliteDatabaseOptions(false));
       client = new DatabaseClient(
         { connection, source: null, remoteCanCloseUnexpectedly: false },
         {
-          ...resolvedOptions,
+          ...this.options,
           requiresPersistentTriggers
         }
       );
@@ -206,18 +158,3 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
     };
   }
 }
-
-/**
- * Asserts that the factory options are valid.
- */
-function assertValidWASQLiteOpenFactoryOptions(options: WASQLiteOpenFactoryOptions): void {
-  // The OPFS VFS only works in dedicated web workers.
-  if ('vfs' in options && 'flags' in options) {
-    const { vfs, flags = {} } = options;
-    if (vfs && vfsRequiresDedicatedWorkers(vfs) && 'useWebWorker' in flags && !flags.useWebWorker) {
-      throw new Error(
-        `Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${vfs}).`
-      );
-    }
-  }
-}

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,30 @@ 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(), '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
+      });
     }
 
     /**
@@ -151,21 +111,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 +157,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 +176,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 +195,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 +211,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         event: SharedSyncClientEvent.CLOSE_CLIENT,
         data: {}
       };
-      this.messagePort.postMessage(closeMessagePayload);
+      messagePort.postMessage(closeMessagePayload);
     });
 
     await super.dispose();
@@ -259,7 +220,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/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;
+}