@syncular/client 0.30.7 → 0.30.9

package/dist/failed-overlay.js

@@ -0,0 +1,97 @@
+import { ClientSyncError } from './errors.js';
+import { jsonToRowValue, quoteIdent } from './schema.js';
+import { deleteLocalRow, upsertLocalRow } from './apply.js';
+/** Protected failure state. The server base advances independently of intent. */
+export function ensureFailedOverlaySchema(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS _syncular_failed_rows(
+    commit_id TEXT NOT NULL, idx INTEGER NOT NULL,
+    tbl TEXT NOT NULL, id TEXT NOT NULL, at INTEGER NOT NULL,
+    op TEXT NOT NULL, intent TEXT, base TEXT, version INTEGER,
+    PRIMARY KEY(commit_id, idx))`);
+}
+export function retainedBaseWrite(db, table, rowId, values, version) {
+    db.exec('UPDATE _syncular_failed_rows SET base = ?, version = ? WHERE tbl = ? AND id = ?', [
+        values === undefined ? null : JSON.stringify(values),
+        version ?? null,
+        table,
+        rowId,
+    ]);
+}
+export function retainFailedRows(db, commit, images) {
+    for (const [index, operation] of commit.operations.entries()) {
+        const image = images.find((image) => image.opIndex === index);
+        const initial = operation.op === 'upsert'
+            ? { ...image?.values, ...operation.values }
+            : undefined;
+        if (!image)
+            throw new ClientSyncError('sync.local_corrupt', 'retained intent has no before-image');
+        db.exec(`INSERT INTO _syncular_failed_rows(commit_id, idx, tbl, id, at, op, intent, base, version)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            commit.clientCommitId,
+            index,
+            operation.table,
+            operation.rowId,
+            commit.createdAtMs,
+            JSON.stringify(operation),
+            initial ? JSON.stringify(initial) : null,
+            image.values ? JSON.stringify(image.values) : null,
+            image.syncVersion ?? null,
+        ]);
+    }
+}
+export function restoreFailedBases(db, schema, absentIntent = false) {
+    const seen = new Set();
+    for (const row of db.query('SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx')) {
+        const key = JSON.stringify([row.tbl, row.id]);
+        if (!absentIntent && seen.has(key))
+            continue;
+        seen.add(key);
+        const table = schema.tables.get(String(row.tbl));
+        if (!table)
+            throw new ClientSyncError('sync.unknown_table', 'retained intent references an unknown table');
+        const json = absentIntent ? row.intent : row.base;
+        if (absentIntent &&
+            (json === null ||
+                db.query(`SELECT 1 FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`, [String(row.id)]).length))
+            continue;
+        if (json === null)
+            deleteLocalRow(db, table, String(row.id), false);
+        else {
+            const values = JSON.parse(String(json));
+            upsertLocalRow(db, table, table.columns.map((column) => jsonToRowValue(values[column.name] ?? null)), Number(row.version ?? -1), false);
+        }
+    }
+}
+export function failedOverlayCommits(db) {
+    const commits = new Map();
+    for (const row of db.query('SELECT * FROM _syncular_failed_rows ORDER BY at, commit_id, idx')) {
+        const id = String(row.commit_id);
+        const operation = JSON.parse(String(row.op));
+        const prior = commits.get(id);
+        if (prior)
+            prior.operations.push(operation);
+        else
+            commits.set(id, {
+                seq: 0,
+                clientCommitId: id,
+                createdAtMs: Number(row.at),
+                operations: [operation],
+            });
+    }
+    return [...commits.values()];
+}
+export function dropFailedRows(db, matches) {
+    const ids = new Set();
+    for (const row of db.query('SELECT * FROM _syncular_failed_rows')) {
+        const json = row.intent ?? row.base;
+        if (json === null)
+            continue;
+        const values = JSON.parse(String(json));
+        if (matches(String(row.tbl), values))
+            ids.add(String(row.commit_id));
+    }
+    const dropped = failedOverlayCommits(db).filter((commit) => ids.has(commit.clientCommitId));
+    for (const id of ids)
+        db.exec('DELETE FROM _syncular_failed_rows WHERE commit_id = ?', [id]);
+    return dropped;
+}

