@syncular/client 0.30.12 → 0.30.13

package/dist/client.d.ts

@@ -104,6 +104,7 @@ export interface SyncClientLimits {
     readonly outcomeRetentionMaxEntries?: number;
 }
 export interface SyncClientConfig {
+    readonly transportEnabled?: boolean;
     /** Keep rejected/conflicting local intent visible until explicit resolution. */
     readonly retainFailedCommits?: boolean;
     readonly database: ClientDatabase;
@@ -295,6 +296,8 @@ export declare class SyncClient {
     /** Acquire leadership, create local tables, resolve the clientId. */
     start(): Promise<void>;
     close(): Promise<void>;
+    /** Host-owned transport policy; the local replica remains available. */
+    setTransportEnabled(enabled: boolean): void;
     /** Current fail-closed local-replica security state. */
     securityLifecycle(): SecurityLifecycle;
     /**

package/dist/client.js

@@ -133,6 +133,7 @@ export class SyncClient {
     /** RFC 0005 resolved capture budgets; undefined ⇒ feature off. */
     #previousVersion;
     #securityLifecycle;
+    #transportEnabled;
     #now;
     #outcomeRetentionMaxEntries;
     #retainFailedCommits;
@@ -221,6 +222,11 @@ export class SyncClient {
     #protectedAsync = new Set();
     #preflightBarrier;
     constructor(config) {
+        if (config.transportEnabled !== undefined &&
+            typeof config.transportEnabled !== 'boolean') {
+            throw invalidRequest('transportEnabled must be a boolean');
+        }
+        this.#transportEnabled = config.transportEnabled !== false;
         if (config.securityPreflight === true && config.encryption !== undefined) {
             throw invalidRequest('securityPreflight and encryption are mutually exclusive; activateSecurity installs keys');
         }
@@ -537,6 +543,8 @@ export class SyncClient {
         this.#syncIntentListeners.clear();
     }
     #emitSyncNeeded(reason) {
+        if (!this.#transportEnabled)
+            return;
         try {
             this.#config.onSyncNeeded?.(reason);
         }
@@ -553,6 +561,8 @@ export class SyncClient {
         }
     }
     #emitSyncIntent(intent) {
+        if (!this.#transportEnabled && intent.kind !== 'none')
+            return;
         try {
             this.#config.onSyncIntent?.(intent);
         }
@@ -568,6 +578,25 @@ export class SyncClient {
             }
         }
     }
+    /** Host-owned transport policy; the local replica remains available. */
+    setTransportEnabled(enabled) {
+        this.#requireStarted();
+        if (typeof enabled !== 'boolean')
+            throw invalidRequest('transportEnabled must be a boolean');
+        if (this.#transportEnabled === enabled)
+            return;
+        this.#transportEnabled = enabled;
+        if (!enabled && !this.#syncOutstanding)
+            this.disconnectRealtime();
+        this.#emitSyncIntent(enabled && this.#securityLifecycle === 'active'
+            ? { kind: 'interactive' }
+            : { kind: 'none' });
+        this.#emitDiagnostics();
+    }
+    #requireTransport() {
+        if (!this.#transportEnabled)
+            throw new ClientSyncError('sync.offline', 'transport gate is closed');
+    }
     /** Current fail-closed local-replica security state. */
     securityLifecycle() {
         return this.#securityLifecycle;
@@ -1028,12 +1057,14 @@ export class SyncClient {
         }
         const capturedAtMs = this.#now();
         const leaseState = this.#diagnosticLease(capturedAtMs);
-        const connectivity = this.#lastRound?.status === 'succeeded'
-            ? 'online'
-            : this.#lastRound?.status === 'failed' &&
-                this.#transportFailureCode(this.#lastRound.errorCode)
-                ? 'offline'
-                : 'unknown';
+        const connectivity = !this.#transportEnabled
+            ? 'offline'
+            : this.#lastRound?.status === 'succeeded'
+                ? 'online'
+                : this.#lastRound?.status === 'failed' &&
+                    this.#transportFailureCode(this.#lastRound.errorCode)
+                    ? 'offline'
+                    : 'unknown';
         const expectedOrder = new Map(expected.map((item, index) => [item.id, index]));
         const allSubscriptions = [...subscriptions.values()].sort((a, b) => {
             const aExpected = expectedOrder.get(a.id);
@@ -1057,16 +1088,12 @@ export class SyncClient {
                 realtimeRetryDelayMs: this.#realtimeRetryDelayMs,
             }),
             securityLifecycle: this.#securityLifecycle,
-            schema: {
+            schema: definedObject({
                 currentVersion: this.#config.schema.version,
                 upgrading: this.#upgrading,
-                ...(this.#schemaFloor?.requiredSchemaVersion !== undefined
-                    ? { requiredVersion: this.#schemaFloor.requiredSchemaVersion }
-                    : {}),
-                ...(this.#schemaFloor?.latestSchemaVersion !== undefined
-                    ? { latestVersion: this.#schemaFloor.latestSchemaVersion }
-                    : {}),
-            },
+                requiredVersion: this.#schemaFloor?.requiredSchemaVersion,
+                latestVersion: this.#schemaFloor?.latestSchemaVersion,
+            }),
             replica: {
                 localRevision: getLocalRevision(this.#db).toString(),
                 syncNeeded: this.#needsPull,
@@ -1246,7 +1273,11 @@ export class SyncClient {
         this.#requireActive();
         const task = Promise.resolve().then(fn);
         this.#protectedAsync.add(task);
-        void task.then(() => this.#protectedAsync.delete(task), () => this.#protectedAsync.delete(task));
+        const settled = () => {
+            if (this.#realtimeConnectPromise === task)
+                this.#realtimeConnectPromise = undefined;
+        };
+        void task.then(settled, settled);
         return task;
     }
     // -- blobs (§5.9) ---------------------------------------------------------
@@ -1272,14 +1303,12 @@ export class SyncClient {
             recordPendingUpload(this.#db, blobId, nowMs, options?.mediaType);
         });
         this.#enforceBlobCacheCap();
-        return {
+        return definedObject({
             blobId,
             byteLength: bytes.length,
-            ...(options?.mediaType !== undefined
-                ? { mediaType: options.mediaType }
-                : {}),
-            ...(options?.name !== undefined ? { name: options.name } : {}),
-        };
+            mediaType: options?.mediaType,
+            name: options?.name,
+        });
     }
     /** Serialize a BlobRef to the canonical string a `blob_ref` column holds. */
     blobRefString(ref) {
@@ -1309,6 +1338,7 @@ export class SyncClient {
         // presign configured) a signed url the client fetches directly. On a url
         // arm the client MUST NOT attach host auth and MUST NOT fall through:
         // failure => re-request, the caller's next fetchBlob mints a fresh url.
+        this.#requireTransport();
         const response = await transport.download(blobId);
         let bytes;
         if (response.kind === 'url') {
@@ -1350,6 +1380,7 @@ export class SyncClient {
     }
     /** Flush any queued blob uploads (§5.9.7 B4); safe to call standalone. */
     flushBlobUploads() {
+        this.#requireTransport();
         return this.#runProtectedAsync(() => this.#flushBlobUploads());
     }
     async #flushBlobUploads() {
@@ -1443,12 +1474,9 @@ export class SyncClient {
         else if (replacement !== undefined) {
             throw invalidRequest('replacementClientCommitId is valid only for superseded outcomes');
         }
-        const allowed = (current.status === 'conflict' &&
+        const allowed = ((current.status === 'conflict' || current.status === 'rejected') &&
             (input.resolution === 'resolved_keep_server' ||
                 input.resolution === 'superseded')) ||
-            (current.status === 'rejected' &&
-                (input.resolution === 'superseded' ||
-                    input.resolution === 'resolved_keep_server')) ||
             ((current.status === 'applied' || current.status === 'cached') &&
                 input.resolution === 'dismissed');
         if (!allowed) {
@@ -1529,6 +1557,7 @@ export class SyncClient {
      */
     setPresence(scopeKey, doc) {
         this.#requireActive();
+        this.#requireTransport();
         const socket = this.#socket;
         if (socket === undefined) {
             throw invalidRequest('setPresence requires a connected realtime socket (§8.6)');
@@ -1667,7 +1696,9 @@ export class SyncClient {
             }
         });
         const effects = {
-            sync: changed || widened ? { kind: 'interactive' } : { kind: 'none' },
+            sync: this.#transportEnabled && (changed || widened)
+                ? { kind: 'interactive' }
+                : { kind: 'none' },
         };
         if (effects.sync.kind === 'interactive') {
             this.#emitSyncIntent(effects.sync);
@@ -1922,7 +1953,9 @@ export class SyncClient {
     mutateCommand(mutations) {
         return {
             value: this.mutate(mutations),
-            effects: { sync: { kind: 'interactive' } },
+            effects: {
+                sync: { kind: this.#transportEnabled ? 'interactive' : 'none' },
+            },
         };
     }
     /**
@@ -1943,17 +1976,15 @@ export class SyncClient {
             throw invalidRequest(`table ${compiled.name}: patch cannot change the primary key`);
         }
         return this.#recordMutations([
-            {
+            definedObject({
                 table,
                 op: 'patch',
                 values: {
                     ...Object.fromEntries(normalized),
                     [pkColumn.name]: rowId,
                 },
-                ...(options?.baseVersion !== undefined
-                    ? { baseVersion: options.baseVersion }
-                    : {}),
-            },
+                baseVersion: options?.baseVersion,
+            }),
         ]);
     }
     /**
@@ -2187,7 +2218,9 @@ export class SyncClient {
     patchCommand(table, rowId, partial, options) {
         return {
             value: this.patch(table, rowId, partial, options),
-            effects: { sync: { kind: 'interactive' } },
+            effects: {
+                sync: { kind: this.#transportEnabled ? 'interactive' : 'none' },
+            },
         };
     }
     // -- lease state (§7.3.5) ---------------------------------------------------
@@ -2282,16 +2315,14 @@ export class SyncClient {
                 retainFailedRows(this.#db, commit, listOutboxBeforeImages(this.#db, commit.clientCommitId));
             this.#rollbackFailedCommit(commit, batch);
             this.#replayOutbox();
-            const rejection = {
+            const rejection = definedObject({
                 clientCommitId: commit.clientCommitId,
                 opIndex: 0,
                 code,
                 message,
                 retryable: false,
-                ...(commit.operations[0] !== undefined
-                    ? { operation: commit.operations[0] }
-                    : {}),
-            };
+                operation: commit.operations[0],
+            });
             this.#rejections.push(rejection);
             recordCommitOutcome(this.#db, {
                 clientCommitId: commit.clientCommitId,
@@ -2319,7 +2350,7 @@ export class SyncClient {
     sync() {
         this.#requireActive();
         if (this.#syncOutstanding) {
-            return Promise.reject(invalidRequest('sync() is already running — the core owns one loop (coalesce wake-ups)'));
+            return Promise.reject(invalidRequest('sync() is already running; coalesce wake-ups'));
         }
         this.#syncOutstanding = true;
         this.#beginDiagnosticsDeferral();
@@ -2361,6 +2392,8 @@ export class SyncClient {
         })
             .finally(() => {
             this.#syncOutstanding = false;
+            if (!this.#transportEnabled)
+                this.disconnectRealtime();
             this.#endDiagnosticsDeferral();
         });
     }
@@ -2393,6 +2426,7 @@ export class SyncClient {
             : 'client.unknown_failure';
     }
     async #runSync() {
+        this.#requireTransport();
         this.#roundRetryDelayMs = undefined;
         this.#progress.emit({
             attempt: ++this.#progressAttempt,
@@ -2422,7 +2456,7 @@ export class SyncClient {
             if (logEpoch !== undefined &&
                 this.#hasBlobs &&
                 this.#config.blobs !== undefined) {
-                await this.flushBlobUploads();
+                await this.#flushBlobUploads();
             }
             // §7.4.4: encode the outbox with the CURRENT codec; a commit that
             // cannot express itself under the new schema (a dropped column/table)
@@ -2538,6 +2572,8 @@ export class SyncClient {
         for (let round = 0; round < budget; round++) {
             const before = JSON.stringify(loadSubscriptions(this.#db).map((sub) => [sub.id, sub.bootstrapState]));
             last = await this.sync();
+            if (!this.#transportEnabled || last.schemaFloor !== undefined)
+                return last;
             if (maxRounds === undefined &&
                 last.segmentRowsApplied > 0 &&
                 last.bootstrapping.length > 0 &&
@@ -2547,8 +2583,6 @@ export class SyncClient {
                         sub.bootstrapState,
                     ])))
                 round = -1;
-            if (last.schemaFloor !== undefined)
-                return last;
             if (last.commitsApplied === 0 &&
                 last.segmentRowsApplied === 0 &&
                 last.bootstrapping.length === 0 &&
@@ -2640,6 +2674,7 @@ export class SyncClient {
     }
     connectRealtime() {
         this.#requireActive();
+        this.#requireTransport();
         if (this.#realtimePolicy === 'off') {
             return Promise.reject(invalidRequest("realtimePolicy is 'off'; realtime connect is refused"));
         }
@@ -2695,9 +2730,13 @@ export class SyncClient {
                 },
             });
             openedSocket = socket;
+            if (!this.#transportEnabled) {
+                socket.close();
+                this.#requireTransport();
+            }
             if (this.#securityLifecycle === 'preflight') {
                 socket.close();
-                throw new ClientSyncError(SECURITY_PREFLIGHT_REQUIRED_CODE, 'realtime connected after the client entered security preflight');
+                this.#requireActive();
             }
             if (generation !== this.#realtimeGeneration || !this.#started) {
                 socket.close();
@@ -2834,6 +2873,8 @@ export class SyncClient {
         }
     }
     async #handleRealtimeBinary(bytes) {
+        if (!this.#transportEnabled)
+            return;
         if (this.#syncing) {
             // Fast path: a pull is mid-flight; let it win and recover the gap
             // itself — re-pulling is idempotent, interleaved application is not
@@ -2862,7 +2903,8 @@ export class SyncClient {
         });
     }
     #sendAck(cursor) {
-        this.#socket?.send(JSON.stringify({ type: 'ack', cursor }));
+        if (this.#transportEnabled)
+            this.#socket?.send(JSON.stringify({ type: 'ack', cursor }));
     }
     /** Ack the highest cursor that is contiguously applied for every sub. */
     #ackAfterPull() {
@@ -3017,58 +3059,24 @@ export class SyncClient {
                             await this.#applyCommit(frame, summary);
                         }
                         break;
-                    case 'SEGMENT_INLINE': {
-                        if (section === undefined ||
-                            section.skip ||
-                            section.sub === undefined) {
-                            break;
-                        }
-                        const segment = decodeRowsSegment(frame.payload);
-                        this.#progress.update({
-                            phase: 'import',
-                            subscriptionId: section.sub.id,
-                            table: section.sub.table,
-                            segmentId: undefined,
-                            bytesReceived: frame.payload.byteLength,
-                            bytesTotal: frame.payload.byteLength,
-                            rowsProcessed: 0,
-                            rowsTotal: segment.blocks.reduce((n, block) => n + block.length, 0),
-                        });
-                        await this.#applySegmentOrFail(section, summary, (table, clearFirst, effective) => applyRowsSegment(this.#db, this.#schema, table, segment, {
-                            clearFirst,
-                            isCurrent: () => this.#localResetEpoch === resetEpoch,
-                            onProgress: (rowsProcessed) => this.#progress.update({ rowsProcessed }),
-                            effective,
-                            transaction: (fn) => this.#applyBatch((batch) => {
-                                if (segment.blocks.some((block) => block.length > 0) ||
-                                    (clearFirst &&
-                                        this.#scopedRowsExist(table, effective))) {
-                                    batch.table(table.name);
-                                }
-                                const result = fn();
-                                this.#replayOutbox();
-                                return result;
-                            }),
-                        }, this.#encryption), section.fresh && !section.cleared);
-                        break;
-                    }
+                    case 'SEGMENT_INLINE':
                     case 'SEGMENT_REF': {
                         if (section === undefined ||
                             section.skip ||
-                            section.sub === undefined) {
+                            section.sub === undefined)
                             break;
-                        }
-                        // §4.2: a descriptor whose mediaType was not advertised is a
-                        // broken server — fail loud, never skip or guess.
-                        if (frame.mediaType === 'sqlite' &&
+                        if (frame.type === 'SEGMENT_REF' &&
+                            frame.mediaType === 'sqlite' &&
                             (this.#acceptMask() & ACCEPT_SQLITE) === 0) {
                             throw invalidRequest('SEGMENT_REF mediaType sqlite was not advertised in accept (§4.2)');
                         }
-                        const bytes = await this.#downloadSegment(frame, section.sub);
-                        this.#progress.update({ phase: 'import' });
-                        if (frame.mediaType === 'sqlite') {
-                            // §5.3: images are whole-table — a paged descriptor is
-                            // invalid, and the image is always its table's first page.
+                        const bytes = frame.type === 'SEGMENT_REF'
+                            ? await this.#downloadSegment(frame, section.sub)
+                            : frame.payload;
+                        if (frame.type === 'SEGMENT_REF')
+                            this.#progress.update({ phase: 'import' });
+                        if (frame.type === 'SEGMENT_REF' && frame.mediaType === 'sqlite') {
+                            // Images are whole-table; paged image descriptors are invalid.
                             if (frame.rowCursor !== undefined ||
                                 frame.nextRowCursor !== undefined) {
                                 throw invalidRequest('sqlite segments are whole-table: rowCursor/nextRowCursor must be absent (§5.3)');
@@ -3078,43 +3086,26 @@ export class SyncClient {
                                 rowCount: frame.rowCount,
                                 asOfCommitSeq: frame.asOfCommitSeq,
                                 scopeDigest: frame.scopeDigest,
-                            }, {
-                                clearFirst,
-                                isCurrent: () => this.#localResetEpoch === resetEpoch,
-                                onProgress: (rowsProcessed) => this.#progress.update({ rowsProcessed }),
-                                effective,
-                                transaction: (fn) => this.#applyBatch((batch) => {
-                                    if (frame.rowCount > 0 ||
-                                        (clearFirst &&
-                                            this.#scopedRowsExist(table, effective))) {
-                                        batch.table(table.name);
-                                    }
-                                    const result = fn();
-                                    this.#replayOutbox();
-                                    return result;
-                                }),
-                            }), section.fresh && !section.cleared);
+                            }, this.#segmentApplyOptions(table, clearFirst, effective, frame.rowCount > 0, resetEpoch)), section.fresh && !section.cleared);
                         }
                         else {
                             const segment = decodeRowsSegment(bytes);
-                            await this.#applySegmentOrFail(section, summary, (table, clearFirst, effective) => applyRowsSegment(this.#db, this.#schema, table, segment, {
-                                clearFirst,
-                                isCurrent: () => this.#localResetEpoch === resetEpoch,
-                                onProgress: (rowsProcessed) => this.#progress.update({ rowsProcessed }),
-                                effective,
-                                transaction: (fn) => this.#applyBatch((batch) => {
-                                    if (segment.blocks.some((block) => block.length > 0) ||
-                                        (clearFirst &&
-                                            this.#scopedRowsExist(table, effective))) {
-                                        batch.table(table.name);
-                                    }
-                                    const result = fn();
-                                    this.#replayOutbox();
-                                    return result;
-                                }),
-                            }, this.#encryption), section.fresh &&
+                            if (frame.type === 'SEGMENT_INLINE') {
+                                this.#progress.update({
+                                    phase: 'import',
+                                    subscriptionId: section.sub.id,
+                                    table: section.sub.table,
+                                    segmentId: undefined,
+                                    bytesReceived: bytes.byteLength,
+                                    bytesTotal: bytes.byteLength,
+                                    rowsProcessed: 0,
+                                    rowsTotal: segment.blocks.reduce((n, block) => n + block.length, 0),
+                                });
+                            }
+                            await this.#applySegmentOrFail(section, summary, (table, clearFirst, effective) => applyRowsSegment(this.#db, this.#schema, table, segment, this.#segmentApplyOptions(table, clearFirst, effective, segment.blocks.some((block) => block.length > 0), resetEpoch), this.#encryption), section.fresh &&
                                 !section.cleared &&
-                                frame.rowCursor === undefined);
+                                (frame.type === 'SEGMENT_INLINE' ||
+                                    frame.rowCursor === undefined));
                         }
                         break;
                     }
@@ -3378,6 +3369,23 @@ export class SyncClient {
         return (scope !== undefined &&
             this.#db.query(`SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${scope.sql} LIMIT 1`, scope.params).length > 0);
     }
+    /** Shared transaction, reset fence and progress for both segment formats. */
+    #segmentApplyOptions(table, clearFirst, effective, hasRows, resetEpoch) {
+        return {
+            clearFirst,
+            effective,
+            isCurrent: () => this.#localResetEpoch === resetEpoch,
+            onProgress: (rowsProcessed) => this.#progress.update({ rowsProcessed }),
+            transaction: (fn) => this.#applyBatch((batch) => {
+                if (hasRows ||
+                    (clearFirst && this.#scopedRowsExist(table, effective)))
+                    batch.table(table.name);
+                const result = fn();
+                this.#replayOutbox();
+                return result;
+            }),
+        };
+    }
     /**
      * Apply a segment (rows or sqlite image); a §5.6/§3.3 fail-closed error
      * (no local scope-column mapping) marks the subscription `failed` and

package/dist/worker-entry.js

@@ -94,6 +94,7 @@ export function startSyncWorker(overrides = {}) {
         autoSyncScheduled = false;
         if (closed ||
             client === undefined ||
+            offline ||
             client.securityLifecycle() === 'preflight') {
             return;
         }
@@ -116,6 +117,7 @@ export function startSyncWorker(overrides = {}) {
         if (!autoSync ||
             closed ||
             client === undefined ||
+            offline ||
             client.securityLifecycle() === 'preflight' ||
             intent.kind === 'none') {
             return;
@@ -156,31 +158,6 @@ export function startSyncWorker(overrides = {}) {
         }
         return client;
     }
-    function assertOnline() {
-        if (offline) {
-            throw new ClientSyncError('sync.transport_failed', 'the worker transport is offline (setOffline(true))', true);
-        }
-    }
-    function gateOffline(inner) {
-        return (request) => {
-            assertOnline();
-            return inner(request);
-        };
-    }
-    /** Offline gate that preserves the §5.4 `fetchUrl` capability marker. */
-    function gateSegmentsOffline(inner) {
-        const fetchUrl = inner.fetchUrl;
-        return Object.assign(gateOffline(inner), {
-            ...(fetchUrl !== undefined
-                ? {
-                    fetchUrl: (url, onProgress) => {
-                        assertOnline();
-                        return fetchUrl(url, onProgress);
-                    },
-                }
-                : {}),
-        });
-    }
     async function init(config) {
         if (client !== undefined) {
             throw new ClientSyncError(WORKER_FAILED_CODE, 'the worker is already initialized');
@@ -215,9 +192,9 @@ export function startSyncWorker(overrides = {}) {
                 }
             }
         }
-        const transport = gateOffline(overrides.createTransport !== undefined
+        const transport = overrides.createTransport !== undefined
             ? overrides.createTransport(config)
-            : httpSyncTransport(config.endpoints.syncUrl, http));
+            : httpSyncTransport(config.endpoints.syncUrl, http);
         const segments = overrides.createSegments !== undefined
             ? overrides.createSegments(config)
             : config.endpoints.segmentsUrl !== undefined
@@ -231,18 +208,15 @@ export function startSyncWorker(overrides = {}) {
         // `{clientId}` URL placeholder — start the client first, then attach
         // the connector through a mutable slot read at connect time.
         let realtimeConnector;
+        offline = config.transportEnabled === false;
         const started = new SyncClient({
+            transportEnabled: !offline,
             database,
             schema: config.schema,
             transport,
-            ...(segments !== undefined
-                ? { segments: gateSegmentsOffline(segments) }
-                : {}),
+            ...(segments !== undefined ? { segments } : {}),
             ...(blobs !== undefined ? { blobs } : {}),
             realtime: (handlers) => {
-                if (offline) {
-                    throw new ClientSyncError('sync.transport_failed', 'the worker realtime channel is offline (setOffline(true))', true);
-                }
                 if (realtimeConnector === undefined) {
                     throw new ClientSyncError('sync.invalid_request', 'no realtime connector configured');
                 }
@@ -399,8 +373,13 @@ export function startSyncWorker(overrides = {}) {
         },
         setOffline: (value) => {
             offline = value;
-            if (offline)
-                client?.disconnectRealtime();
+            requireClient().setTransportEnabled(!value);
+            if (offline) {
+                if (backgroundTimer !== undefined)
+                    clearTimeout(backgroundTimer);
+                backgroundTimer = undefined;
+                backgroundDue = Number.POSITIVE_INFINITY;
+            }
             else if (client !== undefined) {
                 const snapshot = client.diagnosticsSnapshot();
                 post({

package/dist/worker-host.d.ts

@@ -85,6 +85,7 @@ export interface SyncClientHandleConfig {
     readonly encryption?: EncryptionKeyringConfig;
     /** Open the worker-owned replica behind the fail-closed security gate. */
     readonly securityPreflight?: boolean;
+    readonly transportEnabled?: boolean;
     readonly clientId?: string;
     readonly limits?: SyncClientLimits;
     readonly retainFailedCommits?: boolean;

package/dist/worker-host.js

@@ -566,6 +566,9 @@ function buildInitConfig(config, headers = config.headers) {
         ...(config.encryption !== undefined
             ? { encryption: config.encryption }
             : {}),
+        ...(config.transportEnabled !== undefined
+            ? { transportEnabled: config.transportEnabled }
+            : {}),
         ...(config.securityPreflight !== undefined
             ? { securityPreflight: config.securityPreflight }
             : {}),

package/dist/worker-protocol.d.ts

@@ -78,6 +78,7 @@ export interface WorkerInitConfig {
     readonly encryption?: EncryptionKeyringConfig;
     /** Open the worker-owned replica behind the fail-closed security gate. */
     readonly securityPreflight?: boolean;
+    readonly transportEnabled?: boolean;
     readonly clientId?: string;
     readonly limits?: SyncClientLimits;
     readonly retainFailedCommits?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.12",
+  "version": "0.30.13",
   "description": "Syncular TypeScript client core — offline-first sync over SQLite (WASM/OPFS, Bun, Node)",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -89,10 +89,10 @@
   },
   "dependencies": {
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@syncular/core": "0.30.12"
+    "@syncular/core": "0.30.13"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.12",
+    "@syncular/server": "0.30.13",
     "playwright": "1.63.0",
     "@electric-sql/pglite": "^0.5.4"
   }