@syncular/server 0.15.47 → 0.16.1

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.
  *
@@ -85,6 +88,7 @@ import type {
   IndexRowScanQuery,
   NewCommit,
   NewReaction,
+  PartitionRegistryEntry,
   PrunedReactionCounts,
   ReactionClaimQuery,
   ReactionFailure,
@@ -136,6 +140,12 @@ CREATE TABLE IF NOT EXISTS sync_partitions(
   max_commit_seq BIGINT NOT NULL DEFAULT 0,
   horizon_seq BIGINT NOT NULL DEFAULT 0
 );
+CREATE TABLE IF NOT EXISTS sync_partition_registry(
+  partition TEXT PRIMARY KEY,
+  log_epoch TEXT NOT NULL,
+  epoch_required BOOLEAN NOT NULL DEFAULT FALSE,
+  last_authenticated_at_ms BIGINT NOT NULL
+);
 CREATE TABLE IF NOT EXISTS sync_row_scopes(
   partition TEXT NOT NULL, tbl TEXT NOT NULL,
   var TEXT NOT NULL, value TEXT NOT NULL, row_id TEXT NOT NULL,
@@ -189,10 +199,13 @@ CREATE INDEX IF NOT EXISTS sync_reactions_dead_letter
   ON sync_reactions(partition, status, available_at_ms, idempotency_key);
 CREATE TABLE IF NOT EXISTS sync_clients(
   partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,
+  wire_version INTEGER NOT NULL DEFAULT 1,
   cursor BIGINT NOT NULL, subscriptions JSONB NOT NULL,
   updated_at_ms BIGINT NOT NULL,
   PRIMARY KEY(partition, client_id)
 );
+ALTER TABLE sync_clients
+  ADD COLUMN IF NOT EXISTS wire_version INTEGER NOT NULL DEFAULT 1;
 CREATE TABLE IF NOT EXISTS sync_blob_refs(
   partition TEXT NOT NULL, tbl TEXT NOT NULL, row_id TEXT NOT NULL,
   blob_id TEXT NOT NULL,
@@ -213,6 +226,21 @@ interface SerializedResult {
   details?: import('@syncular/core').RejectionDetails;
 }
 
+async function lockPartitionOn(
+  client: PgQueryable,
+  partition: string,
+): Promise<void> {
+  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');
 }
@@ -639,15 +667,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;
   }
@@ -998,6 +1018,87 @@ export class PostgresServerStorage implements ServerStorage {
     this.#schemaVersion = schema.version;
   }
 
+  async touchPartition(
+    partition: string,
+    authenticatedAtMs: number,
+    initialLogEpoch: string,
+  ): Promise<PartitionRegistryEntry> {
+    if (initialLogEpoch.length === 0) {
+      throw new Error('initial log epoch must be non-empty');
+    }
+    const { rows } = await this.#exec.query<{
+      log_epoch: string;
+      epoch_required: boolean;
+      last_authenticated_at_ms: unknown;
+    }>(
+      `INSERT INTO sync_partition_registry(
+         partition, log_epoch, last_authenticated_at_ms
+       ) VALUES ($1,$2,$3)
+       ON CONFLICT(partition) DO UPDATE SET
+         last_authenticated_at_ms=EXCLUDED.last_authenticated_at_ms
+       RETURNING log_epoch, epoch_required, last_authenticated_at_ms`,
+      [partition, initialLogEpoch, authenticatedAtMs],
+    );
+    const row = rows[0];
+    if (row === undefined)
+      throw new Error('partition registry write did not persist');
+    return {
+      partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required,
+      lastAuthenticatedAtMs: asNumber(row.last_authenticated_at_ms),
+    };
+  }
+
+  async rotatePartitionLogEpoch(
+    partition: string,
+    logEpoch: string,
+    authenticatedAtMs: number,
+  ): 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
+         ) VALUES ($1,$2,TRUE,$3)
+         ON CONFLICT(partition) DO UPDATE SET
+           log_epoch=EXCLUDED.log_epoch,
+           epoch_required=TRUE,
+           last_authenticated_at_ms=EXCLUDED.last_authenticated_at_ms`,
+        [partition, logEpoch, authenticatedAtMs],
+      );
+      await client.query('DELETE FROM sync_clients WHERE partition=$1', [
+        partition,
+      ]);
+    });
+    return {
+      partition,
+      logEpoch,
+      epochRequired: true,
+      lastAuthenticatedAtMs: authenticatedAtMs,
+    };
+  }
+
+  async listPartitionRegistry(): Promise<PartitionRegistryEntry[]> {
+    const { rows } = await this.#exec.query<{
+      partition: string;
+      log_epoch: string;
+      epoch_required: boolean;
+      last_authenticated_at_ms: unknown;
+    }>(
+      `SELECT partition, log_epoch, epoch_required, last_authenticated_at_ms
+         FROM sync_partition_registry ORDER BY partition`,
+      [],
+    );
+    return rows.map((row) => ({
+      partition: row.partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required,
+      lastAuthenticatedAtMs: asNumber(row.last_authenticated_at_ms),
+    }));
+  }
+
   /**
    * Open a real Postgres transaction. The push handler drives the returned
    * `StorageTransaction` imperatively (getRow/upsert/…/commit), but the
@@ -1058,7 +1159,7 @@ export class PostgresServerStorage implements ServerStorage {
     }
     const prepared = bindAuthoritativePartition(
       prepareAuthoritativeQuery(
-        query.sql,
+        query.plan,
         query.params,
         query.tables,
         this.#tables,
@@ -1087,6 +1188,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',
@@ -1098,25 +1207,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(
@@ -1496,11 +1632,12 @@ export class PostgresServerStorage implements ServerStorage {
     const { rows } = await this.#exec.query<{
       client_id: string;
       actor_id: string;
+      wire_version: unknown;
       cursor: unknown;
       subscriptions: unknown;
       updated_at_ms: unknown;
     }>(
-      'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 AND client_id=$2',
+      'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 AND client_id=$2',
       [partition, clientId],
     );
     const record = rows[0];
@@ -1508,6 +1645,7 @@ export class PostgresServerStorage implements ServerStorage {
     return {
       clientId: record.client_id,
       actorId: record.actor_id,
+      wireVersion: asNumber(record.wire_version),
       cursor: asNumber(record.cursor),
       updatedAtMs: asNumber(record.updated_at_ms),
       subscriptions: asJson<ClientSubscription[]>(record.subscriptions),
@@ -1519,16 +1657,18 @@ export class PostgresServerStorage implements ServerStorage {
     record: ClientRecord,
   ): Promise<void> {
     await this.#exec.query(
-      `INSERT INTO sync_clients(partition, client_id, actor_id, cursor, subscriptions, updated_at_ms)
-       VALUES ($1,$2,$3,$4,$5,$6)
+      `INSERT INTO sync_clients(partition, client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms)
+       VALUES ($1,$2,$3,$4,$5,$6,$7)
        ON CONFLICT (partition, client_id) DO UPDATE
-         SET actor_id=EXCLUDED.actor_id, cursor=EXCLUDED.cursor,
+         SET actor_id=EXCLUDED.actor_id, wire_version=EXCLUDED.wire_version,
+             cursor=EXCLUDED.cursor,
              subscriptions=EXCLUDED.subscriptions,
              updated_at_ms=EXCLUDED.updated_at_ms`,
       [
         partition,
         record.clientId,
         record.actorId,
+        record.wireVersion,
         record.cursor,
         JSON.stringify(record.subscriptions),
         record.updatedAtMs,
@@ -1536,6 +1676,17 @@ export class PostgresServerStorage implements ServerStorage {
     );
   }
 
