@syncular/client 0.30.10 → 0.30.12

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,
   ]);
 }

package/src/schema.ts

@@ -92,17 +92,22 @@ const ALLOWED_FTS_TOKENIZERS = new Set([
   'trigram',
 ]);
 
+function invalidSchema(message: string): never {
+  throw new Error(message);
+}
+
 export function compileClientSchema(
   schema: ClientSchema,
 ): CompiledClientSchema {
   const tables = new Map<string, CompiledClientTable>();
   const schemaObjectNames = new Set<string>();
   for (const table of schema.tables) {
+    const tableLabel = `table ${table.name}`;
     if (tables.has(table.name)) {
-      throw new Error(`duplicate table ${JSON.stringify(table.name)}`);
+      invalidSchema(`duplicate table ${JSON.stringify(table.name)}`);
     }
     if (schemaObjectNames.has(table.name)) {
-      throw new Error(
+      invalidSchema(
         `table ${JSON.stringify(table.name)} conflicts with an index or FTS projection`,
       );
     }
@@ -110,36 +115,32 @@ export function compileClientSchema(
     const columnIndex = new Map<string, number>();
     table.columns.forEach((column, index) => {
       if (columnIndex.has(column.name)) {
-        throw new Error(
-          `table ${table.name}: duplicate column ${JSON.stringify(column.name)}`,
+        invalidSchema(
+          `${tableLabel}: duplicate column ${JSON.stringify(column.name)}`,
         );
       }
       columnIndex.set(column.name, index);
     });
     const primaryKeyIndex = columnIndex.get(table.primaryKey);
     if (primaryKeyIndex === undefined) {
-      throw new Error(
-        `table ${table.name}: primary key ${JSON.stringify(table.primaryKey)} is not a column`,
+      invalidSchema(
+        `${tableLabel}: primary key ${JSON.stringify(table.primaryKey)} is not a column`,
       );
     }
     // §2.4 primary-key eligibility: a primary key MUST render to a `rowId`
     // string every implementation produces identically and local storage
     // resolves without deferring to a SQLite build.
-    const primaryKeyColumn = table.columns[primaryKeyIndex];
+    const primaryKeyColumn = table.columns[primaryKeyIndex] as RowColumn;
     if (
-      primaryKeyColumn !== undefined &&
-      primaryKeyColumn.type !== 'string' &&
-      primaryKeyColumn.type !== 'integer' &&
-      primaryKeyColumn.type !== 'boolean' &&
-      primaryKeyColumn.type !== 'json'
+      !['string', 'integer', 'boolean', 'json'].includes(primaryKeyColumn.type)
     ) {
-      throw new Error(
-        `table ${table.name}: primary key ${JSON.stringify(table.primaryKey)} has an ineligible column type (§2.4); a primary key must be string, integer, boolean, or json`,
+      invalidSchema(
+        `${tableLabel}: primary key ${JSON.stringify(table.primaryKey)} has an ineligible type (§2.4)`,
       );
     }
     if (table.scopes.length === 0) {
-      throw new Error(
-        `table ${table.name}: every synced table declares at least one scope pattern (§3.1)`,
+      invalidSchema(
+        `${tableLabel}: every synced table declares at least one scope pattern (§3.1)`,
       );
     }
     const scopeColumnByVariable = new Map<string, string>();
@@ -148,22 +149,22 @@ export function compileClientSchema(
       const pattern = typeof spec === 'string' ? spec : spec.pattern;
       const match = PATTERN_RE.exec(pattern);
       if (match === null || match[1] === undefined || match[2] === undefined) {
-        throw new Error(
-          `table ${table.name}: scope pattern ${JSON.stringify(pattern)} must be 'prefix:{variable}'`,
+        invalidSchema(
+          `${tableLabel}: scope pattern ${JSON.stringify(pattern)} must be 'prefix:{variable}'`,
         );
       }
       const prefix = match[1];
       const variable = match[2];
       const column = typeof spec === 'string' ? variable : spec.column;
       if (!columnIndex.has(column)) {
-        throw new Error(
-          `table ${table.name}: scope pattern ${JSON.stringify(pattern)} names unknown column ${JSON.stringify(column)}`,
+        invalidSchema(
+          `${tableLabel}: scope pattern ${JSON.stringify(pattern)} names unknown column ${JSON.stringify(column)}`,
         );
       }
       const existing = scopeColumnByVariable.get(variable);
       if (existing !== undefined && existing !== column) {
-        throw new Error(
-          `table ${table.name}: variable ${JSON.stringify(variable)} maps to two different columns (§3.1)`,
+        invalidSchema(
+          `${tableLabel}: variable ${JSON.stringify(variable)} maps to two different columns (§3.1)`,
         );
       }
       scopeColumnByVariable.set(variable, column);
@@ -183,61 +184,34 @@ export function compileClientSchema(
     });
     for (const alias of ambiguous) columnIndexByCamel.delete(alias);
     const indexes = table.indexes ?? [];
-    for (const index of indexes) {
-      if (schemaObjectNames.has(index.name)) {
-        throw new Error(
-          `table ${table.name}: index ${JSON.stringify(index.name)} conflicts with another schema object`,
-        );
-      }
-      schemaObjectNames.add(index.name);
-      for (const column of index.columns) {
-        if (!columnIndex.has(column)) {
-          throw new Error(
-            `table ${table.name}: index ${JSON.stringify(index.name)} names unknown column ${JSON.stringify(column)}`,
-          );
-        }
-      }
-    }
     const ftsIndexes = table.ftsIndexes ?? [];
-    for (const index of ftsIndexes) {
-      if (schemaObjectNames.has(index.name)) {
-        throw new Error(
-          `table ${table.name}: FTS projection ${JSON.stringify(index.name)} conflicts with another schema object`,
-        );
-      }
+    for (const index of [...indexes, ...ftsIndexes]) {
+      const fts = 'tokenize' in index;
+      const label = `${tableLabel}: ${fts ? 'FTS projection' : 'index'} ${JSON.stringify(index.name)}`;
+      if (schemaObjectNames.has(index.name))
+        invalidSchema(`${label} conflicts with another schema object`);
       schemaObjectNames.add(index.name);
-      if (index.columns.length === 0 || index.columns.length > 32) {
-        throw new Error(
-          `table ${table.name}: FTS projection ${JSON.stringify(index.name)} needs between 1 and 32 columns`,
-        );
-      }
-      const seenColumns = new Set<string>();
-      for (const columnName of index.columns) {
-        if (seenColumns.has(columnName)) {
-          throw new Error(
-            `table ${table.name}: FTS projection ${JSON.stringify(index.name)} repeats column ${JSON.stringify(columnName)}`,
-          );
-        }
-        seenColumns.add(columnName);
-        const column = table.columns.find(
-          (candidate) => candidate.name === columnName,
-        );
-        if (column === undefined) {
-          throw new Error(
-            `table ${table.name}: FTS projection ${JSON.stringify(index.name)} names unknown column ${JSON.stringify(columnName)}`,
+      if (fts && (!index.columns.length || index.columns.length > 32))
+        invalidSchema(`${label} needs between 1 and 32 columns`);
+      const seen = new Set<string>();
+      for (const name of index.columns) {
+        if (fts && seen.has(name))
+          invalidSchema(`${label} repeats column ${JSON.stringify(name)}`);
+        seen.add(name);
+        const column = table.columns[columnIndex.get(name) ?? -1];
+        if (!column)
+          invalidSchema(
+            `${label} names unknown column ${JSON.stringify(name)}`,
           );
-        }
-        if (localColumnType(column) !== 'string') {
-          throw new Error(
-            `table ${table.name}: FTS projection ${JSON.stringify(index.name)} column ${JSON.stringify(columnName)} must have string type`,
+        if (fts && localColumnType(column) !== 'string')
+          invalidSchema(
+            `${label} column ${JSON.stringify(name)} must have string type`,
           );
-        }
       }
-      if (!ALLOWED_FTS_TOKENIZERS.has(index.tokenize)) {
-        throw new Error(
-          `table ${table.name}: FTS projection ${JSON.stringify(index.name)} tokenizer ${JSON.stringify(index.tokenize)} is not allowlisted`,
+      if (fts && !ALLOWED_FTS_TOKENIZERS.has(index.tokenize))
+        invalidSchema(
+          `${label} tokenizer ${JSON.stringify(index.tokenize)} is not allowlisted`,
         );
-      }
     }
     tables.set(table.name, {
       name: table.name,
@@ -291,6 +265,21 @@ export function stripSyncColumns(rows: SqlRow[]): SqlRow[] {
   });
 }
 
+export function matchesLocalScopes(
+  table: CompiledClientTable,
+  scopes: Readonly<Record<string, readonly string[]>>,
+  values: Readonly<Record<string, JsonRowValue>>,
+): boolean {
+  const entries = Object.entries(scopes);
+  return (
+    entries.length > 0 &&
+    entries.every(([variable, allowed]) => {
+      const column = table.scopeColumnByVariable.get(variable);
+      return column !== undefined && allowed.includes(String(values[column]));
+    })
+  );
+}
+
 export function quoteIdent(name: string): string {
   return `"${name.replaceAll('"', '""')}"`;
 }
@@ -344,7 +333,7 @@ function createSyncedTable(
   });
   columns.push(`${quoteIdent(SYNC_VERSION_COLUMN)} INTEGER NOT NULL DEFAULT 0`);
   db.exec(
-    `CREATE TABLE IF NOT EXISTS ${quoteIdent(table.name)} (${columns.join(', ')})`,
+    `CREATE TABLE IF NOT EXISTS ${quoteIdent(table.name)}(${columns.join(', ')})`,
   );
   // Local secondary indexes (CREATE INDEX subset). Created here so both the
   // initial ensureLocalSchema and the §7.4.3 drop-and-recreate reset path
@@ -354,7 +343,7 @@ function createSyncedTable(
     const unique = index.unique ? 'UNIQUE ' : '';
     const cols = index.columns.map((c) => quoteIdent(c)).join(', ');
     db.exec(
-      `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdent(index.name)} ON ${quoteIdent(table.name)} (${cols})`,
+      `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdent(index.name)} ON ${quoteIdent(table.name)}(${cols})`,
     );
   }
 }
@@ -382,6 +371,9 @@ function createFtsProjection(
   table: CompiledClientTable,
   index: ClientFtsIndexSpec,
 ): void {
+  const projection = quoteIdent(index.name);
+  const sourceTable = quoteIdent(table.name);
+  const primaryKey = quoteIdent(table.primaryKey);
   const existed =
     db.query(
       "SELECT 1 AS present FROM sqlite_master WHERE type='table' AND name=?",
@@ -390,7 +382,7 @@ function createFtsProjection(
   const indexedColumns = index.columns.map(quoteIdent);
   const tokenizer = index.tokenize.replaceAll("'", "''");
   db.exec(
-    `CREATE VIRTUAL TABLE IF NOT EXISTS ${quoteIdent(index.name)} USING fts5(${quoteIdent(FTS_SOURCE_ID_COLUMN)} UNINDEXED, ${indexedColumns.join(', ')}, tokenize='${tokenizer}')`,
+    `CREATE VIRTUAL TABLE IF NOT EXISTS ${projection} USING fts5(${quoteIdent(FTS_SOURCE_ID_COLUMN)} UNINDEXED,${indexedColumns.join(', ')},tokenize='${tokenizer}')`,
   );
 
   const mapping = quoteIdent(`_syncular_fts_${index.name}`);
@@ -399,11 +391,11 @@ function createFtsProjection(
       `_syncular_fts_${index.name}`,
     ]).length > 0;
   db.exec(
-    `CREATE TABLE IF NOT EXISTS ${mapping} (id INTEGER PRIMARY KEY, source_id TEXT NOT NULL UNIQUE)`,
+    `CREATE TABLE IF NOT EXISTS ${mapping}(id INTEGER PRIMARY KEY,source_id TEXT NOT NULL UNIQUE)`,
   );
-  const sourceId = `CAST(${quoteIdent(table.primaryKey)} AS TEXT)`;
-  const newSourceId = `CAST(new.${quoteIdent(table.primaryKey)} AS TEXT)`;
-  const oldSourceId = `CAST(old.${quoteIdent(table.primaryKey)} AS TEXT)`;
+  const sourceId = `CAST(${primaryKey} AS TEXT)`;
+  const newSourceId = `CAST(new.${primaryKey} AS TEXT)`;
+  const oldSourceId = `CAST(old.${primaryKey} AS TEXT)`;
   const projectionColumns = [
     quoteIdent(FTS_SOURCE_ID_COLUMN),
     ...indexedColumns,
@@ -413,10 +405,10 @@ function createFtsProjection(
     ...index.columns.map((column) => `new.${quoteIdent(column)}`),
   ].join(', ');
   const deleteFor = (value: string) =>
-    `DELETE FROM ${quoteIdent(index.name)} WHERE rowid = (SELECT id FROM ${mapping} WHERE source_id = ${value}); DELETE FROM ${mapping} WHERE source_id = ${value}`;
+    `DELETE FROM ${projection} WHERE rowid=(SELECT id FROM ${mapping} WHERE source_id=${value});DELETE FROM ${mapping} WHERE source_id=${value}`;
   const deleteDisplaced = (select: string) =>
-    `DELETE FROM ${quoteIdent(index.name)} WHERE rowid IN (SELECT id FROM ${mapping} WHERE source_id IN (${select})); DELETE FROM ${mapping} WHERE source_id IN (${select})`;
-  const insertNew = `INSERT INTO ${mapping}(source_id) VALUES (${newSourceId}); INSERT INTO ${quoteIdent(index.name)} (rowid, ${projectionColumns}) VALUES ((SELECT id FROM ${mapping} WHERE source_id = ${newSourceId}), ${newValues})`;
+    `DELETE FROM ${projection} WHERE rowid IN (SELECT id FROM ${mapping} WHERE source_id IN (${select}));DELETE FROM ${mapping} WHERE source_id IN (${select})`;
+  const insertNew = `INSERT INTO ${mapping}(source_id)VALUES(${newSourceId});INSERT INTO ${projection}(rowid,${projectionColumns})VALUES((SELECT id FROM ${mapping} WHERE source_id=${newSourceId}),${newValues})`;
 
   // A clean insert cannot already have a projection row because the source
   // primary key is unique. Keep clean inserts linear by moving replacement
@@ -445,7 +437,7 @@ function createFtsProjection(
   for (const suffix of ['bi', 'ai', 'ad', 'au', 'bu']) {
     db.exec(`DROP TRIGGER IF EXISTS ${quoteIdent(`${index.name}_${suffix}`)}`);
   }
-  const replacementExists = `EXISTS (SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = new.${quoteIdent(table.primaryKey)})`;
+  const replacementExists = `EXISTS (SELECT 1 FROM ${sourceTable} WHERE ${primaryKey} = new.${primaryKey})`;
   // Per secondary UNIQUE index: the different-PK rows about to be displaced
   // via that unique key. `=` makes NULL unique values match nothing, which is
   // exactly SQLite's unique-index semantics (NULLs never conflict).
@@ -454,7 +446,7 @@ function createFtsProjection(
     const match = spec.columns
       .map((column) => `${quoteIdent(column)} = new.${quoteIdent(column)}`)
       .join(' AND ');
-    return `SELECT ${sourceId} FROM ${quoteIdent(table.name)} WHERE ${match} AND ${quoteIdent(table.primaryKey)} != new.${quoteIdent(table.primaryKey)}`;
+    return `SELECT ${sourceId} FROM ${sourceTable} WHERE ${match} AND ${primaryKey} !=new.${primaryKey}`;
   });
   const insertGuardCondition = [
     replacementExists,
@@ -465,17 +457,22 @@ function createFtsProjection(
     ...displacedByUnique.map(deleteDisplaced),
   ].join('; ');
 
-  db.exec(
-    `CREATE TRIGGER ${quoteIdent(`${index.name}_bi`)} BEFORE INSERT ON ${quoteIdent(table.name)} WHEN ${insertGuardCondition} BEGIN ${insertGuardBody}; END`,
-  );
-  db.exec(
-    `CREATE TRIGGER ${quoteIdent(`${index.name}_ai`)} AFTER INSERT ON ${quoteIdent(table.name)} BEGIN ${insertNew}; END`,
-  );
-  db.exec(
-    `CREATE TRIGGER ${quoteIdent(`${index.name}_ad`)} AFTER DELETE ON ${quoteIdent(table.name)} BEGIN ${deleteFor(oldSourceId)}; END`,
-  );
-  db.exec(
-    `CREATE TRIGGER ${quoteIdent(`${index.name}_au`)} AFTER UPDATE ON ${quoteIdent(table.name)} BEGIN ${deleteFor(oldSourceId)}; ${deleteFor(newSourceId)}; ${insertNew}; END`,
+  const createTrigger = (
+    suffix: string,
+    timing: string,
+    body: string,
+    when = '',
+  ) =>
+    db.exec(
+      `CREATE TRIGGER ${quoteIdent(`${index.name}_${suffix}`)} ${timing} ON ${sourceTable}${when ? ` WHEN ${when}` : ''} BEGIN ${body};END`,
+    );
+  createTrigger('bi', 'BEFORE INSERT', insertGuardBody, insertGuardCondition);
+  createTrigger('ai', 'AFTER INSERT', insertNew);
+  createTrigger('ad', 'AFTER DELETE', deleteFor(oldSourceId));
+  createTrigger(
+    'au',
+    'AFTER UPDATE',
+    `${deleteFor(oldSourceId)}; ${deleteFor(newSourceId)}; ${insertNew}`,
   );
   // BEFORE UPDATE guard for `UPDATE OR REPLACE`: clear the projection of any
   // different-PK row about to be displaced through a secondary unique index by
@@ -486,20 +483,18 @@ function createFtsProjection(
       .map((select) => `EXISTS (${select})`)
       .join(' OR ');
     const updateGuardBody = displacedByUnique.map(deleteDisplaced).join('; ');
-    db.exec(
-      `CREATE TRIGGER ${quoteIdent(`${index.name}_bu`)} BEFORE UPDATE ON ${quoteIdent(table.name)} WHEN ${updateGuardCondition} BEGIN ${updateGuardBody}; END`,
-    );
+    createTrigger('bu', 'BEFORE UPDATE', updateGuardBody, updateGuardCondition);
   }
 
   if (!existed) {
     db.exec(
-      `INSERT INTO ${quoteIdent(index.name)} (${projectionColumns}) SELECT ${sourceId}, ${indexedColumns.join(', ')} FROM ${quoteIdent(table.name)}`,
+      `INSERT INTO ${projection}(${projectionColumns})SELECT ${sourceId},${indexedColumns.join(', ')} FROM ${sourceTable}`,
     );
   }
   if (!mapped || !existed) {
     db.exec(`DELETE FROM ${mapping}`);
     db.exec(
-      `INSERT INTO ${mapping}(id, source_id) SELECT rowid, ${quoteIdent(FTS_SOURCE_ID_COLUMN)} FROM ${quoteIdent(index.name)}`,
+      `INSERT INTO ${mapping}(id,source_id)SELECT rowid,${quoteIdent(FTS_SOURCE_ID_COLUMN)} FROM ${projection}`,
     );
   }
 }
@@ -534,39 +529,39 @@ export function ensureLocalSyncedSchema(
 export function ensureLocalBookkeepingSchema(db: ClientDatabase): void {
   db.transaction(() => {
     ensureFailedOverlaySchema(db);
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_meta(
-      key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_blob_commit_refs(
-      commit_id TEXT NOT NULL, blob_id TEXT NOT NULL, PRIMARY KEY(commit_id, blob_id))`);
+    const createTable = (name: string, columns: string) =>
+      db.exec(`CREATE TABLE IF NOT EXISTS ${name}(${columns})`);
+    createTable('_syncular_meta', 'key TEXT PRIMARY KEY,value TEXT NOT NULL');
+    createTable(
+      '_syncular_blob_commit_refs',
+      'commit_id TEXT NOT NULL,blob_id TEXT NOT NULL,PRIMARY KEY(commit_id,blob_id)',
+    );
     db.exec(
       'CREATE INDEX IF NOT EXISTS _syncular_blob_commit_refs_body ON _syncular_blob_commit_refs(blob_id)',
     );
     db.exec(
-      `INSERT OR IGNORE INTO _syncular_meta(key, value) VALUES ('localRevision', '0')`,
+      "INSERT OR IGNORE INTO _syncular_meta(key,value)VALUES('localRevision','0')",
+    );
+    createTable(
+      '_syncular_outbox',
+      'seq INTEGER PRIMARY KEY AUTOINCREMENT,client_commit_id TEXT NOT NULL UNIQUE,created_at_ms INTEGER NOT NULL,operations TEXT NOT NULL',
+    );
+    createTable(
+      '_syncular_outbox_before_images',
+      'client_commit_id TEXT NOT NULL,op_index INTEGER NOT NULL,existed INTEGER NOT NULL CHECK(existed IN (0,1)),sync_version INTEGER,values_json TEXT,PRIMARY KEY(client_commit_id,op_index)',
+    );
+    if (
+      !db
+        .query('PRAGMA table_info(_syncular_outbox_before_images)')
+        .some((row) => row.name === 'delivery_seq')
+    )
+      db.exec(
+        'ALTER TABLE _syncular_outbox_before_images ADD COLUMN delivery_seq INTEGER',
+      );
+    createTable(
+      '_syncular_commit_outcomes',
+      "seq INTEGER PRIMARY KEY AUTOINCREMENT,client_commit_id TEXT NOT NULL UNIQUE,status TEXT NOT NULL CHECK(status IN ('applied','cached','conflict','rejected')),recorded_at_ms INTEGER NOT NULL,results TEXT NOT NULL,operations TEXT,resolution TEXT NOT NULL DEFAULT 'active' CHECK(resolution IN ('active','resolved_keep_server','superseded','dismissed')),resolved_at_ms INTEGER,replacement_client_commit_id TEXT",
     );
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_outbox(
-      seq INTEGER PRIMARY KEY AUTOINCREMENT,
-      client_commit_id TEXT NOT NULL UNIQUE,
-      created_at_ms INTEGER NOT NULL,
-      operations TEXT NOT NULL)`);
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_outbox_before_images(
-      client_commit_id TEXT NOT NULL,
-      op_index INTEGER NOT NULL,
-      existed INTEGER NOT NULL CHECK(existed IN (0, 1)),
-      sync_version INTEGER,
-      values_json TEXT,
-      PRIMARY KEY(client_commit_id, op_index))`);
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_commit_outcomes(
-      seq INTEGER PRIMARY KEY AUTOINCREMENT,
-      client_commit_id TEXT NOT NULL UNIQUE,
-      status TEXT NOT NULL CHECK(status IN ('applied', 'cached', 'conflict', 'rejected')),
-      recorded_at_ms INTEGER NOT NULL,
-      results TEXT NOT NULL,
-      operations TEXT,
-      resolution TEXT NOT NULL DEFAULT 'active'
-        CHECK(resolution IN ('active', 'resolved_keep_server', 'superseded', 'dismissed')),
-      resolved_at_ms INTEGER,
-      replacement_client_commit_id TEXT)`);
     // Outcomes created before durable aggregate recovery retain no commit
     // envelope. New failed outcomes store it in the protected client DB.
     try {
@@ -576,32 +571,26 @@ export function ensureLocalBookkeepingSchema(db: ClientDatabase): void {
     } catch {
       // column already exists — the CREATE above included it
     }
-    db.exec(`CREATE INDEX IF NOT EXISTS _syncular_commit_outcomes_resolution_seq
-      ON _syncular_commit_outcomes(resolution, seq)`);
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_subscriptions(
-      id TEXT PRIMARY KEY,
-      tbl TEXT NOT NULL,
-      requested_scopes TEXT NOT NULL,
-      params TEXT,
-      cursor INTEGER NOT NULL DEFAULT -1,
-      bootstrap_state TEXT,
-      effective_scopes TEXT,
-      status TEXT NOT NULL DEFAULT 'active',
-      reason_code TEXT)`);
+    db.exec(
+      'CREATE INDEX IF NOT EXISTS _syncular_commit_outcomes_resolution_seq ON _syncular_commit_outcomes(resolution,seq)',
+    );
+    createTable(
+      '_syncular_subscriptions',
+      "id TEXT PRIMARY KEY,tbl TEXT NOT NULL,requested_scopes TEXT NOT NULL,params TEXT,cursor INTEGER NOT NULL DEFAULT -1,bootstrap_state TEXT,effective_scopes TEXT,status TEXT NOT NULL DEFAULT 'active',reason_code TEXT",
+    );
     // §4.8 window registry: which units (scope values) of a window base are
     // live locally — the completeness oracle (I3) and the shrink driver
     // (a unit's omission from the next pull unregisters it, §4.1).
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_windows(
-      base TEXT NOT NULL,
-      unit TEXT NOT NULL,
-      sub_id TEXT NOT NULL,
-      PRIMARY KEY (base, unit))`);
+    createTable(
+      '_syncular_windows',
+      'base TEXT NOT NULL,unit TEXT NOT NULL,sub_id TEXT NOT NULL,PRIMARY KEY(base,unit)',
+    );
     // §4.8 E1: units that left the window but still had outbox-pinned rows.
     // Retried when the outbox drains; cancelled if the unit re-enters.
-    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_window_pending_evict(
-      sub_id TEXT PRIMARY KEY,
-      tbl TEXT NOT NULL,
-      effective_scopes TEXT NOT NULL)`);
+    createTable(
+      '_syncular_window_pending_evict',
+      'sub_id TEXT PRIMARY KEY,tbl TEXT NOT NULL,effective_scopes TEXT NOT NULL',
+    );
   });
 }
 
@@ -634,9 +623,7 @@ export function dropAndRecreateSyncedTables(
   // Drop virtual tables first. SQLite then removes their shadow tables as one
   // unit, so the generic discovery below never tears an FTS5 projection apart.
   const virtualTables = db.query(
-    `SELECT name FROM sqlite_master WHERE type = 'table'
-       AND sql LIKE 'CREATE VIRTUAL TABLE%'
-       AND name NOT LIKE '${RESERVED_TABLE_PREFIX}%'`,
+    `SELECT name FROM sqlite_master WHERE type='table' AND sql LIKE 'CREATE VIRTUAL TABLE%' AND name NOT LIKE '${RESERVED_TABLE_PREFIX}%'`,
   );
   for (const row of virtualTables) {
     db.exec(
@@ -645,9 +632,7 @@ export function dropAndRecreateSyncedTables(
     db.exec(`DROP TABLE IF EXISTS ${quoteIdent(String(row.name))}`);
   }
   const existing = db.query(
-    `SELECT name FROM sqlite_master WHERE type = 'table'
-       AND name NOT LIKE '${RESERVED_TABLE_PREFIX}%'
-       AND name NOT LIKE 'sqlite_%'`,
+    `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '${RESERVED_TABLE_PREFIX}%' AND name NOT LIKE 'sqlite_%'`,
   );
   for (const row of existing) {
     db.exec(`DROP TABLE IF EXISTS ${quoteIdent(String(row.name))}`);
@@ -680,15 +665,8 @@ export function fromSqlValue(column: RowColumn, value: SqlValue): RowValue {
       return value !== 0 && value !== false;
     case 'integer':
       return typeof value === 'bigint' ? Number(value) : (value as number);
-    case 'float':
-      return value as number;
-    case 'bytes':
-    case 'crdt':
-      return value as Uint8Array;
-    case 'string':
-    case 'json':
-    case 'blob_ref':
-      return value as string;
+    default:
+      return value as RowValue;
   }
 }
 
@@ -710,17 +688,17 @@ export function normalizeRecordKeys(
     if (index === undefined) {
       if (key.startsWith('_sync_')) {
         throw invalidRequest(
-          `table ${table.name}: ${JSON.stringify(key)} is an internal sync column and cannot appear in mutation values — did you build this record from a raw SELECT * row? (client.query() strips _sync_* columns; rows read via client.database keep them)`,
+          `table ${table.name}: ${JSON.stringify(key)} is an internal sync column; omit it from mutation values`,
         );
       }
       throw invalidRequest(
-        `table ${table.name}: unknown column ${JSON.stringify(key)} in mutation values (snake_case and camelCase keys are accepted)`,
+        `table ${table.name}: unknown column ${JSON.stringify(key)} in mutation values`,
       );
     }
     const sqlName = (table.columns[index] as RowColumn).name;
     if (normalized.has(sqlName)) {
       throw invalidRequest(
-        `table ${table.name}: column ${JSON.stringify(sqlName)} appears twice in mutation values (as both snake_case and camelCase) — pass it once`,
+        `table ${table.name}: column ${JSON.stringify(sqlName)} appears twice in mutation values`,
       );
     }
     normalized.set(sqlName, value);
@@ -810,3 +788,13 @@ export function jsonToRowValue(value: JsonRowValue): RowValue {
   }
   return value;
 }
+
+/** Convert each column value without changing the row's presence set. */
+export function mapRowValues<T, U>(
+  values: Readonly<Record<string, T>>,
+  convert: (value: T) => U,
+): Record<string, U> {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [key, convert(value)]),
+  );
+}