@syncular/client 0.20.1 → 0.21.1

package/package.json

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

package/src/client.ts

@@ -37,6 +37,7 @@ import {
   type SubStartFrame,
   type WakeReason,
 } from '@syncular/core';
+import { EncryptError } from '@syncular/core';
 import {
   applyCommitFrame,
   applyRowsSegment,
@@ -158,6 +159,8 @@ import {
   ensureLocalBookkeepingSchema,
   ensureLocalSyncedSchema,
   fromSqlValue,
+  coerceSqlRepresentation,
+  type JsonRowValue,
   jsonToRowValue,
   LOCAL_SCHEMA_VERSION_KEY,
   normalizeRecordKeys,
@@ -2127,11 +2130,11 @@ export class SyncClient {
 
   #recordMutations(
     mutations: readonly MutationInput[],
-    changedFieldsByIndex: readonly (readonly string[] | undefined)[] = [],
+    partial = false,
   ): string {
     this.#requireActive();
     const clientCommitId = crypto.randomUUID();
-    const operations: OutboxOperation[] = mutations.map((mutation, index) => {
+    const operations: OutboxOperation[] = mutations.map((mutation) => {
       const table = this.#table(mutation.table);
       if (mutation.op === 'delete') {
         return {
@@ -2143,6 +2146,55 @@ export class SyncClient {
             : {}),
         };
       }
+      if (partial) {
+        // §6.7 patch: the values map IS the presence set — the primary key
+        // plus the supplied non-scope columns. Absent columns keep their
+        // stored value; the overlay and the server both apply only the
+        // present ones.
+        const normalized = normalizeRecordKeys(table, mutation.values);
+        const scopeColumns = new Set(table.scopeColumnByVariable.values());
+        const json: Record<string, JsonRowValue> = {};
+        for (const column of table.columns) {
+          if (!normalized.has(column.name)) continue;
+          if (scopeColumns.has(column.name)) {
+            throw new ClientSyncError(
+              'sync.invalid_request',
+              `table ${table.name}: patch cannot write scope column ${JSON.stringify(column.name)} (§3.4)`,
+            );
+          }
+          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)`,
+              );
+            }
+            json[column.name] = null;
+            continue;
+          }
+          json[column.name] = rowValueToJson(
+            coerceSqlRepresentation(column, value) as RowValue,
+          );
+        }
+        const pkColumn = table.columns[table.primaryKeyIndex] as RowColumn;
+        const pkValue = json[pkColumn.name];
+        if (typeof pkValue !== 'string' || pkValue.length === 0) {
+          throw new ClientSyncError(
+            'sync.invalid_request',
+            `table ${table.name}: upsert requires a non-empty string primary key`,
+          );
+        }
+        return {
+          table: mutation.table,
+          rowId: pkValue,
+          op: 'upsert',
+          ...(mutation.baseVersion !== undefined
+            ? { baseVersion: mutation.baseVersion }
+            : {}),
+          values: json,
+        };
+      }
       const values = recordToRowValues(table, mutation.values);
       const pkValue = values[table.primaryKeyIndex];
       if (typeof pkValue !== 'string' || pkValue.length === 0) {
@@ -2163,9 +2215,6 @@ export class SyncClient {
           ? { baseVersion: mutation.baseVersion }
           : {}),
         values: json,
-        ...(changedFieldsByIndex[index] !== undefined
-          ? { changedFields: [...(changedFieldsByIndex[index] ?? [])] }
-          : {}),
       };
     });
     this.#applyBatch((batch) => {
@@ -2218,12 +2267,12 @@ export class SyncClient {
   }
 
   /**
-   * Partial-update convenience over the §6.1 full-row wire: read the
-   * current LOCAL row, merge `partial` over it, and record one full-row
-   * upsert through `mutate()`. `partial` keys follow the same two-casing
-   * rule as mutation values (snake_case or camelCase). The row must be
-   * locally present (subscribed/windowed-in); patching an absent row is
-   * an error — there is no base to merge into.
+   * Partial update over the §6.1 sparse wire: record one upsert whose
+   * presence set is the primary key plus the supplied non-scope columns.
+   * `partial` keys follow the same two-casing rule as mutation values
+   * (snake_case or camelCase). Absent columns keep their stored value on
+   * the server and in the local overlay; when the local row is absent the
+   * overlay leaves it absent (§7.1) and the server answers per §5.2.
    */
   patch(
     table: string,
@@ -2234,37 +2283,29 @@ export class SyncClient {
     this.#requireActive();
     const compiled = this.#table(table);
     const pkColumn = compiled.columns[compiled.primaryKeyIndex] as RowColumn;
-    const rows = this.#db.query(
-      `SELECT * FROM ${quoteIdent(compiled.name)} WHERE ${quoteIdent(pkColumn.name)} = ?`,
-      [rowId],
-    );
-    const row = rows[0];
-    if (row === undefined) {
+    const normalized = normalizeRecordKeys(compiled, partial);
+    const pkOverride = normalized.get(pkColumn.name);
+    if (pkOverride !== undefined && pkOverride !== rowId) {
       throw new ClientSyncError(
         'sync.invalid_request',
-        `table ${compiled.name}: no local row with primary key ${JSON.stringify(rowId)} to patch`,
+        `table ${compiled.name}: patch cannot change the primary key`,
       );
     }
-    const record: Record<string, unknown> = {};
-    for (const column of compiled.columns as readonly RowColumn[]) {
-      record[column.name] = fromSqlValue(column, row[column.name] ?? null);
-    }
-    const normalizedPartial = normalizeRecordKeys(compiled, partial);
-    for (const [name, value] of normalizedPartial) {
-      record[name] = value;
-    }
     return this.#recordMutations(
       [
         {
           table,
           op: 'upsert',
-          values: record,
+          values: {
+            ...Object.fromEntries(normalized),
+            [pkColumn.name]: rowId,
+          },
           ...(options?.baseVersion !== undefined
             ? { baseVersion: options.baseVersion }
             : {}),
         },
       ],
-      [[...normalizedPartial.keys()].sort()],
+      true,
     );
   }
 
@@ -2598,8 +2639,27 @@ export class SyncClient {
       try {
         pushFrames.push(
           // §5.11: encrypted columns are encrypted at this encode-at-send
-          // seam before the row codec serializes them.
-          await encodeOutboxCommit(this.#schema, commit, this.#encryption),
+          // seam before the row codec serializes them. The stored local row
+          // supplies an ABSENT key-id selector (§6.1 presence set first,
+          // stored row second); an unresolvable key becomes a durable
+          // rejection for that commit, never a sync() throw.
+          await encodeOutboxCommit(
+            this.#schema,
+            commit,
+            this.#encryption,
+            (table, rowId) => {
+              const selector = this.#encryption?.keyIdColumns?.[table.name];
+              if (selector === undefined) return undefined;
+              const row = this.#db.query(
+                `SELECT ${quoteIdent(selector)} AS value FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`,
+                [rowId],
+              )[0];
+              const value = row?.value;
+              return typeof value === 'string' && value.length > 0
+                ? value
+                : undefined;
+            },
+          ),
         );
         outbox.push(commit);
         ops += commit.operations.length;
@@ -2608,6 +2668,10 @@ export class SyncClient {
           this.#dropIncompatibleCommit(commit, error.message);
           continue;
         }
+        if (error instanceof EncryptError) {
+          this.#dropIncompatibleCommit(commit, error.message, error.code);
+          continue;
+        }
         throw error;
       }
     }
@@ -2618,14 +2682,19 @@ export class SyncClient {
    * §7.4.4: drop a commit that cannot re-encode after a bump, mirroring the
    * §7.2 `rejected` surface — the commit leaves the outbox, its
    * purely-optimistic rows are undone, and a rejection record is raised.
+   * §5.11: the same drop carries an encode-seam `client.encrypt_failed`.
    */
-  #dropIncompatibleCommit(commit: OutboxCommit, message: string): void {
+  #dropIncompatibleCommit(
+    commit: OutboxCommit,
+    message: string,
+    code: string = OUTBOX_INCOMPATIBLE_CODE,
+  ): void {
     this.#applyBatch((batch) => {
       this.#rollbackFailedCommit(commit, batch);
       const rejection: RejectionRecord = {
         clientCommitId: commit.clientCommitId,
         opIndex: 0,
-        code: OUTBOX_INCOMPATIBLE_CODE,
+        code,
         message,
         retryable: false,
         ...(commit.operations[0] !== undefined
@@ -3735,6 +3804,10 @@ export class SyncClient {
           message: result.message,
           serverVersion: result.serverVersion,
           serverRow: this.#decodeServerRow(operation?.table, result.serverRow),
+          conflictColumns: this.#decodeConflictColumns(
+            operation?.table,
+            result.conflictColumns,
+          ),
           ...(operation !== undefined ? { operation } : {}),
         };
         this.#conflicts.push(conflict);
@@ -3804,6 +3877,26 @@ export class SyncClient {
     return record;
   }
 
+  /**
+   * §6.3 `conflictColumns`: decode the presence-layout bitmap into the names
+   * of the present columns whose `column_version` exceeded `baseVersion`. A
+   * custom merge recomputes exactly these columns (§6.5).
+   */
+  #decodeConflictColumns(
+    tableName: string | undefined,
+    bitmap: Uint8Array,
+  ): readonly string[] {
+    if (tableName === undefined) return [];
+    const table = this.#schema.tables.get(tableName);
+    if (table === undefined) return [];
+    const names: string[] = [];
+    table.columns.forEach((column, index) => {
+      const byte = bitmap[index >> 3] ?? 0;
+      if (((byte >> (index & 7)) & 1) === 1) names.push(column.name);
+    });
+    return names;
+  }
+
   async #applyCommit(
     frame: CommitFrame,
     summary: MutableSummary,
@@ -4318,9 +4411,26 @@ export class SyncClient {
         deleteLocalRow(this.#db, table, op.rowId);
         continue;
       }
+      // §7.1 overlay: apply the operation's PRESENT columns over the current
+      // local row. A partial operation over an absent local row leaves it
+      // absent — the server answers it with sync.row_deleted or
+      // sync.row_missing, and the local mirror never invents a base.
+      const opValues = op.values ?? {};
+      const full = table.columns.every((column) => column.name in opValues);
+      const local = this.#db.query(
+        `SELECT * FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`,
+        [op.rowId],
+      )[0];
+      if (local === undefined && !full) {
+        if (batch !== undefined && !precise) batch.table(op.table);
+        continue;
+      }
       const values = table.columns.map((column) => {
-        const value = op.values?.[column.name];
-        return value === undefined ? null : jsonToRowValue(value);
+        const value = opValues[column.name];
+        if (value !== undefined) return jsonToRowValue(value);
+        return local === undefined
+          ? null
+          : fromSqlValue(column, local[column.name] ?? null);
       });
       // Record the row's scope keys from its scope columns (I2 refinement).
       if (batch !== undefined) {
@@ -4335,12 +4445,10 @@ export class SyncClient {
         }
         if (!precise) batch.table(table.name);
       }
-      const existing = this.#db.query(
-        `SELECT ${quoteIdent(SYNC_VERSION_COLUMN)} AS v FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(table.primaryKey)} = ?`,
-        [op.rowId],
-      )[0];
       const version =
-        existing === undefined ? OPTIMISTIC_VERSION : (existing.v as number);
+        local === undefined
+          ? OPTIMISTIC_VERSION
+          : (local[SYNC_VERSION_COLUMN] as number);
       upsertLocalRow(this.#db, table, values, version);
     }
   }

package/src/encryption.ts

@@ -12,6 +12,7 @@ import {
   type DeclaredType,
   DecryptError,
   decryptValue,
+  EncryptError,
   encryptValue,
   KEY_LENGTH,
   type NonceSource,
@@ -99,7 +100,7 @@ function encryptionKeyId(
   if (config.keyIdFor !== undefined) {
     const selected = config.keyIdFor(table.name, rowId, values);
     if (selected.length === 0) {
-      throw new DecryptError(
+      throw new EncryptError(
         `empty encryption key id selected for table ${JSON.stringify(table.name)}`,
       );
     }
@@ -111,18 +112,18 @@ function encryptionKeyId(
     (column) => column.name === selectorColumn,
   );
   if (index < 0) {
-    throw new DecryptError(
+    throw new EncryptError(
       `encryption key-id column ${JSON.stringify(selectorColumn)} is not present on table ${JSON.stringify(table.name)}`,
     );
   }
   if (table.columns[index]?.encrypted === true) {
-    throw new DecryptError(
+    throw new EncryptError(
       `encryption key-id column ${JSON.stringify(selectorColumn)} on table ${JSON.stringify(table.name)} must not be encrypted`,
     );
   }
   const selected = values[index];
   if (typeof selected !== 'string' || selected.length === 0) {
-    throw new DecryptError(
+    throw new EncryptError(
       `encryption key-id column ${JSON.stringify(selectorColumn)} on table ${JSON.stringify(table.name)} must contain a non-empty string`,
     );
   }
@@ -142,15 +143,45 @@ function declaredTypeOf(column: RowColumn): DeclaredType {
  * value becomes the §5.11 ciphertext-envelope `bytes`. NULLs pass through
  * unencrypted (§5.11).
  */
-export async function encryptRowValues(
+export async function encryptRowValues<T extends RowValue | undefined>(
   config: EncryptionConfig,
   table: CompiledClientTable,
   rowId: string,
-  values: readonly RowValue[],
-): Promise<RowValue[]> {
+  values: readonly T[],
+  storedKeyId?: string,
+): Promise<T[]> {
   if (!table.hasEncryptedColumns) return values.slice();
   const out = values.slice();
-  const keyId = encryptionKeyId(config, table, rowId, values);
+  // Sparse semantics: absent (undefined) and NULL columns are never
+  // re-encrypted, so a patch that presents no encrypted value needs no key.
+  let hasPresentEncrypted = false;
+  for (let i = 0; i < table.columns.length; i++) {
+    if (table.columns[i]?.encrypted !== true) continue;
+    const value = out[i];
+    if (value !== undefined && value !== null) {
+      hasPresentEncrypted = true;
+      break;
+    }
+  }
+  if (!hasPresentEncrypted) return out;
+  // Key selection reads the presence set first, then the stored local row.
+  // Absent slots densify to null for selection only; the loop below still
+  // leaves them untouched. Absent ≠ NULL (§6.1): only an ABSENT selector
+  // slot is filled from the stored row, never a present NULL.
+  const selected: RowValue[] = values.map((value) => value ?? null);
+  const selectorColumn = config.keyIdColumns?.[table.name];
+  if (
+    selectorColumn !== undefined &&
+    config.keyIdFor === undefined &&
+    storedKeyId !== undefined
+  ) {
+    const index = table.columns.findIndex(
+      (column) => column.name === selectorColumn,
+    );
+    if (index >= 0 && values[index] === undefined)
+      selected[index] = storedKeyId;
+  }
+  const keyId = encryptionKeyId(config, table, rowId, selected);
   for (let i = 0; i < table.columns.length; i++) {
     const column = table.columns[i];
     if (column === undefined || !column.encrypted) continue;
@@ -158,17 +189,17 @@ export async function encryptRowValues(
     if (value === null || value === undefined) continue; // NULL stays NULL
     const key = config.keyProvider(keyId);
     if (key === undefined) {
-      throw new DecryptError(
+      throw new EncryptError(
         `no encryption key for keyId ${JSON.stringify(keyId)} (table ${table.name})`,
       );
     }
-    out[i] = await encryptValue(
+    out[i] = (await encryptValue(
       declaredTypeOf(column),
       value as PlainValue,
       keyId,
       key,
       config.nonceSource,
-    );
+    )) as T;
   }
   return out;
 }

package/src/outbox.ts

@@ -6,10 +6,11 @@
  * upgrade to N+1 by re-encoding.
  */
 import {
-  encodeRow,
+  encodeSparseRow,
   type PushCommitFrame,
   type PushOperation,
   type ScopeMap,
+  type SparseRowValue,
 } from '@syncular/core';
 import type { ClientDatabase, SqlRow } from './database';
 import type { EncryptionConfig } from './encryption';
@@ -27,13 +28,13 @@ export interface OutboxOperation {
   readonly op: 'upsert' | 'delete';
   /** Optimistic-concurrency token (§6.2); absent = last-write-wins. */
   readonly baseVersion?: number;
-  /** Full-row values keyed by column name; present iff `op` is `upsert`. */
-  readonly values?: Readonly<Record<string, JsonRowValue>>;
   /**
-   * Local-only normalized columns intentionally supplied to `patch()`.
-   * Absent for full-row mutate/upsert because intent is then unknown.
+   * The PRESENT columns keyed by column name; present iff `op` is `upsert`.
+   * A key the operation writes carries its value; a column the operation
+   * leaves unchanged has no key (§6.1 sparse rows, §7.2.1: intent is the
+   * presence set — `mutate` marks every column, `patch` the supplied ones).
    */
-  readonly changedFields?: readonly string[];
+  readonly values?: Readonly<Record<string, JsonRowValue>>;
 }
 
 export interface OutboxCommit {
@@ -212,10 +213,10 @@ export class OutboxEncodeError extends ClientSyncError {
   }
 }
 
-function orderedValues(
+function sparseValues(
   table: CompiledClientTable,
   values: Readonly<Record<string, JsonRowValue>>,
-) {
+): SparseRowValue[] {
   // Any persisted key that is not a column of the CURRENT schema means the
   // bump removed (or renamed) it — the commit cannot be expressed now.
   for (const key of Object.keys(values)) {
@@ -227,8 +228,7 @@ function orderedValues(
   }
   return table.columns.map((column) => {
     const value = values[column.name];
-    if (value === undefined) return null;
-    return jsonToRowValue(value);
+    return value === undefined ? undefined : jsonToRowValue(value);
   });
 }
 
@@ -237,12 +237,17 @@ function orderedValues(
  * schema's row codec (§6.1). When `encryption` is configured, encrypted
  * columns (§5.11) are encrypted here — the encode-at-send seam — before the
  * row codec serializes them as ciphertext-envelope `bytes`. Async because
- * WebCrypto is async.
+ * WebCrypto is async. `storedKeyIdFor` supplies the stored local row's
+ * key-id selector for a sparse upsert that omits that column (§5.11).
  */
 export async function encodeOutboxCommit(
   schema: CompiledClientSchema,
   commit: OutboxCommit,
   encryption?: EncryptionConfig,
+  storedKeyIdFor?: (
+    table: CompiledClientTable,
+    rowId: string,
+  ) => string | undefined,
 ): Promise<PushCommitFrame> {
   const operations: PushOperation[] = [];
   for (const op of commit.operations) {
@@ -270,18 +275,24 @@ export async function encodeOutboxCommit(
         `outbox upsert on ${op.table}/${op.rowId} has no values`,
       );
     }
-    let values = orderedValues(table, op.values);
+    let values = sparseValues(table, op.values);
     if (encryption !== undefined && table.hasEncryptedColumns) {
       // Lazy: opt-in E2EE never enters an encryption-free app's bundle.
       const { encryptRowValues } = await import('./encryption');
-      values = await encryptRowValues(encryption, table, op.rowId, values);
+      values = await encryptRowValues(
+        encryption,
+        table,
+        op.rowId,
+        values,
+        storedKeyIdFor?.(table, op.rowId),
+      );
     }
     operations.push({
       table: op.table,
       rowId: op.rowId,
       op: 'upsert',
       ...(op.baseVersion !== undefined ? { baseVersion: op.baseVersion } : {}),
-      payload: encodeRow(table.columns, values),
+      payload: encodeSparseRow(table.columns, table.primaryKeyIndex, values),
     });
   }
   return {

package/src/outcomes.ts

@@ -22,6 +22,12 @@ export interface ConflictRecord {
   readonly serverVersion: number;
   /** The current server row, decoded — resolve without a round-trip. */
   readonly serverRow: Readonly<Record<string, RowValue>>;
+  /**
+   * §6.3: the present columns whose `column_version` exceeded the losing
+   * operation's `baseVersion`. A custom merge recomputes exactly these;
+   * keep-server and keep-local ignore them (§6.5).
+   */
+  readonly conflictColumns: readonly string[];
   /** The losing local operation (absent only for malformed op indexes). */
   readonly operation?: OutboxOperation;
 }
@@ -94,8 +100,13 @@ export interface ResolveCommitOutcomeInput {
   readonly replacementClientCommitId?: string;
 }
 
-interface StoredConflictRecord extends Omit<ConflictRecord, 'serverRow'> {
+interface StoredConflictRecord extends Omit<
+  ConflictRecord,
+  'serverRow' | 'conflictColumns'
+> {
   readonly serverRow: Readonly<Record<string, JsonRowValue>>;
+  /** Absent in journal entries written before wire version 3. */
+  readonly conflictColumns?: readonly string[];
 }
 
 type StoredCommitOperationOutcome =
@@ -130,6 +141,8 @@ function decodeResults(raw: string): CommitOperationOutcome[] {
       status: 'conflict',
       conflict: {
         ...result.conflict,
+        // Pre-column-version journal entries carry no conflictColumns.
+        conflictColumns: result.conflict.conflictColumns ?? [],
         serverRow: Object.fromEntries(
           Object.entries(result.conflict.serverRow).map(([key, value]) => [
             key,

package/src/remote.ts

@@ -9,7 +9,8 @@ import {
   encodeMessage,
   encodeRemoteOperationRequest,
   encodeRemoteOperationRealtimeMessage,
-  encodeRow,
+  encodeSparseRow,
+  PROTOCOL_WIRE_VERSION,
   type PushOperation,
   type PushOperationResult,
   type PushResultDetailsFrame,
@@ -204,7 +205,8 @@ export class SyncRemoteClient {
     }
   >();
   readonly #encryption: EncryptionConfig | undefined;
-  readonly #logEpoch: string | undefined;
+  /** Pinned by config, or acquired on the first prepared commit (§2.1). */
+  #logEpoch: string | undefined;
 
   constructor(config: SyncRemoteClientConfig) {
     if (config.clientId.length === 0) {
@@ -242,6 +244,53 @@ export class SyncRemoteClient {
         'a remote commit must carry at least one mutation (§6.1)',
       );
     }
+    let logEpoch = this.#logEpoch;
+    if (logEpoch === undefined) {
+      // §2.1: a push round binds to the partition log epoch; an acquisition
+      // round carries no push commits.
+      if (this.#transport === undefined) {
+        throw new ClientSyncError(
+          'client.remote_sync_unconfigured',
+          'SyncRemoteClient has no sync transport for ordinary commits',
+        );
+      }
+      const acquisition = decodeMessage(
+        await this.#transport(
+          encodeMessage({
+            wireVersion: PROTOCOL_WIRE_VERSION,
+            msgKind: 'request',
+            frames: [
+              {
+                type: 'REQ_HEADER',
+                clientId: this.#clientId,
+                schemaVersion: schema.version,
+              },
+              // A pull that asks for nothing: the round exists for its epoch.
+              {
+                type: 'PULL_HEADER',
+                limitCommits: 0,
+                limitSnapshotRows: 0,
+                maxSnapshotPages: 0,
+                accept: 0b0011,
+              },
+            ],
+          }),
+        ),
+      );
+      const acquisitionHeader = acquisition.frames[0];
+      if (
+        acquisition.msgKind !== 'response' ||
+        acquisitionHeader?.type !== 'RESP_HEADER' ||
+        acquisitionHeader.logEpoch === undefined
+      ) {
+        throw new ClientSyncError(
+          'client.invalid_host_response',
+          'remote epoch acquisition returned an invalid response',
+        );
+      }
+      logEpoch = acquisitionHeader.logEpoch;
+      this.#logEpoch = logEpoch;
+    }
     const operations: PushOperation[] = [];
     for (const mutation of input.mutations) {
       const table = schema.tables.get(mutation.table);
@@ -277,22 +326,20 @@ export class SyncRemoteClient {
         ...(mutation.baseVersion !== undefined
           ? { baseVersion: mutation.baseVersion }
           : {}),
-        payload: encodeRow(table.columns, values),
+        payload: encodeSparseRow(table.columns, table.primaryKeyIndex, values),
       });
     }
     return {
       requestId: input.requestId,
       bytes: encodeMessage({
-        wireVersion: this.#logEpoch === undefined ? 1 : 2,
+        wireVersion: PROTOCOL_WIRE_VERSION,
         msgKind: 'request',
         frames: [
           {
             type: 'REQ_HEADER',
             clientId: this.#clientId,
             schemaVersion: schema.version,
-            ...(this.#logEpoch !== undefined
-              ? { logEpoch: this.#logEpoch }
-              : {}),
+            logEpoch,
           },
           {
             type: 'PUSH_COMMIT',