@syncular/client 0.30.10 → 0.30.12

package/dist/wasm-database.js

@@ -22,6 +22,7 @@
  * `ClientDatabase`. Browser-only — exercised by the demo, never imported
  * by bun tests (subpath export `@syncular/client/wasm`).
  */
+import { webLocksLeaderLock } from './leader-lock.js';
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 import { assertImageAlias, runTransaction, } from './database.js';
 import { ClientSyncError, invalidRequest, STORAGE_BUSY_CODE, STORAGE_UNAVAILABLE_CODE, } from './errors.js';
@@ -37,6 +38,7 @@ class WasmClientDatabase {
     #sqlite3;
     /** RFC 0005: present only for a persistent OPFS database. */
     #sah;
+    #closed = false;
     #tx = { depth: 0 };
     constructor(db, sqlite3, sah) {
         this.#db = db;
@@ -128,7 +130,14 @@ class WasmClientDatabase {
         }
     }
     close() {
+        if (this.#closed)
+            return;
         this.#db.close();
+        // DB.close() leaves the SAH pool live. Close siblings first, then pause the
+        // VFS without deleting files, before releasing this worker's physical lock.
+        this.#sah?.util.pauseVfs();
+        this.#closed = true;
+        void this.#sah?.lease.release();
     }
 }
 let sqlite3Init;
@@ -249,35 +258,42 @@ export async function openPersistentWasmDatabase(name, options) {
             'requires OPFS (~2023+ browsers). There is no IndexedDB or ' +
             'in-memory fallback for persistent mode.');
     }
-    const sqlite3 = await initSqlite3();
-    const directory = options?.directory ?? `.syncular/${name}`;
-    let pool = sahPools.get(directory);
-    if (pool === undefined) {
-        pool = sqlite3
-            .installOpfsSAHPoolVfs({
-            // VFS registration names must be unique per directory.
-            name: `syncular-sahpool-${directory.replace(/[^A-Za-z0-9]+/g, '-')}`,
-            directory,
-            // sqlite-wasm caches a rejected initialization promise by VFS name.
-            // Syncular removes its own rejected entry below, so allow a later
-            // open in the same worker to make a real attempt as well.
-            forceReinitIfPreviouslyFailed: true,
-            initialCapacity: Math.max(options?.initialCapacity ?? SAH_POOL_DEFAULT_CAPACITY, SAH_POOL_MIN_CAPACITY),
-        })
-            .catch((error) => {
-            sahPools.delete(directory);
-            throw opfsSahPoolError(error, directory);
-        });
-        sahPools.set(directory, pool);
+    if (!navigator.locks) {
+        throw new ClientSyncError(STORAGE_UNAVAILABLE_CODE, 'Persistent OPFS storage requires Web Locks');
     }
-    const util = await pool;
-    const db = new util.OpfsSAHPoolDb(`/${name}.db`);
+    const directory = (options?.directory ?? `.syncular/${name}`).replace(/^\/+|\/+$/g, '');
+    // The document's leader lease can end before its worker's SAHs close. This
+    // worker-owned lock has exactly the same lifetime as the physical pool.
+    const lease = await webLocksLeaderLock().acquire(`syncular-opfs/${directory}`);
+    let util;
+    let db;
     try {
+        const sqlite3 = await initSqlite3();
+        let pool = sahPools.get(directory);
+        if (pool === undefined) {
+            pool = sqlite3
+                .installOpfsSAHPoolVfs({
+                name: `syncular-sahpool-${directory.replace(/[^A-Za-z0-9]+/g, '-')}`,
+                directory,
+                forceReinitIfPreviouslyFailed: true,
+                initialCapacity: Math.max(options?.initialCapacity ?? SAH_POOL_DEFAULT_CAPACITY, SAH_POOL_MIN_CAPACITY),
+            })
+                .catch((error) => {
+                sahPools.delete(directory);
+                throw opfsSahPoolError(error, directory);
+            });
+            sahPools.set(directory, pool);
+        }
+        util = await pool;
+        await util.unpauseVfs();
+        db = new util.OpfsSAHPoolDb(`/${name}.db`);
         configureSahCrashRecovery(db, sqlite3);
-        return new WasmClientDatabase(db, sqlite3, { util });
+        return new WasmClientDatabase(db, sqlite3, { util, lease });
     }
     catch (error) {
-        db.close();
+        db?.close();
+        util?.pauseVfs();
+        await lease.release();
         throw error;
     }
 }

