@syncular/server 0.15.46 → 0.15.48

package/README.md

@@ -29,7 +29,7 @@ The supported set, and what deliberately does **not** get an adapter:
 
 | Runtime | Adapter | Transport | Storage | Status |
 | --- | --- | --- | --- | --- |
-| **Bun / Node** | `@syncular/server-hono` | HTTP (`POST /sync`, segments, blobs) **+ WS realtime** (§8, host-driven upgrade) | any: `SqliteServerStorage`, `PostgresServerStorage`, memory | **Supported now** — the reference deployment; runs the full conformance catalog on both bindings. |
+| **Bun / Node 22.13+** | `@syncular/server-hono` | HTTP (`POST /sync`, segments, blobs) **+ WS realtime** (§8, host-driven upgrade) | `SqliteServerStorage` through `@syncular/server/sqlite`, Postgres, memory | **Supported now** — the reference deployment; runs the full conformance catalog on both bindings. |
 | **Cloudflare Workers** | `@syncular/server-workers` | HTTP binding via Hono (Workers-native) **+ optional WS realtime** (§8) | `D1ServerStorage` behind one per-partition Durable Object queue; R2-as-S3 for segments/blobs | **Supported now** — D1 sync writes always traverse the DO; WebSocket upgrades remain optional. |
 | Raw Deno / edge-misc | — | — | — | **Not adapted** (policy below). |
 
@@ -76,9 +76,9 @@ or the storage projection cannot migrate:
 ```ts
 import {
   ensureSyncServerReady,
-  SqliteServerStorage,
   type SyncServerConfig,
 } from '@syncular/server';
+import { SqliteServerStorage } from '@syncular/server/sqlite';
 
 const config: SyncServerConfig = {
   schema,
@@ -91,6 +91,12 @@ await ensureSyncServerReady(config);
 Bun.serve({ fetch: app.fetch });
 ```
 
+`@syncular/server/sqlite` selects `bun:sqlite` on Bun and the built-in
+`node:sqlite` module on Node. It covers server storage, segment storage, blob
+storage, leases, and SQLite-image generation without an external SQLite
+package. The runtime-specific database wrappers are `BunSqliteDatabase` and
+`NodeSqliteDatabase` when a host needs direct access to the native handle.
+
 The helper accepts the generated `ServerSchema`, compiles it, and calls the
 storage backend's low-level `ensureSchema(CompiledSchema)`. A failure is a
 `SyncServerReadinessError` with stable code `sync.schema_not_ready`, a `phase`
@@ -99,6 +105,12 @@ Log the cause for operators and stop startup. Do not catch readiness errors in
 authentication or convert them to a 401; request-time schema checks are only a
 defensive fallback.
 
+After restoring an authoritative database, keep traffic stopped and call
+`rotatePartitionLogEpoch({ storage, partition })` for every restored
+partition. The rotation clears stale client cursors and requires version 2
+clients to reset their server-derived rows while preserving the outbox. Follow
+the complete [backup and restore runbook](https://syncular.dev/server-backup-restore/).
+
 ## Write validators and recovery metadata
 
 `validators` is the server-authoritative seam for row business rules that
@@ -501,7 +513,7 @@ by design:
 | `horizonStatus(partition)` | `{maxCommitSeq, horizonSeq, retainedCommits, activeCursorFloor, recommendedHorizonSeq, recommendation}` — the horizon a prune pass would reach now (§4.6) + a coarse `up-to-date` / `prune-recommended`. |
 | `segmentStats()` / `blobStats(partition)` / `stats(partition)` | Counts/bytes where the stores expose them (segments split rows/sqlite). `undefined` when a store omits `stats()`. |
 | `metrics(partition, {windowMs?, buckets?})` | Ring-derived request/push health over a trailing window (default 5 min): request count/rate, error share, p50/p95 duration, push applied/rejected/conflicted, and per-bucket counts for a sparkline. Zero new server state; all zeros when no ring is wired. |
-| `listPartitions()` / `partitionsOverview()` | Every partition the storage holds state for; the overview adds retained backlog, client counts (known/active), and the prune recommendation per partition — the fleet view. |
+| `listPartitionRegistry()` / `partitionsOverview()` | Every authenticated partition; the registry carries log continuity and last-authenticated time, while the overview adds retained backlog, client counts, and the prune recommendation. |
 | `events({type?, sinceMs?, clientId?, actorId?, limit?})` | The ring tail, newest first. Empty when no ring is wired (`hasEventStream` reports which). |
 | `subscribeEvents(listener)` | Live events as they land in the ring; returns the unsubscribe function, `undefined` when no ring is wired. |
 
@@ -974,7 +986,8 @@ same table+scope during a storm, your TTL is shorter than the storm.
 
 ## Postgres storage (the production database path)
 
-`SqliteServerStorage` (bun:sqlite) is the dev-speed default. For
+`SqliteServerStorage` from `@syncular/server/sqlite` uses `bun:sqlite` or
+Node's built-in `node:sqlite`. For
 production, `PostgresServerStorage` implements the same `ServerStorage`
 contract against Postgres, with the inverted scope index carried through
 as **covering indexes** so scope fanout is an index range scan, never a

package/dist/admin.d.ts

@@ -223,11 +223,7 @@ export declare class SyncularAdmin {
         readonly windowMs?: number;
         readonly buckets?: number;
     }): AdminMetrics;
