@powersync/common 0.0.0-dev-20250710154318 → 0.0.0-dev-20250714144421

package/lib/client/AbstractPowerSyncDatabase.d.ts

@@ -100,11 +100,6 @@ export declare const DEFAULT_LOCK_TIMEOUT_MS = 120000;
 export declare const isPowerSyncDatabaseOptionsWithSettings: (test: any) => test is PowerSyncDatabaseOptionsWithSettings;
 export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDBListener> {
     protected options: PowerSyncDatabaseOptions;
-    /**
-     * Transactions should be queued in the DBAdapter, but we also want to prevent
-     * calls to `.execute` while an async transaction is running.
-     */
-    protected static transactionMutex: Mutex;
     /**
      * Returns true if the connection is closed.
      */

package/lib/client/AbstractPowerSyncDatabase.js

@@ -8,7 +8,6 @@ import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
 import { BaseObserver } from '../utils/BaseObserver.js';
 import { ControlledExecutor } from '../utils/ControlledExecutor.js';
 import { throttleTrailing } from '../utils/async.js';
-import { mutexRunExclusive } from '../utils/mutex.js';
 import { ConnectionManager } from './ConnectionManager.js';
 import { isDBAdapter, isSQLOpenFactory, isSQLOpenOptions } from './SQLOpenFactory.js';
 import { runOnSchemaChange } from './runOnSchemaChange.js';
@@ -45,11 +44,6 @@ export const isPowerSyncDatabaseOptionsWithSettings = (test) => {
 };
 export class AbstractPowerSyncDatabase extends BaseObserver {
     options;
-    /**
-     * Transactions should be queued in the DBAdapter, but we also want to prevent
-     * calls to `.execute` while an async transaction is running.
-     */
-    static transactionMutex = new Mutex();
     /**
      * Returns true if the connection is closed.
      */
@@ -475,8 +469,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      * @returns The query result as an object with structured key-value pairs
      */
     async execute(sql, parameters) {
-        await this.waitForReady();
-        return this.database.execute(sql, parameters);
+        return this.writeLock((tx) => tx.execute(sql, parameters));
     }
     /**
      * Execute a SQL write (INSERT/UPDATE/DELETE) query directly on the database without any PowerSync processing.
@@ -544,7 +537,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      */
     async readLock(callback) {
         await this.waitForReady();
-        return mutexRunExclusive(AbstractPowerSyncDatabase.transactionMutex, () => callback(this.database));
+        return this.database.readLock(callback);
     }
     /**
      * Takes a global lock, without starting a transaction.
@@ -552,10 +545,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      */
     async writeLock(callback) {
         await this.waitForReady();
-        return mutexRunExclusive(AbstractPowerSyncDatabase.transactionMutex, async () => {
-            const res = await callback(this.database);
-            return res;
-        });
+        return this.database.writeLock(callback);
     }
     /**
      * Open a read-only transaction.

package/lib/client/sync/bucket/SqliteBucketStorage.d.ts

@@ -1,4 +1,3 @@
-import { Mutex } from 'async-mutex';
 import { ILogger } from 'js-logger';
 import { DBAdapter, Transaction } from '../../../db/DBAdapter.js';
 import { BaseObserver } from '../../../utils/BaseObserver.js';
@@ -8,13 +7,12 @@ import { CrudEntry } from './CrudEntry.js';
 import { SyncDataBatch } from './SyncDataBatch.js';
 export declare class SqliteBucketStorage extends BaseObserver<BucketStorageListener> implements BucketStorageAdapter {
     private db;
-    private mutex;
     private logger;
     tableNames: Set<string>;
     private _hasCompletedSync;
     private updateListener;
     private _clientId?;
-    constructor(db: DBAdapter, mutex: Mutex, logger?: ILogger);
+    constructor(db: DBAdapter, logger?: ILogger);
     init(): Promise<void>;
     dispose(): Promise<void>;
     _getClientId(): Promise<string>;

package/lib/client/sync/bucket/SqliteBucketStorage.js

@@ -6,16 +6,14 @@ import { PSInternalTable } from './BucketStorageAdapter.js';
 import { CrudEntry } from './CrudEntry.js';
 export class SqliteBucketStorage extends BaseObserver {
     db;
-    mutex;
     logger;
     tableNames;
     _hasCompletedSync;
     updateListener;
     _clientId;
-    constructor(db, mutex, logger = Logger.get('SqliteBucketStorage')) {
+    constructor(db, logger = Logger.get('SqliteBucketStorage')) {
         super();
         this.db = db;
-        this.mutex = mutex;
         this.logger = logger;
         this._hasCompletedSync = false;
         this.tableNames = new Set();
@@ -66,11 +64,11 @@ export class SqliteBucketStorage extends BaseObserver {
     async saveSyncData(batch, fixedKeyFormat = false) {
         await this.writeTransaction(async (tx) => {
             for (const b of batch.buckets) {
-                const result = await tx.execute('INSERT INTO powersync_operations(op, data) VALUES(?, ?)', [
+                await tx.execute('INSERT INTO powersync_operations(op, data) VALUES(?, ?)', [
                     'save',
                     JSON.stringify({ buckets: [b.toJSON(fixedKeyFormat)] })
                 ]);
-                this.logger.debug('saveSyncData', JSON.stringify(result));
+                this.logger.debug(`Saved batch of data for  bucket: ${b.bucket}, operations: ${b.data.length}`);
             }
         });
     }
@@ -86,7 +84,7 @@ export class SqliteBucketStorage extends BaseObserver {
         await this.writeTransaction(async (tx) => {
             await tx.execute('INSERT INTO powersync_operations(op, data) VALUES(?, ?)', ['delete_bucket', bucket]);
         });
-        this.logger.debug('done deleting bucket');
+        this.logger.debug(`Done deleting bucket ${bucket}`);
     }
     async hasCompletedSync() {
         if (this._hasCompletedSync) {
@@ -108,6 +106,12 @@ export class SqliteBucketStorage extends BaseObserver {
             }
             return { ready: false, checkpointValid: false, checkpointFailures: r.checkpointFailures };
         }
+        if (priority == null) {
+            this.logger.debug(`Validated checksums checkpoint ${checkpoint.last_op_id}`);
+        }
+        else {
+            this.logger.debug(`Validated checksums for partial checkpoint ${checkpoint.last_op_id}, priority ${priority}`);
+        }
         let buckets = checkpoint.buckets;
         if (priority !== undefined) {
             buckets = buckets.filter((b) => hasMatchingPriority(priority, b));
@@ -124,7 +128,6 @@ export class SqliteBucketStorage extends BaseObserver {
         });
         const valid = await this.updateObjectsFromBuckets(checkpoint, priority);
         if (!valid) {
-            this.logger.debug('Not at a consistent checkpoint - cannot update local db');
             return { ready: false, checkpointValid: true };
         }
         return {
@@ -177,7 +180,6 @@ export class SqliteBucketStorage extends BaseObserver {
             JSON.stringify({ ...checkpoint })
         ]);
         const resultItem = rs.rows?.item(0);
-        this.logger.debug('validateChecksums priority, checkpoint, result item', priority, checkpoint, resultItem);
         if (!resultItem) {
             return {
                 checkpointValid: false,
@@ -210,30 +212,26 @@ export class SqliteBucketStorage extends BaseObserver {
         }
         const seqBefore = rs[0]['seq'];
         const opId = await cb();
-        this.logger.debug(`[updateLocalTarget] Updating target to checkpoint ${opId}`);
         return this.writeTransaction(async (tx) => {
             const anyData = await tx.execute('SELECT 1 FROM ps_crud LIMIT 1');
             if (anyData.rows?.length) {
                 // if isNotEmpty
-                this.logger.debug('updateLocalTarget', 'ps crud is not empty');
+                this.logger.debug(`New data uploaded since write checkpoint ${opId} - need new write checkpoint`);
                 return false;
             }
             const rs = await tx.execute("SELECT seq FROM sqlite_sequence WHERE name = 'ps_crud'");
             if (!rs.rows?.length) {
                 // assert isNotEmpty
-                throw new Error('SQlite Sequence should not be empty');
+                throw new Error('SQLite Sequence should not be empty');
             }
             const seqAfter = rs.rows?.item(0)['seq'];
-            this.logger.debug('seqAfter', JSON.stringify(rs.rows?.item(0)));
             if (seqAfter != seqBefore) {
-                this.logger.debug('seqAfter != seqBefore', seqAfter, seqBefore);
+                this.logger.debug(`New data uploaded since write checpoint ${opId} - need new write checkpoint (sequence updated)`);
                 // New crud data may have been uploaded since we got the checkpoint. Abort.
                 return false;
             }
-            const response = await tx.execute("UPDATE ps_buckets SET target_op = CAST(? as INTEGER) WHERE name='$local'", [
-                opId
-            ]);
-            this.logger.debug(['[updateLocalTarget] Response from updating target_op ', JSON.stringify(response)]);
+            this.logger.debug(`Updating target write checkpoint to ${opId}`);
+            await tx.execute("UPDATE ps_buckets SET target_op = CAST(? as INTEGER) WHERE name='$local'", [opId]);
             return true;
         });
     }

package/lib/client/sync/stream/AbstractRemote.d.ts

@@ -3,7 +3,7 @@ import { type fetch } from 'cross-fetch';
 import Logger, { ILogger } from 'js-logger';
 import { DataStream } from '../../../utils/DataStream.js';
 import { PowerSyncCredentials } from '../../connection/PowerSyncCredentials.js';
-import { StreamingSyncLine, StreamingSyncRequest } from './streaming-sync-types.js';
+import { StreamingSyncRequest } from './streaming-sync-types.js';
 export type BSONImplementation = typeof BSON;
 export type RemoteConnector = {
     fetchCredentials: () => Promise<PowerSyncCredentials | null>;
@@ -120,11 +120,6 @@ export declare abstract class AbstractRemote {
      */
     abstract getBSON(): Promise<BSONImplementation>;
     protected createSocket(url: string): WebSocket;
-    /**
-     * Connects to the sync/stream websocket endpoint and delivers sync lines by decoding the BSON events
-     * sent by the server.
-     */
-    socketStream(options: SocketSyncStreamOptions): Promise<DataStream<StreamingSyncLine>>;
     /**
      * Returns a data stream of sync line data.
      *
@@ -133,10 +128,6 @@ export declare abstract class AbstractRemote {
      * (required for compatibility with older sync services).
      */
     socketStreamRaw<T>(options: SocketSyncStreamOptions, map: (buffer: Uint8Array) => T, bson?: typeof BSON): Promise<DataStream<T>>;
-    /**
-     * Connects to the sync/stream http endpoint, parsing lines as JSON.
-     */
-    postStream(options: SyncStreamOptions): Promise<DataStream<StreamingSyncLine>>;
     /**
      * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
      */

package/lib/client/sync/stream/AbstractRemote.js

@@ -178,14 +178,6 @@ export class AbstractRemote {
     createSocket(url) {
         return new WebSocket(url);
     }
-    /**
-     * Connects to the sync/stream websocket endpoint and delivers sync lines by decoding the BSON events
-     * sent by the server.
-     */
-    async socketStream(options) {
-        const bson = await this.getBSON();
-        return await this.socketStreamRaw(options, (data) => bson.deserialize(data), bson);
-    }
     /**
      * Returns a data stream of sync line data.
      *
@@ -363,14 +355,6 @@ export class AbstractRemote {
         }
         return stream;
     }
-    /**
-     * Connects to the sync/stream http endpoint, parsing lines as JSON.
-     */
-    async postStream(options) {
-        return await this.postStreamRaw(options, (line) => {
-            return JSON.parse(line);
-        });
-    }
     /**
      * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
      */

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.d.ts

@@ -166,7 +166,7 @@ export declare abstract class AbstractStreamingSyncImplementation extends BaseOb
     protected abortController: AbortController | null;
     protected crudUpdateListener?: () => void;
     protected streamingSyncPromise?: Promise<void>;
-    private pendingCrudUpload?;
+    private isUploadingCrud;
     private notifyCompletedUploads?;
     syncStatus: SyncStatus;
     triggerCrudUpload: () => void;

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.js

@@ -3,7 +3,7 @@ import { SyncStatus } from '../../../db/crud/SyncStatus.js';
 import { FULL_SYNC_PRIORITY } from '../../../db/crud/SyncProgress.js';
 import { AbortOperation } from '../../../utils/AbortOperation.js';
 import { BaseObserver } from '../../../utils/BaseObserver.js';
-import { onAbortPromise, throttleLeadingTrailing } from '../../../utils/async.js';
+import { throttleLeadingTrailing } from '../../../utils/async.js';
 import { PowerSyncControlCommand } from '../bucket/BucketStorageAdapter.js';
 import { SyncDataBucket } from '../bucket/SyncDataBucket.js';
 import { FetchStrategy } from './AbstractRemote.js';
@@ -85,7 +85,7 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     abortController;
     crudUpdateListener;
     streamingSyncPromise;
-    pendingCrudUpload;
+    isUploadingCrud = false;
     notifyCompletedUploads;
     syncStatus;
     triggerCrudUpload;
@@ -103,15 +103,13 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
         });
         this.abortController = null;
         this.triggerCrudUpload = throttleLeadingTrailing(() => {
-            if (!this.syncStatus.connected || this.pendingCrudUpload != null) {
+            if (!this.syncStatus.connected || this.isUploadingCrud) {
                 return;
             }
-            this.pendingCrudUpload = new Promise((resolve) => {
-                this._uploadAllCrud().finally(() => {
-                    this.notifyCompletedUploads?.();
-                    this.pendingCrudUpload = undefined;
-                    resolve();
-                });
+            this.isUploadingCrud = true;
+            this._uploadAllCrud().finally(() => {
+                this.notifyCompletedUploads?.();
+                this.isUploadingCrud = false;
             });
         }, this.options.crudUploadThrottleMs);
     }
@@ -169,11 +167,10 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     }
     async getWriteCheckpoint() {
         const clientId = await this.options.adapter.getClientId();
-        this.logger.debug(`Creating write checkpoint for ${clientId}`);
         let path = `/write-checkpoint2.json?client_id=${clientId}`;
         const response = await this.options.remote.get(path);
         const checkpoint = response['data']['write_checkpoint'];
-        this.logger.debug(`Got write checkpoint: ${checkpoint}`);
+        this.logger.debug(`Created write checkpoint: ${checkpoint}`);
         return checkpoint;
     }
     async _uploadAllCrud() {
@@ -213,10 +210,10 @@ The next upload iteration will be delayed.`);
                         }
                         else {
                             // Uploading is completed
-                            this.logger.debug('Upload complete, creating write checkpoint');
                             const neededUpdate = await this.options.adapter.updateLocalTarget(() => this.getWriteCheckpoint());
-                            if (neededUpdate == false) {
-                                this.logger.debug('No write checkpoint needed');
+                            if (neededUpdate == false && checkedCrudItem != null) {
+                                // Only log this if there was something to upload
+                                this.logger.debug('Upload complete, no write checkpoint needed.');
                             }
                             break;
                         }
@@ -368,6 +365,7 @@ The next upload iteration will be delayed.`);
                 });
             }
             finally {
+                this.notifyCompletedUploads = undefined;
                 if (!signal.aborted) {
                     nestedAbortController.abort(new AbortOperation('Closing sync stream network requests before retry.'));
                     nestedAbortController = new AbortController();
@@ -445,10 +443,9 @@ The next upload iteration will be delayed.`);
         this.logger.debug('Streaming sync iteration started');
         this.options.adapter.startSession();
         let [req, bucketMap] = await this.collectLocalBucketState();
-        // These are compared by reference
         let targetCheckpoint = null;
-        let validatedCheckpoint = null;
-        let appliedCheckpoint = null;
+        // A checkpoint that has been validated but not applied (e.g. due to pending local writes)
+        let pendingValidatedCheckpoint = null;
         const clientId = await this.options.adapter.getClientId();
         const usingFixedKeyFormat = await this.requireKeyFormat(false);
         this.logger.debug('Requesting stream from server');
@@ -465,21 +462,55 @@ The next upload iteration will be delayed.`);
         };
         let stream;
         if (resolvedOptions?.connectionMethod == SyncStreamConnectionMethod.HTTP) {
-            stream = await this.options.remote.postStream(syncOptions);
+            stream = await this.options.remote.postStreamRaw(syncOptions, (line) => {
+                if (typeof line == 'string') {
+                    return JSON.parse(line);
+                }
+                else {
+                    // Directly enqueued by us
+                    return line;
+                }
+            });
         }
         else {
-            stream = await this.options.remote.socketStream({
+            const bson = await this.options.remote.getBSON();
+            stream = await this.options.remote.socketStreamRaw({
                 ...syncOptions,
                 ...{ fetchStrategy: resolvedOptions.fetchStrategy }
-            });
+            }, (payload) => {
+                if (payload instanceof Uint8Array) {
+                    return bson.deserialize(payload);
+                }
+                else {
+                    // Directly enqueued by us
+                    return payload;
+                }
+            }, bson);
         }
         this.logger.debug('Stream established. Processing events');
