@powersync/web 1.30.0 → 1.32.0

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@powersync/web",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "PowerSync Web SDK",
   "main": "lib/src/index.js",
+  "module": "lib/src/index.js",
+  "type": "module",
   "types": "lib/src/index.d.ts",
   "bin": {
-    "powersync-web": "bin/powersync.js"
+    "powersync-web": "bin/powersync.cjs"
   },
   "files": [
     "bin",
@@ -15,21 +17,23 @@
     "src"
   ],
   "exports": {
-    ".": "./lib/src/index.js",
+    ".": {
+      "types": "./lib/src/index.d.ts",
+      "default": "./lib/src/index.js"
+    },
     "./umd": {
-      "import": "./dist/index.umd.js",
-      "require": "./dist/index.umd.js",
-      "types": "./lib/src/index.d.ts"
+      "types": "./lib/src/index.d.ts",
+      "default": "./dist/index.umd.js"
     },
     "./umd/worker/db": {
+      "types": "./lib/src/index.d.ts",
       "import": "./dist/worker/WASQLiteDB.umd.js",
-      "require": "./dist/worker/WASQLiteDB.umd.js",
-      "types": "./lib/src/index.d.ts"
+      "require": "./dist/worker/WASQLiteDB.umd.js"
     },
     "./umd/worker/sync": {
+      "types": "./lib/src/index.d.ts",
       "import": "./dist/worker/SharedSyncImplementation.umd.js",
-      "require": "./dist/worker/SharedSyncImplementation.umd.js",
-      "types": "./lib/src/index.d.ts"
+      "require": "./dist/worker/SharedSyncImplementation.umd.js"
     }
   },
   "repository": "https://github.com/powersync-ja/powersync-js",
@@ -51,28 +55,27 @@
   "author": "JOURNEYAPPS",
   "license": "Apache-2.0",
   "peerDependencies": {
-    "@journeyapps/wa-sqlite": "^1.4.0",
-    "@powersync/common": "^1.44.0"
+    "@journeyapps/wa-sqlite": "^1.4.1",
+    "@powersync/common": "^1.46.0"
   },
   "dependencies": {
     "async-mutex": "^0.5.0",
     "bson": "^6.10.4",
     "comlink": "^4.4.2",
     "commander": "^12.1.0",
-    "@powersync/common": "1.44.0"
+    "@powersync/common": "1.46.0"
   },
   "devDependencies": {
-    "@journeyapps/wa-sqlite": "^1.4.0",
+    "@journeyapps/wa-sqlite": "^1.4.1",
     "@types/uuid": "^9.0.6",
     "crypto-browserify": "^3.12.0",
+    "glob": "^11.0.0",
     "p-defer": "^4.0.1",
     "source-map-loader": "^5.0.0",
     "stream-browserify": "^3.0.0",
     "terser-webpack-plugin": "^5.3.9",
-    "uuid": "^9.0.1",
-    "vite": "^6.1.0",
-    "vite-plugin-top-level-await": "^1.4.4",
-    "vite-plugin-wasm": "^3.3.0",
+    "uuid": "^11.1.0",
+    "vite": "^7.3.1",
     "vm-browserify": "^1.1.2",
     "webpack": "^5.90.1",
     "webpack-cli": "^5.1.4",
@@ -86,6 +89,7 @@
     "build:prod": "pnpm run build:tsc --sourceMap false && pnpm run build:webpack-main && pnpm run build:webpack-workers",
     "clean": "rm -rf lib dist tsconfig.tsbuildinfo",
     "watch": "tsc --build -w",
-    "test": "pnpm build && vitest"
+    "test": "pnpm build && vitest",
+    "test:exports": "attw --pack . --entrypoints . --profile=esm-only "
   }
 }

package/src/db/NavigatorTriggerClaimManager.ts

@@ -0,0 +1,23 @@
+import { TriggerClaimManager } from '@powersync/common';
+import { getNavigatorLocks } from '../shared/navigator.js';
+
+/**
+ * @internal
+ * @experimental
+ */
+export const NAVIGATOR_TRIGGER_CLAIM_MANAGER: TriggerClaimManager = {
+  async obtainClaim(identifier: string): Promise<() => Promise<void>> {
+    return new Promise((resolveReleaser) => {
+      getNavigatorLocks().request(identifier, async () => {
+        await new Promise<void>((releaseLock) => {
+          resolveReleaser(async () => releaseLock());
+        });
+      });
+    });
+  },
+
+  async checkClaim(identifier: string): Promise<boolean> {
+    const currentState = await getNavigatorLocks().query();
+    return currentState.held?.find((heldLock) => heldLock.name == identifier) != null;
+  }
+};

