@syncular/client 0.30.12 → 0.30.14

package/dist/client.js

@@ -1,3 +1,7 @@
+import { BLOB_COMMIT_REFS } from './blob.js';
+import { hasUniqueIndex } from './schema.js';
+import { OUTCOMES_TABLE } from './outcomes.js';
+import { OUTBOX_TABLE } from './outbox.js';
 import { RETAINED_ROWS } from './failed-overlay.js';
 import { dropFailedRows, failedOverlayCommits, retainFailedRows, restoreFailedBases, uniqueConflicts, } from './failed-overlay.js';
 import { ProgressEmitter, } from './progress.js';
@@ -133,6 +137,7 @@ export class SyncClient {
     /** RFC 0005 resolved capture budgets; undefined ⇒ feature off. */
     #previousVersion;
     #securityLifecycle;
+    #transportEnabled;
     #now;
     #outcomeRetentionMaxEntries;
     #retainFailedCommits;
@@ -221,6 +226,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');
         }
@@ -472,6 +482,13 @@ export class SyncClient {
     }
     /** §2.1 reset after the server reports a different log continuity. */
     #runLogEpochReset(logEpoch) {
+        if (getMeta(this.#db, LOG_EPOCH_META_KEY) === undefined) {
+            this.#applyBatch(() => setMeta(this.#db, LOG_EPOCH_META_KEY, logEpoch));
+            this.#setSyncNeeded(true);
+            this.#emitSyncNeeded('startup');
+            this.#emitSyncIntent({ kind: 'interactive' });
+            return [];
+        }
         const subscriptions = loadSubscriptions(this.#db);
         const pending = listOutbox(this.#db);
         this.#setUpgrading(true);
@@ -537,6 +554,8 @@ export class SyncClient {
         this.#syncIntentListeners.clear();
     }
     #emitSyncNeeded(reason) {
+        if (!this.#transportEnabled)
+            return;
         try {
             this.#config.onSyncNeeded?.(reason);
         }
@@ -553,6 +572,8 @@ export class SyncClient {
         }
     }
     #emitSyncIntent(intent) {
+        if (!this.#transportEnabled && intent.kind !== 'none')
+            return;
         try {
             this.#config.onSyncIntent?.(intent);
         }
@@ -568,6 +589,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 +1068,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 +1099,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,
@@ -1101,8 +1139,8 @@ export class SyncClient {
         try {
             const pageCount = Number(this.#db.query('PRAGMA page_count')[0]?.page_count ?? 0);
             const pageSize = Number(this.#db.query('PRAGMA page_size')[0]?.page_size ?? 0);
-            const outboxBytes = Number(this.#db.query('SELECT COALESCE(SUM(LENGTH(operations)),0)AS bytes FROM _syncular_outbox')[0]?.bytes ?? 0);
-            const outcome = this.#db.query('SELECT COUNT(*)AS entries,COALESCE(SUM(LENGTH(results)+ COALESCE(LENGTH(operations),0)),0)AS bytes FROM _syncular_commit_outcomes')[0];
+            const outboxBytes = Number(this.#db.query(`SELECT COALESCE(SUM(LENGTH(operations)),0)AS bytes FROM ${OUTBOX_TABLE}`)[0]?.bytes ?? 0);
+            const outcome = this.#db.query(`SELECT COUNT(*)AS entries,COALESCE(SUM(LENGTH(results)+ COALESCE(LENGTH(operations),0)),0)AS bytes FROM ${OUTCOMES_TABLE}`)[0];
             const blobBytes = this.#hasBlobs
                 ? Number(this.#db.query('SELECT COALESCE(SUM(byte_length),0)AS bytes FROM _syncular_blobs')[0]?.bytes ?? 0)
                 : 0;
@@ -1246,7 +1284,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 +1314,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 +1349,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 +1391,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 +1485,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 +1568,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 +1707,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);
@@ -1894,7 +1936,7 @@ export class SyncClient {
                         catch {
                             continue;
                         }
-                        this.#db.exec('INSERT OR IGNORE INTO _syncular_blob_commit_refs(commit_id,blob_id)SELECT ?,? WHERE EXISTS(SELECT 1 FROM _syncular_blobs WHERE blob_id=?)', [clientCommitId, blobId, blobId]);
+                        this.#db.exec(`INSERT OR IGNORE INTO ${BLOB_COMMIT_REFS}(commit_id,blob_id)SELECT ?,? WHERE EXISTS(SELECT 1 FROM _syncular_blobs WHERE blob_id=?)`, [clientCommitId, blobId, blobId]);
                     }
                 }
                 try {
@@ -1922,7 +1964,9 @@ export class SyncClient {
     mutateCommand(mutations) {
         return {
             value: this.mutate(mutations),
-            effects: { sync: { kind: 'interactive' } },
+            effects: {
+                sync: { kind: this.#transportEnabled ? 'interactive' : 'none' },
+            },
         };
     }
     /**
@@ -1943,17 +1987,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 +2229,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) ---------------------------------------------------
@@ -2217,7 +2261,7 @@ export class SyncClient {
     async #encodeOutboxForPush() {
         // Pin before the first encryption await: mutations can append while a
         // round is encoding, and belong to the next request.
-        const bounds = this.#db.query('SELECT COUNT(*)AS count,MAX(seq)AS last_seq FROM _syncular_outbox')[0];
+        const bounds = this.#db.query(`SELECT COUNT(*)AS count,MAX(seq)AS last_seq FROM ${OUTBOX_TABLE}`)[0];
         const pendingCount = bounds.count;
         const throughSeq = bounds.last_seq ?? 0;
         const pushFrames = [];
@@ -2282,16 +2326,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 +2361,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 +2403,8 @@ export class SyncClient {
         })
             .finally(() => {
             this.#syncOutstanding = false;
+            if (!this.#transportEnabled)
+                this.disconnectRealtime();
             this.#endDiagnosticsDeferral();
         });
     }
@@ -2393,6 +2437,7 @@ export class SyncClient {
             : 'client.unknown_failure';
     }
     async #runSync() {
+        this.#requireTransport();
         this.#roundRetryDelayMs = undefined;
         this.#progress.emit({
             attempt: ++this.#progressAttempt,
@@ -2422,7 +2467,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 +2583,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 +2594,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 +2685,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 +2741,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 +2884,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 +2914,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 +3070,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 +3097,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;
                     }
@@ -3149,14 +3151,7 @@ export class SyncClient {
             }
         }
         finally {
-            try {
-                // §7.1: local reads see outbox state applied optimistically — replay
-                // the still-pending commits on top of the freshly applied server state.
-                this.#replayOutbox();
-            }
-            finally {
-                this.#endDiagnosticsDeferral();
-            }
+            this.#endDiagnosticsDeferral();
         }
         if (errorFrame !== undefined)
             throw errorFrame;
@@ -3285,13 +3280,16 @@ export class SyncClient {
             if (this.#retainFailedCommits)
                 retainFailedRows(this.#db, commit, listOutboxBeforeImages(this.#db, commit.clientCommitId));
             this.#rollbackFailedCommit(commit, batch);
+            this.#replayOutbox(commit.operations.map((operation) => JSON.stringify(hasUniqueIndex(this.#table(operation.table))
+                ? [operation.table]
+                : [operation.table, operation.rowId])));
         });
         batch.status();
         summary.rejected.push(frame.clientCommitId);
         return true;
     }
     #outboxCommitExists(clientCommitId) {
-        return (this.#db.query('SELECT 1 FROM _syncular_outbox WHERE client_commit_id=? LIMIT 1', [clientCommitId]).length > 0);
+        return (this.#db.query(`SELECT 1 FROM ${OUTBOX_TABLE} WHERE client_commit_id=? LIMIT 1`, [clientCommitId]).length > 0);
     }
     #decodeServerRow(tableName, payload) {
         if (tableName === undefined)
@@ -3329,7 +3327,7 @@ export class SyncClient {
         await applyCommitFrame(this.#db, this.#schema, frame, this.#encryption, (fn) => this.#applyBatch((batch) => {
             this.#recordCommitChanges(batch, frame);
             const result = fn();
-            this.#replayOutbox(result);
+            this.#replayOutbox(result, false);
             return result;
         }));
         summary.commitsApplied += 1;
@@ -3378,6 +3376,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(result, false);
+                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
@@ -3505,11 +3520,12 @@ export class SyncClient {
                         return matchesLocalScopes(table, effective, values);
                     }));
                     if (covered.length) {
-                        restoreFailedBases(this.#db, this.#schema);
+                        const scope = covered.map((row) => JSON.stringify([sub.table, String(row.id)]));
+                        restoreFailedBases(this.#db, this.#schema, scope);
                         for (const row of covered)
                             this.#db.exec(`DELETE FROM ${RETAINED_ROWS} WHERE tbl=? AND id=? AND commit_seq<=?`, [sub.table, String(row.id), nextCursor]);
                         batch.table(sub.table);
-                        this.#replayOutbox();
+                        this.#replayOutbox(scope, false);
                     }
                 }
                 if (completed && registered !== undefined) {
@@ -3552,9 +3568,11 @@ export class SyncClient {
             if (lastEffective !== undefined &&
                 Object.keys(lastEffective).length > 0) {
                 try {
-                    restoreFailedBases(this.#db, this.#schema);
-                    this.#dropRetainedRows(batch, (name, values) => name === table.name &&
-                        matchesLocalScopes(table, lastEffective, values));
+                    const scope = [
+                        JSON.stringify([table.name]),
+                        ...this.#dropRetainedRows(batch, (name, values) => name === table.name &&
+                            matchesLocalScopes(table, lastEffective, values)),
+                    ];
                     deleteScopedRows(this.#db, table, lastEffective);
                     batch.scopeMap(table, lastEffective);
                     const pendingById = new Map(listOutbox(this.#db).map((commit) => [
@@ -3592,6 +3610,7 @@ export class SyncClient {
                         batch.rejections();
                         batch.outcomes();
                     }
+                    this.#replayOutbox(scope);
                     this.#deleteUnreferencedBlobs();
                 }
                 catch (error) {
@@ -3764,7 +3783,7 @@ export class SyncClient {
                 ? OPTIMISTIC_VERSION
                 : local[SYNC_VERSION_COLUMN];
             if (replay &&
-                table.indexes.some((index) => index.unique) &&
+                hasUniqueIndex(table) &&
                 uniqueConflicts(this.#db, table, Object.fromEntries(table.columns.map((column, index) => [
                     column.name,
                     values[index] ?? null,
@@ -3778,33 +3797,35 @@ export class SyncClient {
         this.#db.exec(`DELETE FROM ${RETAINED_ROWS} WHERE commit_seq IS NOT NULL`);
     }
     #dropRetainedRows(batch, matches) {
-        for (const commit of dropFailedRows(this.#db, matches)) {
+        const scope = [];
+        for (const commit of dropFailedRows(this.#db, this.#schema, matches)) {
             batch.conflicts();
             batch.rejections();
             batch.outcomes();
             this.#conflicts = this.#conflicts.filter((record) => record.clientCommitId !== commit.clientCommitId);
             this.#rejections = this.#rejections.filter((record) => record.clientCommitId !== commit.clientCommitId);
-            for (const op of commit.operations)
+            for (const op of commit.operations) {
                 batch.table(op.table);
+                scope.push(JSON.stringify([op.table, op.rowId]));
+            }
         }
+        return scope;
     }
-    #replayOutbox(rowKeys) {
-        const acknowledged = failedOverlayCommits(this.#db, true, rowKeys);
-        const pending = [
-            ...failedOverlayCommits(this.#db, false, rowKeys),
-            ...listOutbox(this.#db, rowKeys),
-        ].sort((a, b) => a.createdAtMs - b.createdAtMs || a.seq - b.seq);
-        if (pending.length === 0 && acknowledged.length === 0)
+    #replayOutbox(scope, restoreBases = true) {
+        if (scope?.length === 0)
             return;
         this.#applyBatch((batch) => {
-            this.#db.transaction(() => {
-                restoreFailedBases(this.#db, this.#schema, false, rowKeys);
-                restoreFailedBases(this.#db, this.#schema, true, rowKeys);
-                for (const commit of [...acknowledged, ...pending])
-                    this.#applyOperationsLocally(rowKeys === undefined
-                        ? commit.operations
-                        : commit.operations.filter((op) => rowKeys.includes(JSON.stringify([op.table, op.rowId]))), batch, true);
-            });
+            if (restoreBases)
+                restoreFailedBases(this.#db, this.#schema, scope);
+            const acknowledged = failedOverlayCommits(this.#db, true, scope, this.#schema);
+            const pending = [
+                ...failedOverlayCommits(this.#db, false, scope, this.#schema),
+                ...listOutbox(this.#db, scope),
+            ].sort((a, b) => a.createdAtMs - b.createdAtMs || a.seq - b.seq);
+            for (const commit of [...acknowledged, ...pending])
+                this.#applyOperationsLocally(commit.operations.filter((op) => scope === undefined ||
+                    scope.includes(JSON.stringify([op.table, op.rowId])) ||
+                    scope.includes(JSON.stringify([op.table]))), batch, true);
         });
     }
     #deleteUnreferencedBlobs() {