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

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

@@ -1,11 +1,11 @@
-import { ILogger } from '@powersync/common';
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
 import { ConcurrentSqliteConnection, ConnectionLeaseToken } from './ConcurrentConnection.js';
-import { RawQueryResult } from './RawSqliteConnection.js';
+import { RawWebResult } from './RawSqliteConnection.js';
 
 export interface DatabaseServerOptions {
   inner: ConcurrentSqliteConnection;
   onClose: () => void;
-  logger: ILogger;
+  logger: PowerSyncLogger;
 }
 
 /**
@@ -24,7 +24,7 @@ export class DatabaseServer {
   constructor(options: DatabaseServerOptions) {
     this.#options = options;
     const inner = options.inner;
-    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.dbFilename}-table-updates`);
+    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.filename}-table-updates`);
 
     this.#updateBroadcastChannel.onmessage = ({ data }) => {
       this.#pushTableUpdateToClients(data as string[]);
@@ -85,7 +85,7 @@ export class DatabaseServer {
 
         // If the client holds a connection lease it hasn't returned, return that now.
         for (const { lease } of connectionLeases.values()) {
-          this.#logger.debug(`Closing connection lease that hasn't been returned.`);
+          this.#logger.log({ level: LogLevels.debug, message: `Closing connection lease that hasn't been returned.` });
           await lease.returnLease();
         }
 
@@ -94,7 +94,10 @@ export class DatabaseServer {
         if (this.#activeClients.size == 0) {
           await this.forceClose();
         } else {
-          this.#logger.debug('Keeping underlying connection active since its used by other clients.');
+          this.#logger.log({
+            level: LogLevels.debug,
+            message: 'Keeping underlying connection active since its used by other clients.'
+          });
         }
       }
     };
@@ -133,9 +136,9 @@ export class DatabaseServer {
         try {
           if (lease.write) {
             // Collect update hooks invoked while the client had the write connection.
-            const { resultSet } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
-            if (resultSet) {
-              const updatedTables: string[] = JSON.parse(resultSet.rows[0][0] as string);
+            const { rawRows } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
+            if (rawRows.length) {
+              const updatedTables: string[] = JSON.parse(rawRows[0][0] as string);
               if (updatedTables.length) {
                 this.#updateBroadcastChannel.postMessage(updatedTables);
                 this.#pushTableUpdateToClients(updatedTables);
@@ -169,7 +172,10 @@ export class DatabaseServer {
   }
 
   async forceClose() {
-    this.#logger.debug(`Closing connection to ${this.#inner.options}.`);
+    this.#logger.log({
+      level: LogLevels.debug,
+      message: `Closing connection to ${JSON.stringify(this.#inner.options)}.`
+    });
     const connection = this.#inner;
     this.#options.onClose();
     this.#updateBroadcastChannel.close();
@@ -190,8 +196,8 @@ export interface ClientConnectionView {
    * give other clients access to the database afterwards.
    */
   requestAccess(write: boolean, timeoutMs?: number): Promise<string>;
