@syncular/server 0.15.48 → 0.17.0

package/src/operations.ts

@@ -1,3 +1,7 @@
+import {
+  type AuthoritativeRelationPlan,
+  validateAuthoritativeRelationPlan,
+} from './authoritative-query';
 import {
   decodeRow,
   decodeRemoteOperationRequest,
@@ -42,6 +46,7 @@ export interface AuthoritativeQueryDescriptor<Params = undefined> {
   readonly hasParams: boolean;
   readonly sql: string;
   readonly tables: readonly string[];
+  readonly relationPlans: readonly AuthoritativeRelationPlan[];
   readonly resultColumns: readonly {
     readonly name: string;
     readonly type:
@@ -280,6 +285,9 @@ export function registerRemoteQuery<Params>(
   options: RemoteQueryOptions<Params>,
 ): RegisteredRemoteQuery {
   if (
+    !Array.isArray(descriptor.relationPlans) ||
+    !descriptor.relationPlans.some((plan) => plan.sql === descriptor.sql) ||
+    descriptor.relationPlans.some((plan) => !Array.isArray(plan.relations)) ||
     descriptor.id.length === 0 ||
     new Set(descriptor.tables).size !== descriptor.tables.length ||
     !Array.isArray(descriptor.resultColumns) ||
@@ -288,9 +296,12 @@ export function registerRemoteQuery<Params>(
       descriptor.resultColumns.length
   ) {
     throw new Error(
-      'remote query requires a non-empty id and unique tables and result columns',
+      'remote query requires generated relation plans, a non-empty id, and unique tables and result columns; regenerate queries',
     );
   }
+  for (const plan of descriptor.relationPlans) {
+    validateAuthoritativeRelationPlan(plan, descriptor.tables);
+  }
   if (
     !Number.isSafeInteger(options.maxRows) ||
     options.maxRows < 1 ||
@@ -394,12 +405,29 @@ export function registerRemoteQuery<Params>(
           'configured storage does not implement authoritative queries',
         );
       }
-      await ctx.storage.ensureSchema(schema);
       const selectedSql = descriptor.sqlFor?.(params) ?? descriptor.sql;
+      const plan = descriptor.relationPlans.find(
+        (candidate) => candidate.sql === selectedSql,
+      );
+      if (plan === undefined) {
+        throw syncError(
+          'operation.invalid_request',
+          'selected SQL has no generated relation plan; regenerate queries',
+        );
+      }
+      await ctx.storage.ensureSchema(schema);
+      const prefix = 'SELECT * FROM (';
       let result;
       try {
         result = await ctx.storage.queryAuthoritative(ctx.partition, {
-          sql: `SELECT * FROM (${selectedSql}) AS "_syncular_registered_query" LIMIT ?`,
+          plan: {
+            sql: `${prefix}${selectedSql}) AS "_syncular_registered_query" LIMIT ?`,
+            relations: plan.relations.map((relation) => ({
+              ...relation,
+              start: relation.start + prefix.length,
+              end: relation.end + prefix.length,
+            })),
+          },
           params: [...descriptor.bind(params), options.maxRows + 1],
           tables: descriptor.tables,
         });

package/src/postgres-storage.ts

@@ -1,3 +1,6 @@
+import { validateCommitPruneQuery } from './prune';
+import { StorageQueryError } from './storage-errors';
+import type { CommitPruneQuery, CommitPruneResult } from './storage';
 /**
  * Postgres server storage: the production database path.
  *
@@ -223,6 +226,28 @@ interface SerializedResult {
   details?: import('@syncular/core').RejectionDetails;
 }
 
+async function lockPartitionOn(
+  client: PgQueryable,
+  partition: string,
+): Promise<void> {
+  const locked = await client.query(
+    'SELECT max_commit_seq FROM sync_partitions WHERE partition=$1 FOR UPDATE',
+    [partition],
+  );
+  if (locked.rows.length > 0) return;
+  // The first writer initializes the partition. Concurrent initializers may
+  // wait on this insert, so acquire the row lock again before applying writes.
+  await client.query(
+    `INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 0)
+    ON CONFLICT (partition) DO NOTHING`,
+    [partition],
+  );
+  await client.query(
+    'SELECT max_commit_seq FROM sync_partitions WHERE partition=$1 FOR UPDATE',
+    [partition],
+  );
+}
+
 function toBase64(bytes: Uint8Array): string {
   return Buffer.from(bytes).toString('base64');
 }
@@ -649,15 +674,7 @@ class PostgresTransaction implements StorageTransaction {
 
   async lockPartitionForPush(): Promise<void> {
     this.#assertOpen();
-    await this.#client.query(
-      `INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 0)
-       ON CONFLICT (partition) DO NOTHING`,
-      [this.#partition],
-    );
-    await this.#client.query(
-      'SELECT max_commit_seq FROM sync_partitions WHERE partition=$1 FOR UPDATE',
-      [this.#partition],
-    );
+    await lockPartitionOn(this.#client, this.#partition);
     await this.#client.query('SAVEPOINT syncular_push_candidate');
     this.#pushApplySavepoint = true;
   }
@@ -743,32 +760,40 @@ class PostgresTransaction implements StorageTransaction {
     // Allocate the next dense commitSeq under a per-partition row lock: the
     // UPDATE … RETURNING serializes concurrent pushes to this partition and
     // never leaves a gap on rollback (see the file header).
-    const { rows } = await q.query<{ max_commit_seq: unknown }>(
-      `INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 1)
-       ON CONFLICT (partition) DO UPDATE
-         SET max_commit_seq = sync_partitions.max_commit_seq + 1
-       RETURNING max_commit_seq`,
-      [p],
-    );
-    const commitSeq = asNumber(rows[0]?.max_commit_seq);
-    await q.query(
-      `INSERT INTO sync_commits(partition, commit_seq, client_id, client_commit_id, actor_id, created_at_ms)
-       VALUES ($1,$2,$3,$4,$5,$6)`,
+    const { rows } = await q.query<{ commit_seq: unknown }>(
+      `WITH allocated AS (
+         INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 1)
+         ON CONFLICT (partition) DO UPDATE
+           SET max_commit_seq = sync_partitions.max_commit_seq + 1
+         RETURNING max_commit_seq
+       )
+       INSERT INTO sync_commits(partition, commit_seq, client_id, client_commit_id, actor_id, created_at_ms)
+       SELECT $1, max_commit_seq, $2, $3, $4, $5 FROM allocated
+       RETURNING commit_seq`,
       [
         p,
-        commitSeq,
         commit.clientId,
         commit.clientCommitId,
         commit.actorId,
         commit.createdAtMs,
       ],
     );
+    const commitSeq = asNumber(rows[0]?.commit_seq);
     for (let idx = 0; idx < commit.changes.length; idx++) {
       const change = commit.changes[idx];
       if (change === undefined) continue;
+      // Bind serialized scopes as text before parsing JSONB. Drivers that
+      // encode JSONB parameters would otherwise store this string as a scalar.
       await q.query(
-        `INSERT INTO sync_changes(partition, commit_seq, idx, tbl, row_id, op, row_version, scopes, payload)
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`,
+        `WITH inserted AS (
+           INSERT INTO sync_changes(partition, commit_seq, idx, tbl, row_id, op, row_version, scopes, payload)
+           VALUES ($1,$2,$3,$4,$5,$6,$7,$8::text::jsonb,$9)
+           RETURNING partition, tbl, commit_seq, scopes
+         )
+         INSERT INTO sync_change_scopes(partition, tbl, var, value, commit_seq)
+         SELECT inserted.partition, inserted.tbl, scope.key, scope.value, inserted.commit_seq
+         FROM inserted CROSS JOIN LATERAL jsonb_each_text(inserted.scopes) AS scope
+         ON CONFLICT DO NOTHING`,
         [
           p,
           commitSeq,
@@ -781,13 +806,6 @@ class PostgresTransaction implements StorageTransaction {
           change.payload ?? null,
         ],
       );
-      for (const [variable, value] of Object.entries(change.scopes)) {
-        await q.query(
-          `INSERT INTO sync_change_scopes(partition, tbl, var, value, commit_seq)
-           VALUES ($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING`,
-          [p, change.table, variable, value, commitSeq],
-        );
-      }
     }
     return commitSeq;
   }
@@ -976,6 +994,9 @@ export class PostgresServerStorage implements ServerStorage {
           await client.query('DELETE FROM sync_row_scopes WHERE tbl=$1', [
             tableName,
           ]);
+          await client.query('DELETE FROM sync_blob_refs WHERE tbl=$1', [
+            tableName,
+          ]);
           await client.query(dropTableDdl(tableName));
         }
         for (const statement of schemaDdl(
@@ -1047,6 +1068,7 @@ export class PostgresServerStorage implements ServerStorage {
   ): Promise<PartitionRegistryEntry> {
     if (logEpoch.length === 0) throw new Error('log epoch must be non-empty');
     await this.#exec.transaction(async (client) => {
+      await lockPartitionOn(client, partition);
       await client.query(
         `INSERT INTO sync_partition_registry(
            partition, log_epoch, epoch_required, last_authenticated_at_ms
@@ -1148,7 +1170,7 @@ export class PostgresServerStorage implements ServerStorage {
     }
     const prepared = bindAuthoritativePartition(
       prepareAuthoritativeQuery(
-        query.sql,
+        query.plan,
         query.params,
         query.tables,
         this.#tables,
@@ -1177,6 +1199,14 @@ export class PostgresServerStorage implements ServerStorage {
     });
   }
 
+  async getPartitionLogEpoch(partition: string): Promise<string | undefined> {
+    const { rows } = await this.#exec.query<{ log_epoch: string }>(
+      'SELECT log_epoch FROM sync_partition_registry WHERE partition=$1',
+      [partition],
+    );
+    return rows[0]?.log_epoch;
+  }
+
   async getHorizonSeq(partition: string): Promise<number> {
     const { rows } = await this.#exec.query<{ horizon_seq: unknown }>(
       'SELECT horizon_seq FROM sync_partitions WHERE partition=$1',
@@ -1188,25 +1218,52 @@ export class PostgresServerStorage implements ServerStorage {
   async setHorizonSeq(partition: string, seq: number): Promise<void> {
     await this.#exec.query(
       `INSERT INTO sync_partitions(partition, horizon_seq) VALUES ($1,$2)
-       ON CONFLICT (partition) DO UPDATE SET horizon_seq=EXCLUDED.horizon_seq`,
+       ON CONFLICT (partition) DO UPDATE SET horizon_seq=GREATEST(sync_partitions.horizon_seq,EXCLUDED.horizon_seq)`,
       [partition, seq],
     );
   }
 
-  async pruneCommitsThrough(partition: string, seq: number): Promise<number> {
-    const removed = await this.#exec.query(
-      'DELETE FROM sync_commits WHERE partition=$1 AND commit_seq<=$2',
-      [partition, seq],
-    );
-    await this.#exec.query(
-      'DELETE FROM sync_changes WHERE partition=$1 AND commit_seq<=$2',
-      [partition, seq],
-    );
-    await this.#exec.query(
-      'DELETE FROM sync_change_scopes WHERE partition=$1 AND commit_seq<=$2',
-      [partition, seq],
-    );
-    return removed.rowCount;
+  async pruneCommitsThrough(
+    partition: string,
+    query: CommitPruneQuery,
+  ): Promise<CommitPruneResult> {
+    validateCommitPruneQuery(query);
+    return this.#exec.transaction(async (client) => {
+      await lockPartitionOn(client, partition);
+      const epoch = await client.query<{ log_epoch: string }>(
+        'SELECT log_epoch FROM sync_partition_registry WHERE partition=$1 FOR UPDATE',
+        [partition],
+      );
+      if (epoch.rows[0]?.log_epoch !== query.logEpoch)
+        throw new StorageQueryError('sync.storage.prune_epoch_mismatch');
+      const previous = await client.query<{ horizon_seq: unknown }>(
+        'SELECT horizon_seq FROM sync_partitions WHERE partition=$1',
+        [partition],
+      );
+      const previousHorizonSeq = asNumber(previous.rows[0]?.horizon_seq);
+      const horizonSeq = Math.max(previousHorizonSeq, query.throughSeq);
+      await client.query(
+        'UPDATE sync_partitions SET horizon_seq=$2 WHERE partition=$1',
+        [partition, horizonSeq],
+      );
+      const removed = await client.query(
+        'DELETE FROM sync_commits WHERE partition=$1 AND commit_seq<=$2',
+        [partition, horizonSeq],
+      );
+      await client.query(
+        'DELETE FROM sync_changes WHERE partition=$1 AND commit_seq<=$2',
+        [partition, horizonSeq],
+      );
+      await client.query(
+        'DELETE FROM sync_change_scopes WHERE partition=$1 AND commit_seq<=$2',
+        [partition, horizonSeq],
+      );
+      return {
+        previousHorizonSeq,
+        horizonSeq,
+        removedCommits: removed.rowCount,
+      };
+    });
   }
 
   async getCommitSeqBefore(
@@ -1630,6 +1687,49 @@ export class PostgresServerStorage implements ServerStorage {
     );
   }
 
+  async advanceClientCursor(
+    partition: string,
+    clientId: string,
+    actorId: string,
+    logEpoch: string,
+    cursor: number,
+    updatedAtMs: number,
+  ): Promise<void> {
+    await this.#exec.query(
+      `UPDATE sync_clients
+         SET cursor=GREATEST(cursor, $1), updated_at_ms=GREATEST(updated_at_ms, $2)
+         WHERE partition=$3 AND client_id=$4 AND actor_id=$5
+           AND EXISTS (SELECT 1 FROM sync_partition_registry
+                       WHERE partition=sync_clients.partition AND log_epoch=$6)`,
+      [cursor, updatedAtMs, partition, clientId, actorId, logEpoch],
+    );
+  }
+
+  async updateClientCursor(
+    partition: string,
+    clientId: string,
+    cursor: number,
+    updatedAtMs: number,
+  ): Promise<void> {
+    await this.#exec.query(
+      `UPDATE sync_clients
+       SET cursor=GREATEST(cursor, $3), updated_at_ms=GREATEST(updated_at_ms, $4)
+       WHERE partition=$1 AND client_id=$2`,
+      [partition, clientId, cursor, updatedAtMs],
+    );
+  }
+
+  async getActiveClientCursorFloor(
+    partition: string,
+    cutoffMs: number,
+  ): Promise<number | null> {
+    const { rows } = await this.#exec.query<{ cursor: unknown }>(
+      'SELECT MIN(cursor) AS cursor FROM sync_clients WHERE partition=$1 AND updated_at_ms>=$2',
+      [partition, cutoffMs],
+    );
+    return rows[0]!.cursor === null ? null : asNumber(rows[0]!.cursor);
+  }
+
   async listClientCursors(partition: string): Promise<ClientCursorInfo[]> {
     const { rows } = await this.#exec.query<{
       client_id: string;

package/src/prune.ts

@@ -7,7 +7,20 @@
  * least the newest `minRetainedCommits` commits are always retained.
  */
 import { emitEvent, type SyncularServerEvents } from './events';
-import type { ServerStorage } from './storage';
+import type { CommitPruneQuery, ServerStorage } from './storage';
+import { StorageQueryError } from './storage-errors';
+
+/** Shared validation for the built-in atomic pruning adapters. */
+export function validateCommitPruneQuery(query: CommitPruneQuery): void {
+  if (
+    !Number.isSafeInteger(query.throughSeq) ||
+    query.throughSeq < 0 ||
+    typeof query.logEpoch !== 'string' ||
+    query.logEpoch.length === 0
+  ) {
+    throw new StorageQueryError('sync.storage.invalid_prune_cursor');
+  }
+}
 
 export interface RetentionPolicy {
   /** Active window for laggard cursors (default 14 days). */
@@ -37,28 +50,29 @@ export interface PruneOptions {
 export async function pruneCommitLog(options: PruneOptions): Promise<number> {
   const { storage, partition, nowMs } = options;
   const policy = { ...DEFAULT_RETENTION, ...options.retention };
+  const logEpoch = await storage.getPartitionLogEpoch(partition);
+  if (logEpoch === undefined)
+    throw new StorageQueryError('sync.storage.partition_unregistered');
   const maxSeq = await storage.getMaxCommitSeq(partition);
-  const cursors = await storage.listClientCursors(partition);
-  const activeCursors = cursors
-    .filter((c) => c.updatedAtMs >= nowMs - policy.activeWindowMs)
-    .map((c) => c.cursor);
   const cursorFloor =
-    activeCursors.length > 0
-      ? Math.min(...activeCursors)
-      : Number.MAX_SAFE_INTEGER;
+    (await storage.getActiveClientCursorFloor(
+      partition,
+      nowMs - policy.activeWindowMs,
+    )) ?? Number.MAX_SAFE_INTEGER;
   const forcedSeq = await storage.getCommitSeqBefore(
     partition,
     nowMs - policy.ageForceMs,
   );
   const retainFloor = maxSeq - policy.minRetainedCommits;
   const target = Math.min(Math.max(cursorFloor, forcedSeq), retainFloor);
-  const current = await storage.getHorizonSeq(partition);
-  const horizon = Math.max(current, Math.max(0, target));
-  let removedCommits = 0;
-  if (horizon > current) {
-    await storage.setHorizonSeq(partition, horizon);
-    removedCommits = await storage.pruneCommitsThrough(partition, horizon);
-  }
+  const {
+    previousHorizonSeq: current,
+    horizonSeq: horizon,
+    removedCommits,
+  } = await storage.pruneCommitsThrough(partition, {
+    logEpoch,
+    throughSeq: Math.max(0, target),
+  });
   const events = options.events;
   if (events !== undefined) {
     emitEvent(events, {

package/src/pull.ts

@@ -17,10 +17,16 @@ import { clockOf, limitsOf } from './context';
 import type { PullSegmentSummary } from './events';
 import type { CompiledSchema, CompiledTable } from './schema';
 import { scopeDigest } from './scopes';
-import type { SegmentRecord } from './segment-store';
+import type { SegmentRecord, SegmentStore } from './segment-store';
 import { issueSegmentUrl } from './signed-url';
 import type { SqliteImageBuilder } from './sqlite-image';
-import type { StoredCommit, StoredRow } from './storage';
+import type { ServerStorage, StoredCommit, StoredRow } from './storage';
+
+// One artifact build per owning storage pair and complete immutable identity.
+const imageBuilds = new WeakMap<
+  ServerStorage,
+  WeakMap<SegmentStore, Map<string, Promise<SegmentRecord>>>
+>();
 
 /**
  * Resolve the §5.3 image builder: the host-injected one if present, else the
@@ -260,57 +266,89 @@ async function* sqliteImageSegment(
   // support floor, not a fallback (§5.3: sqlite is an *accept*, not a demand).
   const buildImage = await resolveImageBuilder(ctx);
   if (buildImage === undefined) return false;
-  // The probe rows are the snapshot's first page — keep them and scan on
-  // from the probe's cursor instead of re-reading the whole prefix (the
-  // scan is keyset-ordered by rowId, so the concatenation is exactly the
-  // rows a single full scan would return).
-  const rows: StoredRow[] = [...probe];
-  let afterRowId: string | null = probe[probe.length - 1]?.rowId ?? null;
-  for (;;) {
-    const scanned: StoredRow[] = await storage.scanRows(partition, {
-      table: plan.table.name,
-      scopeFilter: plan.effective,
-      afterRowId,
-      limit: 50_000,
-    });
-    rows.push(...scanned);
-    const last = scanned[scanned.length - 1];
-    if (scanned.length < 50_000 || last === undefined) break;
-    afterRowId = last.rowId;
+  let stores = imageBuilds.get(storage);
+  if (stores === undefined) {
+    stores = new WeakMap();
+    imageBuilds.set(storage, stores);
+  }
+  let builds = stores.get(segments);
+  if (builds === undefined) {
+    builds = new Map();
+    stores.set(segments, builds);
   }
-  const bytes = buildImage({
-    table: plan.table,
+  const identity = {
+    partition,
+    logEpoch,
+    table: plan.table.name,
     schemaVersion: schema.version,
-    asOfCommitSeq: asOf,
+    mediaType: 'sqlite' as const,
     scopeDigest: digest,
-    rows,
-  });
-  const record = await segments.put(
-    {
-      partition,
-      logEpoch,
-      table: plan.table.name,
-      schemaVersion: schema.version,
-      mediaType: 'sqlite',
-      scopeDigest: digest,
-      asOfCommitSeq: asOf,
-      rowCount: rows.length,
-      rowCursor: null,
-      nextRowCursor: null,
-    },
-    bytes,
-    now,
-  );
+    asOfCommitSeq: asOf,
+  };
+  const key = JSON.stringify(identity);
+  let building = builds.get(key);
+  let builtHere = false;
+  if (building === undefined) {
+    building = (async () => {
+      // Another request can finish while this one's eligibility probe awaits.
+      const cached = await segments.find(identity, clockOf(ctx)());
+      if (cached !== undefined) return cached;
+      builtHere = true;
+      let rowCount = 0;
+      const bytes = await buildImage({
+        table: plan.table,
+        schemaVersion: schema.version,
+        asOfCommitSeq: asOf,
+        scopeDigest: digest,
+        rowBatches: (async function* () {
+          rowCount += probe.length;
+          yield probe;
+          let afterRowId = probe[probe.length - 1]!.rowId;
+          for (;;) {
+            const rows = await storage.scanRows(partition, {
+              table: plan.table.name,
+              scopeFilter: plan.effective,
+              afterRowId,
+              limit: 5_000,
+            });
+            rowCount += rows.length;
+            yield rows;
+            const last = rows[rows.length - 1];
+            if (rows.length < 5_000 || last === undefined) break;
+            afterRowId = last.rowId;
+          }
+        })(),
+      });
+      return segments.put(
+        { ...identity, rowCount, rowCursor: null, nextRowCursor: null },
+        bytes,
+        clockOf(ctx)(),
+      );
+    })();
+    builds.set(key, building);
+  }
+  let record: SegmentRecord;
+  try {
+    record = await building;
+  } finally {
+    if (builds.get(key) === building) builds.delete(key);
+  }
   trace?.segments.push({
     mediaType: 'sqlite',
     delivery: 'ref',
-    origin: 'built',
+    origin: builtHere ? 'built' : 'reused',
     bytes: record.byteLength,
     rows: record.rowCount,
   });
   yield segmentRefFrame(
     record,
-    await signedUrlFields(ctx, limits, record.segmentId, digest, now),
+    await signedUrlFields(
+      ctx,
+      limits,
+      record.segmentId,
+      digest,
+      clockOf(ctx)(),
+    ),
   );
   return true;
 }
@@ -463,6 +501,28 @@ export async function* subscriptionSection(
 
   const token = parseBootstrapToken(sub.bootstrapState, sub.table);
 
+  let commits: StoredCommit[] = [];
+  if (
+    token === undefined &&
+    sub.cursor >= 0 &&
+    sub.cursor >= horizonSeq &&
+    sub.cursor <= maxSeq
+  ) {
+    commits = await ctx.storage.readCommitWindow(ctx.partition, {
+      table: sub.table,
+      scopeFilter: plan.effective,
+      afterSeq: sub.cursor,
+      throughSeq: maxSeq,
+      limitChanges: limits.limitCommits + 1,
+    });
+    // Validate continuity before committing to an active section. A prune
+    // during a paged read can otherwise make an incomplete window look empty.
+    horizonSeq = Math.max(
+      horizonSeq,
+      await ctx.storage.getHorizonSeq(ctx.partition),
+    );
+  }
+
   // §4.6: a cursor behind the horizon (and not resuming a bootstrap)
   // cannot compute deltas — answer `reset` and echo the cursor.
   if (token === undefined && sub.cursor >= 0 && sub.cursor < horizonSeq) {
@@ -536,13 +596,6 @@ export async function* subscriptionSection(
     effectiveScopes: plan.effective,
     bootstrap: false,
   };
-  const commits = await ctx.storage.readCommitWindow(ctx.partition, {
-    table: sub.table,
-    scopeFilter: plan.effective,
-    afterSeq: sub.cursor,
-    throughSeq: maxSeq,
-    limitChanges: limits.limitCommits + 1,
-  });
   let delivered = 0;
   let deliveredCommits = 0;
   let lastDeliveredSeq = sub.cursor;

package/src/push.ts

@@ -185,7 +185,7 @@ async function runValidator(
     return errorRecord(
       opIndex,
       'sync.constraint_violation',
-      `write validator for table ${JSON.stringify(table.name)} threw: ${error instanceof Error ? error.message : String(error)}`,
+      'write validator failed',
     );
   }
   return undefined;
@@ -220,7 +220,7 @@ async function mergeCrdtColumns(
       return errorRecord(
         opIndex,
         'sync.crdt_merge_failed',
-        `no CRDT merger registered for crdtType ${JSON.stringify(crdtType)} (§5.10.2)`,
+        'no CRDT merger registered',
       );
     }
     const storedRaw = storedValues?.[index];
@@ -228,11 +228,11 @@ async function mergeCrdtColumns(
     let merged: Uint8Array;
     try {
       merged = await merger(stored, incoming);
-    } catch (error) {
+    } catch {
       return errorRecord(
         opIndex,
         'sync.crdt_merge_failed',
-        `CRDT merger for ${JSON.stringify(crdtType)} threw: ${error instanceof Error ? error.message : String(error)}`,
+        'CRDT merger failed',
       );
     }
     values[index] = merged;
@@ -732,7 +732,7 @@ async function runCommitValidator(
     return errorRecord(
       operations[0]?.opIndex ?? 0,
       'sync.constraint_violation',
-      `whole-commit validator threw: ${error instanceof Error ? error.message : String(error)}`,
+      'whole-commit validator failed',
     );
   }
   return undefined;