@syncular/client 0.30.10 → 0.30.12

package/dist/failed-overlay.d.ts

@@ -1,10 +1,15 @@
+export declare const RETAINED_ROWS = "_syncular_failed_rows";
 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 retainFailedRows(db: ClientDatabase, commit: OutboxCommit, images: readonly OutboxBeforeImage[]): void;
-export declare function restoreFailedBases(db: ClientDatabase, schema: CompiledClientSchema, absentIntent?: boolean): void;
-export declare function failedOverlayCommits(db: ClientDatabase): OutboxCommit[];
+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[], commitSeq?: number): 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, rowKeys?: readonly string[]): boolean;
+export declare function failedOverlayCommits(db: ClientDatabase, acknowledged?: boolean, rowKeys?: readonly string[]): OutboxCommit[];
 export declare function dropFailedRows(db: ClientDatabase, matches: (table: string, values: Readonly<Record<string, JsonRowValue>>) => boolean): OutboxCommit[];

package/dist/failed-overlay.js

@@ -1,32 +1,59 @@
+export const RETAINED_ROWS = '_syncular_failed_rows';
 import { ClientSyncError } from './errors.js';
-import { jsonToRowValue, quoteIdent } from './schema.js';
+import { mapRowValues, fromSqlValue, jsonToRowValue, quoteIdent, rowValueToJson, SYNC_VERSION_COLUMN, toSqlValue, } from './schema.js';
 import { deleteLocalRow, upsertLocalRow } from './apply.js';
 /** Protected failure state. The server base advances independently of intent. */
 export function ensureFailedOverlaySchema(db) {
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_failed_rows(
-    commit_id TEXT NOT NULL, idx INTEGER NOT NULL,
-    tbl TEXT NOT NULL, id TEXT NOT NULL, at INTEGER NOT NULL,
-    op TEXT NOT NULL, intent TEXT, base TEXT, version INTEGER,
-    PRIMARY KEY(commit_id, idx))`);
+    db.exec(`CREATE TABLE IF NOT EXISTS ${RETAINED_ROWS}(commit_id TEXT NOT NULL,idx INTEGER NOT NULL,tbl TEXT NOT NULL,id TEXT NOT NULL,at INTEGER NOT NULL,op TEXT NOT NULL,intent TEXT,base TEXT,version INTEGER,unique_conflicts TEXT,commit_seq INTEGER,PRIMARY KEY(commit_id,idx))`);
+    const columns = db.query(`PRAGMA table_info(${RETAINED_ROWS})`);
+    for (const column of ['unique_conflicts TEXT', 'commit_seq INTEGER'])
+        if (!columns.some((row) => row.name === column.split(' ')[0]))
+            db.exec(`ALTER TABLE ${RETAINED_ROWS} ADD COLUMN ${column}`);
 }
 export function retainedBaseWrite(db, table, rowId, values, version) {
-    db.exec('UPDATE _syncular_failed_rows SET base = ?, version = ? WHERE tbl = ? AND id = ?', [
+    db.exec(`UPDATE ${RETAINED_ROWS} SET base=?,version=? WHERE tbl=? AND id=?`, [
         values === undefined ? null : JSON.stringify(values),
         version ?? null,
-        table,
+        table.name,
         rowId,
     ]);
+    if (!table.indexes.some((index) => index.unique))
+        return;
+    for (const retained of db.query(`SELECT commit_id,idx,intent,unique_conflicts FROM ${RETAINED_ROWS} WHERE tbl=? AND commit_seq IS NULL`, [table.name])) {
+        const prior = retained.unique_conflicts === null
+            ? []
+            : JSON.parse(retained.unique_conflicts);
+        const conflicts = prior.filter((conflict) => conflict.rowId !== rowId);
+        if (values !== undefined && retained.intent !== null) {
+            const intent = JSON.parse(retained.intent);
+            conflicts.push(...uniqueConflicts(db, table, mapRowValues(intent, jsonToRowValue))
+                .filter((conflict) => conflict.rowId === rowId)
+                .map((conflict) => ({
+                ...conflict,
+                serverRow: mapRowValues(conflict.serverRow, rowValueToJson),
+            })));
+        }
+        db.exec(`UPDATE ${RETAINED_ROWS} SET unique_conflicts=? WHERE commit_id=? AND idx=?`, [
+            conflicts.length
+                ? JSON.stringify(conflicts.sort((a, b) => table.indexes.findIndex((index) => index.name === a.index) -
+                    table.indexes.findIndex((index) => index.name === b.index)))
+                : null,
+            retained.commit_id,
+            Number(retained.idx),
+        ]);
+    }
 }
-export function retainFailedRows(db, commit, images) {
+export function retainFailedRows(db, commit, images, commitSeq) {
     for (const [index, operation] of commit.operations.entries()) {
         const image = images.find((image) => image.opIndex === index);
+        if (commitSeq !== undefined && (image?.deliverySeq ?? -1) >= commitSeq)
+            continue;
         const initial = operation.op === 'upsert'
             ? { ...image?.values, ...operation.values }
             : undefined;
         if (!image)
-            throw new ClientSyncError('sync.local_corrupt', 'retained intent has no before-image');
-        db.exec(`INSERT INTO _syncular_failed_rows(commit_id, idx, tbl, id, at, op, intent, base, version)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            throw new ClientSyncError('sync.local_corrupt', 'missing intent before-image');
+        db.exec(`INSERT INTO ${RETAINED_ROWS}(commit_id,idx,tbl,id,at,op,intent,base,version,commit_seq)VALUES(?,?,?,?,?,?,?,?,?,?)`, [
             commit.clientCommitId,
             index,
             operation.table,
@@ -36,42 +63,91 @@ export function retainFailedRows(db, commit, images) {
             initial ? JSON.stringify(initial) : null,
             image.values ? JSON.stringify(image.values) : null,
             image.syncVersion ?? null,
+            commitSeq ?? null,
         ]);
     }
 }