-  execute(token: string, sql: string, params: any[] | undefined): Promise<RawQueryResult>;
-  executeBatch(token: string, sql: string, params: any[][]): Promise<RawQueryResult[]>;
+  execute(token: string, sql: string, params: any[] | undefined): Promise<RawWebResult>;
+  executeBatch(token: string, sql: string, params: any[][]): Promise<RawWebResult[]>;
   completeAccess(token: string): Promise<void>;
 
   /**

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

@@ -1,18 +1,34 @@
 import { Factory as WaSqliteFactory, SQLITE_ROW } from '@journeyapps/wa-sqlite';
 
-import { loadModuleAndVfs } from './vfs.js';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+import { loadModuleAndVfs, WASQLiteVFS } from './vfs.js';
+import { TemporaryStorageOption } from '../options.js';
+import { RawQueryResult, SqliteValue } from '@powersync/common';
+import { maxPathNameLength } from '../resolveAndValidateOptions.js';
+import { PreparedStatementCache } from './StatementCache.js';
+
+export interface RawWebResult extends Required<RawQueryResult> {
+  autocommit: boolean;
+}
 
 export interface RawResultSet {
-  columns: string[];
-  rows: SQLiteCompatibleType[][];
+  columnNames: string[];
+  rawRows: SqliteValue[][];
 }
 
-export interface RawQueryResult {
-  changes: number;
-  lastInsertRowId: number;
-  autocommit: boolean;
-  resultSet: RawResultSet | undefined;
+/**
+ * @internal
+ */
+export interface RawWaSqliteDatabaseOptions {
+  filename: string;
+  readonly: boolean;
+  vfs: WASQLiteVFS;
+  encryptionKey: string | undefined;
+  temporaryStorage: TemporaryStorageOption;
+  cacheSizeKb: number;
+  /**
+   * The amount of prepared statements to cache, or 0 to disable caching.
+   */
+  preparedStatementsCache: number;
 }
 
 /**
@@ -23,35 +39,48 @@ export interface RawQueryResult {
  */
 export class RawSqliteConnection {
   private _sqliteAPI: SQLiteAPI | null = null;
+  private sqlite3_stmt_isexplain!: (stmt: number) => 0 | 1 | 2;
+
   /**
    * The `sqlite3*` connection pointer.
    */
   private db: number = 0;
+  private statementCache: PreparedStatementCache | null;
 
-  constructor(readonly options: ResolvedWASQLiteOpenFactoryOptions) {}
+  constructor(readonly options: RawWaSqliteDatabaseOptions) {
+    this.statementCache =
+      options.preparedStatementsCache > 0 ? new PreparedStatementCache(options.preparedStatementsCache) : null;
+  }
 
   get isOpen(): boolean {
     return this.db != 0;
   }
 
   async init() {
-    const api = (this._sqliteAPI = await this.openSQLiteAPI());
+    const { module, vfs } = await loadModuleAndVfs(this.options);
+    await this.initWithModule(module, vfs);
+  }
+
+  async initWithModule(module: any, vfs: any) {
+    const api = (this._sqliteAPI = await this.openSQLiteAPI(module, vfs));
     this.db = await api.open_v2(
-      this.options.dbFilename,
-      this.options.isReadOnly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
+      this.options.filename,
+      this.options.readonly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
     );
     await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
     if (this.options.encryptionKey) {
-      const escapedKey = this.options.encryptionKey.replace("'", "''");
-      await this.executeRaw(`PRAGMA key = '${escapedKey}'`);
+      const escapedKey = this.options.encryptionKey.replaceAll("'", "''");
+      await this.executeRaw(`PRAGMA key = '${escapedKey}';`);
     }
     await this.executeRaw(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
 
     await this.executeRaw(`SELECT powersync_update_hooks('install');`);
   }
 
-  private async openSQLiteAPI(): Promise<SQLiteAPI> {
-    const { module, vfs } = await loadModuleAndVfs(this.options);
+  private async openSQLiteAPI(module: any, vfs: SQLiteVFS): Promise<SQLiteAPI> {
+    vfs.mxPathname = maxPathNameLength;
+
+    this.sqlite3_stmt_isexplain = module.cwrap('sqlite3_stmt_isexplain', 'int', ['int']);
     const sqlite3 = WaSqliteFactory(module);
     sqlite3.vfs_register(vfs, true);
     /**
@@ -63,7 +92,7 @@ export class RawSqliteConnection {
      * Create the multiple cipher vfs if an encryption key is provided
      */
     if (this.options.encryptionKey) {
-      const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.dbFilename, 1]);
+      const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.filename, 1]);
       if (createResult !== 0) {
         throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
       }
@@ -87,12 +116,12 @@ export class RawSqliteConnection {
     return this.requireSqlite().get_autocommit(this.db) != 0;
   }
 
-  async execute(sql: string, bindings?: any[]): Promise<RawQueryResult> {
+  async execute(sql: string, bindings?: any[]): Promise<RawWebResult> {
     const resultSet = await this.executeSingleStatementRaw(sql, bindings);
     return this.wrapQueryResults(this.requireSqlite(), resultSet);
   }
 
-  async executeBatch(sql: string, bindings: any[][]): Promise<RawQueryResult[]> {
+  async executeBatch(sql: string, bindings: any[][]): Promise<RawWebResult[]> {
     const results = [];
     const api = this.requireSqlite();
     for await (const stmt of api.statements(this.db, sql)) {
@@ -110,31 +139,32 @@ export class RawSqliteConnection {
     return results;
   }
 
-  private wrapQueryResults(api: SQLiteAPI, rs: RawResultSet | undefined): RawQueryResult {
+  private wrapQueryResults(api: SQLiteAPI, { rawRows, columnNames }: RawResultSet): RawWebResult {
     return {
-      changes: api.changes(this.db),
-      lastInsertRowId: api.last_insert_id(this.db),
+      rowsAffected: api.changes(this.db),
+      insertId: api.last_insert_id(this.db),
       autocommit: api.get_autocommit(this.db) != 0,
-      resultSet: rs
+      rawRows,
+      columnNames
     };
   }
 
   /**
    * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
    */
-  private async executeSingleStatementRaw(sql: string, bindings?: any[]): Promise<RawResultSet | undefined> {
+  private async executeSingleStatementRaw(sql: string, bindings?: any[]): Promise<RawResultSet> {
     const results = await this.executeRaw(sql, bindings);
-    return results.length ? results[0] : undefined;
+    return results.length ? results[0] : { columnNames: [], rawRows: [] };
   }
 
   async executeRaw(sql: string, bindings?: any[]): Promise<RawResultSet[]> {
     const results = [];
     const api = this.requireSqlite();
-    for await (const stmt of api.statements(this.db, sql)) {
+    for await (const stmt of this.cachedStatements(api, sql)) {
       let columns;
 
       const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
-      columns = rs.columns;
+      columns = rs.columnNames;
       if (columns.length) {
         results.push(rs);
       }
@@ -176,13 +206,61 @@ export class RawSqliteConnection {
     }
 
     knownColumns ??= api.column_names(stmt);
-    return { columns: knownColumns, rows };
+    return { columnNames: knownColumns, rawRows: rows };
   }
 
   async close() {
     if (this.isOpen) {
-      await this.requireSqlite().close(this.db);
+      const api = this.requireSqlite();
+
+      if (this.statementCache) {
+        for (const stmt of this.statementCache.drain()) {
+          await api.finalize(stmt);
+        }
+      }
+
+      await api.close(this.db);
       this.db = 0;
     }
   }
+
+  private async *cachedStatements(api: SQLiteAPI, sql: string): AsyncIterable<number> {
+    {
+      const existing = this.statementCache?.lookup(sql);
+      if (existing != null) {
+        yield existing;
+        return;
+      }
+    }
+
+    const inner = api.statements(this.db, sql, { unscoped: true });
+    const preparedStatements: number[] = [];
+
+    try {
+      for await (const stmt of inner) {
+        preparedStatements.push(stmt);
+        yield stmt;
+      }
+    } finally {
+      // We can only cache statements if the sql text corresponds to a single statement, otherwise it's not clear what
+      // portion of the original sql text to use as a key.
+      if (preparedStatements.length === 1 && this.statementCache) {
+        const stmt = preparedStatements[0];
+        // Don't cache EXPLAIN statements, their result becomes invalid after schema changes.
+        if (this.sqlite3_stmt_isexplain(stmt) == 0) {
+          const evicted = this.statementCache.addStatement(sql, stmt);
+          if (evicted != null) {
+            await api.finalize(evicted);
+          }
+
+          return;
+        }
+      }
+
+      // We're not caching statements, so finalize them.
+      for (const stmt of preparedStatements) {
+        await api.finalize(stmt);
+      }
+    }
+  }
 }

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

@@ -0,0 +1,50 @@
+export class PreparedStatementCache {
+  readonly #size: number;
+  // Note that Map preserves insertion order, which allows using it as an LRU
+  // cache (with the first element being the first element to evict).
+  readonly #statements = new Map<string, number>();
+
+  constructor(size: number) {
+    this.#size = size;
+  }
+
+  /**
+   * Attempts to look up the cached sql statement, if it's currently cached.
+   */
+  lookup(sql: string): number | null {
+    const foundStatement = this.#statements.get(sql);
+    if (foundStatement != null) {
+      // Delete and re-insert to move to the end (most-recently-used position).
+      this.#statements.delete(sql);
+      this.#statements.set(sql, foundStatement);
+      return foundStatement;
+    }
+
+    return null;
+  }
+
+  /**
+   * Adds a new statement into the cache.
+   *
+   * If that exceeds the target size of the statement cache, returns an old statement to evict.
+   * The caller is responsible for freeing that statement.
+   */
+  addStatement(sql: string, statement: number): number | null {
+    this.#statements.set(sql, statement);
+
+    if (this.#statements.size > this.#size) {
+      for (const [k, v] of this.#statements.entries()) {
+        this.#statements.delete(k);
+        return v;
+      }
+    }
+
+    return null;
+  }
+
+  drain(): number[] {
+    const values = [...this.#statements.values()];
+    this.#statements.clear();
+    return values;
+  }
+}

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

@@ -1,70 +1,38 @@
-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 { maxPathNameLength, 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;
+  private options: ResolvedWebSQLOpenOptions;
+  private logger: PowerSyncLogger;
 
-  constructor(private options: WASQLiteOpenFactoryOptions) {
-    assertValidWASQLiteOpenFactoryOptions(options);
-    this.resolvedFlags = resolveWebSQLFlags(options.flags);
-    this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
-  }
+  constructor(options: WASQLiteOpenFactoryOptions) {
+    this.options = resolveAndValidateOptions(options.open);
+
+    // Account for the fact that SQLite might append -journal suffixes
+    const maxLength = maxPathNameLength - 16;
+    if (this.options.dbFilename.length > maxLength) {
+      throw new Error(`dbFilename too long (max length is ${maxLength})`);
+    }
 
-  get waOptions(): WASQLiteOpenFactoryOptions {
-    // Cast to extended type
-    return this.options;
+    this.logger = options.logger;
   }
 
   protected openAdapter(): DBAdapter {
@@ -72,84 +40,91 @@ 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;
-
-    if (!enableMultiTabs) {
-      this.logger.warn('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,
+      enableMultiTabs,
+      useWebWorker,
       vfs,
+      dbFilename,
+      encryptionKey,
       temporaryStorage,
       cacheSizeKb,
-      flags: this.resolvedFlags,
-      encryptionKey: encryptionKey,
-      isReadOnly
-    });
+      preparedStatementsCache
+    } = this.options;
+
+    if (!enableMultiTabs) {
+      this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
+    }
 
     let client: DatabaseClient;
     let additionalReaders: DatabaseClient[] = [];
     let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
 
+    function resolveRawWaSqliteDatabaseOptions(readonly: boolean): RawWaSqliteDatabaseOptions {
+      return {
+        filename: dbFilename,
+        readonly,
+        vfs,
+        encryptionKey,
+        temporaryStorage,
+        cacheSizeKb,
+        // TODO: Enable prepared statement cache by default?
+        preparedStatementsCache: preparedStatementsCache ?? 0
+      };
+    }
+
     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, this.logger, 'database');
+        } else {
+          const needsDedicated = vfsRequiresDedicatedWorkers(vfs);
+          const useShared = !needsDedicated && enableMultiTabs;
+
+          workerConnection = connectToWorker({
+            service: 'database',
+            databaseIdentifier: this.options.dbFilename,
+            shared: useShared,
+            customWorker: optionsDbWorker,
+            loggerForErrors: this.logger
+          });
+        }
+
+        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,42 +134,39 @@ 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;
+
+        const additionalReaderPromises: Promise<DatabaseClient>[] = [];
         for (let i = 0; i < additionalReadersCount; i++) {
-          const reader = await openDatabaseWorker(resolveOptions(true));
-          additionalReaders.push(reader);
+          additionalReaderPromises.push(openDatabaseWorker(true));
         }
+        additionalReaders.push(...(await Promise.all(additionalReaderPromises)));
       }
     } else {
       // Don't use a web worker. Instead, open the MultiDatabaseServer a worker would use locally.
       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 +178,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}).`
-      );
-    }
-  }
-}