package/dist/invalidation.d.ts

@@ -83,6 +83,7 @@ export declare class ChangeAccumulator {
     scopeMap(table: CompiledClientTable, scopes: ScopeMap): void;
     /** Add precise keys for a COMMIT change's stored scope values. */
     changeScopes(table: CompiledClientTable, scopes: Readonly<Record<string, string>>): void;
+    hasTable(name: string): boolean;
     get touched(): boolean;
     get statusChanged(): boolean;
     finish(revision: LocalRevision, status: SyncStatusSnapshot | undefined): ClientChangeBatch;

package/dist/invalidation.js

@@ -73,6 +73,9 @@ export class ChangeAccumulator {
             }
         }
     }
+    hasTable(name) {
+        return this.#tables.has(name);
+    }
     get touched() {
         return (this.#tables.size > 0 ||
             this.#windows.size > 0 ||

package/dist/outcomes.d.ts

@@ -50,6 +50,15 @@ export type CommitOperationOutcome = {
     readonly status: 'error';
     readonly rejection: RejectionRecord;
 };
+export interface RetainedCommitRow {
+    readonly table: string;
+    readonly rowId: string;
+    /** Complete intended row, or null for a local deletion. */
+    readonly localRow: Readonly<Record<string, RowValue>> | null;
+    /** Latest authorized server base, or null for an absent server row. */
+    readonly serverRow: Readonly<Record<string, RowValue>> | null;
+    readonly serverVersion: number | null;
+}
 export interface CommitOutcome {
     /** Monotonic local journal order; not a server sequence. */
     readonly sequence: number;
@@ -63,6 +72,7 @@ export interface CommitOutcome {
      * for successful and historical outcomes. Never sent over the wire.
      */
     readonly operations?: readonly OutboxOperation[];
+    readonly retainedRows?: readonly RetainedCommitRow[];
     readonly resolution: CommitOutcomeResolution;
     readonly resolvedAtMs?: number;
     readonly replacementClientCommitId?: string;

package/dist/outcomes.js

@@ -36,7 +36,21 @@ function decodeResults(raw) {
         };
     });
 }
-function parseOutcome(row) {
+function parseOutcome(db, row) {
+    const retainedRows = db
+        .query('SELECT tbl, id, intent, base, version FROM _syncular_failed_rows WHERE commit_id = ? ORDER BY idx', [String(row.client_commit_id)])
+        .map((retained) => {
+        const decode = (value) => value === null
+            ? null
+            : Object.fromEntries(Object.entries(JSON.parse(String(value))).map(([key, value]) => [key, jsonToRowValue(value)]));
+        return {
+            table: String(retained.tbl),
+            rowId: String(retained.id),
+            localRow: decode(retained.intent),
+            serverRow: decode(retained.base),
+            serverVersion: retained.version === null ? null : Number(retained.version),
+        };
+    });
     return {
         sequence: row.seq,
         clientCommitId: row.client_commit_id,
@@ -46,6 +60,7 @@ function parseOutcome(row) {
         ...(typeof row.operations === 'string'
             ? { operations: JSON.parse(row.operations) }
             : {}),
+        ...(retainedRows.length > 0 ? { retainedRows } : {}),
         resolution: row.resolution,
         ...(typeof row.resolved_at_ms === 'number'
             ? { resolvedAtMs: row.resolved_at_ms }
@@ -73,7 +88,7 @@ export function commitOutcome(db, clientCommitId) {
     const row = db.query(`SELECT seq, client_commit_id, status, recorded_at_ms, results, operations,
             resolution, resolved_at_ms, replacement_client_commit_id
        FROM _syncular_commit_outcomes WHERE client_commit_id = ?`, [clientCommitId])[0];
-    return row === undefined ? undefined : parseOutcome(row);
+    return row === undefined ? undefined : parseOutcome(db, row);
 }
 export function listCommitOutcomes(db, query = {}) {
     const limit = query.limit;
@@ -87,7 +102,7 @@ export function listCommitOutcomes(db, query = {}) {
             resolution, resolved_at_ms, replacement_client_commit_id
        FROM _syncular_commit_outcomes ${where}
       ORDER BY seq DESC${limit === undefined ? '' : ' LIMIT ?'}`, limit === undefined ? [] : [limit]);
-    return rows.map(parseOutcome);
+    return rows.map((row) => parseOutcome(db, row));
 }
 export function persistCommitOutcomeResolution(db, input, nowMs) {
     db.exec(`UPDATE _syncular_commit_outcomes

package/dist/remote.js

@@ -5,7 +5,7 @@
 import { decodeMessage, decodeRemoteOperationResponse, decodeRemoteOperationRealtimeMessage, encodeMessage, encodeRemoteOperationRequest, encodeRemoteOperationRealtimeMessage, encodeSparseRow, PROTOCOL_WIRE_VERSION, } from '@syncular/core';
 import { encryptRowValues } from './encryption.js';
 import { ClientSyncError } from './errors.js';
-import { compileClientSchema, recordToRowValues, } from './schema.js';
+import { compileClientSchema, recordToRowValues, normalizeRecordKeys, coerceSqlRepresentation, } from './schema.js';
 export function remoteCommand(id) {
     if (id.length === 0)
         throw invalid('remote command id must be non-empty');
@@ -157,7 +157,12 @@ export class SyncRemoteClient {
                 });
                 continue;
             }
-            let values = recordToRowValues(table, mutation.values);
+            const normalized = normalizeRecordKeys(table, mutation.values);
+            let values = mutation.op === 'patch'
+                ? table.columns.map((column) => normalized.has(column.name)
+                    ? coerceSqlRepresentation(column, normalized.get(column.name))
+                    : undefined)
+                : recordToRowValues(table, mutation.values);
             const rowId = values[table.primaryKeyIndex];
             if (typeof rowId !== 'string' || rowId.length === 0) {
                 throw invalid('remote upsert requires a non-empty string primary key');

package/dist/schema.js

@@ -1,4 +1,5 @@
-import { ClientSyncError } from './errors.js';
+import { ensureFailedOverlaySchema } from './failed-overlay.js';
+import { invalidRequest } from './errors.js';
 import { snakeToCamel } from './naming.js';
 const PATTERN_RE = /^([^{}]+):\{([^{}:]+)\}$/;
 const ALLOWED_FTS_TOKENIZERS = new Set([
@@ -361,6 +362,7 @@ export function ensureLocalSyncedSchema(db, schema) {
  */
 export function ensureLocalBookkeepingSchema(db) {
     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(
@@ -510,13 +512,13 @@ export function normalizeRecordKeys(table, record) {
         const index = table.columnIndex.get(key) ?? table.columnIndexByCamel.get(key);
         if (index === undefined) {
             if (key.startsWith('_sync_')) {
-                throw new ClientSyncError('sync.invalid_request', `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 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 new ClientSyncError('sync.invalid_request', `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 (snake_case and camelCase keys are accepted)`);
         }
         const sqlName = table.columns[index].name;
         if (normalized.has(sqlName)) {
-            throw new ClientSyncError('sync.invalid_request', `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 (as both snake_case and camelCase) — pass it once`);
         }
         normalized.set(sqlName, value);
     }
@@ -551,7 +553,7 @@ export function recordToRowValues(table, record) {
         const value = normalized.get(column.name);
         if (value === undefined || value === null) {
             if (!column.nullable) {
-                throw new ClientSyncError('sync.invalid_request', `table ${table.name}: column ${JSON.stringify(column.name)} is not nullable (§6.1 full-row payloads)`);
+                throw invalidRequest(`table ${table.name}: column ${JSON.stringify(column.name)} is not nullable (§6.1 full-row payloads)`);
             }
             return null;
         }

package/dist/wasm-database.js

@@ -24,7 +24,7 @@
  */
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 import { assertImageAlias, runTransaction, } from './database.js';
-import { ClientSyncError, STORAGE_BUSY_CODE, STORAGE_UNAVAILABLE_CODE, } from './errors.js';
+import { ClientSyncError, invalidRequest, STORAGE_BUSY_CODE, STORAGE_UNAVAILABLE_CODE, } from './errors.js';
 function coerceParams(params) {
     return params.map((value) => {
         if (typeof value === 'boolean')
@@ -108,7 +108,7 @@ class WasmClientDatabase {
         assertImageAlias(alias);
         const pointer = this.#db.pointer;
         if (pointer === undefined) {
-            throw new ClientSyncError('sync.invalid_request', 'sqlite-wasm database exposes no native handle for image import');
+            throw invalidRequest('sqlite-wasm database exposes no native handle for image import');
         }
         const { capi, wasm } = this.#sqlite3;
         this.exec(`ATTACH ':memory:' AS ${alias}`);
@@ -119,7 +119,7 @@ class WasmClientDatabase {
             // immutable inputs (§5.1).
             capi.SQLITE_DESERIALIZE_FREEONCLOSE | capi.SQLITE_DESERIALIZE_READONLY);
             if (rc !== 0) {
-                throw new ClientSyncError('sync.invalid_request', `sqlite3_deserialize failed with code ${rc} (§5.3)`);
+                throw invalidRequest(`sqlite3_deserialize failed with code ${rc} (§5.3)`);
             }
             return await fn();
         }
@@ -235,10 +235,10 @@ function configureSahCrashRecovery(db, sqlite3) {
  */
 export async function openPersistentWasmDatabase(name, options) {
     if (!/^[A-Za-z0-9._-]+$/.test(name)) {
-        throw new ClientSyncError('sync.invalid_request', `invalid persistent database name ${JSON.stringify(name)}`);
+        throw invalidRequest(`invalid persistent database name ${JSON.stringify(name)}`);
     }
     if (!inWorkerContext()) {
-        throw new ClientSyncError('sync.invalid_request', 'openPersistentWasmDatabase() must run inside a Web Worker: the ' +
+        throw invalidRequest('openPersistentWasmDatabase() must run inside a Web Worker: the ' +
             'persistent mode is whole-core-in-a-worker by design (Direction ' +
             'decision 2, 2026-07-03). Use the worker handle from the main ' +
             'thread, or openWasmDatabase() for explicitly ephemeral state.');

package/dist/window.js

@@ -13,7 +13,7 @@
  * transaction and the invalidation choke point.
  */
 import { canonicalScopeJson } from '@syncular/core';
-import { ClientSyncError } from './errors.js';
+import { invalidRequest } from './errors.js';
 const MAX_TIME_BUCKET_MS = 253_402_300_799_999;
 function monthBucket(year, month) {
     return `${year.toString().padStart(4, '0')}-${month.toString().padStart(2, '0')}`;
@@ -24,7 +24,7 @@ export function creationTimeBucket(createdAtMs, unit) {
         !Number.isSafeInteger(createdAtMs) ||
         createdAtMs < 0 ||
         createdAtMs > MAX_TIME_BUCKET_MS) {
-        throw new ClientSyncError('sync.invalid_request', 'creationTimeBucket requires a supported unit and a UTC timestamp from 1970 through 9999');
+        throw invalidRequest('creationTimeBucket requires a supported unit and a UTC timestamp from 1970 through 9999');
     }
     const date = new Date(createdAtMs);
     return monthBucket(date.getUTCFullYear(), date.getUTCMonth() + 1);
@@ -38,12 +38,12 @@ export function last(count, unit, nowMs = Date.now()) {
         !Number.isSafeInteger(nowMs) ||
         nowMs < 0 ||
         nowMs > MAX_TIME_BUCKET_MS) {
-        throw new ClientSyncError('sync.invalid_request', 'last requires a supported unit, a count from 1 through 1200, and a UTC timestamp from 1970 through 9999');
+        throw invalidRequest('last requires a supported unit, a count from 1 through 1200, and a UTC timestamp from 1970 through 9999');
     }
     const date = new Date(nowMs);
     const current = date.getUTCFullYear() * 12 + date.getUTCMonth();
     if (current - (count - 1) < 1970 * 12) {
-        throw new ClientSyncError('sync.invalid_request', 'last requires every returned UTC month to fall from 1970 through 9999');
+        throw invalidRequest('last requires every returned UTC month to fall from 1970 through 9999');
     }
     const units = [];
     for (let offset = count - 1; offset >= 0; offset -= 1) {

package/dist/worker-entry.js

@@ -250,6 +250,9 @@ export function startSyncWorker(overrides = {}) {
             },
             ...(config.clientId !== undefined ? { clientId: config.clientId } : {}),
             ...(config.limits !== undefined ? { limits: config.limits } : {}),
+            ...(config.retainFailedCommits !== undefined
+                ? { retainFailedCommits: config.retainFailedCommits }
+                : {}),
             ...(config.realtimePolicy !== undefined
                 ? { realtimePolicy: config.realtimePolicy }
                 : {}),

package/dist/worker-host.d.ts

@@ -87,6 +87,7 @@ export interface SyncClientHandleConfig {
     readonly securityPreflight?: boolean;
     readonly clientId?: string;
     readonly limits?: SyncClientLimits;
+    readonly retainFailedCommits?: boolean;
     /**
      * SPEC §8.8 realtime policy for the worker-owned core, forwarded into
      * `WorkerInitConfig`. Absent ⇒ `optional`.

package/dist/worker-host.js

@@ -545,6 +545,9 @@ function buildInitConfig(config, headers = config.headers) {
             : {}),
         ...(config.clientId !== undefined ? { clientId: config.clientId } : {}),
         ...(config.limits !== undefined ? { limits: config.limits } : {}),
+        ...(config.retainFailedCommits !== undefined
+            ? { retainFailedCommits: config.retainFailedCommits }
+            : {}),
         ...(config.realtimePolicy !== undefined
             ? { realtimePolicy: config.realtimePolicy }
             : {}),

package/dist/worker-protocol.d.ts

@@ -80,6 +80,7 @@ export interface WorkerInitConfig {
     readonly securityPreflight?: boolean;
     readonly clientId?: string;
     readonly limits?: SyncClientLimits;
+    readonly retainFailedCommits?: boolean;
     /**
      * SPEC §8.8 realtime policy for the worker-owned core; forwarded verbatim.
      * Absent ⇒ `optional` (a connected socket, otherwise `POST /sync`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.7",
+  "version": "0.30.9",
   "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.7"
+    "@syncular/core": "0.30.9"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.7",
+    "@syncular/server": "0.30.9",
     "playwright": "1.63.0"
   }
 }

package/src/apply.ts

@@ -1,3 +1,4 @@
+import { retainedBaseWrite } 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
@@ -13,13 +14,14 @@ import {
 } from '@syncular/core';
 import type { ClientDatabase, SqlValue } from './database';
 import type { EncryptionConfig } from './encryption';
-import { ClientSyncError } from './errors';
+import { ClientSyncError, invalidRequest } from './errors';
 import {
   type CompiledClientSchema,
   type CompiledClientTable,
   quoteIdent,
   SYNC_VERSION_COLUMN,
   toSqlValue,
+  rowValueToJson,
 } from './schema';
 
 /** Lets the client wrap the physical write in its revision transaction. */
@@ -44,7 +46,21 @@ export function upsertLocalRow(
   table: CompiledClientTable,
   values: readonly RowValue[],
   syncVersion: number,
+  serverWrite = true,
 ): void {
+  if (serverWrite)
+    retainedBaseWrite(
+      db,
+      table.name,
+      String(values[table.primaryKeyIndex]),
+      Object.fromEntries(
+        table.columns.map((column, index) => [
+          column.name,
+          rowValueToJson(values[index] ?? null),
+        ]),
+      ),
+      syncVersion,
+    );
   db.exec(upsertSql(table), [...values.map(toSqlValue), syncVersion]);
 }
 
@@ -52,7 +68,9 @@ export function deleteLocalRow(
   db: ClientDatabase,
   table: CompiledClientTable,
   rowId: string,
+  serverWrite = true,
 ): void {
+  if (serverWrite) retainedBaseWrite(db, table.name, rowId);
   db.exec(
     `DELETE FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`,
     [rowId],
@@ -90,8 +108,7 @@ export async function applyCommitFrame(
   for (const change of frame.changes) {
     const tableName = frame.tables[change.tableIndex];
     if (tableName === undefined) {
-      throw new ClientSyncError(
-        'sync.invalid_request',
+      throw invalidRequest(
         `COMMIT change tableIndex ${change.tableIndex} out of range`,
       );
     }
@@ -107,10 +124,7 @@ export async function applyCommitFrame(
       continue;
     }
     if (change.row === undefined || change.rowVersion === undefined) {
-      throw new ClientSyncError(
-        'sync.invalid_request',
-        'upsert change without row payload',
-      );
+      throw invalidRequest('upsert change without row payload');
     }
     let values = decodeRow(table.columns, change.row);
     if (encryption !== undefined && table.hasEncryptedColumns) {
@@ -204,6 +218,12 @@ export function deleteScopedRows(
     );
     params.push(...values);
   }
+  for (const row of db.query(
+    `SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${clauses.join(' AND ')}`,
+    params,
+  )) {
+    retainedBaseWrite(db, table.name, String(row.id));
+  }
   db.exec(
     `DELETE FROM ${quoteIdent(table.name)} WHERE ${clauses.join(' AND ')}`,
     params,
@@ -283,10 +303,7 @@ export interface SqliteSegmentDescriptor {
 const IMAGE_ALIAS = 'syncular_image';
 
 function imageInvalid(detail: string): never {
-  throw new ClientSyncError(
-    'sync.invalid_request',
-    `sqlite segment rejected: ${detail} (§5.3)`,
-  );
+  throw invalidRequest(`sqlite segment rejected: ${detail} (§5.3)`);
 }
 
 /**
@@ -313,8 +330,7 @@ export async function applySqliteSegment(
 ): Promise<number> {
   const withImage = db.withSqliteImage?.bind(db);
   if (withImage === undefined) {
-    throw new ClientSyncError(
-      'sync.invalid_request',
+    throw invalidRequest(
       'received a sqlite segment but the database backend cannot import images (§4.2: do not advertise accept bit 2)',
     );
   }
@@ -422,6 +438,23 @@ export async function applySqliteSegment(
           params,
         );
         applied += Number(db.query('SELECT changes() AS n')[0]?.n ?? 0);
+        for (const row of db.query(
+          `SELECT * FROM ${source} WHERE ${predicates.join(' AND ') || 'true'}`,
+          params,
+        )) {
+          retainedBaseWrite(
+            db,
+            table.name,
+            String(row[table.primaryKey]),
+            Object.fromEntries(
+              table.columns.map((column) => [
+                column.name,
+                rowValueToJson(row[column.name] as RowValue),
+              ]),
+            ),
+            Number(row._syncular_version),
+          );
+        }
       });
       options.onProgress?.(applied);
       await yieldToHost();