@syncular/client 0.30.10 → 0.30.11

package/dist/client.js

@@ -1,4 +1,4 @@
-import { dropFailedRows, failedOverlayCommits, retainFailedRows, restoreFailedBases, } from './failed-overlay.js';
+import { dropFailedRows, failedOverlayCommits, retainFailedRows, restoreFailedBases, uniqueConflicts, } from './failed-overlay.js';
 import { ProgressEmitter, } from './progress.js';
 /**
  * SyncClient implements the client side of SPEC.md §§3–8.
@@ -26,7 +26,7 @@ import { activeFailureRecords, listCommitOutcomes, persistCommitOutcomeResolutio
 import { assertReadOnlyQuery } from './query-guard.js';
 import { buildPreviousVersionAudit, capturePreviousVersion, clearPreviousVersionAudit, clearPreviousVersionRefusal, dropPreviousVersionContainer, loadLocalSchemaDescriptor, PREVIOUS_VERSION_CONTAINER_NAME, PREVIOUS_VERSION_MAX_LIMIT, readPreviousVersionContainer, readPreviousVersionRows, setLocalSchemaDescriptor, storedPreviousVersionAudit, storedPreviousVersionRefusal, withPreviousVersionContainer, writePreviousVersionAudit, writePreviousVersionRefusal, } from './previous-version.js';
 import { compileClientSchema, dropAndRecreateSyncedTables, ensureLocalBookkeepingSchema, ensureLocalSyncedSchema, fromSqlValue, coerceSqlRepresentation, jsonToRowValue, LOCAL_SCHEMA_VERSION_KEY, normalizeRecordKeys, OPTIMISTIC_VERSION, quoteIdent, recordToRowValues, rowValueToJson, SYNC_VERSION_COLUMN, stripSyncColumns, } from './schema.js';
-import { bumpLocalRevision, deleteSubscription, getLocalRevision, getMeta, getSubscription, loadSubscriptions, pruneUnknownSubscriptions, resetSubscriptionsForBump, saveSubscription, setMeta, } from './state.js';
+import { bumpLocalRevision, deleteSubscription, getLocalRevision, getMeta, getSubscription, loadSubscriptions, pruneUnknownSubscriptions, saveSubscriptionScopeSchema, resetSubscriptionsForBump, saveSubscription, setMeta, } from './state.js';
 import { deletePendingEviction, deleteWindowUnit, deriveSubId, getWindowUnitBySubId, insertWindowUnit, loadPendingEvictions, loadWindowUnits, savePendingEviction, unitScopes, windowBaseKey, } from './window.js';
 /** Stable client-local error while protected operations are preflight-gated. */
 export const SECURITY_PREFLIGHT_REQUIRED_CODE = 'client.security_preflight_required';