+        this.notifyCompletedUploads = () => {
+            if (!stream.closed) {
+                stream.enqueueData({ crud_upload_completed: null });
+            }
+        };
         while (!stream.closed) {
             const line = await stream.read();
             if (!line) {
                 // The stream has closed while waiting
                 return;
             }
+            if ('crud_upload_completed' in line) {
+                if (pendingValidatedCheckpoint != null) {
+                    const { applied, endIteration } = await this.applyCheckpoint(pendingValidatedCheckpoint);
+                    if (applied) {
+                        pendingValidatedCheckpoint = null;
+                    }
+                    else if (endIteration) {
+                        break;
+                    }
+                }
+                continue;
+            }
             // A connection is active and messages are being received
             if (!this.syncStatus.connected) {
                 // There is a connection now
@@ -490,6 +521,8 @@ The next upload iteration will be delayed.`);
             }
             if (isStreamingSyncCheckpoint(line)) {
                 targetCheckpoint = line.checkpoint;
+                // New checkpoint - existing validated checkpoint is no longer valid
+                pendingValidatedCheckpoint = null;
                 const bucketsToDelete = new Set(bucketMap.keys());
                 const newBuckets = new Map();
                 for (const checksum of line.checkpoint.buckets) {
@@ -508,14 +541,20 @@ The next upload iteration will be delayed.`);
                 await this.updateSyncStatusForStartingCheckpoint(targetCheckpoint);
             }
             else if (isStreamingSyncCheckpointComplete(line)) {
-                const result = await this.applyCheckpoint(targetCheckpoint, signal);
+                const result = await this.applyCheckpoint(targetCheckpoint);
                 if (result.endIteration) {
                     return;
                 }
-                else if (result.applied) {
-                    appliedCheckpoint = targetCheckpoint;
+                else if (!result.applied) {
+                    // "Could not apply checkpoint due to local data". We need to retry after
+                    // finishing uploads.
+                    pendingValidatedCheckpoint = targetCheckpoint;
+                }
+                else {
+                    // Nothing to retry later. This would likely already be null from the last
+                    // checksum or checksum_diff operation, but we make sure.
+                    pendingValidatedCheckpoint = null;
                 }
-                validatedCheckpoint = targetCheckpoint;
             }
             else if (isStreamingSyncCheckpointPartiallyComplete(line)) {
                 const priority = line.partial_checkpoint_complete.priority;
@@ -552,6 +591,8 @@ The next upload iteration will be delayed.`);
                 if (targetCheckpoint == null) {
                     throw new Error('Checkpoint diff without previous checkpoint');
                 }
+                // New checkpoint - existing validated checkpoint is no longer valid
+                pendingValidatedCheckpoint = null;
                 const diff = line.checkpoint_diff;
                 const newBuckets = new Map();
                 for (const checksum of targetCheckpoint.buckets) {
@@ -625,26 +666,7 @@ The next upload iteration will be delayed.`);
                 this.triggerCrudUpload();
             }
             else {
-                this.logger.debug('Sync complete');
-                if (targetCheckpoint === appliedCheckpoint) {
-                    this.updateSyncStatus({
-                        connected: true,
-                        lastSyncedAt: new Date(),
-                        priorityStatusEntries: [],
-                        dataFlow: {
-                            downloadError: undefined
-                        }
-                    });
-                }
-                else if (validatedCheckpoint === targetCheckpoint) {
-                    const result = await this.applyCheckpoint(targetCheckpoint, signal);
-                    if (result.endIteration) {
-                        return;
-                    }
-                    else if (result.applied) {
-                        appliedCheckpoint = targetCheckpoint;
-                    }
-                }
+                this.logger.debug('Received unknown sync line', line);
             }
         }
         this.logger.debug('Stream input empty');
