@syncular/server 0.15.47 → 0.15.48

package/dist/sqlite-segment-store.js

@@ -15,6 +15,7 @@ export class SqliteSegmentStore {
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS sync_segments(
         segment_id TEXT PRIMARY KEY, partition TEXT NOT NULL,
+        log_epoch TEXT NOT NULL,
         tbl TEXT NOT NULL, schema_version INTEGER NOT NULL,
         media_type TEXT NOT NULL, scope_digest TEXT NOT NULL,
         as_of_commit_seq INTEGER NOT NULL, row_count INTEGER NOT NULL,
@@ -23,6 +24,12 @@ export class SqliteSegmentStore {
         expires_at_ms INTEGER NOT NULL, bytes BLOB NOT NULL
       );
     `);
+        const columns = this.db
+            .query('PRAGMA table_info(sync_segments)')
+            .all();
+        if (!columns.some((column) => column.name === 'log_epoch')) {
+            this.db.exec("ALTER TABLE sync_segments ADD COLUMN log_epoch TEXT NOT NULL DEFAULT ''");
+        }
     }
     async put(metadata, bytes, nowMs) {
         const segmentId = await segmentIdFor(bytes);
@@ -35,11 +42,11 @@ export class SqliteSegmentStore {
         };
         this.db
             .query(`INSERT OR REPLACE INTO sync_segments(
-          segment_id, partition, tbl, schema_version, media_type,
+          segment_id, partition, log_epoch, tbl, schema_version, media_type,
           scope_digest, as_of_commit_seq, row_count, row_cursor,
           next_row_cursor, byte_length, created_at_ms, expires_at_ms, bytes
-        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
-            .run(record.segmentId, record.partition, record.table, record.schemaVersion, record.mediaType, record.scopeDigest, record.asOfCommitSeq, record.rowCount, record.rowCursor, record.nextRowCursor, record.byteLength, record.createdAtMs, record.expiresAtMs, bytes);
+        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+            .run(record.segmentId, record.partition, record.logEpoch, record.table, record.schemaVersion, record.mediaType, record.scopeDigest, record.asOfCommitSeq, record.rowCount, record.rowCursor, record.nextRowCursor, record.byteLength, record.createdAtMs, record.expiresAtMs, bytes);
         return record;
     }
     async get(segmentId) {
@@ -52,6 +59,7 @@ export class SqliteSegmentStore {
             record: {
                 segmentId: row.segment_id,
                 partition: row.partition,
+                logEpoch: row.log_epoch,
                 table: row.tbl,
                 schemaVersion: row.schema_version,
                 mediaType: row.media_type === 'sqlite' ? 'sqlite' : 'rows',
@@ -72,16 +80,17 @@ export class SqliteSegmentStore {
             .query(`SELECT segment_id, row_count, next_row_cursor, byte_length,
                 created_at_ms, expires_at_ms
          FROM sync_segments
-         WHERE partition=? AND tbl=? AND schema_version=? AND media_type=?
+         WHERE partition=? AND log_epoch=? AND tbl=? AND schema_version=? AND media_type=?
            AND scope_digest=? AND as_of_commit_seq=? AND row_cursor IS NULL
            AND expires_at_ms > ?
          LIMIT 1`)
-            .get(key.partition, key.table, key.schemaVersion, key.mediaType, key.scopeDigest, key.asOfCommitSeq, nowMs);
+            .get(key.partition, key.logEpoch, key.table, key.schemaVersion, key.mediaType, key.scopeDigest, key.asOfCommitSeq, nowMs);
         if (row === null)
             return undefined;
         return {
             segmentId: row.segment_id,
             partition: key.partition,
+            logEpoch: key.logEpoch,
             table: key.table,
             schemaVersion: key.schemaVersion,
             mediaType: key.mediaType,

package/dist/sqlite-storage.d.ts

@@ -1,6 +1,6 @@
 import type { CompiledSchema, CompiledTable } from './schema.js';
 import { type SqliteDatabase } from './sqlite-driver.js';
-import type { AuthoritativeQueryRequest, AuthoritativeQueryResult, ClientCursorInfo, ClientRecord, CommitMetadata, CommitMetadataQuery, CommitWindowQuery, IndexRowScanQuery, PrunedReactionCounts, ReactionClaimQuery, ReactionFailureUpdate, ReactionListQuery, ReactionPruneQuery, RowScanQuery, ScopeActivityQuery, ScopeCommitActivity, ServerStorage, StorageTransaction, StoredCommit, StoredPushResult, StoredReaction, StoredRow } from './storage.js';
+import type { AuthoritativeQueryRequest, AuthoritativeQueryResult, ClientCursorInfo, ClientRecord, CommitMetadata, CommitMetadataQuery, CommitWindowQuery, IndexRowScanQuery, PartitionRegistryEntry, PrunedReactionCounts, ReactionClaimQuery, ReactionFailureUpdate, ReactionListQuery, ReactionPruneQuery, RowScanQuery, ScopeActivityQuery, ScopeCommitActivity, ServerStorage, StorageTransaction, StoredCommit, StoredPushResult, StoredReaction, StoredRow } from './storage.js';
 export declare class SqliteServerStorage implements ServerStorage {
     #private;
     readonly db: SqliteDatabase;
@@ -8,6 +8,9 @@ export declare class SqliteServerStorage implements ServerStorage {
     /** Resolve a table's compiled schema; row operations require `ensureSchema`. */
     table(name: string): CompiledTable;
     ensureSchema(schema: CompiledSchema): Promise<void>;
+    touchPartition(partition: string, authenticatedAtMs: number, initialLogEpoch: string): Promise<PartitionRegistryEntry>;
+    rotatePartitionLogEpoch(partition: string, logEpoch: string, authenticatedAtMs: number): Promise<PartitionRegistryEntry>;
+    listPartitionRegistry(): Promise<PartitionRegistryEntry[]>;
     begin(partition: string): Promise<StorageTransaction>;
     /** Internal: write a row + refresh its scope-index entries. */
     writeRow(partition: string, table: string, row: StoredRow): void;

package/dist/sqlite-storage.js

@@ -219,6 +219,12 @@ export class SqliteServerStorage {
         }
         this.db = db;
         this.db.exec(SQLITE_DDL);
+        const clientColumns = this.db
+            .query('PRAGMA table_info("sync_clients")')
+            .all();
+        if (!clientColumns.some((column) => column.name === 'wire_version')) {
+            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`. */
     table(name) {
@@ -294,6 +300,74 @@ export class SqliteServerStorage {
         this.#tables = schema.tables;
         this.#schemaVersion = schema.version;
     }
+    async touchPartition(partition, authenticatedAtMs, initialLogEpoch) {
+        if (initialLogEpoch.length === 0) {
+            throw new Error('initial log epoch must be non-empty');
+        }
+        this.db
+            .query(`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`)
+            .run(partition, initialLogEpoch, authenticatedAtMs);
+        const row = this.db
+            .query(`SELECT log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry WHERE partition=?`)
+            .get(partition);
+        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, logEpoch, authenticatedAtMs) {
+        if (logEpoch.length === 0)
+            throw new Error('log epoch must be non-empty');
+        return this.#serializeReactionWrite(() => {
+            this.db.exec('BEGIN IMMEDIATE');
+            try {
+                this.db
+                    .query(`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`)
+                    .run(partition, logEpoch, authenticatedAtMs);
+                this.db
+                    .query('DELETE FROM sync_clients WHERE partition=?')
+                    .run(partition);
+                this.db.exec('COMMIT');
+            }
+            catch (error) {
+                this.db.exec('ROLLBACK');
+                throw error;
+            }
+            return {
+                partition,
+                logEpoch,
+                epochRequired: true,
+                lastAuthenticatedAtMs: authenticatedAtMs,
+            };
+        });
+    }
+    async listPartitionRegistry() {
+        return this.db
+            .query(`SELECT partition, log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry ORDER BY partition`)
+            .all()
+            .map((row) => ({
+            partition: row.partition,
+            logEpoch: row.log_epoch,
+            epochRequired: row.epoch_required === 1,
+            lastAuthenticatedAtMs: row.last_authenticated_at_ms,
+        }));
+    }
     /**
      * Migration rewrite: keyset-paged walk of a row table. When `oldLayout` is
      * given every payload re-encodes under
@@ -659,13 +733,14 @@ export class SqliteServerStorage {
     }
     async getClientRecord(partition, clientId) {
         const record = this.db
-            .query('SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?')
+            .query('SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?')
             .get(partition, clientId);
         if (record === null)
             return undefined;
         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),
@@ -673,8 +748,8 @@ export class SqliteServerStorage {
     }
     async putClientRecord(partition, record) {
         this.db
-            .query('INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?)')
-            .run(partition, record.clientId, record.actorId, record.cursor, JSON.stringify(record.subscriptions), record.updatedAtMs);
+            .query('INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?,?)')
+            .run(partition, record.clientId, record.actorId, record.wireVersion, record.cursor, JSON.stringify(record.subscriptions), record.updatedAtMs);
     }
     async listClientCursors(partition) {
         const records = this.db
@@ -719,11 +794,12 @@ export class SqliteServerStorage {
     // -- admin/console read surface --------------------------------------------
     async listClientRecords(partition) {
         const records = this.db
-            .query('SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? ORDER BY updated_at_ms DESC')
+            .query('SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? ORDER BY updated_at_ms DESC')
             .all(partition);
         return records.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),
@@ -800,12 +876,6 @@ export class SqliteServerStorage {
         };
     }
     async listPartitions() {
-        // 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 = this.db
-            .query(`SELECT partition FROM sync_partitions
-         UNION SELECT partition FROM sync_clients ORDER BY partition`)
-            .all();
-        return rows.map((r) => r.partition);
+        return (await this.listPartitionRegistry()).map((entry) => entry.partition);
     }
 }

package/dist/storage.d.ts

@@ -144,6 +144,8 @@ export interface ClientSubscription {
 export interface ClientRecord {
     readonly clientId: string;
     readonly actorId: string;
+    /** SSP2 version last accepted from this client; selects realtime deltas. */
+    readonly wireVersion: number;
     /** Minimum `nextCursor` across the last pull's active subscriptions. */
     readonly cursor: number;
     readonly updatedAtMs: number;
@@ -195,6 +197,13 @@ export interface ClientCursorInfo {
     readonly cursor: number;
     readonly updatedAtMs: number;
 }
+/** Durable partition identity refreshed after host authentication (§2.1). */
+export interface PartitionRegistryEntry {
+    readonly partition: string;
+    readonly logEpoch: string;
+    readonly epochRequired: boolean;
+    readonly lastAuthenticatedAtMs: number;
+}
 /**
  * Commit-log metadata (no change payloads) for the admin/console read
  * surface. `changeCount` is the number of changes the commit carries;
@@ -340,6 +349,12 @@ export interface ServerStorage {
      * lazily as a defensive backstop.
      */
     ensureSchema(schema: CompiledSchema): Promise<void>;
+    /** Create or refresh the authenticated partition registry row (§2.1). */
+    touchPartition(partition: string, authenticatedAtMs: number, initialLogEpoch: string): Promise<PartitionRegistryEntry>;
+    /** Rotate log continuity after restore and discard stale cursor records. */
+    rotatePartitionLogEpoch(partition: string, logEpoch: string, authenticatedAtMs: number): Promise<PartitionRegistryEntry>;
+    /** Registry entries ordered by partition for maintenance loops. */
+    listPartitionRegistry(): Promise<PartitionRegistryEntry[]>;
     begin(partition: string): Promise<StorageTransaction>;
     getMaxCommitSeq(partition: string): Promise<number>;
     getHorizonSeq(partition: string): Promise<number>;
@@ -427,10 +442,8 @@ export interface ServerStorage {
      * change scope index (never a log scan).
      * `getRowScopes`: the (table, rowId) row's current server_version and
      * stored scopes without decoding its payload — the row inspector.
-     * `listPartitions`: every partition this storage holds state for — the
-     * union of the partition registry (commit log counters) and client
-     * records, sorted. Powers the console's fleet view / partition picker;
-     * deliberately NOT partition-scoped (the one cross-partition read).
+     * `listPartitions`: the partition-only compatibility view of
+     * `listPartitionRegistry`, sorted.
      */
     listClientRecords?(partition: string): Promise<ClientRecord[]>;
     listCommitMetadata?(partition: string, query: CommitMetadataQuery): Promise<CommitMetadata[]>;
@@ -439,7 +452,7 @@ export interface ServerStorage {
         serverVersion: number;
         scopes: Record<string, string>;
     } | undefined>;
-    listPartitions?(): Promise<string[]>;
+    listPartitions(): Promise<string[]>;
 }
 /** A row referencing a blob, with the scopes needed to authorize download. */
 export interface BlobReferencingRow {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.15.47",
+  "version": "0.15.48",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -68,7 +68,7 @@
     "verify:node": "cd ../.. && bun build ./packages/server/test/sqlite-runtime/verify-node.mjs --target=node --conditions=bun --outfile=./packages/server/.verify-node.built.mjs && node ./packages/server/.verify-node.built.mjs"
   },
   "dependencies": {
-    "@syncular/core": "0.15.47"
+    "@syncular/core": "0.15.48"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"

package/src/admin.ts

@@ -520,17 +520,11 @@ export class SyncularAdmin {
     };
   }
 
-  /**
-   * Every partition the storage knows (commit log + client records) — the
-   * fleet-view backing and the console's partition picker. Fails loud when
-   * the backend omits the optional `listPartitions`.
-   */
+  /** Every authenticated partition in the storage-backed registry. */
   async listPartitions(): Promise<string[]> {
-    const list = required(
-      this.#storage.listPartitions?.bind(this.#storage),
-      'storage',
+    return (await this.#storage.listPartitionRegistry()).map(
+      (entry) => entry.partition,
     );
-    return list();
   }
 
   /**

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

@@ -95,6 +95,7 @@ import type {
   IndexRowScanQuery,
   NewCommit,
   NewReaction,
+  PartitionRegistryEntry,
   PrunedReactionCounts,
   ReactionClaimQuery,
   ReactionFailure,
@@ -752,6 +753,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 +868,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,
@@ -1390,12 +1488,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 +1503,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 +1516,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,
@@ -1494,12 +1595,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 +1609,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 +1731,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;