@powersync/web 1.38.2 → 1.38.4

package/dist/worker/SharedSyncImplementation.umd.js

@@ -1733,7 +1733,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   sanitizeUUID: () => (/* binding */ sanitizeUUID),
 /* harmony export */   timeoutSignal: () => (/* binding */ timeoutSignal)
 /* harmony export */ });
-// https://www.sqlite.org/lang_expr.html#castexpr
+/**
+ * @see https://www.sqlite.org/lang_expr.html#castexpr
+ * @public
+ */
 var ColumnType;
 (function (ColumnType) {
     ColumnType["TEXT"] = "TEXT";
@@ -1749,14 +1752,24 @@ const integer = {
 const real = {
     type: ColumnType.REAL
 };
-// powersync-sqlite-core limits the number of column per table to 1999, due to internal SQLite limits.
-// In earlier versions this was limited to 63.
+/**
+ * powersync-sqlite-core limits the number of column per table to 1999, due to internal SQLite limits.
+ * In earlier versions this was limited to 63.
+ *
+ * @internal
+ */
 const MAX_AMOUNT_OF_COLUMNS = 1999;
+/**
+ * @public
+ */
 const column = {
     text,
     integer,
     real
 };
+/**
+ * @public
+ */
 class Column {
     options;
     constructor(options) {
@@ -1776,9 +1789,15 @@ class Column {
     }
 }
 
+/**
+ * @internal
+ */
 const DEFAULT_INDEX_COLUMN_OPTIONS = {
     ascending: true
 };
+/**
+ * @public
+ */
 class IndexedColumn {
     options;
     static createAscending(column) {
@@ -1805,9 +1824,15 @@ class IndexedColumn {
     }
 }
 
+/**
+ * @internal
+ */
 const DEFAULT_INDEX_OPTIONS = {
     columns: []
 };
+/**
+ * @public
+ */
 class Index {
     options;
     static createAscending(options, columnNames) {
@@ -1849,6 +1874,9 @@ function encodeTableOptions(options) {
     };
 }
 
+/**
+ * @internal
+ */
 const DEFAULT_TABLE_OPTIONS = {
     indexes: [],
     insertOnly: false,
@@ -1857,7 +1885,13 @@ const DEFAULT_TABLE_OPTIONS = {
     trackMetadata: false,
     ignoreEmptyUpdates: false
 };
+/**
+ * @internal
+ */
 const InvalidSQLCharacters = /["'%,.#\s[\]]/;
+/**
+ * @public
+ */
 class Table {
     options;
     _mappedColumns;
@@ -2048,6 +2082,11 @@ class Table {
     }
 }
 
+/**
+ * The default name of the local table storing attachment data.
+ *
+ * @alpha
+ */
 const ATTACHMENT_TABLE = 'attachments';
 /**
  * Maps a database row to an AttachmentRecord.
@@ -2055,7 +2094,7 @@ const ATTACHMENT_TABLE = 'attachments';
  * @param row - The database row object
  * @returns The corresponding AttachmentRecord
  *
- * @experimental
+ * @alpha
  */
 function attachmentFromSql(row) {
     return {
@@ -2073,7 +2112,7 @@ function attachmentFromSql(row) {
 /**
  * AttachmentState represents the current synchronization state of an attachment.
  *
- * @experimental
+ * @alpha
  */
 var AttachmentState;
 (function (AttachmentState) {
@@ -2086,7 +2125,7 @@ var AttachmentState;
 /**
  * AttachmentTable defines the schema for the attachment queue table.
  *
- * @internal
+ * @alpha
  */
 class AttachmentTable extends Table {
     constructor(options) {
@@ -2114,7 +2153,8 @@ class AttachmentTable extends Table {
  * Provides methods to query, insert, update, and delete attachment records with
  * proper transaction management through PowerSync.
  *
- * @internal
+ * @experimental
+ * @alpha
  */
 class AttachmentContext {
     /** PowerSync database instance for executing queries */
@@ -2336,6 +2376,9 @@ class AttachmentContext {
     }
 }
 
+/**
+ * @public
+ */
 var WatchedQueryListenerEvent;
 (function (WatchedQueryListenerEvent) {
     WatchedQueryListenerEvent["ON_DATA"] = "onData";
@@ -2344,176 +2387,18 @@ var WatchedQueryListenerEvent;
     WatchedQueryListenerEvent["SETTINGS_WILL_UPDATE"] = "settingsWillUpdate";
     WatchedQueryListenerEvent["CLOSED"] = "closed";
 })(WatchedQueryListenerEvent || (WatchedQueryListenerEvent = {}));
+/**
+ * @internal
+ */
 const DEFAULT_WATCH_THROTTLE_MS = 30;
+/**
+ * @internal
+ */
 const DEFAULT_WATCH_QUERY_OPTIONS = {
     throttleMs: DEFAULT_WATCH_THROTTLE_MS,
     reportFetching: true
 };
 
-/**
- * Orchestrates attachment synchronization between local and remote storage.
- * Handles uploads, downloads, deletions, and state transitions.
- *
- * @internal
- */
-class SyncingService {
-    attachmentService;
-    localStorage;
-    remoteStorage;
-    logger;
-    errorHandler;
-    constructor(attachmentService, localStorage, remoteStorage, logger, errorHandler) {
-        this.attachmentService = attachmentService;
-        this.localStorage = localStorage;
-        this.remoteStorage = remoteStorage;
-        this.logger = logger;
-        this.errorHandler = errorHandler;
-    }
-    /**
-     * Processes attachments based on their state (upload, download, or delete).
-     * All updates are saved in a single batch after processing.
-     *
-     * @param attachments - Array of attachment records to process
-     * @param context - Attachment context for database operations
-     * @returns Promise that resolves when all attachments have been processed and saved
-     */
-    async processAttachments(attachments, context) {
-        const updatedAttachments = [];
-        for (const attachment of attachments) {
-            switch (attachment.state) {
-                case AttachmentState.QUEUED_UPLOAD:
-                    const uploaded = await this.uploadAttachment(attachment);
-                    updatedAttachments.push(uploaded);
-                    break;
-                case AttachmentState.QUEUED_DOWNLOAD:
-                    const downloaded = await this.downloadAttachment(attachment);
-                    updatedAttachments.push(downloaded);
-                    break;
-                case AttachmentState.QUEUED_DELETE:
-                    const deleted = await this.deleteAttachment(attachment, context);
-                    updatedAttachments.push(deleted);
-                    break;
-            }
-        }
-        await context.saveAttachments(updatedAttachments);
-    }
-    /**
-     * Uploads an attachment from local storage to remote storage.
-     * On success, marks as SYNCED. On failure, defers to error handler or archives.
-     *
-     * @param attachment - The attachment record to upload
-     * @returns Updated attachment record with new state
-     * @throws Error if the attachment has no localUri
-     */
-    async uploadAttachment(attachment) {
-        this.logger.info(`Uploading attachment ${attachment.filename}`);
-        try {
-            if (attachment.localUri == null) {
-                throw new Error(`No localUri for attachment ${attachment.id}`);
-            }
-            const fileBlob = await this.localStorage.readFile(attachment.localUri);
-            await this.remoteStorage.uploadFile(fileBlob, attachment);
-            return {
-                ...attachment,
-                state: AttachmentState.SYNCED,
-                hasSynced: true
-            };
-        }
-        catch (error) {
-            const shouldRetry = (await this.errorHandler?.onUploadError(attachment, error)) ?? true;
-            if (!shouldRetry) {
-                return {
-                    ...attachment,
-                    state: AttachmentState.ARCHIVED
-                };
-            }
-            return attachment;
-        }
-    }
-    /**
-     * Downloads an attachment from remote storage to local storage.
-     * Retrieves the file, converts to base64, and saves locally.
-     * On success, marks as SYNCED. On failure, defers to error handler or archives.
-     *
-     * @param attachment - The attachment record to download
-     * @returns Updated attachment record with local URI and new state
-     */
-    async downloadAttachment(attachment) {
-        this.logger.info(`Downloading attachment ${attachment.filename}`);
-        try {
-            const fileData = await this.remoteStorage.downloadFile(attachment);
-            const localUri = this.localStorage.getLocalUri(attachment.filename);
-            await this.localStorage.saveFile(localUri, fileData);
-            return {
-                ...attachment,
-                state: AttachmentState.SYNCED,
-                localUri: localUri,
-                hasSynced: true
-            };
-        }
-        catch (error) {
-            const shouldRetry = (await this.errorHandler?.onDownloadError(attachment, error)) ?? true;
-            if (!shouldRetry) {
-                return {
-                    ...attachment,
-                    state: AttachmentState.ARCHIVED
-                };
-            }
-            return attachment;
-        }
-    }
-    /**
-     * Deletes an attachment from both remote and local storage.
-     * Removes the remote file, local file (if exists), and the attachment record.
-     * On failure, defers to error handler or archives.
-     *
-     * @param attachment - The attachment record to delete
-     * @param context - Attachment context for database operations
-     * @returns Updated attachment record
-     */
-    async deleteAttachment(attachment, context) {
-        try {
-            await this.remoteStorage.deleteFile(attachment);
-            if (attachment.localUri) {
-                await this.localStorage.deleteFile(attachment.localUri);
-            }
-            await context.deleteAttachment(attachment.id);
-            return {
-                ...attachment,
-                state: AttachmentState.ARCHIVED
-            };
-        }
-        catch (error) {
-            const shouldRetry = (await this.errorHandler?.onDeleteError(attachment, error)) ?? true;
-            if (!shouldRetry) {
-                return {
-                    ...attachment,
-                    state: AttachmentState.ARCHIVED
-                };
-            }
-            return attachment;
-        }
-    }
-    /**
-     * Performs cleanup of archived attachments by removing their local files and records.
-     * Errors during local file deletion are logged but do not prevent record deletion.
-     */
-    async deleteArchivedAttachments(context) {
-        return await context.deleteArchivedAttachments(async (archivedAttachments) => {
-            for (const attachment of archivedAttachments) {
-                if (attachment.localUri) {
-                    try {
-                        await this.localStorage.deleteFile(attachment.localUri);
-                    }
-                    catch (error) {
-                        this.logger.error('Error deleting local file for archived attachment', error);
-                    }
-                }
-            }
-        });
-    }
-}
-
 /**
  * A simple fixed-capacity queue implementation.
  *
@@ -2699,6 +2584,9 @@ class Mutex {
         }
     }
 }
+/**
+ * @internal
+ */
 function timeoutSignal(timeout) {
     if (timeout == null)
         return;
@@ -2761,6 +2649,170 @@ class AttachmentService {
     }
 }
 
+/**
+ * Orchestrates attachment synchronization between local and remote storage.
+ * Handles uploads, downloads, deletions, and state transitions.
+ *
+ * @internal
+ */
+class SyncingService {
+    attachmentService;
+    localStorage;
+    remoteStorage;
+    logger;
+    errorHandler;
+    constructor(attachmentService, localStorage, remoteStorage, logger, errorHandler) {
+        this.attachmentService = attachmentService;
+        this.localStorage = localStorage;
+        this.remoteStorage = remoteStorage;
+        this.logger = logger;
+        this.errorHandler = errorHandler;
+    }
+    /**
+     * Processes attachments based on their state (upload, download, or delete).
+     * All updates are saved in a single batch after processing.
+     *
+     * @param attachments - Array of attachment records to process
+     * @param context - Attachment context for database operations
+     * @returns Promise that resolves when all attachments have been processed and saved
+     */
+    async processAttachments(attachments, context) {
+        const updatedAttachments = [];
+        for (const attachment of attachments) {
+            switch (attachment.state) {
+                case AttachmentState.QUEUED_UPLOAD:
+                    const uploaded = await this.uploadAttachment(attachment);
+                    updatedAttachments.push(uploaded);
+                    break;
+                case AttachmentState.QUEUED_DOWNLOAD:
+                    const downloaded = await this.downloadAttachment(attachment);
+                    updatedAttachments.push(downloaded);
+                    break;
+                case AttachmentState.QUEUED_DELETE:
+                    const deleted = await this.deleteAttachment(attachment, context);
+                    updatedAttachments.push(deleted);
+                    break;
+            }
+        }
+        await context.saveAttachments(updatedAttachments);
+    }
+    /**
+     * Uploads an attachment from local storage to remote storage.
+     * On success, marks as SYNCED. On failure, defers to error handler or archives.
+     *
+     * @param attachment - The attachment record to upload
+     * @returns Updated attachment record with new state
+     * @throws Error if the attachment has no localUri
+     */
+    async uploadAttachment(attachment) {
+        this.logger.info(`Uploading attachment ${attachment.filename}`);
+        try {
+            if (attachment.localUri == null) {
+                throw new Error(`No localUri for attachment ${attachment.id}`);
+            }
+            const fileBlob = await this.localStorage.readFile(attachment.localUri);
+            await this.remoteStorage.uploadFile(fileBlob, attachment);
+            return {
+                ...attachment,
+                state: AttachmentState.SYNCED,
+                hasSynced: true
+            };
+        }
+        catch (error) {
+            const shouldRetry = (await this.errorHandler?.onUploadError(attachment, error)) ?? true;
+            if (!shouldRetry) {
+                return {
+                    ...attachment,
+                    state: AttachmentState.ARCHIVED
+                };
+            }
+            return attachment;
+        }
+    }
+    /**
+     * Downloads an attachment from remote storage to local storage.
+     * Retrieves the file, converts to base64, and saves locally.
+     * On success, marks as SYNCED. On failure, defers to error handler or archives.
+     *
+     * @param attachment - The attachment record to download
+     * @returns Updated attachment record with local URI and new state
+     */
+    async downloadAttachment(attachment) {
+        this.logger.info(`Downloading attachment ${attachment.filename}`);
+        try {
+            const fileData = await this.remoteStorage.downloadFile(attachment);
+            const localUri = this.localStorage.getLocalUri(attachment.filename);
+            await this.localStorage.saveFile(localUri, fileData);
+            return {
+                ...attachment,
+                state: AttachmentState.SYNCED,
+                localUri: localUri,
+                hasSynced: true
+            };
+        }
+        catch (error) {
+            const shouldRetry = (await this.errorHandler?.onDownloadError(attachment, error)) ?? true;
+            if (!shouldRetry) {
+                return {
+                    ...attachment,
+                    state: AttachmentState.ARCHIVED
+                };
+            }
+            return attachment;
+        }
+    }
+    /**
+     * Deletes an attachment from both remote and local storage.
+     * Removes the remote file, local file (if exists), and the attachment record.
+     * On failure, defers to error handler or archives.
+     *
+     * @param attachment - The attachment record to delete
+     * @param context - Attachment context for database operations
+     * @returns Updated attachment record
+     */
+    async deleteAttachment(attachment, context) {
+        try {
+            await this.remoteStorage.deleteFile(attachment);
+            if (attachment.localUri) {
+                await this.localStorage.deleteFile(attachment.localUri);
+            }
+            await context.deleteAttachment(attachment.id);
+            return {
+                ...attachment,
+                state: AttachmentState.ARCHIVED
+            };
+        }
+        catch (error) {
+            const shouldRetry = (await this.errorHandler?.onDeleteError(attachment, error)) ?? true;
+            if (!shouldRetry) {
+                return {
+                    ...attachment,
+                    state: AttachmentState.ARCHIVED
+                };
+            }
+            return attachment;
+        }
+    }
+    /**
+     * Performs cleanup of archived attachments by removing their local files and records.
+     * Errors during local file deletion are logged but do not prevent record deletion.
+     */
+    async deleteArchivedAttachments(context) {
+        return await context.deleteArchivedAttachments(async (archivedAttachments) => {
+            for (const attachment of archivedAttachments) {
+                if (attachment.localUri) {
+                    try {
+                        await this.localStorage.deleteFile(attachment.localUri);
+                    }
+                    catch (error) {
+                        this.logger.error('Error deleting local file for archived attachment', error);
+                    }
+                }
+            }
+        });
+    }
+}
+
 /**
  * AttachmentQueue manages the lifecycle and synchronization of attachments
  * between local and remote storage.
@@ -2817,16 +2869,6 @@ class AttachmentQueue {
      * Creates a new AttachmentQueue instance.
      *
      * @param options - Configuration options
-     * @param options.db - PowerSync database instance
-     * @param options.remoteStorage - Remote storage adapter for upload/download operations
-     * @param options.localStorage - Local storage adapter for file persistence
-     * @param options.watchAttachments - Callback for monitoring attachment changes in your data model
-     * @param options.tableName - Name of the table to store attachment records. Default: 'ps_attachment_queue'
-     * @param options.logger - Logger instance. Defaults to db.logger
-     * @param options.syncIntervalMs - Periodic polling interval in milliseconds for retrying failed uploads/downloads. Default: 30000
-     * @param options.syncThrottleDuration - Throttle duration in milliseconds for the reactive watch query that detects attachment changes. Prevents rapid-fire syncs during bulk changes. Default: 30
-     * @param options.downloadAttachments - Whether to automatically download remote attachments. Default: true
-     * @param options.archivedCacheLimit - Maximum archived attachments before cleanup. Default: 100
      */
     constructor({ db, localStorage, remoteStorage, watchAttachments, logger, tableName = ATTACHMENT_TABLE, syncIntervalMs = 30 * 1000, syncThrottleDuration = DEFAULT_WATCH_THROTTLE_MS, downloadAttachments = true, archivedCacheLimit = 100, errorHandler }) {
         this.db = db;
@@ -2915,6 +2957,7 @@ class AttachmentQueue {
                             state: AttachmentState.QUEUED_DOWNLOAD,
                             hasSynced: false,
                             metaData: watchedAttachment.metaData,
+                            mediaType: watchedAttachment.mediaType,
                             timestamp: new Date().getTime()
                         });
                         continue;
@@ -3002,17 +3045,24 @@ class AttachmentQueue {
             this.statusListenerDispose = undefined;
         }
     }
+    /**
+     * Provides an {@link AttachmentContext} to a callback.
+     *
+     * The callback runs while the attachment queue mutex is held. Do not call
+     * other {@link AttachmentQueue} methods from within the callback, as they may
+     * attempt to acquire the same mutex and block indefinitely.
+     */
+    withAttachmentContext(callback) {
+        /**
+         * AttachmentService is internal and private in this class.
+         * We only need to expose its locking and context functionality for extending classes.
+         */
+        return this.attachmentService.withContext(callback);
+    }
     /**
      * Saves a file to local storage and queues it for upload to remote storage.
      *
      * @param options - File save options
-     * @param options.data - The file data as ArrayBuffer, Blob, or base64 string
-     * @param options.fileExtension - File extension (e.g., 'jpg', 'pdf')
-     * @param options.mediaType - MIME type of the file (e.g., 'image/jpeg')
-     * @param options.metaData - Optional metadata to associate with the attachment
-     * @param options.id - Optional custom ID. If not provided, a UUID will be generated
-     * @param options.updateHook - Optional callback to execute additional database operations
-     *                             within the same transaction as the attachment creation
      * @returns Promise resolving to the created attachment record
      */
     async saveFile({ data, fileExtension, mediaType, metaData, id, updateHook }) {
@@ -3125,171 +3175,19 @@ class AttachmentQueue {
     }
 }
 
+/**
+ * @alpha
+ */
 var EncodingType;
 (function (EncodingType) {
     EncodingType["UTF8"] = "utf8";
     EncodingType["Base64"] = "base64";
 })(EncodingType || (EncodingType = {}));
 
-const symbolAsyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var dom = {};
-
-var eventIterator = {};
-
-var hasRequiredEventIterator;
-
-function requireEventIterator () {
-	if (hasRequiredEventIterator) return eventIterator;
-	hasRequiredEventIterator = 1;
-	Object.defineProperty(eventIterator, "__esModule", { value: true });
-	class EventQueue {
-	    constructor() {
-	        this.pullQueue = [];
-	        this.pushQueue = [];
-	        this.eventHandlers = {};
-	        this.isPaused = false;
-	        this.isStopped = false;
-	    }
-	    push(value) {
-	        if (this.isStopped)
-	            return;
-	        const resolution = { value, done: false };
-	        if (this.pullQueue.length) {
-	            const placeholder = this.pullQueue.shift();
-	            if (placeholder)
-	                placeholder.resolve(resolution);
-	        }
-	        else {
-	            this.pushQueue.push(Promise.resolve(resolution));
-	            if (this.highWaterMark !== undefined &&
-	                this.pushQueue.length >= this.highWaterMark &&
-	                !this.isPaused) {
-	                this.isPaused = true;
-	                if (this.eventHandlers.highWater) {
-	                    this.eventHandlers.highWater();
-	                }
-	                else if (console) {
-	                    console.warn(`EventIterator queue reached ${this.pushQueue.length} items`);
-	                }
-	            }
-	        }
-	    }
-	    stop() {
-	        if (this.isStopped)
-	            return;
-	        this.isStopped = true;
-	        this.remove();
-	        for (const placeholder of this.pullQueue) {
-	            placeholder.resolve({ value: undefined, done: true });
-	        }
-	        this.pullQueue.length = 0;
-	    }
-	    fail(error) {
-	        if (this.isStopped)
-	            return;
-	        this.isStopped = true;
-	        this.remove();
-	        if (this.pullQueue.length) {
-	            for (const placeholder of this.pullQueue) {
-	                placeholder.reject(error);
-	            }
-	            this.pullQueue.length = 0;
-	        }
-	        else {
-	            const rejection = Promise.reject(error);
-	            /* Attach error handler to avoid leaking an unhandled promise rejection. */
-	            rejection.catch(() => { });
-	            this.pushQueue.push(rejection);
-	        }
-	    }
-	    remove() {
-	        Promise.resolve().then(() => {
-	            if (this.removeCallback)
-	                this.removeCallback();
-	        });
-	    }
-	    [symbolAsyncIterator]() {
-	        return {
-	            next: (value) => {
-	                const result = this.pushQueue.shift();
-	                if (result) {
-	                    if (this.lowWaterMark !== undefined &&
-	                        this.pushQueue.length <= this.lowWaterMark &&
-	                        this.isPaused) {
-	                        this.isPaused = false;
-	                        if (this.eventHandlers.lowWater) {
-	                            this.eventHandlers.lowWater();
-	                        }
-	                    }
-	                    return result;
-	                }
-	                else if (this.isStopped) {
-	                    return Promise.resolve({ value: undefined, done: true });
-	                }
-	                else {
-	                    return new Promise((resolve, reject) => {
-	                        this.pullQueue.push({ resolve, reject });
-	                    });
-	                }
-	            },
-	            return: () => {
-	                this.isStopped = true;
-	                this.pushQueue.length = 0;
-	                this.remove();
-	                return Promise.resolve({ value: undefined, done: true });
-	            },
-	        };
-	    }
-	}
-	class EventIterator {
-	    constructor(listen, { highWaterMark = 100, lowWaterMark = 1 } = {}) {
-	        const queue = new EventQueue();
-	        queue.highWaterMark = highWaterMark;
-	        queue.lowWaterMark = lowWaterMark;
-	        queue.removeCallback =
-	            listen({
-	                push: value => queue.push(value),
-	                stop: () => queue.stop(),
-	                fail: error => queue.fail(error),
-	                on: (event, fn) => {
-	                    queue.eventHandlers[event] = fn;
-	                },
-	            }) || (() => { });
-	        this[symbolAsyncIterator] = () => queue[symbolAsyncIterator]();
-	        Object.freeze(this);
-	    }
-	}
-	eventIterator.EventIterator = EventIterator;
-	eventIterator.default = EventIterator;
-	return eventIterator;
-}
-
-var hasRequiredDom;
-
-function requireDom () {
-	if (hasRequiredDom) return dom;
-	hasRequiredDom = 1;
-	Object.defineProperty(dom, "__esModule", { value: true });
-	const event_iterator_1 = requireEventIterator();
-	dom.EventIterator = event_iterator_1.EventIterator;
-	function subscribe(event, options, evOptions) {
-	    return new event_iterator_1.EventIterator(({ push }) => {
-	        this.addEventListener(event, push, options);
-	        return () => this.removeEventListener(event, push, options);
-	    }, evOptions);
-	}
-	dom.subscribe = subscribe;
-	dom.default = event_iterator_1.EventIterator;
-	return dom;
-}
-
-var domExports = requireDom();
-
 var logger$1 = {exports: {}};
 
 /*!
@@ -3588,7 +3486,9 @@ var Logger = /*@__PURE__*/getDefaultExportFromCjs(loggerExports);
  * different SQLite DB implementations.
  */
 /**
- * Implements {@link DBGetUtils} on a {@link SqlRunner}.
+ * Implements {@link DBGetUtils} on a {@link SqlExecutor}.
+ *
+ * @internal
  */
 function DBGetUtilsDefaultMixin(Base) {
     return class extends Base {
@@ -3632,6 +3532,8 @@ function DBGetUtilsDefaultMixin(Base) {
 }
 /**
  * Update table operation numbers from SQLite
+ *
+ * @public
  */
 var RowUpdateType;
 (function (RowUpdateType) {
@@ -3640,8 +3542,10 @@ var RowUpdateType;
     RowUpdateType[RowUpdateType["SQLITE_UPDATE"] = 23] = "SQLITE_UPDATE";
 })(RowUpdateType || (RowUpdateType = {}));
 /**
- * A mixin to implement {@link DBAdapter} by delegating to {@link ConnectionPool.readLock} and
- * {@link ConnectionPool.writeLock}.
+ * A mixin to implement {@link DBAdapter} by delegating to {@link ConnectionPool#readLock} and
+ * {@link ConnectionPool#writeLock}.
+ *
+ * @internal
  */
 function DBAdapterDefaultMixin(Base) {
     return class extends Base {
@@ -3729,9 +3633,15 @@ class TransactionImplementation extends DBGetUtilsDefaultMixin(BaseTransaction)
         }
     }
 }
+/**
+ * @internal
+ */
 function isBatchedUpdateNotification(update) {
     return 'tables' in update;
 }
+/**
+ * @internal
+ */
 function extractTableUpdates(update) {
     return isBatchedUpdateNotification(update) ? update.tables : [update.table];
 }
@@ -3759,6 +3669,8 @@ const FULL_SYNC_PRIORITY = 2147483647;
  *
  * Also note that data is downloaded in bulk, which means that individual counters are unlikely
  * to be updated one-by-one.
+ *
+ * @public
  */
 class SyncProgress {
     internal;
@@ -3797,6 +3709,9 @@ class SyncProgress {
     }
 }
 
+/**
+ * @public
+ */
 class SyncStatus {
     options;
     constructor(options) {
@@ -3807,6 +3722,8 @@ class SyncStatus {
      * implementation).
      *
      * This information is only available after a connection has been requested.
+     *
+     * @deprecated This always returns the Rust client (the only option).
      */
     get clientImplementation() {
         return this.options.clientImplementation;
@@ -3814,7 +3731,7 @@ class SyncStatus {
     /**
      * Indicates if the client is currently connected to the PowerSync service.
      *
-     * @returns {boolean} True if connected, false otherwise. Defaults to false if not specified.
+     * @returns True if connected, false otherwise. Defaults to false if not specified.
      */
     get connected() {
         return this.options.connected ?? false;
@@ -3822,7 +3739,7 @@ class SyncStatus {
     /**
      * Indicates if the client is in the process of establishing a connection to the PowerSync service.
      *
-     * @returns {boolean} True if connecting, false otherwise. Defaults to false if not specified.
+     * @returns True if connecting, false otherwise. Defaults to false if not specified.
      */
     get connecting() {
         return this.options.connecting ?? false;
@@ -3831,7 +3748,7 @@ class SyncStatus {
      * Time that a last sync has fully completed, if any.
      * This timestamp is reset to null after a restart of the PowerSync service.
      *
-     * @returns {Date | undefined} The timestamp of the last successful sync, or undefined if no sync has completed.
+     * @returns The timestamp of the last successful sync, or undefined if no sync has completed.
      */
     get lastSyncedAt() {
         return this.options.lastSyncedAt;
@@ -3839,7 +3756,7 @@ class SyncStatus {
     /**
      * Indicates whether there has been at least one full sync completed since initialization.
      *
-     * @returns {boolean | undefined} True if at least one sync has completed, false if no sync has completed,
+     * @returns True if at least one sync has completed, false if no sync has completed,
      * or undefined when the state is still being loaded from the database.
      */
     get hasSynced() {
@@ -3848,10 +3765,10 @@ class SyncStatus {
     /**
      * Provides the current data flow status regarding uploads and downloads.
      *
-     * @returns {SyncDataFlowStatus} An object containing:
+     * @returns An object containing:
      * - downloading: True if actively downloading changes (only when connected is also true)
      * - uploading: True if actively uploading changes
-     * Defaults to {downloading: false, uploading: false} if not specified.
+     * Defaults to `{downloading: false, uploading: false}` if not specified.
      */
     get dataFlowStatus() {
         return (this.options.dataFlow ?? {
@@ -3876,7 +3793,7 @@ class SyncStatus {
         return this.options.dataFlow?.internalStreamSubscriptions?.map((core) => new SyncStreamStatusView(this, core));
     }
     /**
-     * If the `stream` appears in {@link syncStreams}, returns the current status for that stream.
+     * If the `stream` appears in {@link SyncStatus.syncStreams}, returns the current status for that stream.
      */
     forStream(stream) {
         const asJson = JSON.stringify(stream.parameters);
@@ -3886,7 +3803,7 @@ class SyncStatus {
     /**
      * Provides sync status information for all bucket priorities, sorted by priority (highest first).
      *
-     * @returns {SyncPriorityStatus[]} An array of status entries for different sync priority levels,
+     * @returns An array of status entries for different sync priority levels,
      * sorted with highest priorities (lower numbers) first.
      */
     get priorityStatusEntries() {
@@ -3921,8 +3838,8 @@ class SyncStatus {
      * For example, if PowerSync just finished synchronizing buckets in priority level 3, calling this method
      * with a priority of 1 may return information for priority level 3.
      *
-     * @param {number} priority The bucket priority for which the status should be reported
-     * @returns {SyncPriorityStatus} Status information for the requested priority level or the next higher level with available status
+     * @param priority - The bucket priority for which the status should be reported
+     * @returns Status information for the requested priority level or the next higher level with available status
      */
     statusForPriority(priority) {
         // priorityStatusEntries are sorted by ascending priorities (so higher numbers to lower numbers).
@@ -3943,8 +3860,8 @@ class SyncStatus {
      * Compares this SyncStatus instance with another to determine if they are equal.
      * Equality is determined by comparing the serialized JSON representation of both instances.
      *
-     * @param {SyncStatus} status The SyncStatus instance to compare against
-     * @returns {boolean} True if the instances are considered equal, false otherwise
+     * @param status - The SyncStatus instance to compare against
+     * @returns True if the instances are considered equal, false otherwise
      */
     isEqual(status) {
         /**
@@ -3967,7 +3884,7 @@ class SyncStatus {
      * Creates a human-readable string representation of the current sync status.
      * Includes information about connection state, sync completion, and data flow.
      *
-     * @returns {string} A string representation of the sync status
+     * @returns A string representation of the sync status
      */
     getMessage() {
         const dataFlow = this.dataFlowStatus;
@@ -3976,7 +3893,7 @@ class SyncStatus {
     /**
      * Serializes the SyncStatus instance to a plain object.
      *
-     * @returns {SyncStatusOptions} A plain object representation of the sync status
+     * @returns A plain object representation of the sync status
      */
     toJSON() {
         return {
@@ -4042,6 +3959,9 @@ class SyncStreamStatusView {
     }
 }
 
+/**
+ * @public
+ */
 class UploadQueueStats {
     count;
     size;
@@ -4067,6 +3987,9 @@ class UploadQueueStats {
     }
 }
 
+/**
+ * @internal
+ */
 class BaseObserver {
     listeners = new Set();
     constructor() { }
@@ -4094,6 +4017,9 @@ class BaseObserver {
     }
 }
 
+/**
+ * @internal
+ */
 class ControlledExecutor {
     task;
     /**
@@ -4145,6 +4071,210 @@ class ControlledExecutor {
     }
 }
 
+/**
+ * Some JavaScript engines, in particular older versions of React Native, don't support Symbol.asyncIterator.
+ *
+ * For those, users relying on async generators typically lower them with a transpiler and [this polyfill](https://github.com/Azure/azure-sdk-for-js/blob/%40azure/core-asynciterator-polyfill_1.0.2/sdk/core/core-asynciterator-polyfill/src/index.ts#L4-L6).
+ * This definition is compatible with that polyfill, so transpiled apps can use async iterables created by the PowerSync
+ * SDK.
+ */
+const symbolAsyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
+
+const doneResult = { done: true, value: undefined };
+function valueResult(value) {
+    return { done: false, value };
+}
+/**
+ * Expands a source async iterator by allowing to inject events asynchronously.
+ *
+ * The resulting iterator will emit all events from its source. Additionally though, events can be injected. These
+ * events are dropped once the main iterator completes, but are otherwise forwarded.
+ *
+ * The iterator completes when its source completes, and it supports backpressure by only calling `next()` on the source
+ * in response to a `next()` call from downstream if no pending injected events can be dispatched.
+ */
+function injectable(source) {
+    let sourceIsDone = false;
+    let waiter = undefined; // An active, waiting next() call.
+    // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
+    let pendingSourceEvent = null;
+    let sourceFetchInFlight = false;
+    let pendingInjectedEvents = [];
+    const consumeWaiter = () => {
+        const pending = waiter;
+        waiter = undefined;
+        return pending;
+    };
+    const fetchFromSource = () => {
+        const resolveWaiter = (propagate) => {
+            sourceFetchInFlight = false;
+            const active = consumeWaiter();
+            if (active) {
+                propagate(active);
+            }
+            else {
+                pendingSourceEvent = propagate;
+            }
+        };
+        sourceFetchInFlight = true;
+        const nextFromSource = source.next();
+        nextFromSource.then((value) => {
+            sourceIsDone = value.done == true;
+            resolveWaiter((w) => w.resolve(value));
+        }, (error) => {
+            resolveWaiter((w) => w.reject(error));
+        });
+    };
+    return {
+        next: () => {
+            return new Promise((resolve, reject) => {
+                // First priority: Dispatch ready upstream events.
+                if (sourceIsDone) {
+                    return resolve(doneResult);
+                }
+                if (pendingSourceEvent) {
+                    pendingSourceEvent({ resolve, reject });
+                    pendingSourceEvent = null;
+                    return;
+                }
+                // Second priority: Dispatch injected events
+                if (pendingInjectedEvents.length) {
+                    return resolve(valueResult(pendingInjectedEvents.shift()));
+                }
+                // Nothing pending? Fetch from source
+                waiter = { resolve, reject };
+                if (!sourceFetchInFlight) {
+                    fetchFromSource();
+                }
+            });
+        },
+        inject: (event) => {
+            const pending = consumeWaiter();
+            if (pending != null) {
+                pending.resolve(valueResult(event));
+            }
+            else {
+                pendingInjectedEvents.push(event);
+            }
+        }
+    };
+}
+/**
+ * Splits a byte stream at line endings, emitting each line as a string.
+ */
+function extractJsonLines(source, decoder) {
+    let buffer = '';
+    const pendingLines = [];
+    let isFinalEvent = false;
+    return {
+        next: async () => {
+            while (true) {
+                if (isFinalEvent) {
+                    return doneResult;
+                }
+                {
+                    const first = pendingLines.shift();
+                    if (first) {
+                        return { done: false, value: first };
+                    }
+                }
+                const { done, value } = await source.next();
+                if (done) {
+                    const remaining = buffer.trim();
+                    if (remaining.length != 0) {
+                        isFinalEvent = true;
+                        return { done: false, value: remaining };
+                    }
+                    return doneResult;
+                }
+                const data = decoder.decode(value, { stream: true });
+                buffer += data;
+                const lines = buffer.split('\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const l = lines[i].trim();
+                    if (l.length > 0) {
+                        pendingLines.push(l);
+                    }
+                }
+                buffer = lines[lines.length - 1];
+            }
+        }
+    };
+}
+/**
+ * Splits a concatenated stream of BSON objects by emitting individual objects.
+ */
+function extractBsonObjects(source) {
+    // Fully read but not emitted yet.
+    const completedObjects = [];
+    // Whether source has returned { done: true }. We do the same once completed objects have been emitted.
+    let isDone = false;
+    const lengthBuffer = new DataView(new ArrayBuffer(4));
+    let objectBody = null;
+    // If we're parsing the length field, a number between 1 and 4 (inclusive) describing remaining bytes in the header.
+    // If we're consuming a document, the bytes remaining.
+    let remainingLength = 4;
+    return {
+        async next() {
+            while (true) {
+                // Before fetching new data from upstream, return completed objects.
+                if (completedObjects.length) {
+                    return valueResult(completedObjects.shift());
+                }
+                if (isDone) {
+                    return doneResult;
+                }
+                const upstreamEvent = await source.next();
+                if (upstreamEvent.done) {
+                    isDone = true;
+                    if (objectBody || remainingLength != 4) {
+                        throw new Error('illegal end of stream in BSON object');
+                    }
+                    return doneResult;
+                }
+                const chunk = upstreamEvent.value;
+                for (let i = 0; i < chunk.length;) {
+                    const availableInData = chunk.length - i;
+                    if (objectBody) {
+                        // We're in the middle of reading a BSON document.
+                        const bytesToRead = Math.min(availableInData, remainingLength);
+                        const copySource = new Uint8Array(chunk.buffer, chunk.byteOffset + i, bytesToRead);
+                        objectBody.set(copySource, objectBody.length - remainingLength);
+                        i += bytesToRead;
+                        remainingLength -= bytesToRead;
+                        if (remainingLength == 0) {
+                            completedObjects.push(objectBody);
+                            // Prepare to read another document, starting with its length
+                            objectBody = null;
+                            remainingLength = 4;
+                        }
+                    }
+                    else {
+                        // Copy up to 4 bytes into lengthBuffer, depending on how many we still need.
+                        const bytesToRead = Math.min(availableInData, remainingLength);
+                        for (let j = 0; j < bytesToRead; j++) {
+                            lengthBuffer.setUint8(4 - remainingLength + j, chunk[i + j]);
+                        }
+                        i += bytesToRead;
+                        remainingLength -= bytesToRead;
+                        if (remainingLength == 0) {
+                            // Transition from reading length header to reading document. Subtracting 4 because the length of the
+                            // header is included in length.
+                            const length = lengthBuffer.getInt32(0, true /* little endian */);
+                            remainingLength = length - 4;
+                            if (remainingLength < 1) {
+                                throw new Error(`invalid length for bson: ${length}`);
+                            }
+                            objectBody = new Uint8Array(length);
+                            new DataView(objectBody.buffer).setInt32(0, length, true);
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+
 /**
  * Throttle a function to be called at most once every "wait" milliseconds,
  * on the trailing edge.
@@ -4164,45 +4294,128 @@ function throttleTrailing(func, wait) {
     };
 }
 function asyncNotifier() {
-    let waitingConsumer = null;
-    let hasPendingNotification = false;
+    const queue = new EventQueue();
     return {
         notify() {
-            if (waitingConsumer != null) {
-                waitingConsumer();
-                waitingConsumer = null;
-            }
+            if (queue.countOutstandingEvents > 0) ;
             else {
-                hasPendingNotification = true;
+                queue.notify();
             }
         },
         waitForNotification(signal) {
-            return new Promise((resolve) => {
-                if (waitingConsumer != null) {
-                    throw new Error('Illegal call to waitForNotification, already has a waiter.');
-                }
-                if (signal.aborted) {
-                    resolve();
+            return queue.waitForEvent(signal);
+        }
+    };
+}
+class EventQueue {
+    options;
+    waitingConsumer;
+    outstandingEvents;
+    constructor(options = {}) {
+        this.options = options;
+        this.outstandingEvents = [];
+    }
+    /**
+     * The amount of buffered events not yet dispatched to listeners.
+     */
+    get countOutstandingEvents() {
+        return this.outstandingEvents.length;
+    }
+    notifyInner(dispatch) {
+        const existing = this.waitingConsumer;
+        this.waitingConsumer = undefined;
+        const dispatchAndNotifyListeners = (waiter) => {
+            dispatch(waiter);
+            this.options.eventDelivered?.();
+        };
+        if (existing) {
+            dispatchAndNotifyListeners(existing);
+        }
+        else {
+            this.outstandingEvents.push(dispatchAndNotifyListeners);
+        }
+    }
+    notify(value) {
+        this.notifyInner((l) => l.resolve(value));
+    }
+    notifyError(error) {
+        this.notifyInner((l) => l.reject(error));
+    }
+    waitForEvent(signal) {
+        return new Promise((resolve, reject) => {
+            if (this.waitingConsumer != null) {
+                throw new Error('Illegal call to waitForEvent, already has a waiter.');
+            }
+            const complete = () => {
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const onAbort = () => {
+                complete();
+                this.waitingConsumer = undefined;
+                resolve(undefined);
+            };
+            const waiter = {
+                resolve: (value) => {
+                    complete();
+                    resolve(value);
+                },
+                reject: (error) => {
+                    complete();
+                    reject(error);
                 }
-                else if (hasPendingNotification) {
-                    resolve();
-                    hasPendingNotification = false;
+            };
+            if (signal.aborted) {
+                resolve(undefined);
+            }
+            else if (this.countOutstandingEvents > 0) {
+                const [event] = this.outstandingEvents.splice(0, 1);
+                event(waiter);
+            }
+            else {
+                this.waitingConsumer = waiter;
+                signal.addEventListener('abort', onAbort);
+            }
+        });
+    }
+    /**
+     * Creates an async iterable backed by event queues.
+     *
+     * @param run A function invoked for every new listener. It receives a queue backing the async iterator.
+     * @param abort An additional abort signal. The `run` callback will also be aborted when `AsyncIterator.return` is
+     * called.
+     * @returns An object conforming to the async iterable protocol.
+     */
+    static queueBasedAsyncIterable(run, abort) {
+        return {
+            [symbolAsyncIterator]: () => {
+                const queue = new EventQueue();
+                const controller = new AbortController();
+                function dispose() {
+                    controller.abort();
+                    abort?.removeEventListener('abort', dispose);
                 }
-                else {
-                    function complete() {
-                        signal.removeEventListener('abort', onAbort);
-                        resolve();
+                if (abort) {
+                    if (abort.aborted) {
+                        controller.abort();
                     }
-                    function onAbort() {
-                        waitingConsumer = null;
-                        resolve();
+                    else {
+                        abort.addEventListener('abort', dispose);
                     }
-                    waitingConsumer = complete;
-                    signal.addEventListener('abort', onAbort);
                 }
-            });
-        }
-    };
+                run(queue, controller.signal);
+                return {
+                    async next() {
+                        const event = await queue.waitForEvent(controller.signal);
+                        return event == null ? doneResult : valueResult(event);
+                    },
+                    async return() {
+                        dispose();
+                        return doneResult;
+                    }
+                };
+            }
+        };
+    }
 }
 
 /**
@@ -4361,7 +4574,7 @@ class ConnectionManager extends BaseObserver {
     /**
      * Close the sync connection.
      *
-     * Use {@link connect} to connect again.
+     * Use {@link ConnectionManager.connect} to connect again.
      */
     async disconnect() {
         // This will help abort pending connects
@@ -4501,6 +4714,8 @@ const _finalizer = 'FinalizationRegistry' in globalThis
 /**
  * An efficient comparator for {@link WatchedQuery} created with {@link Query#watch}. This has the ability to determine if a query
  * result has changes without necessarily processing all items in the result.
+ *
+ * @public
  */
 class ArrayComparator {
     options;
@@ -4528,6 +4743,8 @@ class ArrayComparator {
 }
 /**
  * Watched query comparator that always reports changed result sets.
+ *
+ * @public
  */
 const FalsyComparator = {
     checkEquality: () => false // Default comparator that always returns false
@@ -4735,6 +4952,8 @@ class AbstractQueryProcessor extends MetaBaseObserver {
 /**
  * An empty differential result set.
  * This is used as the initial state for differential incrementally watched queries.
+ *
+ * @internal
  */
 const EMPTY_DIFFERENTIAL = {
     added: [],
@@ -4747,6 +4966,8 @@ const EMPTY_DIFFERENTIAL = {
  * Default implementation of the {@link DifferentialWatchedQueryComparator} for watched queries.
  * It keys items by their `id` property if available, alternatively it uses JSON stringification
  * of the entire item for the key and comparison.
+ *
+ * @internal
  */
 const DEFAULT_ROW_COMPARATOR = {
     keyBy: (item) => {
@@ -5027,6 +5248,8 @@ class CustomQuery {
 
 /**
  * Tests if the input is a {@link SQLOpenOptions}
+ *
+ * @internal
  */
 const isSQLOpenOptions = (test) => {
     // typeof null is `object`, but you cannot use the `in` operator on `null.
@@ -5034,17 +5257,24 @@ const isSQLOpenOptions = (test) => {
 };
 /**
  * Tests if input is a {@link SQLOpenFactory}
+ *
+ * @internal
  */
 const isSQLOpenFactory = (test) => {
     return typeof test?.openDB == 'function';
 };
 /**
  * Tests if input is a {@link DBAdapter}
+ *
+ * @internal
  */
 const isDBAdapter = (test) => {
     return typeof test?.writeTransaction == 'function';
 };
 
+/**
+ * @internal
+ */
 var PSInternalTable;
 (function (PSInternalTable) {
     PSInternalTable["DATA"] = "ps_data";
@@ -5053,6 +5283,9 @@ var PSInternalTable;
     PSInternalTable["OPLOG"] = "ps_oplog";
     PSInternalTable["UNTYPED"] = "ps_untyped";
 })(PSInternalTable || (PSInternalTable = {}));
+/**
+ * @internal
+ */
 var PowerSyncControlCommand;
 (function (PowerSyncControlCommand) {
     PowerSyncControlCommand["PROCESS_TEXT_LINE"] = "line_text";
@@ -5070,6 +5303,8 @@ var PowerSyncControlCommand;
 
 /**
  * A batch of client-side changes.
+ *
+ * @public
  */
 class CrudBatch {
     crud;
@@ -5096,6 +5331,8 @@ class CrudBatch {
 
 /**
  * Type of local change.
+ *
+ * @public
  */
 var UpdateType;
 (function (UpdateType) {
@@ -5108,6 +5345,8 @@ var UpdateType;
 })(UpdateType || (UpdateType = {}));
 /**
  * A single client-side change.
+ *
+ * @public
  */
 class CrudEntry {
     /**
@@ -5204,6 +5443,9 @@ class CrudEntry {
     }
 }
 
+/**
+ * @public
+ */
 class CrudTransaction extends CrudBatch {
     crud;
     complete;
@@ -5232,6 +5474,8 @@ class CrudTransaction extends CrudBatch {
  * Calls to Abortcontroller.abort(reason: any) will result in the
  * `reason` being thrown. This is not necessarily an error,
  *  but extends error for better logging purposes.
+ *
+ * @internal
  */
 class AbortOperation extends Error {
     reason;
@@ -12402,7 +12646,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.53.2";
+var version = "1.55.0";
 var PACKAGE = {
 	version: version};
 
@@ -12478,289 +12722,95 @@ function requireWebsocketDuplexConnection () {
 	        get: function () {
 	            return this.done ? 0 : 1;
 	        },
-	        enumerable: false,
-	        configurable: true
-	    });
-	    WebsocketDuplexConnection.prototype.close = function (error) {
-	        if (this.done) {
-	            _super.prototype.close.call(this, error);
-	            return;
-	        }
-	        this.websocket.removeEventListener("close", this.handleClosed);
-	        this.websocket.removeEventListener("error", this.handleError);
-	        this.websocket.removeEventListener("message", this.handleMessage);
-	        this.websocket.close();
-	        delete this.websocket;
-	        _super.prototype.close.call(this, error);
-	    };
-	    WebsocketDuplexConnection.prototype.send = function (frame) {
-	        if (this.done) {
-	            return;
-	        }
-	        var buffer = (0, rsocket_core_1.serializeFrame)(frame);
-	        this.websocket.send(buffer);
-	    };
-	    return WebsocketDuplexConnection;
-	}(rsocket_core_1.Deferred));
-	WebsocketDuplexConnection.WebsocketDuplexConnection = WebsocketDuplexConnection$1;
-	
-	return WebsocketDuplexConnection;
-}
-
-var WebsocketDuplexConnectionExports = requireWebsocketDuplexConnection();
-
-/**
- * Adapted from rsocket-websocket-client
- * https://github.com/rsocket/rsocket-js/blob/e224cf379e747c4f1ddc4f2fa111854626cc8575/packages/rsocket-websocket-client/src/WebsocketClientTransport.ts#L17
- * This adds additional error handling for React Native iOS.
- * This particularly adds a close listener to handle cases where the WebSocket
- * connection closes immediately after opening without emitting an error.
- */
-class WebsocketClientTransport {
-    url;
-    factory;
-    constructor(options) {
-        this.url = options.url;
-        this.factory = options.wsCreator ?? ((url) => new WebSocket(url));
-    }
-    connect(multiplexerDemultiplexerFactory) {
-        return new Promise((resolve, reject) => {
-            const websocket = this.factory(this.url);
-            websocket.binaryType = 'arraybuffer';
-            let removeListeners;
-            const openListener = () => {
-                removeListeners();
-                resolve(new WebsocketDuplexConnectionExports.WebsocketDuplexConnection(websocket, new distExports.Deserializer(), multiplexerDemultiplexerFactory));
-            };
-            const errorListener = (ev) => {
-                removeListeners();
-                // We add a default error in that case.
-                if (ev.error != null) {
-                    // undici typically provides an error object
-                    reject(ev.error);
-                }
-                else if (ev.message != null) {
-                    // React Native typically does not provide an error object, but does provide a message
-                    reject(new Error(`Failed to create websocket connection: ${ev.message}`));
-                }
-                else {
-                    // Browsers often provide no details at all
-                    reject(new Error(`Failed to create websocket connection to ${this.url}`));
-                }
-            };
-            /**
-             * In some cases, such as React Native iOS, the WebSocket connection may close immediately after opening
-             * without and error. In such cases, we need to handle the close event to reject the promise.
-             */
-            const closeListener = () => {
-                removeListeners();
-                reject(new Error('WebSocket connection closed while opening'));
-            };
-            removeListeners = () => {
-                websocket.removeEventListener('open', openListener);
-                websocket.removeEventListener('error', errorListener);
-                websocket.removeEventListener('close', closeListener);
-            };
-            websocket.addEventListener('open', openListener);
-            websocket.addEventListener('error', errorListener);
-            websocket.addEventListener('close', closeListener);
-        });
-    }
-}
-
-const doneResult = { done: true, value: undefined };
-function valueResult(value) {
-    return { done: false, value };
-}
-/**
- * Expands a source async iterator by allowing to inject events asynchronously.
- *
- * The resulting iterator will emit all events from its source. Additionally though, events can be injected. These
- * events are dropped once the main iterator completes, but are otherwise forwarded.
- *
- * The iterator completes when its source completes, and it supports backpressure by only calling `next()` on the source
- * in response to a `next()` call from downstream if no pending injected events can be dispatched.
- */
-function injectable(source) {
-    let sourceIsDone = false;
-    let waiter = undefined; // An active, waiting next() call.
-    // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
-    let pendingSourceEvent = null;
-    let sourceFetchInFlight = false;
-    let pendingInjectedEvents = [];
-    const consumeWaiter = () => {
-        const pending = waiter;
-        waiter = undefined;
-        return pending;
-    };
-    const fetchFromSource = () => {
-        const resolveWaiter = (propagate) => {
-            sourceFetchInFlight = false;
-            const active = consumeWaiter();
-            if (active) {
-                propagate(active);
-            }
-            else {
-                pendingSourceEvent = propagate;
-            }
-        };
-        sourceFetchInFlight = true;
-        const nextFromSource = source.next();
-        nextFromSource.then((value) => {
-            sourceIsDone = value.done == true;
-            resolveWaiter((w) => w.resolve(value));
-        }, (error) => {
-            resolveWaiter((w) => w.reject(error));
-        });
-    };
-    return {
-        next: () => {
-            return new Promise((resolve, reject) => {
-                // First priority: Dispatch ready upstream events.
-                if (sourceIsDone) {
-                    return resolve(doneResult);
-                }
-                if (pendingSourceEvent) {
-                    pendingSourceEvent({ resolve, reject });
-                    pendingSourceEvent = null;
-                    return;
-                }
-                // Second priority: Dispatch injected events
-                if (pendingInjectedEvents.length) {
-                    return resolve(valueResult(pendingInjectedEvents.shift()));
-                }
-                // Nothing pending? Fetch from source
-                waiter = { resolve, reject };
-                if (!sourceFetchInFlight) {
-                    fetchFromSource();
-                }
-            });
-        },
-        inject: (event) => {
-            const pending = consumeWaiter();
-            if (pending != null) {
-                pending.resolve(valueResult(event));
-            }
-            else {
-                pendingInjectedEvents.push(event);
-            }
-        }
-    };
-}
-/**
- * Splits a byte stream at line endings, emitting each line as a string.
- */
-function extractJsonLines(source, decoder) {
-    let buffer = '';
-    const pendingLines = [];
-    let isFinalEvent = false;
-    return {
-        next: async () => {
-            while (true) {
-                if (isFinalEvent) {
-                    return doneResult;
-                }
-                {
-                    const first = pendingLines.shift();
-                    if (first) {
-                        return { done: false, value: first };
-                    }
-                }
-                const { done, value } = await source.next();
-                if (done) {
-                    const remaining = buffer.trim();
-                    if (remaining.length != 0) {
-                        isFinalEvent = true;
-                        return { done: false, value: remaining };
-                    }
-                    return doneResult;
-                }
-                const data = decoder.decode(value, { stream: true });
-                buffer += data;
-                const lines = buffer.split('\n');
-                for (let i = 0; i < lines.length - 1; i++) {
-                    const l = lines[i].trim();
-                    if (l.length > 0) {
-                        pendingLines.push(l);
-                    }
-                }
-                buffer = lines[lines.length - 1];
-            }
-        }
-    };
+	        enumerable: false,
+	        configurable: true
+	    });
+	    WebsocketDuplexConnection.prototype.close = function (error) {
+	        if (this.done) {
+	            _super.prototype.close.call(this, error);
+	            return;
+	        }
+	        this.websocket.removeEventListener("close", this.handleClosed);
+	        this.websocket.removeEventListener("error", this.handleError);
+	        this.websocket.removeEventListener("message", this.handleMessage);
+	        this.websocket.close();
+	        delete this.websocket;
+	        _super.prototype.close.call(this, error);
+	    };
+	    WebsocketDuplexConnection.prototype.send = function (frame) {
+	        if (this.done) {
+	            return;
+	        }
+	        var buffer = (0, rsocket_core_1.serializeFrame)(frame);
+	        this.websocket.send(buffer);
+	    };
+	    return WebsocketDuplexConnection;
+	}(rsocket_core_1.Deferred));
+	WebsocketDuplexConnection.WebsocketDuplexConnection = WebsocketDuplexConnection$1;
+	
+	return WebsocketDuplexConnection;
 }
+
+var WebsocketDuplexConnectionExports = requireWebsocketDuplexConnection();
+
 /**
- * Splits a concatenated stream of BSON objects by emitting individual objects.
+ * Adapted from rsocket-websocket-client
+ * https://github.com/rsocket/rsocket-js/blob/e224cf379e747c4f1ddc4f2fa111854626cc8575/packages/rsocket-websocket-client/src/WebsocketClientTransport.ts#L17
+ * This adds additional error handling for React Native iOS.
+ * This particularly adds a close listener to handle cases where the WebSocket
+ * connection closes immediately after opening without emitting an error.
  */
-function extractBsonObjects(source) {
-    // Fully read but not emitted yet.
-    const completedObjects = [];
-    // Whether source has returned { done: true }. We do the same once completed objects have been emitted.
-    let isDone = false;
-    const lengthBuffer = new DataView(new ArrayBuffer(4));
-    let objectBody = null;
-    // If we're parsing the length field, a number between 1 and 4 (inclusive) describing remaining bytes in the header.
-    // If we're consuming a document, the bytes remaining.
-    let remainingLength = 4;
-    return {
-        async next() {
-            while (true) {
-                // Before fetching new data from upstream, return completed objects.
-                if (completedObjects.length) {
-                    return valueResult(completedObjects.shift());
-                }
-                if (isDone) {
-                    return doneResult;
+class WebsocketClientTransport {
+    url;
+    factory;
+    constructor(options) {
+        this.url = options.url;
+        this.factory = options.wsCreator ?? ((url) => new WebSocket(url));
+    }
+    connect(multiplexerDemultiplexerFactory) {
+        return new Promise((resolve, reject) => {
+            const websocket = this.factory(this.url);
+            websocket.binaryType = 'arraybuffer';
+            let removeListeners;
+            const openListener = () => {
+                removeListeners();
+                resolve(new WebsocketDuplexConnectionExports.WebsocketDuplexConnection(websocket, new distExports.Deserializer(), multiplexerDemultiplexerFactory));
+            };
+            const errorListener = (event) => {
+                const ev = event;
+                removeListeners();
+                // We add a default error in that case.
+                if (ev.error != null) {
+                    // undici typically provides an error object
+                    reject(ev.error);
                 }
-                const upstreamEvent = await source.next();
-                if (upstreamEvent.done) {
-                    isDone = true;
-                    if (objectBody || remainingLength != 4) {
-                        throw new Error('illegal end of stream in BSON object');
-                    }
-                    return doneResult;
+                else if (ev.message != null) {
+                    // React Native typically does not provide an error object, but does provide a message
+                    reject(new Error(`Failed to create websocket connection: ${ev.message}`));
                 }
-                const chunk = upstreamEvent.value;
-                for (let i = 0; i < chunk.length;) {
-                    const availableInData = chunk.length - i;
-                    if (objectBody) {
-                        // We're in the middle of reading a BSON document.
-                        const bytesToRead = Math.min(availableInData, remainingLength);
-                        const copySource = new Uint8Array(chunk.buffer, chunk.byteOffset + i, bytesToRead);
-                        objectBody.set(copySource, objectBody.length - remainingLength);
-                        i += bytesToRead;
-                        remainingLength -= bytesToRead;
-                        if (remainingLength == 0) {
-                            completedObjects.push(objectBody);
-                            // Prepare to read another document, starting with its length
-                            objectBody = null;
-                            remainingLength = 4;
-                        }
-                    }
-                    else {
-                        // Copy up to 4 bytes into lengthBuffer, depending on how many we still need.
-                        const bytesToRead = Math.min(availableInData, remainingLength);
-                        for (let j = 0; j < bytesToRead; j++) {
-                            lengthBuffer.setUint8(4 - remainingLength + j, chunk[i + j]);
-                        }
-                        i += bytesToRead;
-                        remainingLength -= bytesToRead;
-                        if (remainingLength == 0) {
-                            // Transition from reading length header to reading document. Subtracting 4 because the length of the
-                            // header is included in length.
-                            const length = lengthBuffer.getInt32(0, true /* little endian */);
-                            remainingLength = length - 4;
-                            if (remainingLength < 1) {
-                                throw new Error(`invalid length for bson: ${length}`);
-                            }
-                            objectBody = new Uint8Array(length);
-                            new DataView(objectBody.buffer).setInt32(0, length, true);
-                        }
-                    }
+                else {
+                    // Browsers often provide no details at all
+                    reject(new Error(`Failed to create websocket connection to ${this.url}`));
                 }
-            }
-        }
-    };
+            };
+            /**
+             * In some cases, such as React Native iOS, the WebSocket connection may close immediately after opening
+             * without and error. In such cases, we need to handle the close event to reject the promise.
+             */
+            const closeListener = () => {
+                removeListeners();
+                reject(new Error('WebSocket connection closed while opening'));
+            };
+            removeListeners = () => {
+                websocket.removeEventListener('open', openListener);
+                websocket.removeEventListener('error', errorListener);
+                websocket.removeEventListener('close', closeListener);
+            };
+            websocket.addEventListener('open', openListener);
+            websocket.addEventListener('error', errorListener);
+            websocket.addEventListener('close', closeListener);
+        });
+    }
 }
 
 const POWERSYNC_TRAILING_SLASH_MATCH = /\/+$/;
@@ -12775,7 +12825,13 @@ const SOCKET_TIMEOUT_MS = 30_000;
 // If there is a backlog of messages (for example on slow connections), keepalive messages could be delayed
 // significantly. Therefore this is longer than the socket timeout.
 const KEEP_ALIVE_LIFETIME_MS = 90_000;
+/**
+ * @internal
+ */
 const DEFAULT_REMOTE_LOGGER = Logger.get('PowerSyncRemote');
+/**
+ * @public
+ */
 var FetchStrategy;
 (function (FetchStrategy) {
     /**
@@ -12794,12 +12850,17 @@ var FetchStrategy;
  * The class wrapper is used to distinguish the fetchImplementation
  * option in [AbstractRemoteOptions] from the general fetch method
  * which is typeof "function"
+ *
+ * @internal
  */
 class FetchImplementationProvider {
     getFetch() {
         throw new Error('Unspecified fetch implementation');
     }
 }
+/**
+ * @internal
+ */
 const DEFAULT_REMOTE_OPTIONS = {
     socketUrlTransformer: (url) => url.replace(/^https?:\/\//, function (match) {
         return match === 'https://' ? 'wss://' : 'ws://';
@@ -12807,6 +12868,9 @@ const DEFAULT_REMOTE_OPTIONS = {
     fetchImplementation: new FetchImplementationProvider(),
     fetchOptions: {}
 };
+/**
+ * @internal
+ */
 class AbstractRemote {
     connector;
     logger;
@@ -12967,8 +13031,19 @@ class AbstractRemote {
         let pendingSocket = null;
         let keepAliveTimeout;
         let rsocket = null;
-        let queue = null;
+        let paused = false;
+        const queue = new EventQueue({
+            eventDelivered: () => {
+                if (queue.countOutstandingEvents <= SYNC_QUEUE_REQUEST_LOW_WATER) {
+                    paused = false;
+                    requestMore();
+                }
+            }
+        });
         let didClose = false;
+        let connectionEstablished = false;
+        let pendingEventsCount = syncQueueRequestSize;
+        let res = null;
         const abortRequest = () => {
             if (didClose) {
                 return;
@@ -12981,10 +13056,23 @@ class AbstractRemote {
             if (rsocket) {
                 rsocket.close();
             }
-            if (queue) {
-                queue.stop();
-            }
+            // Send a bogus event to the queue to ensure a pending listener gets woken up. We check for didClose and would
+            // return a doneEvent.
+            queue.notify(null);
         };
+        function push(event) {
+            queue.notify(event);
+            if (queue.countOutstandingEvents >= SYNC_QUEUE_REQUEST_HIGH_WATER) {
+                paused = true;
+            }
+        }
+        function requestMore() {
+            const delta = syncQueueRequestSize - pendingEventsCount;
+            if (!paused && delta > 0) {
+                res?.request(delta);
+                pendingEventsCount = syncQueueRequestSize;
+            }
+        }
         // Handle upstream abort
         if (options.abortSignal.aborted) {
             throw new AbortOperation('Connection request aborted');
@@ -13039,25 +13127,19 @@ class AbstractRemote {
         // Helps to prevent double close scenarios
         rsocket.onClose(() => (rsocket = null));
         return await new Promise((resolve, reject) => {
-            let connectionEstablished = false;
-            let pendingEventsCount = syncQueueRequestSize;
-            let paused = false;
-            let res = null;
-            function requestMore() {
-                const delta = syncQueueRequestSize - pendingEventsCount;
-                if (!paused && delta > 0) {
-                    res?.request(delta);
-                    pendingEventsCount = syncQueueRequestSize;
+            const queueAsIterator = {
+                next: async () => {
+                    if (didClose)
+                        return doneResult;
+                    const notification = await queue.waitForEvent(options.abortSignal);
+                    if (didClose) {
+                        return doneResult;
+                    }
+                    else {
+                        return valueResult(notification);
+                    }
                 }
-            }
-            const events = new domExports.EventIterator((q) => {
-                queue = q;
-                q.on('highWater', () => (paused = true));
-                q.on('lowWater', () => {
-                    paused = false;
-                    requestMore();
-                });
-            }, { highWaterMark: SYNC_QUEUE_REQUEST_HIGH_WATER, lowWaterMark: SYNC_QUEUE_REQUEST_LOW_WATER })[symbolAsyncIterator]();
+            };
             res = rsocket.requestStream({
                 data: toBuffer(options.data),
                 metadata: toBuffer({
@@ -13093,11 +13175,11 @@ class AbstractRemote {
                     // The connection is active
                     if (!connectionEstablished) {
                         connectionEstablished = true;
-                        resolve(events);
+                        resolve(queueAsIterator);
                     }
                     const { data } = payload;
                     if (data) {
-                        queue.push(data);
+                        push(data);
                     }
                     // Less events are now pending
                     pendingEventsCount--;
@@ -13216,7 +13298,7 @@ class AbstractRemote {
      * Posts a `/sync/stream` request.
      *
      * Depending on the `Content-Type` of the response, this returns strings for sync lines or encoded BSON documents as
-     * {@link Uint8Array}s.
+     * `Uint8Array`s.
      */
     async fetchStream(options) {
         const { isBson, stream } = await this.fetchStreamRaw(options);
@@ -13258,16 +13340,26 @@ function isInterruptingInstruction(instruction) {
     return 'EstablishSyncStream' in instruction || 'CloseSyncStream' in instruction;
 }
 
+/**
+ * @internal
+ */
 var LockType;
 (function (LockType) {
     LockType["CRUD"] = "crud";
     LockType["SYNC"] = "sync";
 })(LockType || (LockType = {}));
+/**
+ * @public
+ */
 var SyncStreamConnectionMethod;
 (function (SyncStreamConnectionMethod) {
     SyncStreamConnectionMethod["HTTP"] = "http";
     SyncStreamConnectionMethod["WEB_SOCKET"] = "web-socket";
 })(SyncStreamConnectionMethod || (SyncStreamConnectionMethod = {}));
+/**
+ * @deprecated Deprecated since {@link SyncClientImplementation.RUST} is the only option.
+ * @public
+ */
 var SyncClientImplementation;
 (function (SyncClientImplementation) {
     /**
@@ -13279,8 +13371,8 @@ var SyncClientImplementation;
      * ## Compatibility warning
      *
      * The Rust sync client stores sync data in a format that is slightly different than the one used
-     * by the old JavaScript client. When adopting the {@link RUST} client on existing databases, the PowerSync SDK will
-     * migrate the format automatically.
+     * by the old JavaScript client. When adopting the {@link SyncClientImplementation.RUST} client on existing databases,
+     * the PowerSync SDK will migrate the format automatically.
      *
      * SDK versions supporting both the JavaScript and the Rust client support both formats with the JavaScript client
      * implementaiton. However, downgrading to an SDK version that only supports the JavaScript client would not be
@@ -13290,14 +13382,29 @@ var SyncClientImplementation;
 })(SyncClientImplementation || (SyncClientImplementation = {}));
 /**
  * The default {@link SyncClientImplementation} to use, {@link SyncClientImplementation.RUST}.
+ *
+ * @deprecated Deprecated since {@link SyncClientImplementation.RUST} is the only option.
+ * @public
  */
 const DEFAULT_SYNC_CLIENT_IMPLEMENTATION = SyncClientImplementation.RUST;
+/**
+ * @internal
+ */
 const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
+/**
+ * @internal
+ */
 const DEFAULT_RETRY_DELAY_MS = 5000;
+/**
+ * @internal
+ */
 const DEFAULT_STREAMING_SYNC_OPTIONS = {
     retryDelayMs: DEFAULT_RETRY_DELAY_MS,
     crudUploadThrottleMs: DEFAULT_CRUD_UPLOAD_THROTTLE_MS
 };
+/**
+ * @internal
+ */
 const DEFAULT_STREAM_CONNECTION_OPTIONS = {
     appMetadata: {},
     connectionMethod: SyncStreamConnectionMethod.WEB_SOCKET,
@@ -13307,6 +13414,9 @@ const DEFAULT_STREAM_CONNECTION_OPTIONS = {
     serializedSchema: undefined,
     includeDefaultStreams: true
 };
+/**
+ * @internal
+ */
 class AbstractStreamingSyncImplementation extends BaseObserver {
     options;
     abortController;
@@ -13630,7 +13740,7 @@ The next upload iteration will be delayed.`);
         this.handleActiveStreamsChange?.();
     }
     /**
-     * Older versions of the JS SDK used to encode subkeys as JSON in {@link OplogEntry.toJSON}.
+     * Older versions of the JS SDK used to encode subkeys as JSON in `OplogEntry.toJSON`.
      * Because subkeys are always strings, this leads to quotes being added around them in `ps_oplog`.
      * While this is not a problem as long as it's done consistently, it causes issues when a database
      * created by the JS SDK is used with other SDKs, or (more likely) when the new Rust sync client
@@ -13640,7 +13750,7 @@ The next upload iteration will be delayed.`);
      * migration is only triggered when necessary (for now). The function returns whether the new format
      * should be used, so that the JS SDK is able to write to updated databases.
      *
-     * @param requireFixedKeyFormat Whether we require the new format or also support the old one.
+     * @param requireFixedKeyFormat - Whether we require the new format or also support the old one.
      *        The Rust client requires the new subkey format.
      * @returns Whether the database is now using the new, fixed subkey format.
      */
@@ -13947,7 +14057,8 @@ const MEMORY_TRIGGER_CLAIM_MANAGER = {
 
 /**
  * SQLite operations to track changes for with {@link TriggerManager}
- * @experimental
+ *
+ * @experimental @alpha
  */
 var DiffTriggerOperation;
 (function (DiffTriggerOperation) {
@@ -14009,8 +14120,8 @@ class TriggerManagerImpl {
     get db() {
         return this.options.db;
     }
-    async getUUID() {
-        const { id: uuid } = await this.db.get(/* sql */ `
+    async getUUID(ctx) {
+        const { id: uuid } = await (ctx ?? this.db).get(/* sql */ `
       SELECT
         uuid () as id
     `);
@@ -14123,7 +14234,7 @@ class TriggerManagerImpl {
         const replicatedColumns = columns ?? sourceDefinition.columns.map((col) => col.name);
         const internalSource = sourceDefinition.internalName;
         const triggerIds = [];
-        const id = await this.getUUID();
+        const id = await this.getUUID(setupContext);
         const releaseStorageClaim = useStorage ? await this.options.claimManager.obtainClaim(id) : null;
         /**
          * We default to replicating all columns if no columns array is provided.
@@ -14363,18 +14474,29 @@ const POWERSYNC_TABLE_MATCH = /(^ps_data__|^ps_data_local__)/;
 const DEFAULT_DISCONNECT_CLEAR_OPTIONS = {
     clearLocal: true
 };
+/**
+ * @internal
+ */
 const DEFAULT_POWERSYNC_CLOSE_OPTIONS = {
     disconnect: true
 };
+/**
+ * @internal
+ */
 const DEFAULT_POWERSYNC_DB_OPTIONS = {
     retryDelayMs: 5000,
     crudUploadThrottleMs: DEFAULT_CRUD_UPLOAD_THROTTLE_MS
 };
+/**
+ * @internal
+ */
 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.
+ *
+ * @internal
  */
 const DEFAULT_LOCK_TIMEOUT_MS = 120_000; // 2 mins
 /**
@@ -14384,6 +14506,9 @@ const DEFAULT_LOCK_TIMEOUT_MS = 120_000; // 2 mins
 const isPowerSyncDatabaseOptionsWithSettings = (test) => {
     return typeof test == 'object' && isSQLOpenOptions(test.database);
 };
+/**
+ * @public
+ */
 class AbstractPowerSyncDatabase extends BaseObserver {
     options;
     /**
@@ -14541,7 +14666,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
     /**
      * 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.
@@ -14696,7 +14821,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
     /**
      * Close the sync connection.
      *
-     * Use {@link connect} to connect again.
+     * Use {@link AbstractPowerSyncDatabase.connect} to connect again.
      */
     async disconnect() {
         return this.connectionManager.disconnect();
@@ -14723,8 +14848,8 @@ class AbstractPowerSyncDatabase extends BaseObserver {
     /**
      * 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.
      */
@@ -14782,14 +14907,14 @@ class AbstractPowerSyncDatabase extends BaseObserver {
      * 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
      */
     async getCrudBatch(limit = DEFAULT_CRUD_BATCH_LIMIT) {
@@ -14816,7 +14941,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
      * 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 AbstractPowerSyncDatabase.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
@@ -14831,7 +14956,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
      * 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 AbstractPowerSyncDatabase.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.
      *
@@ -14925,8 +15050,8 @@ SELECT * FROM crud_entries;
      * 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
+     * @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
      */
     async execute(sql, parameters) {
@@ -14936,8 +15061,8 @@ SELECT * FROM crud_entries;
      * 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
+     * @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.
      */
@@ -14950,8 +15075,8 @@ SELECT * FROM crud_entries;
      * 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
+     * @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
      */
     async executeBatch(sql, parameters) {
@@ -14961,8 +15086,8 @@ SELECT * FROM crud_entries;
     /**
      *  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
+     * @param sql - The SQL query to execute
+     * @param parameters - Optional array of parameters to bind to the query
      * @returns An array of results
      */
     async getAll(sql, parameters) {
@@ -14972,8 +15097,8 @@ SELECT * FROM crud_entries;
     /**
      * 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
+     * @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
      */
     async getOptional(sql, parameters) {
@@ -14983,8 +15108,8 @@ SELECT * FROM crud_entries;
     /**
      * 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
+     * @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
      */
@@ -14994,7 +15119,7 @@ SELECT * FROM crud_entries;
     }
     /**
      * Takes a read lock, without starting a transaction.
-     * In most cases, {@link readTransaction} should be used instead.
+     * In most cases, {@link AbstractPowerSyncDatabase.readTransaction} should be used instead.
      */
     async readLock(callback) {
         await this.waitForReady();
@@ -15002,7 +15127,7 @@ SELECT * FROM crud_entries;
     }
     /**
      * Takes a global lock, without starting a transaction.
-     * In most cases, {@link writeTransaction} should be used instead.
+     * In most cases, {@link AbstractPowerSyncDatabase.writeTransaction} should be used instead.
      */
     async writeLock(callback) {
         await this.waitForReady();
@@ -15013,8 +15138,8 @@ SELECT * FROM crud_entries;
      * 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
      */
@@ -15031,8 +15156,8 @@ SELECT * FROM crud_entries;
      * 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
      */
@@ -15109,15 +15234,15 @@ SELECT * FROM crud_entries;
     }
     /**
      * 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, parameters, handler, options) {
         const { onResult, onError = (e) => this.logger.error(e) } = handler ?? {};
@@ -15130,7 +15255,7 @@ SELECT * FROM crud_entries;
         const watchedQuery = new OnChangeQueryProcessor({
             db: this,
             comparator,
-            placeholderData: null,
+            placeholderData: null, // FIXME
             watchOptions: {
                 query: {
                     compile: () => ({
@@ -15163,38 +15288,35 @@ SELECT * FROM crud_entries;
     }
     /**
      * 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, parameters, options) {
-        return new domExports.EventIterator((eventOptions) => {
+        return EventQueue.queueBasedAsyncIterable((queue, abort) => {
             const handler = {
                 onResult: (result) => {
-                    eventOptions.push(result);
+                    queue.notify(result);
                 },
                 onError: (error) => {
-                    eventOptions.fail(error);
+                    queue.notifyError(error);
                 }
             };
-            this.watchWithCallback(sql, parameters, handler, options);
-            options?.signal?.addEventListener('abort', () => {
-                eventOptions.stop();
-            });
-        });
+            this.watchWithCallback(sql, parameters, handler, { ...options, signal: abort });
+        }, options?.signal);
     }
     /**
      * Resolves the list of tables that are used in a SQL query.
      * 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
      */
     async resolveTables(sql, parameters, options) {
@@ -15223,13 +15345,13 @@ SELECT * FROM crud_entries;
     /**
      * 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 AbstractPowerSyncDatabase.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, options) {
@@ -15272,31 +15394,26 @@ SELECT * FROM crud_entries;
     /**
      * 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.
-     *
-     * Note: do not declare this as `async *onChange` as it will not work in React Native.
+     * This is preferred over {@link AbstractPowerSyncDatabase.watchWithAsyncGenerator} when multiple queries need to be
+     * performed together when data is changed.
      *
-     * @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
      */
+    // Note: do not declare this as `async *onChange` as it will not work in React Native.
     onChangeWithAsyncGenerator(options) {
-        const resolvedOptions = options ?? {};
-        return new domExports.EventIterator((eventOptions) => {
-            const dispose = this.onChangeWithCallback({
+        return EventQueue.queueBasedAsyncIterable((queue, abort) => {
+            this.onChangeWithCallback({
                 onChange: (event) => {
-                    eventOptions.push(event);
+                    queue.notify(event);
                 },
                 onError: (error) => {
-                    eventOptions.fail(error);
+                    queue.notifyError(error);
                 }
-            }, options);
-            resolvedOptions.signal?.addEventListener('abort', () => {
-                eventOptions.stop();
-                // Maybe fail?
-            });
-            return () => dispose();
-        });
+            }, { ...options, signal: abort });
+            // Note: We don't have to track the dispose function returned by onChangeWithCallback, it cleans up
+            // after the abort signal completes.
+        }, options?.signal);
     }
     handleTableChanges(changedTables, watchedTables, onDetectedChanges) {
         if (changedTables.size > 0) {
@@ -15315,15 +15432,15 @@ SELECT * FROM crud_entries;
             changedTables.add(table);
         }
     }
-    /**
-     * @ignore
-     */
     async executeReadOnly(sql, params) {
         await this.waitForReady();
         return this.database.readLock((tx) => tx.execute(sql, params));
     }
 }
 
+/**
+ * @internal
+ */
 class AbstractPowerSyncDatabaseOpenFactory {
     options;
     constructor(options) {
@@ -15348,6 +15465,9 @@ class AbstractPowerSyncDatabaseOpenFactory {
     }
 }
 
+/**
+ * @internal
+ */
 function runOnSchemaChange(callback, db, options) {
     const triggerWatchedQuery = () => {
         const abortController = new AbortController();
@@ -15372,6 +15492,9 @@ function runOnSchemaChange(callback, db, options) {
     triggerWatchedQuery();
 }
 
+/**
+ * @public
+ */
 function compilableQueryWatch(db, query, handler, options) {
     const { onResult, onError = (e) => { } } = handler ?? {};
     if (!onResult) {
@@ -15409,8 +15532,14 @@ function compilableQueryWatch(db, query, handler, options) {
     runOnSchemaChange(watchQuery, db, options);
 }
 
+/**
+ * @internal
+ */
 const MAX_OP_ID = '9223372036854775807';
 
+/**
+ * @internal
+ */
 class SqliteBucketStorage extends BaseObserver {
     db;
     logger;
@@ -15571,6 +15700,8 @@ class SqliteBucketStorage extends BaseObserver {
  * Thrown when an underlying database connection is closed.
  * This is particularly relevant when worker connections are marked as closed while
  * operations are still in progress.
+ *
+ * @internal
  */
 class ConnectionClosedError extends Error {
     static NAME = 'ConnectionClosedError';
@@ -15590,6 +15721,8 @@ class ConnectionClosedError extends Error {
 
 /**
  * A schema is a collection of tables. It is used to define the structure of a database.
+ *
+ * @public
  */
 class Schema {
     /*
@@ -15626,7 +15759,7 @@ class Schema {
      * Since raw tables are not backed by JSON, running complex queries on them may be more efficient. Further, they allow
      * using client-side table and column constraints.
      *
-     * @param tables An object of (table name, raw table definition) entries.
+     * @param tables - An object of (table name, raw table definition) entries.
      */
     withRawTables(tables) {
         for (const [name, rawTableDefinition] of Object.entries(tables)) {
@@ -15672,6 +15805,8 @@ class Schema {
   Generate a new table from the columns and indexes
   @deprecated You should use {@link Table} instead as it now allows TableV2 syntax.
   This will be removed in the next major release.
+
+  @public
 */
 class TableV2 extends Table {
 }
@@ -15682,6 +15817,8 @@ function sanitizeString(input) {
 /**
  * Helper function for sanitizing UUID input strings.
  * Typically used with {@link sanitizeSQL}.
+ *
+ * @alpha
  */
 function sanitizeUUID(uuid) {
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -15718,6 +15855,8 @@ function sanitizeUUID(uuid) {
  * // Incorrect:
  * sanitizeSQL`New.id = '${myID}'` // Produces double quotes: New.id = ''O''Reilly''
  * ```
+ *
+ * @alpha
  */
 function sanitizeSQL(strings, ...values) {
     let result = '';
@@ -15747,6 +15886,8 @@ function sanitizeSQL(strings, ...values) {
 
 /**
  * Performs a {@link AbstractPowerSyncDatabase.getAll} operation for a watched query.
+ *
+ * @public
  */
 class GetAllQuery {
     options;
@@ -15771,6 +15912,9 @@ class GetAllQuery {
 }
 
 const TypedLogger = Logger;
+/**
+ * @public
+ */
 const LogLevel = {
     TRACE: TypedLogger.TRACE,
     DEBUG: TypedLogger.DEBUG,
@@ -15787,6 +15931,7 @@ const LogLevel = {
  * across all loggers created with `createLogger`. Adjusting settings on this
  * base logger affects all loggers derived from it unless explicitly overridden.
  *
+ * @public
  */
 function createBaseLogger() {
     return Logger;
@@ -15797,6 +15942,8 @@ function createBaseLogger() {
  * Named loggers allow specific modules or areas of your application to have
  * their own logging levels and behaviors. These loggers inherit configuration
  * from the base logger by default but can override settings independently.
+ *
+ * @public
  */
 function createLogger(name, options = {}) {
     const logger = Logger.get(name);
@@ -15806,6 +15953,9 @@ function createLogger(name, options = {}) {
     return logger;
 }
 
+/**
+ * @internal
+ */
 const parseQuery = (query, parameters) => {
     let sqlStatement;
     if (typeof query == 'string') {