package/dist/worker-host.js

@@ -437,7 +437,29 @@ async function startWorkerCore(options) {
     const worker = config.worker();
     const pending = new Map();
     const nextId = { value: 1 };
+    let terminated = false;
+    let rejectReady;
+    const closedError = new ClientSyncError(WORKER_FAILED_CODE, 'the handle was closed');
+    const terminate = () => {
+        if (terminated)
+            return;
+        terminated = true;
+        globalThis.removeEventListener?.('pagehide', terminate);
+        bridge?.close();
+        worker.terminate();
+        rejectReady?.(closedError);
+        for (const entry of pending.values())
+            entry.reject(closedError);
+        pending.clear();
+        void lease.release();
+    };
+    // Installed before bootstrap starts: pagehide must also terminate a worker
+    // whose first open/import is still pending. Termination closes its SAHs and
+    // releases its physical Web Lock; the next document waits for that lock.
+    globalThis.addEventListener?.('pagehide', terminate);
     const invoke = (method, args) => {
+        if (terminated)
+            return Promise.reject(closedError);
         const id = nextId.value++;
         return new Promise((resolve, reject) => {
             pending.set(id, { resolve, reject });
@@ -451,6 +473,7 @@ async function startWorkerCore(options) {
     };
     let bridge;
     const ready = new Promise((resolve, reject) => {
+        rejectReady = reject;
         const onMessage = (event) => {
             const message = event.data;
             switch (message.t) {
@@ -507,27 +530,30 @@ async function startWorkerCore(options) {
             invoke,
             bridge,
             lease,
-            close: async (terminate) => {
+            close: async (terminateWorker) => {
+                if (terminated)
+                    return;
                 bridge?.close();
                 try {
                     await invoke('close', []);
                 }
                 catch {
-                    // Closing a wedged worker still terminates it below.
+                    // A terminated or failed worker has no further close RPC to service.
+                }
+                if (terminateWorker)
+                    terminate();
+                else {
+                    globalThis.removeEventListener?.('pagehide', terminate);
+                    for (const entry of pending.values())
+                        entry.reject(closedError);
+                    pending.clear();
+                    await lease.release();
                 }
-                if (terminate)
-                    worker.terminate();
-                const closedError = new ClientSyncError(WORKER_FAILED_CODE, 'the handle was closed');
-                for (const entry of pending.values())
-                    entry.reject(closedError);
-                pending.clear();
-                await lease.release();
             },
         };
     }
     catch (error) {
-        worker.terminate();
-        await lease.release();
+        terminate();
         throw error;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.10",
+  "version": "0.30.12",
   "description": "Syncular TypeScript client core — offline-first sync over SQLite (WASM/OPFS, Bun, Node)",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -89,10 +89,10 @@
   },
   "dependencies": {
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@syncular/core": "0.30.10"
+    "@syncular/core": "0.30.12"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.10",
+    "@syncular/server": "0.30.12",
     "playwright": "1.63.0",
     "@electric-sql/pglite": "^0.5.4"
   }

package/src/apply.ts

@@ -1,4 +1,5 @@
-import { retainedBaseWrite } from './failed-overlay';
+import { RETAINED_ROWS } from './failed-overlay';
+import { retainedBaseWrite, restoreFailedBases } from './failed-overlay';
 /**
  * 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
@@ -19,6 +20,8 @@ import {
   type CompiledClientSchema,
   type CompiledClientTable,
   quoteIdent,
+  matchesLocalScopes,
+  type JsonRowValue,
   SYNC_VERSION_COLUMN,
   toSqlValue,
   rowValueToJson,
@@ -37,8 +40,7 @@ function upsertSql(table: CompiledClientTable): string {
     .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(
@@ -48,10 +50,11 @@ export function upsertLocalRow(
   syncVersion: number,
   serverWrite = true,
 ): void {
+  db.exec(upsertSql(table), [...values.map(toSqlValue), syncVersion]);
   if (serverWrite)
     retainedBaseWrite(
       db,
-      table.name,
+      table,
       String(values[table.primaryKeyIndex]),
       Object.fromEntries(
         table.columns.map((column, index) => [
@@ -61,7 +64,6 @@ export function upsertLocalRow(
       ),
       syncVersion,
     );
-  db.exec(upsertSql(table), [...values.map(toSqlValue), syncVersion]);
 }
 
 export function deleteLocalRow(
@@ -70,9 +72,9 @@ export function deleteLocalRow(
   rowId: string,
   serverWrite = true,
 ): void {
-  if (serverWrite) retainedBaseWrite(db, table.name, rowId);
+  if (serverWrite) retainedBaseWrite(db, table, rowId);
   db.exec(
-    `DELETE FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`,
+    `DELETE FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)}=?`,
     [rowId],
   );
 }
@@ -94,7 +96,8 @@ export async function applyCommitFrame(
   schema: CompiledClientSchema,
   frame: CommitFrame,
   encryption?: EncryptionConfig,
-  transaction: ApplyTransaction = (fn) => db.transaction(fn),
+  transaction: (fn: () => readonly string[] | undefined) => unknown = (fn) =>
+    db.transaction(fn),
 ): Promise<void> {
   type Resolved =
     | { op: 'delete'; table: CompiledClientTable; rowId: string }
@@ -139,13 +142,31 @@ export async function applyCommitFrame(
     });
   }
   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);
       } else {
         upsertLocalRow(db, change.table, change.values, change.rowVersion);
       }
     }
+    return rowKeys;
   });
 }
 
@@ -195,39 +216,43 @@ export function validateSegmentColumns(
  * (`sync.scope_revoked`) when the table has no local mapping for a key:
  * precision or nothing, never clear-the-table.
  */
+export function localScopePredicate(
+  table: CompiledClientTable,
+  effective: ScopeMap,
+): { sql: string; params: string[] } | undefined {
+  const entries = Object.entries(effective);
+  if (!entries.length || entries.some(([, values]) => !values.length)) return;
+  const params: string[] = [];
+  const sql = entries
+    .map(([variable, values]) => {
+      const column = table.scopeColumnByVariable.get(variable);
+      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: ClientDatabase,
   table: CompiledClientTable,
   effective: ScopeMap,
 ): void {
-  const entries = Object.entries(effective);
-  if (entries.length === 0) return;
-  const clauses: string[] = [];
-  const params: string[] = [];
-  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)} (§3.3 fail-closed)`,
-      );
-    }
-    if (values.length === 0) return;
-    clauses.push(
-      `${quoteIdent(column)} IN (${values.map(() => '?').join(', ')})`,
-    );
-    params.push(...values);
-  }
+  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 ${clauses.join(' AND ')}`,
+    `SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${sql}`,
     params,
   )) {
-    retainedBaseWrite(db, table.name, String(row.id));
+    retainedBaseWrite(db, table, 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);
 }
 
 /**
@@ -246,24 +271,9 @@ export function evictScopedRows(
   effective: ScopeMap,
   pinnedRowIds: ReadonlySet<string>,
 ): { remaining: boolean; deferred: boolean } {
-  const entries = Object.entries(effective);
-  if (entries.length === 0) return { remaining: false, deferred: false };
-  const clauses: string[] = [];
-  const params: string[] = [];
-  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 scope = localScopePredicate(table, effective);
+  if (!scope) return { remaining: false, deferred: false };
+  const { sql, params } = scope;
   const pk = quoteIdent(table.primaryKey);
   let pinnedClause = '';
   if (pinnedRowIds.size > 0) {
@@ -272,21 +282,40 @@ export function evictScopedRows(
     params.push(...ids);
   }
   const target = quoteIdent(table.name);
+  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 as string) &&
+      [row.intent, row.base].some(
+        (json) =>
+          json !== null &&
+          matchesLocalScopes(
+            table,
+            effective,
+            JSON.parse(json as string) as Record<string, JsonRowValue>,
+          ),
+      )
+    )
+      db.exec(
+        `DELETE FROM ${RETAINED_ROWS} WHERE tbl=? AND id=? AND commit_seq IS NOT NULL`,
+        [table.name, row.id as string],
+      );
+  }
   db.exec(
-    `DELETE FROM ${target} WHERE ${pk} IN (
-      SELECT ${pk} FROM ${target} WHERE ${clauses.join(' AND ')}${pinnedClause} LIMIT 1024
-    )`,
+    `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 ${clauses.join(' AND ')}${pinnedClause} LIMIT 1`,
+      `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`,
+      `SELECT 1 FROM ${target} WHERE ${sql} LIMIT 1`,
       params.slice(0, params.length - pinnedRowIds.size),
     ).length > 0;
   return { remaining, deferred };
@@ -331,7 +360,7 @@ export async function applySqliteSegment(
   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)',
+      'database cannot import images; disable accept bit 2 (§4.2)',
     );
   }
   if (descriptor.table !== table.name) {
@@ -343,10 +372,7 @@ export async function applySqliteSegment(
     let meta: ReturnType<ClientDatabase['query']>;
     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"`,
+        `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');
@@ -396,7 +422,7 @@ export async function applySqliteSegment(
     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));
@@ -411,9 +437,7 @@ export async function applySqliteSegment(
     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`,
+        `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');
@@ -428,23 +452,21 @@ export async function applySqliteSegment(
         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}`,
+          `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);
+        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,
+            table,
             String(row[table.primaryKey]),
             Object.fromEntries(
               table.columns.map((column) => [
@@ -515,11 +537,12 @@ export async function applyRowsSegment(
     first = false;
     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/src/blob.ts

@@ -105,7 +105,7 @@ export async function computeBlobId(bytes: Uint8Array): Promise<string> {
 
 export function ensureBlobSchema(db: ClientDatabase): void {
   const existing = db.query(
-    "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '_syncular_blobs'",
+    "SELECT 1 FROM sqlite_master WHERE type='table' AND name='_syncular_blobs'",
   );
   if (existing.length > 0) {
     const columns = db
@@ -129,15 +129,13 @@ export function ensureBlobSchema(db: ClientDatabase): void {
       );
     }
   } 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. */
@@ -149,9 +147,7 @@ export function putCachedBlob(
   mediaType?: string,
 ): void {
   db.exec(
-    `INSERT INTO _syncular_blobs(
-       blob_id, bytes, byte_length, media_type, created_at_ms)
-     VALUES (?,?,?,?,?) ON CONFLICT(blob_id) DO NOTHING`,
+    '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],
   );
 }
@@ -161,7 +157,7 @@ export function getCachedBlob(
   blobId: string,
 ): CachedBlob | undefined {
   const rows = db.query(
-    'SELECT bytes, byte_length, media_type FROM _syncular_blobs WHERE blob_id = ?',
+    'SELECT bytes,byte_length,media_type FROM _syncular_blobs WHERE blob_id=?',
     [blobId],
   );
   const row = rows[0];
@@ -185,24 +181,20 @@ export function enforceBlobCacheCap(
   maxBytes: number,
 ): string[] {
   const totalRow = db.query(
-    'SELECT COALESCE(SUM(byte_length), 0) AS total FROM _syncular_blobs',
+    '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`,
+    `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: string[] = [];
   db.transaction(() => {
     for (const row of candidates) {
       if (total <= maxBytes) break;
       const blobId = row.blob_id as string;
-      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);
     }
@@ -215,13 +207,7 @@ export function listPendingUploads(
 ): { blobId: string; mediaType?: string }[] {
   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`,
+      '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 (
@@ -247,14 +233,13 @@ export function recordPendingUpload(
   mediaType?: string,
 ): void {
   db.exec(
-    `INSERT OR IGNORE INTO _syncular_blob_uploads(blob_id, media_type, created_at_ms)
-     VALUES (?,?,?)`,
+    'INSERT OR IGNORE INTO _syncular_blob_uploads(blob_id,media_type,created_at_ms)VALUES(?,?,?)',
     [blobId, mediaType ?? null, nowMs],
   );
 }
 
 export function clearPendingUpload(db: ClientDatabase, blobId: string): void {
-  db.exec('DELETE FROM _syncular_blob_uploads WHERE blob_id = ?', [blobId]);
+  db.exec('DELETE FROM _syncular_blob_uploads WHERE blob_id=?', [blobId]);
 }
 
 /**
@@ -286,11 +271,7 @@ function visibleBlobIdsSql(schema: CompiledClientSchema): string {
     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'`,
+        `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'`,
       );
     }
   }
@@ -304,10 +285,7 @@ export function deleteUnreferencedCachedBlobs(
   schema: CompiledClientSchema,
 ): void {
   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)})`,
+    `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)})`,
   );
 }