-    /**
-     * 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. */
     listPartitions(): Promise<string[]>;
     /**
      * The fleet view: one row per known partition — retained backlog, client

package/dist/admin.js

@@ -283,14 +283,9 @@ export class SyncularAdmin {
             buckets: { widthMs, counts, errors },
         };
     }
-    /**
-     * 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() {
-        const list = required(this.#storage.listPartitions?.bind(this.#storage), 'storage');
-        return list();
+        return (await this.#storage.listPartitionRegistry()).map((entry) => entry.partition);
     }
     /**
      * The fleet view: one row per known partition — retained backlog, client

package/dist/blob-handlers.js

@@ -7,7 +7,7 @@
  * adapters map these onto `PUT/GET <mount>/blobs/{blobId}`.
  */
 import { blobIdFor, isBlobId } from './blob-store.js';
-import { clockOf, RESOLVER_OUTAGE } from './context.js';
+import { clockOf, RESOLVER_OUTAGE, touchAuthenticatedPartition, } from './context.js';
 import { SyncError, syncError } from './errors.js';
 import { emitEvent } from './events.js';
 import { compileSchema } from './schema.js';
@@ -16,6 +16,7 @@ import { issueBlobUploadUrl, issueBlobUrl } from './signed-url.js';
 const DEFAULT_MAX_BLOB_BYTES = 64 * 1024 * 1024;
 /** `PUT <mount>/blobs/{blobId}` (§5.9.3). Host auth is the adapter's job. */
 export async function handleBlobUpload(ctx, request) {
+    await touchAuthenticatedPartition(ctx);
     const store = ctx.blobs;
     if (store === undefined) {
         throw syncError('blob.not_found', 'this server has no blob store (§5.9)');
@@ -50,6 +51,7 @@ export async function handleBlobUpload(ctx, request) {
  * reference index passes the §3.4 scope check for the actor.
  */
 export async function handleBlobDownload(ctx, blobId) {
+    await touchAuthenticatedPartition(ctx);
     const events = ctx.events;
     if (events === undefined)
         return downloadBlob(ctx, blobId);
@@ -213,6 +215,7 @@ async function downloadBlob(ctx, blobId) {
  * result when no presigned-upload store is configured (client streams direct).
  */
 export async function handleBlobUploadGrant(ctx, request) {
+    await touchAuthenticatedPartition(ctx);
     const store = ctx.blobs;
     if (store === undefined) {
         throw syncError('blob.not_found', 'this server has no blob store (§5.9)');

package/dist/context.d.ts

@@ -14,7 +14,7 @@ import type { ServerSchema } from './schema.js';
 import type { SegmentStore } from './segment-store.js';
 import type { BlobPresignConfig, BlobUploadPresignConfig, SegmentUrlConfig } from './signed-url.js';
 import type { SqliteImageBuilder } from './sqlite-image.js';
-import type { ServerStorage, StoredCommit } from './storage.js';
+import type { PartitionRegistryEntry, ServerStorage, StoredCommit } from './storage.js';
 import type { CommitValidator, ValidatorRegistry } from './validate.js';
 /** SSP2 body content type (§1.1). */
 export declare const SSP2_CONTENT_TYPE = "application/vnd.syncular.sync.v2";
@@ -148,7 +148,8 @@ export interface SyncServerConfig {
      * §5.3 sqlite-image builder, injected so the pull path never
      * statically imports `bun:sqlite`. Absent ⇒ the sqlite-image lane is off
      * (bit-2 clients are served the rows lane) — the Workers/edge posture. A
-     * Bun/Node host wires `buildSqliteImage` from `@syncular/server`.
+     * Bun or Node host wires `buildSqliteImage` from
+     * `@syncular/server/sqlite`.
      */
     readonly sqliteImageBuilder?: SqliteImageBuilder;
     readonly realtime?: RealtimeNotifier;
@@ -165,3 +166,5 @@ export interface SyncRequestContext extends SyncServerConfig {
 }
 export declare function clockOf(ctx: SyncServerConfig): () => number;
 export declare function limitsOf(ctx: SyncServerConfig): ServerLimits;
+/** Refresh the registry after host authentication and return log continuity. */
+export declare function touchAuthenticatedPartition(ctx: SyncRequestContext): Promise<PartitionRegistryEntry>;

package/dist/context.js

@@ -21,3 +21,7 @@ export function clockOf(ctx) {
 export function limitsOf(ctx) {
     return { ...DEFAULT_LIMITS, ...ctx.limits };
 }
+/** Refresh the registry after host authentication and return log continuity. */
+export function touchAuthenticatedPartition(ctx) {
+    return ctx.storage.touchPartition(ctx.partition, clockOf(ctx)(), crypto.randomUUID());
+}

package/dist/d1-storage.d.ts

@@ -1,5 +1,5 @@
 import type { CompiledSchema, CompiledTable } from './schema.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 interface D1PreparedStatement {
     bind(...values: unknown[]): D1PreparedStatement;
     first<T = Record<string, unknown>>(): Promise<T | null>;
@@ -36,6 +36,9 @@ export declare class D1ServerStorage 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>;
     getMaxCommitSeq(partition: string): Promise<number>;
     queryAuthoritative(partition: string, query: AuthoritativeQueryRequest): Promise<AuthoritativeQueryResult>;

package/dist/d1-storage.js

@@ -479,6 +479,12 @@ export class D1ServerStorage {
         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();
+        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`. */
     table(name) {
@@ -563,6 +569,68 @@ export class D1ServerStorage {
         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');
+        }
+        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();
+        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');
+        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() {
+        const { results } = await this.#db
+            .prepare(`SELECT partition, log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry ORDER BY partition`)
+            .all();
+        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, oldLayout) {
         const select = selectRowsForRewriteSql(table, 'sqlite');
@@ -912,7 +980,7 @@ export class D1ServerStorage {
     }
     async getClientRecord(partition, clientId) {
         const record = await this.#db
-            .prepare('SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?')
+            .prepare('SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?')
             .bind(partition, clientId)
             .first();
         if (record === null)
@@ -920,6 +988,7 @@ export class D1ServerStorage {
         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),
@@ -927,8 +996,8 @@ export class D1ServerStorage {
     }
     async putClientRecord(partition, record) {
         await this.#db
-            .prepare('INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?)')
-            .bind(partition, record.clientId, record.actorId, record.cursor, JSON.stringify(record.subscriptions), record.updatedAtMs)
+            .prepare('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)
             .run();
     }
     async listClientCursors(partition) {
@@ -976,12 +1045,13 @@ export class D1ServerStorage {
     // -- admin/console read surface --------------------------------------------
     async listClientRecords(partition) {
         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')
+            .prepare('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();
         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),
@@ -1065,12 +1135,6 @@ export class D1ServerStorage {
         };
     }
     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 { results } = await this.#db
-            .prepare(`SELECT partition FROM sync_partitions
-         UNION SELECT partition FROM sync_clients ORDER BY partition`)
-            .all();
-        return results.map((r) => r.partition);
+        return (await this.listPartitionRegistry()).map((entry) => entry.partition);
     }
 }

package/dist/errors.js

@@ -191,6 +191,12 @@ export const ERROR_CATALOG = {
         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/dist/events.d.ts

@@ -28,10 +28,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;

package/dist/frame-bytes.d.ts

@@ -10,11 +10,11 @@
  */
 import { type ResponseFrame } from '@syncular/core';
 /** The 8-byte SSP2 response envelope header (§1.2). */
-export declare const RESPONSE_ENVELOPE_HEADER: Uint8Array;
+export declare function responseEnvelopeHeader(wireVersion: number): Uint8Array;
 /** The terminating END frame (§1.2 rule 1). */
 export declare const END_FRAME_BYTES: Uint8Array;
 /**
  * Encode one response frame (5-byte frame header + payload) using the
  * reference codec.
  */
-export declare function encodeResponseFrame(frame: ResponseFrame): Uint8Array;
+export declare function encodeResponseFrame(frame: ResponseFrame, wireVersion?: number): Uint8Array;

package/dist/frame-bytes.js

@@ -9,7 +9,13 @@
  * bytes; the reference codec remains the single source of wire bytes.
  */
 import { encodeMessage, PROTOCOL_WIRE_VERSION, } from '@syncular/core';
-const STUB_HEADER = { type: 'RESP_HEADER' };
+const stubHeader = (wireVersion) => wireVersion >= 2
+    ? {
+        type: 'RESP_HEADER',
+        logEpoch: 'frame-probe',
+        resetRequired: false,
+    }
+    : { type: 'RESP_HEADER' };
 const STUB_SUB_START = {
     type: 'SUB_START',
     id: '',
@@ -20,25 +26,32 @@ const STUB_SUB_START = {
 };
 const STUB_SUB_END = { 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 = probe.slice(0, 8);
+export function responseEnvelopeHeader(wireVersion) {
+    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 = probe.slice(probe.length - 5);
-function wrapperFor(frame) {
+function wrapperFor(frame, wireVersion) {
     switch (frame.type) {
         case 'RESP_HEADER':
             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 = {
                 type: 'PUSH_RESULT',
@@ -52,17 +65,23 @@ function wrapperFor(frame) {
                     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,
             };
     }
@@ -71,10 +90,10 @@ function wrapperFor(frame) {
  * Encode one response frame (5-byte frame header + payload) using the
  * reference codec.
  */
-export function encodeResponseFrame(frame) {
-    const { frames, index } = wrapperFor(frame);
+export function encodeResponseFrame(frame, wireVersion = PROTOCOL_WIRE_VERSION) {
+    const { frames, index } = wrapperFor(frame, wireVersion);
     const encoded = encodeMessage({
-        wireVersion: PROTOCOL_WIRE_VERSION,
+        wireVersion,
         msgKind: 'response',
         frames,
     });

package/dist/handler.js

@@ -10,10 +10,10 @@
  * frame (§1.6).
  */
 import { DecodeError, decodeMessage, } from '@syncular/core';
-import { clockOf, limitsOf, REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE, } from './context.js';
+import { clockOf, limitsOf, REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE, touchAuthenticatedPartition, } from './context.js';
 import { SyncError, syncError } from './errors.js';
 import { emitEvent, } from './events.js';
-import { END_FRAME_BYTES, encodeResponseFrame, RESPONSE_ENVELOPE_HEADER, } from './frame-bytes.js';
+import { END_FRAME_BYTES, encodeResponseFrame, responseEnvelopeHeader, } from './frame-bytes.js';
 import { ACCEPT_EXTERNAL_ROWS, ACCEPT_INLINE_ROWS, clampPullLimits, subscriptionSection, } from './pull.js';
 import { processPushCommitWithTrace } from './push.js';
 import { compileSchema } from './schema.js';
@@ -96,7 +96,7 @@ async function resolveOnce(ctx, clientId, schema) {
     }
     return { resolved: { ok: true, allowed }, leaseToEmit };
 }
-async function planRequest(request, ctx, schema) {
+async function planRequest(request, ctx, schema, registry) {
     const header = request.frames[0];
     if (header === undefined || header.type !== 'REQ_HEADER') {
         throw syncError('sync.invalid_request', 'missing REQ_HEADER');
@@ -112,10 +112,22 @@ async function planRequest(request, ctx, schema) {
         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,
@@ -125,6 +137,20 @@ async function planRequest(request, ctx, schema) {
             leaseToEmit: undefined,
         };
     }
+    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', 'clientId uses a reserved server-command namespace (§1.5)');
     }
@@ -181,6 +207,9 @@ async function planRequest(request, ctx, schema) {
         return { frame, table, status: 'revoked', effective: {} };
     });
     return {
+        wireVersion: request.wireVersion,
+        logEpoch: registry.logEpoch,
+        epochReset: false,
         header,
         pushes,
         pull,
@@ -256,7 +285,7 @@ function emitPushEvent(events, ctx, clientId, push, processed) {
 }
 async function* streamResponse(plan, ctx, schema, report) {
     const events = ctx.events;
-    yield RESPONSE_ENVELOPE_HEADER;
+    yield responseEnvelopeHeader(plan.wireVersion);
     if (plan.schemaFloor) {
         if (report !== undefined)
             report.outcome = 'schema_floor';
@@ -264,21 +293,33 @@ async function* streamResponse(plan, ctx, schema, report) {
             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',
         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;
+    }
     // §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,
-        });
+        }, plan.wireVersion);
         if (events !== undefined) {
             emitEvent(events, {
                 type: 'lease.issued',
@@ -299,10 +340,11 @@ async function* streamResponse(plan, ctx, schema, report) {
             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.
         const cursors = [];
@@ -313,7 +355,7 @@ async function* streamResponse(plan, ctx, schema, report) {
             const horizonSeq = await ctx.storage.getHorizonSeq(ctx.partition);
             for (const subscription of plan.subscriptions) {
                 const trace = summaries !== undefined ? { segments: [] } : undefined;
-                const section = subscriptionSection(ctx, schema, limits, subscription, maxSeq, horizonSeq, trace);
+                const section = subscriptionSection(ctx, schema, limits, subscription, maxSeq, horizonSeq, trace, plan.logEpoch);
                 let status = 'active';
                 let bootstrap = false;
                 let commits = 0;
@@ -331,7 +373,7 @@ async function* streamResponse(plan, ctx, schema, report) {
                             changes += frame.changes.length;
                         }
                     }
-                    yield encodeResponseFrame(frame);
+                    yield encodeResponseFrame(frame, plan.wireVersion);
                     step = await section.next();
                 }
                 if (step.value.active)
@@ -379,6 +421,7 @@ async function* streamResponse(plan, ctx, schema, report) {
         await ctx.storage.putClientRecord(ctx.partition, {
             clientId: plan.header.clientId,
             actorId: ctx.actorId,
+            wireVersion: plan.wireVersion,
             cursor,
             updatedAtMs: clockOf(ctx)(),
             subscriptions,
@@ -399,7 +442,7 @@ async function* streamResponse(plan, ctx, schema, report) {
                 retryable: error.retryable,
                 recommendedAction: error.recommendedAction,
                 ...(error.details !== undefined ? { details: error.details } : {}),
-            });
+            }, plan.wireVersion);
             yield END_FRAME_BYTES;
             return;
         }
@@ -461,7 +504,8 @@ async function createStreamCore(bytes, ctx, events, startedAtMs = 0) {
     // 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 = { outcome: 'ok' };

package/dist/index-bun.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, BunSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-bun.js';

package/dist/index-bun.js

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, BunSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-bun.js';

package/dist/index-node.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, NodeSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-node.js';

package/dist/index-node.js

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, NodeSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-node.js';