@syncular/client 0.30.10 → 0.30.11

package/src/failed-overlay.ts

@@ -1,7 +1,21 @@
 import { ClientSyncError } from './errors';
 import type { ClientDatabase } from './database';
-import type { CompiledClientSchema, JsonRowValue } from './schema';
-import { jsonToRowValue, quoteIdent } from './schema';
+import type {
+  CompiledClientSchema,
+  CompiledClientTable,
+  JsonRowValue,
+} from './schema';
+import {
+  mapRowValues,
+  fromSqlValue,
+  jsonToRowValue,
+  quoteIdent,
+  rowValueToJson,
+  SYNC_VERSION_COLUMN,
+  toSqlValue,
+} from './schema';
+import type { RowValue } from '@syncular/core';
+import type { RetainedCommitRow } from './outcomes';
 import type {
   OutboxCommit,
   OutboxBeforeImage,
@@ -11,29 +25,78 @@ import { deleteLocalRow, upsertLocalRow } from './apply';
 
 /** Protected failure state. The server base advances independently of intent. */
 export function ensureFailedOverlaySchema(db: ClientDatabase): void {
-  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 _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,unique_conflicts TEXT,PRIMARY KEY(commit_id,idx))',
+  );
+  if (
+    !db
+      .query('PRAGMA table_info(_syncular_failed_rows)')
+      .some((row) => row.name === 'unique_conflicts')
+  )
+    db.exec(
+      'ALTER TABLE _syncular_failed_rows ADD COLUMN unique_conflicts TEXT',
+    );
 }
 
 export function retainedBaseWrite(
   db: ClientDatabase,
-  table: string,
+  table: CompiledClientTable,
   rowId: string,
   values?: Readonly<Record<string, JsonRowValue>>,
   version?: number,
 ): void {
   db.exec(
-    'UPDATE _syncular_failed_rows SET base = ?, version = ? WHERE tbl = ? AND id = ?',
+    'UPDATE _syncular_failed_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 _syncular_failed_rows WHERE tbl=?',
+    [table.name],
+  )) {
+    const prior: readonly (Omit<
+      NonNullable<RetainedCommitRow['uniqueConflicts']>[number],
+      'serverRow'
+    > & { serverRow: Readonly<Record<string, JsonRowValue>> })[] =
+      retained.unique_conflicts === null
+        ? []
+        : JSON.parse(String(retained.unique_conflicts));
+    const conflicts = prior.filter((conflict) => conflict.rowId !== rowId);
+    if (values !== undefined && retained.intent !== null) {
+      const intent: Record<string, JsonRowValue> = JSON.parse(
+        String(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 _syncular_failed_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,
+        String(retained.commit_id),
+        Number(retained.idx),
+      ],
+    );
+  }
 }
 
 export function retainFailedRows(
@@ -53,8 +116,7 @@ export function retainFailedRows(
         'retained intent has no before-image',
       );
     db.exec(
-      `INSERT INTO _syncular_failed_rows(commit_id, idx, tbl, id, at, op, intent, base, version)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      'INSERT INTO _syncular_failed_rows(commit_id,idx,tbl,id,at,op,intent,base,version)VALUES(?,?,?,?,?,?,?,?,?)',
       [
         commit.clientCommitId,
         index,
@@ -70,6 +132,40 @@ export function retainFailedRows(
   }
 }
 
+/** Match declared keys through SQLite, preserving index affinity and NULL semantics. */
+export function uniqueConflicts(
+  db: ClientDatabase,
+  table: CompiledClientTable,
+  values: Readonly<Record<string, RowValue>>,
+): NonNullable<RetainedCommitRow['uniqueConflicts']> {
+  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]),
+        })),
+    );
+}
+
 export function restoreFailedBases(
   db: ClientDatabase,
   schema: CompiledClientSchema,
@@ -77,7 +173,7 @@ export function restoreFailedBases(
 ): void {
   const seen = new Set<string>();
   for (const row of db.query(
-    'SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx',
+    'SELECT * FROM _syncular_failed_rows ORDER BY at,commit_id,idx',
   )) {
     const key = JSON.stringify([row.tbl, row.id]);
     if (!absentIntent && seen.has(key)) continue;
@@ -89,11 +185,48 @@ export function restoreFailedBases(
         'retained intent references an unknown table',
       );
     const json = absentIntent ? row.intent : row.base;
+    if (absentIntent && row.intent !== null) {
+      const values: Record<string, JsonRowValue> = JSON.parse(
+        String(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.unique_conflicts === null) {
+        const authorized = conflicts.filter(
+          (conflict) =>
+            conflict.serverVersion >= 0 &&
+            !db.query(
+              "SELECT 1 FROM _syncular_failed_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 _syncular_failed_rows SET unique_conflicts=? WHERE commit_id=? AND idx=?',
+            [
+              JSON.stringify(
+                authorized.map((conflict) => ({
+                  ...conflict,
+                  serverRow: mapRowValues(conflict.serverRow, rowValueToJson),
+                })),
+              ),
+              String(row.commit_id),
+              Number(row.idx),
+            ],
+          );
+      }
+      if (conflicts.length) continue;
+    }
     if (
       absentIntent &&
       (json === null ||
         db.query(
-          `SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`,
+          `SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`,
           [String(row.id)],
         ).length)
     )
@@ -134,7 +267,7 @@ export function failedOverlayCommits(db: ClientDatabase): OutboxCommit[] {
     }
   >();
   for (const row of db.query(
-    'SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx',
+    'SELECT * FROM _syncular_failed_rows ORDER BY at,commit_id,idx',
   )) {
     const id = String(row.commit_id);
     const operation: OutboxOperation = JSON.parse(String(row.op));
@@ -168,7 +301,12 @@ export function dropFailedRows(
   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]);
+  for (const id of ids) {
+    db.exec('DELETE FROM _syncular_failed_rows WHERE commit_id=?', [id]);
+    db.exec(
+      "UPDATE _syncular_commit_outcomes SET operations=NULL,results='[]' WHERE client_commit_id=?",
+      [id],
+    );
+  }
   return dropped;
 }

package/src/outbox.ts

@@ -66,15 +66,12 @@ export function appendOutboxCommit(
     );
   }
   db.exec(
-    `INSERT INTO _syncular_outbox(client_commit_id, created_at_ms, operations)
-     VALUES (?, ?, ?)`,
+    '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 (?, ?, ?, ?, ?)`,
+      'INSERT INTO _syncular_outbox_before_images(client_commit_id,op_index,existed,sync_version,values_json)VALUES(?,?,?,?,?)',
       [
         clientCommitId,
         image.opIndex,
@@ -90,8 +87,7 @@ export function appendOutboxCommit(
 export function listOutbox(db: ClientDatabase): OutboxCommit[] {
   return db
     .query(
-      `SELECT seq, client_commit_id, created_at_ms, operations
-       FROM _syncular_outbox ORDER BY seq ASC`,
+      'SELECT seq, client_commit_id, created_at_ms, operations FROM _syncular_outbox ORDER BY seq ASC',
     )
     .map(decodeOutboxRow);
 }
@@ -113,8 +109,7 @@ export function* iterateOutbox(
   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`,
+      '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;
@@ -128,7 +123,7 @@ export function* iterateOutbox(
 
 /** Routine status reads never load operation bodies. */
 export function countOutbox(db: ClientDatabase): number {
-  return db.query('SELECT COUNT(*) AS count FROM _syncular_outbox')[0]!
+  return db.query('SELECT COUNT(*)AS count FROM _syncular_outbox')[0]!
     .count as number;
 }
 
@@ -136,14 +131,14 @@ export function deleteOutboxCommit(
   db: ClientDatabase,
   clientCommitId: string,
 ): void {
-  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 = ?',
+    '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 WHERE client_commit_id=?', [
     clientCommitId,
   ]);
 }
@@ -154,9 +149,7 @@ export function listOutboxBeforeImages(
 ): OutboxBeforeImage[] {
   return db
     .query(
-      `SELECT op_index, existed, sync_version, values_json
-         FROM _syncular_outbox_before_images
-        WHERE client_commit_id = ? ORDER BY op_index`,
+      'SELECT op_index,existed,sync_version,values_json FROM _syncular_outbox_before_images WHERE client_commit_id=? ORDER BY op_index',
       [clientCommitId],
     )
     .map((row) => ({
@@ -182,14 +175,11 @@ export function replaceOutboxBeforeImages(
 ): void {
   for (const image of replacements) {
     db.exec(
-      `DELETE FROM _syncular_outbox_before_images
-        WHERE client_commit_id = ? AND op_index = ?`,
+      '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 (?, ?, ?, ?, ?)`,
+      'INSERT INTO _syncular_outbox_before_images(client_commit_id,op_index,existed,sync_version,values_json)VALUES(?,?,?,?,?)',
       [
         clientCommitId,
         image.opIndex,

package/src/outcomes.ts

@@ -10,7 +10,12 @@ import type { RejectionDetails, RowValue } from '@syncular/core';
 import type { ClientDatabase } from './database';
 import { ClientSyncError } from './errors';
 import type { OutboxOperation } from './outbox';
-import { type JsonRowValue, jsonToRowValue, rowValueToJson } from './schema';
+import {
+  mapRowValues,
+  type JsonRowValue,
+  jsonToRowValue,
+  rowValueToJson,
+} from './schema';
 
 export interface ConflictRecord {
   readonly clientCommitId: string;
@@ -70,6 +75,14 @@ export type CommitOperationOutcome =
     };
 
 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. */
@@ -132,12 +145,7 @@ function encodeResults(results: readonly CommitOperationOutcome[]): string {
       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),
       },
     };
   });
@@ -154,12 +162,7 @@ function decodeResults(raw: string): CommitOperationOutcome[] {
         ...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),
       },
     };
   });