-export function restoreFailedBases(db, schema, absentIntent = false) {
+/** Match declared keys through SQLite, preserving index affinity and NULL semantics. */
+export function uniqueConflicts(db, table, values) {
+    return table.indexes
+        .filter((index) => index.unique)
+        .flatMap((index) => db
+        .query(`SELECT * FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} !=? AND ${index.columns.map((column) => `${quoteIdent(column)} = ?`).join(' AND ')}`, [
+        toSqlValue(values[table.primaryKey] ?? null),
+        ...index.columns.map((column) => toSqlValue(values[column] ?? null)),
+    ])
+        .map((row) => ({
+        index: index.name,
+        columns: index.columns,
+        rowId: String(row[table.primaryKey]),
+        serverRow: Object.fromEntries(table.columns.map((column) => [
+            column.name,
+            fromSqlValue(column, row[column.name] ?? null),
+        ])),
+        serverVersion: Number(row[SYNC_VERSION_COLUMN]),
+    })));
+}
+function retainedRows(db, rowKeys) {
+    return db.query(`SELECT * FROM ${RETAINED_ROWS} WHERE ?1 IS NULL OR json_array(tbl,id) IN(SELECT value FROM json_each(?1)) ORDER BY commit_seq,at,commit_id,idx`, [rowKeys ? JSON.stringify(rowKeys) : null]);
+}
+export function restoreFailedBases(db, schema, absentIntent = false, rowKeys) {
     const seen = new Set();
-    for (const row of db.query('SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx')) {
+    for (const row of retainedRows(db, rowKeys)) {
         const key = JSON.stringify([row.tbl, row.id]);
         if (!absentIntent && seen.has(key))
             continue;
         seen.add(key);
-        const table = schema.tables.get(String(row.tbl));
+        const table = schema.tables.get(row.tbl);
         if (!table)
-            throw new ClientSyncError('sync.unknown_table', 'retained intent references an unknown table');
+            throw new ClientSyncError('sync.unknown_table', 'retained table is unknown');
         const json = absentIntent ? row.intent : row.base;
+        if (absentIntent && row.intent !== null) {
+            const values = JSON.parse(row.intent);
+            const conflicts = uniqueConflicts(db, table, mapRowValues(values, jsonToRowValue));
+            // Hydrate a pre-0.30.11 failure after its winner was already imported.
+            // Pending and retained overlays cannot supply authoritative row evidence.
+            if (row.commit_seq === null && row.unique_conflicts === null) {
+                const authorized = conflicts.filter((conflict) => conflict.serverVersion >= 0 &&
+                    !db.query(`SELECT 1 FROM ${RETAINED_ROWS} WHERE tbl=? AND id=? UNION ALL SELECT 1 FROM _syncular_outbox,json_each(operations)WHERE json_extract(json_each.value,'$.table')=? AND json_extract(json_each.value,'$.rowId')=? LIMIT 1`, [table.name, conflict.rowId, table.name, conflict.rowId]).length);
+                if (authorized.length)
+                    db.exec(`UPDATE ${RETAINED_ROWS} SET unique_conflicts=? WHERE commit_id=? AND idx=?`, [
+                        JSON.stringify(authorized.map((conflict) => ({
+                            ...conflict,
+                            serverRow: mapRowValues(conflict.serverRow, rowValueToJson),
+                        }))),
+                        row.commit_id,
+                        row.idx,
+                    ]);
+            }
+            if (conflicts.length)
+                continue;
+        }
         if (absentIntent &&
             (json === null ||
-                db.query(`SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [String(row.id)]).length))
+                db.query(`SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [row.id]).length))
             continue;
         if (json === null)
-            deleteLocalRow(db, table, String(row.id), false);
+            deleteLocalRow(db, table, row.id, false);
         else {
             const values = JSON.parse(String(json));
             if (absentIntent) {
-                const operation = JSON.parse(String(row.op));
-                if (!table.columns.every((column) => Object.hasOwn(operation.values ?? {}, column.name)))
+                const operation = JSON.parse(row.op);
+                if (row.commit_seq === null &&
+                    !table.columns.every((column) => Object.hasOwn(operation.values ?? {}, column.name)))
                     continue;
             }
-            upsertLocalRow(db, table, table.columns.map((column) => jsonToRowValue(values[column.name] ?? null)), Number(row.version ?? -1), false);
+            upsertLocalRow(db, table, table.columns.map((column) => jsonToRowValue(values[column.name] ?? null)), (row.version ?? -1), false);
         }
     }
+    return seen.size > 0;
 }
-export function failedOverlayCommits(db) {
+export function failedOverlayCommits(db, acknowledged = false, rowKeys) {
     const commits = new Map();
-    for (const row of db.query('SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx')) {
-        const id = String(row.commit_id);
-        const operation = JSON.parse(String(row.op));
+    for (const row of retainedRows(db, rowKeys)) {
+        if ((row.commit_seq !== null) !== acknowledged)
+            continue;
+        const id = row.commit_id;
+        const operation = JSON.parse(row.op);
         const prior = commits.get(id);
         if (prior)
             prior.operations.push(operation);
@@ -79,7 +155,7 @@ export function failedOverlayCommits(db) {
             commits.set(id, {
                 seq: 0,
                 clientCommitId: id,
-                createdAtMs: Number(row.at),
+                createdAtMs: row.at,
                 operations: [operation],
             });
     }
@@ -87,16 +163,22 @@ export function failedOverlayCommits(db) {
 }
 export function dropFailedRows(db, matches) {
     const ids = new Set();
-    for (const row of db.query('SELECT * FROM _syncular_failed_rows')) {
-        const json = row.intent ?? row.base;
-        if (json === null)
-            continue;
-        const values = JSON.parse(String(json));
-        if (matches(String(row.tbl), values))
-            ids.add(String(row.commit_id));
+    for (const row of retainedRows(db)) {
+        for (const json of [row.intent, row.base]) {
+            if (json === null)
+                continue;
+            const values = JSON.parse(String(json));
+            if (matches(row.tbl, values))
+                ids.add(row.commit_id);
+        }
+    }
+    const dropped = [
+        ...failedOverlayCommits(db),
+        ...failedOverlayCommits(db, true),
+    ].filter((commit) => ids.has(commit.clientCommitId));
+    for (const id of ids) {
+        db.exec(`DELETE FROM ${RETAINED_ROWS} WHERE commit_id=?`, [id]);
+        db.exec("UPDATE _syncular_commit_outcomes SET operations=NULL,results='[]' WHERE client_commit_id=?", [id]);
     }
-    const dropped = failedOverlayCommits(db).filter((commit) => ids.has(commit.clientCommitId));
-    for (const id of ids)
-        db.exec('DELETE FROM _syncular_failed_rows WHERE commit_id = ?', [id]);
     return dropped;
 }

package/dist/outbox.d.ts

@@ -34,12 +34,13 @@ export interface OutboxCommit {
 export interface OutboxBeforeImage {
     readonly opIndex: number;
     readonly existed: boolean;
+    readonly deliverySeq?: number;
     readonly syncVersion?: number;
     readonly values?: Readonly<Record<string, JsonRowValue>>;
 }
 export declare function appendOutboxCommit(db: ClientDatabase, clientCommitId: string, operations: readonly OutboxOperation[], nowMs: number, beforeImages?: readonly OutboxBeforeImage[]): void;
 /** Pending commits in FIFO creation order (§7.1). Full reads serve replay and the public listing. */
-export declare function listOutbox(db: ClientDatabase): OutboxCommit[];
+export declare function listOutbox(db: ClientDatabase, rowKeys?: readonly string[]): OutboxCommit[];
 /** Keyset pages bound staging; laziness decodes only commits consumed by the encoder. */
 export declare function iterateOutbox(db: ClientDatabase, throughSeq: number): Generator<OutboxCommit>;
 /** Routine status reads never load operation bodies. */

package/dist/outbox.js

@@ -7,30 +7,20 @@
  */
 import { encodeSparseRow, } from '@syncular/core';
 import { ClientSyncError } from './errors.js';
-import { jsonToRowValue, } from './schema.js';
+import { jsonToRowValue, matchesLocalScopes, } from './schema.js';
 export function appendOutboxCommit(db, clientCommitId, operations, nowMs, beforeImages = []) {
     if (operations.length === 0) {
         throw new ClientSyncError('sync.empty_commit', 'a local commit must carry at least one operation (§6.1)');
     }
-    db.exec(`INSERT INTO _syncular_outbox(client_commit_id, created_at_ms, operations)
-     VALUES (?, ?, ?)`, [clientCommitId, nowMs, JSON.stringify(operations)]);
-    for (const image of beforeImages) {
-        db.exec(`INSERT INTO _syncular_outbox_before_images(
-         client_commit_id, op_index, existed, sync_version, values_json
-       ) VALUES (?, ?, ?, ?, ?)`, [
-            clientCommitId,
-            image.opIndex,
-            image.existed ? 1 : 0,
-            image.syncVersion ?? null,
-            image.values === undefined ? null : JSON.stringify(image.values),
-        ]);
-    }
+    db.exec('INSERT INTO _syncular_outbox(client_commit_id,created_at_ms,operations)VALUES(?,?,?)', [clientCommitId, nowMs, JSON.stringify(operations)]);
+    replaceOutboxBeforeImages(db, clientCommitId, beforeImages);
 }
 /** Pending commits in FIFO creation order (§7.1). Full reads serve replay and the public listing. */
-export function listOutbox(db) {
+export function listOutbox(db, rowKeys) {
     return db
-        .query(`SELECT seq, client_commit_id, created_at_ms, operations
-       FROM _syncular_outbox ORDER BY seq ASC`)
+        .query(rowKeys === undefined
+        ? 'SELECT seq, client_commit_id, created_at_ms, operations FROM _syncular_outbox ORDER BY seq ASC'
+        : "SELECT * FROM _syncular_outbox WHERE EXISTS(SELECT 1 FROM json_each(operations) WHERE json_array(json_extract(value,'$.table'),json_extract(value,'$.rowId')) IN(SELECT value FROM json_each(?))) ORDER BY seq", rowKeys && [JSON.stringify(rowKeys)])
         .map(decodeOutboxRow);
 }
 function decodeOutboxRow(row) {
@@ -45,8 +35,7 @@ function decodeOutboxRow(row) {
 export function* iterateOutbox(db, throughSeq) {
     let afterSeq = 0;
     while (afterSeq < throughSeq) {
-        const rows = db.query(`SELECT seq, client_commit_id, created_at_ms, operations FROM _syncular_outbox
-       WHERE seq > ? AND seq <= ? ORDER BY seq ASC LIMIT 32`, [afterSeq, throughSeq]);
+        const rows = db.query('SELECT seq, client_commit_id, created_at_ms, operations FROM _syncular_outbox WHERE seq > ? AND seq <= ? ORDER BY seq ASC LIMIT 32', [afterSeq, throughSeq]);
         if (rows.length === 0)
             return;
         for (const row of rows) {
@@ -58,26 +47,27 @@ export function* iterateOutbox(db, throughSeq) {
 }
 /** Routine status reads never load operation bodies. */
 export function countOutbox(db) {
-    return db.query('SELECT COUNT(*) AS count FROM _syncular_outbox')[0]
+    return db.query('SELECT COUNT(*)AS count FROM _syncular_outbox')[0]
         .count;
 }
 export function deleteOutboxCommit(db, clientCommitId) {
-    db.exec('DELETE FROM _syncular_blob_commit_refs WHERE commit_id = ?', [
+    db.exec('DELETE FROM _syncular_blob_commit_refs WHERE commit_id=?', [
         clientCommitId,
     ]);
-    db.exec('DELETE FROM _syncular_outbox_before_images WHERE client_commit_id = ?', [clientCommitId]);
-    db.exec('DELETE FROM _syncular_outbox WHERE client_commit_id = ?', [
+    db.exec('DELETE FROM _syncular_outbox_before_images WHERE client_commit_id=?', [clientCommitId]);
+    db.exec('DELETE FROM _syncular_outbox WHERE client_commit_id=?', [
         clientCommitId,
     ]);
 }
 export function listOutboxBeforeImages(db, clientCommitId) {
     return db
-        .query(`SELECT op_index, existed, sync_version, values_json
-         FROM _syncular_outbox_before_images
-        WHERE client_commit_id = ? ORDER BY op_index`, [clientCommitId])
+        .query('SELECT op_index,existed,sync_version,values_json,delivery_seq FROM _syncular_outbox_before_images WHERE client_commit_id=? ORDER BY op_index', [clientCommitId])
         .map((row) => ({
         opIndex: row.op_index,
         existed: row.existed === 1,
+        ...(typeof row.delivery_seq === 'number'
+            ? { deliverySeq: row.delivery_seq }
+            : {}),
         ...(typeof row.sync_version === 'number'
             ? { syncVersion: row.sync_version }
             : {}),
@@ -90,11 +80,7 @@ export function listOutboxBeforeImages(db, clientCommitId) {
 }
 export function replaceOutboxBeforeImages(db, clientCommitId, replacements) {
     for (const image of replacements) {
-        db.exec(`DELETE FROM _syncular_outbox_before_images
-        WHERE client_commit_id = ? AND op_index = ?`, [clientCommitId, image.opIndex]);
-        db.exec(`INSERT INTO _syncular_outbox_before_images(
-         client_commit_id, op_index, existed, sync_version, values_json
-       ) VALUES (?, ?, ?, ?, ?)`, [
+        db.exec('INSERT INTO _syncular_outbox_before_images(client_commit_id,op_index,existed,sync_version,values_json)VALUES(?,?,?,?,?) ON CONFLICT(client_commit_id,op_index)DO UPDATE SET existed=excluded.existed,sync_version=excluded.sync_version,values_json=excluded.values_json', [
             clientCommitId,
             image.opIndex,
             image.existed ? 1 : 0,
@@ -119,7 +105,7 @@ function sparseValues(table, values) {
     // bump removed (or renamed) it — the commit cannot be expressed now.
     for (const key of Object.keys(values)) {
         if (!table.columnIndex.has(key)) {
-            throw new OutboxEncodeError(`outbox commit references column ${JSON.stringify(key)} on ${JSON.stringify(table.name)}, which the current schema no longer has (§7.4.4)`);
+            throw new OutboxEncodeError(`outbox column ${JSON.stringify(key)} is absent from table ${JSON.stringify(table.name)} (§7.4.4)`);
         }
     }
     return table.columns.map((column) => {
@@ -152,7 +138,7 @@ export async function encodeOutboxCommit(schema, commit, encryption, storedKeyId
         const table = schema.tables.get(op.table);
         if (table === undefined) {
             // §7.4.4: the bump removed this table — the commit cannot be encoded.
-            throw new OutboxEncodeError(`outbox commit ${commit.clientCommitId} targets table ${JSON.stringify(op.table)}, which the current schema no longer has (§7.4.4)`);
+            throw new OutboxEncodeError(`outbox table ${JSON.stringify(op.table)} is absent from the current schema (§7.4.4)`);
         }
         if (op.values === undefined) {
             throw new ClientSyncError('sync.invalid_request', `outbox upsert on ${op.table}/${op.rowId} has no values`);
@@ -193,13 +179,7 @@ export function dropOutboxCommitsInScope(db, table, effective) {
         const inScope = commit.operations.some((op) => {
             if (op.table !== table.name || op.values === undefined)
                 return false;
-            return entries.every(([variable, values]) => {
-                const column = table.scopeColumnByVariable.get(variable);
-                if (column === undefined)
-                    return false;
-                const value = op.values?.[column];
-                return typeof value === 'string' && values.includes(value);
-            });
+            return matchesLocalScopes(table, effective, op.values);
         });
         if (inScope) {
             deleteOutboxCommit(db, commit.clientCommitId);

package/dist/outcomes.d.ts

@@ -51,6 +51,14 @@ export type CommitOperationOutcome = {
     readonly rejection: RejectionRecord;
 };
 export interface RetainedCommitRow {
+    /** Authorized different-primary-key server rows matching intended unique keys. */
+    readonly uniqueConflicts?: readonly {
+        readonly index: string;
+        readonly columns: readonly string[];
+        readonly rowId: string;
+        readonly serverRow: Readonly<Record<string, RowValue>>;
+        readonly serverVersion: number;
+    }[];
     readonly table: string;
     readonly rowId: string;
     /** Complete intended row, or null for a local deletion. */

package/dist/outcomes.js

@@ -1,5 +1,6 @@
+import { RETAINED_ROWS } from './failed-overlay.js';
 import { ClientSyncError } from './errors.js';
-import { jsonToRowValue, rowValueToJson } from './schema.js';
+import { mapRowValues, jsonToRowValue, rowValueToJson, } from './schema.js';
 function encodeResults(results) {
     const stored = results.map((result) => {
         if (result.status !== 'conflict')
@@ -8,10 +9,7 @@ function encodeResults(results) {
             status: 'conflict',
             conflict: {
                 ...result.conflict,
-                serverRow: Object.fromEntries(Object.entries(result.conflict.serverRow).map(([key, value]) => [
-                    key,
-                    rowValueToJson(value),
-                ])),
+                serverRow: mapRowValues(result.conflict.serverRow, rowValueToJson),
             },
         };
     });
@@ -28,27 +26,32 @@ function decodeResults(raw) {
                 ...result.conflict,
                 // Pre-column-version journal entries carry no conflictColumns.
                 conflictColumns: result.conflict.conflictColumns ?? [],
-                serverRow: Object.fromEntries(Object.entries(result.conflict.serverRow).map(([key, value]) => [
-                    key,
-                    jsonToRowValue(value),
-                ])),
+                serverRow: mapRowValues(result.conflict.serverRow, jsonToRowValue),
             },
         };
     });
 }
 function parseOutcome(db, row) {
     const retainedRows = db
-        .query('SELECT tbl, id, intent, base, version FROM _syncular_failed_rows WHERE commit_id = ? ORDER BY idx', [String(row.client_commit_id)])
+        .query(`SELECT tbl,id,intent,base,version,unique_conflicts FROM ${RETAINED_ROWS} WHERE commit_seq IS NULL AND commit_id=? ORDER BY idx`, [row.client_commit_id])
         .map((retained) => {
         const decode = (value) => value === null
             ? null
             : Object.fromEntries(Object.entries(JSON.parse(String(value))).map(([key, value]) => [key, jsonToRowValue(value)]));
         return {
-            table: String(retained.tbl),
-            rowId: String(retained.id),
+            table: retained.tbl,
+            rowId: retained.id,
             localRow: decode(retained.intent),
+            ...(retained.unique_conflicts === null
+                ? {}
+                : {
+                    uniqueConflicts: JSON.parse(retained.unique_conflicts).map((conflict) => ({
+                        ...conflict,
+                        serverRow: decode(JSON.stringify(conflict.serverRow)),
+                    })),
+                }),
             serverRow: decode(retained.base),
-            serverVersion: retained.version === null ? null : Number(retained.version),
+            serverVersion: retained.version === null ? null : retained.version,
         };
     });
     return {
@@ -71,9 +74,7 @@ function parseOutcome(db, row) {
     };
 }
 export function recordCommitOutcome(db, outcome) {
-    db.exec(`INSERT INTO _syncular_commit_outcomes(
-       client_commit_id, status, recorded_at_ms, results, operations, resolution
-     ) VALUES (?, ?, ?, ?, ?, 'active')`, [
+    db.exec("INSERT INTO _syncular_commit_outcomes(client_commit_id,status,recorded_at_ms,results,operations,resolution)VALUES(?,?,?,?,?,'active')", [
         outcome.clientCommitId,
         outcome.status,
         outcome.recordedAtMs,
@@ -85,9 +86,7 @@ export function recordCommitOutcome(db, outcome) {
     return commitOutcome(db, outcome.clientCommitId);
 }
 export function commitOutcome(db, clientCommitId) {
-    const row = db.query(`SELECT seq, client_commit_id, status, recorded_at_ms, results, operations,
-            resolution, resolved_at_ms, replacement_client_commit_id
-       FROM _syncular_commit_outcomes WHERE client_commit_id = ?`, [clientCommitId])[0];
+    const row = db.query('SELECT seq,client_commit_id,status,recorded_at_ms,results,operations,resolution,resolved_at_ms,replacement_client_commit_id FROM _syncular_commit_outcomes WHERE client_commit_id=?', [clientCommitId])[0];
     return row === undefined ? undefined : parseOutcome(db, row);
 }
 export function listCommitOutcomes(db, query = {}) {
@@ -98,16 +97,11 @@ export function listCommitOutcomes(db, query = {}) {
     const where = query.activeOnly
         ? "WHERE resolution = 'active' AND status IN ('conflict', 'rejected')"
         : '';
-    const rows = db.query(`SELECT seq, client_commit_id, status, recorded_at_ms, results, operations,
-            resolution, resolved_at_ms, replacement_client_commit_id
-       FROM _syncular_commit_outcomes ${where}
-      ORDER BY seq DESC${limit === undefined ? '' : ' LIMIT ?'}`, limit === undefined ? [] : [limit]);
+    const rows = db.query(`SELECT seq,client_commit_id,status,recorded_at_ms,results,operations,resolution,resolved_at_ms,replacement_client_commit_id FROM _syncular_commit_outcomes ${where} ORDER BY seq DESC${limit === undefined ? '' : ' LIMIT ?'}`, limit === undefined ? [] : [limit]);
     return rows.map((row) => parseOutcome(db, row));
 }
 export function persistCommitOutcomeResolution(db, input, nowMs) {
-    db.exec(`UPDATE _syncular_commit_outcomes
-        SET resolution = ?, resolved_at_ms = ?, replacement_client_commit_id = ?
-      WHERE client_commit_id = ? AND resolution = 'active'`, [
+    db.exec("UPDATE _syncular_commit_outcomes SET resolution=?,resolved_at_ms=?,replacement_client_commit_id=? WHERE client_commit_id=? AND resolution='active'", [
         input.resolution,
         nowMs,
         input.replacementClientCommitId ?? null,
@@ -127,11 +121,9 @@ export function pruneCommitOutcomes(db, maxEntries) {
     const excess = Math.max(0, (count ?? 0) - maxEntries);
     if (excess === 0)
         return 0;
-    const candidates = db.query(`SELECT seq FROM _syncular_commit_outcomes
-      WHERE status IN ('applied', 'cached') OR resolution != 'active'
-      ORDER BY seq ASC LIMIT ?`, [excess]);
+    const candidates = db.query("SELECT seq FROM _syncular_commit_outcomes WHERE status IN('applied','cached')OR resolution !='active' ORDER BY seq ASC LIMIT ?", [excess]);
     for (const candidate of candidates) {
-        db.exec('DELETE FROM _syncular_commit_outcomes WHERE seq = ?', [
+        db.exec('DELETE FROM _syncular_commit_outcomes WHERE seq=?', [
             candidate.seq,
         ]);
     }

package/dist/previous-version.js

@@ -241,10 +241,10 @@ export function withPreviousVersionContainer(db, fn, removeFile = false) {
 }
 /** Read the container's own metadata record; `undefined` when absent/corrupt. */
 export function readPreviousVersionContainer(db) {
-    const meta = db.query("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?", [CONTAINER_META_TABLE]);
+    const meta = db.query("SELECT 1 AS present FROM sqlite_master WHERE type='table' AND name=?", [CONTAINER_META_TABLE]);
     if (meta.length === 0)
         return undefined;
-    const raw = db.query(`SELECT record FROM ${quoteIdent(CONTAINER_META_TABLE)} WHERE id = 1`)[0]?.record;
+    const raw = db.query(`SELECT record FROM ${quoteIdent(CONTAINER_META_TABLE)} WHERE id=1`)[0]?.record;
     if (raw === undefined)
         return undefined;
     try {
@@ -287,11 +287,9 @@ function decodeRecord(value) {
     };
 }
 function writeRecord(db, record) {
-    db.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(CONTAINER_META_TABLE)} (
-       id INTEGER PRIMARY KEY CHECK (id = 1),
-       record TEXT NOT NULL)`);
+    db.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(CONTAINER_META_TABLE)}(id INTEGER PRIMARY KEY CHECK(id=1),record TEXT NOT NULL)`);
     db.exec(`DELETE FROM ${quoteIdent(CONTAINER_META_TABLE)}`);
-    db.exec(`INSERT INTO ${quoteIdent(CONTAINER_META_TABLE)}(id, record) VALUES (1, ?)`, [JSON.stringify(record)]);
+    db.exec(`INSERT INTO ${quoteIdent(CONTAINER_META_TABLE)}(id,record)VALUES(1,?)`, [JSON.stringify(record)]);
 }
 // ---------------------------------------------------------------------------
 // Bounded capture (D2 / A4)
@@ -309,9 +307,7 @@ function writeRecord(db, record) {
  */
 export function capturePreviousVersion(replica, container, oldDescriptor, newSchema, config, nowMs) {
     const discovered = new Set(replica
-        .query(`SELECT name FROM sqlite_master WHERE type = 'table'
-           AND name NOT LIKE '_syncular_%'
-           AND name NOT LIKE 'sqlite_%'`)
+        .query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '_syncular_%' AND name NOT LIKE 'sqlite_%'")
         .map((row) => String(row.name)));
     // Only descriptor-known tables carry semantic types; those are the tables the
     // copy would hold, and the count the table budget bounds.
@@ -326,7 +322,7 @@ export function capturePreviousVersion(replica, container, oldDescriptor, newSch
     let measuredRows = 0;
     const perTableRows = [];
     for (const table of tables) {
-        const probeRows = Number(replica.query(`SELECT COUNT(*) AS count FROM (SELECT 1 FROM ${quoteIdent(table.name)} LIMIT ?)`, [config.maxRows + 1])[0]?.count ?? 0);
+        const probeRows = Number(replica.query(`SELECT COUNT(*)AS count FROM(SELECT 1 FROM ${quoteIdent(table.name)} LIMIT ?)`, [config.maxRows + 1])[0]?.count ?? 0);
         measuredRows += probeRows;
         perTableRows.push(probeRows);
         if (measuredRows > config.maxRows)
@@ -340,13 +336,10 @@ export function capturePreviousVersion(replica, container, oldDescriptor, newSch
             .join(' + ');
         if (table.columns.length === 0)
             continue;
-        const oversized = replica.query(`SELECT 1 AS hit FROM ${quoteIdent(table.name)}
-         WHERE (${byteSum}) > ? LIMIT 1`, [config.maxRowBytes]);
+        const oversized = replica.query(`SELECT 1 AS hit FROM ${quoteIdent(table.name)} WHERE(${byteSum})>? LIMIT 1`, [config.maxRowBytes]);
         if (oversized.length > 0)
             return over(measuredRows, measuredBytes);
-        const total = replica.query(`SELECT COALESCE(SUM(bytes), 0) AS total FROM (
-         SELECT (${byteSum}) AS bytes FROM ${quoteIdent(table.name)} LIMIT ?
-       )`, [perTableRows[index] ?? 0])[0]?.total;
+        const total = replica.query(`SELECT COALESCE(SUM(bytes),0)AS total FROM(SELECT(${byteSum})AS bytes FROM ${quoteIdent(table.name)} LIMIT ?)`, [perTableRows[index] ?? 0])[0]?.total;
         measuredBytes += Number(total ?? 0);
         if (measuredBytes > config.maxBytes)
             return over(measuredRows, measuredBytes);
@@ -354,19 +347,14 @@ export function capturePreviousVersion(replica, container, oldDescriptor, newSch
     let copiedRows = 0;
     container.transaction(() => {
         dropPreviousVersionContainer(container);
-        container.exec(`CREATE TABLE ${quoteIdent(CONTAINER_TABLE)} (
-         tbl TEXT NOT NULL,
-         row_id TEXT NOT NULL,
-         payload TEXT NOT NULL,
-         PRIMARY KEY (tbl, row_id))`);
+        container.exec(`CREATE TABLE ${quoteIdent(CONTAINER_TABLE)}(tbl TEXT NOT NULL,row_id TEXT NOT NULL,payload TEXT NOT NULL,PRIMARY KEY(tbl,row_id))`);
         for (const table of tables) {
             const selectColumns = table.columns
                 .map((column) => quoteIdent(column.name))
                 .join(', ');
             let lastRowId = -1;
             for (;;) {
-                const rows = replica.query(`SELECT rowid AS _rid, ${selectColumns} FROM ${quoteIdent(table.name)}
-             WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`, [lastRowId, COPY_BATCH_ROWS]);
+                const rows = replica.query(`SELECT rowid AS _rid,${selectColumns} FROM ${quoteIdent(table.name)} WHERE rowid>? ORDER BY rowid ASC LIMIT ?`, [lastRowId, COPY_BATCH_ROWS]);
                 if (rows.length === 0)
                     break;
                 for (const row of rows) {
@@ -375,8 +363,7 @@ export function capturePreviousVersion(replica, container, oldDescriptor, newSch
                         const value = fromSqlValue({ name: column.name, type: column.type, nullable: true }, (row[column.name] ?? null));
                         payload[column.name] = rowValueToJson(value);
                     }
-                    container.exec(`INSERT INTO ${quoteIdent(CONTAINER_TABLE)}(tbl, row_id, payload)
-               VALUES (?, ?, ?)`, [table.name, rowIdText(table, row), JSON.stringify(payload)]);
+                    container.exec(`INSERT INTO ${quoteIdent(CONTAINER_TABLE)}(tbl,row_id,payload)VALUES(?,?,?)`, [table.name, rowIdText(table, row), JSON.stringify(payload)]);
                 }
                 lastRowId = Number(rows[rows.length - 1]?._rid ?? lastRowId);
                 copiedRows += rows.length;
@@ -431,8 +418,7 @@ export function readPreviousVersionRows(db, table, rowIds, limit) {
     const where = rowIds.length === 0
         ? ''
         : ` AND row_id IN (${rowIds.map(() => '?').join(', ')})`;
-    const rows = db.query(`SELECT row_id, payload FROM ${quoteIdent(CONTAINER_TABLE)}
-       WHERE tbl = ?${where} ORDER BY row_id ASC LIMIT ?`, [table.name, ...rowIds, limit + 1]);
+    const rows = db.query(`SELECT row_id,payload FROM ${quoteIdent(CONTAINER_TABLE)} WHERE tbl=?${where} ORDER BY row_id ASC LIMIT ?`, [table.name, ...rowIds, limit + 1]);
     const truncated = rows.length > limit;
     const visible = truncated ? rows.slice(0, limit) : rows;
     return {
@@ -455,7 +441,7 @@ export function writePreviousVersionRefusal(db, reason, measurement) {
 }
 /** Delete the durable refusal. Part of the orphan sweep and of a successful capture. */
 export function clearPreviousVersionRefusal(db) {
-    db.exec('DELETE FROM _syncular_meta WHERE key = ?', [
+    db.exec('DELETE FROM _syncular_meta WHERE key=?', [
         PREVIOUS_VERSION_CONTEXT_KEY,
     ]);
 }
@@ -589,7 +575,7 @@ export function writePreviousVersionAudit(db, audit) {
 }
 /** Delete the advisory audit. Part of a discard, never of a normal bump. */
 export function clearPreviousVersionAudit(db) {
-    db.exec('DELETE FROM _syncular_meta WHERE key = ?', [
+    db.exec('DELETE FROM _syncular_meta WHERE key=?', [
         PREVIOUS_VERSION_AUDIT_KEY,
     ]);
 }