@powersync/common 0.0.0-dev-20260504100448 → 0.0.0-dev-20260630141119

package/lib/client/{AbstractPowerSyncDatabase.d.ts → CommonPowerSyncDatabase.d.ts}

@@ -1,72 +1,58 @@
-import { ILogger } from 'js-logger';
-import { DBAdapter, QueryResult, Transaction } from '../db/DBAdapter.js';
+import { DBAdapter, DBGetUtils, LockContext, SqlExecutor, Transaction } from '../db/DBAdapter.js';
 import { SyncStatus } from '../db/crud/SyncStatus.js';
-import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
 import { Schema } from '../db/schema/Schema.js';
-import { BaseObserver } from '../utils/BaseObserver.js';
-import { ConnectionManager, CreateSyncImplementationOptions } from './ConnectionManager.js';
-import { ArrayQueryDefinition, Query } from './Query.js';
-import { SQLOpenFactory, SQLOpenOptions } from './SQLOpenFactory.js';
+import { BaseListener, BaseObserverInterface } from '../utils/BaseObserver.js';
+import { WatchedQueryComparator } from './watched/processors/comparators.js';
+import { PowerSyncLogger } from '../utils/Logger.js';
+import { DatabaseSource } from './SQLOpenFactory.js';
+import { TriggerManager } from './triggers/TriggerManager.js';
 import { PowerSyncBackendConnector } from './connection/PowerSyncBackendConnector.js';
-import { BucketStorageAdapter } from './sync/bucket/BucketStorageAdapter.js';
+import { SyncOptions } from './sync/options.js';
+import { SyncStream } from './sync/sync-streams.js';
+import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
 import { CrudBatch } from './sync/bucket/CrudBatch.js';
 import { CrudTransaction } from './sync/bucket/CrudTransaction.js';
-import { InternalConnectionOptions, StreamingSyncImplementation, StreamingSyncImplementationListener, type AdditionalConnectionOptions, type PowerSyncConnectionOptions, type RequiredAdditionalConnectionOptions } from './sync/stream/AbstractStreamingSyncImplementation.js';
-import { SyncStream } from './sync/sync-streams.js';
-import { TriggerManager, TriggerManagerConfig } from './triggers/TriggerManager.js';
-import { TriggerManagerImpl } from './triggers/TriggerManagerImpl.js';
+import { ArrayQueryDefinition, Query } from './Query.js';
 import { WatchCompatibleQuery } from './watched/WatchedQuery.js';
-import { WatchedQueryComparator } from './watched/processors/comparators.js';
 import { Mutex } from '../utils/mutex.js';
+import { QueryResult } from '../db/QueryResult.js';
+/**
+ * @public
+ */
 export interface DisconnectAndClearOptions {
     /** When set to false, data in local-only tables is preserved. */
     clearLocal?: boolean;
 }
