@syncular/server-dialect-sqlite 0.0.1 → 0.0.2-126

package/src/index.ts

@@ -14,31 +14,28 @@
  */
 
 import type { ScopeValues, StoredScopes, SyncOp } from '@syncular/core';
-import type { DbExecutor, ServerSyncDialect } from '@syncular/server';
-import type {
-  SyncChangeRow,
-  SyncCommitRow,
-  SyncCoreDb,
-} from '@syncular/server/schema';
-import type { Kysely, Transaction } from 'kysely';
+import type { DbExecutor } from '@syncular/server';
+import {
+  BaseServerSyncDialect,
+  coerceIsoString,
+  coerceNumber,
+  type IncrementalPullRow,
+  type IncrementalPullRowsArgs,
+  parseScopes,
+} from '@syncular/server';
+import type { SyncChangeRow, SyncCoreDb } from '@syncular/server/schema';
+import type { Kysely, RawBuilder, Transaction } from 'kysely';
 import { sql } from 'kysely';
 
-function coerceNumber(value: unknown): number | null {
-  if (value === null || value === undefined) return null;
-  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
-  if (typeof value === 'bigint')
-    return Number.isFinite(Number(value)) ? Number(value) : null;
-  if (typeof value === 'string') {
-    const n = Number(value);
-    return Number.isFinite(n) ? n : null;
-  }
-  return null;
+function isActiveTransaction<DB extends SyncCoreDb>(
+  db: Kysely<DB>
+): db is Kysely<DB> & Transaction<DB> {
+  return (db as { isTransaction?: boolean }).isTransaction === true;
 }
 
-function coerceIsoString(value: unknown): string {
-  if (typeof value === 'string') return value;
-  if (value instanceof Date) return value.toISOString();
-  return String(value);
+function createSavepointName(): string {
+  const randomPart = Math.floor(Math.random() * 1_000_000_000).toString(36);
+  return `syncular_sp_${Date.now().toString(36)}_${randomPart}`;
 }
 
 function parseJsonValue(value: unknown): unknown {
@@ -54,42 +51,6 @@ function parseJsonValue(value: unknown): unknown {
   return value;
 }
 
-function parseScopes(value: unknown): StoredScopes {
-  if (value === null || value === undefined) return {};
-  if (typeof value === 'object' && !Array.isArray(value)) {
-    const result: StoredScopes = {};
-    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-      if (typeof v === 'string') {
-        result[k] = v;
-      }
-    }
-    return result;
-  }
-  if (typeof value === 'string') {
-    try {
-      const parsed = JSON.parse(value);
-      if (
-        typeof parsed === 'object' &&
-        parsed !== null &&
-        !Array.isArray(parsed)
-      ) {
-        const result: StoredScopes = {};
-        for (const [k, v] of Object.entries(
-          parsed as Record<string, unknown>
-        )) {
-          if (typeof v === 'string') {
-            result[k] = v;
-          }
-        }
-        return result;
-      }
-    } catch {
-      // ignore
-    }
-  }
-  return {};
-}
-
 function toStringArray(value: unknown): string[] {
   if (Array.isArray(value)) {
     return value.filter((k: unknown): k is string => typeof k === 'string');
@@ -126,17 +87,67 @@ function scopesMatch(stored: StoredScopes, requested: ScopeValues): boolean {
   return true;
 }
 
-export class SqliteServerSyncDialect implements ServerSyncDialect {
+async function ensurePartitionColumn<DB extends SyncCoreDb>(
+  db: Kysely<DB>,
+  table: string
+): Promise<void> {
+  try {
+    await sql
+      .raw(
+        `ALTER TABLE ${table} ADD COLUMN partition_id TEXT NOT NULL DEFAULT 'default'`
+      )
+      .execute(db);
+  } catch {
+    // Ignore when column already exists (or table is immutable in the current backend).
+  }
+}
+
+async function ensureTransportPathColumn<DB extends SyncCoreDb>(
+  db: Kysely<DB>
+): Promise<void> {
+  try {
+    await sql
+      .raw(
+        "ALTER TABLE sync_request_events ADD COLUMN transport_path TEXT NOT NULL DEFAULT 'direct'"
+      )
+      .execute(db);
+  } catch {
+    // Ignore when column already exists (or table is immutable in the current backend).
+  }
+}
+
+export class SqliteServerSyncDialect extends BaseServerSyncDialect {
   readonly name = 'sqlite' as const;
   readonly supportsForUpdate = false;
   readonly supportsSavepoints: boolean;
   private readonly _supportsTransactions: boolean;
 
   constructor(options?: { supportsTransactions?: boolean }) {
+    super();
     this._supportsTransactions = options?.supportsTransactions ?? true;
     this.supportsSavepoints = this._supportsTransactions;
   }
 
+  // ===========================================================================
+  // SQL Fragment Hooks
+  // ===========================================================================
+
+  protected buildNumberListFilter(values: number[]): RawBuilder<unknown> {
+    const list = sql.join(
+      values.map((v) => sql`${v}`),
+      sql`, `
+    );
+    return sql`IN (${list})`;
+  }
+
+  protected buildStringListFilter(values: string[]): RawBuilder<unknown> {
+    const list = sql.join(
+      values.map((v) => sql`${v}`),
+      sql`, `
+    );
+    return sql`IN (${list})`;
+  }
+
   // ===========================================================================
   // Schema Setup
   // ===========================================================================
@@ -153,6 +164,9 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       .addColumn('commit_seq', 'integer', (col) =>
         col.primaryKey().autoIncrement()
       )
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
       .addColumn('actor_id', 'text', (col) => col.notNull())
       .addColumn('client_id', 'text', (col) => col.notNull())
       .addColumn('client_commit_id', 'text', (col) => col.notNull())
@@ -164,23 +178,38 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
         col.notNull().defaultTo('[]')
       )
       .execute();
+    await ensurePartitionColumn(db, 'sync_commits');
 
+    await sql`DROP INDEX IF EXISTS idx_sync_commits_client_commit`.execute(db);
     await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_sync_commits_client_commit
-      ON sync_commits(client_id, client_commit_id)`.execute(db);
+      ON sync_commits(partition_id, client_id, client_commit_id)`.execute(db);
 
     // sync_table_commits table (index of which commits affect which tables)
     await db.schema
       .createTable('sync_table_commits')
       .ifNotExists()
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
       .addColumn('table', 'text', (col) => col.notNull())
       .addColumn('commit_seq', 'integer', (col) =>
         col.notNull().references('sync_commits.commit_seq').onDelete('cascade')
       )
-      .addPrimaryKeyConstraint('sync_table_commits_pk', ['table', 'commit_seq'])
+      .addPrimaryKeyConstraint('sync_table_commits_pk', [
+        'partition_id',
+        'table',
+        'commit_seq',
+      ])
       .execute();
+    await ensurePartitionColumn(db, 'sync_table_commits');
+
+    // Ensure unique index matches ON CONFLICT clause in push.ts
+    // (needed when migrating from old schema where PK was only (table, commit_seq))
+    await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_sync_table_commits_partition_pk
+      ON sync_table_commits(partition_id, "table", commit_seq)`.execute(db);
 
     await sql`CREATE INDEX IF NOT EXISTS idx_sync_table_commits_commit_seq
-      ON sync_table_commits(commit_seq)`.execute(db);
+      ON sync_table_commits(partition_id, commit_seq)`.execute(db);
 
     // sync_changes table - uses JSON for scopes
     await db.schema
@@ -189,6 +218,9 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       .addColumn('change_id', 'integer', (col) =>
         col.primaryKey().autoIncrement()
       )
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
       .addColumn('commit_seq', 'integer', (col) =>
         col.notNull().references('sync_commits.commit_seq').onDelete('cascade')
       )
@@ -199,25 +231,39 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       .addColumn('row_version', 'integer')
       .addColumn('scopes', 'json', (col) => col.notNull())
       .execute();
+    await ensurePartitionColumn(db, 'sync_changes');
 
     await sql`CREATE INDEX IF NOT EXISTS idx_sync_changes_commit_seq
-      ON sync_changes(commit_seq)`.execute(db);
+      ON sync_changes(partition_id, commit_seq)`.execute(db);
 
     await sql`CREATE INDEX IF NOT EXISTS idx_sync_changes_table
-      ON sync_changes("table")`.execute(db);
+      ON sync_changes(partition_id, "table")`.execute(db);
 
     // sync_client_cursors table
     await db.schema
       .createTable('sync_client_cursors')
       .ifNotExists()
-      .addColumn('client_id', 'text', (col) => col.primaryKey())
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
+      .addColumn('client_id', 'text', (col) => col.notNull())
       .addColumn('actor_id', 'text', (col) => col.notNull())
       .addColumn('cursor', 'integer', (col) => col.notNull().defaultTo(0))
       .addColumn('effective_scopes', 'json', (col) =>
         col.notNull().defaultTo('{}')
       )
       .addColumn('updated_at', 'text', (col) => col.notNull().defaultTo(nowIso))
+      .addPrimaryKeyConstraint('sync_client_cursors_pk', [
+        'partition_id',
+        'client_id',
+      ])
       .execute();
+    await ensurePartitionColumn(db, 'sync_client_cursors');
+
+    // Ensure unique index matches ON CONFLICT clause in recordClientCursor
+    // (needed when migrating from old schema where PK was only (client_id))
+    await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_sync_client_cursors_partition_pk
+      ON sync_client_cursors(partition_id, client_id)`.execute(db);
 
     await sql`CREATE INDEX IF NOT EXISTS idx_sync_client_cursors_updated_at
       ON sync_client_cursors(updated_at)`.execute(db);
@@ -227,6 +273,9 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       .createTable('sync_snapshot_chunks')
       .ifNotExists()
       .addColumn('chunk_id', 'text', (col) => col.primaryKey())
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
       .addColumn('scope_key', 'text', (col) => col.notNull())
       .addColumn('scope', 'text', (col) => col.notNull())
       .addColumn('as_of_commit_seq', 'integer', (col) => col.notNull())
@@ -241,12 +290,13 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       .addColumn('created_at', 'text', (col) => col.notNull().defaultTo(nowIso))
       .addColumn('expires_at', 'text', (col) => col.notNull())
       .execute();
+    await ensurePartitionColumn(db, 'sync_snapshot_chunks');
 
     await sql`CREATE INDEX IF NOT EXISTS idx_sync_snapshot_chunks_expires_at
       ON sync_snapshot_chunks(expires_at)`.execute(db);
 
     await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_sync_snapshot_chunks_page_key
-      ON sync_snapshot_chunks(scope_key, scope, as_of_commit_seq, row_cursor, row_limit, encoding, compression)`.execute(
+      ON sync_snapshot_chunks(partition_id, scope_key, scope, as_of_commit_seq, row_cursor, row_limit, encoding, compression)`.execute(
       db
     );
 
@@ -269,6 +319,22 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
     db: Kysely<DB>,
     fn: (executor: DbExecutor<DB>) => Promise<T>
   ): Promise<T> {
+    if (isActiveTransaction(db)) {
+      if (!this._supportsTransactions) {
+        return fn(db);
+      }
+      const savepoint = createSavepointName();
+      await sql.raw(`SAVEPOINT ${savepoint}`).execute(db);
+      try {
+        const result = await fn(db);
+        await sql.raw(`RELEASE SAVEPOINT ${savepoint}`).execute(db);
+        return result;
+      } catch (error) {
+        await sql.raw(`ROLLBACK TO SAVEPOINT ${savepoint}`).execute(db);
+        await sql.raw(`RELEASE SAVEPOINT ${savepoint}`).execute(db);
+        throw error;
+      }
+    }
     if (this._supportsTransactions) {
       return db.transaction().execute(fn);
     }
@@ -282,94 +348,19 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
   }
 
   // ===========================================================================
-  // Commit/Change Log Queries
+  // Commit/Change Log Queries (dialect-specific)
   // ===========================================================================
 
-  async readMaxCommitSeq<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>
-  ): Promise<number> {
-    const res = await sql<{ max_seq: unknown }>`
-      SELECT max(commit_seq) as max_seq
-      FROM sync_commits
-    `.execute(db);
-
-    return coerceNumber(res.rows[0]?.max_seq) ?? 0;
-  }
-
-  async readMinCommitSeq<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>
-  ): Promise<number> {
-    const res = await sql<{ min_seq: unknown }>`
-      SELECT min(commit_seq) as min_seq
-      FROM sync_commits
-    `.execute(db);
-
-    return coerceNumber(res.rows[0]?.min_seq) ?? 0;
-  }
-
-  async readCommitSeqsForPull<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    args: { cursor: number; limitCommits: number; tables: string[] }
-  ): Promise<number[]> {
-    if (args.tables.length === 0) return [];
-
-    const tablesIn = sql.join(
-      args.tables.map((t) => sql`${t}`),
-      sql`, `
-    );
-
-    const res = await sql<{ commit_seq: unknown }>`
-      SELECT DISTINCT commit_seq
-      FROM sync_table_commits
-      WHERE "table" IN (${tablesIn})
-        AND commit_seq > ${args.cursor}
-      ORDER BY commit_seq ASC
-      LIMIT ${args.limitCommits}
-    `.execute(db);
-
-    return res.rows
-      .map((r) => coerceNumber(r.commit_seq))
-      .filter(
-        (n): n is number =>
-          typeof n === 'number' && Number.isFinite(n) && n > args.cursor
-      );
-  }
-
-  async readCommits<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    commitSeqs: number[]
-  ): Promise<SyncCommitRow[]> {
-    if (commitSeqs.length === 0) return [];
-
-    const commitSeqsIn = sql.join(
-      commitSeqs.map((seq) => sql`${seq}`),
-      sql`, `
-    );
-
-    const res = await sql<{
-      commit_seq: unknown;
-      actor_id: string;
-      created_at: unknown;
-      result_json: unknown | null;
-    }>`
-      SELECT commit_seq, actor_id, created_at, result_json
-      FROM sync_commits
-      WHERE commit_seq IN (${commitSeqsIn})
-      ORDER BY commit_seq ASC
-    `.execute(db);
-
-    return res.rows.map((row) => ({
-      commit_seq: coerceNumber(row.commit_seq) ?? 0,
-      actor_id: row.actor_id,
-      created_at: coerceIsoString(row.created_at),
-      result_json: row.result_json ?? null,
-    }));
-  }
-
   async readChangesForCommits<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    args: { commitSeqs: number[]; table: string; scopes: ScopeValues }
+    db: DbExecutor<DB>,
+    args: {
+      commitSeqs: number[];
+      table: string;
+      scopes: ScopeValues;
+      partitionId?: string;
+    }
   ): Promise<SyncChangeRow[]> {
+    const partitionId = args.partitionId ?? 'default';
     if (args.commitSeqs.length === 0) return [];
 
     const commitSeqsIn = sql.join(
@@ -390,6 +381,7 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       SELECT commit_seq, "table", row_id, op, row_json, row_version, scopes
       FROM sync_changes
       WHERE commit_seq IN (${commitSeqsIn})
+        AND partition_id = ${partitionId}
         AND "table" = ${args.table}
       ORDER BY commit_seq ASC, change_id ASC
     `.execute(db);
@@ -411,40 +403,25 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       }));
   }
 
-  async readIncrementalPullRows<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    args: {
-      table: string;
-      scopes: ScopeValues;
-      cursor: number;
-      limitCommits: number;
-    }
-  ): Promise<
-    Array<{
-      commit_seq: number;
-      actor_id: string;
-      created_at: string;
-      change_id: number;
-      table: string;
-      row_id: string;
-      op: SyncOp;
-      row_json: unknown | null;
-      row_version: number | null;
-      scopes: StoredScopes;
-    }>
-  > {
+  protected override async readIncrementalPullRowsBatch<DB extends SyncCoreDb>(
+    db: DbExecutor<DB>,
+    args: Omit<IncrementalPullRowsArgs, 'batchSize'>
+  ): Promise<IncrementalPullRow[]> {
+    const partitionId = args.partitionId ?? 'default';
     const limitCommits = Math.max(1, Math.min(500, args.limitCommits));
 
     // Get commit_seqs for this table
     const commitSeqsRes = await sql<{ commit_seq: unknown }>`
       SELECT commit_seq
       FROM sync_table_commits
-      WHERE "table" = ${args.table}
+      WHERE partition_id = ${partitionId}
+        AND "table" = ${args.table}
         AND commit_seq > ${args.cursor}
         AND EXISTS (
           SELECT 1
           FROM sync_commits cm
           WHERE cm.commit_seq = sync_table_commits.commit_seq
+            AND cm.partition_id = ${partitionId}
         )
       ORDER BY commit_seq ASC
       LIMIT ${limitCommits}
@@ -488,6 +465,8 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       FROM sync_commits cm
       JOIN sync_changes c ON c.commit_seq = cm.commit_seq
       WHERE cm.commit_seq IN (${commitSeqsIn})
+        AND cm.partition_id = ${partitionId}
+        AND c.partition_id = ${partitionId}
         AND c."table" = ${args.table}
       ORDER BY cm.commit_seq ASC, c.change_id ASC
     `.execute(db);
@@ -512,115 +491,8 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       }));
   }
 