package/src/db/PowerSyncDatabase.ts

@@ -1,37 +1,40 @@
 import {
-  type BucketStorageAdapter,
-  type PowerSyncBackendConnector,
-  type PowerSyncCloseOptions,
-  type RequiredAdditionalConnectionOptions,
   AbstractPowerSyncDatabase,
   DBAdapter,
-  DEFAULT_POWERSYNC_CLOSE_OPTIONS,
-  isDBAdapter,
-  isSQLOpenFactory,
   PowerSyncDatabaseOptions,
   PowerSyncDatabaseOptionsWithDBAdapter,
   PowerSyncDatabaseOptionsWithOpenFactory,
   PowerSyncDatabaseOptionsWithSettings,
   SqliteBucketStorage,
-  StreamingSyncImplementation
+  StreamingSyncImplementation,
+  TriggerManagerConfig,
+  isDBAdapter,
+  isSQLOpenFactory,
+  type BucketStorageAdapter,
+  type PowerSyncBackendConnector,
+  type PowerSyncCloseOptions,
+  type RequiredAdditionalConnectionOptions
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { getNavigatorLocks } from '../shared/navigator';
-import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory';
+import { getNavigatorLocks } from '../shared/navigator.js';
+import { NAVIGATOR_TRIGGER_CLAIM_MANAGER } from './NavigatorTriggerClaimManager.js';
+import { LockedAsyncDatabaseAdapter } from './adapters/LockedAsyncDatabaseAdapter.js';
+import { WebDBAdapter } from './adapters/WebDBAdapter.js';
+import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import {
   DEFAULT_WEB_SQL_FLAGS,
   ResolvedWebSQLOpenOptions,
-  resolveWebSQLFlags,
-  WebSQLFlags
-} from './adapters/web-sql-flags';
-import { WebDBAdapter } from './adapters/WebDBAdapter';
-import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation';
-import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation';
-import { WebRemote } from './sync/WebRemote';
+  WebSQLFlags,
+  isServerSide,
+  resolveWebSQLFlags
+} from './adapters/web-sql-flags.js';
+import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation.js';
+import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation.js';
+import { WebRemote } from './sync/WebRemote.js';
 import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
