@syncular/server 0.0.6-96 → 0.1.0

package/src/postgres/index.ts

@@ -0,0 +1,1291 @@
+/**
+ * @syncular/server/postgres - PostgreSQL Server Sync Dialect
+ *
+ * Driver-agnostic PostgreSQL dialect for sync. Works with any Postgres-compatible
+ * Kysely dialect (pg, pglite, neon, etc.).
+ *
+ * Tables:
+ * - sync_commits: commit log (idempotency + ordering)
+ * - sync_table_commits: commit routing index (fast pull by table)
+ * - sync_changes: change log (JSONB scopes for filtering)
+ * - sync_client_cursors: per-client cursor tracking (pruning/observability)
+ */
+
+import type { ScopeValues, StoredScopes, SyncOp } from '@syncular/core';
+import type { DbExecutor } from '@syncular/server';
+import {
+  type AuditRowHistoryArgs,
+  type AuditRowHistoryRow,
+  BaseServerSyncDialect,
+  coerceIsoString,
+  coerceNumber,
+  createSavepointName,
+  type IncrementalPullRow,
+  type IncrementalPullRowsArgs,
+  isActiveTransaction,
+  parseScopes,
+} from '@syncular/server';
+import type { SyncChangeRow, SyncCoreDb } from '@syncular/server/schema';
+import type { Kysely, RawBuilder, Transaction } from 'kysely';
+import { sql } from 'kysely';
+
+function buildJsonbScopeContainmentFilter(
+  columnReference: string,
+  scopes: ScopeValues
+): RawBuilder<unknown> {
+  const fragments: RawBuilder<unknown>[] = [];
+
+  for (const [key, value] of Object.entries(scopes)) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        fragments.push(sql`FALSE`);
+        continue;
+      }
+
+      const anyValueMatches = sql.join(
+        value.map((entry) => {
+          const scopeFilter = JSON.stringify({ [key]: entry });
+          return sql`${sql.ref(columnReference)} @> ${scopeFilter}::jsonb`;
+        }),
+        sql` OR `
+      );
+      fragments.push(sql`(${anyValueMatches})`);
+      continue;
+    }
+
+    const scopeFilter = JSON.stringify({ [key]: value });
+    fragments.push(sql`${sql.ref(columnReference)} @> ${scopeFilter}::jsonb`);
+  }
+
+  if (fragments.length === 0) {
+    return sql`TRUE`;
+  }
+
+  return sql.join(fragments, sql` AND `);
+}
+
+export class PostgresServerSyncDialect extends BaseServerSyncDialect<'postgres'> {
+  readonly family = 'postgres' as const;
+  readonly supportsForUpdate = true;
+  readonly supportsSavepoints = true;
+  readonly supportsInsertReturning = true;
+
+  // ===========================================================================
+  // SQL Fragment Hooks
+  // ===========================================================================
+
+  protected buildNumberListFilter(values: number[]): RawBuilder<unknown> {
+    return sql`= ANY(${values}::bigint[])`;
+  }
+
+  protected buildStringListFilter(values: string[]): RawBuilder<unknown> {
+    return sql`= ANY(${values}::text[])`;
+  }
+
+  // ===========================================================================
+  // Schema Setup
+  // ===========================================================================
+
+  async ensureSyncSchema<DB extends SyncCoreDb>(db: Kysely<DB>): Promise<void> {
+    await db.schema
+      .createTable('sync_commits')
+      .ifNotExists()
+      .addColumn('commit_seq', 'bigserial', (col) => col.primaryKey())
+      .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())
+      .addColumn('created_at', 'timestamptz', (col) =>
+        col.notNull().defaultTo(sql`now()`)
+      )
+      .addColumn('meta', 'jsonb')
+      .addColumn('result_json', 'jsonb')
+      .addColumn('change_count', 'integer', (col) => col.notNull().defaultTo(0))
+      .addColumn('commit_digest', 'text')
+      .addColumn('commit_chain_root', 'text')
+      .addColumn('affected_tables', sql`text[]`, (col) =>
+        col.notNull().defaultTo(sql`ARRAY[]::text[]`)
+      )
+      .execute();
+
+    // Ensure new columns exist for dev environments that already created the table.
+    await sql`ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS change_count integer NOT NULL DEFAULT 0`.execute(
+      db
+    );
+    await sql`ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS affected_tables text[] NOT NULL DEFAULT ARRAY[]::text[]`.execute(
+      db
+    );
+    await sql`ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+    await sql`ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS commit_digest text`.execute(db);
+    await sql`ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS commit_chain_root text`.execute(db);
+
+    await sql`DROP INDEX IF EXISTS idx_sync_commits_client_commit`.execute(db);
+    await db.schema
+      .createIndex('idx_sync_commits_client_commit')
+      .ifNotExists()
+      .on('sync_commits')
+      .columns(['partition_id', 'client_id', 'client_commit_id'])
+      .unique()
+      .execute();
+    await db.schema
+      .createIndex('idx_sync_commits_partition_client_commit_seq')
+      .ifNotExists()
+      .on('sync_commits')
+      .columns(['partition_id', 'client_id', 'commit_seq'])
+      .execute();
+
+    // Table-based commit routing index
+    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', 'bigint', (col) =>
+        col.notNull().references('sync_commits.commit_seq').onDelete('cascade')
+      )
+      .addPrimaryKeyConstraint('sync_table_commits_pk', [
+        'partition_id',
+        'table',
+        'commit_seq',
+      ])
+      .execute();
+
+    await sql`ALTER TABLE sync_table_commits
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+
+    await db.schema
+      .createIndex('idx_sync_table_commits_commit_seq')
+      .ifNotExists()
+      .on('sync_table_commits')
+      .columns(['partition_id', 'commit_seq'])
+      .execute();
+
+    await db.schema
+      .createTable('sync_scope_commits')
+      .ifNotExists()
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
+      .addColumn('table', 'text', (col) => col.notNull())
+      .addColumn('scope_key', 'text', (col) => col.notNull())
+      .addColumn('commit_seq', 'bigint', (col) =>
+        col.notNull().references('sync_commits.commit_seq').onDelete('cascade')
+      )
+      .addPrimaryKeyConstraint('sync_scope_commits_pk', [
+        'partition_id',
+        'table',
+        'scope_key',
+        'commit_seq',
+      ])
+      .execute();
+
+    await sql`ALTER TABLE sync_scope_commits
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+
+    await db.schema
+      .createIndex('idx_sync_scope_commits_commit_seq')
+      .ifNotExists()
+      .on('sync_scope_commits')
+      .columns(['partition_id', 'commit_seq'])
+      .execute();
+
+    // Changes table with JSONB scopes
+    await db.schema
+      .createTable('sync_changes')
+      .ifNotExists()
+      .addColumn('change_id', 'bigserial', (col) => col.primaryKey())
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
+      .addColumn('commit_seq', 'bigint', (col) =>
+        col.notNull().references('sync_commits.commit_seq').onDelete('cascade')
+      )
+      .addColumn('table', 'text', (col) => col.notNull())
+      .addColumn('row_id', 'text', (col) => col.notNull())
+      .addColumn('op', 'text', (col) => col.notNull())
+      .addColumn('row_json', 'jsonb')
+      .addColumn('row_version', 'bigint')
+      .addColumn('scopes', 'jsonb', (col) => col.notNull())
+      .execute();
+
+    await sql`ALTER TABLE sync_changes
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+
+    await db.schema
+      .createIndex('idx_sync_changes_commit_seq')
+      .ifNotExists()
+      .on('sync_changes')
+      .columns(['partition_id', 'commit_seq'])
+      .execute();
+
+    await db.schema
+      .createIndex('idx_sync_changes_table')
+      .ifNotExists()
+      .on('sync_changes')
+      .columns(['partition_id', 'table'])
+      .execute();
+
+    await db.schema
+      .createIndex('idx_sync_changes_table_commit_seq_change_id')
+      .ifNotExists()
+      .on('sync_changes')
+      .columns(['partition_id', 'table', 'commit_seq', 'change_id'])
+      .execute();
+
+    await this.ensureIndex(
+      db,
+      'idx_sync_changes_scopes',
+      'CREATE INDEX idx_sync_changes_scopes ON sync_changes USING GIN (scopes)'
+    );
+
+    await db.schema
+      .createTable('sync_client_cursors')
+      .ifNotExists()
+      .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', 'bigint', (col) => col.notNull().defaultTo(0))
+      .addColumn('effective_scopes', 'jsonb', (col) =>
+        col.notNull().defaultTo(sql`'{}'::jsonb`)
+      )
+      .addColumn('realtime_subscriptions', 'jsonb')
+      .addColumn('updated_at', 'timestamptz', (col) =>
+        col.notNull().defaultTo(sql`now()`)
+      )
+      .addPrimaryKeyConstraint('sync_client_cursors_pk', [
+        'partition_id',
+        'client_id',
+      ])
+      .execute();
+
+    await sql`ALTER TABLE sync_client_cursors
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+    await sql`ALTER TABLE sync_client_cursors
+      ADD COLUMN IF NOT EXISTS realtime_subscriptions jsonb`.execute(db);
+
+    await db.schema
+      .createIndex('idx_sync_client_cursors_updated_at')
+      .ifNotExists()
+      .on('sync_client_cursors')
+      .columns(['updated_at'])
+      .execute();
+
+    await db.schema
+      .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', 'bigint', (col) => col.notNull())
+      .addColumn('row_cursor', 'text', (col) => col.notNull().defaultTo(''))
+      .addColumn('row_limit', 'integer', (col) => col.notNull())
+      .addColumn('next_row_cursor', 'text')
+      .addColumn('is_last_page', 'integer', (col) => col.notNull().defaultTo(0))
+      .addColumn('encoding', 'text', (col) => col.notNull())
+      .addColumn('compression', 'text', (col) => col.notNull())
+      .addColumn('sha256', 'text', (col) => col.notNull())
+      .addColumn('byte_length', 'integer', (col) => col.notNull())
+      .addColumn('blob_hash', 'text', (col) => col.notNull().defaultTo(''))
+      .addColumn('body', 'bytea') // Deprecated: use blob storage
+      .addColumn('created_at', 'timestamptz', (col) =>
+        col.notNull().defaultTo(sql`now()`)
+      )
+      .addColumn('expires_at', 'timestamptz', (col) => col.notNull())
+      .execute();
+
+    await sql`ALTER TABLE sync_snapshot_chunks
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+    await sql`ALTER TABLE sync_snapshot_chunks
+      ADD COLUMN IF NOT EXISTS next_row_cursor text`.execute(db);
+    await sql`ALTER TABLE sync_snapshot_chunks
+      ADD COLUMN IF NOT EXISTS is_last_page integer NOT NULL DEFAULT 0`.execute(
+      db
+    );
+
+    await db.schema
+      .createIndex('idx_sync_snapshot_chunks_expires_at')
+      .ifNotExists()
+      .on('sync_snapshot_chunks')
+      .columns(['expires_at'])
+      .execute();
+
+    await db.schema
+      .createIndex('idx_sync_snapshot_chunks_page_key')
+      .ifNotExists()
+      .on('sync_snapshot_chunks')
+      .columns([
+        'partition_id',
+        'scope_key',
+        'scope',
+        'as_of_commit_seq',
+        'row_cursor',
+        'row_limit',
+        'encoding',
+        'compression',
+      ])
+      .unique()
+      .execute();
+
+    await db.schema
+      .createTable('sync_snapshot_artifacts')
+      .ifNotExists()
+      .addColumn('artifact_id', 'text', (col) => col.primaryKey())
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
+      .addColumn('scope_key', 'text', (col) => col.notNull())
+      .addColumn('subscription_id', 'text', (col) => col.notNull())
+      .addColumn('table', 'text', (col) => col.notNull())
+      .addColumn('artifact_kind', 'text', (col) => col.notNull())
+      .addColumn('schema_version', 'text', (col) => col.notNull())
+      .addColumn('as_of_commit_seq', 'bigint', (col) => col.notNull())
+      .addColumn('row_cursor', 'text', (col) => col.notNull().defaultTo(''))
+      .addColumn('row_limit', 'integer', (col) => col.notNull())
+      .addColumn('row_count', 'integer', (col) => col.notNull())
+      .addColumn('next_row_cursor', 'text')
+      .addColumn('is_first_page', 'integer', (col) =>
+        col.notNull().defaultTo(0)
+      )
+      .addColumn('is_last_page', 'integer', (col) => col.notNull().defaultTo(0))
+      .addColumn('compression', 'text', (col) => col.notNull())
+      .addColumn('sha256', 'text', (col) => col.notNull())
+      .addColumn('byte_length', 'integer', (col) => col.notNull())
+      .addColumn('manifest_digest', 'text', (col) => col.notNull())
+      .addColumn('feature_set_json', 'text', (col) => col.notNull())
+      .addColumn('manifest_json', 'text', (col) => col.notNull())
+      .addColumn('blob_hash', 'text', (col) => col.notNull())
+      .addColumn('created_at', 'timestamptz', (col) =>
+        col.notNull().defaultTo(sql`now()`)
+      )
+      .addColumn('expires_at', 'timestamptz', (col) => col.notNull())
+      .execute();
+
+    await db.schema
+      .createIndex('idx_sync_snapshot_artifacts_expires_at')
+      .ifNotExists()
+      .on('sync_snapshot_artifacts')
+      .columns(['expires_at'])
+      .execute();
+
+    await db.schema
+      .createIndex('idx_sync_snapshot_artifacts_page_key')
+      .ifNotExists()
+      .on('sync_snapshot_artifacts')
+      .columns([
+        'partition_id',
+        'scope_key',
+        'subscription_id',
+        'table',
+        'as_of_commit_seq',
+        'row_cursor',
+        'row_limit',
+        'artifact_kind',
+        'schema_version',
+        'compression',
+      ])
+      .unique()
+      .execute();
+
+    await db.schema
+      .createTable('sync_crdt_updates')
+      .ifNotExists()
+      .addColumn('seq', 'bigserial', (col) => col.primaryKey())
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
+      .addColumn('stream_id', 'text', (col) => col.notNull())
+      .addColumn('app_table', 'text', (col) => col.notNull())
+      .addColumn('row_id', 'text', (col) => col.notNull())
+      .addColumn('field_name', 'text', (col) => col.notNull())
+      .addColumn('update_id', 'text', (col) => col.notNull())
+      .addColumn('actor_id', 'text')
+      .addColumn('client_id', 'text')
+      .addColumn('key_id', 'text', (col) => col.notNull())
+      .addColumn('ciphertext', 'text', (col) => col.notNull())
+      .addColumn('scopes', 'jsonb', (col) =>
+        col.notNull().defaultTo(sql`'{}'::jsonb`)
+      )
+      .addColumn('created_at', 'timestamptz', (col) =>
+        col.notNull().defaultTo(sql`now()`)
+      )
+      .execute();
+    await sql`ALTER TABLE sync_crdt_updates
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+    await db.schema
+      .createIndex('idx_sync_crdt_updates_update_id')
+      .ifNotExists()
+      .on('sync_crdt_updates')
+      .columns(['partition_id', 'update_id'])
+      .unique()
+      .execute();
+    await db.schema
+      .createIndex('idx_sync_crdt_updates_stream_seq')
+      .ifNotExists()
+      .on('sync_crdt_updates')
+      .columns(['partition_id', 'stream_id', 'seq'])
+      .execute();
+    await db.schema
+      .createIndex('idx_sync_crdt_updates_scope_table')
+      .ifNotExists()
+      .on('sync_crdt_updates')
+      .columns(['partition_id', 'app_table', 'row_id', 'field_name'])
+      .execute();
+    await this.ensureIndex(
+      db,
+      'idx_sync_crdt_updates_scopes',
+      'CREATE INDEX idx_sync_crdt_updates_scopes ON sync_crdt_updates USING GIN (scopes)'
+    );
+
+    await db.schema
+      .createTable('sync_crdt_checkpoints')
+      .ifNotExists()
+      .addColumn('seq', 'bigserial', (col) => col.primaryKey())
+      .addColumn('partition_id', 'text', (col) =>
+        col.notNull().defaultTo('default')
+      )
+      .addColumn('stream_id', 'text', (col) => col.notNull())
+      .addColumn('app_table', 'text', (col) => col.notNull())
+      .addColumn('row_id', 'text', (col) => col.notNull())
+      .addColumn('field_name', 'text', (col) => col.notNull())
+      .addColumn('checkpoint_id', 'text', (col) => col.notNull())
+      .addColumn('covers_seq', 'bigint', (col) => col.notNull())
+      .addColumn('actor_id', 'text')
+      .addColumn('client_id', 'text')
+      .addColumn('key_id', 'text', (col) => col.notNull())
+      .addColumn('ciphertext', 'text', (col) => col.notNull())
+      .addColumn('scopes', 'jsonb', (col) =>
+        col.notNull().defaultTo(sql`'{}'::jsonb`)
+      )
+      .addColumn('created_at', 'timestamptz', (col) =>
+        col.notNull().defaultTo(sql`now()`)
+      )
+      .execute();
+    await sql`ALTER TABLE sync_crdt_checkpoints
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(
+      db
+    );
+    await db.schema
+      .createIndex('idx_sync_crdt_checkpoints_checkpoint_id')
+      .ifNotExists()
+      .on('sync_crdt_checkpoints')
+      .columns(['partition_id', 'checkpoint_id'])
+      .unique()
+      .execute();
+    await db.schema
+      .createIndex('idx_sync_crdt_checkpoints_stream_covers')
+      .ifNotExists()
+      .on('sync_crdt_checkpoints')
+      .columns(['partition_id', 'stream_id', 'covers_seq'])
+      .execute();
+    await db.schema
+      .createIndex('idx_sync_crdt_checkpoints_scope_table')
+      .ifNotExists()
+      .on('sync_crdt_checkpoints')
+      .columns(['partition_id', 'app_table', 'row_id', 'field_name'])
+      .execute();
+    await this.ensureIndex(
+      db,
+      'idx_sync_crdt_checkpoints_scopes',
+      'CREATE INDEX idx_sync_crdt_checkpoints_scopes ON sync_crdt_checkpoints USING GIN (scopes)'
+    );
+  }
+
+  // ===========================================================================
+  // Transaction Control
+  // ===========================================================================
+
+  async executeInTransaction<DB extends SyncCoreDb, T>(
+    db: Kysely<DB>,
+    fn: (executor: DbExecutor<DB>) => Promise<T>
+  ): Promise<T> {
+    if (isActiveTransaction(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;
+      }
+    }
+    return db.transaction().execute(fn);
+  }
+
+  async setRepeatableRead<DB extends SyncCoreDb>(
+    trx: DbExecutor<DB>
+  ): Promise<void> {
+    await sql`SET TRANSACTION ISOLATION LEVEL REPEATABLE READ`.execute(trx);
+  }
+
+  // ===========================================================================
+  // Overrides (dialect-specific optimizations / casts)
+  // ===========================================================================
+
+  async readCommitSeqsForPull<DB extends SyncCoreDb>(
+    db: Kysely<DB> | Transaction<DB>,
+    args: {
+      cursor: number;
+      limitCommits: number;
+      tables: string[];
+      partitionId?: string;
+    }
+  ): Promise<number[]> {
+    const partitionId = args.partitionId ?? 'default';
+    if (args.tables.length === 0) return [];
+
+    // Single-table fast path: skip DISTINCT since (partition_id, table, commit_seq) is PK
+    if (args.tables.length === 1) {
+      const res = await sql<{ commit_seq: unknown }>`
+        SELECT commit_seq
+        FROM sync_table_commits
+        WHERE partition_id = ${partitionId}
+          AND "table" = ${args.tables[0]}
+          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
+        );
+    }
+
+    // Multi-table: use ANY() with DISTINCT
+    return super.readCommitSeqsForPull(db, args);
+  }
+
+  async recordClientCursor<DB extends SyncCoreDb>(
+    db: Kysely<DB> | Transaction<DB>,
+    args: {
+      partitionId?: string;
+      clientId: string;
+      actorId: string;
+      cursor: number;
+      effectiveScopes: ScopeValues;
+      realtimeSubscriptions?: unknown;
+    }
+  ): Promise<void> {
+    const partitionId = args.partitionId ?? 'default';
+    const now = new Date().toISOString();
+    const scopesJson = JSON.stringify(args.effectiveScopes);
+
+    if (args.realtimeSubscriptions === undefined) {
+      await sql`
+        INSERT INTO sync_client_cursors (partition_id, client_id, actor_id, cursor, effective_scopes, updated_at)
+        VALUES (${partitionId}, ${args.clientId}, ${args.actorId}, ${args.cursor}, ${scopesJson}::jsonb, ${now})
+        ON CONFLICT(partition_id, client_id) DO UPDATE SET
+          actor_id = ${args.actorId},
+          cursor = ${args.cursor},
+          effective_scopes = ${scopesJson}::jsonb,
+          updated_at = ${now}
+      `.execute(db);
+      return;
+    }
+
+    const realtimeSubscriptionsJson = JSON.stringify(
+      args.realtimeSubscriptions
+    );
+
+    await sql`
+      INSERT INTO sync_client_cursors (partition_id, client_id, actor_id, cursor, effective_scopes, realtime_subscriptions, updated_at)
+      VALUES (${partitionId}, ${args.clientId}, ${args.actorId}, ${args.cursor}, ${scopesJson}::jsonb, ${realtimeSubscriptionsJson}::jsonb, ${now})
+      ON CONFLICT(partition_id, client_id) DO UPDATE SET
+        actor_id = ${args.actorId},
+        cursor = ${args.cursor},
+        effective_scopes = ${scopesJson}::jsonb,
+        realtime_subscriptions = ${realtimeSubscriptionsJson}::jsonb,
+        updated_at = ${now}
+    `.execute(db);
+  }
+
+  // ===========================================================================
+  // Commit/Change Log Queries (dialect-specific)
+  // ===========================================================================
+
+  async readChangesForCommits<DB extends SyncCoreDb>(
+    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 scopeFilter = buildJsonbScopeContainmentFilter('scopes', args.scopes);
+
+    const res = await sql<{
+      commit_seq: unknown;
+      table: string;
+      row_id: string;
+      op: string;
+      row_json: unknown | null;
+      row_version: unknown | null;
+      scopes: unknown;
+    }>`
+      SELECT commit_seq, "table", row_id, op, row_json, row_version, scopes
+      FROM sync_changes
+      WHERE commit_seq = ANY(${args.commitSeqs}::bigint[])
+        AND partition_id = ${partitionId}
+        AND "table" = ${args.table}
+        AND (${scopeFilter})
+      ORDER BY commit_seq ASC, change_id ASC
+    `.execute(db);
+
+    return res.rows.map((row) => ({
+      commit_seq: coerceNumber(row.commit_seq) ?? 0,
+      table: row.table,
+      row_id: row.row_id,
+      op: row.op as SyncOp,
+      row_json: row.row_json ?? null,
+      row_version: coerceNumber(row.row_version),
+      scopes: parseScopes(row.scopes),
+    }));
+  }
+
+  async readAuditRowHistory<DB extends SyncCoreDb>(
+    db: DbExecutor<DB>,
+    args: AuditRowHistoryArgs
+  ): Promise<AuditRowHistoryRow[]> {
+    const partitionId = args.partitionId ?? 'default';
+    const scopeFilter = buildJsonbScopeContainmentFilter(
+      'c.scopes',
+      args.scopes
+    );
+    const limit = Math.max(1, Math.min(200, args.limit));
+    const whereClauses = [
+      sql`c.partition_id = ${partitionId}`,
+      sql`cm.partition_id = ${partitionId}`,
+      sql`c."table" = ${args.table}`,
+      sql`c.row_id = ${args.rowId}`,
+      sql`(${scopeFilter})`,
+    ];
+
+    if (args.beforeCommitSeq !== undefined) {
+      whereClauses.push(sql`c.commit_seq < ${args.beforeCommitSeq}`);
+    }
+    if (args.afterCommitSeq !== undefined) {
+      whereClauses.push(sql`c.commit_seq >= ${args.afterCommitSeq}`);
+    }
+
+    const res = await sql<{
+      commit_seq: unknown;
+      actor_id: string;
+      client_id: string;
+      client_commit_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
+        c.commit_seq,
+        cm.actor_id,
+        cm.client_id,
+        cm.client_commit_id,
+        cm.created_at,
+        c.change_id,
+        c."table",
+        c.row_id,
+        c.op,
+        c.row_json,
+        c.row_version,
+        c.scopes
+      FROM sync_changes c
+      JOIN sync_commits cm
+        ON cm.partition_id = c.partition_id
+       AND cm.commit_seq = c.commit_seq
+      WHERE ${sql.join(whereClauses, sql` AND `)}
+      ORDER BY c.commit_seq DESC, c.change_id DESC
+      LIMIT ${limit + 1}
+    `.execute(db);
+
+    return res.rows.map((row) => ({
+      commit_seq: coerceNumber(row.commit_seq) ?? 0,
+      actor_id: row.actor_id,
+      client_id: row.client_id,
+      client_commit_id: row.client_commit_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: row.row_json ?? null,
+      row_version: coerceNumber(row.row_version),
+      scopes: parseScopes(row.scopes),
+    }));
+  }
+
+  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(1000, args.limitCommits));
+
+    const scopeFilter = buildJsonbScopeContainmentFilter(
+      'c.scopes',
+      args.scopes
+    );
+
+    const scopeIndexedCommitSeqs = await this.readScopeIndexedCommitSeqsForPull(
+      db,
+      {
+        partitionId,
+        table: args.table,
+        scopes: args.scopes,
+        cursor: args.cursor,
+        limitCommits,
+      }
+    );
+    if (scopeIndexedCommitSeqs.length > 0) {
+      const commitSeqsFilter = this.buildNumberListFilter(
+        scopeIndexedCommitSeqs
+      );
+      const scannedMaxCommitSeq =
+        scopeIndexedCommitSeqs[scopeIndexedCommitSeqs.length - 1] ??
+        args.cursor;
+      const res = await sql<{
+        commit_seq: unknown;
+        actor_id: string;
+        created_at: unknown;
+        commit_digest: string | null;
+        commit_chain_root: string | null;
+        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,
+          cm.commit_digest,
+          cm.commit_chain_root,
+          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 ${commitSeqsFilter}
+          AND cm.partition_id = ${partitionId}
+          AND c.partition_id = ${partitionId}
+          AND c."table" = ${args.table}
+          AND (${scopeFilter})
+        ORDER BY cm.commit_seq ASC, c.change_id ASC
+      `.execute(db);
+
+      return res.rows.map((row) => ({
+        commit_seq: coerceNumber(row.commit_seq) ?? 0,
+        scanned_max_commit_seq: scannedMaxCommitSeq,
+        actor_id: row.actor_id,
+        created_at: coerceIsoString(row.created_at),
+        commit_digest: row.commit_digest ?? null,
+        commit_chain_root: row.commit_chain_root ?? null,
+        change_id: coerceNumber(row.change_id) ?? 0,
+        table: row.table,
+        row_id: row.row_id,
+        op: row.op as SyncOp,
+        row_json: row.row_json ?? null,
+        row_version: coerceNumber(row.row_version),
+        scopes: parseScopes(row.scopes),
+      }));
+    }
+
+    const res = await sql<{
+      commit_seq: unknown;
+      scanned_max_commit_seq: unknown;
+      actor_id: string;
+      created_at: unknown;
+      commit_digest: string | null;
+      commit_chain_root: string | null;
+      change_id: unknown;
+      table: string;
+      row_id: string;
+      op: string;
+      row_json: unknown | null;
+      row_version: unknown | null;
+      scopes: unknown;
+    }>`
+      WITH commit_window AS (
+        SELECT tc.commit_seq
+        FROM sync_table_commits tc
+        JOIN sync_commits cm ON cm.commit_seq = tc.commit_seq
+        WHERE tc.partition_id = ${partitionId}
+          AND tc."table" = ${args.table}
+          AND cm.partition_id = ${partitionId}
+          AND tc.commit_seq > ${args.cursor}
+        ORDER BY tc.commit_seq ASC
+        LIMIT ${limitCommits}
+      ),
+      commit_seqs AS (
+        SELECT cw.commit_seq
+        FROM commit_window cw
+        WHERE EXISTS (
+          SELECT 1
+          FROM sync_changes c
+          WHERE c.commit_seq = cw.commit_seq
+            AND c.partition_id = ${partitionId}
+            AND c."table" = ${args.table}
+            AND (${scopeFilter})
+        )
+        ORDER BY cw.commit_seq ASC
+      )
+      SELECT
+        cm.commit_seq,
+        (SELECT max(commit_seq) FROM commit_window) AS scanned_max_commit_seq,
+        cm.actor_id,
+        cm.created_at,
+        cm.commit_digest,
+        cm.commit_chain_root,
+        c.change_id,
+        c."table",
+        c.row_id,
+        c.op,
+        c.row_json,
+        c.row_version,
+        c.scopes
+      FROM commit_seqs cs
+      JOIN sync_commits cm ON cm.commit_seq = cs.commit_seq
+      JOIN sync_changes c ON c.commit_seq = cs.commit_seq
+      WHERE cm.partition_id = ${partitionId}
+        AND c.partition_id = ${partitionId}
+        AND c."table" = ${args.table}
+        AND (${scopeFilter})
+      ORDER BY cm.commit_seq ASC, c.change_id ASC
+    `.execute(db);
+
+    return res.rows.map((row) => ({
+      commit_seq: coerceNumber(row.commit_seq) ?? 0,
+      scanned_max_commit_seq: coerceNumber(row.scanned_max_commit_seq),
+      actor_id: row.actor_id,
+      created_at: coerceIsoString(row.created_at),
+      commit_digest: row.commit_digest ?? null,
+      commit_chain_root: row.commit_chain_root ?? null,
+      change_id: coerceNumber(row.change_id) ?? 0,
+      table: row.table,
+      row_id: row.row_id,
+      op: row.op as SyncOp,
+      row_json: row.row_json ?? null,
+      row_version: coerceNumber(row.row_version),
+      scopes: parseScopes(row.scopes),
+    }));
+  }
+
+  async compactChanges<DB extends SyncCoreDb>(
+    db: DbExecutor<DB>,
+    args: { fullHistoryHours: number }
+  ): Promise<number> {
+    const cutoffIso = new Date(
+      Date.now() - args.fullHistoryHours * 60 * 60 * 1000
+    ).toISOString();
+
+    const res = await sql`
+      WITH ranked AS (
+        SELECT
+          c.change_id,
+          row_number() OVER (
+            PARTITION BY c.partition_id, c."table", c.row_id, c.scopes
+            ORDER BY c.commit_seq DESC, c.change_id DESC
+          ) AS rn
+        FROM sync_changes c
+        JOIN sync_commits cm ON cm.commit_seq = c.commit_seq
+        WHERE cm.created_at < ${cutoffIso}
+      )
+      DELETE FROM sync_changes
+      WHERE change_id IN (SELECT change_id FROM ranked WHERE rn > 1)
+    `.execute(db);
+
+    const deletedChanges = Number(res.numAffectedRows ?? 0);
+
+    // Remove routing index entries that no longer have any remaining changes
+    await sql`
+      DELETE FROM sync_scope_commits sc
+      USING sync_commits cm
+        WHERE cm.commit_seq = sc.commit_seq
+          AND cm.partition_id = sc.partition_id
+          AND cm.created_at < ${cutoffIso}
+        AND NOT EXISTS (
+          SELECT 1
+          FROM sync_changes c
+          WHERE c.commit_seq = sc.commit_seq
+            AND c.partition_id = sc.partition_id
+            AND c."table" = sc."table"
+        )
+    `.execute(db);
+
+    await sql`
+      DELETE FROM sync_table_commits tc
+      USING sync_commits cm
+        WHERE cm.commit_seq = tc.commit_seq
+          AND cm.partition_id = tc.partition_id
+          AND cm.created_at < ${cutoffIso}
+        AND NOT EXISTS (
+          SELECT 1
+          FROM sync_changes c
+          WHERE c.commit_seq = tc.commit_seq
+            AND c.partition_id = tc.partition_id
+            AND c."table" = tc."table"
+        )
+    `.execute(db);
+
+    return deletedChanges;
+  }
+
+  // ===========================================================================
+  // Scope Conversion Helpers
+  // ===========================================================================
+
+  scopesToDb(scopes: StoredScopes): StoredScopes {
+    return scopes;
+  }
+
+  dbToArray(value: unknown): string[] {
+    if (Array.isArray(value)) {
+      return value.filter((k: unknown): k is string => typeof k === 'string');
+    }
+    return [];
+  }
+
+  arrayToDb(values: string[]): string[] {
+    return values.filter((v) => v.length > 0);
+  }
+
+  // ===========================================================================
+  // Console Schema (Request Events)
+  // ===========================================================================
+
+  async ensureConsoleSchema<DB extends SyncCoreDb>(
+    db: Kysely<DB>
+  ): Promise<void> {
+    await sql`
+      CREATE TABLE IF NOT EXISTS sync_request_events (
+        event_id BIGSERIAL PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        request_id TEXT,
+        trace_id TEXT,
+        span_id TEXT,
+        event_type TEXT NOT NULL,
+        actor_id TEXT NOT NULL,
+        client_id TEXT NOT NULL,
+        transport_path TEXT NOT NULL DEFAULT 'direct',
+        sync_path TEXT NOT NULL DEFAULT 'http-combined',
+        status_code INTEGER NOT NULL,
+        outcome TEXT NOT NULL,
+        response_status TEXT NOT NULL DEFAULT 'unknown',
+        error_code TEXT,
+        duration_ms INTEGER NOT NULL,
+        commit_seq BIGINT,
+        operation_count INTEGER,
+        row_count INTEGER,
+        subscription_count INTEGER,
+        scopes_summary JSONB,
+        response_summary JSONB,
+        tables TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+        error_message TEXT,
+        payload_ref TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS partition_id TEXT NOT NULL DEFAULT 'default'
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS request_id TEXT
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS trace_id TEXT
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS span_id TEXT
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS transport_path TEXT NOT NULL DEFAULT 'direct'
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS sync_path TEXT NOT NULL DEFAULT 'http-combined'
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS response_status TEXT NOT NULL DEFAULT 'unknown'
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS error_code TEXT
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS subscription_count INTEGER
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS scopes_summary JSONB
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS response_summary JSONB
+    `.execute(db);
+    await sql`
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS payload_ref TEXT
+    `.execute(db);
+
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_events_created_at',
+      'CREATE INDEX idx_sync_request_events_created_at ON sync_request_events(created_at DESC)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_events_event_type',
+      'CREATE INDEX idx_sync_request_events_event_type ON sync_request_events(event_type)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_events_client_id',
+      'CREATE INDEX idx_sync_request_events_client_id ON sync_request_events(client_id)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_events_request_id',
+      'CREATE INDEX idx_sync_request_events_request_id ON sync_request_events(request_id)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_events_trace_id',
+      'CREATE INDEX idx_sync_request_events_trace_id ON sync_request_events(trace_id)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_events_partition_created_at',
+      'CREATE INDEX idx_sync_request_events_partition_created_at ON sync_request_events(partition_id, created_at DESC)'
+    );
+
+    await sql`
+      CREATE TABLE IF NOT EXISTS sync_request_payloads (
+        payload_ref TEXT PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        request_payload JSONB NOT NULL,
+        response_payload JSONB,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_payloads_created_at',
+      'CREATE INDEX idx_sync_request_payloads_created_at ON sync_request_payloads(created_at DESC)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_request_payloads_partition_created_at',
+      'CREATE INDEX idx_sync_request_payloads_partition_created_at ON sync_request_payloads(partition_id, created_at DESC)'
+    );
+
+    await sql`
+      CREATE TABLE IF NOT EXISTS sync_operation_events (
+        operation_id BIGSERIAL PRIMARY KEY,
+        operation_type TEXT NOT NULL,
+        console_user_id TEXT,
+        partition_id TEXT,
+        target_client_id TEXT,
+        request_payload JSONB,
+        result_payload JSONB,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+    await this.ensureIndex(
+      db,
+      'idx_sync_operation_events_created_at',
+      'CREATE INDEX idx_sync_operation_events_created_at ON sync_operation_events(created_at DESC)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_operation_events_type',
+      'CREATE INDEX idx_sync_operation_events_type ON sync_operation_events(operation_type)'
+    );
+
+    await sql`
+      CREATE TABLE IF NOT EXISTS sync_realtime_events (
+        event_id BIGSERIAL PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        actor_id TEXT NOT NULL,
+        client_id TEXT NOT NULL,
+        transport_path TEXT NOT NULL DEFAULT 'direct',
+        event_type TEXT NOT NULL,
+        reason TEXT,
+        cursor BIGINT,
+        latest_cursor BIGINT,
+        commit_seq BIGINT,
+        scope_count INTEGER,
+        skipped_count INTEGER,
+        sync_pack_encoding TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+    await this.ensureIndex(
+      db,
+      'idx_sync_realtime_events_created_at',
+      'CREATE INDEX idx_sync_realtime_events_created_at ON sync_realtime_events(created_at DESC)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_realtime_events_partition_client_created_at',
+      'CREATE INDEX idx_sync_realtime_events_partition_client_created_at ON sync_realtime_events(partition_id, client_id, created_at DESC)'
+    );
+
+    await sql`
+      CREATE TABLE IF NOT EXISTS sync_client_diagnostic_snapshots (
+        snapshot_id BIGSERIAL PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        client_id TEXT NOT NULL,
+        actor_id TEXT,
+        runtime_kind TEXT,
+        runtime_version TEXT,
+        schema_version INTEGER,
+        reported_at TIMESTAMPTZ NOT NULL,
+        received_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        lifecycle_phase TEXT,
+        connection_state TEXT,
+        freshness_state TEXT NOT NULL,
+        health_max_severity TEXT,
+        diagnostic_codes_summary JSONB,
+        queue_summary JSONB,
+        timing_summary JSONB,
+        redaction_summary JSONB,
+        snapshot_json JSONB NOT NULL
+      )
+    `.execute(db);
+    await this.ensureIndex(
+      db,
+      'idx_sync_client_diagnostic_snapshots_received_at',
+      'CREATE INDEX idx_sync_client_diagnostic_snapshots_received_at ON sync_client_diagnostic_snapshots(received_at DESC)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_client_diagnostic_snapshots_latest',
+      'CREATE INDEX idx_sync_client_diagnostic_snapshots_latest ON sync_client_diagnostic_snapshots(partition_id, client_id, received_at DESC)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_client_diagnostic_snapshots_health',
+      'CREATE INDEX idx_sync_client_diagnostic_snapshots_health ON sync_client_diagnostic_snapshots(partition_id, health_max_severity, received_at DESC)'
+    );
+
+    // API Keys table
+    await sql`
+      CREATE TABLE IF NOT EXISTS sync_api_keys (
+        key_id TEXT PRIMARY KEY,
+        key_hash TEXT NOT NULL,
+        key_prefix TEXT NOT NULL,
+        name TEXT NOT NULL,
+        key_type TEXT NOT NULL,
+        scope_keys TEXT[] DEFAULT ARRAY[]::TEXT[],
+        actor_id TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        expires_at TIMESTAMPTZ,
+        last_used_at TIMESTAMPTZ,
+        revoked_at TIMESTAMPTZ
+      )
+    `.execute(db);
+
+    await this.ensureIndex(
+      db,
+      'idx_sync_api_keys_key_hash',
+      'CREATE INDEX idx_sync_api_keys_key_hash ON sync_api_keys(key_hash)'
+    );
+    await this.ensureIndex(
+      db,
+      'idx_sync_api_keys_key_type',
+      'CREATE INDEX idx_sync_api_keys_key_type ON sync_api_keys(key_type)'
+    );
+  }
+
+  // ===========================================================================
+  // Private Helpers
+  // ===========================================================================
+
+  private async ensureIndex<DB extends SyncCoreDb>(
+    db: Kysely<DB>,
+    indexName: string,
+    createSql: string
+  ): Promise<void> {
+    const exists = await sql<{ ok: 1 }>`
+      SELECT 1 as ok
+      FROM pg_indexes
+      WHERE schemaname = 'public'
+        AND indexname = ${indexName}
+      LIMIT 1
+    `.execute(db);
+
+    if (exists.rows.length > 0) return;
+    await sql.raw(createSql).execute(db);
+  }
+}
+
+export function createPostgresServerDialect(): PostgresServerSyncDialect {
+  return new PostgresServerSyncDialect();
+}
+
+/**
+ * Explicit server-side dialect alias for Neon-backed Postgres runtimes.
+ *
+ * Neon uses the same SQL family and sync schema behavior as Postgres, but this
+ * helper makes the runtime/provider intent visible in app code and host
+ * integrations.
+ */
+export function createNeonServerDialect(): PostgresServerSyncDialect {
+  return createPostgresServerDialect();
+}