-  /**
-   * Streaming version of incremental pull for large result sets.
-   * Yields changes one at a time instead of loading all into memory.
-   */
-  async *streamIncrementalPullRows<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    args: {
-      table: string;
-      scopes: ScopeValues;
-      cursor: number;
-      limitCommits: number;
-    }
-  ): AsyncGenerator<{
-    commit_seq: number;
-    actor_id: string;
-    created_at: string;
-    change_id: number;
-    table: string;
-    row_id: string;
-    op: SyncOp;
-    row_json: unknown | null;
-    row_version: number | null;
-    scopes: StoredScopes;
-  }> {
-    const limitCommits = Math.max(1, Math.min(500, args.limitCommits));
-
-    // Get commit_seqs for this table
-    const commitSeqsRes = await sql<{ commit_seq: unknown }>`
-      SELECT commit_seq
-      FROM sync_table_commits
-      WHERE "table" = ${args.table}
-        AND commit_seq > ${args.cursor}
-        AND EXISTS (
-          SELECT 1
-          FROM sync_commits cm
-          WHERE cm.commit_seq = sync_table_commits.commit_seq
-        )
-      ORDER BY commit_seq ASC
-      LIMIT ${limitCommits}
-    `.execute(db);
-
-    const commitSeqs = commitSeqsRes.rows
-      .map((r) => coerceNumber(r.commit_seq))
-      .filter((n): n is number => n !== null);
-
-    if (commitSeqs.length === 0) return;
-
-    // Process in smaller batches to avoid memory issues
-    const batchSize = 100;
-    for (let i = 0; i < commitSeqs.length; i += batchSize) {
-      const batch = commitSeqs.slice(i, i + batchSize);
-      const commitSeqsIn = sql.join(
-        batch.map((seq) => sql`${seq}`),
-        sql`, `
-      );
-
-      const changesRes = await sql<{
-        commit_seq: unknown;
-        actor_id: string;
-        created_at: unknown;
-        change_id: unknown;
-        table: string;
-        row_id: string;
-        op: string;
-        row_json: unknown | null;
-        row_version: unknown | null;
-        scopes: unknown;
-      }>`
-        SELECT
-          cm.commit_seq,
-          cm.actor_id,
-          cm.created_at,
-          c.change_id,
-          c."table",
-          c.row_id,
-          c.op,
-          c.row_json,
-          c.row_version,
-          c.scopes
-        FROM sync_commits cm
-        JOIN sync_changes c ON c.commit_seq = cm.commit_seq
-        WHERE cm.commit_seq IN (${commitSeqsIn})
-          AND c."table" = ${args.table}
-        ORDER BY cm.commit_seq ASC, c.change_id ASC
-      `.execute(db);
-
-      // Filter and yield each row
-      for (const row of changesRes.rows) {
-        const storedScopes = parseScopes(row.scopes);
-        if (scopesMatch(storedScopes, args.scopes)) {
-          yield {
-            commit_seq: coerceNumber(row.commit_seq) ?? 0,
-            actor_id: row.actor_id,
-            created_at: coerceIsoString(row.created_at),
-            change_id: coerceNumber(row.change_id) ?? 0,
-            table: row.table,
-            row_id: row.row_id,
-            op: row.op as SyncOp,
-            row_json: parseJsonValue(row.row_json),
-            row_version: coerceNumber(row.row_version),
-            scopes: storedScopes,
-          };
-        }
-      }
-    }
-  }
-
   async compactChanges<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
