@syncular/client 0.30.11 → 0.30.13

package/dist/schema.js

@@ -10,42 +10,41 @@ const ALLOWED_FTS_TOKENIZERS = new Set([
     'porter unicode61',
     'trigram',
 ]);
+function invalidSchema(message) {
+    throw new Error(message);
+}
 export function compileClientSchema(schema) {
     const tables = new Map();
     const schemaObjectNames = new Set();
     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(`table ${JSON.stringify(table.name)} conflicts with an index or FTS projection`);
+            invalidSchema(`table ${JSON.stringify(table.name)} conflicts with an index or FTS projection`);
         }
         schemaObjectNames.add(table.name);
         const columnIndex = new Map();
         table.columns.forEach((column, index) => {
             if (columnIndex.has(column.name)) {
-                throw new Error(`${tableLabel}: 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(`${tableLabel}: 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];
-        if (primaryKeyColumn !== undefined &&
-            primaryKeyColumn.type !== 'string' &&
-            primaryKeyColumn.type !== 'integer' &&
-            primaryKeyColumn.type !== 'boolean' &&
-            primaryKeyColumn.type !== 'json') {
-            throw new Error(`${tableLabel}: primary key ${JSON.stringify(table.primaryKey)} has an ineligible column type (§2.4); a primary key must be string, integer, boolean, or json`);
+        if (!['string', 'integer', 'boolean', 'json'].includes(primaryKeyColumn.type)) {
+            invalidSchema(`${tableLabel}: primary key ${JSON.stringify(table.primaryKey)} has an ineligible type (§2.4)`);
         }
         if (table.scopes.length === 0) {
-            throw new Error(`${tableLabel}: 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();
         const scopePrefixByVariable = new Map();
@@ -53,17 +52,17 @@ export function compileClientSchema(schema) {
             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(`${tableLabel}: 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(`${tableLabel}: 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(`${tableLabel}: 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);
             scopePrefixByVariable.set(variable, prefix);
@@ -84,44 +83,28 @@ export function compileClientSchema(schema) {
         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(`${tableLabel}: 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(`${tableLabel}: index ${JSON.stringify(index.name)} names unknown column ${JSON.stringify(column)}`);
-                }
-            }
-        }
         const ftsIndexes = table.ftsIndexes ?? [];
-        for (const index of ftsIndexes) {
-            const projectionLabel = `${tableLabel}: FTS projection ${JSON.stringify(index.name)}`;
-            if (schemaObjectNames.has(index.name)) {
-                throw new Error(`${projectionLabel} 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(`${projectionLabel} needs between 1 and 32 columns`);
-            }
-            const seenColumns = new Set();
-            for (const columnName of index.columns) {
-                if (seenColumns.has(columnName)) {
-                    throw new Error(`${projectionLabel} repeats column ${JSON.stringify(columnName)}`);
-                }
-                seenColumns.add(columnName);
-                const column = table.columns.find((candidate) => candidate.name === columnName);
-                if (column === undefined) {
-                    throw new Error(`${projectionLabel} names unknown column ${JSON.stringify(columnName)}`);
-                }
-                if (localColumnType(column) !== 'string') {
-                    throw new Error(`${projectionLabel} column ${JSON.stringify(columnName)} must have string type`);
-                }
-            }
-            if (!ALLOWED_FTS_TOKENIZERS.has(index.tokenize)) {
-                throw new Error(`${projectionLabel} tokenizer ${JSON.stringify(index.tokenize)} is not allowlisted`);
+            if (fts && (!index.columns.length || index.columns.length > 32))
+                invalidSchema(`${label} needs between 1 and 32 columns`);
+            const seen = new Set();
+            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 (fts && localColumnType(column) !== 'string')
+                    invalidSchema(`${label} column ${JSON.stringify(name)} must have string type`);
             }
+            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,
@@ -173,6 +156,14 @@ export function stripSyncColumns(rows) {
         return copy;
     });
 }
+export function matchesLocalScopes(table, scopes, values) {
+    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) {
     return `"${name.replaceAll('"', '""')}"`;
 }
@@ -247,18 +238,21 @@ const FTS_SOURCE_ID_COLUMN = '_syncular_source_id';
  * comment below for the full rationale.
  */
 function createFtsProjection(db, table, index) {
+    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=?", [index.name]).length > 0;
     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}')`);
+    db.exec(`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}`);
     const mapped = db.query("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", [
         `_syncular_fts_${index.name}`,
     ]).length > 0;
     db.exec(`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,
@@ -267,9 +261,9 @@ function createFtsProjection(db, table, index) {
         newSourceId,
         ...index.columns.map((column) => `new.${quoteIdent(column)}`),
     ].join(', ');
-    const deleteFor = (value) => `DELETE FROM ${quoteIdent(index.name)} WHERE rowid=(SELECT id FROM ${mapping} WHERE source_id=${value});DELETE FROM ${mapping} WHERE source_id=${value}`;
-    const deleteDisplaced = (select) => `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})`;
+    const deleteFor = (value) => `DELETE FROM ${projection} WHERE rowid=(SELECT id FROM ${mapping} WHERE source_id=${value});DELETE FROM ${mapping} WHERE source_id=${value}`;
+    const deleteDisplaced = (select) => `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
     // cleanup behind indexed source-table existence checks. SQLite does not
@@ -297,7 +291,7 @@ function createFtsProjection(db, table, index) {
     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).
@@ -306,7 +300,7 @@ function createFtsProjection(db, table, index) {
         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,
@@ -316,7 +310,7 @@ function createFtsProjection(db, table, index) {
         deleteFor(newSourceId),
         ...displacedByUnique.map(deleteDisplaced),
     ].join('; ');
-    const createTrigger = (suffix, timing, body, when = '') => db.exec(`CREATE TRIGGER ${quoteIdent(`${index.name}_${suffix}`)} ${timing} ON ${quoteIdent(table.name)}${when ? ` WHEN ${when}` : ''} BEGIN ${body};END`);
+    const createTrigger = (suffix, timing, body, 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));
@@ -333,11 +327,11 @@ function createFtsProjection(db, table, index) {
         createTrigger('bu', 'BEFORE UPDATE', updateGuardBody, updateGuardCondition);
     }
     if (!existed) {
-        db.exec(`INSERT INTO ${quoteIdent(index.name)}(${projectionColumns})SELECT ${sourceId},${indexedColumns.join(', ')} FROM ${quoteIdent(table.name)}`);
+        db.exec(`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)}`);
+        db.exec(`INSERT INTO ${mapping}(id,source_id)SELECT rowid,${quoteIdent(FTS_SOURCE_ID_COLUMN)} FROM ${projection}`);
     }
 }
 /**
@@ -373,6 +367,10 @@ export function ensureLocalBookkeepingSchema(db) {
         db.exec("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");
         // Outcomes created before durable aggregate recovery retain no commit
         // envelope. New failed outcomes store it in the protected client DB.
@@ -449,14 +447,7 @@ export function fromSqlValue(column, value) {
             return value !== 0 && value !== false;
         case 'integer':
             return typeof value === 'bigint' ? Number(value) : value;
-        case 'float':
-            return value;
-        case 'bytes':
-        case 'crdt':
-            return value;
-        case 'string':
-        case 'json':
-        case 'blob_ref':
+        default:
             return value;
     }
 }
@@ -473,13 +464,13 @@ export function normalizeRecordKeys(table, record) {
         const index = table.columnIndex.get(key) ?? table.columnIndexByCamel.get(key);
         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)`);
+                throw invalidRequest(`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)`);
+            throw invalidRequest(`table ${table.name}: unknown column ${JSON.stringify(key)} in mutation values`);
         }
         const sqlName = table.columns[index].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`);
+            throw invalidRequest(`table ${table.name}: column ${JSON.stringify(sqlName)} appears twice in mutation values`);
         }
         normalized.set(sqlName, value);
     }

package/dist/worker-entry.js

@@ -94,6 +94,7 @@ export function startSyncWorker(overrides = {}) {
         autoSyncScheduled = false;
         if (closed ||
             client === undefined ||
+            offline ||
             client.securityLifecycle() === 'preflight') {
             return;
         }
@@ -116,6 +117,7 @@ export function startSyncWorker(overrides = {}) {
         if (!autoSync ||
             closed ||
             client === undefined ||
+            offline ||
             client.securityLifecycle() === 'preflight' ||
             intent.kind === 'none') {
             return;
@@ -156,31 +158,6 @@ export function startSyncWorker(overrides = {}) {
         }
         return client;
     }
-    function assertOnline() {
-        if (offline) {
-            throw new ClientSyncError('sync.transport_failed', 'the worker transport is offline (setOffline(true))', true);
-        }
-    }
-    function gateOffline(inner) {
-        return (request) => {
-            assertOnline();
-            return inner(request);
-        };
-    }
-    /** Offline gate that preserves the §5.4 `fetchUrl` capability marker. */
-    function gateSegmentsOffline(inner) {
-        const fetchUrl = inner.fetchUrl;
-        return Object.assign(gateOffline(inner), {
-            ...(fetchUrl !== undefined
-                ? {
-                    fetchUrl: (url, onProgress) => {
-                        assertOnline();
-                        return fetchUrl(url, onProgress);
-                    },
-                }
-                : {}),
-        });
-    }
     async function init(config) {
         if (client !== undefined) {
             throw new ClientSyncError(WORKER_FAILED_CODE, 'the worker is already initialized');
@@ -215,9 +192,9 @@ export function startSyncWorker(overrides = {}) {
                 }
             }
         }
-        const transport = gateOffline(overrides.createTransport !== undefined
+        const transport = overrides.createTransport !== undefined
             ? overrides.createTransport(config)
-            : httpSyncTransport(config.endpoints.syncUrl, http));
+            : httpSyncTransport(config.endpoints.syncUrl, http);
         const segments = overrides.createSegments !== undefined
             ? overrides.createSegments(config)
             : config.endpoints.segmentsUrl !== undefined
@@ -231,18 +208,15 @@ export function startSyncWorker(overrides = {}) {
         // `{clientId}` URL placeholder — start the client first, then attach
         // the connector through a mutable slot read at connect time.
         let realtimeConnector;
+        offline = config.transportEnabled === false;
         const started = new SyncClient({
+            transportEnabled: !offline,
             database,
             schema: config.schema,
             transport,
-            ...(segments !== undefined
-                ? { segments: gateSegmentsOffline(segments) }
-                : {}),
+            ...(segments !== undefined ? { segments } : {}),
             ...(blobs !== undefined ? { blobs } : {}),
             realtime: (handlers) => {
-                if (offline) {
-                    throw new ClientSyncError('sync.transport_failed', 'the worker realtime channel is offline (setOffline(true))', true);
-                }
                 if (realtimeConnector === undefined) {
                     throw new ClientSyncError('sync.invalid_request', 'no realtime connector configured');
                 }
@@ -399,8 +373,13 @@ export function startSyncWorker(overrides = {}) {
         },
         setOffline: (value) => {
             offline = value;
-            if (offline)
-                client?.disconnectRealtime();
+            requireClient().setTransportEnabled(!value);
+            if (offline) {
+                if (backgroundTimer !== undefined)
+                    clearTimeout(backgroundTimer);
+                backgroundTimer = undefined;
+                backgroundDue = Number.POSITIVE_INFINITY;
+            }
             else if (client !== undefined) {
                 const snapshot = client.diagnosticsSnapshot();
                 post({

package/dist/worker-host.d.ts

@@ -85,6 +85,7 @@ export interface SyncClientHandleConfig {
     readonly encryption?: EncryptionKeyringConfig;
     /** Open the worker-owned replica behind the fail-closed security gate. */
     readonly securityPreflight?: boolean;
+    readonly transportEnabled?: boolean;
     readonly clientId?: string;
     readonly limits?: SyncClientLimits;
     readonly retainFailedCommits?: boolean;

package/dist/worker-host.js

@@ -566,6 +566,9 @@ function buildInitConfig(config, headers = config.headers) {
         ...(config.encryption !== undefined
             ? { encryption: config.encryption }
             : {}),
+        ...(config.transportEnabled !== undefined
+            ? { transportEnabled: config.transportEnabled }
+            : {}),
         ...(config.securityPreflight !== undefined
             ? { securityPreflight: config.securityPreflight }
             : {}),

package/dist/worker-protocol.d.ts

@@ -78,6 +78,7 @@ export interface WorkerInitConfig {
     readonly encryption?: EncryptionKeyringConfig;
     /** Open the worker-owned replica behind the fail-closed security gate. */
     readonly securityPreflight?: boolean;
+    readonly transportEnabled?: boolean;
     readonly clientId?: string;
     readonly limits?: SyncClientLimits;
     readonly retainFailedCommits?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.11",
+  "version": "0.30.13",
   "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.11"
+    "@syncular/core": "0.30.13"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.11",
+    "@syncular/server": "0.30.13",
     "playwright": "1.63.0",
     "@electric-sql/pglite": "^0.5.4"
   }

package/src/apply.ts

@@ -1,3 +1,4 @@
+import { RETAINED_ROWS } from './failed-overlay';
 import { retainedBaseWrite, restoreFailedBases } from './failed-overlay';
 /**
  * Local application of server data: `COMMIT` frames (§4.5), rows segments
@@ -19,6 +20,8 @@ import {
   type CompiledClientSchema,
   type CompiledClientTable,
   quoteIdent,
+  matchesLocalScopes,
+  type JsonRowValue,
   SYNC_VERSION_COLUMN,
   toSqlValue,
   rowValueToJson,
@@ -93,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 }
@@ -138,14 +142,31 @@ export async function applyCommitFrame(
     });
   }
   transaction(() => {
-    restoreFailedBases(db, schema);
-    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, 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,19 +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 };
@@ -329,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) {
@@ -506,12 +537,12 @@ export async function applyRowsSegment(
     first = false;
     if (!clearThisBlock && rows.length === 0) continue;
     (options.transaction ?? ((fn) => db.transaction(fn)))(() => {
-      restoreFailedBases(db, schema);
+      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);
       }