-} from './sync/WebStreamingSyncImplementation';
+} from './sync/WebStreamingSyncImplementation.js';
 
 export interface WebPowerSyncFlags extends WebSQLFlags {
   /**
@@ -144,7 +147,33 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     }
   }
 
-  async _initialize(): Promise<void> {}
+  async _initialize(): Promise<void> {
+    if (this.database instanceof LockedAsyncDatabaseAdapter) {
+      /**
+       * While init is done automatically,
+       * LockedAsyncDatabaseAdapter only exposes config after init.
+       * We can explicitly wait for init here in order to access config.
+       */
+      await this.database.init();
+    }
+
+    // In some cases, like the SQLJs adapter, we don't pass a WebDBAdapter, so we need to check.
+    if (typeof (this.database as WebDBAdapter).getConfiguration == 'function') {
+      const config = (this.database as WebDBAdapter).getConfiguration();
+      if (config.requiresPersistentTriggers) {
+        this.triggersImpl.updateDefaults({
+          useStorageByDefault: true
+        });
+      }
+    }
+  }
+
+  protected generateTriggerManagerConfig(): TriggerManagerConfig {
+    return {
+      // We need to share hold information between tabs for web
+      claimManager: NAVIGATOR_TRIGGER_CLAIM_MANAGER
+    };
+  }
 
   protected openDBAdapter(options: WebPowerSyncDatabaseOptionsWithSettings): DBAdapter {
     const defaultFactory = new WASQLiteOpenFactory({
@@ -160,17 +189,30 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
    * By default the sync stream client is only disconnected if
    * multiple tabs are not enabled.
    */
-  close(options: PowerSyncCloseOptions = DEFAULT_POWERSYNC_CLOSE_OPTIONS): Promise<void> {
+  close(options?: PowerSyncCloseOptions): Promise<void> {
     if (this.unloadListener) {
       window.removeEventListener('unload', this.unloadListener);
     }
-
     return super.close({
       // Don't disconnect by default if multiple tabs are enabled
-      disconnect: options.disconnect ?? !this.resolvedFlags.enableMultiTabs
+      disconnect: options?.disconnect ?? !this.resolvedFlags.enableMultiTabs
     });
   }
 
+  protected async loadVersion(): Promise<void> {
+    if (isServerSide()) {
+      return;
+    }
+    return super.loadVersion();
+  }
+
+  protected async resolveOfflineSyncStatus() {
+    if (isServerSide()) {
+      return;
+    }
+    return super.resolveOfflineSyncStatus();
+  }
+
   protected generateBucketStorageAdapter(): BucketStorageAdapter {
     return new SqliteBucketStorage(this.database);
   }

package/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.ts

@@ -9,7 +9,7 @@ import {
   WebPowerSyncDatabaseOptions,
   WebPowerSyncFlags,
   resolveWebPowerSyncFlags
-} from '../../db/PowerSyncDatabase';
+} from '../../db/PowerSyncDatabase.js';
 
 /**
  * {@link WebPowerSyncFlags}

package/src/db/adapters/AbstractWebSQLOpenFactory.ts

@@ -1,6 +1,6 @@
-import { type ILogger, createLogger, DBAdapter, SQLOpenFactory } from '@powersync/common';
-import { SSRDBAdapter } from './SSRDBAdapter';
-import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions, isServerSide, resolveWebSQLFlags } from './web-sql-flags';
+import { DBAdapter, type ILogger, SQLOpenFactory, createLogger } from '@powersync/common';
+import { SSRDBAdapter } from './SSRDBAdapter.js';
+import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions, isServerSide, resolveWebSQLFlags } from './web-sql-flags.js';
 
 export abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
   protected resolvedFlags: ResolvedWebSQLFlags;

package/src/db/adapters/AsyncDatabaseConnection.ts

@@ -1,5 +1,5 @@
 import { BatchedUpdateNotification, QueryResult } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 /**
  * @internal

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -1,5 +1,6 @@
 import {
   BaseObserver,
+  ConnectionClosedError,
   DBAdapter,
   DBAdapterListener,
   DBGetUtils,
@@ -10,13 +11,13 @@ import {
   createLogger,
   type ILogger
 } from '@powersync/common';
-import { getNavigatorLocks } from '../..//shared/navigator';
-import { AsyncDatabaseConnection } from './AsyncDatabaseConnection';
-import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
-import { ResolvedWASQLiteOpenFactoryOptions } from './wa-sqlite/WASQLiteOpenFactory';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { AsyncDatabaseConnection } from './AsyncDatabaseConnection.js';
+import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection.js';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './wa-sqlite/WASQLiteOpenFactory.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 /**
  * @internal
@@ -26,10 +27,16 @@ export interface LockedAsyncDatabaseAdapterOptions {
   openConnection: () => Promise<AsyncDatabaseConnection>;
   debugMode?: boolean;
   logger?: ILogger;
+  defaultLockTimeoutMs?: number;
+  reOpenOnConnectionClosed?: boolean;
 }
 
 export type LockedAsyncDatabaseAdapterListener = DBAdapterListener & {
   initialized?: () => void;
+  /**
+   * Fired when the database is re-opened after being closed.
+   */
+  databaseReOpened?: () => void;
 };
 
 /**
@@ -51,6 +58,7 @@ export class LockedAsyncDatabaseAdapter
   private _config: ResolvedWebSQLOpenOptions | null = null;
   protected pendingAbortControllers: Set<AbortController>;
   protected requiresHolds: boolean | null;
+  protected databaseOpenPromise: Promise<void> | null = null;
 
   closing: boolean;
   closed: boolean;
@@ -105,23 +113,83 @@ export class LockedAsyncDatabaseAdapter
     return this.initPromise;
   }
 
+  protected async openInternalDB() {
+    /**
+     * Execute opening of the db in a lock in order not to interfere with other operations.
+     */
+    return this._acquireLock(async () => {
+      // Dispose any previous table change listener.
+      this._disposeTableChangeListener?.();
+      this._disposeTableChangeListener = null;
+      this._db?.close().catch((ex) => this.logger.warn(`Error closing database before opening new instance`, ex));
+      const isReOpen = !!this._db;
+      this._db = null;
+
+      this._db = await this.options.openConnection();
+      await this._db.init();
+      this._config = await this._db.getConfig();
+      await this.registerOnChangeListener(this._db);
+      if (isReOpen) {
+        this.iterateListeners((cb) => cb.databaseReOpened?.());
+      }
+      /**
+       * This is only required for the long-lived shared IndexedDB connections.
+       */
+      this.requiresHolds = (this._config as ResolvedWASQLiteOpenFactoryOptions).vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+    });
+  }
+
+  protected _reOpen() {
+    this.databaseOpenPromise = this.openInternalDB().finally(() => {
+      this.databaseOpenPromise = null;
+    });
+    return this.databaseOpenPromise;
+  }
+
+  /**
+   * Re-opens the underlying database.
+   * Returns a pending operation if one is already in progress.
+   */
+  async reOpenInternalDB(): Promise<void> {
+    if (!this.options.reOpenOnConnectionClosed) {
+      throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
+    }
+    if (this.databaseOpenPromise) {
+      return this.databaseOpenPromise;
+    }
+    return this._reOpen();
+  }
+
   protected async _init() {
-    this._db = await this.options.openConnection();
-    await this._db.init();
-    this._config = await this._db.getConfig();
-    await this.registerOnChangeListener(this._db);
-    this.iterateListeners((cb) => cb.initialized?.());
     /**
-     * This is only required for the long-lived shared IndexedDB connections.
+     * For OPFS, we can see this open call sometimes fail due to NoModificationAllowedError.
+     * We should be able to recover from this by re-opening the database.
      */
-    this.requiresHolds = (this._config as ResolvedWASQLiteOpenFactoryOptions).vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+    const maxAttempts = 3;
+    for (let count = 0; count < maxAttempts; count++) {
+      try {
+        await this.openInternalDB();
+        break;
+      } catch (ex) {
+        if (count == maxAttempts - 1) {
+          throw ex;
+        }
+        this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
+    this.iterateListeners((cb) => cb.initialized?.());
   }
 
-  getConfiguration(): ResolvedWebSQLOpenOptions {
+  getConfiguration(): WebDBAdapterConfiguration {
     if (!this._config) {
       throw new Error(`Cannot get config before initialization is completed`);
     }
-    return this._config;
+    return {
+      ...this._config,
+      // This can be overridden by the adapter later
+      requiresPersistentTriggers: false
+    };
   }
 
   protected async waitForInitialized() {
@@ -170,7 +238,14 @@ export class LockedAsyncDatabaseAdapter
    */
   async close() {
     this.closing = true;
-    this._disposeTableChangeListener?.();
+    /**
+     * Note that we obtain a reference to the callback to avoid calling the callback with `this` as the context.
+     * This is to avoid Comlink attempting to clone `this` when calling the method.
+     */
+    const dispose = this._disposeTableChangeListener;
+    if (dispose) {
+      dispose();
+    }
     this.pendingAbortControllers.forEach((controller) => controller.abort('Closed'));
     await this.baseDB?.close?.();
     this.closed = true;
@@ -196,7 +271,7 @@ export class LockedAsyncDatabaseAdapter
     return this.acquireLock(
       async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })),
       {
-        timeoutMs: options?.timeoutMs
+        timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
       }
     );
   }
@@ -206,23 +281,20 @@ export class LockedAsyncDatabaseAdapter
     return this.acquireLock(
       async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })),
       {
-        timeoutMs: options?.timeoutMs
+        timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
       }
     );
   }
 