-export interface BasePowerSyncDatabaseOptions extends AdditionalConnectionOptions {
+/**
+ * Options required regardless of how a PowerSync database is opened.
+ *
+ * @public
+ */
+export interface BasePowerSyncDatabaseOptions {
     /** Schema used for the local database. */
     schema: Schema;
-    /**
-     * @deprecated Use {@link retryDelayMs} instead as this will be removed in future releases.
-     */
-    retryDelay?: number;
-    logger?: ILogger;
-}
-export interface PowerSyncDatabaseOptions extends BasePowerSyncDatabaseOptions {
-    /**
-     * Source for a SQLite database connection.
-     * This can be either:
-     *  - A {@link DBAdapter} if providing an instantiated SQLite connection
-     *  - A {@link SQLOpenFactory} which will be used to open a SQLite connection
-     *  - {@link SQLOpenOptions} for opening a SQLite connection with a default {@link SQLOpenFactory}
-     */
-    database: DBAdapter | SQLOpenFactory | SQLOpenOptions;
-}
-export interface PowerSyncDatabaseOptionsWithDBAdapter extends BasePowerSyncDatabaseOptions {
-    database: DBAdapter;
-}
-export interface PowerSyncDatabaseOptionsWithOpenFactory extends BasePowerSyncDatabaseOptions {
-    database: SQLOpenFactory;
-}
-export interface PowerSyncDatabaseOptionsWithSettings extends BasePowerSyncDatabaseOptions {
-    database: SQLOpenOptions;
+    logger?: PowerSyncLogger;
 }
+/**
+ * @public
+ */
+export type PowerSyncDatabaseOptions = BasePowerSyncDatabaseOptions & DatabaseSource;
+/**
+ * @public
+ */
 export interface SQLOnChangeOptions {
     signal?: AbortSignal;
     tables?: string[];
     /** The minimum interval between queries. */
     throttleMs?: number;
-    /**
-     * @deprecated All tables specified in {@link tables} will be watched, including PowerSync tables with prefixes.
-     *
-     * Allows for watching any SQL table
-     * by not removing PowerSync table name prefixes
-     */
-    rawTableNames?: boolean;
     /**
      * Emits an empty result set immediately
      */
     triggerImmediate?: boolean;
 }
+/**
+ * @public
+ */
 export interface SQLWatchOptions extends SQLOnChangeOptions {
     /**
      * Optional comparator which will be used to compare the results of the query.
@@ -74,23 +60,38 @@ export interface SQLWatchOptions extends SQLOnChangeOptions {
      */
     comparator?: WatchedQueryComparator<QueryResult>;
 }
+/**
+ * @public
+ */
 export interface WatchOnChangeEvent {
     changedTables: string[];
 }
+/**
+ * @public
+ */
 export interface WatchHandler {
     onResult: (results: QueryResult) => void;
     onError?: (error: Error) => void;
 }
+/**
+ * @public
+ */
 export interface WatchOnChangeHandler {
     onChange: (event: WatchOnChangeEvent) => Promise<void> | void;
-    onError?: (error: Error) => void;
 }
-export interface PowerSyncDBListener extends StreamingSyncImplementationListener {
+/**
+ * @public
+ */
+export interface PowerSyncDBListener extends BaseListener {
     initialized: () => void;
     schemaChanged: (schema: Schema) => void;
+    statusChanged?: (status: SyncStatus) => void;
     closing: () => Promise<void> | void;
     closed: () => Promise<void> | void;
 }
+/**
+ * @public
+ */
 export interface PowerSyncCloseOptions {
     /**
      * Disconnect the sync stream client if connected.
@@ -99,76 +100,45 @@ export interface PowerSyncCloseOptions {
      */
     disconnect?: boolean;
 }
-export declare const DEFAULT_POWERSYNC_CLOSE_OPTIONS: PowerSyncCloseOptions;
-export declare const DEFAULT_POWERSYNC_DB_OPTIONS: {
-    retryDelayMs: number;
-    crudUploadThrottleMs: number;
-};
-export declare const DEFAULT_CRUD_BATCH_LIMIT = 100;
 /**
- * Requesting nested or recursive locks can block the application in some circumstances.
- * This default lock timeout will act as a failsafe to throw an error if a lock cannot
- * be obtained.
+ * @public
  */
-export declare const DEFAULT_LOCK_TIMEOUT_MS = 120000;
+export interface PowerSyncDatabaseConstructor<Options> {
+    new (options: Options): CommonPowerSyncDatabase;
+}
 /**
- * Tests if the input is a {@link PowerSyncDatabaseOptionsWithSettings}
- * @internal
+ * @public
+ * @deprecated Use {@link CommonPowerSyncDatabase} instead.
  */
-export declare const isPowerSyncDatabaseOptionsWithSettings: (test: any) => test is PowerSyncDatabaseOptionsWithSettings;
-export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDBListener> {
-    protected options: PowerSyncDatabaseOptions;
+export type AbstractPowerSyncDatabase = CommonPowerSyncDatabase;
+/**
+ * @public
+ */
+export interface CommonPowerSyncDatabase extends BaseObserverInterface<PowerSyncDBListener>, SqlExecutor, DBGetUtils {
     /**
      * Returns true if the connection is closed.
      */
-    closed: boolean;
-    ready: boolean;
+    readonly closed: boolean;
+    readonly ready: boolean;
     /**
      * Current connection status.
      */
-    currentStatus: SyncStatus;
-    sdkVersion: string;
-    protected bucketStorageAdapter: BucketStorageAdapter;
-    protected _isReadyPromise: Promise<void>;
-    protected connectionManager: ConnectionManager;
-    private subscriptions;
-    get syncStreamImplementation(): StreamingSyncImplementation | null;
-    /**
-     * The connector used to connect to the PowerSync service.
-     *
-     * @returns The connector used to connect to the PowerSync service or null if `connect()` has not been called.
-     */
-    get connector(): PowerSyncBackendConnector | null;
+    readonly currentStatus: SyncStatus;
+    readonly sdkVersion: string;
     /**
-     * The resolved connection options used to connect to the PowerSync service.
-     *
-     * @returns The resolved connection options used to connect to the PowerSync service or null if `connect()` has not been called.
-     */
-    get connectionOptions(): InternalConnectionOptions | null;
-    protected _schema: Schema;
-    private _database;
-    protected runExclusiveMutex: Mutex;
-    /**
-     * @experimental
+     * @experimental @alpha
      * Allows creating SQLite triggers which can be used to track various operations on SQLite tables.
      */
     readonly triggers: TriggerManager;
-    protected triggersImpl: TriggerManagerImpl;
-    logger: ILogger;
-    constructor(options: PowerSyncDatabaseOptionsWithDBAdapter);
-    constructor(options: PowerSyncDatabaseOptionsWithOpenFactory);
-    constructor(options: PowerSyncDatabaseOptionsWithSettings);
-    constructor(options: PowerSyncDatabaseOptions);
+    readonly logger: PowerSyncLogger;
     /**
      * Schema used for the local database.
      */
-    get schema(): Schema<{
-        [x: string]: import("../index.js").Table<any>;
-    }>;
+    readonly schema: Schema;
     /**
      * The underlying database.
      *
-     * For the most part, behavior is the same whether querying on the underlying database, or on {@link AbstractPowerSyncDatabase}.
+     * For the most part, behavior is the same whether querying on the underlying database, or on {@link CommonPowerSyncDatabase}.
      */
     get database(): DBAdapter;
     /**
@@ -176,17 +146,6 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      */
     get connected(): boolean;
     get connecting(): boolean;
-    /**
-     * Opens the DBAdapter given open options using a default open factory
-     */
-    protected abstract openDBAdapter(options: PowerSyncDatabaseOptionsWithSettings): DBAdapter;
-    /**
-     * Generates a base configuration for {@link TriggerManagerImpl}.
-     * Implementations should override this if necessary.
-     */
-    protected generateTriggerManagerConfig(): TriggerManagerConfig;
-    protected abstract generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions): StreamingSyncImplementation;
-    protected abstract generateBucketStorageAdapter(): BucketStorageAdapter;
     /**
      * @returns A promise which will resolve once initialization is completed.
      */
@@ -194,7 +153,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     /**
      * Wait for the first sync operation to complete.
      *
-     * @param request Either an abort signal (after which the promise will complete regardless of
+     * @param request - Either an abort signal (after which the promise will complete regardless of
      * whether a full sync was completed) or an object providing an abort signal and a priority target.
      * When a priority target is set, the promise may complete when all buckets with the given (or higher)
      * priorities have been synchronized. This can be earlier than a complete sync.
@@ -208,22 +167,10 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Waits for the first sync status for which the `status` callback returns a truthy value.
      */
     waitForStatus(predicate: (status: SyncStatus) => any, signal?: AbortSignal): Promise<void>;
-    /**
-     * Allows for extended implementations to execute custom initialization
-     * logic as part of the total init process
-     */
-    abstract _initialize(): Promise<void>;
-    /**
-     * Entry point for executing initialization logic.
-     * This is to be automatically executed in the constructor.
-     */
-    protected initialize(): Promise<void>;
-    protected loadVersion(): Promise<void>;
-    protected resolveOfflineSyncStatus(): Promise<void>;
     /**
      * Replace the schema with a new version. This is for advanced use cases - typically the schema should just be specified once in the constructor.
      *
-     * Cannot be used while connected - this should only be called before {@link AbstractPowerSyncDatabase.connect}.
+     * Cannot be used while connected - this should only be called before {@link CommonPowerSyncDatabase.connect}.
      */
     updateSchema(schema: Schema): Promise<void>;
     /**
@@ -231,25 +178,14 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * While initializing is automatic, this helps to catch and report initialization errors.
      */
     init(): Promise<void>;
-    protected resolvedConnectionOptions(options: CreateSyncImplementationOptions): CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions;
-    /**
-     * @deprecated Use {@link AbstractPowerSyncDatabase#close} instead.
-     * Clears all listeners registered by {@link AbstractPowerSyncDatabase#registerListener}.
-     */
-    dispose(): void;
-    /**
-     * Locking mechanism for exclusively running critical portions of connect/disconnect operations.
-     * Locking here is mostly only important on web for multiple tab scenarios.
-     */
-    protected runExclusive<T>(callback: () => Promise<T>): Promise<T>;
     /**
      * Connects to stream of events from the PowerSync instance.
      */
-    connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
+    connect(connector: PowerSyncBackendConnector, options?: SyncOptions): Promise<void>;
     /**
      * Close the sync connection.
      *
-     * Use {@link connect} to connect again.
+     * Use {@link CommonPowerSyncDatabase.connect} to connect again.
      */
     disconnect(): Promise<void>;
     /**
@@ -264,10 +200,9 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     /**
      * Create a sync stream to query its status or to subscribe to it.
      *
-     * @param name The name of the stream to subscribe to.
-     * @param params Optional parameters for the stream subscription.
+     * @param name - The name of the stream to subscribe to.
+     * @param params - Optional parameters for the stream subscription.
      * @returns A {@link SyncStream} instance that can be subscribed to.
-     * @experimental Sync streams are currently in alpha.
      */
     syncStream(name: string, params?: Record<string, any>): SyncStream;
     /**
@@ -293,14 +228,14 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Once the data have been successfully uploaded, call {@link CrudBatch.complete} before
      * requesting the next batch.
      *
-     * Use {@link limit} to specify the maximum number of updates to return in a single
+     * Use the `limit` parameter to specify the maximum number of updates to return in a single
      * batch.
      *
      * This method does include transaction ids in the result, but does not group
      * data by transaction. One batch may contain data from multiple transactions,
      * and a single transaction may be split over multiple batches.
      *
-     * @param limit Maximum number of CRUD entries to include in the batch
+     * @param limit - Maximum number of CRUD entries to include in the batch
      * @returns A batch of CRUD operations to upload, or null if there are none
      */
     getCrudBatch(limit?: number): Promise<CrudBatch | null>;
@@ -314,7 +249,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Once the data have been successfully uploaded, call {@link CrudTransaction.complete} before
      * requesting the next transaction.
      *
-     * Unlike {@link getCrudBatch}, this only returns data from a single transaction at a time.
+     * Unlike {@link CommonPowerSyncDatabase.getCrudBatch}, this only returns data from a single transaction at a time.
      * All data for the transaction is loaded into memory.
      *
      * @returns A transaction of CRUD operations to upload, or null if there are none
@@ -326,7 +261,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * This is typically used from the {@link PowerSyncBackendConnector.uploadData} callback. Each entry emitted by the
      * returned iterator is a full transaction containing all local writes made while that transaction was active.
      *
-     * Unlike {@link getNextCrudTransaction}, which always returns the oldest transaction that hasn't been
+     * Unlike {@link CommonPowerSyncDatabase.getNextCrudTransaction}, which always returns the oldest transaction that hasn't been
      * {@link CrudTransaction.complete}d yet, this iterator can be used to receive multiple transactions. Calling
      * {@link CrudTransaction.complete} will mark that and all prior transactions emitted by the iterator as completed.
      *
@@ -360,82 +295,23 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * @returns A unique identifier for the database instance
      */
     getClientId(): Promise<string>;
-    private handleCrudCheckpoint;
-    /**
-     * Execute a SQL write (INSERT/UPDATE/DELETE) query
-     * and optionally return results.
-     *
-     * When using the default client-side [JSON-based view system](https://docs.powersync.com/architecture/client-architecture#client-side-schema-and-sqlite-database-structure),
-     * the returned result's `rowsAffected` may be `0` for successful `UPDATE` and `DELETE` statements.
-     * Use a `RETURNING` clause and inspect `result.rows` when you need to confirm which rows changed.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The query result as an object with structured key-value pairs
-     */
-    execute(sql: string, parameters?: any[]): Promise<QueryResult>;
-    /**
-     * Execute a SQL write (INSERT/UPDATE/DELETE) query directly on the database without any PowerSync processing.
-     * This bypasses certain PowerSync abstractions and is useful for accessing the raw database results.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The raw query result from the underlying database as a nested array of raw values, where each row is
-     * represented as an array of column values without field names.
-     */
-    executeRaw(sql: string, parameters?: any[]): Promise<any[][]>;
-    /**
-     * Execute a write query (INSERT/UPDATE/DELETE) multiple times with each parameter set
-     * and optionally return results.
-     * This is faster than executing separately with each parameter set.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional 2D array of parameter sets, where each inner array is a set of parameters for one execution
-     * @returns The query result
-     */
-    executeBatch(sql: string, parameters?: any[][]): Promise<QueryResult>;
-    /**
-     *  Execute a read-only query and return results.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns An array of results
-     */
-    getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
-    /**
-     * Execute a read-only query and return the first result, or null if the ResultSet is empty.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The first result if found, or null if no results are returned
-     */
-    getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
-    /**
-     * Execute a read-only query and return the first result, error if the ResultSet is empty.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The first result matching the query
-     * @throws Error if no rows are returned
-     */
-    get<T>(sql: string, parameters?: any[]): Promise<T>;
     /**
      * Takes a read lock, without starting a transaction.
-     * In most cases, {@link readTransaction} should be used instead.
+     * In most cases, {@link CommonPowerSyncDatabase.readTransaction} should be used instead.
      */
-    readLock<T>(callback: (db: DBAdapter) => Promise<T>): Promise<T>;
+    readLock<T>(callback: (db: LockContext) => Promise<T>): Promise<T>;
     /**
      * Takes a global lock, without starting a transaction.
-     * In most cases, {@link writeTransaction} should be used instead.
+     * In most cases, {@link CommonPowerSyncDatabase.writeTransaction} should be used instead.
      */
-    writeLock<T>(callback: (db: DBAdapter) => Promise<T>): Promise<T>;
+    writeLock<T>(callback: (db: LockContext) => Promise<T>): Promise<T>;
     /**
      * Open a read-only transaction.
      * Read transactions can run concurrently to a write transaction.
      * Changes from any write transaction are not visible to read transactions started before it.
      *
-     * @param callback Function to execute within the transaction
-     * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
+     * @param callback - Function to execute within the transaction
+     * @param lockTimeout - Time in milliseconds to wait for a lock before throwing an error
      * @returns The result of the callback
      * @throws Error if the lock cannot be obtained within the timeout period
      */
@@ -445,15 +321,15 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * This takes a global lock - only one write transaction can execute against the database at a time.
      * Statements within the transaction must be done on the provided {@link Transaction} interface.
      *
-     * @param callback Function to execute within the transaction
-     * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
+     * @param callback - Function to execute within the transaction
+     * @param lockTimeout - Time in milliseconds to wait for a lock before throwing an error
      * @returns The result of the callback
      * @throws Error if the lock cannot be obtained within the timeout period
      */
     writeTransaction<T>(callback: (tx: Transaction) => Promise<T>, lockTimeout?: number): Promise<T>;
     /**
-     * This version of `watch` uses {@link AsyncGenerator}, for documentation see {@link watchWithAsyncGenerator}.
-     * Can be overloaded to use a callback handler instead, for documentation see {@link watchWithCallback}.
+     * This version of `watch` uses `AsyncGenerator`, for documentation see {@link CommonPowerSyncDatabase.watchWithAsyncGenerator}.
+     * Can be overloaded to use a callback handler instead, for documentation see {@link CommonPowerSyncDatabase.watchWithCallback}.
      *
      * @example
      * ```javascript
@@ -469,7 +345,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      */
     watch(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult>;
     /**
-     * See {@link watchWithCallback}.
+     * See {@link CommonPowerSyncDatabase.watchWithCallback}.
      *
      * @example
      * ```javascript
@@ -487,7 +363,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     watch(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void;
     /**
      * Allows defining a query which can be used to build a {@link WatchedQuery}.
-     * The defined query will be executed with {@link AbstractPowerSyncDatabase#getAll}.
+     * The defined query will be executed with {@link CommonPowerSyncDatabase#getAll}.
      * An optional mapper function can be provided to transform the results.
      *
      * @example
@@ -523,25 +399,25 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     customQuery<RowType>(query: WatchCompatibleQuery<RowType[]>): Query<RowType>;
     /**
      * Execute a read query every time the source tables are modified.
-     * Use {@link SQLWatchOptions.throttleMs} to specify the minimum interval between queries.
+     * Use {@link SQLOnChangeOptions.throttleMs} to specify the minimum interval between queries.
      * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
      *
      * Note that the `onChange` callback member of the handler is required.
      *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @param handler Callbacks for handling results and errors
-     * @param options Options for configuring watch behavior
+     * @param sql - The SQL query to execute
+     * @param parameters - Optional array of parameters to bind to the query
+     * @param handler - Callbacks for handling results and errors
+     * @param options - Options for configuring watch behavior
      */
     watchWithCallback(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void;
     /**
      * Execute a read query every time the source tables are modified.
-     * Use {@link SQLWatchOptions.throttleMs} to specify the minimum interval between queries.
+     * Use {@link SQLOnChangeOptions.throttleMs} to specify the minimum interval between queries.
      * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
      *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @param options Options for configuring watch behavior
+     * @param sql - The SQL query to execute
+     * @param parameters - Optional array of parameters to bind to the query
+     * @param options - Options for configuring watch behavior
      * @returns An AsyncIterable that yields QueryResults whenever the data changes
      */
     watchWithAsyncGenerator(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult>;
@@ -550,15 +426,15 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * If tables are specified in the options, those are used directly.
      * Otherwise, analyzes the query using EXPLAIN to determine which tables are accessed.
      *
-     * @param sql The SQL query to analyze
-     * @param parameters Optional parameters for the SQL query
-     * @param options Optional watch options that may contain explicit table list
+     * @param sql - The SQL query to analyze
+     * @param parameters - Optional parameters for the SQL query
+     * @param options - Optional watch options that may contain explicit table list
      * @returns Array of table names that the query depends on
      */
     resolveTables(sql: string, parameters?: any[], options?: SQLWatchOptions): Promise<string[]>;
     /**
-     * This version of `onChange` uses {@link AsyncGenerator}, for documentation see {@link onChangeWithAsyncGenerator}.
-     * Can be overloaded to use a callback handler instead, for documentation see {@link onChangeWithCallback}.
+     * This version of `onChange` uses `AsyncGenerator`, for documentation see {@link CommonPowerSyncDatabase.onChangeWithAsyncGenerator}.
+     * Can be overloaded to use a callback handler instead, for documentation see {@link CommonPowerSyncDatabase.onChangeWithCallback}.
      *
      * @example
      * ```javascript
@@ -571,7 +447,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      */
     onChange(options?: SQLOnChangeOptions): AsyncIterable<WatchOnChangeEvent>;
     /**
-     * See {@link onChangeWithCallback}.
+     * See {@link CommonPowerSyncDatabase.onChangeWithCallback}.
      *
      * @example
      * ```javascript
@@ -588,32 +464,30 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     /**
      * Invoke the provided callback on any changes to any of the specified tables.
      *
-     * This is preferred over {@link watchWithCallback} when multiple queries need to be performed
+     * This is preferred over {@link CommonPowerSyncDatabase.watchWithCallback} when multiple queries need to be performed
      * together when data is changed.
      *
      * Note that the `onChange` callback member of the handler is required.
      *
-     * @param handler Callbacks for handling change events and errors
-     * @param options Options for configuring watch behavior
+     * @param handler - Callbacks for handling change events and errors
+     * @param options - Options for configuring watch behavior
      * @returns A dispose function to stop watching for changes
      */
     onChangeWithCallback(handler?: WatchOnChangeHandler, options?: SQLOnChangeOptions): () => void;
     /**
      * Create a Stream of changes to any of the specified tables.
      *
-     * This is preferred over {@link watchWithAsyncGenerator} when multiple queries need to be performed
-     * together when data is changed.
+     * This is preferred over {@link CommonPowerSyncDatabase.watchWithAsyncGenerator} when multiple queries need to be
+     * performed together when data is changed.
      *
      * Note: do not declare this as `async *onChange` as it will not work in React Native.
      *
-     * @param options Options for configuring watch behavior
+     * @param options - Options for configuring watch behavior
      * @returns An AsyncIterable that yields change events whenever the specified tables change
      */
     onChangeWithAsyncGenerator(options?: SQLWatchOptions): AsyncIterable<WatchOnChangeEvent>;
-    private handleTableChanges;
-    private processTableUpdates;
     /**
-     * @ignore
+     * @internal
      */
-    private executeReadOnly;
+    createMutex(): Mutex;
 }

package/lib/client/CommonPowerSyncDatabase.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CommonPowerSyncDatabase.js.map

package/lib/client/CommonPowerSyncDatabase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommonPowerSyncDatabase.js","sourceRoot":"","sources":["../../src/client/CommonPowerSyncDatabase.ts"],"names":[],"mappings":""}

package/lib/client/Query.d.ts

@@ -4,11 +4,15 @@ import { StandardWatchedQuery } from './watched/processors/OnChangeQueryProcesso
 import { WatchedQueryOptions } from './watched/WatchedQuery.js';
 /**
  * Query parameters for {@link ArrayQueryDefinition#parameters}
+ *
+ * @public
  */
 export type QueryParam = string | number | boolean | null | undefined | bigint | Uint8Array;
 /**
  * Options for building a query with {@link AbstractPowerSyncDatabase#query}.
  * This query will be executed with {@link AbstractPowerSyncDatabase#getAll}.
+ *
+ * @public
  */
 export interface ArrayQueryDefinition<RowType = unknown> {
     sql: string;
@@ -27,6 +31,8 @@ export interface ArrayQueryDefinition<RowType = unknown> {
 }
 /**
  * Options for {@link Query#watch}.
+ *
+ * @public
  */
 export interface StandardWatchedQueryOptions<RowType> extends WatchedQueryOptions {
     /**
@@ -51,6 +57,9 @@ export interface StandardWatchedQueryOptions<RowType> extends WatchedQueryOption
      */
     placeholderData?: RowType[];
 }
+/**
+ * @public
+ */
 export interface Query<RowType> {
     /**
      * Creates a {@link WatchedQuery} which watches and emits results of the linked query.