@powersync/common 1.51.0 → 1.53.0

package/dist/bundle.cjs

@@ -1398,6 +1398,8 @@ 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;
 }
@@ -1478,7 +1480,7 @@ function requireEventIterator () {
 	                this.removeCallback();
 	        });
 	    }
-	    [Symbol.asyncIterator]() {
+	    [symbolAsyncIterator]() {
 	        return {
 	            next: (value) => {
 	                const result = this.pushQueue.shift();
@@ -1525,7 +1527,7 @@ function requireEventIterator () {
 	                    queue.eventHandlers[event] = fn;
 	                },
 	            }) || (() => { });
-	        this[Symbol.asyncIterator] = () => queue[Symbol.asyncIterator]();
+	        this[symbolAsyncIterator] = () => queue[symbolAsyncIterator]();
 	        Object.freeze(this);
 	    }
 	}
@@ -1969,8 +1971,15 @@ class BaseTransaction {
 class TransactionImplementation extends DBGetUtilsDefaultMixin(BaseTransaction) {
     static async runWith(ctx, fn) {
         let tx = new TransactionImplementation(ctx);
+        // For write transactions, use BEGIN IMMEDIATE to immediately obtain a write lock on the database (instead of doing
+        // that on the first statement). If we have a genuine read-only connection, we also use BEGIN IMMEDIATE there: In
+        // WAL mode, that ensures we pin the current state of the database (instead of the state at the first statement in
+        // the transaction). But if we have a "fake" read-only connection implemented through `pragma query_only = true`, we
+        // can't use this trick because it would attempt to lock the connection. So there, we use a regular `BEGIN`
+        // statement.
+        const useBeginImmediate = ctx.connectionType != 'queryOnly';
         try {
-            await ctx.execute('BEGIN IMMEDIATE');
+            await ctx.execute(useBeginImmediate ? 'BEGIN IMMEDIATE' : 'BEGIN');
             const result = await fn(tx);
             await tx.commit();
             return result;
@@ -2129,16 +2138,12 @@ class SyncStatus {
      *
      * This returns null when the database is currently being opened and we don't have reliable information about all
      * included streams yet.
-     *
-     * @experimental Sync streams are currently in alpha.
      */
     get syncStreams() {
         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.
-     *
-     * @experimental Sync streams are currently in alpha.
      */
     forStream(stream) {
         const asJson = JSON.stringify(stream.parameters);
@@ -2407,15 +2412,6 @@ class ControlledExecutor {
     }
 }
 
-/**
- * A ponyfill for `Symbol.asyncIterator` that is compatible with the
- * [recommended 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)
- * we recommend for React Native.
- *
- * As long as we use this symbol (instead of `for await` and `async *`) in this package, we can be compatible with async
- * iterators without requiring them.
- */
-const symbolAsyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
 /**
  * Throttle a function to be called at most once every "wait" milliseconds,
  * on the trailing edge.
@@ -2730,7 +2726,7 @@ class SyncStreamSubscriptionHandle {
     constructor(subscription) {
         this.subscription = subscription;
         subscription.refcount++;
-        _finalizer?.register(this, subscription);
+        _finalizer?.register(this, subscription, this);
     }
     get name() {
         return this.subscription.name;
@@ -3319,6 +3315,10 @@ exports.PowerSyncControlCommand = void 0;
     PowerSyncControlCommand["NOTIFY_TOKEN_REFRESHED"] = "refreshed_token";
     PowerSyncControlCommand["NOTIFY_CRUD_UPLOAD_COMPLETED"] = "completed_upload";
     PowerSyncControlCommand["UPDATE_SUBSCRIPTIONS"] = "update_subscriptions";
+    /**
+     * An `established` or `end` event for response streams.
+     */
+    PowerSyncControlCommand["CONNECTION_STATE"] = "connection";
 })(exports.PowerSyncControlCommand || (exports.PowerSyncControlCommand = {}));
 
 /**
@@ -3500,103 +3500,6 @@ class AbortOperation extends Error {
     }
 }
 
-exports.OpTypeEnum = void 0;
-(function (OpTypeEnum) {
-    OpTypeEnum[OpTypeEnum["CLEAR"] = 1] = "CLEAR";
-    OpTypeEnum[OpTypeEnum["MOVE"] = 2] = "MOVE";
-    OpTypeEnum[OpTypeEnum["PUT"] = 3] = "PUT";
-    OpTypeEnum[OpTypeEnum["REMOVE"] = 4] = "REMOVE";
-})(exports.OpTypeEnum || (exports.OpTypeEnum = {}));
-/**
- * Used internally for sync buckets.
- */
-class OpType {
-    value;
-    static fromJSON(jsonValue) {
-        return new OpType(exports.OpTypeEnum[jsonValue]);
-    }
-    constructor(value) {
-        this.value = value;
-    }
-    toJSON() {
-        return Object.entries(exports.OpTypeEnum).find(([, value]) => value === this.value)[0];
-    }
-}
-
-class OplogEntry {
-    op_id;
-    op;
-    checksum;
-    subkey;
-    object_type;
-    object_id;
-    data;
-    static fromRow(row) {
-        return new OplogEntry(row.op_id, OpType.fromJSON(row.op), row.checksum, row.subkey, row.object_type, row.object_id, row.data);
-    }
-    constructor(op_id, op, checksum, subkey, object_type, object_id, data) {
-        this.op_id = op_id;
-        this.op = op;
-        this.checksum = checksum;
-        this.subkey = subkey;
-        this.object_type = object_type;
-        this.object_id = object_id;
-        this.data = data;
-    }
-    toJSON(fixedKeyEncoding = false) {
-        return {
-            op_id: this.op_id,
-            op: this.op.toJSON(),
-            object_type: this.object_type,
-            object_id: this.object_id,
-            checksum: this.checksum,
-            data: this.data,
-            // Older versions of the JS SDK used to always JSON.stringify here. That has always been wrong,
-            // but we need to migrate gradually to not break existing databases.
-            subkey: fixedKeyEncoding ? this.subkey : JSON.stringify(this.subkey)
-        };
-    }
-}
-
-class SyncDataBucket {
-    bucket;
-    data;
-    has_more;
-    after;
-    next_after;
-    static fromRow(row) {
-        return new SyncDataBucket(row.bucket, row.data.map((entry) => OplogEntry.fromRow(entry)), row.has_more ?? false, row.after, row.next_after);
-    }
-    constructor(bucket, data, 
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more, 
-    /**
-     * The `after` specified in the request.
-     */
-    after, 
-    /**
-     * Use this for the next request.
-     */
-    next_after) {
-        this.bucket = bucket;
-        this.data = data;
-        this.has_more = has_more;
-        this.after = after;
-        this.next_after = next_after;
-    }
-    toJSON(fixedKeyEncoding = false) {
-        return {
-            bucket: this.bucket,
-            has_more: this.has_more,
-            after: this.after,
-            next_after: this.next_after,
-            data: this.data.map((entry) => entry.toJSON(fixedKeyEncoding))
-        };
-    }
-}
-
 var buffer = {};
 
 var base64Js = {};
@@ -10752,177 +10655,10 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.51.0";
+var version = "1.53.0";
 var PACKAGE = {
 	version: version};
 
-const DEFAULT_PRESSURE_LIMITS = {
-    highWater: 10,
-    lowWater: 0
-};
-/**
- * A very basic implementation of a data stream with backpressure support which does not use
- * native JS streams or async iterators.
- * This is handy for environments such as React Native which need polyfills for the above.
- */
-class DataStream extends BaseObserver {
-    options;
-    dataQueue;
-    isClosed;
-    processingPromise;
-    notifyDataAdded;
-    logger;
-    mapLine;
-    constructor(options) {
-        super();
-        this.options = options;
-        this.processingPromise = null;
-        this.isClosed = false;
-        this.dataQueue = [];
-        this.mapLine = options?.mapLine ?? ((line) => line);
-        this.logger = options?.logger ?? Logger.get('DataStream');
-        if (options?.closeOnError) {
-            const l = this.registerListener({
-                error: (ex) => {
-                    l?.();
-                    this.close();
-                }
-            });
-        }
-    }
-    get highWatermark() {
-        return this.options?.pressure?.highWaterMark ?? DEFAULT_PRESSURE_LIMITS.highWater;
-    }
-    get lowWatermark() {
-        return this.options?.pressure?.lowWaterMark ?? DEFAULT_PRESSURE_LIMITS.lowWater;
-    }
-    get closed() {
-        return this.isClosed;
-    }
-    async close() {
-        this.isClosed = true;
-        await this.processingPromise;
-        this.iterateListeners((l) => l.closed?.());
-        // Discard any data in the queue
-        this.dataQueue = [];
-        this.listeners.clear();
-    }
-    /**
-     * Enqueues data for the consumers to read
-     */
-    enqueueData(data) {
-        if (this.isClosed) {
-            throw new Error('Cannot enqueue data into closed stream.');
-        }
-        this.dataQueue.push(data);
-        this.notifyDataAdded?.();
-        this.processQueue();
-    }
-    /**
-     * Reads data once from the data stream
-     * @returns a Data payload or Null if the stream closed.
-     */
-    async read() {
-        if (this.closed) {
-            return null;
-        }
-        // Wait for any pending processing to complete first.
-        // This ensures we register our listener before calling processQueue(),
-        // avoiding a race where processQueue() sees no reader and returns early.
-        if (this.processingPromise) {
-            await this.processingPromise;
-        }
-        // Re-check after await - stream may have closed while we were waiting
-        if (this.closed) {
-            return null;
-        }
-        return new Promise((resolve, reject) => {
-            const l = this.registerListener({
-                data: async (data) => {
-                    resolve(data);
-                    // Remove the listener
-                    l?.();
-                },
-                closed: () => {
-                    resolve(null);
-                    l?.();
-                },
-                error: (ex) => {
-                    reject(ex);
-                    l?.();
-                }
-            });
-            this.processQueue();
-        });
-    }
-    /**
-     * Executes a callback for each data item in the stream
-     */
-    forEach(callback) {
-        if (this.dataQueue.length <= this.lowWatermark) {
-            this.iterateAsyncErrored(async (l) => l.lowWater?.());
-        }
-        return this.registerListener({
-            data: callback
-        });
-    }
-    processQueue() {
-        if (this.processingPromise) {
-            return;
-        }
-        const promise = (this.processingPromise = this._processQueue());
-        promise.finally(() => {
-            this.processingPromise = null;
-        });
-        return promise;
-    }
-    hasDataReader() {
-        return Array.from(this.listeners.values()).some((l) => !!l.data);
-    }
-    async _processQueue() {
-        /**
-         * Allow listeners to mutate the queue before processing.
-         * This allows for operations such as dropping or compressing data
-         * on high water or requesting more data on low water.
-         */
-        if (this.dataQueue.length >= this.highWatermark) {
-            await this.iterateAsyncErrored(async (l) => l.highWater?.());
-        }
-        if (this.isClosed || !this.hasDataReader()) {
-            return;
-        }
-        if (this.dataQueue.length) {
-            const data = this.dataQueue.shift();
-            const mapped = this.mapLine(data);
-            await this.iterateAsyncErrored(async (l) => l.data?.(mapped));
-        }
-        if (this.dataQueue.length <= this.lowWatermark) {
-            const dataAdded = new Promise((resolve) => {
-                this.notifyDataAdded = resolve;
-            });
-            await Promise.race([this.iterateAsyncErrored(async (l) => l.lowWater?.()), dataAdded]);
-            this.notifyDataAdded = null;
-        }
-        if (this.dataQueue.length > 0) {
-            setTimeout(() => this.processQueue());
-        }
-    }
-    async iterateAsyncErrored(cb) {
-        // Important: We need to copy the listeners, as calling a listener could result in adding another
-        // listener, resulting in infinite loops.
-        const listeners = Array.from(this.listeners.values());
-        for (let i of listeners) {
-            try {
-                await cb(i);
-            }
-            catch (ex) {
-                this.logger.error(ex);
-                this.iterateListeners((l) => l.error?.(ex));
-            }
-        }
-    }
-}
-
 var WebsocketDuplexConnection = {};
 
 var hasRequiredWebsocketDuplexConnection;
@@ -11085,8 +10821,199 @@ 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 pendingInjectedEvents = [];
+    const consumeWaiter = () => {
+        const pending = waiter;
+        waiter = undefined;
+        return pending;
+    };
+    const fetchFromSource = () => {
+        const resolveWaiter = (propagate) => {
+            const active = consumeWaiter();
+            if (active) {
+                propagate(active);
+            }
+            else {
+                pendingSourceEvent = propagate;
+            }
+        };
+        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 };
+                return 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;
 const SYNC_QUEUE_REQUEST_LOW_WATER = 5;
 // Keep alive message is sent every period
 const KEEP_ALIVE_MS = 20_000;
@@ -11266,73 +11193,67 @@ class AbstractRemote {
         return new WebSocket(url);
     }
     /**
-     * Returns a data stream of sync line data.
+     * Returns a data stream of sync line data, fetched via RSocket-over-WebSocket.
      *
-     * @param map Maps received payload frames to the typed event value.
-     * @param bson A BSON encoder and decoder. When set, the data stream will be requested with a BSON payload
-     * (required for compatibility with older sync services).
+     * The only mechanism to abort the returned stream is to use the abort signal in {@link SocketSyncStreamOptions}.
      */
-    async socketStreamRaw(options, map, bson) {
+    async socketStreamRaw(options) {
         const { path, fetchStrategy = exports.FetchStrategy.Buffered } = options;
-        const mimeType = bson == null ? 'application/json' : 'application/bson';
+        const mimeType = 'application/json';
         function toBuffer(js) {
-            let contents;
-            if (bson != null) {
-                contents = bson.serialize(js);
-            }
-            else {
-                contents = JSON.stringify(js);
-            }
-            return bufferExports.Buffer.from(contents);
+            return bufferExports.Buffer.from(JSON.stringify(js));
         }
         const syncQueueRequestSize = fetchStrategy == exports.FetchStrategy.Buffered ? 10 : 1;
         const request = await this.buildRequest(path);
+        const url = this.options.socketUrlTransformer(request.url);
         // Add the user agent in the setup payload - we can't set custom
         // headers with websockets on web. The browser userAgent is however added
         // automatically as a header.
         const userAgent = this.getUserAgent();
-        const stream = new DataStream({
-            logger: this.logger,
-            pressure: {
-                lowWaterMark: SYNC_QUEUE_REQUEST_LOW_WATER
-            },
-            mapLine: map
-        });
+        // While we're connecting (a process that can't be aborted in RSocket), the WebSocket instance to close if we wanted
+        // to abort the connection.
+        let pendingSocket = null;
+        let keepAliveTimeout;
+        let rsocket = null;
+        let queue = null;
+        let didClose = false;
+        const abortRequest = () => {
+            if (didClose) {
+                return;
+            }
+            didClose = true;
+            clearTimeout(keepAliveTimeout);
+            if (pendingSocket) {
+                pendingSocket.close();
+            }
+            if (rsocket) {
+                rsocket.close();
+            }
+            if (queue) {
+                queue.stop();
+            }
+        };
         // Handle upstream abort
-        if (options.abortSignal?.aborted) {
+        if (options.abortSignal.aborted) {
             throw new AbortOperation('Connection request aborted');
         }
         else {
-            options.abortSignal?.addEventListener('abort', () => {
-                stream.close();
-            }, { once: true });
+            options.abortSignal.addEventListener('abort', abortRequest);
         }
-        let keepAliveTimeout;
         const resetTimeout = () => {
             clearTimeout(keepAliveTimeout);
             keepAliveTimeout = setTimeout(() => {
                 this.logger.error(`No data received on WebSocket in ${SOCKET_TIMEOUT_MS}ms, closing connection.`);
-                stream.close();
+                abortRequest();
             }, SOCKET_TIMEOUT_MS);
         };
         resetTimeout();
-        // Typescript complains about this being `never` if it's not assigned here.
-        // This is assigned in `wsCreator`.
-        let disposeSocketConnectionTimeout = () => { };
-        const url = this.options.socketUrlTransformer(request.url);
         const connector = new distExports.RSocketConnector({
             transport: new WebsocketClientTransport({
                 url,
                 wsCreator: (url) => {
-                    const socket = this.createSocket(url);
-                    disposeSocketConnectionTimeout = stream.registerListener({
-                        closed: () => {
-                            // Allow closing the underlying WebSocket if the stream was closed before the
-                            // RSocket connect completed. This should effectively abort the request.
-                            socket.close();
-                        }
-                    });
-                    socket.addEventListener('message', (event) => {
+                    const socket = (pendingSocket = this.createSocket(url));
+                    socket.addEventListener('message', () => {
                         resetTimeout();
                     });
                     return socket;
@@ -11352,43 +11273,40 @@ class AbstractRemote {
                 }
             }
         });
-        let rsocket;
         try {
             rsocket = await connector.connect();
             // The connection is established, we no longer need to monitor the initial timeout
-            disposeSocketConnectionTimeout();
+            pendingSocket = null;
         }
         catch (ex) {
             this.logger.error(`Failed to connect WebSocket`, ex);
-            clearTimeout(keepAliveTimeout);
-            if (!stream.closed) {
-                await stream.close();
-            }
+            abortRequest();
             throw ex;
         }
         resetTimeout();
-        let socketIsClosed = false;
-        const closeSocket = () => {
-            clearTimeout(keepAliveTimeout);
-            if (socketIsClosed) {
-                return;
-            }
-            socketIsClosed = true;
-            rsocket.close();
-        };
         // Helps to prevent double close scenarios
-        rsocket.onClose(() => (socketIsClosed = true));
-        // We initially request this amount and expect these to arrive eventually
-        let pendingEventsCount = syncQueueRequestSize;
-        const disposeClosedListener = stream.registerListener({
-            closed: () => {
-                closeSocket();
-                disposeClosedListener();
-            }
-        });
-        const socket = await new Promise((resolve, reject) => {
+        rsocket.onClose(() => (rsocket = null));
+        return await new Promise((resolve, reject) => {
             let connectionEstablished = false;
-            const res = rsocket.requestStream({
+            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 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({
                     path
@@ -11413,7 +11331,7 @@ class AbstractRemote {
                     }
                     // RSocket will close the RSocket stream automatically
                     // Close the downstream stream as well - this will close the RSocket connection and WebSocket
-                    stream.close();
+                    abortRequest();
                     // Handles cases where the connection failed e.g. auth error or connection error
                     if (!connectionEstablished) {
                         reject(e);
@@ -11423,41 +11341,40 @@ class AbstractRemote {
                     // The connection is active
                     if (!connectionEstablished) {
                         connectionEstablished = true;
-                        resolve(res);
+                        resolve(events);
                     }
                     const { data } = payload;
+                    if (data) {
+                        queue.push(data);
+                    }
                     // Less events are now pending
                     pendingEventsCount--;
-                    if (!data) {
-                        return;
-                    }
-                    stream.enqueueData(data);
+                    // Request another event (unless the downstream consumer is paused).
+                    requestMore();
                 },
                 onComplete: () => {
-                    stream.close();
+                    abortRequest(); // this will also emit a done event
                 },
                 onExtension: () => { }
             });
         });
-        const l = stream.registerListener({
-            lowWater: async () => {
-                // Request to fill up the queue
-                const required = syncQueueRequestSize - pendingEventsCount;
-                if (required > 0) {
-                    socket.request(syncQueueRequestSize - pendingEventsCount);
-                    pendingEventsCount = syncQueueRequestSize;
-                }
-            },
-            closed: () => {
-                l();
-            }
-        });
-        return stream;
     }
     /**
-     * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
+     * @returns Whether the HTTP implementation on this platform can receive streamed binary responses. This is true on
+     * all platforms except React Native (who would have guessed...), where we must not request BSON responses.
+     *
+     * @see https://github.com/react-native-community/fetch?tab=readme-ov-file#motivation
+     */
+    get supportsStreamingBinaryResponses() {
+        return true;
+    }
+    /**
+     * Posts a `/sync/stream` request, asserts that it completes successfully and returns the streaming response as an
+     * async iterator of byte blobs.
+     *
+     * To cancel the async iterator, use the abort signal from {@link SyncStreamOptions} passed to this method.
      */
-    async postStreamRaw(options, mapLine) {
+    async fetchStreamRaw(options) {
         const { data, path, headers, abortSignal } = options;
         const request = await this.buildRequest(path);
         /**
@@ -11469,119 +11386,94 @@ class AbstractRemote {
          *  Aborting the active fetch request while it is being consumed seems to throw
          *  an unhandled exception on the window level.
          */
-        if (abortSignal?.aborted) {
-            throw new AbortOperation('Abort request received before making postStreamRaw request');
+        if (abortSignal.aborted) {
+            throw new AbortOperation('Abort request received before making fetchStreamRaw request');
         }
         const controller = new AbortController();
-        let requestResolved = false;
-        abortSignal?.addEventListener('abort', () => {
-            if (!requestResolved) {
+        let reader = null;
+        abortSignal.addEventListener('abort', () => {
+            const reason = abortSignal.reason ??
+                new AbortOperation('Cancelling network request before it resolves. Abort signal has been received.');
+            if (reader == null) {
                 // Only abort via the abort controller if the request has not resolved yet
-                controller.abort(abortSignal.reason ??
-                    new AbortOperation('Cancelling network request before it resolves. Abort signal has been received.'));
+                controller.abort(reason);
+            }
+            else {
+                reader.cancel(reason).catch(() => {
+                    // Cancelling the reader might rethrow an exception we would have handled by throwing in next(). So we can
+                    // ignore it here.
+                });
             }
         });
-        const res = await this.fetch(request.url, {
-            method: 'POST',
-            headers: { ...headers, ...request.headers },
-            body: JSON.stringify(data),
-            signal: controller.signal,
-            cache: 'no-store',
-            ...(this.options.fetchOptions ?? {}),
-            ...options.fetchOptions
-        }).catch((ex) => {
+        let res;
+        let responseIsBson = false;
+        try {
+            const ndJson = 'application/x-ndjson';
+            const bson = 'application/vnd.powersync.bson-stream';
+            res = await this.fetch(request.url, {
+                method: 'POST',
+                headers: {
+                    ...headers,
+                    ...request.headers,
+                    accept: this.supportsStreamingBinaryResponses ? `${bson};q=0.9,${ndJson};q=0.8` : ndJson
+                },
+                body: JSON.stringify(data),
+                signal: controller.signal,
+                cache: 'no-store',
+                ...(this.options.fetchOptions ?? {}),
+                ...options.fetchOptions
+            });
+            if (!res.ok || !res.body) {
+                const text = await res.text();
+                this.logger.error(`Could not POST streaming to ${path} - ${res.status} - ${res.statusText}: ${text}`);
+                const error = new Error(`HTTP ${res.statusText}: ${text}`);
+                error.status = res.status;
+                throw error;
+            }
+            const contentType = res.headers.get('content-type');
+            responseIsBson = contentType == bson;
+        }
+        catch (ex) {
             if (ex.name == 'AbortError') {
                 throw new AbortOperation(`Pending fetch request to ${request.url} has been aborted.`);
             }
             throw ex;
-        });
-        if (!res) {
-            throw new Error('Fetch request was aborted');
-        }
-        requestResolved = true;
-        if (!res.ok || !res.body) {
-            const text = await res.text();
-            this.logger.error(`Could not POST streaming to ${path} - ${res.status} - ${res.statusText}: ${text}`);
-            const error = new Error(`HTTP ${res.statusText}: ${text}`);
-            error.status = res.status;
-            throw error;
         }
-        // Create a new stream splitting the response at line endings while also handling cancellations
-        // by closing the reader.
-        const reader = res.body.getReader();
-        let readerReleased = false;
-        // This will close the network request and read stream
-        const closeReader = async () => {
-            try {
-                readerReleased = true;
-                await reader.cancel();
-            }
-            catch (ex) {
-                // an error will throw if the reader hasn't been used yet
-            }
-            reader.releaseLock();
-        };
-        const stream = new DataStream({
-            logger: this.logger,
-            mapLine: mapLine,
-            pressure: {
-                highWaterMark: 20,
-                lowWaterMark: 10
-            }
-        });
-        abortSignal?.addEventListener('abort', () => {
-            closeReader();
-            stream.close();
-        });
-        const decoder = this.createTextDecoder();
-        let buffer = '';
-        const consumeStream = async () => {
-            while (!stream.closed && !abortSignal?.aborted && !readerReleased) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    const remaining = buffer.trim();
-                    if (remaining.length != 0) {
-                        stream.enqueueData(remaining);
-                    }
-                    stream.close();
-                    await closeReader();
-                    return;
+        reader = res.body.getReader();
+        const stream = {
+            next: async () => {
+                if (controller.signal.aborted) {
+                    return doneResult;
                 }
-                const data = decoder.decode(value, { stream: true });
-                buffer += data;
-                const lines = buffer.split('\n');
-                for (var i = 0; i < lines.length - 1; i++) {
-                    var l = lines[i].trim();
-                    if (l.length > 0) {
-                        stream.enqueueData(l);
-                    }
+                try {
+                    return await reader.read();
                 }
-                buffer = lines[lines.length - 1];
-                // Implement backpressure by waiting for the low water mark to be reached
-                if (stream.dataQueue.length > stream.highWatermark) {
-                    await new Promise((resolve) => {
-                        const dispose = stream.registerListener({
-                            lowWater: async () => {
-                                resolve();
-                                dispose();
-                            },
-                            closed: () => {
-                                resolve();
-                                dispose();
-                            }
-                        });
-                    });
+                catch (ex) {
+                    if (controller.signal.aborted) {
+                        // .read() completes with an error if we cancel the reader, which we do to disconnect. So this is just
+                        // things working as intended, we can return a done event and consider the exception handled.
+                        return doneResult;
+                    }
+                    throw ex;
                 }
             }
         };
-        consumeStream().catch(ex => this.logger.error('Error consuming stream', ex));
-        const l = stream.registerListener({
-            closed: () => {
-                closeReader();
-                l?.();
-            }
-        });
-        return stream;
+        return { isBson: responseIsBson, stream };
+    }
+    /**
+     * 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.
+     */
+    async fetchStream(options) {
+        const { isBson, stream } = await this.fetchStreamRaw(options);
+        if (isBson) {
+            return extractBsonObjects(stream);
+        }
+        else {
+            return extractJsonLines(stream, this.createTextDecoder());
+        }
     }
 }
 
@@ -11610,31 +11502,8 @@ function coreStatusToJs(status) {
         priorityStatusEntries: status.priority_status.map(priorityToJs)
     };
 }
-
-function isStreamingSyncData(line) {
-    return line.data != null;
-}
-function isStreamingKeepalive(line) {
-    return line.token_expires_in != null;
-}
-function isStreamingSyncCheckpoint(line) {
-    return line.checkpoint != null;
-}
-function isStreamingSyncCheckpointComplete(line) {
-    return line.checkpoint_complete != null;
-}
-function isStreamingSyncCheckpointPartiallyComplete(line) {
-    return line.partial_checkpoint_complete != null;
-}
-function isStreamingSyncCheckpointDiff(line) {
-    return line.checkpoint_diff != null;
-}
-function isContinueCheckpointRequest(request) {
-    return (Array.isArray(request.buckets) &&
-        typeof request.checkpoint_token == 'string');
-}
-function isSyncNewCheckpointRequest(request) {
-    return typeof request.request_checkpoint == 'object';
+function isInterruptingInstruction(instruction) {
+    return 'EstablishSyncStream' in instruction || 'CloseSyncStream' in instruction;
 }
 
 exports.LockType = void 0;
@@ -11649,35 +11518,21 @@ exports.SyncStreamConnectionMethod = void 0;
 })(exports.SyncStreamConnectionMethod || (exports.SyncStreamConnectionMethod = {}));
 exports.SyncClientImplementation = void 0;
 (function (SyncClientImplementation) {
-    /**
-     * Decodes and handles sync lines received from the sync service in JavaScript.
-     *
-     * This is the default option.
-     *
-     * @deprecated We recommend the {@link RUST} client implementation for all apps. If you have issues with
-     * the Rust client, please file an issue or reach out to us. The JavaScript client will be removed in a future
-     * version of the PowerSync SDK.
-     */
-    SyncClientImplementation["JAVASCRIPT"] = "js";
     /**
      * This implementation offloads the sync line decoding and handling into the PowerSync
      * core extension.
      *
-     * This option is more performant than the {@link JAVASCRIPT} client, enabled by default and the
-     * recommended client implementation for all apps.
+     * This is the only option, as an older JavaScript client implementation has been removed from the SDK.
      *
      * ## Compatibility warning
      *
      * The Rust sync client stores sync data in a format that is slightly different than the one used
-     * by the old {@link JAVASCRIPT} implementation. When adopting the {@link RUST} client on existing
-     * databases, the PowerSync SDK will migrate the format automatically.
-     * Further, the {@link JAVASCRIPT} client in recent versions of the PowerSync JS SDK (starting from
-     * the version introducing {@link RUST} as an option) also supports the new format, so you can switch
-     * back to {@link JAVASCRIPT} later.
+     * by the old JavaScript client. When adopting the {@link RUST} client on existing databases, the PowerSync SDK will
+     * migrate the format automatically.
      *
-     * __However__: Upgrading the SDK version, then adopting {@link RUST} as a sync client and later
-     * downgrading the SDK to an older version (necessarily using the JavaScript-based implementation then)
-     * can lead to sync issues.
+     * 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
+     * possible anymore. Problematic SDK versions have been released before 2025-06-09.
      */
     SyncClientImplementation["RUST"] = "rust";
 })(exports.SyncClientImplementation || (exports.SyncClientImplementation = {}));
@@ -11700,13 +11555,7 @@ const DEFAULT_STREAM_CONNECTION_OPTIONS = {
     serializedSchema: undefined,
     includeDefaultStreams: true
 };
-// The priority we assume when we receive checkpoint lines where no priority is set.
-// This is the default priority used by the sync service, but can be set to an arbitrary
-// value since sync services without priorities also won't send partial sync completion
-// messages.
-const FALLBACK_PRIORITY = 3;
 class AbstractStreamingSyncImplementation extends BaseObserver {
-    _lastSyncedAt;
     options;
     abortController;
     // In rare cases, mostly for tests, uploads can be triggered without being properly connected.
@@ -11716,6 +11565,7 @@ class AbstractStreamingSyncImplementation extends BaseObserver {
     streamingSyncPromise;
     logger;
     activeStreams;
+    connectionMayHaveChanged = false;
     isUploadingCrud = false;
     notifyCompletedUploads;
     handleActiveStreamsChange;
@@ -11795,9 +11645,6 @@ class AbstractStreamingSyncImplementation extends BaseObserver {
         this.crudUpdateListener = undefined;
         this.uploadAbortController?.abort();
     }
-    async hasCompletedSync() {
-        return this.options.adapter.hasCompletedSync();
-    }
     async getWriteCheckpoint() {
         const clientId = await this.options.adapter.getClientId();
         let path = `/write-checkpoint2.json?client_id=${clientId}`;
@@ -11879,7 +11726,7 @@ The next upload iteration will be delayed.`);
                         });
                     }
                 }
-                this.uploadAbortController = null;
+                this.uploadAbortController = undefined;
             }
         });
     }
@@ -11995,6 +11842,11 @@ The next upload iteration will be delayed.`);
                     shouldDelayRetry = false;
                     // A disconnect was requested, we should not delay since there is no explicit retry
                 }
+                else if (this.connectionMayHaveChanged && ex.message?.indexOf('No iteration is active') >= 0) {
+                    this.connectionMayHaveChanged = false;
+                    this.logger.info('Sync error after changed connection, retrying immediately');
+                    shouldDelayRetry = false;
+                }
                 else {
                     this.logger.error(ex);
                 }
@@ -12025,17 +11877,14 @@ The next upload iteration will be delayed.`);
         // Mark as disconnected if here
         this.updateSyncStatus({ connected: false, connecting: false });
     }
-    async collectLocalBucketState() {
-        const bucketEntries = await this.options.adapter.getBucketStates();
-        const req = bucketEntries.map((entry) => ({
-            name: entry.bucket,
-            after: entry.op_id
-        }));
-        const localDescriptions = new Map();
-        for (const entry of bucketEntries) {
-            localDescriptions.set(entry.bucket, null);
-        }
-        return [req, localDescriptions];
+    markConnectionMayHaveChanged() {
+        // By setting this field, we'll immediately retry if the next sync event causes an error triggered by us not having
+        // an active sync iteration on the connection in use.
+        this.connectionMayHaveChanged = true;
+        // This triggers a `powersync_control` invocation if a sync iteration is currently active. This is a cheap call to
+        // make when no subscriptions have actually changed, we're mainly interested in this immediately throwing if no
+        // iteration is active. That allows us to reconnect ASAP, instead of having to wait for the next sync line.
+        this.handleActiveStreamsChange?.();
     }
     /**
      * Older versions of the JS SDK used to encode subkeys as JSON in {@link OplogEntry.toJSON}.
@@ -12076,344 +11925,98 @@ The next upload iteration will be delayed.`);
                 if (invalidMetadata.length > 0) {
                     throw new Error(`Invalid appMetadata provided. Only string values are allowed. Invalid values: ${invalidMetadata.map(([key, value]) => `${key}: ${value}`).join(', ')}`);
                 }
-                const clientImplementation = resolvedOptions.clientImplementation;
-                this.updateSyncStatus({ clientImplementation });
-                if (clientImplementation == exports.SyncClientImplementation.JAVASCRIPT) {
-                    await this.legacyStreamingSyncIteration(signal, resolvedOptions);
-                    return null;
-                }
-                else {
-                    await this.requireKeyFormat(true);
-                    return await this.rustSyncIteration(signal, resolvedOptions);
-                }
+                await this.requireKeyFormat(true);
+                return await this.rustSyncIteration(signal, resolvedOptions);
             }
         });
     }
-    async legacyStreamingSyncIteration(signal, resolvedOptions) {
-        const rawTables = resolvedOptions.serializedSchema?.raw_tables;
-        if (rawTables != null && rawTables.length) {
-            this.logger.warn('Raw tables require the Rust-based sync client. The JS client will ignore them.');
-        }
-        if (this.activeStreams.length) {
-            this.logger.error('Sync streams require `clientImplementation: SyncClientImplementation.RUST` when connecting.');
-        }
-        this.logger.debug('Streaming sync iteration started');
-        this.options.adapter.startSession();
-        let [req, bucketMap] = await this.collectLocalBucketState();
-        let targetCheckpoint = null;
-        // A checkpoint that has been validated but not applied (e.g. due to pending local writes)
-        let pendingValidatedCheckpoint = null;
-        const clientId = await this.options.adapter.getClientId();
-        const usingFixedKeyFormat = await this.requireKeyFormat(false);
-        this.logger.debug('Requesting stream from server');
-        const syncOptions = {
-            path: '/sync/stream',
-            abortSignal: signal,
-            data: {
-                buckets: req,
-                include_checksum: true,
-                raw_data: true,
-                parameters: resolvedOptions.params,
-                app_metadata: resolvedOptions.appMetadata,
-                client_id: clientId
+    receiveSyncLines(data) {
+        const { options, connection } = data;
+        const remote = this.options.remote;
+        const openInner = async () => {
+            if (connection.connectionMethod == exports.SyncStreamConnectionMethod.HTTP) {
+                return await remote.fetchStream(options);
             }
-        };
-        let stream;
-        if (resolvedOptions?.connectionMethod == exports.SyncStreamConnectionMethod.HTTP) {
-            stream = await this.options.remote.postStreamRaw(syncOptions, (line) => {
-                if (typeof line == 'string') {
-                    return JSON.parse(line);
-                }
-                else {
-                    // Directly enqueued by us
-                    return line;
-                }
-            });
-        }
-        else {
-            const bson = await this.options.remote.getBSON();
-            stream = await this.options.remote.socketStreamRaw({
-                ...syncOptions,
-                ...{ fetchStrategy: resolvedOptions.fetchStrategy }
-            }, (payload) => {
-                if (payload instanceof Uint8Array) {
-                    return bson.deserialize(payload);
-                }
-                else {
-                    // Directly enqueued by us
-                    return payload;
-                }
-            }, bson);
-        }
-        this.logger.debug('Stream established. Processing events');
-        this.notifyCompletedUploads = () => {
-            if (!stream.closed) {
-                stream.enqueueData({ crud_upload_completed: null });
+            else {
+                return await this.options.remote.socketStreamRaw({
+                    ...options,
+                    ...{ fetchStrategy: connection.fetchStrategy }
+                });
             }
         };
-        while (!stream.closed) {
-            const line = await stream.read();
-            if (!line) {
-                // The stream has closed while waiting
-                return;
-            }
-            if ('crud_upload_completed' in line) {
-                if (pendingValidatedCheckpoint != null) {
-                    const { applied, endIteration } = await this.applyCheckpoint(pendingValidatedCheckpoint);
-                    if (applied) {
-                        pendingValidatedCheckpoint = null;
-                    }
-                    else if (endIteration) {
-                        break;
-                    }
+        let inner;
+        let done = false;
+        return {
+            async next() {
+                if (done) {
+                    return doneResult;
                 }
-                continue;
-            }
-            // A connection is active and messages are being received
-            if (!this.syncStatus.connected) {
-                // There is a connection now
-                Promise.resolve().then(() => this.triggerCrudUpload());
-                this.updateSyncStatus({
-                    connected: true
-                });
-            }
-            if (isStreamingSyncCheckpoint(line)) {
-                targetCheckpoint = line.checkpoint;
-                // New checkpoint - existing validated checkpoint is no longer valid
-                pendingValidatedCheckpoint = null;
-                const bucketsToDelete = new Set(bucketMap.keys());
-                const newBuckets = new Map();
-                for (const checksum of line.checkpoint.buckets) {
-                    newBuckets.set(checksum.bucket, {
-                        name: checksum.bucket,
-                        priority: checksum.priority ?? FALLBACK_PRIORITY
+                else if (inner == null) {
+                    inner = await openInner();
+                    // We're connected here, so we can tell the core extension about it.
+                    return valueResult({
+                        command: exports.PowerSyncControlCommand.CONNECTION_STATE,
+                        payload: 'established'
                     });
-                    bucketsToDelete.delete(checksum.bucket);
-                }
-                if (bucketsToDelete.size > 0) {
-                    this.logger.debug('Removing buckets', [...bucketsToDelete]);
-                }
-                bucketMap = newBuckets;
-                await this.options.adapter.removeBuckets([...bucketsToDelete]);
-                await this.options.adapter.setTargetCheckpoint(targetCheckpoint);
-                await this.updateSyncStatusForStartingCheckpoint(targetCheckpoint);
-            }
-            else if (isStreamingSyncCheckpointComplete(line)) {
-                const result = await this.applyCheckpoint(targetCheckpoint);
-                if (result.endIteration) {
-                    return;
-                }
-                else if (!result.applied) {
-                    // "Could not apply checkpoint due to local data". We need to retry after
-                    // finishing uploads.
-                    pendingValidatedCheckpoint = targetCheckpoint;
-                }
-                else {
-                    // Nothing to retry later. This would likely already be null from the last
-                    // checksum or checksum_diff operation, but we make sure.
-                    pendingValidatedCheckpoint = null;
                 }
-            }
-            else if (isStreamingSyncCheckpointPartiallyComplete(line)) {
-                const priority = line.partial_checkpoint_complete.priority;
-                this.logger.debug('Partial checkpoint complete', priority);
-                const result = await this.options.adapter.syncLocalDatabase(targetCheckpoint, priority);
-                if (!result.checkpointValid) {
-                    // This means checksums failed. Start again with a new checkpoint.
-                    // TODO: better back-off
-                    await new Promise((resolve) => setTimeout(resolve, 50));
-                    return;
-                }
-                else if (!result.ready) ;
                 else {
-                    // We'll keep on downloading, but can report that this priority is synced now.
-                    this.logger.debug('partial checkpoint validation succeeded');
-                    // All states with a higher priority can be deleted since this partial sync includes them.
-                    const priorityStates = this.syncStatus.priorityStatusEntries.filter((s) => s.priority <= priority);
-                    priorityStates.push({
-                        priority,
-                        lastSyncedAt: new Date(),
-                        hasSynced: true
-                    });
-                    this.updateSyncStatus({
-                        connected: true,
-                        priorityStatusEntries: priorityStates
-                    });
-                }
-            }
-            else if (isStreamingSyncCheckpointDiff(line)) {
-                // TODO: It may be faster to just keep track of the diff, instead of the entire checkpoint
-                if (targetCheckpoint == null) {
-                    throw new Error('Checkpoint diff without previous checkpoint');
-                }
-                // New checkpoint - existing validated checkpoint is no longer valid
-                pendingValidatedCheckpoint = null;
-                const diff = line.checkpoint_diff;
-                const newBuckets = new Map();
-                for (const checksum of targetCheckpoint.buckets) {
-                    newBuckets.set(checksum.bucket, checksum);
-                }
-                for (const checksum of diff.updated_buckets) {
-                    newBuckets.set(checksum.bucket, checksum);
-                }
-                for (const bucket of diff.removed_buckets) {
-                    newBuckets.delete(bucket);
-                }
-                const newCheckpoint = {
-                    last_op_id: diff.last_op_id,
-                    buckets: [...newBuckets.values()],
-                    write_checkpoint: diff.write_checkpoint
-                };
-                targetCheckpoint = newCheckpoint;
-                await this.updateSyncStatusForStartingCheckpoint(targetCheckpoint);
-                bucketMap = new Map();
-                newBuckets.forEach((checksum, name) => bucketMap.set(name, {
-                    name: checksum.bucket,
-                    priority: checksum.priority ?? FALLBACK_PRIORITY
-                }));
-                const bucketsToDelete = diff.removed_buckets;
-                if (bucketsToDelete.length > 0) {
-                    this.logger.debug('Remove buckets', bucketsToDelete);
-                }
-                await this.options.adapter.removeBuckets(bucketsToDelete);
-                await this.options.adapter.setTargetCheckpoint(targetCheckpoint);
-            }
-            else if (isStreamingSyncData(line)) {
-                const { data } = line;
-                const previousProgress = this.syncStatus.dataFlowStatus.downloadProgress;
-                let updatedProgress = null;
-                if (previousProgress) {
-                    updatedProgress = { ...previousProgress };
-                    const progressForBucket = updatedProgress[data.bucket];
-                    if (progressForBucket) {
-                        updatedProgress[data.bucket] = {
-                            ...progressForBucket,
-                            since_last: progressForBucket.since_last + data.data.length
-                        };
+                    const event = await inner.next();
+                    if (event.done) {
+                        done = true;
+                        return valueResult({ command: exports.PowerSyncControlCommand.CONNECTION_STATE, payload: 'end' });
                     }
-                }
-                this.updateSyncStatus({
-                    dataFlow: {
-                        downloading: true,
-                        downloadProgress: updatedProgress
+                    else {
+                        return valueResult({
+                            command: typeof event.value == 'string'
+                                ? exports.PowerSyncControlCommand.PROCESS_TEXT_LINE
+                                : exports.PowerSyncControlCommand.PROCESS_BSON_LINE,
+                            payload: event.value
+                        });
                     }
-                });
-                await this.options.adapter.saveSyncData({ buckets: [SyncDataBucket.fromRow(data)] }, usingFixedKeyFormat);
-            }
-            else if (isStreamingKeepalive(line)) {
-                const remaining_seconds = line.token_expires_in;
-                if (remaining_seconds == 0) {
-                    // Connection would be closed automatically right after this
-                    this.logger.debug('Token expiring; reconnect');
-                    /**
-                     * For a rare case where the backend connector does not update the token
-                     * (uses the same one), this should have some delay.
-                     */
-                    await this.delayRetry();
-                    return;
-                }
-                else if (remaining_seconds < 30) {
-                    this.logger.debug('Token will expire soon; reconnect');
-                    // Pre-emptively refresh the token
-                    this.options.remote.invalidateCredentials();
-                    return;
                 }
-                this.triggerCrudUpload();
             }
-            else {
-                this.logger.debug('Received unknown sync line', line);
-            }
-        }
-        this.logger.debug('Stream input empty');
-        // Connection closed. Likely due to auth issue.
-        return;
+        };
     }
     async rustSyncIteration(signal, resolvedOptions) {
         const syncImplementation = this;
         const adapter = this.options.adapter;
         const remote = this.options.remote;
-        let receivingLines = null;
-        let hadSyncLine = false;
         let hideDisconnectOnRestart = false;
+        let notifyTokenRefreshed;
         if (signal.aborted) {
             throw new AbortOperation('Connection request has been aborted');
         }
-        const abortController = new AbortController();
-        signal.addEventListener('abort', () => abortController.abort());
-        // Pending sync lines received from the service, as well as local events that trigger a powersync_control
-        // invocation (local events include refreshed tokens and completed uploads).
-        // This is a single data stream so that we can handle all control calls from a single place.
-        let controlInvocations = null;
-        async function connect(instr) {
-            const syncOptions = {
-                path: '/sync/stream',
-                abortSignal: abortController.signal,
-                data: instr.request
+        function startCommand() {
+            const options = {
+                parameters: resolvedOptions.params,
+                app_metadata: resolvedOptions.appMetadata,
+                active_streams: syncImplementation.activeStreams,
+                include_defaults: resolvedOptions.includeDefaultStreams
             };
-            if (resolvedOptions.connectionMethod == exports.SyncStreamConnectionMethod.HTTP) {
-                controlInvocations = await remote.postStreamRaw(syncOptions, (line) => {
-                    if (typeof line == 'string') {
-                        return {
-                            command: exports.PowerSyncControlCommand.PROCESS_TEXT_LINE,
-                            payload: line
-                        };
-                    }
-                    else {
-                        // Directly enqueued by us
-                        return line;
-                    }
-                });
-            }
-            else {
-                controlInvocations = await remote.socketStreamRaw({
-                    ...syncOptions,
-                    fetchStrategy: resolvedOptions.fetchStrategy
-                }, (payload) => {
-                    if (payload instanceof Uint8Array) {
-                        return {
-                            command: exports.PowerSyncControlCommand.PROCESS_BSON_LINE,
-                            payload: payload
-                        };
-                    }
-                    else {
-                        // Directly enqueued by us
-                        return payload;
-                    }
-                });
-            }
-            // The rust client will set connected: true after the first sync line because that's when it gets invoked, but
-            // we're already connected here and can report that.
-            syncImplementation.updateSyncStatus({ connected: true });
-            try {
-                while (!controlInvocations.closed) {
-                    const line = await controlInvocations.read();
-                    if (line == null) {
-                        return;
-                    }
-                    await control(line.command, line.payload);
-                    if (!hadSyncLine) {
-                        syncImplementation.triggerCrudUpload();
-                        hadSyncLine = true;
-                    }
-                }
-            }
-            finally {
-                const activeInstructions = controlInvocations;
-                // We concurrently add events to the active data stream when e.g. a CRUD upload is completed or a token is
-                // refreshed. That would throw after closing (and we can't handle those events either way), so set this back
-                // to null.
-                controlInvocations = null;
-                await activeInstructions.close();
+            if (resolvedOptions.serializedSchema) {
+                options.schema = resolvedOptions.serializedSchema;
             }
+            return invokePowerSyncControl(exports.PowerSyncControlCommand.START, JSON.stringify(options));
         }
         async function stop() {
-            await control(exports.PowerSyncControlCommand.STOP);
+            const instructions = await invokePowerSyncControl(exports.PowerSyncControlCommand.STOP);
+            for (const instruction of instructions) {
+                // We don't need to handle interrupting instructions since we're unconditionally ending the sync iteration at
+                // this point.
+                if (isInterruptingInstruction(instruction))
+                    continue;
+                await handleInstruction(instruction);
+            }
         }
-        async function control(op, payload) {
+        async function invokePowerSyncControl(op, payload) {
             const rawResponse = await adapter.control(op, payload ?? null);
             const logger = syncImplementation.logger;
             logger.trace('powersync_control', op, payload == null || typeof payload == 'string' ? payload : '<bytes>', rawResponse);
-            await handleInstructions(JSON.parse(rawResponse));
+            if (op != exports.PowerSyncControlCommand.STOP) {
+                // Evidently we have a working connection here, otherwise powersync_control would have failed.
+                syncImplementation.connectionMayHaveChanged = false;
+            }
+            return JSON.parse(rawResponse);
         }
         async function handleInstruction(instruction) {
             if ('LogLine' in instruction) {
@@ -12432,13 +12035,6 @@ The next upload iteration will be delayed.`);
             else if ('UpdateSyncStatus' in instruction) {
                 syncImplementation.updateSyncStatus(coreStatusToJs(instruction.UpdateSyncStatus.status));
             }
-            else if ('EstablishSyncStream' in instruction) {
-                if (receivingLines != null) {
-                    // Already connected, this shouldn't happen during a single iteration.
-                    throw 'Unexpected request to establish sync stream, already connected';
-                }
-                receivingLines = connect(instruction.EstablishSyncStream);
-            }
             else if ('FetchCredentials' in instruction) {
                 if (instruction.FetchCredentials.did_expire) {
                     remote.invalidateCredentials();
@@ -12447,16 +12043,12 @@ The next upload iteration will be delayed.`);
                     remote.invalidateCredentials();
                     // Restart iteration after the credentials have been refreshed.
                     remote.fetchCredentials().then((_) => {
-                        controlInvocations?.enqueueData({ command: exports.PowerSyncControlCommand.NOTIFY_TOKEN_REFRESHED });
+                        notifyTokenRefreshed?.();
                     }, (err) => {
                         syncImplementation.logger.warn('Could not prefetch credentials', err);
                     });
                 }
             }
-            else if ('CloseSyncStream' in instruction) {
-                abortController.abort();
-                hideDisconnectOnRestart = instruction.CloseSyncStream.hide_disconnect;
-            }
             else if ('FlushFileSystem' in instruction) ;
             else if ('DidCompleteSync' in instruction) {
                 syncImplementation.updateSyncStatus({
@@ -12466,105 +12058,83 @@ The next upload iteration will be delayed.`);
                 });
             }
         }
-        async function handleInstructions(instructions) {
-            for (const instr of instructions) {
-                await handleInstruction(instr);
-            }
-        }
         try {
-            const options = {
-                parameters: resolvedOptions.params,
-                app_metadata: resolvedOptions.appMetadata,
-                active_streams: this.activeStreams,
-                include_defaults: resolvedOptions.includeDefaultStreams
-            };
-            if (resolvedOptions.serializedSchema) {
-                options.schema = resolvedOptions.serializedSchema;
+            const defaultResult = { immediateRestart: false };
+            // Pending sync lines received from the service, as well as local events that trigger a powersync_control
+            // invocation (local events include refreshed tokens and completed uploads).
+            // This is a single data stream so that we can handle all control calls from a single place.
+            let controlInvocations = null;
+            for (const startInstruction of await startCommand()) {
+                if ('EstablishSyncStream' in startInstruction) {
+                    const syncOptions = {
+                        path: '/sync/stream',
+                        abortSignal: signal,
+                        data: startInstruction.EstablishSyncStream.request
+                    };
+                    controlInvocations = injectable(syncImplementation.receiveSyncLines({
+                        options: syncOptions,
+                        connection: resolvedOptions
+                    }));
+                }
+                else if ('CloseSyncStream' in startInstruction) {
+                    return defaultResult;
+                }
+                else {
+                    await handleInstruction(startInstruction);
+                }
             }
-            await control(exports.PowerSyncControlCommand.START, JSON.stringify(options));
+            if (controlInvocations == null)
+                return defaultResult;
             this.notifyCompletedUploads = () => {
-                if (controlInvocations && !controlInvocations?.closed) {
-                    controlInvocations.enqueueData({ command: exports.PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
-                }
+                controlInvocations.inject({ command: exports.PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
             };
             this.handleActiveStreamsChange = () => {
-                if (controlInvocations && !controlInvocations?.closed) {
-                    controlInvocations.enqueueData({
-                        command: exports.PowerSyncControlCommand.UPDATE_SUBSCRIPTIONS,
-                        payload: JSON.stringify(this.activeStreams)
-                    });
-                }
+                controlInvocations.inject({
+                    command: exports.PowerSyncControlCommand.UPDATE_SUBSCRIPTIONS,
+                    payload: JSON.stringify(this.activeStreams)
+                });
             };
-            await receivingLines;
+            notifyTokenRefreshed = () => {
+                controlInvocations.inject({
+                    command: exports.PowerSyncControlCommand.NOTIFY_TOKEN_REFRESHED
+                });
+            };
+            let hadSyncLine = false;
+            loop: while (true) {
+                const { done, value } = await controlInvocations.next();
+                if (done)
+                    break;
+                if (!hadSyncLine) {
+                    // Trigger a local CRUD upload when the first sync line has been received, this allows uploading local changes
+                    // that have been made while offline or disconnected.
+                    if (value.command == exports.PowerSyncControlCommand.PROCESS_TEXT_LINE ||
+                        value.command == exports.PowerSyncControlCommand.PROCESS_BSON_LINE) {
+                        hadSyncLine = true;
+                        this.triggerCrudUpload?.();
+                    }
+                }
+                const instructions = await invokePowerSyncControl(value.command, value.payload);
+                for (const instruction of instructions) {
+                    if ('EstablishSyncStream' in instruction) {
+                        throw new Error('Received EstablishSyncStream while already connected.');
+                    }
+                    else if ('CloseSyncStream' in instruction) {
+                        hideDisconnectOnRestart = instruction.CloseSyncStream.hide_disconnect;
+                        break loop;
+                    }
+                    else {
+                        await handleInstruction(instruction);
+                    }
+                }
+            }
         }
         finally {
             this.notifyCompletedUploads = this.handleActiveStreamsChange = undefined;
+            notifyTokenRefreshed = undefined;
             await stop();
         }
         return { immediateRestart: hideDisconnectOnRestart };
     }
-    async updateSyncStatusForStartingCheckpoint(checkpoint) {
-        const localProgress = await this.options.adapter.getBucketOperationProgress();
-        const progress = {};
-        let invalidated = false;
-        for (const bucket of checkpoint.buckets) {
-            const savedProgress = localProgress[bucket.bucket];
-            const atLast = savedProgress?.atLast ?? 0;
-            const sinceLast = savedProgress?.sinceLast ?? 0;
-            progress[bucket.bucket] = {
-                // The fallback priority doesn't matter here, but 3 is the one newer versions of the sync service
-                // will use by default.
-                priority: bucket.priority ?? 3,
-                at_last: atLast,
-                since_last: sinceLast,
-                target_count: bucket.count ?? 0
-            };
-            if (bucket.count != null && bucket.count < atLast + sinceLast) {
-                // Either due to a defrag / sync rule deploy or a compaction operation, the size
-                // of the bucket shrank so much that the local ops exceed the ops in the updated
-                // bucket. We can't prossibly report progress in this case (it would overshoot 100%).
-                invalidated = true;
-            }
-        }
-        if (invalidated) {
-            for (const bucket in progress) {
-                const bucketProgress = progress[bucket];
-                bucketProgress.at_last = 0;
-                bucketProgress.since_last = 0;
-            }
-        }
-        this.updateSyncStatus({
-            dataFlow: {
-                downloading: true,
-                downloadProgress: progress
-            }
-        });
-    }
-    async applyCheckpoint(checkpoint) {
-        let result = await this.options.adapter.syncLocalDatabase(checkpoint);
-        if (!result.checkpointValid) {
-            this.logger.debug(`Checksum mismatch in checkpoint ${checkpoint.last_op_id}, will reconnect`);
-            // This means checksums failed. Start again with a new checkpoint.
-            // TODO: better back-off
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            return { applied: false, endIteration: true };
-        }
-        else if (!result.ready) {
-            this.logger.debug(`Could not apply checkpoint ${checkpoint.last_op_id} due to local data. We will retry applying the checkpoint after that upload is completed.`);
-            return { applied: false, endIteration: false };
-        }
-        this.logger.debug(`Applied checkpoint ${checkpoint.last_op_id}`, checkpoint);
-        this.updateSyncStatus({
-            connected: true,
-            lastSyncedAt: new Date(),
-            dataFlow: {
-                downloading: false,
-                downloadProgress: null,
-                downloadError: undefined
-            }
-        });
-        return { applied: true, endIteration: false };
-    }
     updateSyncStatus(options) {
         const updatedStatus = new SyncStatus({
             connected: options.connected ?? this.syncStatus.connected,
@@ -14103,14 +13673,12 @@ class SqliteBucketStorage extends BaseObserver {
     db;
     logger;
     tableNames;
-    _hasCompletedSync;
     updateListener;
     _clientId;
     constructor(db, logger = Logger.get('SqliteBucketStorage')) {
         super();
         this.db = db;
         this.logger = logger;
-        this._hasCompletedSync = false;
         this.tableNames = new Set();
         this.updateListener = db.registerListener({
             tablesUpdated: (update) => {
@@ -14122,7 +13690,6 @@ class SqliteBucketStorage extends BaseObserver {
         });
     }
     async init() {
-        this._hasCompletedSync = false;
         const existingTableRows = await this.db.getAll(`SELECT name FROM sqlite_master WHERE type='table' AND name GLOB 'ps_data_*'`);
         for (const row of existingTableRows ?? []) {
             this.tableNames.add(row.name);
@@ -14144,156 +13711,6 @@ class SqliteBucketStorage extends BaseObserver {
     getMaxOpId() {
         return MAX_OP_ID;
     }
-    /**
-     * Reset any caches.
-     */
-    startSession() { }
-    async getBucketStates() {
-        const result = await this.db.getAll("SELECT name as bucket, cast(last_op as TEXT) as op_id FROM ps_buckets WHERE pending_delete = 0 AND name != '$local'");
-        return result;
-    }
-    async getBucketOperationProgress() {
-        const rows = await this.db.getAll('SELECT name, count_at_last, count_since_last FROM ps_buckets');
-        return Object.fromEntries(rows.map((r) => [r.name, { atLast: r.count_at_last, sinceLast: r.count_since_last }]));
-    }
-    async saveSyncData(batch, fixedKeyFormat = false) {
-        await this.writeTransaction(async (tx) => {
-            for (const b of batch.buckets) {
-                await tx.execute('INSERT INTO powersync_operations(op, data) VALUES(?, ?)', [
-                    'save',
-                    JSON.stringify({ buckets: [b.toJSON(fixedKeyFormat)] })
-                ]);
-                this.logger.debug(`Saved batch of data for  bucket: ${b.bucket}, operations: ${b.data.length}`);
-            }
-        });
-    }
-    async removeBuckets(buckets) {
-        for (const bucket of buckets) {
-            await this.deleteBucket(bucket);
-        }
-    }
-    /**
-     * Mark a bucket for deletion.
-     */
-    async deleteBucket(bucket) {
-        await this.writeTransaction(async (tx) => {
-            await tx.execute('INSERT INTO powersync_operations(op, data) VALUES(?, ?)', ['delete_bucket', bucket]);
-        });
-        this.logger.debug(`Done deleting bucket ${bucket}`);
-    }
-    async hasCompletedSync() {
-        if (this._hasCompletedSync) {
-            return true;
-        }
-        const r = await this.db.get(`SELECT powersync_last_synced_at() as synced_at`);
-        const completed = r.synced_at != null;
-        if (completed) {
-            this._hasCompletedSync = true;
-        }
-        return completed;
-    }
-    async syncLocalDatabase(checkpoint, priority) {
-        const r = await this.validateChecksums(checkpoint, priority);
-        if (!r.checkpointValid) {
-            this.logger.error('Checksums failed for', r.checkpointFailures);
-            for (const b of r.checkpointFailures ?? []) {
-                await this.deleteBucket(b);
-            }
-            return { ready: false, checkpointValid: false, checkpointFailures: r.checkpointFailures };
-        }
-        if (priority == null) {
-            this.logger.debug(`Validated checksums checkpoint ${checkpoint.last_op_id}`);
-        }
-        else {
-            this.logger.debug(`Validated checksums for partial checkpoint ${checkpoint.last_op_id}, priority ${priority}`);
-        }
-        let buckets = checkpoint.buckets;
-        if (priority !== undefined) {
-            buckets = buckets.filter((b) => hasMatchingPriority(priority, b));
-        }
-        const bucketNames = buckets.map((b) => b.bucket);
-        await this.writeTransaction(async (tx) => {
-            await tx.execute(`UPDATE ps_buckets SET last_op = ? WHERE name IN (SELECT json_each.value FROM json_each(?))`, [
-                checkpoint.last_op_id,
-                JSON.stringify(bucketNames)
-            ]);
-            if (priority == null && checkpoint.write_checkpoint) {
-                await tx.execute("UPDATE ps_buckets SET last_op = ? WHERE name = '$local'", [checkpoint.write_checkpoint]);
-            }
-        });
-        const valid = await this.updateObjectsFromBuckets(checkpoint, priority);
-        if (!valid) {
-            return { ready: false, checkpointValid: true };
-        }
-        return {
-            ready: true,
-            checkpointValid: true
-        };
-    }
-    /**
-     * Atomically update the local state to the current checkpoint.
-     *
-     * This includes creating new tables, dropping old tables, and copying data over from the oplog.
-     */
-    async updateObjectsFromBuckets(checkpoint, priority) {
-        let arg = '';
-        if (priority !== undefined) {
-            const affectedBuckets = [];
-            for (const desc of checkpoint.buckets) {
-                if (hasMatchingPriority(priority, desc)) {
-                    affectedBuckets.push(desc.bucket);
-                }
-            }
-            arg = JSON.stringify({ priority, buckets: affectedBuckets });
-        }
-        return this.writeTransaction(async (tx) => {
-            const { insertId: result } = await tx.execute('INSERT INTO powersync_operations(op, data) VALUES(?, ?)', [
-                'sync_local',
-                arg
-            ]);
-            if (result == 1) {
-                if (priority == null) {
-                    const bucketToCount = Object.fromEntries(checkpoint.buckets.map((b) => [b.bucket, b.count]));
-                    // The two parameters could be replaced with one, but: https://github.com/powersync-ja/better-sqlite3/pull/6
-                    const jsonBucketCount = JSON.stringify(bucketToCount);
-                    await tx.execute("UPDATE ps_buckets SET count_since_last = 0, count_at_last = ?->name WHERE name != '$local' AND ?->name IS NOT NULL", [jsonBucketCount, jsonBucketCount]);
-                }
-                return true;
-            }
-            else {
-                return false;
-            }
-        });
-    }
-    async validateChecksums(checkpoint, priority) {
-        if (priority !== undefined) {
-            // Only validate the buckets within the priority we care about
-            const newBuckets = checkpoint.buckets.filter((cs) => hasMatchingPriority(priority, cs));
-            checkpoint = { ...checkpoint, buckets: newBuckets };
-        }
-        const rs = await this.db.execute('SELECT powersync_validate_checkpoint(?) as result', [
-            JSON.stringify({ ...checkpoint })
-        ]);
-        const resultItem = rs.rows?.item(0);
-        if (!resultItem) {
-            return {
-                checkpointValid: false,
-                ready: false,
-                checkpointFailures: []
-            };
-        }
-        const result = JSON.parse(resultItem['result']);
-        if (result['valid']) {
-            return { ready: true, checkpointValid: true };
-        }
-        else {
-            return {
-                checkpointValid: false,
-                ready: false,
-                checkpointFailures: result['failed_buckets']
-            };
-        }
-    }
     async updateLocalTarget(cb) {
         const rs1 = await this.db.getAll("SELECT target_op FROM ps_buckets WHERE name = '$local' AND target_op = CAST(? as INTEGER)", [MAX_OP_ID]);
         if (!rs1.length) {
@@ -14384,12 +13801,6 @@ class SqliteBucketStorage extends BaseObserver {
     async writeTransaction(callback, options) {
         return this.db.writeTransaction(callback, options);
     }
-    /**
-     * Set a target checkpoint.
-     */
-    async setTargetCheckpoint(checkpoint) {
-        // No-op for now
-    }
     async control(op, payload) {
         return await this.writeTransaction(async (tx) => {
             const [[raw]] = await tx.executeRaw('SELECT powersync_control(?, ?)', [op, payload]);
@@ -14413,20 +13824,6 @@ class SqliteBucketStorage extends BaseObserver {
     }
     static _subkeyMigrationKey = 'powersync_js_migrated_subkeys';
 }
-function hasMatchingPriority(priority, bucket) {
-    return bucket.priority != null && bucket.priority <= priority;
-}
-
-// TODO JSON
-class SyncDataBatch {
-    buckets;
-    static fromJSON(json) {
-        return new SyncDataBatch(json.buckets.map((bucket) => SyncDataBucket.fromRow(bucket)));
-    }
-    constructor(buckets) {
-        this.buckets = buckets;
-    }
-}
 
 /**
  * Thrown when an underlying database connection is closed.
@@ -14486,10 +13883,8 @@ class Schema {
      * developer instead of automatically by PowerSync.
      * 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.
-     * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
      *
      * @param tables An object of (table name, raw table definition) entries.
-     * @experimental Note that the raw tables API is still experimental and may change in the future.
      */
     withRawTables(tables) {
         for (const [name, rawTableDefinition] of Object.entries(tables)) {
@@ -14715,7 +14110,6 @@ exports.DEFAULT_INDEX_OPTIONS = DEFAULT_INDEX_OPTIONS;
 exports.DEFAULT_LOCK_TIMEOUT_MS = DEFAULT_LOCK_TIMEOUT_MS;
 exports.DEFAULT_POWERSYNC_CLOSE_OPTIONS = DEFAULT_POWERSYNC_CLOSE_OPTIONS;
 exports.DEFAULT_POWERSYNC_DB_OPTIONS = DEFAULT_POWERSYNC_DB_OPTIONS;
-exports.DEFAULT_PRESSURE_LIMITS = DEFAULT_PRESSURE_LIMITS;
 exports.DEFAULT_REMOTE_LOGGER = DEFAULT_REMOTE_LOGGER;
 exports.DEFAULT_REMOTE_OPTIONS = DEFAULT_REMOTE_OPTIONS;
 exports.DEFAULT_RETRY_DELAY_MS = DEFAULT_RETRY_DELAY_MS;
@@ -14726,7 +14120,6 @@ exports.DEFAULT_SYNC_CLIENT_IMPLEMENTATION = DEFAULT_SYNC_CLIENT_IMPLEMENTATION;
 exports.DEFAULT_TABLE_OPTIONS = DEFAULT_TABLE_OPTIONS;
 exports.DEFAULT_WATCH_QUERY_OPTIONS = DEFAULT_WATCH_QUERY_OPTIONS;
 exports.DEFAULT_WATCH_THROTTLE_MS = DEFAULT_WATCH_THROTTLE_MS;
-exports.DataStream = DataStream;
 exports.DifferentialQueryProcessor = DifferentialQueryProcessor;
 exports.EMPTY_DIFFERENTIAL = EMPTY_DIFFERENTIAL;
 exports.FalsyComparator = FalsyComparator;
@@ -14741,13 +14134,9 @@ exports.MAX_OP_ID = MAX_OP_ID;
 exports.MEMORY_TRIGGER_CLAIM_MANAGER = MEMORY_TRIGGER_CLAIM_MANAGER;
 exports.Mutex = Mutex;
 exports.OnChangeQueryProcessor = OnChangeQueryProcessor;
-exports.OpType = OpType;
-exports.OplogEntry = OplogEntry;
 exports.Schema = Schema;
 exports.Semaphore = Semaphore;
 exports.SqliteBucketStorage = SqliteBucketStorage;
-exports.SyncDataBatch = SyncDataBatch;
-exports.SyncDataBucket = SyncDataBucket;
 exports.SyncProgress = SyncProgress;
 exports.SyncStatus = SyncStatus;
 exports.SyncingService = SyncingService;
@@ -14762,18 +14151,10 @@ exports.createBaseLogger = createBaseLogger;
 exports.createLogger = createLogger;
 exports.extractTableUpdates = extractTableUpdates;
 exports.isBatchedUpdateNotification = isBatchedUpdateNotification;
-exports.isContinueCheckpointRequest = isContinueCheckpointRequest;
 exports.isDBAdapter = isDBAdapter;
 exports.isPowerSyncDatabaseOptionsWithSettings = isPowerSyncDatabaseOptionsWithSettings;
 exports.isSQLOpenFactory = isSQLOpenFactory;
 exports.isSQLOpenOptions = isSQLOpenOptions;
-exports.isStreamingKeepalive = isStreamingKeepalive;
-exports.isStreamingSyncCheckpoint = isStreamingSyncCheckpoint;
-exports.isStreamingSyncCheckpointComplete = isStreamingSyncCheckpointComplete;
-exports.isStreamingSyncCheckpointDiff = isStreamingSyncCheckpointDiff;
-exports.isStreamingSyncCheckpointPartiallyComplete = isStreamingSyncCheckpointPartiallyComplete;
-exports.isStreamingSyncData = isStreamingSyncData;
-exports.isSyncNewCheckpointRequest = isSyncNewCheckpointRequest;
 exports.parseQuery = parseQuery;
 exports.runOnSchemaChange = runOnSchemaChange;
 exports.sanitizeSQL = sanitizeSQL;