@@ -171,7 +174,7 @@ function parseOutcome(
 ): CommitOutcome {
   const retainedRows: RetainedCommitRow[] = db
     .query(
-      'SELECT tbl, id, intent, base, version FROM _syncular_failed_rows WHERE commit_id = ? ORDER BY idx',
+      'SELECT tbl,id,intent,base,version,unique_conflicts FROM _syncular_failed_rows WHERE commit_id=? ORDER BY idx',
       [String(row.client_commit_id)],
     )
     .map((retained) => {
@@ -187,6 +190,18 @@ function parseOutcome(
         table: String(retained.tbl),
         rowId: String(retained.id),
         localRow: decode(retained.intent),
+        ...(retained.unique_conflicts === null
+          ? {}
+          : {
+              uniqueConflicts: (
+                JSON.parse(String(retained.unique_conflicts)) as NonNullable<
+                  RetainedCommitRow['uniqueConflicts']
+                >
+              ).map((conflict) => ({
+                ...conflict,
+                serverRow: decode(JSON.stringify(conflict.serverRow))!,
+              })),
+            }),
         serverRow: decode(retained.base),
         serverVersion:
           retained.version === null ? null : Number(retained.version),
@@ -217,9 +232,7 @@ export function recordCommitOutcome(
   outcome: Omit<CommitOutcome, 'sequence' | 'resolution'>,
 ): CommitOutcome {
   db.exec(
-    `INSERT INTO _syncular_commit_outcomes(
-       client_commit_id, status, recorded_at_ms, results, operations, resolution
-     ) VALUES (?, ?, ?, ?, ?, 'active')`,
+    "INSERT INTO _syncular_commit_outcomes(client_commit_id,status,recorded_at_ms,results,operations,resolution)VALUES(?,?,?,?,?,'active')",
     [
       outcome.clientCommitId,
       outcome.status,
@@ -238,9 +251,7 @@ export function commitOutcome(
   clientCommitId: string,
 ): CommitOutcome | undefined {
   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 = ?`,
+    '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);
@@ -261,10 +272,7 @@ export function listCommitOutcomes(
     ? "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 ?'}`,
+    `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));
@@ -276,9 +284,7 @@ export function persistCommitOutcomeResolution(
   nowMs: number,
 ): CommitOutcome | undefined {
   db.exec(
-    `UPDATE _syncular_commit_outcomes
-        SET resolution = ?, resolved_at_ms = ?, replacement_client_commit_id = ?
-      WHERE client_commit_id = ? AND resolution = 'active'`,
+    "UPDATE _syncular_commit_outcomes SET resolution=?,resolved_at_ms=?,replacement_client_commit_id=? WHERE client_commit_id=? AND resolution='active'",
     [
       input.resolution,
       nowMs,
@@ -309,13 +315,11 @@ export function pruneCommitOutcomes(
   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 ?`,
+    "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 as number,
     ]);
   }

package/src/previous-version.ts

@@ -453,12 +453,12 @@ export function readPreviousVersionContainer(
   db: ClientDatabase,
 ): PreviousVersionRecord | undefined {
   const meta = db.query(
-    "SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?",
+    "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`,
+    `SELECT record FROM ${quoteIdent(CONTAINER_META_TABLE)} WHERE id=1`,
   )[0]?.record;
   if (raw === undefined) return undefined;
   try {
@@ -504,13 +504,11 @@ function decodeRecord(value: string): PreviousVersionRecord {
 
 function writeRecord(db: ClientDatabase, record: PreviousVersionRecord): void {
   db.exec(
-    `CREATE TABLE IF NOT EXISTS ${quoteIdent(CONTAINER_META_TABLE)} (
-       id INTEGER PRIMARY KEY CHECK (id = 1),
-       record TEXT NOT NULL)`,
+    `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, ?)`,
+    `INSERT INTO ${quoteIdent(CONTAINER_META_TABLE)}(id,record)VALUES(1,?)`,
     [JSON.stringify(record)],
   );
 }
@@ -541,9 +539,7 @@ export function capturePreviousVersion(
   const discovered = new Set(
     replica
       .query(
-        `SELECT name FROM sqlite_master WHERE type = 'table'
-           AND name NOT LIKE '_syncular_%'
-           AND name NOT LIKE 'sqlite_%'`,
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '_syncular_%' AND name NOT LIKE 'sqlite_%'",
       )
       .map((row) => String(row.name)),
   );
@@ -567,7 +563,7 @@ export function capturePreviousVersion(
   for (const table of tables) {
     const probeRows = Number(
       replica.query(
-        `SELECT COUNT(*) AS count FROM (SELECT 1 FROM ${quoteIdent(table.name)} LIMIT ?)`,
+        `SELECT COUNT(*)AS count FROM(SELECT 1 FROM ${quoteIdent(table.name)} LIMIT ?)`,
         [config.maxRows + 1],
       )[0]?.count ?? 0,
     );
@@ -584,15 +580,12 @@ export function capturePreviousVersion(
       .join(' + ');
     if (table.columns.length === 0) continue;
     const oversized = replica.query(
-      `SELECT 1 AS hit FROM ${quoteIdent(table.name)}
-         WHERE (${byteSum}) > ? LIMIT 1`,
+      `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 ?
-       )`,
+      `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);
@@ -604,11 +597,7 @@ export function capturePreviousVersion(
   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))`,
+      `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
@@ -617,8 +606,7 @@ export function capturePreviousVersion(
       let lastRowId = -1;
       for (;;) {
         const rows = replica.query(
-          `SELECT rowid AS _rid, ${selectColumns} FROM ${quoteIdent(table.name)}
-             WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`,
+          `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;
@@ -632,8 +620,7 @@ export function capturePreviousVersion(
             payload[column.name] = rowValueToJson(value);
           }
           container.exec(
-            `INSERT INTO ${quoteIdent(CONTAINER_TABLE)}(tbl, row_id, payload)
-               VALUES (?, ?, ?)`,
+            `INSERT INTO ${quoteIdent(CONTAINER_TABLE)}(tbl,row_id,payload)VALUES(?,?,?)`,
             [table.name, rowIdText(table, row), JSON.stringify(payload)],
           );
         }
@@ -703,8 +690,7 @@ export function readPreviousVersionRows(
       ? ''
       : ` 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 ?`,
+    `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;
@@ -738,7 +724,7 @@ export function writePreviousVersionRefusal(
 
 /** Delete the durable refusal. Part of the orphan sweep and of a successful capture. */
 export function clearPreviousVersionRefusal(db: ClientDatabase): void {
-  db.exec('DELETE FROM _syncular_meta WHERE key = ?', [
+  db.exec('DELETE FROM _syncular_meta WHERE key=?', [
     PREVIOUS_VERSION_CONTEXT_KEY,
   ]);
 }
@@ -906,7 +892,7 @@ export function writePreviousVersionAudit(
 
 /** Delete the advisory audit. Part of a discard, never of a normal bump. */
 export function clearPreviousVersionAudit(db: ClientDatabase): void {
-  db.exec('DELETE FROM _syncular_meta WHERE key = ?', [
+  db.exec('DELETE FROM _syncular_meta WHERE key=?', [
     PREVIOUS_VERSION_AUDIT_KEY,
   ]);
 }