-  protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
-    await this.waitForInitialized();
-
+  protected async _acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
     if (this.closing) {
       throw new Error(`Cannot acquire lock, the database is closing`);
     }
-
     const abortController = new AbortController();
     this.pendingAbortControllers.add(abortController);
     const { timeoutMs } = options ?? {};
 
-    const timoutId = timeoutMs
+    const timeoutId = timeoutMs
       ? setTimeout(() => {
           abortController.abort(`Timeout after ${timeoutMs}ms`);
           this.pendingAbortControllers.delete(abortController);
@@ -234,19 +306,52 @@ export class LockedAsyncDatabaseAdapter
       { signal: abortController.signal },
       async () => {
         this.pendingAbortControllers.delete(abortController);
-        if (timoutId) {
-          clearTimeout(timoutId);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
         }
-        const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
-        try {
-          return await callback();
-        } finally {
-          if (holdId) {
-            await this.baseDB.releaseHold(holdId);
+        return await callback();
+      }
+    );
+  }
+
+  protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
+    await this.waitForInitialized();
+
+    // The database is being opened in the background. Wait for it here.
+    if (this.databaseOpenPromise) {
+      await this.databaseOpenPromise;
+    }
+
+    return this._acquireLock(async () => {
+      let holdId: string | null = null;
+      try {
+        /**
+         * We can't await this since it uses the same lock as we're in now.
+         * If there is a pending open, this call will throw.
+         * If there is no pending open, but there is also no database - the open
+         * might have failed. We need to re-open the database.
+         */
+        if (this.databaseOpenPromise || !this._db) {
+          throw new ConnectionClosedError('Connection is busy re-opening');
+        }
+
+        holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
+        return await callback();
+      } catch (ex) {
+        if (ConnectionClosedError.MATCHES(ex)) {
+          if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
+            // Immediately re-open the database. We need to miss as little table updates as possible.
+            // Note, don't await this since it uses the same lock as we're in now.
+            this.reOpenInternalDB();
           }
         }
+        throw ex;
+      } finally {
+        if (holdId) {
+          await this.baseDB.releaseHold(holdId);
+        }
       }
-    );
+    }, options);
   }
 
   async readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T> {

package/src/db/adapters/WebDBAdapter.ts

@@ -1,11 +1,15 @@
 import { DBAdapter } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 export type SharedConnectionWorker = {
   identifier: string;
   port: MessagePort;
 };
 
+export type WebDBAdapterConfiguration = ResolvedWebSQLOpenOptions & {
+  requiresPersistentTriggers: boolean;
+};
+
 export interface WebDBAdapter extends DBAdapter {
   /**
    * Get a MessagePort which can be used to share the internals of this connection.
@@ -16,5 +20,5 @@ export interface WebDBAdapter extends DBAdapter {
    * Get the config options used to open this connection.
    * This is useful for sharing connections.
    */
-  getConfiguration(): ResolvedWebSQLOpenOptions;
+  getConfiguration(): WebDBAdapterConfiguration;
 }

package/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -1,11 +1,12 @@
+import { BaseObserver, ConnectionClosedError } from '@powersync/common';
 import * as Comlink from 'comlink';
 import {
   AsyncDatabaseConnection,
   OnTableChangeCallback,
   OpenAsyncDatabaseConnection,
   ProxiedQueryResult
-} from './AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+} from './AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 export type SharedConnectionWorker = {
   identifier: string;
@@ -23,17 +24,23 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
   onClose?: () => void;
 };
 
+export type WorkerWrappedAsyncDatabaseConnectionListener = {
+  closing: () => void;
+};
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
 export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions>
+  extends BaseObserver<WorkerWrappedAsyncDatabaseConnectionListener>
   implements AsyncDatabaseConnection
 {
   protected lockAbortController = new AbortController();
   protected notifyRemoteClosed: AbortController | undefined;
 
   constructor(protected options: WrappedWorkerConnectionOptions<Config>) {
+    super();
+
     if (options.remoteCanCloseUnexpectedly) {
       this.notifyRemoteClosed = new AbortController();
     }
@@ -72,18 +79,21 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     return this.withRemote(() => this.baseConnection.isAutoCommit());
   }
 
-  private withRemote<T>(workerPromise: () => Promise<T>): Promise<T> {
+  private withRemote<T>(workerPromise: () => Promise<T>, fireActionOnAbort = false): Promise<T> {
     const controller = this.notifyRemoteClosed;
     if (controller) {
       return new Promise((resolve, reject) => {
         if (controller.signal.aborted) {
-          reject(new Error('Called operation on closed remote'));
-          // Don't run the operation if we're going to reject
-          return;
+          reject(new ConnectionClosedError('Called operation on closed remote'));
+          if (!fireActionOnAbort) {
+            // Don't run the operation if we're going to reject
+            // We might want to fire-and-forget the operation in some cases (like a close operation)
+            return;
+          }
         }
 
         function handleAbort() {
-          reject(new Error('Remote peer closed with request in flight'));
+          reject(new ConnectionClosedError('Remote peer closed with request in flight'));
         }
 
         function completePromise(action: () => void) {
@@ -164,10 +174,12 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     // Abort any pending lock requests.
     this.lockAbortController.abort();
     try {
-      await this.withRemote(() => this.baseConnection.close());
+      // fire and forget the close operation
+      await this.withRemote(() => this.baseConnection.close(), true);
     } finally {
       this.options.remote[Comlink.releaseProxy]();
       this.options.onClose?.();
+      this.iterateListeners((l) => l.closing?.());
     }
   }
 

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

@@ -0,0 +1,23 @@
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WebDBAdapterConfiguration } from '../WebDBAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+
+/**
+ * @internal
+ * An intermediary implementation of WASQLiteDBAdapter, which takes the same
+ * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
+ * basic WA-SQLite specific functionality.
+ * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
+ */
+export class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+  getConfiguration(): WebDBAdapterConfiguration {
+    // This is valid since we only handle WASQLite connections
+    const baseConfig = super.getConfiguration() as unknown as ResolvedWASQLiteOpenFactoryOptions;
+    return {
+      ...super.getConfiguration(),
+      requiresPersistentTriggers:
+        baseConfig.vfs == WASQLiteVFS.OPFSCoopSyncVFS || baseConfig.vfs == WASQLiteVFS.AccessHandlePoolVFS
+    };
+  }
+}