+  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;
@@ -1608,16 +1759,18 @@ export class PostgresServerStorage implements ServerStorage {
     const { rows } = await this.#exec.query<{
       client_id: string;
       actor_id: string;
+      wire_version: unknown;
       cursor: unknown;
       subscriptions: unknown;
       updated_at_ms: unknown;
     }>(
-      'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 ORDER BY updated_at_ms DESC',
+      'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 ORDER BY updated_at_ms DESC',
       [partition],
     );
     return rows.map((r) => ({
       clientId: r.client_id,
       actorId: r.actor_id,
+      wireVersion: asNumber(r.wire_version),
       cursor: asNumber(r.cursor),
       updatedAtMs: asNumber(r.updated_at_ms),
       subscriptions: (typeof r.subscriptions === 'string'
@@ -1742,13 +1895,6 @@ export class PostgresServerStorage implements ServerStorage {
   }
 
   async listPartitions(): Promise<string[]> {
-    // Union: the registry row appears on first commit, the client row on
-    // first pull — a partition with only one of the two still shows up.
-    const { rows } = await this.#exec.query<{ partition: string }>(
-      `SELECT partition FROM sync_partitions
-       UNION SELECT partition FROM sync_clients ORDER BY partition`,
-      [],
-    );
-    return rows.map((r) => r.partition);
+    return (await this.listPartitionRegistry()).map((entry) => entry.partition);
   }
 }

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
@@ -212,12 +218,14 @@ async function* sqliteImageSegment(
   asOf: number,
   digest: string,
   trace: PullSectionTrace | undefined,
+  logEpoch: string,
 ): AsyncGenerator<ResponseFrame, boolean> {
   const { storage, segments, partition } = ctx;
   const now = clockOf(ctx)();
   const existing = await segments.find(
     {
       partition,
+      logEpoch,
       table: plan.table.name,
       schemaVersion: schema.version,
       mediaType: 'sqlite',
@@ -258,56 +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);
   }
-  const bytes = buildImage({
-    table: plan.table,
+  let builds = stores.get(segments);
+  if (builds === undefined) {
+    builds = new Map();
+    stores.set(segments, builds);
+  }
+  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,
-      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;
 }
@@ -320,6 +361,7 @@ async function* bootstrapSegments(
   asOf: number,
   startRowCursor: string | null,
   trace: PullSectionTrace | undefined,
+  logEpoch: string,
 ): AsyncGenerator<
   ResponseFrame,
   { complete: boolean; rowCursor: string | null }
@@ -347,6 +389,7 @@ async function* bootstrapSegments(
       asOf,
       digest,
       trace,
+      logEpoch,
     );
     if (imaged) return { complete: true, rowCursor: null };
   }
@@ -393,6 +436,7 @@ async function* bootstrapSegments(
       const record = await segments.put(
         {
           partition,
+          logEpoch,
           table: plan.table.name,
           schemaVersion: schema.version,
           mediaType: 'rows',
@@ -435,8 +479,12 @@ export async function* subscriptionSection(
   maxSeq: number,
   horizonSeq: number,
   trace?: PullSectionTrace,
+  logEpoch?: string,
 ): AsyncGenerator<ResponseFrame, SubscriptionResult> {
   const sub = plan.frame;
+  if (logEpoch === undefined || logEpoch.length === 0) {
+    throw new Error('subscriptionSection requires a non-empty log epoch');
+  }
 
   if (plan.status === 'revoked') {
     yield {
@@ -496,6 +544,7 @@ export async function* subscriptionSection(
       asOf,
       startCursor,
       trace,
+      logEpoch,
     );
     if (outcome.complete) {
       yield { type: 'SUB_END', nextCursor: asOf };

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;