@powersync/common 1.51.0 → 1.53.0

package/dist/index.d.cts

@@ -1,6 +1,5 @@
 import Logger, { ILogger, ILogLevel } from 'js-logger';
 export { GlobalLogger, ILogHandler, ILogLevel, ILogger, ILoggerOpts } from 'js-logger';
-import { BSON } from 'bson';
 import { fetch } from 'cross-fetch';
 
 interface Disposable {
@@ -87,6 +86,15 @@ interface SqlExecutor {
     executeBatch: (query: string, params?: any[][]) => Promise<QueryResult>;
 }
 interface LockContext extends SqlExecutor, DBGetUtils {
+    /**
+     * How the connection has been opened.
+     *
+     * `writer` indicates that the lock context is capable of writing to the database.
+     * `queryOnly` indicates that the lock context has been opened in a readwrite mode, but a `PRAGMA query_only = TRUE`
+     * disabled writes.
+     * `readOnly` indicates that the lock context has been opened by passing `SQLITE_OPEN_READONLY` to `sqlite3_open_v2`.
+     */
+    connectionType?: 'writer' | 'queryOnly' | 'readOnly';
 }
 /**
  * Implements {@link DBGetUtils} on a {@link SqlRunner}.
@@ -310,139 +318,6 @@ declare class CrudBatch {
     complete: (writeCheckpoint?: string) => Promise<void>);
 }
 
-declare enum OpTypeEnum {
-    CLEAR = 1,
-    MOVE = 2,
-    PUT = 3,
-    REMOVE = 4
-}
-type OpTypeJSON = string;
-/**
- * Used internally for sync buckets.
- */
-declare class OpType {
-    value: OpTypeEnum;
-    static fromJSON(jsonValue: OpTypeJSON): OpType;
-    constructor(value: OpTypeEnum);
-    toJSON(): string;
-}
-
-interface OplogEntryJSON {
-    checksum: number;
-    data?: string;
-    object_id?: string;
-    object_type?: string;
-    op_id: string;
-    op: OpTypeJSON;
-    subkey?: string;
-}
-declare class OplogEntry {
-    op_id: OpId;
-    op: OpType;
-    checksum: number;
-    subkey?: string | undefined;
-    object_type?: string | undefined;
-    object_id?: string | undefined;
-    data?: string | undefined;
-    static fromRow(row: OplogEntryJSON): OplogEntry;
-    constructor(op_id: OpId, op: OpType, checksum: number, subkey?: string | undefined, object_type?: string | undefined, object_id?: string | undefined, data?: string | undefined);
-    toJSON(fixedKeyEncoding?: boolean): OplogEntryJSON;
-}
-
-type SyncDataBucketJSON = {
-    bucket: string;
-    has_more?: boolean;
-    after?: string;
-    next_after?: string;
-    data: OplogEntryJSON[];
-};
-declare class SyncDataBucket {
-    bucket: string;
-    data: OplogEntry[];
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more: boolean;
-    /**
-     * The `after` specified in the request.
-     */
-    after?: OpId | undefined;
-    /**
-     * Use this for the next request.
-     */
-    next_after?: OpId | undefined;
-    static fromRow(row: SyncDataBucketJSON): SyncDataBucket;
-    constructor(bucket: string, data: OplogEntry[], 
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more: boolean, 
-    /**
-     * The `after` specified in the request.
-     */
-    after?: OpId | undefined, 
-    /**
-     * Use this for the next request.
-     */
-    next_after?: OpId | undefined);
-    toJSON(fixedKeyEncoding?: boolean): SyncDataBucketJSON;
-}
-
-declare class SyncDataBatch {
-    buckets: SyncDataBucket[];
-    static fromJSON(json: any): SyncDataBatch;
-    constructor(buckets: SyncDataBucket[]);
-}
-
-interface BucketDescription {
-    name: string;
-    priority: number;
-}
-interface Checkpoint {
-    last_op_id: OpId;
-    buckets: BucketChecksum[];
-    write_checkpoint?: string;
-    streams?: any[];
-}
-interface BucketState {
-    bucket: string;
-    op_id: string;
-}
-interface ChecksumCache {
-    checksums: Map<string, {
-        checksum: BucketChecksum;
-        last_op_id: OpId;
-    }>;
-    lastOpId: OpId;
-}
-interface SyncLocalDatabaseResult {
-    ready: boolean;
-    checkpointValid: boolean;
-    checkpointFailures?: string[];
-}
-type SavedProgress = {
-    atLast: number;
-    sinceLast: number;
-};
-type BucketOperationProgress = Record<string, SavedProgress>;
-interface BucketChecksum {
-    bucket: string;
-    priority?: number;
-    /**
-     * 32-bit unsigned hash.
-     */
-    checksum: number;
-    /**
-     * 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;
-}
 declare enum PSInternalTable {
     DATA = "ps_data",
     CRUD = "ps_crud",
@@ -457,30 +332,22 @@ declare enum PowerSyncControlCommand {
     START = "start",
     NOTIFY_TOKEN_REFRESHED = "refreshed_token",
     NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload",
-    UPDATE_SUBSCRIPTIONS = "update_subscriptions"
+    UPDATE_SUBSCRIPTIONS = "update_subscriptions",
+    /**
+     * An `established` or `end` event for response streams.
+     */
+    CONNECTION_STATE = "connection"
 }
 interface BucketStorageListener extends BaseListener {
     crudUpdate: () => void;
 }
 interface BucketStorageAdapter extends BaseObserverInterface<BucketStorageListener>, Disposable {
     init(): Promise<void>;
-    saveSyncData(batch: SyncDataBatch, fixedKeyFormat?: boolean): Promise<void>;
-    removeBuckets(buckets: string[]): Promise<void>;
-    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
-    startSession(): void;
-    getBucketStates(): Promise<BucketState[]>;
-    getBucketOperationProgress(): Promise<BucketOperationProgress>;
     hasMigratedSubkeys(): Promise<boolean>;
     migrateToFixedSubkeys(): Promise<void>;
-    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<{
-        checkpointValid: boolean;
-        ready: boolean;
-        failures?: any[];
-    }>;
     nextCrudItem(): Promise<CrudEntry | undefined>;
     hasCrud(): Promise<boolean>;
     getCrudBatch(limit?: number): Promise<CrudBatch | null>;
-    hasCompletedSync(): Promise<boolean>;
     updateLocalTarget(cb: () => Promise<string>): Promise<boolean>;
     getMaxOpId(): string;
     /**
@@ -493,67 +360,6 @@ interface BucketStorageAdapter extends BaseObserverInterface<BucketStorageListen
     control(op: PowerSyncControlCommand, payload: string | Uint8Array | null): Promise<string>;
 }
 
-type DataStreamOptions<ParsedData, SourceData> = {
-    mapLine?: (line: SourceData) => ParsedData;
-    /**
-     * Close the stream if any consumer throws an error
-     */
-    closeOnError?: boolean;
-    pressure?: {
-        highWaterMark?: number;
-        lowWaterMark?: number;
-    };
-    logger?: ILogger;
-};
-type DataStreamCallback<Data extends any = any> = (data: Data) => Promise<void>;
-interface DataStreamListener<Data extends any = any> extends BaseListener {
-    data: (data: Data) => Promise<void>;
-    closed: () => void;
-    error: (error: Error) => void;
-    highWater: () => Promise<void>;
-    lowWater: () => Promise<void>;
-}
-declare const DEFAULT_PRESSURE_LIMITS: {
-    highWater: number;
-    lowWater: number;
-};
-/**
- * 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.
- */
-declare class DataStream<ParsedData, SourceData = any> extends BaseObserver<DataStreamListener<ParsedData>> {
-    protected options?: DataStreamOptions<ParsedData, SourceData> | undefined;
-    dataQueue: SourceData[];
-    protected isClosed: boolean;
-    protected processingPromise: Promise<void> | null;
-    protected notifyDataAdded: (() => void) | null;
-    protected logger: ILogger;
-    protected mapLine: (line: SourceData) => ParsedData;
-    constructor(options?: DataStreamOptions<ParsedData, SourceData> | undefined);
-    get highWatermark(): number;
-    get lowWatermark(): number;
-    get closed(): boolean;
-    close(): Promise<void>;
-    /**
-     * Enqueues data for the consumers to read
-     */
-    enqueueData(data: SourceData): void;
-    /**
-     * Reads data once from the data stream
-     * @returns a Data payload or Null if the stream closed.
-     */
-    read(): Promise<ParsedData | null>;
-    /**
-     * Executes a callback for each data item in the stream
-     */
-    forEach(callback: DataStreamCallback<ParsedData>): () => void;
-    protected processQueue(): Promise<void> | undefined;
-    protected hasDataReader(): boolean;
-    protected _processQueue(): Promise<void>;
-    protected iterateAsyncErrored(cb: (l: Partial<DataStreamListener<ParsedData>>) => Promise<void>): Promise<void>;
-}
-
 interface PowerSyncCredentials {
     endpoint: string;
     token: string;
@@ -561,146 +367,15 @@ interface PowerSyncCredentials {
 }
 
 /**
- * For sync2.json
- */
-interface ContinueCheckpointRequest {
-    /**
-     * Existing bucket states. Only these buckets are synchronized.
-     */
-    buckets: BucketRequest[];
-    checkpoint_token: string;
-    limit?: number;
-}
-interface SyncNewCheckpointRequest {
-    /**
-     * Existing bucket states. Used if include_data is specified.
-     */
-    buckets?: BucketRequest[];
-    request_checkpoint: {
-        /**
-         * Whether or not to include an initial data request.
-         */
-        include_data: boolean;
-        /**
-         * Whether or not to compute a checksum.
-         */
-        include_checksum: boolean;
-    };
-    limit?: number;
-}
-type SyncRequest = ContinueCheckpointRequest | SyncNewCheckpointRequest;
-interface SyncResponse {
-    /**
-     * Data for the buckets returned. May not have an an entry for each bucket in the request.
-     */
-    data?: SyncDataBucketJSON[];
-    /**
-     * True if the response limit has been reached, and another request must be made.
-     */
-    has_more: boolean;
-    checkpoint_token?: string;
-    checkpoint?: Checkpoint;
-}
-type JSONValue = string | number | boolean | null | undefined | JSONObject | JSONArray;
-interface JSONObject {
-    [key: string]: JSONValue;
-}
-type JSONArray = JSONValue[];
-type StreamingSyncRequestParameterType = JSONValue;
-interface StreamingSyncRequest {
-    /**
-     * Existing bucket states.
-     */
-    buckets?: BucketRequest[];
-    /**
-     * If specified, limit the response to only include these buckets.
-     */
-    only?: string[];
-    /**
-     * Whether or not to compute a checksum for each checkpoint
-     */
-    include_checksum: boolean;
-    /**
-     * Changes the response to stringified data in each OplogEntry
-     */
-    raw_data: boolean;
-    /**
-     * Client parameters to be passed to the sync rules.
-     */
-    parameters?: Record<string, StreamingSyncRequestParameterType>;
-    /**
-     * Application metadata to be included in service logs.
-     */
-    app_metadata?: Record<string, string>;
-    client_id?: string;
-}
-interface StreamingSyncCheckpoint {
-    checkpoint: Checkpoint;
-}
-interface StreamingSyncCheckpointDiff {
-    checkpoint_diff: {
-        last_op_id: OpId;
-        updated_buckets: BucketChecksum[];
-        removed_buckets: string[];
-        write_checkpoint?: string;
-    };
-}
-interface StreamingSyncDataJSON {
-    data: SyncDataBucketJSON;
-}
-interface StreamingSyncCheckpointComplete {
-    checkpoint_complete: {
-        last_op_id: OpId;
-    };
-}
-interface StreamingSyncCheckpointPartiallyComplete {
-    partial_checkpoint_complete: {
-        priority: number;
-        last_op_id: OpId;
-    };
-}
-interface StreamingSyncKeepalive {
-    /** If specified, token expires in this many seconds. */
-    token_expires_in: number;
-}
-type StreamingSyncLine = StreamingSyncDataJSON | StreamingSyncCheckpoint | StreamingSyncCheckpointDiff | StreamingSyncCheckpointComplete | StreamingSyncCheckpointPartiallyComplete | StreamingSyncKeepalive;
-type CrudUploadNotification = {
-    crud_upload_completed: null;
-};
-type StreamingSyncLineOrCrudUploadComplete = StreamingSyncLine | CrudUploadNotification;
-interface BucketRequest {
-    name: string;
-    /**
-     * Base-10 number. Sync all data from this bucket with op_id > after.
-     */
-    after: OpId;
-}
-declare function isStreamingSyncData(line: StreamingSyncLine): line is StreamingSyncDataJSON;
-declare function isStreamingKeepalive(line: StreamingSyncLine): line is StreamingSyncKeepalive;
-declare function isStreamingSyncCheckpoint(line: StreamingSyncLine): line is StreamingSyncCheckpoint;
-declare function isStreamingSyncCheckpointComplete(line: StreamingSyncLine): line is StreamingSyncCheckpointComplete;
-declare function isStreamingSyncCheckpointPartiallyComplete(line: StreamingSyncLine): line is StreamingSyncCheckpointPartiallyComplete;
-declare function isStreamingSyncCheckpointDiff(line: StreamingSyncLine): line is StreamingSyncCheckpointDiff;
-declare function isContinueCheckpointRequest(request: SyncRequest): request is ContinueCheckpointRequest;
-declare function isSyncNewCheckpointRequest(request: SyncRequest): request is SyncNewCheckpointRequest;
-/**
- * For crud.json
+ * An async iterator that can't be cancelled.
+ *
+ * To keep data flow simple, we always pass an explicit cancellation token when subscribing to async streams. Once the
+ * {@link AbortSignal} aborts, iterators are supposed to clean up and then emit a final `{done: true}` event. This means
+ * that there's no way to distinguish between streams that have completed normally and streams that have been cancelled,
+ * but that is acceptable for our uses of this.
  */
-interface CrudRequest {
-    data: CrudEntry[];
-}
-interface CrudResponse {
-    /**
-     * A sync response with a checkpoint >= this checkpoint would contain all the changes in this request.
-     *
-     * Any earlier checkpoint may or may not contain these changes.
-     *
-     * May be empty when the request contains no ops.
-     */
-    checkpoint?: OpId;
-}
+type SimpleAsyncIterator<T> = Pick<AsyncIterator<T>, 'next'>;
 
-type BSONImplementation = typeof BSON;
 type RemoteConnector = {
     fetchCredentials: () => Promise<PowerSyncCredentials | null>;
     invalidateCredentials?: () => void;
@@ -708,9 +383,9 @@ type RemoteConnector = {
 declare const DEFAULT_REMOTE_LOGGER: Logger.ILogger;
 type SyncStreamOptions = {
     path: string;
-    data: StreamingSyncRequest;
+    data: unknown;
     headers?: Record<string, string>;
-    abortSignal?: AbortSignal;
+    abortSignal: AbortSignal;
     fetchOptions?: Request;
 };
 declare enum FetchStrategy {
@@ -811,30 +486,51 @@ declare abstract class AbstractRemote {
     }>;
     post(path: string, data: any, headers?: Record<string, string>): Promise<any>;
     get(path: string, headers?: Record<string, string>): Promise<any>;
-    /**
-     * Provides a BSON implementation. The import nature of this varies depending on the platform
-     */
-    abstract getBSON(): Promise<BSONImplementation>;
     /**
      * @returns A text decoder decoding UTF-8. This is a method to allow patching it for Hermes which doesn't support the
      * builtin, without forcing us to bundle a polyfill with `@powersync/common`.
      */
-    protected createTextDecoder(): TextDecoder;
+    createTextDecoder(): TextDecoder;
     protected createSocket(url: string): WebSocket;
     /**
-     * Returns a data stream of sync line data.
+     * Returns a data stream of sync line data, fetched via RSocket-over-WebSocket.
+     *
+     * The only mechanism to abort the returned stream is to use the abort signal in {@link SocketSyncStreamOptions}.
+     */
+    socketStreamRaw(options: SocketSyncStreamOptions): Promise<SimpleAsyncIterator<Uint8Array>>;
+    /**
+     * @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.
      *
-     * @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).
+     * @see https://github.com/react-native-community/fetch?tab=readme-ov-file#motivation
      */
-    socketStreamRaw<T>(options: SocketSyncStreamOptions, map: (buffer: Uint8Array) => T, bson?: typeof BSON): Promise<DataStream<T>>;
+    protected get supportsStreamingBinaryResponses(): boolean;
     /**
-     * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
+     * 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.
+     */
+    protected fetchStreamRaw(options: SyncStreamOptions): Promise<{
+        isBson: boolean;
+        stream: SimpleAsyncIterator<Uint8Array>;
+    }>;
+    /**
+     * 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.
      */
-    postStreamRaw<T>(options: SyncStreamOptions, mapLine: (line: string) => T): Promise<DataStream<T>>;
+    fetchStream(options: SyncStreamOptions): Promise<SimpleAsyncIterator<Uint8Array | string>>;
 }
 
+type JSONValue = string | number | boolean | null | undefined | JSONObject | JSONArray;
+interface JSONObject {
+    [key: string]: JSONValue;
+}
+type JSONArray = JSONValue[];
+type StreamingSyncRequestParameterType = JSONValue;
+
 declare enum LockType {
     CRUD = "crud",
     SYNC = "sync"
@@ -844,35 +540,21 @@ declare enum SyncStreamConnectionMethod {
     WEB_SOCKET = "web-socket"
 }
 declare enum 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.
-     */
-    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.
      */
     RUST = "rust"
 }
@@ -925,11 +607,7 @@ interface BaseConnectionOptions {
      */
     appMetadata?: Record<string, string>;
     /**
-     * Whether to use a JavaScript implementation to handle received sync lines from the sync
-     * service, or whether this work should be offloaded to the PowerSync core extension.
-     *
-     * This defaults to the JavaScript implementation ({@link SyncClientImplementation.JAVASCRIPT})
-     * since the ({@link SyncClientImplementation.RUST}) implementation is experimental at the moment.
+     * @deprecated The Rust sync client is used unconditionally, so this option can't be configured.
      */
     clientImplementation?: SyncClientImplementation;
     /**
@@ -986,15 +664,14 @@ interface StreamingSyncImplementation extends BaseObserverInterface<StreamingSyn
      */
     disconnect(): Promise<void>;
     getWriteCheckpoint: () => Promise<string>;
-    hasCompletedSync: () => Promise<boolean>;
     isConnected: boolean;
-    lastSyncedAt?: Date;
     syncStatus: SyncStatus;
     triggerCrudUpload: () => void;
     waitForReady(): Promise<void>;
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;
+    markConnectionMayHaveChanged(): void;
 }
 declare const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
 declare const DEFAULT_RETRY_DELAY_MS = 5000;
@@ -1009,14 +686,14 @@ type SubscribedStream = {
     params: Record<string, any> | null;
 };
 declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<StreamingSyncImplementationListener> implements StreamingSyncImplementation {
-    protected _lastSyncedAt: Date | null;
     protected options: AbstractStreamingSyncImplementationOptions;
     protected abortController: AbortController | null;
-    protected uploadAbortController: AbortController | null;
+    protected uploadAbortController: AbortController | undefined;
     protected crudUpdateListener?: () => void;
     protected streamingSyncPromise?: Promise<void>;
     protected logger: ILogger;
     private activeStreams;
+    private connectionMayHaveChanged;
     private isUploadingCrud;
     private notifyCompletedUploads?;
     private handleActiveStreamsChange?;
@@ -1030,7 +707,6 @@ declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<
     get isConnected(): boolean;
     dispose(): Promise<void>;
     abstract obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
-    hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
     protected _uploadAllCrud(): Promise<void>;
     connect(options?: PowerSyncConnectionOptions): Promise<void>;
@@ -1039,7 +715,7 @@ declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<
      * @deprecated use [connect instead]
      */
     streamingSync(signal?: AbortSignal, options?: PowerSyncConnectionOptions): Promise<void>;
-    private collectLocalBucketState;
+    markConnectionMayHaveChanged(): void;
     /**
      * Older versions of the JS SDK used to encode subkeys as JSON in {@link OplogEntry.toJSON}.
      * Because subkeys are always strings, this leads to quotes being added around them in `ps_oplog`.
@@ -1057,10 +733,8 @@ declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<
      */
     private requireKeyFormat;
     protected streamingSyncIteration(signal: AbortSignal, options?: PowerSyncConnectionOptions): Promise<RustIterationResult | null>;
-    private legacyStreamingSyncIteration;
+    private receiveSyncLines;
     private rustSyncIteration;
-    private updateSyncStatusForStartingCheckpoint;
-    private applyCheckpoint;
     protected updateSyncStatus(options: SyncStatusOptions): void;
     private delayRetry;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;
@@ -1287,6 +961,9 @@ type SyncStatusOptions = {
     lastSyncedAt?: Date;
     hasSynced?: boolean;
     priorityStatusEntries?: SyncPriorityStatus[];
+    /**
+     * @deprecated This field is no longer set, since {@link SyncClientImplementation.RUST} is the only option.
+     */
     clientImplementation?: SyncClientImplementation;
 };
 declare class SyncStatus {
@@ -1360,14 +1037,10 @@ declare 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(): SyncStreamStatus[] | undefined;
     /**
      * If the `stream` appears in {@link syncStreams}, returns the current status for that stream.
-     *
-     * @experimental Sync streams are currently in alpha.
      */
     forStream(stream: SyncStreamDescription): SyncStreamStatus | undefined;
     /**
@@ -1712,11 +1385,6 @@ declare class Table<Columns extends ColumnsType = ColumnsType> {
  * To collect local writes to raw tables with PowerSync, custom triggers are required. See
  * {@link https://docs.powersync.com/usage/use-case-examples/raw-tables the documentation} for details and an example on
  * using raw tables.
- *
- * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
- *
- * @experimental Please note that this feature is experimental at the moment, and not covered by PowerSync semver or
- * stability guarantees.
  */
 type RawTableType = RawTableTypeWithStatements | InferredRawTableType;
 interface RawTableTypeWithStatements {
@@ -1816,10 +1484,8 @@ declare class Schema<S extends SchemaType = SchemaType> {
      * 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: Record<string, RawTableType>): void;
     validate(): void;
@@ -4249,7 +3915,6 @@ declare class SqliteBucketStorage extends BaseObserver<BucketStorageListener> im
     private db;
     private logger;
     tableNames: Set<string>;
-    private _hasCompletedSync;
     private updateListener;
     private _clientId?;
     constructor(db: DBAdapter, logger?: ILogger);
@@ -4258,27 +3923,6 @@ declare class SqliteBucketStorage extends BaseObserver<BucketStorageListener> im
     _getClientId(): Promise<string>;
     getClientId(): Promise<string>;
     getMaxOpId(): string;
-    /**
-     * Reset any caches.
-     */
-    startSession(): void;
-    getBucketStates(): Promise<BucketState[]>;
-    getBucketOperationProgress(): Promise<BucketOperationProgress>;
-    saveSyncData(batch: SyncDataBatch, fixedKeyFormat?: boolean): Promise<void>;
-    removeBuckets(buckets: string[]): Promise<void>;
-    /**
-     * Mark a bucket for deletion.
-     */
-    private deleteBucket;
-    hasCompletedSync(): Promise<boolean>;
-    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<SyncLocalDatabaseResult>;
-    /**
-     * Atomically update the local state to the current checkpoint.
-     *
-     * This includes creating new tables, dropping old tables, and copying data over from the oplog.
-     */
-    private updateObjectsFromBuckets;
-    validateChecksums(checkpoint: Checkpoint, priority: number | undefined): Promise<SyncLocalDatabaseResult>;
     updateLocalTarget(cb: () => Promise<string>): Promise<boolean>;
     nextCrudItem(): Promise<CrudEntry | undefined>;
     hasCrud(): Promise<boolean>;
@@ -4290,10 +3934,6 @@ declare class SqliteBucketStorage extends BaseObserver<BucketStorageListener> im
     writeTransaction<T>(callback: (tx: Transaction) => Promise<T>, options?: {
         timeoutMs: number;
     }): Promise<T>;
-    /**
-     * Set a target checkpoint.
-     */
-    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
     control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string>;
     hasMigratedSubkeys(): Promise<boolean>;
     migrateToFixedSubkeys(): Promise<void>;
@@ -4424,5 +4064,5 @@ interface ParsedQuery {
 }
 declare const parseQuery: <T>(query: string | CompilableQuery<T>, parameters: any[]) => ParsedQuery;
 
-export { ATTACHMENT_TABLE, AbortOperation, AbstractPowerSyncDatabase, AbstractPowerSyncDatabaseOpenFactory, AbstractQueryProcessor, AbstractRemote, AbstractStreamingSyncImplementation, ArrayComparator, AttachmentContext, AttachmentQueue, AttachmentService, AttachmentState, AttachmentTable, BaseObserver, Column, ColumnType, ConnectionClosedError, ConnectionManager, ControlledExecutor, CrudBatch, CrudEntry, CrudTransaction, DBAdapterDefaultMixin, DBGetUtilsDefaultMixin, DEFAULT_CRUD_BATCH_LIMIT, DEFAULT_CRUD_UPLOAD_THROTTLE_MS, DEFAULT_INDEX_COLUMN_OPTIONS, DEFAULT_INDEX_OPTIONS, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_POWERSYNC_CLOSE_OPTIONS, DEFAULT_POWERSYNC_DB_OPTIONS, DEFAULT_PRESSURE_LIMITS, DEFAULT_REMOTE_LOGGER, DEFAULT_REMOTE_OPTIONS, DEFAULT_RETRY_DELAY_MS, DEFAULT_ROW_COMPARATOR, DEFAULT_STREAMING_SYNC_OPTIONS, DEFAULT_STREAM_CONNECTION_OPTIONS, DEFAULT_SYNC_CLIENT_IMPLEMENTATION, DEFAULT_TABLE_OPTIONS, DEFAULT_WATCH_QUERY_OPTIONS, DEFAULT_WATCH_THROTTLE_MS, DataStream, DiffTriggerOperation, DifferentialQueryProcessor, EMPTY_DIFFERENTIAL, EncodingType, FalsyComparator, FetchImplementationProvider, FetchStrategy, GetAllQuery, Index, IndexedColumn, InvalidSQLCharacters, LockType, LogLevel, MAX_AMOUNT_OF_COLUMNS, MAX_OP_ID, MEMORY_TRIGGER_CLAIM_MANAGER, Mutex, OnChangeQueryProcessor, OpType, OpTypeEnum, OplogEntry, PSInternalTable, PowerSyncControlCommand, RowUpdateType, Schema, Semaphore, SqliteBucketStorage, SyncClientImplementation, SyncDataBatch, SyncDataBucket, SyncProgress, SyncStatus, SyncStreamConnectionMethod, SyncingService, Table, TableV2, TriggerManagerImpl, UpdateType, UploadQueueStats, WatchedQueryListenerEvent, attachmentFromSql, column, compilableQueryWatch, createBaseLogger, createLogger, extractTableUpdates, isBatchedUpdateNotification, isContinueCheckpointRequest, isDBAdapter, isPowerSyncDatabaseOptionsWithSettings, isSQLOpenFactory, isSQLOpenOptions, isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncCheckpointPartiallyComplete, isStreamingSyncData, isSyncNewCheckpointRequest, parseQuery, runOnSchemaChange, sanitizeSQL, sanitizeUUID, timeoutSignal };
-export type { AbstractQueryProcessorOptions, AbstractRemoteOptions, AbstractStreamingSyncImplementationOptions, AdditionalConnectionOptions, ArrayComparatorOptions, ArrayQueryDefinition, AttachmentData, AttachmentErrorHandler, AttachmentRecord, AttachmentTableOptions, BSONImplementation, BaseColumnType, BaseConnectionOptions, BaseListener, BaseObserverInterface, BasePowerSyncDatabaseOptions, BaseTriggerDiffRecord, BatchedUpdateNotification, BucketChecksum, BucketDescription, BucketOperationProgress, BucketRequest, BucketState, BucketStorageAdapter, BucketStorageListener, Checkpoint, ChecksumCache, ColumnOptions, ColumnsType, CompilableQuery, CompilableQueryWatchHandler, CompiledQuery, ConnectionManagerListener, ConnectionManagerOptions, ConnectionManagerSyncImplementationResult, ConnectionPool, ContinueCheckpointRequest, ControlledExecutorOptions, CreateDiffTriggerOptions, CreateLoggerOptions, CreateSyncImplementationOptions, CrudRequest, CrudResponse, CrudUploadNotification, DBAdapter, DBAdapterListener, DBGetUtils, DBLockOptions, DataStreamCallback, DataStreamListener, DataStreamOptions, DifferentialQueryProcessorOptions, DifferentialWatchedQuery, DifferentialWatchedQueryComparator, DifferentialWatchedQueryListener, DifferentialWatchedQueryOptions, DifferentialWatchedQuerySettings, DisconnectAndClearOptions, Disposable, ExtractColumnValueType, ExtractedTriggerDiffRecord, FetchImplementation, GetAllQueryOptions, IndexColumnOptions, IndexOptions, IndexShorthand, InternalConnectionOptions, InternalSubscriptionAdapter, LinkQueryOptions, LocalStorageAdapter, LockContext, LockOptions, MutableWatchedQueryState, OnChangeQueryProcessorOptions, OpId, OpTypeJSON, OplogEntryJSON, ParsedQuery, PendingStatement, PendingStatementParameter, PowerSyncBackendConnector, PowerSyncCloseOptions, PowerSyncConnectionOptions, PowerSyncCredentials, PowerSyncDBListener, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, PowerSyncOpenFactoryOptions, ProgressWithOperations, Query, QueryParam, QueryResult, RawTableType, RemoteConnector, RemoteStorageAdapter, RequiredAdditionalConnectionOptions, RequiredPowerSyncConnectionOptions, RowType, SQLOnChangeOptions, SQLOpenFactory, SQLOpenOptions, SQLWatchOptions, SavedProgress, SchemaTableType, SocketSyncStreamOptions, SqlExecutor, StandardWatchedQuery, StandardWatchedQueryOptions, StreamingSyncCheckpoint, StreamingSyncCheckpointComplete, StreamingSyncCheckpointDiff, StreamingSyncCheckpointPartiallyComplete, StreamingSyncDataJSON, StreamingSyncImplementation, StreamingSyncImplementationListener, StreamingSyncKeepalive, StreamingSyncLine, StreamingSyncLineOrCrudUploadComplete, StreamingSyncRequest, StreamingSyncRequestParameterType, SubscribedStream, SyncDataBucketJSON, SyncDataFlowStatus, SyncLocalDatabaseResult, SyncNewCheckpointRequest, SyncPriorityStatus, SyncRequest, SyncResponse, SyncStatusOptions, SyncStream, SyncStreamDescription, SyncStreamOptions, SyncStreamStatus, SyncStreamSubscribeOptions, SyncStreamSubscription, SyncSubscriptionDescription, TableOptions, TableOrRawTableOptions, TableUpdateOperation, TableV2Options, TrackDiffOptions, TrackPreviousOptions, Transaction, TriggerClaimManager, TriggerCreationHooks, TriggerDiffDeleteRecord, TriggerDiffHandlerContext, TriggerDiffInsertRecord, TriggerDiffRecord, TriggerDiffUpdateRecord, TriggerManager, TriggerManagerConfig, TriggerRemoveCallback, TriggerRemoveCallbackOptions, UnlockFn, UpdateNotification, WatchCompatibleQuery, WatchExecuteOptions, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, WatchedAttachmentItem, WatchedQuery, WatchedQueryComparator, WatchedQueryDifferential, WatchedQueryListener, WatchedQueryOptions, WatchedQueryRowDifferential, WatchedQuerySettings, WatchedQueryState, WithDiffOptions };
+export { ATTACHMENT_TABLE, AbortOperation, AbstractPowerSyncDatabase, AbstractPowerSyncDatabaseOpenFactory, AbstractQueryProcessor, AbstractRemote, AbstractStreamingSyncImplementation, ArrayComparator, AttachmentContext, AttachmentQueue, AttachmentService, AttachmentState, AttachmentTable, BaseObserver, Column, ColumnType, ConnectionClosedError, ConnectionManager, ControlledExecutor, CrudBatch, CrudEntry, CrudTransaction, DBAdapterDefaultMixin, DBGetUtilsDefaultMixin, DEFAULT_CRUD_BATCH_LIMIT, DEFAULT_CRUD_UPLOAD_THROTTLE_MS, DEFAULT_INDEX_COLUMN_OPTIONS, DEFAULT_INDEX_OPTIONS, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_POWERSYNC_CLOSE_OPTIONS, DEFAULT_POWERSYNC_DB_OPTIONS, DEFAULT_REMOTE_LOGGER, DEFAULT_REMOTE_OPTIONS, DEFAULT_RETRY_DELAY_MS, DEFAULT_ROW_COMPARATOR, DEFAULT_STREAMING_SYNC_OPTIONS, DEFAULT_STREAM_CONNECTION_OPTIONS, DEFAULT_SYNC_CLIENT_IMPLEMENTATION, DEFAULT_TABLE_OPTIONS, DEFAULT_WATCH_QUERY_OPTIONS, DEFAULT_WATCH_THROTTLE_MS, DiffTriggerOperation, DifferentialQueryProcessor, EMPTY_DIFFERENTIAL, EncodingType, FalsyComparator, FetchImplementationProvider, FetchStrategy, GetAllQuery, Index, IndexedColumn, InvalidSQLCharacters, LockType, LogLevel, MAX_AMOUNT_OF_COLUMNS, MAX_OP_ID, MEMORY_TRIGGER_CLAIM_MANAGER, Mutex, OnChangeQueryProcessor, PSInternalTable, PowerSyncControlCommand, RowUpdateType, Schema, Semaphore, SqliteBucketStorage, SyncClientImplementation, SyncProgress, SyncStatus, SyncStreamConnectionMethod, SyncingService, Table, TableV2, TriggerManagerImpl, UpdateType, UploadQueueStats, WatchedQueryListenerEvent, attachmentFromSql, column, compilableQueryWatch, createBaseLogger, createLogger, extractTableUpdates, isBatchedUpdateNotification, isDBAdapter, isPowerSyncDatabaseOptionsWithSettings, isSQLOpenFactory, isSQLOpenOptions, parseQuery, runOnSchemaChange, sanitizeSQL, sanitizeUUID, timeoutSignal };
+export type { AbstractQueryProcessorOptions, AbstractRemoteOptions, AbstractStreamingSyncImplementationOptions, AdditionalConnectionOptions, ArrayComparatorOptions, ArrayQueryDefinition, AttachmentData, AttachmentErrorHandler, AttachmentRecord, AttachmentTableOptions, BaseColumnType, BaseConnectionOptions, BaseListener, BaseObserverInterface, BasePowerSyncDatabaseOptions, BaseTriggerDiffRecord, BatchedUpdateNotification, BucketStorageAdapter, BucketStorageListener, ColumnOptions, ColumnsType, CompilableQuery, CompilableQueryWatchHandler, CompiledQuery, ConnectionManagerListener, ConnectionManagerOptions, ConnectionManagerSyncImplementationResult, ConnectionPool, ControlledExecutorOptions, CreateDiffTriggerOptions, CreateLoggerOptions, CreateSyncImplementationOptions, DBAdapter, DBAdapterListener, DBGetUtils, DBLockOptions, DifferentialQueryProcessorOptions, DifferentialWatchedQuery, DifferentialWatchedQueryComparator, DifferentialWatchedQueryListener, DifferentialWatchedQueryOptions, DifferentialWatchedQuerySettings, DisconnectAndClearOptions, Disposable, ExtractColumnValueType, ExtractedTriggerDiffRecord, FetchImplementation, GetAllQueryOptions, IndexColumnOptions, IndexOptions, IndexShorthand, InternalConnectionOptions, InternalSubscriptionAdapter, LinkQueryOptions, LocalStorageAdapter, LockContext, LockOptions, MutableWatchedQueryState, OnChangeQueryProcessorOptions, OpId, ParsedQuery, PendingStatement, PendingStatementParameter, PowerSyncBackendConnector, PowerSyncCloseOptions, PowerSyncConnectionOptions, PowerSyncCredentials, PowerSyncDBListener, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, PowerSyncOpenFactoryOptions, ProgressWithOperations, Query, QueryParam, QueryResult, RawTableType, RemoteConnector, RemoteStorageAdapter, RequiredAdditionalConnectionOptions, RequiredPowerSyncConnectionOptions, RowType, SQLOnChangeOptions, SQLOpenFactory, SQLOpenOptions, SQLWatchOptions, SchemaTableType, SimpleAsyncIterator, SocketSyncStreamOptions, SqlExecutor, StandardWatchedQuery, StandardWatchedQueryOptions, StreamingSyncImplementation, StreamingSyncImplementationListener, StreamingSyncRequestParameterType, SubscribedStream, SyncDataFlowStatus, SyncPriorityStatus, SyncStatusOptions, SyncStream, SyncStreamDescription, SyncStreamOptions, SyncStreamStatus, SyncStreamSubscribeOptions, SyncStreamSubscription, SyncSubscriptionDescription, TableOptions, TableOrRawTableOptions, TableUpdateOperation, TableV2Options, TrackDiffOptions, TrackPreviousOptions, Transaction, TriggerClaimManager, TriggerCreationHooks, TriggerDiffDeleteRecord, TriggerDiffHandlerContext, TriggerDiffInsertRecord, TriggerDiffRecord, TriggerDiffUpdateRecord, TriggerManager, TriggerManagerConfig, TriggerRemoveCallback, TriggerRemoveCallbackOptions, UnlockFn, UpdateNotification, WatchCompatibleQuery, WatchExecuteOptions, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, WatchedAttachmentItem, WatchedQuery, WatchedQueryComparator, WatchedQueryDifferential, WatchedQueryListener, WatchedQueryOptions, WatchedQueryRowDifferential, WatchedQuerySettings, WatchedQueryState, WithDiffOptions };