@syncular/client 0.30.10 → 0.30.11

package/dist/failed-overlay.js

@@ -1,21 +1,46 @@
 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 _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, table, rowId, values, version) {
-    db.exec('UPDATE _syncular_failed_rows SET base = ?, version = ? WHERE tbl = ? AND id = ?', [
+    db.exec('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 = 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 = 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(db, commit, images) {
     for (const [index, operation] of commit.operations.entries()) {
@@ -25,8 +50,7 @@ export function retainFailedRows(db, commit, images) {
             : 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 (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        db.exec('INSERT INTO _syncular_failed_rows(commit_id,idx,tbl,id,at,op,intent,base,version)VALUES(?,?,?,?,?,?,?,?,?)', [
             commit.clientCommitId,
             index,
             operation.table,
@@ -39,9 +63,29 @@ export function retainFailedRows(db, commit, images) {
         ]);
     }
 }
+/** 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]),
+    })));
+}
 export function restoreFailedBases(db, schema, absentIntent = false) {
     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 db.query('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;
@@ -50,9 +94,30 @@ export function restoreFailedBases(db, schema, absentIntent = false) {
         if (!table)
             throw new ClientSyncError('sync.unknown_table', 'retained intent references an unknown table');
         const json = absentIntent ? row.intent : row.base;
+        if (absentIntent && row.intent !== null) {
+            const values = 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)} = ?`, [String(row.id)]).length))
+                db.query(`SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [String(row.id)]).length))
             continue;
         if (json === null)
             deleteLocalRow(db, table, String(row.id), false);
@@ -69,7 +134,7 @@ export function restoreFailedBases(db, schema, absentIntent = false) {
 }
 export function failedOverlayCommits(db) {
     const commits = new Map();
-    for (const row of db.query('SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx')) {
+    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));
         const prior = commits.get(id);
@@ -96,7 +161,9 @@ export function dropFailedRows(db, matches) {
             ids.add(String(row.commit_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]);
+    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/dist/outbox.js

@@ -12,12 +12,9 @@ export function appendOutboxCommit(db, clientCommitId, operations, nowMs, before
     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)]);
+    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 (?, ?, ?, ?, ?)`, [
+        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,
@@ -29,8 +26,7 @@ export function appendOutboxCommit(db, clientCommitId, operations, nowMs, before
 /** Pending commits in FIFO creation order (§7.1). Full reads serve replay and the public listing. */
 export function listOutbox(db) {
     return db
-        .query(`SELECT seq, client_commit_id, created_at_ms, operations
-       FROM _syncular_outbox ORDER BY seq ASC`)
+        .query('SELECT seq, client_commit_id, created_at_ms, operations FROM _syncular_outbox ORDER BY seq ASC')
         .map(decodeOutboxRow);
 }
 function decodeOutboxRow(row) {
@@ -45,8 +41,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,23 +53,21 @@ 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 FROM _syncular_outbox_before_images WHERE client_commit_id=? ORDER BY op_index', [clientCommitId])
         .map((row) => ({
         opIndex: row.op_index,
         existed: row.existed === 1,
@@ -90,11 +83,8 @@ 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('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(?,?,?,?,?)', [
             clientCommitId,
             image.opIndex,
             image.existed ? 1 : 0,

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,5 @@
 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 +8,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,17 +25,14 @@ 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 _syncular_failed_rows WHERE commit_id=? ORDER BY idx', [String(row.client_commit_id)])
         .map((retained) => {
         const decode = (value) => value === null
             ? null
@@ -47,6 +41,14 @@ function parseOutcome(db, row) {
             table: String(retained.tbl),
             rowId: String(retained.id),
             localRow: decode(retained.intent),
+            ...(retained.unique_conflicts === null
+                ? {}
+                : {
+                    uniqueConflicts: JSON.parse(String(retained.unique_conflicts)).map((conflict) => ({
+                        ...conflict,
+                        serverRow: decode(JSON.stringify(conflict.serverRow)),
+                    })),
+                }),
             serverRow: decode(retained.base),
             serverVersion: retained.version === null ? null : Number(retained.version),
         };
@@ -71,9 +73,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 +85,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 +96,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 +120,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,
     ]);
 }

package/dist/schema.d.ts

@@ -160,3 +160,5 @@ export type JsonRowValue = string | number | boolean | null | {
 export declare function hexToBytes(hex: string): Uint8Array;
 export declare function rowValueToJson(value: RowValue): JsonRowValue;
 export declare function jsonToRowValue(value: JsonRowValue): RowValue;
+/** Convert each column value without changing the row's presence set. */
+export declare function mapRowValues<T, U>(values: Readonly<Record<string, T>>, convert: (value: T) => U): Record<string, U>;