@powersync/common 1.38.1 → 1.39.0

package/lib/client/AbstractPowerSyncDatabase.js

@@ -2,7 +2,6 @@ import { Mutex } from 'async-mutex';
 import { EventIterator } from 'event-iterator';
 import Logger from 'js-logger';
 import { isBatchedUpdateNotification } from '../db/DBAdapter.js';
-import { FULL_SYNC_PRIORITY } from '../db/crud/SyncProgress.js';
 import { SyncStatus } from '../db/crud/SyncStatus.js';
 import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
 import { BaseObserver } from '../utils/BaseObserver.js';
@@ -19,6 +18,7 @@ import { DEFAULT_CRUD_UPLOAD_THROTTLE_MS, DEFAULT_RETRY_DELAY_MS } from './sync/
 import { TriggerManagerImpl } from './triggers/TriggerManagerImpl.js';
 import { DEFAULT_WATCH_THROTTLE_MS } from './watched/WatchedQuery.js';
 import { OnChangeQueryProcessor } from './watched/processors/OnChangeQueryProcessor.js';
+import { coreStatusToJs } from './sync/stream/core-instruction.js';
 const POWERSYNC_TABLE_MATCH = /(^ps_data__|^ps_data_local__)/;
 const DEFAULT_DISCONNECT_CLEAR_OPTIONS = {
     clearLocal: true
@@ -59,6 +59,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
     bucketStorageAdapter;
     _isReadyPromise;
     connectionManager;
+    subscriptions;
     get syncStreamImplementation() {
         return this.connectionManager.syncStreamImplementation;
     }
@@ -100,6 +101,15 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         this.sdkVersion = '';
         this.runExclusiveMutex = new Mutex();
         // Start async init
+        this.subscriptions = {
+            firstStatusMatching: (predicate, abort) => this.waitForStatus(predicate, abort),
+            resolveOfflineSyncStatus: () => this.resolveOfflineSyncStatus(),
+            rustSubscriptionsCommand: async (payload) => {
+                await this.writeTransaction((tx) => {
+                    return tx.execute('select powersync_control(?,?)', ['subscriptions', JSON.stringify(payload)]);
+                });
+            }
+        };
         this.connectionManager = new ConnectionManager({
             createSyncImplementation: async (connector, options) => {
                 await this.waitForReady();
@@ -176,22 +186,33 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         const statusMatches = priority === undefined
             ? (status) => status.hasSynced
             : (status) => status.statusForPriority(priority).hasSynced;
-        if (statusMatches(this.currentStatus)) {
+        return this.waitForStatus(statusMatches, signal);
+    }
+    /**
+     * Waits for the first sync status for which the `status` callback returns a truthy value.
+     */
+    async waitForStatus(predicate, signal) {
+        if (predicate(this.currentStatus)) {
             return;
         }
         return new Promise((resolve) => {
             const dispose = this.registerListener({
                 statusChanged: (status) => {
-                    if (statusMatches(status)) {
-                        dispose();
-                        resolve();
+                    if (predicate(status)) {
+                        abort();
                     }
                 }
             });
-            signal?.addEventListener('abort', () => {
+            function abort() {
                 dispose();
                 resolve();
-            });
+            }
+            if (signal?.aborted) {
+                abort();
+            }
+            else {
+                signal?.addEventListener('abort', abort);
+            }
         });
     }
     /**
@@ -203,7 +224,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         await this.bucketStorageAdapter.init();
         await this._loadVersion();
         await this.updateSchema(this.options.schema);
-        await this.updateHasSynced();
+        await this.resolveOfflineSyncStatus();
         await this.database.execute('PRAGMA RECURSIVE_TRIGGERS=TRUE');
         this.ready = true;
         this.iterateListeners((cb) => cb.initialized?.());
@@ -230,26 +251,12 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
             throw new Error(`Unsupported powersync extension version. Need >=0.4.5 <1.0.0, got: ${this.sdkVersion}`);
         }
     }
-    async updateHasSynced() {
-        const result = await this.database.getAll('SELECT priority, last_synced_at FROM ps_sync_state ORDER BY priority DESC');
-        let lastCompleteSync;
-        const priorityStatusEntries = [];
-        for (const { priority, last_synced_at } of result) {
-            const parsedDate = new Date(last_synced_at + 'Z');
-            if (priority == FULL_SYNC_PRIORITY) {
-                // This lowest-possible priority represents a complete sync.
-                lastCompleteSync = parsedDate;
-            }
-            else {
-                priorityStatusEntries.push({ priority, hasSynced: true, lastSyncedAt: parsedDate });
-            }
-        }
-        const hasSynced = lastCompleteSync != null;
+    async resolveOfflineSyncStatus() {
+        const result = await this.database.get('SELECT powersync_offline_sync_status() as r');
+        const parsed = JSON.parse(result.r);
         const updatedStatus = new SyncStatus({
             ...this.currentStatus.toJSON(),
-            hasSynced,
-            priorityStatusEntries,
-            lastSyncedAt: lastCompleteSync
+            ...coreStatusToJs(parsed)
         });
         if (!updatedStatus.isEqual(this.currentStatus)) {
             this.currentStatus = updatedStatus;
@@ -346,6 +353,17 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         this.currentStatus = new SyncStatus({});
         this.iterateListeners((l) => l.statusChanged?.(this.currentStatus));
     }
+    /**
+     * Create a sync stream to query its status or to subscribe to it.
+     *
+     * @param name The name of the stream to subscribe to.
+     * @param params Optional parameters for the stream subscription.
+     * @returns A {@link SyncStream} instance that can be subscribed to.
+     * @experimental Sync streams are currently in alpha.
+     */
+    syncStream(name, params) {
+        return this.connectionManager.stream(this.subscriptions, name, params ?? null);
+    }
     /**
      * Close the database, releasing resources.
      *

package/lib/client/ConnectionManager.d.ts

@@ -1,7 +1,9 @@
 import { ILogger } from 'js-logger';
 import { BaseListener, BaseObserver } from '../utils/BaseObserver.js';
 import { PowerSyncBackendConnector } from './connection/PowerSyncBackendConnector.js';
-import { InternalConnectionOptions, StreamingSyncImplementation } from './sync/stream/AbstractStreamingSyncImplementation.js';
+import { AdditionalConnectionOptions, InternalConnectionOptions, StreamingSyncImplementation, SubscribedStream } from './sync/stream/AbstractStreamingSyncImplementation.js';
+import { SyncStream } from './sync/sync-streams.js';
+import { SyncStatus } from '../db/crud/SyncStatus.js';
 /**
  * @internal
  */
@@ -13,11 +15,24 @@ export interface ConnectionManagerSyncImplementationResult {
      */
     onDispose: () => Promise<void> | void;
 }
+/**
+ * The subset of {@link AbstractStreamingSyncImplementationOptions} managed by the connection manager.
+ *
+ * @internal
+ */
+export interface CreateSyncImplementationOptions extends AdditionalConnectionOptions {
+    subscriptions: SubscribedStream[];
+}
+export interface InternalSubscriptionAdapter {
+    firstStatusMatching(predicate: (status: SyncStatus) => any, abort?: AbortSignal): Promise<void>;
+    resolveOfflineSyncStatus(): Promise<void>;
+    rustSubscriptionsCommand(payload: any): Promise<void>;
+}
 /**
  * @internal
  */
 export interface ConnectionManagerOptions {
-    createSyncImplementation(connector: PowerSyncBackendConnector, options: InternalConnectionOptions): Promise<ConnectionManagerSyncImplementationResult>;
+    createSyncImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions): Promise<ConnectionManagerSyncImplementationResult>;
     logger: ILogger;
 }
 type StoredConnectionOptions = {
@@ -63,6 +78,12 @@ export declare class ConnectionManager extends BaseObserver<ConnectionManagerLis
      * is disposed.
      */
     protected syncDisposer: (() => Promise<void> | void) | null;
+    /**
+     * Subscriptions managed in this connection manager.
+     *
+     * On the web, these local subscriptions are merged across tabs by a shared worker.
+     */
+    private locallyActiveSubscriptions;
     constructor(options: ConnectionManagerOptions);
     get logger(): ILogger;
     close(): Promise<void>;
@@ -76,5 +97,14 @@ export declare class ConnectionManager extends BaseObserver<ConnectionManagerLis
     disconnect(): Promise<void>;
     protected disconnectInternal(): Promise<void>;
     protected performDisconnect(): Promise<void>;
+    stream(adapter: InternalSubscriptionAdapter, name: string, parameters: Record<string, any> | null): SyncStream;
+    /**
+     * @internal exposed for testing
+     */
+    get activeStreams(): {
+        name: string;
+        params: Record<string, any> | null;
+    }[];
+    private subscriptionsMayHaveChanged;
 }
 export {};

package/lib/client/ConnectionManager.js

@@ -32,6 +32,12 @@ export class ConnectionManager extends BaseObserver {
      * is disposed.
      */
     syncDisposer;
+    /**
+     * Subscriptions managed in this connection manager.
+     *
+     * On the web, these local subscriptions are merged across tabs by a shared worker.
+     */
+    locallyActiveSubscriptions = new Map();
     constructor(options) {
         super();
         this.options = options;
@@ -55,7 +61,7 @@ export class ConnectionManager extends BaseObserver {
         // Update pending options to the latest values
         this.pendingConnectionOptions = {
             connector,
-            options: options ?? {}
+            options
         };
         // Disconnecting here provides aborting in progress connection attempts.
         // The connectInternal method will clear pending options once it starts connecting (with the options).
@@ -114,7 +120,10 @@ export class ConnectionManager extends BaseObserver {
                 const { connector, options } = this.pendingConnectionOptions;
                 appliedOptions = options;
                 this.pendingConnectionOptions = null;
-                const { sync, onDispose } = await this.options.createSyncImplementation(connector, options);
+                const { sync, onDispose } = await this.options.createSyncImplementation(connector, {
+                    subscriptions: this.activeStreams,
+                    ...options
+                });
                 this.iterateListeners((l) => l.syncStreamCreated?.(sync));
                 this.syncStreamImplementation = sync;
                 this.syncDisposer = onDispose;
@@ -171,4 +180,108 @@ export class ConnectionManager extends BaseObserver {
         await sync?.dispose();
         await disposer?.();
     }
+    stream(adapter, name, parameters) {
+        const desc = { name, parameters };
+        const waitForFirstSync = (abort) => {
+            return adapter.firstStatusMatching((s) => s.forStream(desc)?.subscription.hasSynced, abort);
+        };
+        return {
+            ...desc,
+            subscribe: async (options) => {
+                // NOTE: We also run this command if a subscription already exists, because this increases the expiry date
+                // (relevant if the app is closed before connecting again, where the last subscribe call determines the ttl).
+                await adapter.rustSubscriptionsCommand({
+                    subscribe: {
+                        stream: {
+                            name,
+                            params: parameters
+                        },
+                        ttl: options?.ttl,
+                        priority: options?.priority
+                    }
+                });
+                if (!this.syncStreamImplementation) {
+                    // We're not connected. So, update the offline sync status to reflect the new subscription.
+                    // (With an active iteration, the sync client would include it in its state).
+                    await adapter.resolveOfflineSyncStatus();
+                }
+                const key = `${name}|${JSON.stringify(parameters)}`;
+                let subscription = this.locallyActiveSubscriptions.get(key);
+                if (subscription == null) {
+                    const clearSubscription = () => {
+                        this.locallyActiveSubscriptions.delete(key);
+                        this.subscriptionsMayHaveChanged();
+                    };
+                    subscription = new ActiveSubscription(name, parameters, this.logger, waitForFirstSync, clearSubscription);
+                    this.locallyActiveSubscriptions.set(key, subscription);
+                    this.subscriptionsMayHaveChanged();
+                }
+                return new SyncStreamSubscriptionHandle(subscription);
+            },
+            unsubscribeAll: async () => {
+                await adapter.rustSubscriptionsCommand({ unsubscribe: { name, params: parameters } });
+                this.subscriptionsMayHaveChanged();
+            }
+        };
+    }
+    /**
+     * @internal exposed for testing
+     */
+    get activeStreams() {
+        return [...this.locallyActiveSubscriptions.values()].map((a) => ({ name: a.name, params: a.parameters }));
+    }
+    subscriptionsMayHaveChanged() {
+        this.syncStreamImplementation?.updateSubscriptions(this.activeStreams);
+    }
+}
+class ActiveSubscription {
+    name;
+    parameters;
+    logger;
+    waitForFirstSync;
+    clearSubscription;
+    refcount = 0;
+    constructor(name, parameters, logger, waitForFirstSync, clearSubscription) {
+        this.name = name;
+        this.parameters = parameters;
+        this.logger = logger;
+        this.waitForFirstSync = waitForFirstSync;
+        this.clearSubscription = clearSubscription;
+    }
+    decrementRefCount() {
+        this.refcount--;
+        if (this.refcount == 0) {
+            this.clearSubscription();
+        }
+    }
+}
+class SyncStreamSubscriptionHandle {
+    subscription;
+    active = true;
+    constructor(subscription) {
+        this.subscription = subscription;
+        subscription.refcount++;
+        _finalizer?.register(this, subscription);
+    }
+    get name() {
+        return this.subscription.name;
+    }
+    get parameters() {
+        return this.subscription.parameters;
+    }
+    waitForFirstSync(abort) {
+        return this.subscription.waitForFirstSync(abort);
+    }
+    unsubscribe() {
+        if (this.active) {
+            this.active = false;
+            _finalizer?.unregister(this);
+            this.subscription.decrementRefCount();
+        }
+    }
 }
+const _finalizer = 'FinalizationRegistry' in globalThis
+    ? new FinalizationRegistry((sub) => {
+        sub.logger.warn(`A subscription to ${sub.name} with params ${JSON.stringify(sub.parameters)} leaked! Please ensure calling unsubscribe() when you don't need a subscription anymore. For global subscriptions, consider storing them in global fields to avoid this warning.`);
+    })
+    : null;

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

@@ -10,6 +10,7 @@ export interface Checkpoint {
     last_op_id: OpId;
     buckets: BucketChecksum[];
     write_checkpoint?: string;
+    streams?: any[];
 }
 export interface BucketState {
     bucket: string;
@@ -43,6 +44,12 @@ export interface BucketChecksum {
      * Count of operations - informational only.
      */
     count?: number;
+    /**
+     * The JavaScript client does not use this field, which is why it's defined to be `any`. We rely on the structure of
+     * this interface to pass custom `BucketChecksum`s to the Rust client in unit tests, which so all fields need to be
+     * present.
+     */
+    subscriptions?: any;
 }
 export declare enum PSInternalTable {
     DATA = "ps_data",
@@ -57,7 +64,8 @@ export declare enum PowerSyncControlCommand {
     STOP = "stop",
     START = "start",
     NOTIFY_TOKEN_REFRESHED = "refreshed_token",
-    NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload"
+    NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload",
+    UPDATE_SUBSCRIPTIONS = "update_subscriptions"
 }
 export interface BucketStorageListener extends BaseListener {
     crudUpdate: () => void;

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

@@ -14,4 +14,5 @@ export var PowerSyncControlCommand;
     PowerSyncControlCommand["START"] = "start";
     PowerSyncControlCommand["NOTIFY_TOKEN_REFRESHED"] = "refreshed_token";
     PowerSyncControlCommand["NOTIFY_CRUD_UPLOAD_COMPLETED"] = "completed_upload";
+    PowerSyncControlCommand["UPDATE_SUBSCRIPTIONS"] = "update_subscriptions";
 })(PowerSyncControlCommand || (PowerSyncControlCommand = {}));

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

@@ -62,8 +62,9 @@ export interface LockOptions<T> {
     type: LockType;
     signal?: AbortSignal;
 }
-export interface AbstractStreamingSyncImplementationOptions extends AdditionalConnectionOptions {
+export interface AbstractStreamingSyncImplementationOptions extends RequiredAdditionalConnectionOptions {
     adapter: BucketStorageAdapter;
+    subscriptions: SubscribedStream[];
     uploadCrud: () => Promise<void>;
     /**
      * An identifier for which PowerSync DB this sync implementation is
@@ -115,6 +116,12 @@ export interface BaseConnectionOptions {
      * These parameters are passed to the sync rules, and will be available under the`user_parameters` object.
      */
     params?: Record<string, StreamingSyncRequestParameterType>;
+    /**
+     * Whether to include streams that have `auto_subscribe: true` in their definition.
+     *
+     * This defaults to `true`.
+     */
+    includeDefaultStreams?: boolean;
     /**
      * The serialized schema - mainly used to forward information about raw tables to the sync client.
      */
@@ -135,7 +142,9 @@ export interface AdditionalConnectionOptions {
     crudUploadThrottleMs?: number;
 }
 /** @internal */
-export type RequiredAdditionalConnectionOptions = Required<AdditionalConnectionOptions>;
+export interface RequiredAdditionalConnectionOptions extends Required<AdditionalConnectionOptions> {
+    subscriptions: SubscribedStream[];
+}
 export interface StreamingSyncImplementation extends BaseObserverInterface<StreamingSyncImplementationListener>, Disposable {
     /**
      * Connects to the sync service
@@ -155,6 +164,7 @@ export interface StreamingSyncImplementation extends BaseObserverInterface<Strea
     waitForReady(): Promise<void>;
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
+    updateSubscriptions(subscriptions: SubscribedStream[]): void;
 }
 export declare const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
 export declare const DEFAULT_RETRY_DELAY_MS = 5000;
@@ -164,6 +174,10 @@ export declare const DEFAULT_STREAMING_SYNC_OPTIONS: {
 };
 export type RequiredPowerSyncConnectionOptions = Required<BaseConnectionOptions>;
 export declare const DEFAULT_STREAM_CONNECTION_OPTIONS: RequiredPowerSyncConnectionOptions;
+export type SubscribedStream = {
+    name: string;
+    params: Record<string, any> | null;
+};
 export declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<StreamingSyncImplementationListener> implements StreamingSyncImplementation {
     protected _lastSyncedAt: Date | null;
     protected options: AbstractStreamingSyncImplementationOptions;
@@ -172,8 +186,10 @@ export declare abstract class AbstractStreamingSyncImplementation extends BaseOb
     protected crudUpdateListener?: () => void;
     protected streamingSyncPromise?: Promise<void>;
     protected logger: ILogger;
+    private activeStreams;
     private isUploadingCrud;
     private notifyCompletedUploads?;
+    private handleActiveStreamsChange?;
     syncStatus: SyncStatus;
     triggerCrudUpload: () => void;
     constructor(options: AbstractStreamingSyncImplementationOptions);
@@ -210,11 +226,16 @@ export declare abstract class AbstractStreamingSyncImplementation extends BaseOb
      * @returns Whether the database is now using the new, fixed subkey format.
      */
     private requireKeyFormat;
-    protected streamingSyncIteration(signal: AbortSignal, options?: PowerSyncConnectionOptions): Promise<void>;
+    protected streamingSyncIteration(signal: AbortSignal, options?: PowerSyncConnectionOptions): Promise<RustIterationResult | null>;
     private legacyStreamingSyncIteration;
     private rustSyncIteration;
     private updateSyncStatusForStartingCheckpoint;
     private applyCheckpoint;
     protected updateSyncStatus(options: SyncStatusOptions): void;
     private delayRetry;
+    updateSubscriptions(subscriptions: SubscribedStream[]): void;
+}
+interface RustIterationResult {
+    immediateRestart: boolean;
 }
+export {};

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

@@ -1,5 +1,4 @@
 import Logger from 'js-logger';
-import { FULL_SYNC_PRIORITY } from '../../../db/crud/SyncProgress.js';
 import { SyncStatus } from '../../../db/crud/SyncStatus.js';
 import { AbortOperation } from '../../../utils/AbortOperation.js';
 import { BaseObserver } from '../../../utils/BaseObserver.js';
@@ -7,6 +6,7 @@ import { throttleLeadingTrailing } from '../../../utils/async.js';
 import { PowerSyncControlCommand } from '../bucket/BucketStorageAdapter.js';
 import { SyncDataBucket } from '../bucket/SyncDataBucket.js';
 import { FetchStrategy } from './AbstractRemote.js';
+import { coreStatusToJs } from './core-instruction.js';
 import { isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncCheckpointPartiallyComplete, isStreamingSyncData } from './streaming-sync-types.js';
 export var LockType;
 (function (LockType) {
@@ -72,7 +72,8 @@ export const DEFAULT_STREAM_CONNECTION_OPTIONS = {
     clientImplementation: DEFAULT_SYNC_CLIENT_IMPLEMENTATION,
     fetchStrategy: FetchStrategy.Buffered,
     params: {},
-    serializedSchema: undefined
+    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
@@ -89,13 +90,16 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     crudUpdateListener;
     streamingSyncPromise;
     logger;
+    activeStreams;
     isUploadingCrud = false;
     notifyCompletedUploads;
+    handleActiveStreamsChange;
     syncStatus;
     triggerCrudUpload;
     constructor(options) {
         super();
-        this.options = { ...DEFAULT_STREAMING_SYNC_OPTIONS, ...options };
+        this.options = options;
+        this.activeStreams = options.subscriptions;
         this.logger = options.logger ?? Logger.get('PowerSyncStream');
         this.syncStatus = new SyncStatus({
             connected: false,
@@ -343,11 +347,12 @@ The next upload iteration will be delayed.`);
         while (true) {
             this.updateSyncStatus({ connecting: true });
             let shouldDelayRetry = true;
+            let result = null;
             try {
                 if (signal?.aborted) {
                     break;
                 }
-                await this.streamingSyncIteration(nestedAbortController.signal, options);
+                result = await this.streamingSyncIteration(nestedAbortController.signal, options);
                 // Continue immediately, streamingSyncIteration will wait before completing if necessary.
             }
             catch (ex) {
@@ -380,13 +385,15 @@ The next upload iteration will be delayed.`);
                     nestedAbortController.abort(new AbortOperation('Closing sync stream network requests before retry.'));
                     nestedAbortController = new AbortController();
                 }
-                this.updateSyncStatus({
-                    connected: false,
-                    connecting: true // May be unnecessary
-                });
-                // On error, wait a little before retrying
-                if (shouldDelayRetry) {
-                    await this.delayRetry(nestedAbortController.signal);
+                if (result?.immediateRestart != true) {
+                    this.updateSyncStatus({
+                        connected: false,
+                        connecting: true // May be unnecessary
+                    });
+                    // On error, wait a little before retrying
+                    if (shouldDelayRetry) {
+                        await this.delayRetry(nestedAbortController.signal);
+                    }
                 }
             }
         }
@@ -430,8 +437,8 @@ The next upload iteration will be delayed.`);
             return hasMigrated;
         }
     }
-    async streamingSyncIteration(signal, options) {
-        await this.obtainLock({
+    streamingSyncIteration(signal, options) {
+        return this.obtainLock({
             type: LockType.SYNC,
             signal,
             callback: async () => {
@@ -443,10 +450,11 @@ The next upload iteration will be delayed.`);
                 this.updateSyncStatus({ clientImplementation });
                 if (clientImplementation == SyncClientImplementation.JAVASCRIPT) {
                     await this.legacyStreamingSyncIteration(signal, resolvedOptions);
+                    return null;
                 }
                 else {
                     await this.requireKeyFormat(true);
-                    await this.rustSyncIteration(signal, resolvedOptions);
+                    return await this.rustSyncIteration(signal, resolvedOptions);
                 }
             }
         });
@@ -695,6 +703,7 @@ The next upload iteration will be delayed.`);
         const remote = this.options.remote;
         let receivingLines = null;
         let hadSyncLine = false;
+        let hideDisconnectOnRestart = false;
         if (signal.aborted) {
             throw new AbortOperation('Connection request has been aborted');
         }
@@ -771,6 +780,8 @@ The next upload iteration will be delayed.`);
         }
         async function control(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));
         }
         async function handleInstruction(instruction) {
@@ -788,27 +799,7 @@ The next upload iteration will be delayed.`);
                 }
             }
             else if ('UpdateSyncStatus' in instruction) {
-                function coreStatusToJs(status) {
-                    return {
-                        priority: status.priority,
-                        hasSynced: status.has_synced ?? undefined,
-                        lastSyncedAt: status?.last_synced_at != null ? new Date(status.last_synced_at * 1000) : undefined
-                    };
-                }
-                const info = instruction.UpdateSyncStatus.status;
-                const coreCompleteSync = info.priority_status.find((s) => s.priority == FULL_SYNC_PRIORITY);
-                const completeSync = coreCompleteSync != null ? coreStatusToJs(coreCompleteSync) : null;
-                syncImplementation.updateSyncStatus({
-                    connected: info.connected,
-                    connecting: info.connecting,
-                    dataFlow: {
-                        downloading: info.downloading != null,
-                        downloadProgress: info.downloading?.buckets
-                    },
-                    lastSyncedAt: completeSync?.lastSyncedAt,
-                    hasSynced: completeSync?.hasSynced,
-                    priorityStatusEntries: info.priority_status.map(coreStatusToJs)
-                });
+                syncImplementation.updateSyncStatus(coreStatusToJs(instruction.UpdateSyncStatus.status));
             }
             else if ('EstablishSyncStream' in instruction) {
                 if (receivingLines != null) {
@@ -833,6 +824,7 @@ The next upload iteration will be delayed.`);
             }
             else if ('CloseSyncStream' in instruction) {
                 abortController.abort();
+                hideDisconnectOnRestart = instruction.CloseSyncStream.hide_disconnect;
             }
             else if ('FlushFileSystem' in instruction) {
                 // Not necessary on JS platforms.
@@ -851,7 +843,11 @@ The next upload iteration will be delayed.`);
             }
         }
         try {
-            const options = { parameters: resolvedOptions.params };
+            const options = {
+                parameters: resolvedOptions.params,
+                active_streams: this.activeStreams,
+                include_defaults: resolvedOptions.includeDefaultStreams
+            };
             if (resolvedOptions.serializedSchema) {
                 options.schema = resolvedOptions.serializedSchema;
             }
@@ -861,12 +857,21 @@ The next upload iteration will be delayed.`);
                     controlInvocations.enqueueData({ command: PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
                 }
             };
+            this.handleActiveStreamsChange = () => {
+                if (controlInvocations && !controlInvocations?.closed) {
+                    controlInvocations.enqueueData({
+                        command: PowerSyncControlCommand.UPDATE_SUBSCRIPTIONS,
+                        payload: JSON.stringify(this.activeStreams)
+                    });
+                }
+            };
             await receivingLines;
         }
         finally {
-            this.notifyCompletedUploads = undefined;
+            this.notifyCompletedUploads = this.handleActiveStreamsChange = undefined;
             await stop();
         }
+        return { immediateRestart: hideDisconnectOnRestart };
     }
     async updateSyncStatusForStartingCheckpoint(checkpoint) {
         const localProgress = await this.options.adapter.getBucketOperationProgress();
@@ -971,4 +976,8 @@ The next upload iteration will be delayed.`);
             timeoutId = setTimeout(endDelay, retryDelayMs);
         });
     }
+    updateSubscriptions(subscriptions) {
+        this.activeStreams = subscriptions;
+        this.handleActiveStreamsChange?.();
+    }
 }