@powersync/web 0.0.0-dev-20260708104358 → 0.0.0-dev-20260917074240

package/src/worker/sync/SharedSyncImplementation.ts

@@ -1,26 +1,24 @@
 import {
-  AbortOperation,
   BaseObserver,
-  ConnectionManager,
-  ConnectionPool,
   DBAdapter,
-  DBAdapterDefaultMixin,
-  DBAdapterListener,
   DBLockOptions,
   LockContext,
   PowerSyncBackendConnector,
+  SyncStatus,
+  LogLevels,
+  SyncStreamConnectionMethod
+} from '@powersync/common';
+import {
+  AbortOperation,
+  ConnectionManager,
   SqliteBucketStorage,
   SubscribedStream,
-  SyncStatus,
-  createLogger,
-  Mutex,
-  type ILogLevel,
-  type ILogger,
-  type PowerSyncConnectionOptions,
   type StreamingSyncImplementation,
   type StreamingSyncImplementationListener,
-  type SyncStatusOptions
-} from '@powersync/common';
+  Mutex,
+  ResolvedSyncOptions,
+  SyncStatusSnapshot
+} from '@powersync/shared-internals';
 import * as Comlink from 'comlink';
 import { WebRemote } from '../../db/sync/WebRemote.js';
 import {
@@ -28,11 +26,11 @@ import {
   WebStreamingSyncImplementationOptions
 } from '../../db/sync/WebStreamingSyncImplementation.js';
 
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
 import { BroadcastLogger } from './BroadcastLogger.js';
 import { DatabaseClient, OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
 import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/options.js';
 
 /**
  * @internal
@@ -60,8 +58,12 @@ export type ManualSharedSyncPayload = {
  * @internal
  */
 export type SharedSyncInitOptions = {
-  streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote' | 'subscriptions'>;
+  streamOptions: Omit<
+    WebStreamingSyncImplementationOptions,
+    'adapter' | 'uploadCrud' | 'postCheckpointRequest' | 'remote' | 'subscriptions' | 'logger'
+  >;
   dbParams: ResolvedWebSQLOpenOptions;
+  enableBroadcastLogs: boolean;
 };
 
 /**
@@ -83,14 +85,6 @@ export type WrappedSyncPort = {
   isClosing: boolean;
 };
 
-/**
- * @internal
- */
-export type RemoteOperationAbortController = {
-  controller: AbortController;
-  activePort: WrappedSyncPort;
-};
-
 /**
  * HACK: The shared implementation wraps and provides its own
  * PowerSyncBackendConnector when generating the streaming sync implementation.
@@ -98,6 +92,23 @@ export type RemoteOperationAbortController = {
  */
 const CONNECTOR_PLACEHOLDER = {} as PowerSyncBackendConnector;
 
+/**
+ * How long to wait for a client tab to answer a call before giving up on it.
+ */
+const CONNECTOR_CALL_TIMEOUT_MS = 30_000;
+
+type UseConnectorOptions = {
+  /**
+   * Aborted when the sync client disconnects.
+   */
+  signal?: AbortSignal;
+  /**
+   * Fail the call if the tab has not responded within this many milliseconds. `null` waits indefinitely, which is only
+   * appropriate for calls that are unbounded by nature and already covered by {@link UseConnectorOptions.signal}.
+   */
+  timeoutMs?: number | null;
+};
+
 /**
  * @internal
  * Shared sync implementation which runs inside a shared webworker
@@ -108,25 +119,22 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected isInitialized: Promise<void>;
   protected statusListener?: () => void;
 
-  protected fetchCredentialsController?: RemoteOperationAbortController;
-  protected uploadDataController?: RemoteOperationAbortController;
-
   protected syncParams: SharedSyncInitOptions | null;
-  protected logger: ILogger;
-  protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
+  protected lastConnectOptions: ResolvedSyncOptions | undefined;
   protected portMutex: Mutex;
   private subscriptions: SubscribedStream[] = [];
 
   protected connectionManager: ConnectionManager;
-  syncStatus: SyncStatus;
-  broadCastLogger: ILogger;
+  private syncStatus?: SyncStatusSnapshot;
+  logger: BroadcastLogger;
   protected readonly database = this.generateReconnectableDatabase();
 
+  private sharedCloseSignal = generateTabCloseSignal();
+
   constructor() {
     super();
     this.ports = [];
     this.syncParams = null;
-    this.logger = createLogger('shared-sync');
     this.lastConnectOptions = undefined;
     this.portMutex = new Mutex();
 
@@ -139,26 +147,37 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       });
     });
 
-    this.syncStatus = new SyncStatus({});
-    this.broadCastLogger = new BroadcastLogger(this.ports);
+    this.logger = new BroadcastLogger('shared-sync', this.ports);
 
     this.connectionManager = new ConnectionManager({
       createSyncImplementation: async () => {
         await this.waitForReady();
 
         const sync = this.generateStreamingImplementation();
-        const onDispose = sync.registerListener({
-          statusChanged: (status) => {
-            this.updateAllStatuses(status.toJSON());
+        const removeStatusListener = sync.registerListener({
+          statusChanged: (snapshot) => {
+            this.syncStatus = snapshot;
+            const json = snapshot.toJSON();
+            this.ports.forEach((p) => p.clientProvider.statusChanged(json));
           }
         });
 
         return {
           sync,
-          onDispose
+          onDispose: () => {
+            removeStatusListener();
+
+            // Drop the JavaScript state along with the implementation that produced it: it describes in-flight work of
+            // a sync client that no longer exists. `addPort` hands this status to every tab that connects afterwards,
+            // so a `downloadError` left here is shown by tabs that never saw the failure, and nothing can clear it
+            // because only a completed sync does. The core status is kept - `hasSynced` and `lastSyncedAt` are
+            // persisted facts that remain true while disconnected.
+            this.syncStatus &&= new SyncStatusSnapshot(this.syncStatus.core, {});
+          }
         };
       },
-      logger: this.logger
+      logger: this.logger,
+      defaultConnectionMethod: SyncStreamConnectionMethod.HTTP
     });
   }
 
@@ -192,12 +211,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
-  async waitForStatus(status: SyncStatusOptions): Promise<void> {
-    return this.withSyncImplementation(async (sync) => {
-      return sync.waitForStatus(status);
-    });
-  }
-
   async waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void> {
     return this.withSyncImplementation(async (sync) => {
       return sync.waitUntilStatusMatches(predicate);
@@ -209,7 +222,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   }
 
   private collectActiveSubscriptions() {
-    this.logger.debug('Collecting active stream subscriptions across tabs');
+    this.logger.log({ level: LogLevels.debug, message: 'Collecting active stream subscriptions across tabs' });
     const active = new Map<string, SubscribedStream>();
     for (const port of this.ports) {
       for (const stream of port.currentSubscriptions) {
@@ -218,7 +231,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       }
     }
     this.subscriptions = [...active.values()];
-    this.logger.debug('Collected stream subscriptions', this.subscriptions);
+    this.logger.log({
+      level: LogLevels.debug,
+      message: `Collected stream subscriptions, ${JSON.stringify(this.subscriptions)}`
+    });
     this.connectionManager.syncStreamImplementation?.updateSubscriptions(this.subscriptions);
   }
 
@@ -227,9 +243,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     this.collectActiveSubscriptions();
   }
 
-  setLogLevel(level: ILogLevel) {
+  setLogLevel(level: number) {
     this.logger.setLevel(level);
-    this.broadCastLogger.setLevel(level);
   }
 
   /**
@@ -247,16 +262,18 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
 
     // First time setting params
     this.syncParams = params;
-    if (params.streamOptions?.flags?.broadcastLogs) {
-      this.logger = this.broadCastLogger;
-    }
+    this.logger.sendBroadcasts = params.enableBroadcastLogs;
 
     // Ensure we have a usable database connection, the reconnectable database will connect lazily on first use.
     await this.database.readLock(async () => {});
 
     self.onerror = (event) => {
       // Share any uncaught events on the broadcast logger
-      this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
+      this.logger.log({
+        level: LogLevels.error,
+        message: 'Uncaught exception in PowerSync shared sync worker',
+        error: event
+      });
     };
 
     this.iterateListeners((l) => l.initialized?.());
@@ -274,9 +291,9 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
    * The connection will simply be reconnected whenever a new tab
    * connects.
    */
-  async connect(options?: PowerSyncConnectionOptions) {
+  async connect(options: ResolvedSyncOptions, serializedSchema: any) {
     this.lastConnectOptions = options;
-    return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options ?? {});
+    return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options ?? {}, serializedSchema);
   }
 
   async disconnect() {
@@ -298,7 +315,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       this.ports.push(portProvider);
 
       // Give the newly connected client the latest status
-      const status = this.connectionManager.syncStreamImplementation?.syncStatus;
+      const status = this.syncStatus;
       if (status) {
         portProvider.clientProvider.statusChanged(status.toJSON());
       }
@@ -321,7 +338,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     return await this.portMutex.runExclusive(async () => {
       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.`);
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `Could not remove port ${port} since it is not present in active ports.`
+        });
         return () => {};
       }
 
@@ -329,18 +349,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       // Remove from the list of active ports
       this.ports.splice(index, 1);
 
-      /**
-       * The port might currently be in use. Any active functions might
-       * not resolve. Abort them here.
-       */
-      [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-        if (abortController?.activePort == port) {
-          abortController!.controller.abort(
-            new AbortOperation('Closing pending requests after client port is removed')
-          );
-        }
-      });
-
       // Close the worker wrapped database connection, we can't accurately rely on this connection
       for (const closeListener of trackedPort.closeListeners) {
         await closeListener();
@@ -358,10 +366,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
-  async getWriteCheckpoint(): Promise<string> {
-    return this.withSyncImplementation(async (sync) => {
-      return sync.getWriteCheckpoint();
-    });
+  requestCheckpoint() {
+    return this.withSyncImplementation((sync) => sync.requestCheckpoint());
   }
 
   protected async withSyncImplementation<T>(callback: (sync: StreamingSyncImplementation) => Promise<T>): Promise<T> {
@@ -397,62 +403,48 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
               throw new Error('No client port found to invalidate credentials');
             }
             try {
-              this.logger.log('calling the last port client provider to invalidate credentials');
+              this.logger.log({
+                level: LogLevels.info,
+                message: 'calling the last port client provider to invalidate credentials'
+              });
               lastPort.clientProvider.invalidateCredentials();
-            } catch (ex) {
-              this.logger.error('error invalidating credentials', ex);
+            } catch (error) {
+              this.logger.log({ level: LogLevels.error, message: 'error invalidating credentials', error });
             }
           },
-          fetchCredentials: async () => {
-            const lastPort = await this.getLastWrappedPort();
-            if (!lastPort) {
-              throw new Error('No client port found to fetch credentials');
-            }
-            return new Promise(async (resolve, reject) => {
-              const abortController = new AbortController();
-              this.fetchCredentialsController = {
-                controller: abortController,
-                activePort: lastPort
-              };
-
-              abortController.signal.onabort = reject;
-              try {
-                this.logger.log('calling the last port client provider for credentials');
-                resolve(await lastPort.clientProvider.fetchCredentials());
-              } catch (ex) {
-                reject(ex);
-              } finally {
-                this.fetchCredentialsController = undefined;
-              }
-            });
+          fetchCredentials: () => {
+            return this.#useConnector(
+              (port) => {
+                this.logger.log({
+                  level: LogLevels.info,
+                  message: 'calling the last port client provider for credentials'
+                });
+
+                return port.clientProvider.fetchCredentials();
+              },
+              'fetchCredentials',
+              // No sync abort signal reaches the remote, so this relies on the timeout alone.
+              { timeoutMs: CONNECTOR_CALL_TIMEOUT_MS }
+            );
           }
         },
         this.logger
       ),
-      uploadCrud: async () => {
-        const lastPort = await this.getLastWrappedPort();
-        if (!lastPort) {
-          throw new Error('No client port found to upload crud');
-        }
-
-        return new Promise(async (resolve, reject) => {
-          const abortController = new AbortController();
-          this.uploadDataController = {
-            controller: abortController,
-            activePort: lastPort
-          };
-
-          // Resolving will make it retry
-          abortController.signal.onabort = () => resolve();
-          try {
-            resolve(await lastPort.clientProvider.uploadCrud());
-          } catch (ex) {
-            reject(ex);
-          } finally {
-            this.uploadDataController = undefined;
-          }
+      uploadCrud: (signal) => {
+        return this.#useConnector((port) => port.clientProvider.uploadCrud(), 'uploadCrud', {
+          signal,
+          // Uploads are user-defined and legitimately unbounded (large batches over slow connections), so a timeout
+          // would cut valid work short. Disconnecting aborts the signal, which is what releases this.
+          timeoutMs: null
         });
       },
+      postCheckpointRequest: (clientId, requestId, signal) => {
+        return this.#useConnector(
+          (port) => port.clientProvider.postCheckpointRequest(clientId, requestId),
+          'postCheckpointRequest',
+          { signal, timeoutMs: CONNECTOR_CALL_TIMEOUT_MS }
+        );
+      },
       ...syncParams.streamOptions,
       subscriptions: this.subscriptions,
       // Logger cannot be transferred just yet
@@ -460,6 +452,79 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
+  /**
+   * Calls into a client tab.
+   *
+   * A tab can stop servicing its message port without ever closing it: it may be frozen or in the back/forward cache,
+   * or its sync implementation may have been abandoned without being disposed. Comlink has no timeout of its own, so a
+   * call to such a port settles neither way, and the `closeListeners` below only fire for ports we know have closed.
+   *
+   * That is not a local problem. `disconnect()` awaits the sync loops, so a single call that can never settle wedges
+   * the disconnect, and with it every `connect()` queued behind it. Every call is therefore bounded by the caller's
+   * abort signal, a timeout, or both.
+   */
+  async #useConnector<T>(
+    inner: (port: WrappedSyncPort) => Promise<T>,
+    debugContext: string,
+    options: UseConnectorOptions = {}
+  ): Promise<T> {
+    const { signal, timeoutMs = CONNECTOR_CALL_TIMEOUT_MS } = options;
+
+    const controller = new AbortController();
+    const abortWith = (reason: string) => {
+      if (controller.signal.aborted) {
+        return;
+      }
+      this.logger.log({ level: LogLevels.warn, message: `Aborting ${debugContext}: ${reason}` });
+      controller.abort(new AbortOperation(`Aborted ${debugContext}: ${reason}`));
+    };
+
+    const timeout =
+      timeoutMs == null
+        ? undefined
+        : setTimeout(() => abortWith(`the client tab did not respond within ${timeoutMs}ms`), timeoutMs);
+
+    const onRequestedAbort = () => abortWith('the sync client disconnected');
+    signal?.addEventListener('abort', onRequestedAbort, { once: true });
+    if (signal?.aborted) {
+      onRequestedAbort();
+    }
+
+    try {
+      return await withAbort({
+        signal: controller.signal,
+        // Resolving the port takes the portMutex, which is held while other ports are being removed, so it has to be
+        // inside the guard as well.
+        action: async () => {
+          const lastPort = await this.getLastWrappedPort();
+          if (!lastPort) {
+            throw new Error(`No client port found for ${debugContext}`);
+          }
+
+          return await new Promise<T>((resolve, reject) => {
+            const portClosed = () => {
+              reject(new Error(`Tab closed while handling ${debugContext}`));
+            };
+
+            lastPort.closeListeners.push(portClosed);
+
+            inner(lastPort)
+              .then(resolve, reject)
+              .finally(() => {
+                const index = lastPort.closeListeners.indexOf(portClosed);
+                if (index >= 0) {
+                  lastPort.closeListeners.splice(index, 1);
+                }
+              });
+          });
+        }
+      });
+    } finally {
+      clearTimeout(timeout);
+      signal?.removeEventListener('abort', onRequestedAbort);
+    }
+  }
+
   /**
    * Requests a random client to share its database connection with us.
    */
@@ -508,7 +573,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     const remote = Comlink.wrap<OpenWorkerConnection>(workerPort);
     const identifier = this.syncParams!.dbParams.dbFilename;
 
-    const clientLockName = await generateTabCloseSignal();
+    const clientLockName = await this.sharedCloseSignal;
 
     /**
      * The open could fail if the tab is closed while we're busy opening the database.
@@ -542,7 +607,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     clearTimeout(timeout);
 
     client.closeListeners.push(async () => {
-      this.logger.info('Aborting open connection because associated tab closed.');
+      this.logger.log({ level: LogLevels.info, message: 'Aborting open connection because associated tab closed.' });
       handleClosed(db);
       /**
        * Don't await this close operation. It might never resolve if the tab is closed.
@@ -550,7 +615,9 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
        * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
        */
       db.markRemoteClosed();
-      db.close().catch((ex) => this.logger.warn('error closing database connection', ex));
+      db.close().catch((error) =>
+        this.logger.log({ level: LogLevels.warn, message: 'error closing database connection', error })
+      );
     });
     return db;
   }
@@ -559,7 +626,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     const syncParams = this.syncParams;
     const sharedSync = this;
 
-    class ReconnectPool extends BaseObserver<DBAdapterListener> implements ConnectionPool {
+    return new (class extends DBAdapter {
       private connectionState:
         | null
         | DatabaseClient<ResolvedWebSQLOpenOptions>
@@ -628,19 +695,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       async refreshSchema(): Promise<void> {
         // Not used by sync client.
       }
-    }
-
-    const Adapter = DBAdapterDefaultMixin(ReconnectPool);
-    return new Adapter();
-  }
-
-  /**
-   * A method to update the all shared statuses for each
-   * client.
-   */
-  private updateAllStatuses(status: SyncStatusOptions) {
-    this.syncStatus = new SyncStatus(status);
-    this.ports.forEach((p) => p.clientProvider.statusChanged(status));
+    })();
   }
 }
 
@@ -653,15 +708,19 @@ function withAbort<T>(options: {
   cleanupOnAbort?: (result: T) => void;
 }): Promise<T> {
   const { action, signal, cleanupOnAbort } = options;
+  // Callers that abort with an `Error` reason get it propagated, so the failure says what actually went wrong.
+  const abortError = () =>
+    signal.reason instanceof Error ? signal.reason : new AbortOperation('Operation aborted by abort controller');
+
   return new Promise((resolve, reject) => {
     if (signal.aborted) {
-      reject(new AbortOperation('Operation aborted by abort controller'));
+      reject(abortError());
       return;
     }
 
     function handleAbort() {
       signal.removeEventListener('abort', handleAbort);
-      reject(new AbortOperation('Operation aborted by abort controller'));
+      reject(abortError());
     }
 
     signal.addEventListener('abort', handleAbort, { once: true });

package/src/worker/sync/WorkerClient.ts

@@ -1,4 +1,3 @@
-import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { getNavigatorLocks } from '../../shared/navigator.js';
 import {
@@ -8,6 +7,7 @@ import {
   SharedSyncInitOptions,
   WrappedSyncPort
 } from './SharedSyncImplementation.js';
+import { SubscribedStream, ResolvedSyncOptions } from '@powersync/shared-internals';
 
 /**
  * A client to the shared sync worker.
@@ -65,7 +65,7 @@ export class WorkerClient {
     });
   }
 
-  setLogLevel(level: ILogLevel) {
+  setLogLevel(level: number) {
     this.sync.setLogLevel(level);
   }
 
@@ -78,12 +78,8 @@ export class WorkerClient {
     return this.sync.setParams(params);
   }
 
-  getWriteCheckpoint() {
-    return this.sync.getWriteCheckpoint();
-  }
-
-  connect(options?: PowerSyncConnectionOptions) {
-    return this.sync.connect(options);
+  connect(options: ResolvedSyncOptions, schema: any) {
+    return this.sync.connect(options, schema);
   }
 
   updateSubscriptions(subscriptions: SubscribedStream[]) {
@@ -92,6 +88,10 @@ export class WorkerClient {
     }
   }
 
+  requestCheckpoint(): Promise<bigint> {
+    return this.sync.requestCheckpoint();
+  }
+
   disconnect() {
     return this.sync.disconnect();
   }

package/src/worker/worker.ts

@@ -0,0 +1,38 @@
+import * as Comlink from 'comlink';
+
+import { createConsoleLogger, LogLevels } from '@powersync/common';
+import { isSharedWorker, MultiDatabaseServer } from './db/MultiDatabaseServer.js';
+import { SharedSyncImplementation } from './sync/SharedSyncImplementation.js';
+import { OpenWorkerConnection } from '../db/adapters/wa-sqlite/DatabaseClient.js';
+import { SharedWorkerConnectionRequest } from './SharedWorkerConnectionRequest.js';
+import { WorkerClient } from './sync/WorkerClient.js';
+
+const server = new MultiDatabaseServer(createConsoleLogger({ prefix: 'db-worker', minLevel: LogLevels.trace }));
+
+const exposedDatabaseFunctions: OpenWorkerConnection = {
+  connect: (config) => server.handleConnection(config),
+  connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
+};
+
+if (isSharedWorker) {
+  const sharedSyncImplementation = new SharedSyncImplementation();
+
+  // A shared worker can either be an IndexedDB-VFS database server or a shared sync coordinator.
+  // To be able to know what service a client is connecting to, we let clients send an inner MessagePort through the
+  // top-level port along with a tag describing what they need.
+  const _self = self as unknown as SharedWorkerGlobalScope;
+  _self.onconnect = (outerEvent: MessageEvent) => {
+    const port = outerEvent.ports[0];
+    port.onmessage = (event: MessageEvent<SharedWorkerConnectionRequest>) => {
+      const { service, port } = event.data;
+      if (service === 'database') {
+        Comlink.expose(exposedDatabaseFunctions, port);
+      } else if (service === 'sync') {
+        new WorkerClient(sharedSyncImplementation, port);
+      }
+    };
+  };
+} else {
+  // Dedicated workers are only used for databases, so we don't need an intermediate layer.
+  Comlink.expose(exposedDatabaseFunctions);
+}