@syncular/client 0.30.10 → 0.30.12

package/README.md

@@ -18,6 +18,13 @@ Ordinary commits use wire version 1 until the caller supplies an acquired
 partition `logEpoch`. Set `logEpoch` after a restore rotation requires epoch
 validation.
 
+Applied and cached acknowledgements drain the send queue while protected local
+intent stays visible until the same row's server image arrives at that commit
+sequence or later. Empty pulls and restart preserve it; later edits stack above
+it. This behavior is automatic, independent of `retainFailedCommits`. The core
+requests a following pull without relying on an origin realtime notification.
+See [optimistic writes](https://syncular.dev/concepts-conflicts/#the-optimistic-outbox).
+
 ## Client-local FTS5 projections
 
 Generated schemas may attach `ftsIndexes` to a synced table. The
@@ -389,6 +396,14 @@ and scope revocation remove whole retained aggregates. If a sparse conflict
 loses its server base, the client keeps the sparse operation and conflict
 evidence without materializing a local row from the saved before-image.
 
+A retained insert whose unique key belongs to another server primary key remains
+journal intent while reads show the server winner. `retainedRows[].uniqueConflicts`
+contains each matching index, its columns, competing `rowId`, authorized
+`serverRow` and `serverVersion`. Keep-mine patches that competing ID at its
+current version and links the replacement through `superseded`. Edit can choose
+a free unique key. Take-server uses `resolved_keep_server`. Revocation and local
+security purge erase the retained aggregate's protected journal payloads.
+
 ## Application-authorized local security purge
 
 `purgeLocalData({ purgeId, targets })` is the narrow local-storage primitive

package/dist/apply.d.ts

@@ -23,7 +23,7 @@ export declare function deleteLocalRow(db: ClientDatabase, table: CompiledClient
  * (`client.decrypt_failed`) aborts before any local write, so the commit
  * never half-applies.
  */
-export declare function applyCommitFrame(db: ClientDatabase, schema: CompiledClientSchema, frame: CommitFrame, encryption?: EncryptionConfig, transaction?: ApplyTransaction): Promise<void>;
+export declare function applyCommitFrame(db: ClientDatabase, schema: CompiledClientSchema, frame: CommitFrame, encryption?: EncryptionConfig, transaction?: (fn: () => readonly string[] | undefined) => unknown): Promise<void>;
 /**
  * §5.2: the segment's column table must match the generated schema for
  * (table, schemaVersion) — order, names, types, nullability. A mismatch is
@@ -37,6 +37,10 @@ export declare function validateSegmentColumns(schema: CompiledClientSchema, tab
  * (`sync.scope_revoked`) when the table has no local mapping for a key:
  * precision or nothing, never clear-the-table.
  */
+export declare function localScopePredicate(table: CompiledClientTable, effective: ScopeMap): {
+    sql: string;
+    params: string[];
+} | undefined;
 export declare function deleteScopedRows(db: ClientDatabase, table: CompiledClientTable, effective: ScopeMap): void;
 /**
  * §4.8 window eviction: delete rows matching a departing unit's effective

package/dist/apply.js

@@ -1,4 +1,5 @@
-import { retainedBaseWrite } from './failed-overlay.js';
+import { RETAINED_ROWS } from './failed-overlay.js';
+import { retainedBaseWrite, restoreFailedBases } from './failed-overlay.js';
 /**
  * Local application of server data: `COMMIT` frames (§4.5), rows segments
  * (§5.2, §5.6), and the scope-matched delete shared by the §3.3 purge
@@ -6,7 +7,7 @@ import { retainedBaseWrite } from './failed-overlay.js';
  */
 import { decodeRow, } from '@syncular/core';
 import { ClientSyncError, invalidRequest } from './errors.js';
-import { quoteIdent, SYNC_VERSION_COLUMN, toSqlValue, rowValueToJson, } from './schema.js';
+import { quoteIdent, matchesLocalScopes, SYNC_VERSION_COLUMN, toSqlValue, rowValueToJson, } from './schema.js';
 function upsertSql(table) {
     const names = [
         ...table.columns.map((column) => quoteIdent(column.name)),
@@ -17,21 +18,20 @@ function upsertSql(table) {
         .filter((name) => name !== quoteIdent(table.primaryKey))
         .map((name) => `${name}=excluded.${name}`)
         .join(', ');
-    return `INSERT INTO ${quoteIdent(table.name)} (${names.join(', ')}) VALUES (${placeholders})
-    ON CONFLICT (${quoteIdent(table.primaryKey)}) DO UPDATE SET ${updates}`;
+    return `INSERT INTO ${quoteIdent(table.name)}(${names.join(', ')})VALUES(${placeholders})ON CONFLICT(${quoteIdent(table.primaryKey)})DO UPDATE SET ${updates}`;
 }
 export function upsertLocalRow(db, table, values, syncVersion, serverWrite = true) {
+    db.exec(upsertSql(table), [...values.map(toSqlValue), syncVersion]);
     if (serverWrite)
-        retainedBaseWrite(db, table.name, String(values[table.primaryKeyIndex]), Object.fromEntries(table.columns.map((column, index) => [
+        retainedBaseWrite(db, table, String(values[table.primaryKeyIndex]), Object.fromEntries(table.columns.map((column, index) => [
             column.name,
             rowValueToJson(values[index] ?? null),
         ])), syncVersion);
-    db.exec(upsertSql(table), [...values.map(toSqlValue), syncVersion]);
 }
 export function deleteLocalRow(db, table, rowId, serverWrite = true) {
     if (serverWrite)
-        retainedBaseWrite(db, table.name, rowId);
-    db.exec(`DELETE FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [rowId]);
+        retainedBaseWrite(db, table, rowId);
+    db.exec(`DELETE FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`, [rowId]);
 }
 /**
  * Apply one `COMMIT` frame in one local transaction (§1.4 rule 4).
@@ -76,7 +76,14 @@ export async function applyCommitFrame(db, schema, frame, encryption, transactio
         });
     }
     transaction(() => {
-        for (const change of resolved) {
+        const rowKeys = frame.tables.some((name) => schema.tables.get(name)?.indexes.some((index) => index.unique))
+            ? undefined
+            : frame.changes.map((change) => JSON.stringify([frame.tables[change.tableIndex], change.rowId]));
+        restoreFailedBases(db, schema, false, rowKeys);
+        for (const [index, change] of resolved.entries()) {
+            const rowId = frame.changes[index].rowId;
+            db.exec("UPDATE _syncular_outbox_before_images SET delivery_seq=MAX(COALESCE(delivery_seq,0),?) WHERE (client_commit_id,op_index) IN(SELECT client_commit_id,json_each.key FROM _syncular_outbox,json_each(operations) WHERE json_extract(value,'$.table')=? AND json_extract(value,'$.rowId')=?)", [frame.commitSeq, change.table.name, rowId]);
+            db.exec(`DELETE FROM ${RETAINED_ROWS} WHERE tbl=? AND id=? AND commit_seq<=?`, [change.table.name, rowId, frame.commitSeq]);
             if (change.op === 'delete') {
                 deleteLocalRow(db, change.table, change.rowId);
             }
@@ -84,6 +91,7 @@ export async function applyCommitFrame(db, schema, frame, encryption, transactio
                 upsertLocalRow(db, change.table, change.values, change.rowVersion);
             }
         }
+        return rowKeys;
     });
 }
 /**
@@ -123,26 +131,31 @@ export function validateSegmentColumns(schema, table, segment) {
  * (`sync.scope_revoked`) when the table has no local mapping for a key:
  * precision or nothing, never clear-the-table.
  */
-export function deleteScopedRows(db, table, effective) {
+export function localScopePredicate(table, effective) {
     const entries = Object.entries(effective);
-    if (entries.length === 0)
+    if (!entries.length || entries.some(([, values]) => !values.length))
         return;
-    const clauses = [];
     const params = [];
-    for (const [variable, values] of entries) {
+    const sql = entries
+        .map(([variable, values]) => {
         const column = table.scopeColumnByVariable.get(variable);
-        if (column === undefined) {
-            throw new ClientSyncError('sync.scope_revoked', `table ${JSON.stringify(table.name)} has no local scope-column mapping for ${JSON.stringify(variable)} (§3.3 fail-closed)`);
-        }
-        if (values.length === 0)
-            return;
-        clauses.push(`${quoteIdent(column)} IN (${values.map(() => '?').join(', ')})`);
+        if (column === undefined)
+            throw new ClientSyncError('sync.scope_revoked', 'table has no local scope-column mapping');
         params.push(...values);
+        return `${quoteIdent(column)} IN (${values.map(() => '?').join(', ')})`;
+    })
+        .join(' AND ');
+    return { sql, params };
+}
+export function deleteScopedRows(db, table, effective) {
+    const scope = localScopePredicate(table, effective);
+    if (!scope)
+        return;
+    const { sql, params } = scope;
+    for (const row of db.query(`SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${sql}`, params)) {
+        retainedBaseWrite(db, table, String(row.id));
     }
-    for (const row of db.query(`SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${clauses.join(' AND ')}`, params)) {
-        retainedBaseWrite(db, table.name, String(row.id));
-    }
-    db.exec(`DELETE FROM ${quoteIdent(table.name)} WHERE ${clauses.join(' AND ')}`, params);
+    db.exec(`DELETE FROM ${quoteIdent(table.name)} WHERE ${sql}`, params);
 }
 /**
  * §4.8 window eviction: delete rows matching a departing unit's effective
@@ -155,21 +168,10 @@ export function deleteScopedRows(db, table, effective) {
  * cache), which is automatic since the version column is per-row.
  */
 export function evictScopedRows(db, table, effective, pinnedRowIds) {
-    const entries = Object.entries(effective);
-    if (entries.length === 0)
+    const scope = localScopePredicate(table, effective);
+    if (!scope)
         return { remaining: false, deferred: false };
-    const clauses = [];
-    const params = [];
-    for (const [variable, values] of entries) {
-        const column = table.scopeColumnByVariable.get(variable);
-        if (column === undefined) {
-            throw new ClientSyncError('sync.scope_revoked', `table ${JSON.stringify(table.name)} has no local scope-column mapping for ${JSON.stringify(variable)} (§4.8/§3.3 fail-closed)`);
-        }
-        if (values.length === 0)
-            return { remaining: false, deferred: false };
-        clauses.push(`${quoteIdent(column)} IN (${values.map(() => '?').join(', ')})`);
-        params.push(...values);
-    }
+    const { sql, params } = scope;
     const pk = quoteIdent(table.primaryKey);
     let pinnedClause = '';
     if (pinnedRowIds.size > 0) {
@@ -178,12 +180,16 @@ export function evictScopedRows(db, table, effective, pinnedRowIds) {
         params.push(...ids);
     }
     const target = quoteIdent(table.name);
-    db.exec(`DELETE FROM ${target} WHERE ${pk} IN (
-      SELECT ${pk} FROM ${target} WHERE ${clauses.join(' AND ')}${pinnedClause} LIMIT 1024
-    )`, params);
-    const remaining = db.query(`SELECT 1 FROM ${target} WHERE ${clauses.join(' AND ')}${pinnedClause} LIMIT 1`, params).length > 0;
+    for (const row of db.query(`SELECT id,intent,base FROM ${RETAINED_ROWS} WHERE commit_seq IS NOT NULL AND tbl=?`, [table.name])) {
+        if (!pinnedRowIds.has(row.id) &&
+            [row.intent, row.base].some((json) => json !== null &&
+                matchesLocalScopes(table, effective, JSON.parse(json))))
+            db.exec(`DELETE FROM ${RETAINED_ROWS} WHERE tbl=? AND id=? AND commit_seq IS NOT NULL`, [table.name, row.id]);
+    }
+    db.exec(`DELETE FROM ${target} WHERE ${pk} IN(SELECT ${pk} FROM ${target} WHERE ${sql}${pinnedClause} LIMIT 1024)`, params);
+    const remaining = db.query(`SELECT 1 FROM ${target} WHERE ${sql}${pinnedClause} LIMIT 1`, params).length > 0;
     const deferred = remaining ||
-        db.query(`SELECT 1 FROM ${target} WHERE ${clauses.join(' AND ')} LIMIT 1`, params.slice(0, params.length - pinnedRowIds.size)).length > 0;
+        db.query(`SELECT 1 FROM ${target} WHERE ${sql} LIMIT 1`, params.slice(0, params.length - pinnedRowIds.size)).length > 0;
     return { remaining, deferred };
 }
 const IMAGE_ALIAS = 'syncular_image';
@@ -201,7 +207,7 @@ function imageInvalid(detail) {
 export async function applySqliteSegment(db, schema, table, bytes, descriptor, options) {
     const withImage = db.withSqliteImage?.bind(db);
     if (withImage === undefined) {
-        throw invalidRequest('received a sqlite segment but the database backend cannot import images (§4.2: do not advertise accept bit 2)');
+        throw invalidRequest('database cannot import images; disable accept bit 2 (§4.2)');
     }
     if (descriptor.table !== table.name) {
         imageInvalid(`descriptor table ${JSON.stringify(descriptor.table)}`);
@@ -211,10 +217,7 @@ export async function applySqliteSegment(db, schema, table, bytes, descriptor, o
         //    SQLite database or lacks the metadata table fails right here.
         let meta;
         try {
-            meta = db.query(`SELECT format, "table" AS tbl, "schemaVersion" AS sv,
-                "asOfCommitSeq" AS pin, "scopeDigest" AS sd,
-                "rowCount" AS rc
-         FROM ${IMAGE_ALIAS}."_syncular_segment"`);
+            meta = db.query(`SELECT format,"table" AS tbl,"schemaVersion" AS sv,"asOfCommitSeq" AS pin,"scopeDigest" AS sd,"rowCount" AS rc FROM ${IMAGE_ALIAS}."_syncular_segment"`);
         }
         catch {
             imageInvalid('bytes are not a SQLite image with _syncular_segment');
@@ -256,7 +259,7 @@ export async function applySqliteSegment(db, schema, table, bytes, descriptor, o
         if (primaryKeys.length !== 1 || primaryKeys[0]?.name !== table.primaryKey)
             imageInvalid('image primary key does not match generated schema');
         const source = `${IMAGE_ALIAS}.${quoteIdent(table.name)}`;
-        const count = Number(db.query(`SELECT count(*) AS n FROM ${source}`)[0]?.n);
+        const count = Number(db.query(`SELECT count(*)AS n FROM ${source}`)[0]?.n);
         if (count !== descriptor.rowCount)
             imageInvalid('image row count does not match descriptor');
         const names = table.columns.map((column) => quoteIdent(column.name));
@@ -271,9 +274,7 @@ export async function applySqliteSegment(db, schema, table, bytes, descriptor, o
         for (;;) {
             if (options.isCurrent?.() === false)
                 return applied;
-            const boundary = db.query(`SELECT ${primaryKey} AS boundary FROM ${source}
-         ${after === undefined ? '' : `WHERE ${primaryKey} > ?`}
-         ORDER BY ${primaryKey} LIMIT 1 OFFSET 1023`, after === undefined ? [] : [after])[0]?.boundary;
+            const boundary = db.query(`SELECT ${primaryKey} AS boundary FROM ${source} ${after === undefined ? '' : `WHERE ${primaryKey} > ?`} ORDER BY ${primaryKey} LIMIT 1 OFFSET 1023`, after === undefined ? [] : [after])[0]?.boundary;
             if (boundary === null)
                 imageInvalid('image primary key must not be null');
             const predicates = [];
@@ -287,15 +288,13 @@ export async function applySqliteSegment(db, schema, table, bytes, descriptor, o
                 params.push(boundary);
             }
             (options.transaction ?? ((fn) => db.transaction(fn)))(() => {
+                restoreFailedBases(db, schema);
                 if (after === undefined && options.clearFirst)
                     deleteScopedRows(db, table, options.effective);
-                db.exec(`INSERT INTO ${quoteIdent(table.name)} (${insertNames.join(', ')})
-           SELECT ${[...names, quoteIdent('_syncular_version')].join(', ')}
-           FROM ${source} WHERE ${predicates.join(' AND ') || 'true'}
-           ON CONFLICT (${primaryKey}) DO UPDATE SET ${updates}`, params);
-                applied += Number(db.query('SELECT changes() AS n')[0]?.n ?? 0);
+                db.exec(`INSERT INTO ${quoteIdent(table.name)}(${insertNames.join(', ')})SELECT ${[...names, quoteIdent('_syncular_version')].join(', ')} FROM ${source} WHERE ${predicates.join(' AND ') || 'true'} ON CONFLICT(${primaryKey})DO UPDATE SET ${updates}`, params);
+                applied += Number(db.query('SELECT changes()AS n')[0]?.n ?? 0);
                 for (const row of db.query(`SELECT * FROM ${source} WHERE ${predicates.join(' AND ') || 'true'}`, params)) {
-                    retainedBaseWrite(db, table.name, String(row[table.primaryKey]), Object.fromEntries(table.columns.map((column) => [
+                    retainedBaseWrite(db, table, String(row[table.primaryKey]), Object.fromEntries(table.columns.map((column) => [
                         column.name,
                         rowValueToJson(row[column.name]),
                     ])), Number(row._syncular_version));
@@ -348,11 +347,12 @@ export async function applyRowsSegment(db, schema, table, segment, options, encr
         if (!clearThisBlock && rows.length === 0)
             continue;
         (options.transaction ?? ((fn) => db.transaction(fn)))(() => {
+            const protectedRows = restoreFailedBases(db, schema);
             if (clearThisBlock) {
                 deleteScopedRows(db, table, options.effective);
             }
             for (const row of rows) {
-                upsertLocalRow(db, table, row.values, row.serverVersion);
+                upsertLocalRow(db, table, row.values, row.serverVersion, protectedRows);
                 applied += 1;
                 if (applied % 1024 === 0)
                     options.onProgress?.(applied);

package/dist/blob.js

@@ -20,7 +20,7 @@ export async function computeBlobId(bytes) {
     return `sha256:${hex}`;
 }
 export function ensureBlobSchema(db) {
-    const existing = db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '_syncular_blobs'");
+    const existing = db.query("SELECT 1 FROM sqlite_master WHERE type='table' AND name='_syncular_blobs'");
     if (existing.length > 0) {
         const columns = db
             .query('PRAGMA table_info(_syncular_blobs)')
@@ -39,24 +39,16 @@ export function ensureBlobSchema(db) {
         }
     }
     else {
-        db.exec(`CREATE TABLE _syncular_blobs(
-      blob_id TEXT PRIMARY KEY,
-      bytes BLOB NOT NULL,
-      byte_length INTEGER NOT NULL,
-      media_type TEXT,
-      created_at_ms INTEGER NOT NULL)`);
+        db.exec('CREATE TABLE _syncular_blobs(blob_id TEXT PRIMARY KEY,bytes BLOB NOT NULL,byte_length INTEGER NOT NULL,media_type TEXT,created_at_ms INTEGER NOT NULL)');
     }
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_blob_uploads(
-    blob_id TEXT PRIMARY KEY, media_type TEXT, created_at_ms INTEGER NOT NULL)`);
+    db.exec('CREATE TABLE IF NOT EXISTS _syncular_blob_uploads(blob_id TEXT PRIMARY KEY,media_type TEXT,created_at_ms INTEGER NOT NULL)');
 }
 /** Put bytes into the content-addressed cache without rewriting an existing body. */
 export function putCachedBlob(db, blobId, bytes, nowMs, mediaType) {
-    db.exec(`INSERT INTO _syncular_blobs(
-       blob_id, bytes, byte_length, media_type, created_at_ms)
-     VALUES (?,?,?,?,?) ON CONFLICT(blob_id) DO NOTHING`, [blobId, bytes, bytes.length, mediaType ?? null, nowMs]);
+    db.exec('INSERT INTO _syncular_blobs(blob_id,bytes,byte_length,media_type,created_at_ms)VALUES(?,?,?,?,?)ON CONFLICT(blob_id)DO NOTHING', [blobId, bytes, bytes.length, mediaType ?? null, nowMs]);
 }
 export function getCachedBlob(db, blobId) {
-    const rows = db.query('SELECT bytes, byte_length, media_type FROM _syncular_blobs WHERE blob_id = ?', [blobId]);
+    const rows = db.query('SELECT bytes,byte_length,media_type FROM _syncular_blobs WHERE blob_id=?', [blobId]);
     const row = rows[0];
     if (row === undefined)
         return undefined;
@@ -73,23 +65,19 @@ export function getCachedBlob(db, blobId) {
  * until back under the cap. Returns the evicted blobIds.
  */
 export function enforceBlobCacheCap(db, schema, maxBytes) {
-    const totalRow = db.query('SELECT COALESCE(SUM(byte_length), 0) AS total FROM _syncular_blobs')[0];
+    const totalRow = db.query('SELECT COALESCE(SUM(byte_length),0)AS total FROM _syncular_blobs')[0];
     let total = Number(totalRow?.total ?? 0);
     if (total <= maxBytes)
         return [];
     // Oldest eligible body first, with blob ID as a stable tie.
-    const candidates = db.query(`SELECT blob_id, byte_length FROM _syncular_blobs
-     WHERE blob_id NOT IN (SELECT blob_id FROM _syncular_blob_uploads)
-       AND blob_id NOT IN (SELECT blob_id FROM _syncular_blob_commit_refs)
-       AND blob_id NOT IN (${visibleBlobIdsSql(schema)})
-     ORDER BY created_at_ms ASC, blob_id ASC`);
+    const candidates = db.query(`SELECT blob_id,byte_length FROM _syncular_blobs WHERE blob_id NOT IN(SELECT blob_id FROM _syncular_blob_uploads)AND blob_id NOT IN(SELECT blob_id FROM _syncular_blob_commit_refs)AND blob_id NOT IN(${visibleBlobIdsSql(schema)})ORDER BY created_at_ms ASC,blob_id ASC`);
     const evicted = [];
     db.transaction(() => {
         for (const row of candidates) {
             if (total <= maxBytes)
                 break;
             const blobId = row.blob_id;
-            db.exec('DELETE FROM _syncular_blobs WHERE blob_id = ?', [blobId]);
+            db.exec('DELETE FROM _syncular_blobs WHERE blob_id=?', [blobId]);
             total -= Number(row.byte_length);
             evicted.push(blobId);
         }
@@ -98,13 +86,7 @@ export function enforceBlobCacheCap(db, schema, maxBytes) {
 }
 export function listPendingUploads(db) {
     return db
-        .query(`SELECT blob_id, media_type FROM (
-        SELECT blob_id, media_type, created_at_ms FROM _syncular_blob_uploads
-        UNION ALL
-        SELECT DISTINCT r.blob_id, b.media_type, 9223372036854775807 AS created_at_ms
-        FROM _syncular_blob_commit_refs r LEFT JOIN _syncular_blobs b ON b.blob_id = r.blob_id
-        WHERE NOT EXISTS (SELECT 1 FROM _syncular_blob_uploads u WHERE u.blob_id = r.blob_id)
-      ) ORDER BY created_at_ms, blob_id`)
+        .query('SELECT blob_id,media_type FROM(SELECT blob_id,media_type,created_at_ms FROM _syncular_blob_uploads UNION ALL SELECT DISTINCT r.blob_id,b.media_type,9223372036854775807 AS created_at_ms FROM _syncular_blob_commit_refs r LEFT JOIN _syncular_blobs b ON b.blob_id=r.blob_id WHERE NOT EXISTS(SELECT 1 FROM _syncular_blob_uploads u WHERE u.blob_id=r.blob_id))ORDER BY created_at_ms,blob_id')
         .map((row) => {
         if (typeof row.blob_id !== 'string' ||
             (row.media_type !== null && typeof row.media_type !== 'string')) {
@@ -117,11 +99,10 @@ export function listPendingUploads(db) {
     });
 }
 export function recordPendingUpload(db, blobId, nowMs, mediaType) {
-    db.exec(`INSERT OR IGNORE INTO _syncular_blob_uploads(blob_id, media_type, created_at_ms)
-     VALUES (?,?,?)`, [blobId, mediaType ?? null, nowMs]);
+    db.exec('INSERT OR IGNORE INTO _syncular_blob_uploads(blob_id,media_type,created_at_ms)VALUES(?,?,?)', [blobId, mediaType ?? null, nowMs]);
 }
 export function clearPendingUpload(db, blobId) {
-    db.exec('DELETE FROM _syncular_blob_uploads WHERE blob_id = ?', [blobId]);
+    db.exec('DELETE FROM _syncular_blob_uploads WHERE blob_id=?', [blobId]);
 }
 /**
  * All `blob_ref` column names per table.
@@ -149,11 +130,7 @@ function visibleBlobIdsSql(schema) {
     for (const [tableName, columns] of blobRefColumnsBySchema(schema)) {
         for (const column of columns) {
             const identifier = quoteIdent(column);
-            selects.push(`SELECT json_extract(${identifier}, '$.blobId') AS blob_id
-         FROM ${quoteIdent(tableName)}
-         WHERE typeof(${identifier}) = 'text'
-           AND json_valid(${identifier})
-           AND json_type(${identifier}, '$.blobId') = 'text'`);
+            selects.push(`SELECT json_extract(${identifier},'$.blobId')AS blob_id FROM ${quoteIdent(tableName)} WHERE typeof(${identifier})='text' AND json_valid(${identifier})AND json_type(${identifier},'$.blobId')='text'`);
         }
     }
     return selects.length === 0
@@ -161,9 +138,6 @@ function visibleBlobIdsSql(schema) {
         : selects.join(' UNION ');
 }
 export function deleteUnreferencedCachedBlobs(db, schema) {
-    db.exec(`DELETE FROM _syncular_blobs
-     WHERE blob_id NOT IN (SELECT blob_id FROM _syncular_blob_uploads)
-       AND blob_id NOT IN (SELECT blob_id FROM _syncular_blob_commit_refs)
-       AND blob_id NOT IN (${visibleBlobIdsSql(schema)})`);
+    db.exec(`DELETE FROM _syncular_blobs WHERE blob_id NOT IN(SELECT blob_id FROM _syncular_blob_uploads)AND blob_id NOT IN(SELECT blob_id FROM _syncular_blob_commit_refs)AND blob_id NOT IN(${visibleBlobIdsSql(schema)})`);
 }
 export { parseBlobRef, serializeBlobRef };