@@ -309,7 +309,7 @@ export class SyncClient {
         this.#reconcilePreviousVersionAtBoot();
         // A registration remains app intent only while its table exists in the
         // running schema. Removed-table registrations would poison every pull.
-        const subscriptions = pruneUnknownSubscriptions(this.#db, loadSubscriptions(this.#db), new Set(this.#schema.tables.keys()));
+        const subscriptions = pruneUnknownSubscriptions(this.#db, loadSubscriptions(this.#db), this.#schema);
         this.#started = true;
         // A persisted active subscription needs one catch-up round on every open:
         // realtime only covers changes after the socket connects, and an
@@ -355,6 +355,7 @@ export class SyncClient {
                 ensureLocalSyncedSchema(this.#db, this.#schema);
                 setMeta(this.#db, LOCAL_SCHEMA_VERSION_KEY, String(this.#schema.version));
                 setLocalSchemaDescriptor(this.#db, this.#schema);
+                saveSubscriptionScopeSchema(this.#db, this.#schema);
             });
             return;
         }
@@ -366,6 +367,7 @@ export class SyncClient {
             this.#db.transaction(() => {
                 ensureLocalSyncedSchema(this.#db, this.#schema);
                 setLocalSchemaDescriptor(this.#db, this.#schema);
+                saveSubscriptionScopeSchema(this.#db, this.#schema);
             });
             return;
         }
@@ -393,10 +395,12 @@ export class SyncClient {
                 if (this.#previousVersion !== undefined) {
                     writePreviousVersionAudit(this.#db, buildPreviousVersionAudit(this.#schema, listOutbox(this.#db), previousVersion, this.#schema.version, this.#now()));
                 }
+                pruneUnknownSubscriptions(this.#db, loadSubscriptions(this.#db), this.#schema, true);
                 dropAndRecreateSyncedTables(this.#db, this.#schema);
                 resetSubscriptionsForBump(this.#db);
                 setMeta(this.#db, LOCAL_SCHEMA_VERSION_KEY, String(this.#schema.version));
                 setLocalSchemaDescriptor(this.#db, this.#schema);
+                saveSubscriptionScopeSchema(this.#db, this.#schema);
             });
             // Whole-DB reset: every synced table's rows changed (I1 eviction-shaped).
             for (const table of this.#schema.tables.values())
@@ -709,13 +713,13 @@ export class SyncClient {
                     previous.sqliteCode !== sqliteCode ||
                     previous.tables.join('\0') !== tables.join('\0')) {
                     this.#queryFailures.delete(owner.id);
-                    this.#queryFailures.set(owner.id, {
+                    this.#queryFailures.set(owner.id, definedObject({
                         id: owner.id,
                         tables,
                         code,
-                        ...(sqliteCode !== undefined ? { sqliteCode } : {}),
+                        sqliteCode: sqliteCode,
                         atMs: this.#now(),
-                    });
+                    }));
                     for (const id of this.#queryFailures.keys()) {
                         if (this.#queryFailures.size <= MAX_DIAGNOSTIC_QUERY_FAILURES)
                             break;
@@ -1036,22 +1040,18 @@ export class SyncClient {
             }
             return a.id.localeCompare(b.id);
         });
-        return {
+        return definedObject({
             version: CLIENT_DIAGNOSTICS_VERSION,
             capturedAtMs,
-            host: {
+            host: definedObject({
                 kind: 'direct',
                 role: 'single',
                 connectivity,
                 realtime: this.#realtimeState,
                 realtimePolicy: this.#realtimePolicy,
-                ...(this.#realtimeReasonCode !== undefined
-                    ? { realtimeReasonCode: this.#realtimeReasonCode }
-                    : {}),
-                ...(this.#realtimeRetryDelayMs !== undefined
-                    ? { realtimeRetryDelayMs: this.#realtimeRetryDelayMs }
-                    : {}),
-            },
+                realtimeReasonCode: this.#realtimeReasonCode,
+                realtimeRetryDelayMs: this.#realtimeRetryDelayMs,
+            }),
             securityLifecycle: this.#securityLifecycle,
             schema: {
                 currentVersion: this.#config.schema.version,
@@ -1071,24 +1071,20 @@ export class SyncClient {
             lease: leaseState,
             subscriptions: allSubscriptions.slice(0, MAX_DIAGNOSTIC_EXPECTED_SUBSCRIPTIONS),
             subscriptionsTruncated: allSubscriptions.length > MAX_DIAGNOSTIC_EXPECTED_SUBSCRIPTIONS,
-            ...(this.#lastRound !== undefined ? { lastRound: this.#lastRound } : {}),
-            ...(this.#lastChange !== undefined
-                ? { lastChange: this.#lastChange }
-                : {}),
+            lastRound: this.#lastRound,
+            lastChange: this.#lastChange,
             storage: this.#diagnosticStorage(),
             queryFailures: [...this.#queryFailures.values()],
-        };
+        });
     }
     #diagnosticLease(nowMs) {
         const lease = this.#leaseState;
         if (lease?.errorCode !== undefined) {
-            return {
+            return definedObject({
                 state: 'stopped',
                 errorCode: this.#diagnosticCode(lease.errorCode),
-                ...(lease.expiresAtMs !== undefined
-                    ? { expiresAtMs: lease.expiresAtMs }
-                    : {}),
-            };
+                expiresAtMs: lease.expiresAtMs,
+            });
         }
         if (lease?.expiresAtMs === undefined)
             return { state: 'none' };
@@ -1101,12 +1097,10 @@ 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 _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 blobBytes = this.#hasBlobs
-                ? Number(this.#db.query('SELECT COALESCE(SUM(byte_length), 0) AS bytes FROM _syncular_blobs')[0]?.bytes ?? 0)
+                ? Number(this.#db.query('SELECT COALESCE(SUM(byte_length),0)AS bytes FROM _syncular_blobs')[0]?.bytes ?? 0)
                 : 0;
             const pressure = this.#config.blobCacheMaxBytes !== undefined &&
                 blobBytes > this.#config.blobCacheMaxBytes;
@@ -1460,7 +1454,7 @@ export class SyncClient {
         const priorRejections = this.#rejections;
         return this.#applyBatch((batch) => {
             restoreFailedBases(this.#db, this.#schema);
-            this.#db.exec('DELETE FROM _syncular_failed_rows WHERE commit_id = ?', [
+            this.#db.exec('DELETE FROM _syncular_failed_rows WHERE commit_id=?', [
                 input.clientCommitId,
             ]);
             const resolved = persistCommitOutcomeResolution(this.#db, input, this.#now());
@@ -1579,14 +1573,14 @@ export class SyncClient {
             }
             return;
         }
-        saveSubscription(this.#db, {
+        saveSubscription(this.#db, definedObject({
             id: input.id,
             table: input.table,
             scopes: input.scopes,
-            ...(input.params !== undefined ? { params: input.params } : {}),
+            params: input.params,
             cursor: -1,
             status: 'active',
-        });
+        }));
         this.#setSyncNeeded(true);
         this.#emitSyncIntent({ kind: 'interactive' });
         this.#emitDiagnostics();
@@ -1644,14 +1638,14 @@ export class SyncClient {
                         // Re-entry cancels any deferred eviction for this sub id.
                         deletePendingEviction(this.#db, subId);
                         insertWindowUnit(this.#db, baseKey, unit, subId);
-                        saveSubscription(this.#db, {
+                        saveSubscription(this.#db, definedObject({
                             id: subId,
                             table: base.table,
                             scopes: unitScopes(base, unit),
-                            ...(base.params !== undefined ? { params: base.params } : {}),
+                            params: base.params,
                             cursor: -1,
                             status: 'active',
-                        });
+                        }));
                     });
                     this.#needsPull = true;
                     batch.window(baseKey, base.table, unit);
@@ -1809,14 +1803,12 @@ export class SyncClient {
         const operations = mutations.map((mutation) => {
             const table = this.#table(mutation.table);
             if (mutation.op === 'delete') {
-                return {
+                return definedObject({
                     table: mutation.table,
                     rowId: mutation.rowId,
                     op: 'delete',
-                    ...(mutation.baseVersion !== undefined
-                        ? { baseVersion: mutation.baseVersion }
-                        : {}),
-                };
+                    baseVersion: mutation.baseVersion,
+                });
             }
             const json = {};
             if (mutation.op === 'patch') {
@@ -1828,7 +1820,7 @@ export class SyncClient {
                 const scopeColumns = new Set(table.scopeColumnByVariable.values());
                 const pkColumn = table.columns[table.primaryKeyIndex];
                 const pkValue = requireRowId(normalized.get(pkColumn.name));
-                const local = this.#db.query(`SELECT * FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [pkValue])[0];
+                const local = this.#db.query(`SELECT * FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [pkValue])[0];
                 if (!local)
                     throw new ClientSyncError('sync.row_missing', 'a sparse patch requires a local row');
                 for (const column of table.columns) {
@@ -1868,15 +1860,13 @@ export class SyncClient {
                 });
             }
             const pkValue = requireRowId(json[table.primaryKey]);
-            return {
+            return definedObject({
                 table: mutation.table,
                 rowId: pkValue,
                 op: 'upsert',
-                ...(mutation.baseVersion !== undefined
-                    ? { baseVersion: mutation.baseVersion }
-                    : {}),
+                baseVersion: mutation.baseVersion,
                 values: json,
-            };
+            });
         });
         this.#applyBatch((batch) => {
             this.#db.transaction(() => {
@@ -1900,10 +1890,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 _syncular_blob_commit_refs(commit_id,blob_id)SELECT ?,? WHERE EXISTS(SELECT 1 FROM _syncular_blobs WHERE blob_id=?)', [clientCommitId, blobId, blobId]);
                     }
                 }
                 try {
@@ -1990,13 +1977,18 @@ export class SyncClient {
         // in the running schema), so purge drops it as a fixed step, before any
         // mirror row is touched and unconditionally.
         this.#dropPreviousVersion();
-        const rejectionCount = this.#rejections.length;
+        const priorRejections = [...this.#rejections];
+        const priorConflicts = [...this.#conflicts];
         try {
             return this.#applyBatch((batch) => {
                 const targetsByTable = this.#localPurgeTargetsByTable(purge);
                 restoreFailedBases(this.#db, this.#schema);
                 const droppedRetained = dropFailedRows(this.#db, (table, values) => (targetsByTable.get(table) ?? []).some((target) => target.selectors.every((selector) => selector.values.includes(String(values[selector.column])))));
                 for (const commit of droppedRetained) {
+                    batch.conflicts();
+                    batch.rejections();
+                    this.#conflicts = this.#conflicts.filter((record) => record.clientCommitId !== commit.clientCommitId);
+                    this.#rejections = this.#rejections.filter((record) => record.clientCommitId !== commit.clientCommitId);
                     for (const operation of commit.operations)
                         batch.table(operation.table);
                     batch.outcomes();
@@ -2053,7 +2045,7 @@ export class SyncClient {
                     batch.table(tableName);
                     for (let offset = 0; offset < values.length; offset += 400) {
                         const chunk = values.slice(offset, offset + 400);
-                        this.#db.exec(`DELETE FROM ${quoteIdent(tableName)} WHERE ${quoteIdent(table.primaryKey)} IN (${chunk.map(() => '?').join(', ')})`, chunk);
+                        this.#db.exec(`DELETE FROM ${quoteIdent(tableName)} WHERE ${quoteIdent(table.primaryKey)} IN(${chunk.map(() => '?').join(', ')})`, chunk);
                     }
                 }
                 if (doomed.length > 0) {
@@ -2096,7 +2088,8 @@ export class SyncClient {
         catch (error) {
             // SQLite rolls back through #applyBatch; mirror that rollback for the
             // in-memory rejection cache before surfacing the storage failure.
-            this.#rejections.length = rejectionCount;
+            this.#rejections = priorRejections;
+            this.#conflicts = priorConflicts;
             throw error;
         }
     }
@@ -2186,7 +2179,7 @@ export class SyncClient {
                 clauses.push(`${quoteIdent(selector.column)} IN (${selector.values.map(() => '?').join(', ')})`);
                 params.push(...selector.values);
             }
-            for (const row of this.#db.query(`SELECT CAST(${quoteIdent(target.table.primaryKey)} AS TEXT) AS id FROM ${quoteIdent(target.table.name)} WHERE ${clauses.join(' AND ')}`, params)) {
+            for (const row of this.#db.query(`SELECT CAST(${quoteIdent(target.table.primaryKey)} AS TEXT)AS id FROM ${quoteIdent(target.table.name)} WHERE ${clauses.join(' AND ')}`, params)) {
                 if (typeof row.id === 'string')
                     ids.add(row.id);
             }
@@ -2228,7 +2221,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 _syncular_outbox')[0];
         const pendingCount = bounds.count;
         const throughSeq = bounds.last_seq ?? 0;
         const pushFrames = [];
@@ -2258,7 +2251,7 @@ export class SyncClient {
                     const selector = this.#encryption?.keyIdColumns?.[table.name];
                     if (selector === undefined)
                         return undefined;
-                    const row = this.#db.query(`SELECT ${quoteIdent(selector)} AS value FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [rowId])[0];
+                    const row = this.#db.query(`SELECT ${quoteIdent(selector)} AS value FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [rowId])[0];
                     const value = row?.value;
                     return typeof value === 'string' && value.length > 0
                         ? value
@@ -2351,15 +2344,13 @@ export class SyncClient {
             const error = classifySqliteFailure(caught).error;
             const completedAtMs = this.#now();
             const code = error.code;
-            this.#progress.update({
+            this.#progress.update(definedObject({
                 state: 'failed',
                 errorCode: typeof code === 'string'
                     ? this.#diagnosticCode(code)
                     : 'client.unknown_failure',
-                ...(this.#roundRetryDelayMs !== undefined
-                    ? { retryDelayMs: this.#roundRetryDelayMs }
-                    : {}),
-            });
+                retryDelayMs: this.#roundRetryDelayMs,
+            }));
             this.#lastRound = {
                 status: 'failed',
                 startedAtMs,
@@ -2451,12 +2442,12 @@ export class SyncClient {
             const subs = loadSubscriptions(this.#db).filter((sub) => sub.status === 'active');
             const limits = this.#config.limits;
             const frames = [
-                {
+                definedObject({
                     type: 'REQ_HEADER',
                     clientId: this.#clientId,
                     schemaVersion: this.#schema.version,
-                    ...(logEpoch !== undefined ? { logEpoch } : {}),
-                },
+                    logEpoch: logEpoch,
+                }),
                 ...pushFrames,
                 {
                     type: 'PULL_HEADER',
@@ -2465,16 +2456,14 @@ export class SyncClient {
                     maxSnapshotPages: limits?.maxSnapshotPages ?? 0,
                     accept: this.#acceptMask(),
                 },
-                ...subs.map((sub) => ({
+                ...subs.map((sub) => definedObject({
                     type: 'SUBSCRIPTION',
                     id: sub.id,
                     table: sub.table,
                     scopes: sub.scopes,
-                    ...(sub.params !== undefined ? { params: sub.params } : {}),
+                    params: sub.params,
                     cursor: sub.cursor,
-                    ...(sub.bootstrapState !== undefined
-                        ? { bootstrapState: sub.bootstrapState }
-                        : {}),
+                    bootstrapState: sub.bootstrapState,
                 })),
             ];
             const requestBytes = encodeMessage({
@@ -2925,12 +2914,10 @@ export class SyncClient {
             // version this client sends. The §7.4.2 trigger-2 convergence runs
             // when the APP updates (recreating the client with a new generated
             // schema), which fires the boot-time §7.4.1 marker check instead.
-            const schemaFloor = {
+            const schemaFloor = definedObject({
                 requiredSchemaVersion: header.requiredSchemaVersion,
-                ...(header.latestSchemaVersion !== undefined
-                    ? { latestSchemaVersion: header.latestSchemaVersion }
-                    : {}),
-            };
+                latestSchemaVersion: header.latestSchemaVersion,
+            });
             this.#setSchemaFloor(schemaFloor);
             return {
                 ...summary,
@@ -3243,7 +3230,7 @@ export class SyncClient {
         for (const result of frame.results) {
             const operation = commit.operations[result.opIndex];
             if (result.status === 'conflict') {
-                const conflict = {
+                const conflict = definedObject({
                     clientCommitId: frame.clientCommitId,
                     opIndex: result.opIndex,
                     table: operation?.table ?? '',
@@ -3253,8 +3240,8 @@ export class SyncClient {
                     serverVersion: result.serverVersion,
                     serverRow: this.#decodeServerRow(operation?.table, result.serverRow),
                     conflictColumns: this.#decodeConflictColumns(operation?.table, result.conflictColumns),
-                    ...(operation !== undefined ? { operation } : {}),
-                };
+                    operation: operation,
+                });
                 this.#conflicts.push(conflict);
                 outcomeResults.push({ status: 'conflict', conflict });
                 batch.conflicts();
@@ -3262,15 +3249,15 @@ export class SyncClient {
             }
             else if (result.status === 'error') {
                 const details = rejectionDetails?.get(result.opIndex);
-                const rejection = {
+                const rejection = definedObject({
                     clientCommitId: frame.clientCommitId,
                     opIndex: result.opIndex,
                     code: result.code,
                     message: result.message,
                     retryable: result.retryable,
-                    ...(details !== undefined ? { details } : {}),
-                    ...(operation !== undefined ? { operation } : {}),
-                };
+                    details: details,
+                    operation: operation,
+                });
                 this.#rejections.push(rejection);
                 outcomeResults.push({ status: 'error', rejection });
                 batch.rejections();
@@ -3302,7 +3289,7 @@ export class SyncClient {
         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 _syncular_outbox WHERE client_commit_id=? LIMIT 1', [clientCommitId]).length > 0);
     }
     #decodeServerRow(tableName, payload) {
         if (tableName === undefined)
@@ -3339,7 +3326,12 @@ export class SyncClient {
     async #applyCommit(frame, summary) {
         await applyCommitFrame(this.#db, this.#schema, frame, this.#encryption, (fn) => this.#applyBatch((batch) => {
             this.#recordCommitChanges(batch, frame);
-            return fn();
+            const result = fn();
+            if (this.#retainFailedCommits &&
+                this.#db.query('SELECT 1 FROM _syncular_failed_rows LIMIT 1')
+                    .length > 0)
+                this.#replayOutbox();
+            return result;
         }));
         summary.commitsApplied += 1;
     }
@@ -3367,9 +3359,7 @@ export class SyncClient {
         const mappings = [...table.scopeColumnByVariable].filter(([variable]) => table.scopePrefixByVariable.has(variable));
         if (mappings.length === 0)
             return false;
-        const row = this.#db.query(`SELECT ${mappings.map(([, column]) => quoteIdent(column)).join(', ')}
-         FROM ${quoteIdent(table.name)}
-        WHERE ${quoteIdent(table.primaryKey)} = ?`, [rowId])[0];
+        const row = this.#db.query(`SELECT ${mappings.map(([, column]) => quoteIdent(column)).join(', ')} FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [rowId])[0];
         if (row === undefined)
             return false;
         let recorded = false;
@@ -3397,8 +3387,7 @@ export class SyncClient {
             clauses.push(`${quoteIdent(column)} IN (${values.map(() => '?').join(', ')})`);
             params.push(...values);
         }
-        return (this.#db.query(`SELECT 1 FROM ${quoteIdent(table.name)}
-          WHERE ${clauses.join(' AND ')} LIMIT 1`, params).length > 0);
+        return (this.#db.query(`SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${clauses.join(' AND ')} LIMIT 1`, params).length > 0);
     }
     /**
      * Apply a segment (rows or sqlite image); a §5.6/§3.3 fail-closed error
@@ -3419,18 +3408,16 @@ export class SyncClient {
                 error.code === 'sync.scope_revoked') {
                 const registered = getWindowUnitBySubId(this.#db, sub.id);
                 this.#applyBatch((batch) => {
-                    saveSubscription(this.#db, {
+                    saveSubscription(this.#db, definedObject({
                         id: sub.id,
                         table: sub.table,
                         scopes: sub.scopes,
-                        ...(sub.params !== undefined ? { params: sub.params } : {}),
+                        params: sub.params,
                         cursor: sub.cursor,
-                        ...(sub.effectiveScopes !== undefined
-                            ? { effectiveScopes: sub.effectiveScopes }
-                            : {}),
+                        effectiveScopes: sub.effectiveScopes,
                         status: 'failed',
                         reasonCode: 'sync.scope_revoked',
-                    });
+                    }));
                     if (registered !== undefined) {
                         batch.window(registered.baseKey, sub.table, registered.unit);
                     }
@@ -3507,16 +3494,16 @@ export class SyncClient {
             const completed = wasPending && nextCursor >= 0 && bootstrapState === undefined;
             const registered = getWindowUnitBySubId(this.#db, sub.id);
             this.#applyBatch((batch) => {
-                saveSubscription(this.#db, {
+                saveSubscription(this.#db, definedObject({
                     id: sub.id,
                     table: sub.table,
                     scopes: sub.scopes,
-                    ...(sub.params !== undefined ? { params: sub.params } : {}),
+                    params: sub.params,
                     cursor: nextCursor,
-                    ...(bootstrapState !== undefined ? { bootstrapState } : {}),
+                    bootstrapState: bootstrapState,
                     effectiveScopes: start.effectiveScopes,
                     status: 'active',
-                });
+                }));
                 if (completed && registered !== undefined) {
                     // A zero-row bootstrap is a window-domain transition, not a fake
                     // row/table change (SPEC §4.8 / §7.5).
@@ -3530,18 +3517,16 @@ export class SyncClient {
             // with cursor = -1 on the next pull. Staleness, not a purge.
             const registered = getWindowUnitBySubId(this.#db, sub.id);
             this.#applyBatch((batch) => {
-                saveSubscription(this.#db, {
+                saveSubscription(this.#db, definedObject({
                     id: sub.id,
                     table: sub.table,
                     scopes: sub.scopes,
-                    ...(sub.params !== undefined ? { params: sub.params } : {}),
+                    params: sub.params,
                     cursor: -1,
-                    ...(sub.effectiveScopes !== undefined
-                        ? { effectiveScopes: sub.effectiveScopes }
-                        : {}),
+                    effectiveScopes: sub.effectiveScopes,
                     status: 'active',
                     reasonCode: start.reasonCode,
-                });
+                }));
                 if (registered !== undefined) {
                     batch.window(registered.baseKey, sub.table, registered.unit);
                 }
@@ -3563,6 +3548,10 @@ export class SyncClient {
                     const droppedRetained = dropFailedRows(this.#db, (name, values) => name === table.name &&
                         Object.entries(lastEffective).every(([variable, allowed]) => allowed.includes(String(values[table.scopeColumnByVariable.get(variable)]))));
                     for (const commit of droppedRetained) {
+                        batch.conflicts();
+                        batch.rejections();
+                        this.#conflicts = this.#conflicts.filter((record) => record.clientCommitId !== commit.clientCommitId);
+                        this.#rejections = this.#rejections.filter((record) => record.clientCommitId !== commit.clientCommitId);
                         for (const operation of commit.operations)
                             batch.table(operation.table);
                         batch.outcomes();
@@ -3616,18 +3605,16 @@ export class SyncClient {
                     }
                 }
             }
-            saveSubscription(this.#db, {
+            saveSubscription(this.#db, definedObject({
                 id: sub.id,
                 table: sub.table,
                 scopes: sub.scopes,
-                ...(sub.params !== undefined ? { params: sub.params } : {}),
+                params: sub.params,
                 cursor: nextCursor,
-                ...(lastEffective !== undefined
-                    ? { effectiveScopes: lastEffective }
-                    : {}),
+                effectiveScopes: lastEffective,
                 status: failed ? 'failed' : 'revoked',
                 reasonCode: start.reasonCode,
-            });
+            }));
             if (registered !== undefined) {
                 batch.window(registered.baseKey, sub.table, registered.unit);
             }
@@ -3646,7 +3633,7 @@ export class SyncClient {
             ...table.columns.map((column) => quoteIdent(column.name)),
             quoteIdent(SYNC_VERSION_COLUMN),
         ];
-        const row = this.#db.query(`SELECT ${columns.join(', ')} FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [operation.rowId])[0];
+        const row = this.#db.query(`SELECT ${columns.join(', ')} FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [operation.rowId])[0];
         if (row === undefined)
             return { opIndex, existed: false };
         const values = {};
@@ -3686,7 +3673,7 @@ export class SyncClient {
             const table = this.#schema.tables.get(operation.table);
             if (table === undefined)
                 continue;
-            const row = this.#db.query(`SELECT ${quoteIdent(SYNC_VERSION_COLUMN)} AS v FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [operation.rowId])[0];
+            const row = this.#db.query(`SELECT ${quoteIdent(SYNC_VERSION_COLUMN)} AS v FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [operation.rowId])[0];
             if (row !== undefined && row.v === OPTIMISTIC_VERSION) {
                 batch.table(table.name);
                 deleteLocalRow(this.#db, table, operation.rowId);
@@ -3728,7 +3715,7 @@ export class SyncClient {
             this.#applyOperationsLocally(affectedOperations, batch);
         }
     }
-    #applyOperationsLocally(operations, batch) {
+    #applyOperationsLocally(operations, batch, replay = false) {
         for (const op of operations) {
             const table = this.#table(op.table);
             let precise = batch === undefined
@@ -3746,7 +3733,7 @@ export class SyncClient {
             // sync.row_missing, and the local mirror never invents a base.
             const opValues = op.values ?? {};
             const full = table.columns.every((column) => column.name in opValues);
-            const local = this.#db.query(`SELECT * FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [op.rowId])[0];
+            const local = this.#db.query(`SELECT * FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [op.rowId])[0];
             if (local === undefined && !full) {
                 if (batch !== undefined && !precise)
                     batch.table(op.table);
@@ -3777,6 +3764,13 @@ export class SyncClient {
             const version = local === undefined
                 ? OPTIMISTIC_VERSION
                 : local[SYNC_VERSION_COLUMN];
+            if (replay &&
+                table.indexes.some((index) => index.unique) &&
+                uniqueConflicts(this.#db, table, Object.fromEntries(table.columns.map((column, index) => [
+                    column.name,
+                    values[index] ?? null,
+                ]))).length)
+                continue;
             upsertLocalRow(this.#db, table, values, version, false);
         }
     }
@@ -3793,7 +3787,7 @@ export class SyncClient {
                 restoreFailedBases(this.#db, this.#schema);
                 restoreFailedBases(this.#db, this.#schema, true);
                 for (const commit of pending)
-                    this.#applyOperationsLocally(commit.operations, batch);
+                    this.#applyOperationsLocally(commit.operations, batch, true);
             });
         });
     }
@@ -3822,6 +3816,13 @@ export class SyncClient {
         }
     }
 }
+function definedObject(record) {
+    for (const key of Object.keys(record)) {
+        if (record[key] === undefined)
+            delete record[key];
+    }
+    return record;
+}
 function requireRowId(value) {
     if (typeof value !== 'string' || !value.length)
         throw invalidRequest('a mutation requires a non-empty string primary key');

package/dist/failed-overlay.d.ts

@@ -1,10 +1,14 @@
 import type { ClientDatabase } from './database.js';
-import type { CompiledClientSchema, JsonRowValue } from './schema.js';
+import type { CompiledClientSchema, CompiledClientTable, JsonRowValue } from './schema.js';
+import type { RowValue } from '@syncular/core';
+import type { RetainedCommitRow } from './outcomes.js';
 import type { OutboxCommit, OutboxBeforeImage } from './outbox.js';
 /** Protected failure state. The server base advances independently of intent. */
 export declare function ensureFailedOverlaySchema(db: ClientDatabase): void;
-export declare function retainedBaseWrite(db: ClientDatabase, table: string, rowId: string, values?: Readonly<Record<string, JsonRowValue>>, version?: number): void;
+export declare function retainedBaseWrite(db: ClientDatabase, table: CompiledClientTable, rowId: string, values?: Readonly<Record<string, JsonRowValue>>, version?: number): void;
 export declare function retainFailedRows(db: ClientDatabase, commit: OutboxCommit, images: readonly OutboxBeforeImage[]): void;
+/** Match declared keys through SQLite, preserving index affinity and NULL semantics. */
+export declare function uniqueConflicts(db: ClientDatabase, table: CompiledClientTable, values: Readonly<Record<string, RowValue>>): NonNullable<RetainedCommitRow['uniqueConflicts']>;
 export declare function restoreFailedBases(db: ClientDatabase, schema: CompiledClientSchema, absentIntent?: boolean): void;
 export declare function failedOverlayCommits(db: ClientDatabase): OutboxCommit[];
 export declare function dropFailedRows(db: ClientDatabase, matches: (table: string, values: Readonly<Record<string, JsonRowValue>>) => boolean): OutboxCommit[];