@powersync/web 1.31.0 → 1.32.0

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@powersync/web",
-  "version": "1.31.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",
@@ -52,27 +56,26 @@
   "license": "Apache-2.0",
   "peerDependencies": {
     "@journeyapps/wa-sqlite": "^1.4.1",
-    "@powersync/common": "^1.45.0"
+    "@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.45.0"
+    "@powersync/common": "1.46.0"
   },
   "devDependencies": {
     "@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

@@ -7,6 +7,7 @@ import {
   PowerSyncDatabaseOptionsWithSettings,
   SqliteBucketStorage,
   StreamingSyncImplementation,
+  TriggerManagerConfig,
   isDBAdapter,
   isSQLOpenFactory,
   type BucketStorageAdapter,
@@ -15,22 +16,25 @@ import {
   type RequiredAdditionalConnectionOptions
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { getNavigatorLocks } from '../shared/navigator';
-import { WebDBAdapter } from './adapters/WebDBAdapter';
-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,
   WebSQLFlags,
+  isServerSide,
   resolveWebSQLFlags
-} from './adapters/web-sql-flags';
-import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation';
-import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation';
-import { WebRemote } from './sync/WebRemote';
+} 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 {
   /**
@@ -143,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({
@@ -169,6 +199,20 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     });
   }
 
+  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

@@ -11,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
@@ -181,11 +181,15 @@ export class LockedAsyncDatabaseAdapter
     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() {

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

@@ -5,8 +5,8 @@ import {
   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;

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
+    };
+  }
+}

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

@@ -1,8 +1,8 @@
 import * as SQLite from '@journeyapps/wa-sqlite';
 import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory';
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
 /**
  * List of currently tested virtual filesystems
  */

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

@@ -1,17 +1,17 @@
 import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
-import { OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
+import { OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
   TemporaryStorageOption,
   WebSQLFlags
-} from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteVFS } from './WASQLiteConnection';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+} from '../web-sql-flags.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 
 /**
  * These flags are the same as {@link WebSQLFlags}.
@@ -44,7 +44,7 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
   constructor(options: WASQLiteDBAdapterOptions) {
     super({
       name: options.dbFilename,

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

@@ -1,17 +1,17 @@
 import { DBAdapter, type ILogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
-import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
   TemporaryStorageOption,
   WebSQLOpenFactoryOptions
-} from '../web-sql-flags';
-import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection';
+} from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
   vfs?: WASQLiteVFS;
@@ -41,7 +41,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
   }
 
   protected openAdapter(): DBAdapter {
-    return new LockedAsyncDatabaseAdapter({
+    return new InternalWASQLiteDBAdapter({
       name: this.options.dbFilename,
       openConnection: () => this.openConnection(),
       debugMode: this.options.debugMode,

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

@@ -1,7 +1,7 @@
 import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
-import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase';
-import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase.js';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 
 /**
  * @deprecated {@link PowerSyncDatabase} can now be constructed directly

package/src/db/sync/SharedWebStreamingSyncImplementation.ts

@@ -5,16 +5,16 @@ import {
   SyncStatusOptions
 } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { ManualSharedSyncPayload, SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { WorkerClient } from '../../worker/sync/WorkerClient';
-import { WebDBAdapter } from '../adapters/WebDBAdapter';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags';
+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';
+} from './WebStreamingSyncImplementation.js';
 
 /**
  * The shared worker will trigger methods on this side of the message port

package/src/db/sync/WebRemote.ts

@@ -9,7 +9,7 @@ import {
   RemoteConnector
 } from '@powersync/common';
 
-import { getUserAgentInfo } from './userAgent';
+import { getUserAgentInfo } from './userAgent.js';
 
 /*
  * Depends on browser's implementation of global fetch.

package/src/db/sync/WebStreamingSyncImplementation.ts

@@ -4,8 +4,8 @@ import {
   LockOptions,
   LockType
 } from '@powersync/common';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags.js';
 
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
   flags?: WebSQLFlags;

package/src/index.ts

@@ -1,13 +1,13 @@
 export * from '@powersync/common';
-export * from './db/adapters/AsyncDatabaseConnection';
-export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-export * from './db/adapters/AbstractWebSQLOpenFactory';
-export * from './db/adapters/wa-sqlite/WASQLiteConnection';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
-export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory';
-export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
-export * from './db/adapters/web-sql-flags';
-export * from './db/PowerSyncDatabase';
-export * from './db/sync/SharedWebStreamingSyncImplementation';
-export * from './db/sync/WebRemote';
-export * from './db/sync/WebStreamingSyncImplementation';
+export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/AbstractWebSQLOpenFactory.js';
+export * from './db/adapters/AsyncDatabaseConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.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/PowerSyncDatabase.js';
+export * from './db/sync/SharedWebStreamingSyncImplementation.js';
+export * from './db/sync/WebRemote.js';
+export * from './db/sync/WebStreamingSyncImplementation.js';

package/src/worker/db/SharedWASQLiteConnection.ts

@@ -3,8 +3,8 @@ import {
   AsyncDatabaseConnection,
   OnTableChangeCallback,
   ProxiedQueryResult
-} from '../../db/adapters/AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
+} from '../../db/adapters/AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 
 /**
  * Keeps track of open DB connections and the clients which

package/src/worker/db/WASQLiteDB.worker.ts

@@ -5,11 +5,11 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
-import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection';
-import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
+import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection.js';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection.js';
 
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();

package/src/worker/db/WorkerWASQLiteConnection.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 
 /**
  * A Small proxy wrapper around the WASqliteConnection.

package/src/worker/db/open-worker-database.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OpenAsyncDatabaseConnection } from '../..//db/adapters/AsyncDatabaseConnection';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections

package/src/worker/sync/BroadcastLogger.ts

@@ -1,5 +1,5 @@
 import { type ILogger, type ILogLevel, LogLevel } from '@powersync/common';
-import { type WrappedSyncPort } from './SharedSyncImplementation';
+import { type WrappedSyncPort } from './SharedSyncImplementation.js';
 
 /**
  * Broadcasts logs to all clients

package/src/worker/sync/SharedSyncImplementation.ts

@@ -17,18 +17,18 @@ import {
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import { WebRemote } from '../../db/sync/WebRemote';
+import { WebRemote } from '../../db/sync/WebRemote.js';
 import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
-} from '../../db/sync/WebStreamingSyncImplementation';
-
-import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
-import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
-import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
-import { BroadcastLogger } from './BroadcastLogger';
+} from '../../db/sync/WebStreamingSyncImplementation.js';
+
+import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
+import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
+import { BroadcastLogger } from './BroadcastLogger.js';
 
 /**
  * @internal

package/src/worker/sync/SharedSyncImplementation.worker.ts

@@ -1,6 +1,6 @@
 import { createBaseLogger } from '@powersync/common';
-import { SharedSyncImplementation } from './SharedSyncImplementation';
-import { WorkerClient } from './WorkerClient';
+import { SharedSyncImplementation } from './SharedSyncImplementation.js';
+import { WorkerClient } from './WorkerClient.js';
 
 const _self: SharedWorkerGlobalScope = self as any;
 const logger = createBaseLogger();

package/src/worker/sync/WorkerClient.ts

@@ -1,13 +1,13 @@
 import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
+import { getNavigatorLocks } from '../../shared/navigator.js';
 import {
   ManualSharedSyncPayload,
   SharedSyncClientEvent,
   SharedSyncImplementation,
   SharedSyncInitOptions,
   WrappedSyncPort
-} from './SharedSyncImplementation';
+} from './SharedSyncImplementation.js';
 
 /**
  * A client to the shared sync worker.