@@ -860,46 +882,30 @@ The next upload iteration will be delayed.`);
             }
         });
     }
-    async applyCheckpoint(checkpoint, abort) {
+    async applyCheckpoint(checkpoint) {
         let result = await this.options.adapter.syncLocalDatabase(checkpoint);
-        const pending = this.pendingCrudUpload;
         if (!result.checkpointValid) {
-            this.logger.debug('Checksum mismatch in checkpoint, will reconnect');
+            this.logger.debug(`Checksum mismatch in checkpoint ${checkpoint.last_op_id}, will reconnect`);
             // This means checksums failed. Start again with a new checkpoint.
             // TODO: better back-off
             await new Promise((resolve) => setTimeout(resolve, 50));
             return { applied: false, endIteration: true };
         }
-        else if (!result.ready && pending != null) {
-            // We have pending entries in the local upload queue or are waiting to confirm a write
-            // checkpoint, which prevented this checkpoint from applying. Wait for that to complete and
-            // try again.
-            this.logger.debug(`Could not apply checkpoint ${checkpoint.last_op_id} due to local data. Waiting for in-progress upload before retrying.`);
-            await Promise.race([pending, onAbortPromise(abort)]);
-            this.logger.debug(`Pending uploads complete, retrying local checkpoint at ${checkpoint.last_op_id}`);
-            if (abort.aborted) {
-                return { applied: false, endIteration: true };
-            }
-            // Try again now that uploads have completed.
-            result = await this.options.adapter.syncLocalDatabase(checkpoint);
-        }
-        if (result.checkpointValid && result.ready) {
-            this.logger.debug('validated checkpoint', checkpoint);
-            this.updateSyncStatus({
-                connected: true,
-                lastSyncedAt: new Date(),
-                dataFlow: {
-                    downloading: false,
-                    downloadProgress: null,
-                    downloadError: undefined
-                }
-            });
-            return { applied: true, endIteration: false };
-        }
-        else {
-            this.logger.debug('Could not apply checkpoint. Waiting for next sync complete line.');
+        else if (!result.ready) {
+            this.logger.debug(`Could not apply checkpoint ${checkpoint.last_op_id} due to local data. We will retry applying the checkpoint after that upload is completed.`);
             return { applied: false, endIteration: false };
         }
+        this.logger.debug(`Applied checkpoint ${checkpoint.last_op_id}`, checkpoint);
+        this.updateSyncStatus({
+            connected: true,
+            lastSyncedAt: new Date(),
+            dataFlow: {
+                downloading: false,
+                downloadProgress: null,
+                downloadError: undefined
+            }
+        });
+        return { applied: true, endIteration: false };
     }
     updateSyncStatus(options) {
         const updatedStatus = new SyncStatus({

package/lib/client/sync/stream/streaming-sync-types.d.ts

@@ -101,6 +101,10 @@ export interface StreamingSyncKeepalive {
     token_expires_in: number;
 }
 export type StreamingSyncLine = StreamingSyncDataJSON | StreamingSyncCheckpoint | StreamingSyncCheckpointDiff | StreamingSyncCheckpointComplete | StreamingSyncCheckpointPartiallyComplete | StreamingSyncKeepalive;
+export type CrudUploadNotification = {
+    crud_upload_completed: null;
+};
+export type StreamingSyncLineOrCrudUploadComplete = StreamingSyncLine | CrudUploadNotification;
 export interface BucketRequest {
     name: string;
     /**

package/lib/utils/async.d.ts

@@ -12,4 +12,3 @@ export declare function throttleTrailing(func: () => void, wait: number): () =>
  * Roughly equivalent to lodash/throttle with {leading: true, trailing: true}
  */
 export declare function throttleLeadingTrailing(func: () => void, wait: number): () => void;
-export declare function onAbortPromise(signal: AbortSignal): Promise<void>;

package/lib/utils/async.js

@@ -43,13 +43,3 @@ export function throttleLeadingTrailing(func, wait) {
         }
     };
 }
-export function onAbortPromise(signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted) {
-            resolve();
-        }
-        else {
-            signal.onabort = () => resolve();
-        }
-    });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "0.0.0-dev-20250710154318",
+  "version": "0.0.0-dev-20250714144421",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"