@syncular/server 0.15.47 → 0.16.1

package/dist/realtime.js

@@ -14,7 +14,7 @@
  * the `sync` wake-up (§8.3).
  */
 import { DecodeError, decodeMessage, encodeMessage, encodePresenceError, encodePresenceFanout, MessageStreamScanner, PROTOCOL_WIRE_VERSION, parseRealtimePresencePublish, REALTIME_TAG_DELTA, REALTIME_TAG_ROUND, } from '@syncular/core';
-import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE } from './context.js';
+import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE, touchAuthenticatedPartition, } from './context.js';
 import { SyncError, syncError } from './errors.js';
 import { emitEvent } from './events.js';
 import { createSyncResponseStream } from './handler.js';
@@ -120,6 +120,9 @@ export class RealtimeSession {
     partition;
     actorId;
     clientId;
+    logEpoch;
+    /** Response/delta layout selected by the most recent socket round. */
+    wireVersion;
     /** Highest contiguously applied commitSeq acknowledged by the client. */
     cursor;
     /** Suppress deltas until the client catches up via pull + ack (§8.2). */
@@ -144,11 +147,13 @@ export class RealtimeSession {
     /** §8.6.4 rate cap: per-scope-key last-fanout time + a pending latest
      * document coalesced while over the cap. */
     #presenceRate = new Map();
-    constructor(hub, options, registrations, cursor, latestSeq, clock, maxDeltaBytes, storage, events) {
+    constructor(hub, options, registrations, cursor, latestSeq, clock, maxDeltaBytes, storage, logEpoch, wireVersion, events) {
         this.sessionId = crypto.randomUUID();
         this.partition = options.partition;
         this.actorId = options.actorId;
         this.clientId = options.clientId;
+        this.logEpoch = logEpoch;
+        this.wireVersion = wireVersion;
         this.cursor = cursor;
         this.lastKnownSeq = latestSeq;
         this.wakePending = cursor < latestSeq;
@@ -376,6 +381,10 @@ export class RealtimeSession {
                 this.#activeRound = undefined;
         };
         try {
+            const requestedWireVersion = (requestBytes[4] ?? 0) | ((requestBytes[5] ?? 0) << 8);
+            if (requestedWireVersion === 1 || requestedWireVersion === 2) {
+                this.wireVersion = requestedWireVersion;
+            }
             let stream;
             try {
                 // §8.7: the round's clientId must match the connection's —
@@ -398,7 +407,7 @@ export class RealtimeSession {
                         ? error
                         : syncError(error.code, error.message);
                     finishRound(); // END is in this one chunk
-                    await this.#sendRoundChunk(errorResponseBytes(sync));
+                    await this.#sendRoundChunk(errorResponseBytes(sync, this.wireVersion, this.logEpoch));
                     return;
                 }
                 throw error;
@@ -550,7 +559,14 @@ export class RealtimeSession {
             this.sendWake('catchup-required');
             return;
         }
-        const frames = [{ type: 'RESP_HEADER' }];
+        const frames = [
+            {
+                type: 'RESP_HEADER',
+                ...(this.wireVersion >= 2
+                    ? { logEpoch: this.logEpoch, resetRequired: false }
+                    : {}),
+            },
+        ];
         for (const section of sections) {
             frames.push({
                 type: 'SUB_START',
@@ -571,7 +587,7 @@ export class RealtimeSession {
             frames.push({ type: 'SUB_END', nextCursor: commit.commitSeq });
         }
         const bytes = encodeMessage({
-            wireVersion: PROTOCOL_WIRE_VERSION,
+            wireVersion: this.wireVersion,
             msgKind: 'response',
             frames,
         });
@@ -770,6 +786,11 @@ export class RealtimeHub {
     async connect(options) {
         const { storage } = this.#config;
         const clock = this.#config.clock ?? Date.now;
+        const registry = await touchAuthenticatedPartition({
+            ...this.#config,
+            partition: options.partition,
+            actorId: options.actorId,
+        });
         if (options.clientId.startsWith(REMOTE_COMMAND_CLIENT_ID_PREFIX)) {
             throw syncError('sync.invalid_client_id', 'clientId uses a reserved server-command namespace (§1.5)');
         }
@@ -780,7 +801,7 @@ export class RealtimeHub {
         const registrations = await this.loadRegistrations(options.partition, options.actorId, options.clientId);
         const latestSeq = await storage.getMaxCommitSeq(options.partition);
         const cursor = record?.cursor ?? -1;
-        const session = new RealtimeSession(this, options, registrations, cursor, latestSeq, clock, this.#config.maxDeltaBytes ?? DEFAULT_MAX_DELTA_BYTES, storage, this.#config.events);
+        const session = new RealtimeSession(this, options, registrations, cursor, latestSeq, clock, this.#config.maxDeltaBytes ?? DEFAULT_MAX_DELTA_BYTES, storage, registry.logEpoch, record?.wireVersion ?? PROTOCOL_WIRE_VERSION, this.#config.events);
         this.#sessions.add(session);
         const helloResult = options.send(JSON.stringify({
             event: 'hello',
@@ -860,12 +881,15 @@ export function createRealtimeHub(config) {
 /** §8.7 failures: the socket has no HTTP status surface, so a
  * request-level failure becomes a minimal RESP_HEADER/ERROR/END
  * response message delivered as the round's response stream. */
-function errorResponseBytes(error) {
+function errorResponseBytes(error, wireVersion, logEpoch) {
     return encodeMessage({
-        wireVersion: PROTOCOL_WIRE_VERSION,
+        wireVersion,
         msgKind: 'response',
         frames: [
-            { type: 'RESP_HEADER' },
+            {
+                type: 'RESP_HEADER',
+                ...(wireVersion >= 2 ? { logEpoch, resetRequired: false } : {}),
+            },
             {
                 type: 'ERROR',
                 code: error.code,

package/dist/restore.d.ts

@@ -0,0 +1,13 @@
+import type { PartitionRegistryEntry, ServerStorage } from './storage.js';
+export interface RotatePartitionLogEpochOptions {
+    readonly storage: ServerStorage;
+    readonly partition: string;
+    readonly nowMs?: number;
+    /** Deterministic operator/test override. Defaults to a random UUID. */
+    readonly logEpoch?: string;
+}
+/**
+ * Fence clients from a prior authoritative database timeline after restore.
+ * Call while traffic and realtime delivery remain stopped (§2.1).
+ */
+export declare function rotatePartitionLogEpoch(options: RotatePartitionLogEpochOptions): Promise<PartitionRegistryEntry>;

package/dist/restore.js

@@ -0,0 +1,13 @@
+/**
+ * Fence clients from a prior authoritative database timeline after restore.
+ * Call while traffic and realtime delivery remain stopped (§2.1).
+ */
+export function rotatePartitionLogEpoch(options) {
+    if (options.partition.length === 0) {
+        throw new TypeError('partition must be non-empty');
+    }
+    const logEpoch = options.logEpoch ?? crypto.randomUUID();
+    if (logEpoch.length === 0)
+        throw new TypeError('logEpoch must be non-empty');
+    return options.storage.rotatePartitionLogEpoch(options.partition, logEpoch, options.nowMs ?? Date.now());
+}

package/dist/s3-segment-store.js

@@ -70,7 +70,13 @@ function parseRecordJson(json, source) {
         throw new Error(`S3SegmentStore: corrupt record in ${source}`);
     }
     const r = parsed;
-    const strings = ['segmentId', 'partition', 'table', 'scopeDigest'];
+    const strings = [
+        'segmentId',
+        'partition',
+        'logEpoch',
+        'table',
+        'scopeDigest',
+    ];
     const numbers = [
         'schemaVersion',
         'asOfCommitSeq',
@@ -99,6 +105,7 @@ function parseRecordJson(json, source) {
     return {
         segmentId: r.segmentId,
         partition: r.partition,
+        logEpoch: r.logEpoch,
         table: r.table,
         schemaVersion: r.schemaVersion,
         mediaType: r.mediaType,
@@ -136,6 +143,7 @@ export class S3SegmentStore {
     async #findKeyFor(key) {
         const canonical = JSON.stringify([
             key.partition,
+            key.logEpoch,
             key.table,
             key.schemaVersion,
             key.mediaType,
@@ -304,6 +312,7 @@ export class S3SegmentStore {
             return undefined;
         const record = parseRecordJson(await response.text(), 'reuse pointer');
         if (record.partition !== key.partition ||
+            record.logEpoch !== key.logEpoch ||
             record.table !== key.table ||
             record.schemaVersion !== key.schemaVersion ||
             record.mediaType !== key.mediaType ||

package/dist/seed.js

@@ -105,8 +105,42 @@ export async function seedMutations(config, target, mutations) {
             payload: encodeRow(table.columns, values),
         };
     });
+    const requestContext = {
+        ...config,
+        partition: target.partition,
+        actorId: target.actorId,
+    };
+    const acquisition = decodeMessage(await handleSyncRequest(encodeMessage({
+        wireVersion: PROTOCOL_WIRE_VERSION,
+        msgKind: 'request',
+        frames: [
+            {
+                type: 'REQ_HEADER',
+                clientId,
+                schemaVersion: config.schema.version,
+            },
+            {
+                type: 'PULL_HEADER',
+                limitCommits: 0,
+                limitSnapshotRows: 0,
+                maxSnapshotPages: 0,
+                accept: 0b0011,
+            },
+        ],
+    }), requestContext));
+    const acquisitionHeader = acquisition.frames[0];
+    if (acquisition.msgKind !== 'response' ||
+        acquisitionHeader?.type !== 'RESP_HEADER' ||
+        acquisitionHeader.logEpoch === undefined) {
+        throw new SyncError('sync.invalid_request', 'seedMutations: epoch acquisition returned an invalid response');
+    }
     const frames = [
-        { type: 'REQ_HEADER', clientId, schemaVersion: config.schema.version },
+        {
+            type: 'REQ_HEADER',
+            clientId,
+            schemaVersion: config.schema.version,
+            logEpoch: acquisitionHeader.logEpoch,
+        },
         { type: 'PUSH_COMMIT', clientCommitId, operations },
         // A pull that asks for nothing: the round exists for its push half.
         {
@@ -132,9 +166,7 @@ export async function seedMutations(config, target, mutations) {
         msgKind: 'request',
         frames,
     }), {
-        ...config,
-        partition: target.partition,
-        actorId: target.actorId,
+        ...requestContext,
         events: config.events === undefined
             ? capture
             : composeEvents(config.events, capture),

package/dist/segment-download.js

@@ -1,4 +1,4 @@
-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';
@@ -60,8 +60,11 @@ export async function handleSegmentDownload(ctx, request) {
     }
 }
 async function downloadSegment(ctx, request) {
+    const registry = await touchAuthenticatedPartition(ctx);
     const entry = await ctx.segments.get(request.segmentId);
-    if (entry === undefined || entry.record.partition !== ctx.partition) {
+    if (entry === undefined ||
+        entry.record.partition !== ctx.partition ||
+        entry.record.logEpoch !== registry.logEpoch) {
         throw syncError('sync.not_found', 'unknown segment (§5.5)');
     }
     if (entry.record.expiresAtMs <= clockOf(ctx)()) {

package/dist/segment-store.d.ts

@@ -1,6 +1,8 @@
 export declare const DEFAULT_SEGMENT_TTL_MS: number;
 export interface SegmentMetadata {
     readonly partition: string;
+    /** Partition log continuity that produced these bytes (§2.1). */
+    readonly logEpoch: string;
     readonly table: string;
     readonly schemaVersion: number;
     readonly mediaType: 'rows' | 'sqlite';
@@ -23,6 +25,7 @@ export interface SegmentRecord extends SegmentMetadata {
  */
 export interface SegmentFindKey {
     readonly partition: string;
+    readonly logEpoch: string;
     readonly table: string;
     readonly schemaVersion: number;
     readonly mediaType: 'rows' | 'sqlite';

package/dist/segment-store.js

@@ -35,6 +35,7 @@ export class MemorySegmentStore {
     async find(key, nowMs) {
         for (const { record } of this.#entries.values()) {
             if (record.partition === key.partition &&
+                record.logEpoch === key.logEpoch &&
                 record.table === key.table &&
                 record.schemaVersion === key.schemaVersion &&
                 record.mediaType === key.mediaType &&

package/dist/sqlite-bun-driver.d.ts

@@ -2,7 +2,8 @@ import { Database } from 'bun:sqlite';
 import type { SqliteDatabase, SqliteRunResult, SqliteStatement, SqliteValue } from './sqlite-driver.js';
 export declare class BunSqliteDatabase implements SqliteDatabase {
     readonly native: Database;
-    constructor(path?: string);
+    constructor(value?: string | Database);
+    static deserialize(bytes: Uint8Array): BunSqliteDatabase;
     exec(sql: string): void;
     run(sql: string, bindings?: readonly SqliteValue[]): SqliteRunResult;
     query<Row, Params extends readonly SqliteValue[]>(sql: string): SqliteStatement<Row, Params>;

package/dist/sqlite-bun-driver.js

@@ -1,8 +1,11 @@
 import { Database } from 'bun:sqlite';
 export class BunSqliteDatabase {
     native;
-    constructor(path = ':memory:') {
-        this.native = new Database(path);
+    constructor(value = ':memory:') {
+        this.native = typeof value === 'string' ? new Database(value) : value;
+    }
+    static deserialize(bytes) {
+        return new BunSqliteDatabase(Database.deserialize(bytes));
     }
     exec(sql) {
         this.native.exec(sql);

package/dist/sqlite-bun.js

@@ -27,10 +27,10 @@ export class SqliteLeaseStore extends SharedSqliteLeaseStore {
         super(database(value), options);
     }
 }
-export const buildSqliteImage = (input) => {
+export const buildSqliteImage = async (input) => {
     const db = new BunSqliteDatabase();
     try {
-        writeSqliteImage(db, input);
+        await writeSqliteImage(db, input);
         return db.serialize();
     }
     finally {

package/dist/sqlite-dialect.d.ts

@@ -30,7 +30,7 @@ import type { StoredChange, StoredCommit, StoredPushResult, StoredRow } from './
  * the Postgres storage documents (§3.1, performance-by-
  * construction).
  */
-export declare const SQLITE_DDL = "\nCREATE TABLE IF NOT EXISTS sync_partitions(\n  partition TEXT PRIMARY KEY,\n  max_commit_seq INTEGER NOT NULL DEFAULT 0,\n  horizon_seq INTEGER NOT NULL DEFAULT 0\n);\nCREATE TABLE IF NOT EXISTS sync_row_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, row_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, row_id)\n);\nCREATE TABLE IF NOT EXISTS sync_commits(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  client_id TEXT NOT NULL, client_commit_id TEXT NOT NULL,\n  actor_id TEXT NOT NULL, created_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, commit_seq)\n);\nCREATE INDEX IF NOT EXISTS sync_commits_by_time\n  ON sync_commits(partition, created_at_ms);\nCREATE TABLE IF NOT EXISTS sync_changes(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL, idx INTEGER NOT NULL,\n  tbl TEXT NOT NULL, row_id TEXT NOT NULL, op INTEGER NOT NULL,\n  row_version INTEGER, scopes TEXT NOT NULL, payload BLOB,\n  PRIMARY KEY(partition, commit_seq, idx)\n);\nCREATE INDEX IF NOT EXISTS sync_changes_by_table\n  ON sync_changes(partition, commit_seq, tbl, idx);\nCREATE TABLE IF NOT EXISTS sync_change_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, commit_seq)\n);\nCREATE TABLE IF NOT EXISTS sync_push_results(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL,\n  client_commit_id TEXT NOT NULL, result TEXT NOT NULL,\n  PRIMARY KEY(partition, client_id, client_commit_id)\n);\nCREATE TABLE IF NOT EXISTS sync_reactions(\n  partition TEXT NOT NULL, idempotency_key TEXT NOT NULL,\n  type TEXT NOT NULL, version INTEGER NOT NULL, payload TEXT NOT NULL,\n  source_client_id TEXT NOT NULL, source_client_commit_id TEXT NOT NULL,\n  source_commit_seq INTEGER NOT NULL, created_at_ms INTEGER NOT NULL,\n  available_at_ms INTEGER NOT NULL, status TEXT NOT NULL,\n  attempts INTEGER NOT NULL, max_attempts INTEGER NOT NULL,\n  lease_owner TEXT, lease_expires_at_ms INTEGER, completed_at_ms INTEGER,\n  last_failure TEXT,\n  PRIMARY KEY(partition, idempotency_key),\n  CHECK(status IN ('pending', 'leased', 'completed', 'dead-letter'))\n);\nCREATE INDEX IF NOT EXISTS sync_reactions_due\n  ON sync_reactions(partition, status, available_at_ms, created_at_ms, idempotency_key);\nCREATE INDEX IF NOT EXISTS sync_reactions_lease\n  ON sync_reactions(partition, status, lease_expires_at_ms);\nCREATE INDEX IF NOT EXISTS sync_reactions_completed\n  ON sync_reactions(partition, status, completed_at_ms, idempotency_key);\nCREATE INDEX IF NOT EXISTS sync_reactions_dead_letter\n  ON sync_reactions(partition, status, available_at_ms, idempotency_key);\nCREATE TABLE IF NOT EXISTS sync_clients(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,\n  cursor INTEGER NOT NULL, subscriptions TEXT NOT NULL,\n  updated_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, client_id)\n);\nCREATE TABLE IF NOT EXISTS sync_blob_refs(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL, row_id TEXT NOT NULL,\n  blob_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, row_id, blob_id)\n);\nCREATE INDEX IF NOT EXISTS sync_blob_refs_by_blob\n  ON sync_blob_refs(partition, blob_id);\n";
+export declare const SQLITE_DDL = "\nCREATE TABLE IF NOT EXISTS sync_partitions(\n  partition TEXT PRIMARY KEY,\n  max_commit_seq INTEGER NOT NULL DEFAULT 0,\n  horizon_seq INTEGER NOT NULL DEFAULT 0\n);\nCREATE TABLE IF NOT EXISTS sync_partition_registry(\n  partition TEXT PRIMARY KEY,\n  log_epoch TEXT NOT NULL,\n  epoch_required INTEGER NOT NULL DEFAULT 0,\n  last_authenticated_at_ms INTEGER NOT NULL\n);\nCREATE TABLE IF NOT EXISTS sync_row_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, row_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, row_id)\n);\nCREATE TABLE IF NOT EXISTS sync_commits(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  client_id TEXT NOT NULL, client_commit_id TEXT NOT NULL,\n  actor_id TEXT NOT NULL, created_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, commit_seq)\n);\nCREATE INDEX IF NOT EXISTS sync_commits_by_time\n  ON sync_commits(partition, created_at_ms);\nCREATE TABLE IF NOT EXISTS sync_changes(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL, idx INTEGER NOT NULL,\n  tbl TEXT NOT NULL, row_id TEXT NOT NULL, op INTEGER NOT NULL,\n  row_version INTEGER, scopes TEXT NOT NULL, payload BLOB,\n  PRIMARY KEY(partition, commit_seq, idx)\n);\nCREATE INDEX IF NOT EXISTS sync_changes_by_table\n  ON sync_changes(partition, commit_seq, tbl, idx);\nCREATE TABLE IF NOT EXISTS sync_change_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, commit_seq)\n);\nCREATE TABLE IF NOT EXISTS sync_push_results(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL,\n  client_commit_id TEXT NOT NULL, result TEXT NOT NULL,\n  PRIMARY KEY(partition, client_id, client_commit_id)\n);\nCREATE TABLE IF NOT EXISTS sync_reactions(\n  partition TEXT NOT NULL, idempotency_key TEXT NOT NULL,\n  type TEXT NOT NULL, version INTEGER NOT NULL, payload TEXT NOT NULL,\n  source_client_id TEXT NOT NULL, source_client_commit_id TEXT NOT NULL,\n  source_commit_seq INTEGER NOT NULL, created_at_ms INTEGER NOT NULL,\n  available_at_ms INTEGER NOT NULL, status TEXT NOT NULL,\n  attempts INTEGER NOT NULL, max_attempts INTEGER NOT NULL,\n  lease_owner TEXT, lease_expires_at_ms INTEGER, completed_at_ms INTEGER,\n  last_failure TEXT,\n  PRIMARY KEY(partition, idempotency_key),\n  CHECK(status IN ('pending', 'leased', 'completed', 'dead-letter'))\n);\nCREATE INDEX IF NOT EXISTS sync_reactions_due\n  ON sync_reactions(partition, status, available_at_ms, created_at_ms, idempotency_key);\nCREATE INDEX IF NOT EXISTS sync_reactions_lease\n  ON sync_reactions(partition, status, lease_expires_at_ms);\nCREATE INDEX IF NOT EXISTS sync_reactions_completed\n  ON sync_reactions(partition, status, completed_at_ms, idempotency_key);\nCREATE INDEX IF NOT EXISTS sync_reactions_dead_letter\n  ON sync_reactions(partition, status, available_at_ms, idempotency_key);\nCREATE TABLE IF NOT EXISTS sync_clients(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,\n  wire_version INTEGER NOT NULL DEFAULT 1,\n  cursor INTEGER NOT NULL, subscriptions TEXT NOT NULL,\n  updated_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, client_id)\n);\nCREATE TABLE IF NOT EXISTS sync_blob_refs(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL, row_id TEXT NOT NULL,\n  blob_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, row_id, blob_id)\n);\nCREATE INDEX IF NOT EXISTS sync_blob_refs_by_blob\n  ON sync_blob_refs(partition, blob_id);\n";
 /** Split the DDL into individual statements (D1 applies them one by one). */
 export declare function sqliteDdlStatements(): string[];
 /** `?,?,…` for an `IN (…)` clause of `count` positional parameters. */

package/dist/sqlite-dialect.js

@@ -18,6 +18,12 @@ CREATE TABLE IF NOT EXISTS sync_partitions(
   max_commit_seq INTEGER NOT NULL DEFAULT 0,
   horizon_seq INTEGER NOT NULL DEFAULT 0
 );
+CREATE TABLE IF NOT EXISTS sync_partition_registry(
+  partition TEXT PRIMARY KEY,
+  log_epoch TEXT NOT NULL,
+  epoch_required INTEGER NOT NULL DEFAULT 0,
+  last_authenticated_at_ms INTEGER 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,
@@ -71,6 +77,7 @@ 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 INTEGER NOT NULL, subscriptions TEXT NOT NULL,
   updated_at_ms INTEGER NOT NULL,
   PRIMARY KEY(partition, client_id)

package/dist/sqlite-image.d.ts

@@ -10,7 +10,7 @@ export interface SqliteImageInput {
     readonly schemaVersion: number;
     readonly asOfCommitSeq: number;
     readonly scopeDigest: string;
-    readonly rows: readonly StoredRow[];
+    readonly rowBatches: AsyncIterable<readonly StoredRow[]> | Iterable<readonly StoredRow[]>;
 }
 /**
  * The §5.3 image-builder capability, injected through
@@ -20,6 +20,6 @@ export interface SqliteImageInput {
  * on the pull path. A Bun or Node host passes `buildSqliteImage`; a Workers
  * host omits it and serves the rows lane.
  */
-export type SqliteImageBuilder = (input: SqliteImageInput) => Uint8Array;
+export type SqliteImageBuilder = (input: SqliteImageInput) => Promise<Uint8Array>;
 /** Populate a §5.3 image database for a whole-table snapshot. */
-export declare function writeSqliteImage(db: SqliteDatabase, input: SqliteImageInput): void;
+export declare function writeSqliteImage(db: SqliteDatabase, input: SqliteImageInput): Promise<void>;

package/dist/sqlite-image.js

@@ -45,8 +45,8 @@ function toSql(value) {
     return value;
 }
 /** Populate a §5.3 image database for a whole-table snapshot. */
-export function writeSqliteImage(db, input) {
-    const { table, rows } = input;
+export async function writeSqliteImage(db, input) {
+    const { table, rowBatches } = input;
     const primaryKey = table.columns[table.primaryKeyIndex]?.name;
     const columnDefs = table.columns.map((column) => {
         const notNull = column.nullable ? '' : ' NOT NULL';
@@ -59,7 +59,6 @@ export function writeSqliteImage(db, input) {
       format INTEGER NOT NULL, "table" TEXT NOT NULL,
       "schemaVersion" INTEGER NOT NULL, "asOfCommitSeq" INTEGER NOT NULL,
       "scopeDigest" TEXT NOT NULL, "rowCount" INTEGER NOT NULL)`);
-    db.query(`INSERT INTO ${IMAGE_METADATA_TABLE} VALUES (1, ?, ?, ?, ?, ?)`).run(table.name, input.schemaVersion, input.asOfCommitSeq, input.scopeDigest, rows.length);
     const names = [
         ...table.columns.map((column) => quoteIdent(column.name)),
         quoteIdent(IMAGE_VERSION_COLUMN),
@@ -68,10 +67,15 @@ export function writeSqliteImage(db, input) {
      VALUES (${names.map(() => '?').join(', ')})`);
     db.exec('BEGIN');
     try {
-        for (const row of rows) {
-            const values = decodeRow(table.columns, row.payload);
-            insert.run(...values.map(toSql), row.serverVersion);
+        let rowCount = 0;
+        for await (const rows of rowBatches) {
+            for (const row of rows) {
+                const values = decodeRow(table.columns, row.payload);
+                insert.run(...values.map(toSql), row.serverVersion);
+            }
+            rowCount += rows.length;
         }
+        db.query(`INSERT INTO ${IMAGE_METADATA_TABLE} VALUES (1, ?, ?, ?, ?, ?)`).run(table.name, input.schemaVersion, input.asOfCommitSeq, input.scopeDigest, rowCount);
         db.exec('COMMIT');
     }
     catch (error) {

package/dist/sqlite-node.js

@@ -30,13 +30,13 @@ export class SqliteLeaseStore extends SharedSqliteLeaseStore {
         super(database(value), options);
     }
 }
-export const buildSqliteImage = (input) => {
+export const buildSqliteImage = async (input) => {
     const directory = mkdtempSync(join(tmpdir(), 'syncular-server-image-'));
     const path = join(directory, 'segment.db');
     const db = new NodeSqliteDatabase(path);
     try {
         try {
-            writeSqliteImage(db, input);
+            await writeSqliteImage(db, input);
         }
         finally {
             db.close();

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,7 @@
+import type { CommitPruneQuery, CommitPruneResult } from './storage.js';
 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,14 +9,18 @@ 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;
     getMaxCommitSeq(partition: string): Promise<number>;
     queryAuthoritative(partition: string, query: AuthoritativeQueryRequest): Promise<AuthoritativeQueryResult>;
+    getPartitionLogEpoch(partition: string): Promise<string | undefined>;
     getHorizonSeq(partition: string): Promise<number>;
     setHorizonSeq(partition: string, seq: number): Promise<void>;
-    pruneCommitsThrough(partition: string, seq: number): Promise<number>;
+    pruneCommitsThrough(partition: string, query: CommitPruneQuery): Promise<CommitPruneResult>;
     getCommitSeqBefore(partition: string, createdBeforeMs: number): Promise<number>;
     getRow(partition: string, table: string, rowId: string): Promise<StoredRow | undefined>;
     getPushResult(partition: string, clientId: string, clientCommitId: string): Promise<StoredPushResult | undefined>;
@@ -32,6 +37,7 @@ export declare class SqliteServerStorage implements ServerStorage {
     scanRowsByIndex(partition: string, query: IndexRowScanQuery): Promise<StoredRow[]>;
     getClientRecord(partition: string, clientId: string): Promise<ClientRecord | undefined>;
     putClientRecord(partition: string, record: ClientRecord): Promise<void>;
+    getActiveClientCursorFloor(partition: string, cutoffMs: number): Promise<number | null>;
     listClientCursors(partition: string): Promise<ClientCursorInfo[]>;
     listRowsReferencingBlob(partition: string, blobId: string): Promise<{
         readonly table: string;