@powersync/common 1.54.0 → 1.56.0

package/dist/bundle.cjs

@@ -1451,165 +1451,10 @@ exports.EncodingType = void 0;
     EncodingType["Base64"] = "base64";
 })(exports.EncodingType || (exports.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: {}};
 
 /*!
@@ -2292,11 +2137,7 @@ class SyncStatus {
          */
         const replacer = (_, value) => {
             if (value instanceof Error) {
-                return {
-                    name: value.name,
-                    message: value.message,
-                    stack: value.stack
-                };
+                return this.serializeError(value);
             }
             return value;
         };
@@ -2339,11 +2180,18 @@ class SyncStatus {
         if (typeof error == 'undefined') {
             return undefined;
         }
-        return {
+        const serialized = {
             name: error.name,
             message: error.message,
             stack: error.stack
         };
+        // `Error.cause` can be any value (the spec types it as unknown). Preserve it
+        // so consumers reading uploadError/downloadError keep the failure context.
+        // Recurse for Error causes so the whole chain is flattened the same way.
+        if (typeof error.cause != 'undefined') {
+            serialized.cause = error.cause instanceof Error ? this.serializeError(error.cause) : error.cause;
+        }
+        return serialized;
     }
     static comparePriorities(a, b) {
         return b.priority - a.priority; // Reverse because higher priorities have lower numbers
@@ -2493,6 +2341,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.
@@ -2512,45 +2564,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 {
+                queue.notify();
+            }
+        },
+        waitForNotification(signal) {
+            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);
+                }
+            };
+            if (signal.aborted) {
+                resolve(undefined);
+            }
+            else if (this.countOutstandingEvents > 0) {
+                const [event] = this.outstandingEvents.splice(0, 1);
+                event(waiter);
             }
             else {
-                hasPendingNotification = true;
+                this.waitingConsumer = waiter;
+                signal.addEventListener('abort', onAbort);
             }
-        },
-        waitForNotification(signal) {
-            return new Promise((resolve) => {
-                if (waitingConsumer != null) {
-                    throw new Error('Illegal call to waitForNotification, already has a waiter.');
-                }
-                if (signal.aborted) {
-                    resolve();
-                }
-                else if (hasPendingNotification) {
-                    resolve();
-                    hasPendingNotification = false;
+        });
+    }
+    /**
+     * 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;
+                    }
+                };
+            }
+        };
+    }
 }
 
 /**
@@ -10781,7 +10916,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.54.0";
+var version = "1.56.0";
 var PACKAGE = {
 	version: version};
 
@@ -10948,201 +11083,6 @@ class WebsocketClientTransport {
     }
 }
 
-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);
-                        }
-                    }
-                }
-            }
-        }
-    };
-}
-
 const POWERSYNC_TRAILING_SLASH_MATCH = /\/+$/;
 const POWERSYNC_JS_VERSION = PACKAGE.version;
 const SYNC_QUEUE_REQUEST_HIGH_WATER = 10;
@@ -11361,8 +11301,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;
@@ -11375,10 +11326,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');
@@ -11433,25 +11397,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({
@@ -11487,11 +11445,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--;
@@ -13089,7 +13047,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
             this.logger.warn('Schema validation failed. Unexpected behaviour could occur', ex);
         }
         this._schema = schema;
-        await this.database.execute('SELECT powersync_replace_schema(?)', [JSON.stringify(this.schema.toJSON())]);
+        await this.database.writeTransaction((tx) => tx.execute('SELECT powersync_replace_schema(?)', [JSON.stringify(this.schema.toJSON())]));
         await this.database.refreshSchema();
         this.iterateListeners(async (cb) => cb.schemaChanged?.(schema));
     }
@@ -13609,20 +13567,17 @@ SELECT * FROM crud_entries;
      * @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.
@@ -13712,28 +13667,23 @@ SELECT * FROM crud_entries;
      * This is preferred over {@link AbstractPowerSyncDatabase.watchWithAsyncGenerator} when multiple queries need to be
      * performed together when data is changed.
      *
-     * Note: do not declare this as `async *onChange` as it will not work in React Native.
-     *
      * @param options - Options for configuring watch behavior
      * @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) {