@syncular/server 0.15.47 → 0.15.48

package/src/frame-bytes.ts

@@ -18,7 +18,14 @@ import {
   type SubStartFrame,
 } from '@syncular/core';
 
-const STUB_HEADER: RespHeaderFrame = { type: 'RESP_HEADER' };
+const stubHeader = (wireVersion: number): RespHeaderFrame =>
+  wireVersion >= 2
+    ? {
+        type: 'RESP_HEADER',
+        logEpoch: 'frame-probe',
+        resetRequired: false,
+      }
+    : { type: 'RESP_HEADER' };
 const STUB_SUB_START: SubStartFrame = {
   type: 'SUB_START',
   id: '',
@@ -30,18 +37,28 @@ const STUB_SUB_START: SubStartFrame = {
 const STUB_SUB_END: SubEndFrame = { type: 'SUB_END', nextCursor: 0 };
 
 const probe = encodeMessage({
-  wireVersion: PROTOCOL_WIRE_VERSION,
+  wireVersion: 1,
   msgKind: 'response',
-  frames: [STUB_HEADER],
+  frames: [stubHeader(1)],
 });
 
 /** The 8-byte SSP2 response envelope header (§1.2). */
-export const RESPONSE_ENVELOPE_HEADER: Uint8Array = probe.slice(0, 8);
+export function responseEnvelopeHeader(wireVersion: number): Uint8Array {
+  const encoded = encodeMessage({
+    wireVersion,
+    msgKind: 'response',
+    frames: [stubHeader(wireVersion)],
+  });
+  return encoded.slice(0, 8);
+}
 
 /** The terminating END frame (§1.2 rule 1). */
 export const END_FRAME_BYTES: Uint8Array = probe.slice(probe.length - 5);
 
-function wrapperFor(frame: ResponseFrame): {
+function wrapperFor(
+  frame: ResponseFrame,
+  wireVersion: number,
+): {
   frames: ResponseFrame[];
   index: number;
 } {
@@ -50,11 +67,11 @@ function wrapperFor(frame: ResponseFrame): {
       return { frames: [frame], index: 0 };
     case 'LEASE':
       // §7.3.2: LEASE rides immediately after RESP_HEADER.
-      return { frames: [STUB_HEADER, frame], index: 1 };
+      return { frames: [stubHeader(wireVersion), frame], index: 1 };
     case 'PUSH_RESULT':
     case 'ERROR':
     case 'UNKNOWN':
-      return { frames: [STUB_HEADER, frame], index: 1 };
+      return { frames: [stubHeader(wireVersion), frame], index: 1 };
     case 'PUSH_RESULT_DETAILS': {
       const result: PushResultFrame = {
         type: 'PUSH_RESULT',
@@ -68,17 +85,23 @@ function wrapperFor(frame: ResponseFrame): {
           retryable: false,
         })),
       };
-      return { frames: [STUB_HEADER, result, frame], index: 2 };
+      return { frames: [stubHeader(wireVersion), result, frame], index: 2 };
     }
     case 'SUB_START':
-      return { frames: [STUB_HEADER, frame, STUB_SUB_END], index: 1 };
+      return {
+        frames: [stubHeader(wireVersion), frame, STUB_SUB_END],
+        index: 1,
+      };
     case 'SUB_END':
-      return { frames: [STUB_HEADER, STUB_SUB_START, frame], index: 2 };
+      return {
+        frames: [stubHeader(wireVersion), STUB_SUB_START, frame],
+        index: 2,
+      };
     case 'COMMIT':
     case 'SEGMENT_REF':
     case 'SEGMENT_INLINE':
       return {
-        frames: [STUB_HEADER, STUB_SUB_START, frame, STUB_SUB_END],
+        frames: [stubHeader(wireVersion), STUB_SUB_START, frame, STUB_SUB_END],
         index: 2,
       };
   }
@@ -88,10 +111,13 @@ function wrapperFor(frame: ResponseFrame): {
  * Encode one response frame (5-byte frame header + payload) using the
  * reference codec.
  */
-export function encodeResponseFrame(frame: ResponseFrame): Uint8Array {
-  const { frames, index } = wrapperFor(frame);
+export function encodeResponseFrame(
+  frame: ResponseFrame,
+  wireVersion = PROTOCOL_WIRE_VERSION,
+): Uint8Array {
+  const { frames, index } = wrapperFor(frame, wireVersion);
   const encoded = encodeMessage({
-    wireVersion: PROTOCOL_WIRE_VERSION,
+    wireVersion,
     msgKind: 'response',
     frames,
   });

package/src/handler.ts

@@ -28,6 +28,7 @@ import {
   limitsOf,
   REMOTE_COMMAND_CLIENT_ID_PREFIX,
   RESOLVER_OUTAGE,
+  touchAuthenticatedPartition,
 } from './context';
 import { SyncError, syncError } from './errors';
 import {
@@ -38,7 +39,7 @@ import {
 import {
   END_FRAME_BYTES,
   encodeResponseFrame,
-  RESPONSE_ENVELOPE_HEADER,
+  responseEnvelopeHeader,
 } from './frame-bytes';
 import type { LeaseRecord } from './lease-store';
 import {
@@ -53,9 +54,12 @@ import { type ProcessedPushCommit, processPushCommitWithTrace } from './push';
 import type { CompiledSchema } from './schema';
 import { compileSchema } from './schema';
 import { computeEffective, type ResolvedScopes } from './scopes';
-import type { ClientSubscription } from './storage';
+import type { ClientSubscription, PartitionRegistryEntry } from './storage';
 
 interface RequestPlan {
+  readonly wireVersion: number;
+  readonly logEpoch: string;
+  readonly epochReset: boolean;
   readonly header: ReqHeaderFrame;
   readonly pushes: readonly PushCommitFrame[];
   readonly pull: PullHeaderFrame | undefined;
@@ -192,6 +196,7 @@ async function planRequest(
   request: RequestMessage,
   ctx: SyncRequestContext,
   schema: CompiledSchema,
+  registry: PartitionRegistryEntry,
 ): Promise<RequestPlan> {
   const header = request.frames[0];
   if (header === undefined || header.type !== 'REQ_HEADER') {
@@ -206,10 +211,32 @@ async function planRequest(
     else if (frame.type === 'SUBSCRIPTION') subFrames.push(frame);
   }
 
+  if (request.wireVersion === 1 && registry.epochRequired) {
+    throw syncError(
+      'sync.client_wire_unsupported',
+      'this partition requires a client that validates log epochs (§2.1)',
+    );
+  }
+  if (
+    request.wireVersion >= 2 &&
+    header.logEpoch === undefined &&
+    pushes.length > 0
+  ) {
+    throw syncError(
+      'sync.invalid_request',
+      'epoch acquisition requests must not carry push commits (§2.1)',
+    );
+  }
+  const epochReset =
+    request.wireVersion >= 2 && header.logEpoch !== registry.logEpoch;
+
   if (header.schemaVersion !== schema.version) {
     // §2.4: no degraded encoding — answer with the schema floor (§1.6).
     // No lease is issued on a floor round (§7.3.3).
     return {
+      wireVersion: request.wireVersion,
+      logEpoch: registry.logEpoch,
+      epochReset,
       header,
       pushes,
       pull,
@@ -220,6 +247,21 @@ async function planRequest(
     };
   }
 
+  if (epochReset) {
+    return {
+      wireVersion: request.wireVersion,
+      logEpoch: registry.logEpoch,
+      epochReset: true,
+      header,
+      pushes: [],
+      pull: undefined,
+      subscriptions: [],
+      resolved: { ok: false },
+      schemaFloor: false,
+      leaseToEmit: undefined,
+    };
+  }
+
   if (header.clientId.startsWith(REMOTE_COMMAND_CLIENT_ID_PREFIX)) {
     throw syncError(
       'sync.invalid_client_id',
@@ -313,6 +355,9 @@ async function planRequest(
   });
 
   return {
+    wireVersion: request.wireVersion,
+    logEpoch: registry.logEpoch,
+    epochReset: false,
     header,
     pushes,
     pull,
@@ -325,7 +370,7 @@ async function planRequest(
 
 /** Mutable outcome box shared with the instrumented stream wrapper. */
 interface RequestReport {
-  outcome: 'ok' | 'schema_floor' | 'error';
+  outcome: 'ok' | 'schema_floor' | 'reset' | 'error';
   errorCode?: string;
 }
 
@@ -413,28 +458,48 @@ async function* streamResponse(
   report?: RequestReport,
 ): AsyncGenerator<Uint8Array> {
   const events = ctx.events;
-  yield RESPONSE_ENVELOPE_HEADER;
+  yield responseEnvelopeHeader(plan.wireVersion);
   if (plan.schemaFloor) {
     if (report !== undefined) report.outcome = 'schema_floor';
-    yield encodeResponseFrame({
+    yield encodeResponseFrame(
+      {
+        type: 'RESP_HEADER',
+        requiredSchemaVersion: schema.version,
+        latestSchemaVersion: schema.version,
+        ...(plan.wireVersion >= 2
+          ? { logEpoch: plan.logEpoch, resetRequired: plan.epochReset }
+          : {}),
+      },
+      plan.wireVersion,
+    );
+    yield END_FRAME_BYTES;
+    return;
+  }
+  yield encodeResponseFrame(
+    {
       type: 'RESP_HEADER',
-      requiredSchemaVersion: schema.version,
       latestSchemaVersion: schema.version,
-    });
+      ...(plan.wireVersion >= 2
+        ? { logEpoch: plan.logEpoch, resetRequired: plan.epochReset }
+        : {}),
+    },
+    plan.wireVersion,
+  );
+  if (plan.epochReset) {
+    if (report !== undefined) report.outcome = 'reset';
     yield END_FRAME_BYTES;
     return;
   }
-  yield encodeResponseFrame({
-    type: 'RESP_HEADER',
-    latestSchemaVersion: schema.version,
-  });
   // §7.3.2: the LEASE frame rides immediately after RESP_HEADER.
   if (plan.leaseToEmit !== undefined) {
-    yield encodeResponseFrame({
-      type: 'LEASE',
-      leaseId: plan.leaseToEmit.leaseId,
-      expiresAtMs: plan.leaseToEmit.expiresAtMs,
-    });
+    yield encodeResponseFrame(
+      {
+        type: 'LEASE',
+        leaseId: plan.leaseToEmit.leaseId,
+        expiresAtMs: plan.leaseToEmit.expiresAtMs,
+      },
+      plan.wireVersion,
+    );
     if (events !== undefined) {
       emitEvent(events, {
         type: 'lease.issued',
@@ -461,9 +526,11 @@ async function* streamResponse(
       if (events !== undefined) {
         emitPushEvent(events, ctx, plan.header.clientId, push, processed);
       }
-      yield encodeResponseFrame(frame);
+      yield encodeResponseFrame(frame, plan.wireVersion);
       const details = pushResultDetailsFrame(frame);
-      if (details !== undefined) yield encodeResponseFrame(details);
+      if (details !== undefined) {
+        yield encodeResponseFrame(details, plan.wireVersion);
+      }
     }
 
     // Pull half (§4): subscriptions echoed in request order.
@@ -485,6 +552,7 @@ async function* streamResponse(
           maxSeq,
           horizonSeq,
           trace,
+          plan.logEpoch,
         );
         let status: 'active' | 'revoked' | 'reset' = 'active';
         let bootstrap = false;
@@ -502,7 +570,7 @@ async function* streamResponse(
               changes += frame.changes.length;
             }
           }
-          yield encodeResponseFrame(frame);
+          yield encodeResponseFrame(frame, plan.wireVersion);
           step = await section.next();
         }
         if (step.value.active) cursors.push(step.value.nextCursor);
@@ -556,6 +624,7 @@ async function* streamResponse(
     await ctx.storage.putClientRecord(ctx.partition, {
       clientId: plan.header.clientId,
       actorId: ctx.actorId,
+      wireVersion: plan.wireVersion,
       cursor,
       updatedAtMs: clockOf(ctx)(),
       subscriptions,
@@ -567,15 +636,18 @@ async function* streamResponse(
         report.errorCode = error.code;
       }
       // §1.6: in-band ERROR, then END, nothing else.
-      yield encodeResponseFrame({
-        type: 'ERROR',
-        code: error.code,
-        message: error.message,
-        category: error.category,
-        retryable: error.retryable,
-        recommendedAction: error.recommendedAction,
-        ...(error.details !== undefined ? { details: error.details } : {}),
-      });
+      yield encodeResponseFrame(
+        {
+          type: 'ERROR',
+          code: error.code,
+          message: error.message,
+          category: error.category,
+          retryable: error.retryable,
+          recommendedAction: error.recommendedAction,
+          ...(error.details !== undefined ? { details: error.details } : {}),
+        },
+        plan.wireVersion,
+      );
       yield END_FRAME_BYTES;
       return;
     }
@@ -644,7 +716,8 @@ async function createStreamCore(
   // Relational row tables: create/
   // migrate on first contact; memoized per storage instance thereafter.
   await ctx.storage.ensureSchema(schema);
-  const plan = await planRequest(request, ctx, schema);
+  const registry = await touchAuthenticatedPartition(ctx);
+  const plan = await planRequest(request, ctx, schema, registry);
   if (events === undefined) return streamResponse(plan, ctx, schema);
   const report: RequestReport = { outcome: 'ok' };
   return instrumentedStream(

package/src/index.ts

@@ -64,6 +64,7 @@ export {
   type ReactionTypeMap,
 } from './reactions';
 export * from './realtime';
+export * from './restore';
 export * from './relational-rows';
 export * from './s3-blob-store';
 export * from './s3-segment-store';

package/src/operations.ts

@@ -9,7 +9,11 @@ import {
   type ScopeMap,
 } from '@syncular/core';
 import type { SyncRequestContext } from './context';
-import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE } from './context';
+import {
+  REMOTE_COMMAND_CLIENT_ID_PREFIX,
+  RESOLVER_OUTAGE,
+  touchAuthenticatedPartition,
+} from './context';
 import { SyncError, syncError } from './errors';
 import { processPushOperationsWithTrace } from './push';
 import { compileSchema } from './schema';
@@ -673,6 +677,7 @@ export async function handleRemoteOperation(
     return encodeRemoteOperationError(error, 'operation.invalid_request');
   }
   try {
+    await touchAuthenticatedPartition(ctx);
     if (request.clientId.startsWith(REMOTE_COMMAND_CLIENT_ID_PREFIX)) {
       throw syncError(
         'sync.invalid_client_id',

package/src/postgres-storage.ts

@@ -85,6 +85,7 @@ import type {
   IndexRowScanQuery,
   NewCommit,
   NewReaction,
+  PartitionRegistryEntry,
   PrunedReactionCounts,
   ReactionClaimQuery,
   ReactionFailure,
@@ -136,6 +137,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 +196,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,
@@ -998,6 +1008,86 @@ 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 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
@@ -1496,11 +1586,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 +1599,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 +1611,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,
@@ -1608,16 +1702,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 +1838,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/pull.ts

@@ -212,12 +212,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',
@@ -286,6 +288,7 @@ async function* sqliteImageSegment(
   const record = await segments.put(
     {
       partition,
+      logEpoch,
       table: plan.table.name,
       schemaVersion: schema.version,
       mediaType: 'sqlite',
@@ -320,6 +323,7 @@ async function* bootstrapSegments(
   asOf: number,
   startRowCursor: string | null,
   trace: PullSectionTrace | undefined,
+  logEpoch: string,
 ): AsyncGenerator<
   ResponseFrame,
   { complete: boolean; rowCursor: string | null }
@@ -347,6 +351,7 @@ async function* bootstrapSegments(
       asOf,
       digest,
       trace,
+      logEpoch,
     );
     if (imaged) return { complete: true, rowCursor: null };
   }
@@ -393,6 +398,7 @@ async function* bootstrapSegments(
       const record = await segments.put(
         {
           partition,
+          logEpoch,
           table: plan.table.name,
           schemaVersion: schema.version,
           mediaType: 'rows',
@@ -435,8 +441,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 +506,7 @@ export async function* subscriptionSection(
       asOf,
       startCursor,
       trace,
+      logEpoch,
     );
     if (outcome.complete) {
       yield { type: 'SUB_END', nextCursor: asOf };