@syncular/server 0.15.47 → 0.16.1

package/src/authoritative-query.ts

@@ -14,28 +14,16 @@ export interface BoundAuthoritativeQuery {
 
 const PARTITION_BIND = Symbol('syncular.authoritative_partition');
 
-const RESERVED_ALIAS = new Set([
-  'on',
-  'where',
-  'group',
-  'order',
-  'inner',
-  'left',
-  'right',
-  'full',
-  'outer',
-  'natural',
-  'join',
-  'cross',
-  'using',
-  'limit',
-  'having',
-]);
-const IDENT = '[A-Za-z_][A-Za-z0-9_]*';
-const TABLE_REF_RE = new RegExp(
-  `\\b(FROM|(?:NATURAL\\s+)?(?:(?:LEFT|RIGHT|FULL)(?:\\s+OUTER)?|INNER|CROSS)?\\s*JOIN)\\s+((?:\\(\\s*)*)(${IDENT})(?:\\s+(?:AS\\s+)?((?!(?:${[...RESERVED_ALIAS].join('|')})\\b)${IDENT}))?`,
-  'gi',
-);
+/** Compiler-proven occurrences in the exact generated positional statement. */
+export interface AuthoritativeRelationPlan {
+  readonly sql: string;
+  readonly relations: readonly {
+    readonly table: string;
+    readonly start: number;
+    readonly end: number;
+    readonly alias?: string;
+  }[];
+}
 
 function protectedSqlEnd(sql: string, index: number): number | undefined {
   const char = sql[index];
@@ -64,66 +52,57 @@ function protectedSqlEnd(sql: string, index: number): number | undefined {
   return undefined;
 }
 
-function maskedSql(sql: string): string {
-  let out = '';
-  let index = 0;
-  while (index < sql.length) {
-    const end = protectedSqlEnd(sql, index);
-    if (end === undefined) out += sql[index];
-    else out += sql.slice(index, end).replace(/[^\n]/g, ' ');
-    index = end ?? index + 1;
-  }
-  return out;
-}
-
-/**
- * Turn generated local SQL into a partition-local authoritative statement.
- * Only relations declared by the generated descriptor are rewritten. Values
- * remain parameters; request data is never interpolated into SQL.
- */
-export function prepareAuthoritativeQuery(
-  sql: string,
-  params: readonly AuthoritativeQueryValue[],
+/** Validate trusted generated metadata before registration or storage execution. */
+export function validateAuthoritativeRelationPlan(
+  plan: AuthoritativeRelationPlan,
   declaredTables: readonly string[],
-  tables: ReadonlyMap<string, CompiledTable>,
-): PreparedAuthoritativeQuery {
-  if (maskedSql(sql).includes(';'))
-    throw new Error('registered query must be one SELECT');
+): void {
+  if (
+    plan === undefined ||
+    typeof plan.sql !== 'string' ||
+    !Array.isArray(plan.relations)
+  ) {
+    throw new Error(
+      'registered query requires generated relation plans; regenerate queries',
+    );
+  }
+  const sql = plan.sql;
   const declared = new Set(declaredTables);
-  const masked = maskedSql(sql);
-  const replacements: Array<{
-    readonly start: number;
-    readonly end: number;
-    readonly text: string;
-  }> = [];
   const found = new Set<string>();
-  for (const match of masked.matchAll(TABLE_REF_RE)) {
-    const rawTable = match[3] as string;
-    const table = tables.get(rawTable);
-    if (table === undefined) continue;
-    if (!declared.has(table.name)) {
-      throw new Error('registered query table metadata does not match its SQL');
+  let previousEnd = 0;
+  for (const relation of plan.relations) {
+    if (
+      !Number.isSafeInteger(relation.start) ||
+      !Number.isSafeInteger(relation.end) ||
+      relation.start < previousEnd ||
+      relation.end <= relation.start ||
+      relation.end > sql.length
+    ) {
+      throw new Error(
+        'registered query relation boundaries do not match its SQL; regenerate queries',
+      );
     }
-    if (!table.materialize) {
-      throw new Error('registered query targets a non-materialized table');
+    previousEnd = relation.end;
+    if (!declared.has(relation.table)) {
+      throw new Error('registered query table metadata does not match its SQL');
     }
-    let alias = match[4];
-    if (alias !== undefined && RESERVED_ALIAS.has(alias.toLowerCase())) {
-      alias = undefined;
+    const spelling = sql.slice(relation.start, relation.end);
+    const quote = spelling[0];
+    const name =
+      quote === '['
+        ? spelling.slice(1, -1)
+        : quote === '"' || quote === '`'
+          ? spelling
+              .slice(1, -1)
+              .split(quote + quote)
+              .join(quote)
+          : spelling;
+    if (name.toLowerCase() !== relation.table.toLowerCase()) {
+      throw new Error(
+        'registered query relation name does not match its SQL; regenerate queries',
+      );
     }
-    const matchStart = match.index ?? 0;
-    const afterOperator = (match[1] as string).length;
-    const relative = match[0]
-      .toLowerCase()
-      .indexOf(rawTable.toLowerCase(), afterOperator);
-    const start = matchStart + relative;
-    const projection = table.columns.map((column) => quoteIdent(column.name));
-    replacements.push({
-      start,
-      end: start + rawTable.length,
-      text: `(SELECT ${projection.join(', ')} FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(SYNC_PARTITION_COLUMN)}=/*syncular_partition*/?)${alias === undefined ? ` AS ${quoteIdent(table.name)}` : ''}`,
-    });
-    found.add(table.name);
+    found.add(relation.table);
   }
   if (
     found.size !== declared.size ||
@@ -131,42 +110,58 @@ export function prepareAuthoritativeQuery(
   ) {
     throw new Error('registered query table metadata does not match its SQL');
   }
-  let rewritten = sql;
-  for (const replacement of replacements.sort(
-    (left, right) => right.start - left.start,
-  )) {
-    rewritten =
-      rewritten.slice(0, replacement.start) +
-      replacement.text +
-      rewritten.slice(replacement.end);
-  }
+}
 
+/** Bind every compiler-proven table occurrence to the authenticated partition. */
+export function prepareAuthoritativeQuery(
+  plan: AuthoritativeRelationPlan,
+  params: readonly AuthoritativeQueryValue[],
+  declaredTables: readonly string[],
+  tables: ReadonlyMap<string, CompiledTable>,
+): PreparedAuthoritativeQuery {
+  validateAuthoritativeRelationPlan(plan, declaredTables);
+  const sql = plan.sql;
+  const replacements = plan.relations.map((relation) => {
+    const table = tables.get(relation.table);
+    if (table === undefined)
+      throw new Error('registered query targets an unknown table');
+    if (!table.materialize)
+      throw new Error('registered query targets a non-materialized table');
+    return {
+      start: relation.start,
+      end: relation.end,
+      text: `(SELECT ${table.columns.map((column) => quoteIdent(column.name)).join(', ')} FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(SYNC_PARTITION_COLUMN)}=?)${relation.alias === undefined ? ` AS ${quoteIdent(table.name)}` : ''}`,
+    };
+  });
   const bound: (AuthoritativeQueryValue | typeof PARTITION_BIND)[] = [];
   let anonymousIndex = 0;
   let rendered = '';
-  for (let index = 0; index < rewritten.length; index += 1) {
-    if (rewritten.startsWith('/*syncular_partition*/?', index)) {
-      rendered += '?';
+  let nextRelation = 0;
+  for (let index = 0; index < sql.length; index += 1) {
+    const replacement = replacements[nextRelation];
+    if (replacement?.start === index) {
+      rendered += replacement.text;
       bound.push(PARTITION_BIND);
-      index += '/*syncular_partition*/?'.length - 1;
+      index = replacement.end - 1;
+      nextRelation += 1;
       continue;
     }
-    const protectedEnd = protectedSqlEnd(rewritten, index);
+    const protectedEnd = protectedSqlEnd(sql, index);
     if (protectedEnd !== undefined) {
-      rendered += rewritten.slice(index, protectedEnd);
+      rendered += sql.slice(index, protectedEnd);
       index = protectedEnd - 1;
       continue;
     }
-    const char = rewritten[index] as string;
+    const char = sql[index] as string;
     if (char !== '?') {
       rendered += char;
       continue;
     }
     let end = index + 1;
-    while (end < rewritten.length && /[0-9]/.test(rewritten[end] as string)) {
+    while (end < sql.length && /[0-9]/.test(sql[end] as string)) {
       end += 1;
     }
-    const numbered = rewritten.slice(index + 1, end);
+    const numbered = sql.slice(index + 1, end);
     const parameterIndex =
       numbered.length > 0
         ? Number.parseInt(numbered, 10) - 1

package/src/blob-handlers.ts

@@ -8,7 +8,11 @@
  */
 import { blobIdFor, isBlobId } from './blob-store';
 import type { SyncRequestContext } from './context';
-import { clockOf, RESOLVER_OUTAGE } from './context';
+import {
+  clockOf,
+  RESOLVER_OUTAGE,
+  touchAuthenticatedPartition,
+} from './context';
 import { SyncError, syncError } from './errors';
 import { emitEvent } from './events';
 import { compileSchema } from './schema';
@@ -72,6 +76,7 @@ export async function handleBlobUpload(
   ctx: SyncRequestContext,
   request: BlobUploadRequest,
 ): Promise<void> {
+  await touchAuthenticatedPartition(ctx);
   const store = ctx.blobs;
   if (store === undefined) {
     throw syncError('blob.not_found', 'this server has no blob store (§5.9)');
@@ -125,6 +130,7 @@ export async function handleBlobDownload(
   ctx: SyncRequestContext,
   blobId: string,
 ): Promise<BlobDownloadResult> {
+  await touchAuthenticatedPartition(ctx);
   const events = ctx.events;
   if (events === undefined) return downloadBlob(ctx, blobId);
   const clock = clockOf(ctx);
@@ -301,6 +307,7 @@ export async function handleBlobUploadGrant(
   ctx: SyncRequestContext,
   request: BlobUploadGrantRequest,
 ): Promise<BlobUploadGrantResult> {
+  await touchAuthenticatedPartition(ctx);
   const store = ctx.blobs;
   if (store === undefined) {
     throw syncError('blob.not_found', 'this server has no blob store (§5.9)');

package/src/context.ts

@@ -18,7 +18,11 @@ import type {
   SegmentUrlConfig,
 } from './signed-url';
 import type { SqliteImageBuilder } from './sqlite-image';
-import type { ServerStorage, StoredCommit } from './storage';
+import type {
+  PartitionRegistryEntry,
+  ServerStorage,
+  StoredCommit,
+} from './storage';
 import type { CommitValidator, ValidatorRegistry } from './validate';
 
 /** SSP2 body content type (§1.1). */
@@ -192,3 +196,14 @@ export function clockOf(ctx: SyncServerConfig): () => number {
 export function limitsOf(ctx: SyncServerConfig): ServerLimits {
   return { ...DEFAULT_LIMITS, ...ctx.limits };
 }
+
+/** Refresh the registry after host authentication and return log continuity. */
+export function touchAuthenticatedPartition(
+  ctx: SyncRequestContext,
+): Promise<PartitionRegistryEntry> {
+  return ctx.storage.touchPartition(
+    ctx.partition,
+    clockOf(ctx)(),
+    crypto.randomUUID(),
+  );
+}

package/src/d1-storage.ts

@@ -1,3 +1,6 @@
+import { validateCommitPruneQuery } from './prune';
+import { StorageQueryError } from './storage-errors';
+import type { CommitPruneQuery, CommitPruneResult } from './storage';
 /**
  * Cloudflare D1 server storage for Workers deployments.
  *
@@ -95,6 +98,7 @@ import type {
   IndexRowScanQuery,
   NewCommit,
   NewReaction,
+  PartitionRegistryEntry,
   PrunedReactionCounts,
   ReactionClaimQuery,
   ReactionFailure,
@@ -752,6 +756,14 @@ export class D1ServerStorage implements ServerStorage {
     for (const statement of sqliteDdlStatements()) {
       await this.#db.exec(`${statement.replace(/\s+/g, ' ')};`);
     }
+    const { results } = await this.#db
+      .prepare('PRAGMA table_info("sync_clients")')
+      .all<{ name: string }>();
+    if (!results.some((column) => column.name === 'wire_version')) {
+      await this.#db.exec(
+        'ALTER TABLE sync_clients ADD COLUMN wire_version INTEGER NOT NULL DEFAULT 1;',
+      );
+    }
   }
 
   /** Resolve a table's compiled schema; row operations require `ensureSchema`. */
@@ -859,6 +871,95 @@ export class D1ServerStorage 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');
+    }
+    await this.#db
+      .prepare(
+        `INSERT INTO sync_partition_registry(
+           partition, log_epoch, last_authenticated_at_ms
+         ) VALUES (?,?,?)
+         ON CONFLICT(partition) DO UPDATE SET
+           last_authenticated_at_ms=excluded.last_authenticated_at_ms`,
+      )
+      .bind(partition, initialLogEpoch, authenticatedAtMs)
+      .run();
+    const row = await this.#db
+      .prepare(
+        `SELECT log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry WHERE partition=?`,
+      )
+      .bind(partition)
+      .first<{
+        log_epoch: string;
+        epoch_required: number;
+        last_authenticated_at_ms: number;
+      }>();
+    if (row === null)
+      throw new Error('partition registry write did not persist');
+    return {
+      partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required === 1,
+      lastAuthenticatedAtMs: 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.#db.batch([
+      this.#db
+        .prepare(
+          `INSERT INTO sync_partition_registry(
+             partition, log_epoch, epoch_required, last_authenticated_at_ms
+           ) VALUES (?,?,1,?)
+           ON CONFLICT(partition) DO UPDATE SET
+             log_epoch=excluded.log_epoch,
+             epoch_required=1,
+             last_authenticated_at_ms=excluded.last_authenticated_at_ms`,
+        )
+        .bind(partition, logEpoch, authenticatedAtMs),
+      this.#db
+        .prepare('DELETE FROM sync_clients WHERE partition=?')
+        .bind(partition),
+    ]);
+    return {
+      partition,
+      logEpoch,
+      epochRequired: true,
+      lastAuthenticatedAtMs: authenticatedAtMs,
+    };
+  }
+
+  async listPartitionRegistry(): Promise<PartitionRegistryEntry[]> {
+    const { results } = await this.#db
+      .prepare(
+        `SELECT partition, log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry ORDER BY partition`,
+      )
+      .all<{
+        partition: string;
+        log_epoch: string;
+        epoch_required: number;
+        last_authenticated_at_ms: number;
+      }>();
+    return results.map((row) => ({
+      partition: row.partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required === 1,
+      lastAuthenticatedAtMs: row.last_authenticated_at_ms,
+    }));
+  }
+
   /** Keyset-paged migration rewrite (see the sqlite storage's counterpart). */
   async #rewriteRows(
     table: CompiledTable,
@@ -929,7 +1030,7 @@ export class D1ServerStorage implements ServerStorage {
     }
     const prepared = bindAuthoritativePartition(
       prepareAuthoritativeQuery(
-        query.sql,
+        query.plan,
         query.params,
         query.tables,
         this.#tables,
@@ -973,6 +1074,16 @@ export class D1ServerStorage implements ServerStorage {
     };
   }
 
+  async getPartitionLogEpoch(partition: string): Promise<string | undefined> {
+    const row = await this.#db
+      .prepare(
+        'SELECT log_epoch FROM sync_partition_registry WHERE partition=?',
+      )
+      .bind(partition)
+      .first<{ log_epoch: string }>();
+    return row?.log_epoch;
+  }
+
   async getHorizonSeq(partition: string): Promise<number> {
     const row = await this.#db
       .prepare('SELECT horizon_seq FROM sync_partitions WHERE partition=?')
@@ -984,33 +1095,76 @@ export class D1ServerStorage implements ServerStorage {
   async setHorizonSeq(partition: string, seq: number): Promise<void> {
     await this.#db
       .prepare(
-        'INSERT INTO sync_partitions(partition, horizon_seq) VALUES (?,?) ON CONFLICT(partition) DO UPDATE SET horizon_seq=excluded.horizon_seq',
+        'INSERT INTO sync_partitions(partition, horizon_seq) VALUES (?,?) ON CONFLICT(partition) DO UPDATE SET horizon_seq=max(horizon_seq,excluded.horizon_seq)',
       )
       .bind(partition, seq)
       .run();
   }
 
-  async pruneCommitsThrough(partition: string, seq: number): Promise<number> {
-    const before = await this.#db
-      .prepare(
-        'SELECT count(*) AS n FROM sync_commits WHERE partition=? AND commit_seq<=?',
-      )
-      .bind(partition, seq)
-      .first<{ n: number }>();
-    await this.#db.batch([
+  async pruneCommitsThrough(
+    partition: string,
+    query: CommitPruneQuery,
+  ): Promise<CommitPruneResult> {
+    validateCommitPruneQuery(query);
+    if (!this.#pushApplySerialized)
+      throw new Error(
+        'D1 pruning requires externally serialized partition writes',
+      );
+    const epochGuard =
+      'EXISTS (SELECT 1 FROM sync_partition_registry WHERE partition=? AND log_epoch=?)';
+    const horizon =
+      '(SELECT horizon_seq FROM sync_partitions WHERE partition=?)';
+    const results = await this.#db.batch([
       this.#db
-        .prepare('DELETE FROM sync_commits WHERE partition=? AND commit_seq<=?')
-        .bind(partition, seq),
+        .prepare(
+          `SELECT log_epoch, coalesce(${horizon},0) AS previous_horizon_seq FROM sync_partition_registry WHERE partition=?`,
+        )
+        .bind(partition, partition),
       this.#db
-        .prepare('DELETE FROM sync_changes WHERE partition=? AND commit_seq<=?')
-        .bind(partition, seq),
+        .prepare(`INSERT INTO sync_partitions(partition,horizon_seq) SELECT ?,? WHERE ${epochGuard}
+        ON CONFLICT(partition) DO UPDATE SET horizon_seq=max(horizon_seq,excluded.horizon_seq)`)
+        .bind(partition, query.throughSeq, partition, query.logEpoch),
       this.#db
         .prepare(
-          'DELETE FROM sync_change_scopes WHERE partition=? AND commit_seq<=?',
+          `SELECT horizon_seq, (SELECT count(*) FROM sync_commits WHERE partition=? AND commit_seq<=${horizon}) AS removed_commits FROM sync_partitions WHERE partition=?`,
         )
-        .bind(partition, seq),
+        .bind(partition, partition, partition),
+      ...['sync_commits', 'sync_changes', 'sync_change_scopes'].map((table) =>
+        this.#db
+          .prepare(
+            `DELETE FROM ${table} WHERE partition=? AND commit_seq<=${horizon} AND ${epochGuard}`,
+          )
+          .bind(partition, partition, partition, query.logEpoch),
+      ),
     ]);
-    return before?.n ?? 0;
+    const [before, after] = [results[0], results[2]].map((result) => {
+      if (
+        typeof result !== 'object' ||
+        result === null ||
+        !('results' in result) ||
+        !Array.isArray(result.results)
+      ) {
+        throw new Error('D1 pruning returned an invalid batch result');
+      }
+      const row: unknown = result.results[0];
+      return typeof row === 'object' && row !== null
+        ? (row as Readonly<Record<string, unknown>>)
+        : undefined;
+    });
+    if (before?.log_epoch !== query.logEpoch)
+      throw new StorageQueryError('sync.storage.prune_epoch_mismatch');
+    if (
+      typeof before.previous_horizon_seq !== 'number' ||
+      typeof after?.horizon_seq !== 'number' ||
+      typeof after.removed_commits !== 'number'
+    ) {
+      throw new Error('D1 pruning returned invalid horizon metadata');
+    }
+    return {
+      previousHorizonSeq: before.previous_horizon_seq,
+      horizonSeq: after.horizon_seq,
+      removedCommits: after.removed_commits,
+    };
   }
 
   async getCommitSeqBefore(
@@ -1390,12 +1544,13 @@ export class D1ServerStorage implements ServerStorage {
   ): Promise<ClientRecord | undefined> {
     const record = await this.#db
       .prepare(
-        'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?',
+        'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?',
       )
       .bind(partition, clientId)
       .first<{
         client_id: string;
         actor_id: string;
+        wire_version: number;
         cursor: number;
         subscriptions: string;
         updated_at_ms: number;
@@ -1404,6 +1559,7 @@ export class D1ServerStorage implements ServerStorage {
     return {
       clientId: record.client_id,
       actorId: record.actor_id,
+      wireVersion: record.wire_version,
       cursor: record.cursor,
       updatedAtMs: record.updated_at_ms,
       subscriptions: JSON.parse(record.subscriptions) as ClientSubscription[],
@@ -1416,12 +1572,13 @@ export class D1ServerStorage implements ServerStorage {
   ): Promise<void> {
     await this.#db
       .prepare(
-        'INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?)',
+        'INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?,?)',
       )
       .bind(
         partition,
         record.clientId,
         record.actorId,
+        record.wireVersion,
         record.cursor,
         JSON.stringify(record.subscriptions),
         record.updatedAtMs,
@@ -1429,6 +1586,19 @@ export class D1ServerStorage implements ServerStorage {
       .run();
   }
 
+  async getActiveClientCursorFloor(
+    partition: string,
+    cutoffMs: number,
+  ): Promise<number | null> {
+    const row = await this.#db
+      .prepare(
+        'SELECT MIN(cursor) AS cursor FROM sync_clients WHERE partition=? AND updated_at_ms>=?',
+      )
+      .bind(partition, cutoffMs)
+      .first<{ cursor: number | null }>();
+    return row!.cursor;
+  }
+
   async listClientCursors(partition: string): Promise<ClientCursorInfo[]> {
     const { results } = await this.#db
       .prepare(
@@ -1494,12 +1664,13 @@ export class D1ServerStorage implements ServerStorage {
   async listClientRecords(partition: string): Promise<ClientRecord[]> {
     const { results } = await this.#db
       .prepare(
-        'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? ORDER BY updated_at_ms DESC',
+        'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? ORDER BY updated_at_ms DESC',
       )
       .bind(partition)
       .all<{
         client_id: string;
         actor_id: string;
+        wire_version: number;
         cursor: number;
         subscriptions: string;
         updated_at_ms: number;
@@ -1507,6 +1678,7 @@ export class D1ServerStorage implements ServerStorage {
     return results.map((record) => ({
       clientId: record.client_id,
       actorId: record.actor_id,
+      wireVersion: record.wire_version,
       cursor: record.cursor,
       updatedAtMs: record.updated_at_ms,
       subscriptions: JSON.parse(record.subscriptions) as ClientSubscription[],
@@ -1628,14 +1800,6 @@ export class D1ServerStorage 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 { results } = await this.#db
-      .prepare(
-        `SELECT partition FROM sync_partitions
-         UNION SELECT partition FROM sync_clients ORDER BY partition`,
-      )
-      .all<{ partition: string }>();
-    return results.map((r) => r.partition);
+    return (await this.listPartitionRegistry()).map((entry) => entry.partition);
   }
 }

package/src/errors.ts

@@ -199,6 +199,12 @@ export const ERROR_CATALOG: Readonly<Record<string, ErrorCatalogEntry>> = {
     recommendedAction: 'upgradeClient',
     httpStatus: 400,
   },
+  'sync.client_wire_unsupported': {
+    category: 'schema-mismatch',
+    retryable: false,
+    recommendedAction: 'upgradeClient',
+    httpStatus: 400,
+  },
   'sync.websocket_connection_limit': {
     category: 'rate-limited',
     retryable: true,

package/src/events.ts

@@ -29,10 +29,11 @@ export interface RequestHandledEvent {
   /**
    * `ok` — response streamed to END;
    * `schema_floor` — §2.4 required-schema answer;
+   * `reset` — §2.1 log-epoch reset answer;
    * `rejected` — request validation failed before any bytes (§1.7);
    * `error` — in-band ERROR frame (§1.6) or a thrown host failure.
    */
-  readonly outcome: 'ok' | 'schema_floor' | 'rejected' | 'error';
+  readonly outcome: 'ok' | 'schema_floor' | 'reset' | 'rejected' | 'error';
   /** §10.2 code for `rejected`/`error`; `"internal"` for non-SyncErrors. */
   readonly errorCode?: string;
   readonly pushCommits: number;