+    db: DbExecutor<DB>,
     args: { fullHistoryHours: number }
   ): Promise<number> {
     const cutoffIso = new Date(
@@ -630,18 +502,19 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
     // Find all old changes
     const oldChanges = await sql<{
       change_id: unknown;
+      partition_id: string;
       commit_seq: unknown;
       table: string;
       row_id: string;
       scopes: unknown;
     }>`
-      SELECT c.change_id, c.commit_seq, c."table", c.row_id, c.scopes
+      SELECT c.change_id, c.partition_id, c.commit_seq, c."table", c.row_id, c.scopes
       FROM sync_changes c
       JOIN sync_commits cm ON cm.commit_seq = c.commit_seq
       WHERE cm.created_at < ${cutoffIso}
     `.execute(db);
 
-    // Group by (table, row_id, scopes)
+    // Group by (partition_id, table, row_id, scopes)
     const groups = new Map<
       string,
       Array<{ change_id: number; commit_seq: number }>
@@ -649,7 +522,7 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
 
     for (const row of oldChanges.rows) {
       const scopesStr = JSON.stringify(parseScopes(row.scopes));
-      const key = `${row.table}|${row.row_id}|${scopesStr}`;
+      const key = `${row.partition_id}|${row.table}|${row.row_id}|${scopesStr}`;
       if (!groups.has(key)) {
         groups.set(key, []);
       }
@@ -677,11 +550,11 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
     if (toDelete.length === 0) return 0;
 
     // Delete in batches
-    const batchSize = 500;
+    const deleteBatchSize = 500;
     let deleted = 0;
 
-    for (let i = 0; i < toDelete.length; i += batchSize) {
-      const batch = toDelete.slice(i, i + batchSize);
+    for (let i = 0; i < toDelete.length; i += deleteBatchSize) {
+      const batch = toDelete.slice(i, i + deleteBatchSize);
       const batchIn = sql.join(
         batch.map((id) => sql`${id}`),
         sql`, `
@@ -702,11 +575,13 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
         SELECT commit_seq
         FROM sync_commits
         WHERE created_at < ${cutoffIso}
+          AND partition_id = sync_table_commits.partition_id
       )
         AND NOT EXISTS (
           SELECT 1
           FROM sync_changes c
           WHERE c.commit_seq = sync_table_commits.commit_seq
+            AND c.partition_id = sync_table_commits.partition_id
             AND c."table" = sync_table_commits."table"
         )
     `.execute(db);
@@ -714,33 +589,6 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
     return deleted;
   }
 
-  // ===========================================================================
-  // Client Cursor Recording
-  // ===========================================================================
-
-  async recordClientCursor<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    args: {
-      clientId: string;
-      actorId: string;
-      cursor: number;
-      effectiveScopes: ScopeValues;
-    }
-  ): Promise<void> {
-    const now = new Date().toISOString();
-    const scopesJson = JSON.stringify(args.effectiveScopes);
-
-    await sql`
-      INSERT INTO sync_client_cursors (client_id, actor_id, cursor, effective_scopes, updated_at)
-      VALUES (${args.clientId}, ${args.actorId}, ${args.cursor}, ${scopesJson}, ${now})
-      ON CONFLICT(client_id) DO UPDATE SET
-        actor_id = ${args.actorId},
-        cursor = ${args.cursor},
-        effective_scopes = ${scopesJson},
-        updated_at = ${now}
-    `.execute(db);
-  }
-
   // ===========================================================================
   // Scope Conversion Helpers
   // ===========================================================================
@@ -749,10 +597,6 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
     return JSON.stringify(scopes);
   }
 
-  dbToScopes(value: unknown): StoredScopes {
-    return parseScopes(value);
-  }
-
   dbToArray(value: unknown): string[] {
     return toStringArray(value);
   }
@@ -761,21 +605,6 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
     return JSON.stringify(values.filter((v) => v.length > 0));
   }
 
-  async readAffectedTablesFromChanges<DB extends SyncCoreDb>(
-    db: Kysely<DB> | Transaction<DB>,
-    commitSeq: number
-  ): Promise<string[]> {
-    const res = await sql<{ table: string }>`
-      SELECT DISTINCT "table"
-      FROM sync_changes
-      WHERE commit_seq = ${commitSeq}
-    `.execute(db);
-
-    return res.rows
-      .map((r) => r.table)
-      .filter((t): t is string => typeof t === 'string' && t.length > 0);
-  }
-
   // ===========================================================================
   // Console Schema (Request Events)
   // ===========================================================================
@@ -802,8 +631,12 @@ export class SqliteServerSyncDialect implements ServerSyncDialect {
       .addColumn('row_count', 'integer')
       .addColumn('tables', 'text', (col) => col.notNull().defaultTo('[]'))
       .addColumn('error_message', 'text')
+      .addColumn('transport_path', 'text', (col) =>
+        col.notNull().defaultTo('direct')
+      )
       .addColumn('created_at', 'text', (col) => col.notNull().defaultTo(nowIso))
       .execute();
+    await ensureTransportPathColumn(db);
 
     await sql`CREATE INDEX IF NOT EXISTS idx_sync_request_events_created_at
       ON sync_request_events(created_at DESC)`.execute(db);