pgserve 2.0.0 → 2.0.1

package/tests/benchmarks/runner.js

@@ -2,15 +2,14 @@
 
 /**
  * Benchmark Runner
- * Compares SQLite, PGlite, PostgreSQL Server, and pgserve performance
+ * Compares SQLite, PostgreSQL, and pgserve performance
  *
  * 100% Bun-native: Uses bun:sqlite instead of better-sqlite3
  */
 
 import { Database } from 'bun:sqlite';
-import { PGlite } from '@electric-sql/pglite';
-import { vector } from '@electric-sql/pglite/vector';
 import { startMultiTenantServer } from '../../src/index.js';
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -18,6 +17,9 @@ import pg from 'pg';
 import { loadEmbeddings, generateQueryVectors, formatPgVector, getEmbeddingsPath, getGroundTruth, calculateRecall } from './vector-generator.js';
 
 const { Pool } = pg;
+const LEGACY_PGSERVE_VERSION = '1.2.0';
+const LEGACY_PGSERVE_SPEC = `pgserve@${LEGACY_PGSERVE_VERSION}`;
+const NPX_BIN = process.platform === 'win32' ? 'npx.cmd' : 'npx';
 
 // ============================================================================
 // ANSI Colors and Visual Utilities (stress-test style)
@@ -43,7 +45,7 @@ function banner() {
 ${C.cyan}${C.bold}╔════════════════════════════════════════════════════════════════╗
 ║           pgserve UNIFIED BENCHMARK SUITE                      ║
 ║                                                                ║
-║  Comparing: SQLite │ PGlite │ PostgreSQL │ pgserve            ║
+║  Comparing: SQLite │ PostgreSQL │ pgserve 1.2.0 │ pgserve v2    ║
 ╚════════════════════════════════════════════════════════════════╝${C.reset}
 `);
 }
@@ -104,10 +106,10 @@ ${C.cyan}${C.bold}
   // Note: recallCount tracks only SEARCH scenarios (INSERT has 'N/A' recall)
   const engines = {
     sqlite: { name: 'SQLite', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
-    pglite: { name: 'PGlite', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
     postgres: { name: 'PostgreSQL', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0, skipped: false },
-    pgserve: { name: 'pgserve (disk)', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
-    pgserveRam: { name: 'pgserve (RAM)', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
+    pgserveV1: { name: 'pgserve 1.2.0', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
+    pgserve: { name: 'pgserve v2', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
+    pgserveRam: { name: 'pgserve v2 RAM', crudQps: 0, vecQps: 0, vecRecall: 0, p50: 0, p99: 0, errors: 0, count: 0, vecCount: 0, recallCount: 0 },
   };
 
   // Aggregate CRUD results
@@ -176,7 +178,7 @@ ${C.cyan}${C.bold}
   }
 
   // Print each engine row
-  const engineOrder = ['sqlite', 'pglite', 'postgres', 'pgserve'];
+  const engineOrder = ['sqlite', 'postgres', 'pgserveV1', 'pgserve'];
   if (canUseRam) engineOrder.push('pgserveRam');
 
   let maxScore = 0;
@@ -221,7 +223,7 @@ ${C.magenta}${C.bold}╔══════════════════
 `);
 }
 
-// Global error handlers (suppress expected PGlite WASM ExitStatus errors)
+// Global error handlers (suppress expected PostgreSQL WASM ExitStatus errors)
 process.on('unhandledRejection', (reason, promise) => {
   if (reason && reason.name === 'ExitStatus') return;
   console.error('Unhandled Promise Rejection:', reason);
@@ -370,54 +372,85 @@ class Metrics {
   }
 }
 
-/**
- * SQLite Benchmark
- */
-async function benchmarkSQLite(scenario) {
-  console.log('  🔸 Running SQLite benchmark...');
+function skippedCrud(reason, errors = 1) {
+  return { throughput: 0, p50: 0, p99: 0, errors, lockTimeouts: 0, totalOps: 0, skipped: true, reason };
+}
 
-  const dbPath = path.join(RESULTS_DIR, 'sqlite-bench.db');
-  if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+function skippedVector(reason, errors = 1) {
+  return { throughput: 0, recall: 'N/A', p50: 0, p99: 0, errors, totalOps: 0, skipped: true, reason };
+}
 
-  const db = new Database(dbPath);
+async function openPgPool({ port, database, max = 20, timeoutMs = 30_000 }) {
+  const pool = new Pool({
+    host: '127.0.0.1',
+    port,
+    database,
+    user: 'postgres',
+    password: 'postgres',
+    max,
+    connectionTimeoutMillis: 1000
+  });
 
-  // Setup schema
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS messages (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      await pool.query('SELECT 1');
+      return pool;
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  }
+
+  await pool.end().catch(() => {});
+  throw lastError || new Error(`PostgreSQL did not become ready on port ${port}`);
+}
+
+async function runCrudScenarioOnPool(pool, scenario) {
+  await pool.query(`
+    DROP TABLE IF EXISTS bench_messages;
+    CREATE TABLE bench_messages (
+      id SERIAL PRIMARY KEY,
       content TEXT,
-      timestamp INTEGER
+      timestamp BIGINT
     )
   `);
 
   const metrics = new Metrics();
   metrics.start();
 
-  // Run operations
   for (const op of scenario.operations) {
     if (op.type === 'INSERT') {
       const concurrent = op.concurrent || 1;
       const perThread = Math.floor(op.count / concurrent);
 
+      const promises = [];
       for (let i = 0; i < concurrent; i++) {
-        for (let j = 0; j < perThread; j++) {
-          const start = Date.now();
-          try {
-            db.prepare('INSERT INTO messages (content, timestamp) VALUES (?, ?)').run(
-              `Message ${i}-${j}`,
-              Date.now()
-            );
-            metrics.addLatency(Date.now() - start);
-          } catch (error) {
-            metrics.addError(error);
-          }
-        }
+        promises.push(
+          (async () => {
+            for (let j = 0; j < perThread; j++) {
+              const start = Date.now();
+              try {
+                await pool.query(
+                  'INSERT INTO bench_messages (content, timestamp) VALUES ($1, $2)',
+                  [`Message ${i}-${j}`, Date.now()]
+                );
+                metrics.addLatency(Date.now() - start);
+              } catch (error) {
+                metrics.addError(error);
+              }
+            }
+          })()
+        );
       }
+
+      await Promise.all(promises);
     } else if (op.type === 'SELECT') {
       for (let i = 0; i < op.count; i++) {
         const start = Date.now();
         try {
-          db.prepare('SELECT * FROM messages LIMIT 10').all();
+          await pool.query('SELECT * FROM bench_messages LIMIT 10');
           metrics.addLatency(Date.now() - start);
         } catch (error) {
           metrics.addError(error);
@@ -427,9 +460,9 @@ async function benchmarkSQLite(scenario) {
       for (let i = 0; i < op.count; i++) {
         const start = Date.now();
         try {
-          db.prepare('UPDATE messages SET content = ? WHERE id = ?').run(
-            `Updated ${i}`,
-            (i % 100) + 1
+          await pool.query(
+            'UPDATE bench_messages SET content = $1 WHERE id = $2',
+            [`Updated ${i}`, (i % 100) + 1]
           );
           metrics.addLatency(Date.now() - start);
         } catch (error) {
@@ -440,57 +473,220 @@ async function benchmarkSQLite(scenario) {
   }
 
   metrics.end();
-  db.close();
-
+  await pool.query('DROP TABLE IF EXISTS bench_messages');
   return metrics.getReport();
 }
 
+async function runVectorScenarioOnPool(pool, scenario, embeddings, queryVectors, groundTruth) {
+  await pool.query('CREATE EXTENSION IF NOT EXISTS vector');
+
+  await pool.query(`
+    DROP TABLE IF EXISTS embeddings;
+    CREATE TABLE embeddings (
+      id INTEGER PRIMARY KEY,
+      vector vector(${scenario.dimension})
+    )
+  `);
+
+  if (scenario.type === 'INSERT') {
+    console.log(`    Inserting ${scenario.insertCount} vectors (measured)...`);
+    const latencies = [];
+
+    for (let i = 0; i < scenario.insertCount; i++) {
+      const vec = formatPgVector(embeddings.vectors[i]);
+      const start = performance.now();
+      await pool.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
+      latencies.push(performance.now() - start);
+    }
+
+    const totalTime = latencies.reduce((a, b) => a + b, 0);
+    const qps = Math.round((scenario.insertCount / totalTime) * 1000);
+    latencies.sort((a, b) => a - b);
+    const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
+    const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
+
+    await pool.query('DROP TABLE IF EXISTS embeddings');
+
+    return {
+      throughput: qps,
+      recall: 'N/A',
+      p50: parseFloat(p50),
+      p99: parseFloat(p99),
+      errors: 0,
+      totalOps: scenario.insertCount,
+      skipped: false
+    };
+  }
+
+  console.log('    Inserting vectors...');
+  for (let i = 0; i < embeddings.vectors.length; i++) {
+    const vec = formatPgVector(embeddings.vectors[i]);
+    await pool.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
+  }
+
+  console.log('    Warming up...');
+  for (let i = 0; i < scenario.warmupQueries; i++) {
+    const queryVec = formatPgVector(queryVectors[i % queryVectors.length]);
+    await pool.query('SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2', [queryVec, scenario.k]);
+  }
+
+  console.log('    Running measured queries...');
+  const latencies = [];
+  const approximateResults = [];
+
+  for (let i = 0; i < scenario.queryCount; i++) {
+    const queryVec = formatPgVector(queryVectors[i]);
+    const start = performance.now();
+    const result = await pool.query(
+      'SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2',
+      [queryVec, scenario.k]
+    );
+    latencies.push(performance.now() - start);
+    approximateResults.push(result.rows.map(r => r.id));
+  }
+
+  const { recall } = calculateRecall(approximateResults, groundTruth, scenario.k);
+  const totalTime = latencies.reduce((a, b) => a + b, 0);
+  const qps = Math.round((scenario.queryCount / totalTime) * 1000);
+  latencies.sort((a, b) => a - b);
+  const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
+  const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
+
+  await pool.query('DROP TABLE IF EXISTS embeddings');
+
+  return {
+    throughput: qps,
+    recall: (recall * 100).toFixed(1),
+    p50: parseFloat(p50),
+    p99: parseFloat(p99),
+    errors: 0,
+    totalOps: scenario.queryCount,
+    skipped: false
+  };
+}
+
+async function startLegacyPgserve({ port, enablePgvector = false }) {
+  const dataDir = path.join(RESULTS_DIR, `pgserve-${LEGACY_PGSERVE_VERSION}-port-${port}`);
+  fs.rmSync(dataDir, { recursive: true, force: true });
+
+  const args = [
+    '-y',
+    LEGACY_PGSERVE_SPEC,
+    '--port',
+    String(port),
+    '--host',
+    '127.0.0.1',
+    '--data',
+    dataDir,
+    '--log',
+    'error',
+    '--no-stats',
+    '--no-cluster',
+  ];
+  if (enablePgvector) args.push('--pgvector');
+
+  const tail = [];
+  const child = spawn(NPX_BIN, args, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, NO_COLOR: '1' },
+  });
+
+  const append = (chunk) => {
+    tail.push(String(chunk));
+    while (tail.join('').length > 4000) tail.shift();
+  };
+  child.stdout.on('data', append);
+  child.stderr.on('data', append);
+
+  let exited = false;
+  child.once('exit', () => {
+    exited = true;
+  });
+
+  try {
+    const pool = await openPgPool({ port, database: 'bench_test', timeoutMs: 60_000 });
+    await pool.end();
+  } catch (error) {
+    await stopChildProcess(child);
+    const output = tail.join('').trim();
+    const detail = output ? `; output: ${output}` : '';
+    throw new Error(`${LEGACY_PGSERVE_SPEC} failed to become ready: ${error.message}${detail}`);
+  }
+
+  return {
+    async stop() {
+      if (!exited) await stopChildProcess(child);
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    },
+  };
+}
+
+async function stopChildProcess(child) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill('SIGTERM');
+  const exited = await new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), 3000);
+    child.once('exit', () => {
+      clearTimeout(timer);
+      resolve(true);
+    });
+  });
+
+  if (!exited) {
+    child.kill('SIGKILL');
+    await new Promise((resolve) => child.once('exit', resolve));
+  }
+}
+
 /**
- * PGlite Benchmark (in-process WASM PostgreSQL)
+ * SQLite Benchmark
  */
-async function benchmarkPGlite(scenario) {
-  console.log('  🔹 Running PGlite benchmark...');
+async function benchmarkSQLite(scenario) {
+  console.log('  🔸 Running SQLite benchmark...');
 
-  const dataDir = path.join(RESULTS_DIR, 'pglite-bench');
-  if (fs.existsSync(dataDir)) {
-    fs.rmSync(dataDir, { recursive: true });
-  }
+  const dbPath = path.join(RESULTS_DIR, 'sqlite-bench.db');
+  if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
 
-  const db = new PGlite(dataDir);
+  const db = new Database(dbPath);
 
   // Setup schema
-  await db.exec(`
+  db.exec(`
     CREATE TABLE IF NOT EXISTS messages (
-      id SERIAL PRIMARY KEY,
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
       content TEXT,
-      timestamp BIGINT
+      timestamp INTEGER
     )
   `);
 
   const metrics = new Metrics();
   metrics.start();
 
-  // Run operations (PGlite is single-threaded, so concurrent = sequential)
+  // Run operations
   for (const op of scenario.operations) {
     if (op.type === 'INSERT') {
-      const total = op.count;
-      for (let i = 0; i < total; i++) {
-        const start = Date.now();
-        try {
-          await db.query(
-            'INSERT INTO messages (content, timestamp) VALUES ($1, $2)',
-            [`Message ${i}`, Date.now()]
-          );
-          metrics.addLatency(Date.now() - start);
-        } catch (error) {
-          metrics.addError(error);
+      const concurrent = op.concurrent || 1;
+      const perThread = Math.floor(op.count / concurrent);
+
+      for (let i = 0; i < concurrent; i++) {
+        for (let j = 0; j < perThread; j++) {
+          const start = Date.now();
+          try {
+            db.prepare('INSERT INTO messages (content, timestamp) VALUES (?, ?)').run(
+              `Message ${i}-${j}`,
+              Date.now()
+            );
+            metrics.addLatency(Date.now() - start);
+          } catch (error) {
+            metrics.addError(error);
+          }
         }
       }
     } else if (op.type === 'SELECT') {
       for (let i = 0; i < op.count; i++) {
         const start = Date.now();
         try {
-          await db.query('SELECT * FROM messages LIMIT 10');
+          db.prepare('SELECT * FROM messages LIMIT 10').all();
           metrics.addLatency(Date.now() - start);
         } catch (error) {
           metrics.addError(error);
@@ -500,9 +696,9 @@ async function benchmarkPGlite(scenario) {
       for (let i = 0; i < op.count; i++) {
         const start = Date.now();
         try {
-          await db.query(
-            'UPDATE messages SET content = $1 WHERE id = $2',
-            [`Updated ${i}`, (i % 100) + 1]
+          db.prepare('UPDATE messages SET content = ? WHERE id = ?').run(
+            `Updated ${i}`,
+            (i % 100) + 1
           );
           metrics.addLatency(Date.now() - start);
         } catch (error) {
@@ -513,12 +709,7 @@ async function benchmarkPGlite(scenario) {
   }
 
   metrics.end();
-
-  try {
-    await db.close();
-  } catch (e) {
-    // Ignore ExitStatus errors from WASM cleanup
-  }
+  db.close();
 
   return metrics.getReport();
 }
@@ -529,92 +720,36 @@ async function benchmarkPGlite(scenario) {
 async function benchmarkPostgreSQL(scenario) {
   console.log('  🔷 Running PostgreSQL Server benchmark...');
 
-  const pool = new Pool({
-    ...POSTGRES_CONFIG,
-    max: 20
-  });
-
+  let pool;
   try {
-    // Test connection first
-    await pool.query('SELECT 1');
-
-    // Setup schema
-    await pool.query(`
-      DROP TABLE IF EXISTS bench_messages;
-      CREATE TABLE bench_messages (
-        id SERIAL PRIMARY KEY,
-        content TEXT,
-        timestamp BIGINT
-      )
-    `);
-
-    const metrics = new Metrics();
-    metrics.start();
-
-    // Run operations
-    for (const op of scenario.operations) {
-      if (op.type === 'INSERT') {
-        const concurrent = op.concurrent || 1;
-        const perThread = Math.floor(op.count / concurrent);
-
-        const promises = [];
-        for (let i = 0; i < concurrent; i++) {
-          promises.push(
-            (async () => {
-              for (let j = 0; j < perThread; j++) {
-                const start = Date.now();
-                try {
-                  await pool.query(
-                    'INSERT INTO bench_messages (content, timestamp) VALUES ($1, $2)',
-                    [`Message ${i}-${j}`, Date.now()]
-                  );
-                  metrics.addLatency(Date.now() - start);
-                } catch (error) {
-                  metrics.addError(error);
-                }
-              }
-            })()
-          );
-        }
-
-        await Promise.all(promises);
-      } else if (op.type === 'SELECT') {
-        for (let i = 0; i < op.count; i++) {
-          const start = Date.now();
-          try {
-            await pool.query('SELECT * FROM bench_messages LIMIT 10');
-            metrics.addLatency(Date.now() - start);
-          } catch (error) {
-            metrics.addError(error);
-          }
-        }
-      } else if (op.type === 'UPDATE') {
-        for (let i = 0; i < op.count; i++) {
-          const start = Date.now();
-          try {
-            await pool.query(
-              'UPDATE bench_messages SET content = $1 WHERE id = $2',
-              [`Updated ${i}`, (i % 100) + 1]
-            );
-            metrics.addLatency(Date.now() - start);
-          } catch (error) {
-            metrics.addError(error);
-          }
-        }
-      }
-    }
-
-    metrics.end();
+    pool = await openPgPool({ ...POSTGRES_CONFIG });
+    return await runCrudScenarioOnPool(pool, scenario);
+  } catch (error) {
+    console.error('   PostgreSQL benchmark skipped:', error.message);
+    return skippedCrud(error.message, 0);
+  } finally {
+    await pool?.end().catch(() => {});
+  }
+}
 
-    // Cleanup
-    await pool.query('DROP TABLE IF EXISTS bench_messages');
-    await pool.end();
+/**
+ * pgserve 1.2.0 Benchmark (published npm package)
+ */
+async function benchmarkPgserveV1(scenario) {
+  console.log(`  🧭 Running ${LEGACY_PGSERVE_SPEC} benchmark...`);
 
-    return metrics.getReport();
+  let legacy;
+  let pool;
+  try {
+    legacy = await startLegacyPgserve({ port: 18431 });
+    pool = await openPgPool({ port: 18431, database: 'bench_test' });
+    return await runCrudScenarioOnPool(pool, scenario);
   } catch (error) {
-    console.error('   PostgreSQL benchmark skipped:', error.message);
-    await pool.end().catch(() => {});
-    return { throughput: 0, p50: 0, p99: 0, errors: 0, lockTimeouts: 0, totalOps: 0, skipped: true };
+    console.error(`   ${LEGACY_PGSERVE_SPEC} benchmark skipped:`, error.message);
+    return skippedCrud(error.message);
+  } finally {
+    await pool?.end().catch(() => {});
+    await legacy?.stop().catch(() => {});
   }
 }
 
@@ -625,127 +760,27 @@ async function benchmarkPostgreSQL(scenario) {
  */
 async function benchmarkPgserve(scenario, useRam = false) {
   const mode = useRam ? 'RAM' : 'disk';
-  console.log(`  🚀 Running pgserve (${mode}) benchmark...`);
+  console.log(`  🚀 Running pgserve v2 (${mode}) benchmark...`);
 
   let server;
+  let pool;
   try {
     // Start pgserve in memory mode (optionally with RAM storage)
+    const port = useRam ? 18433 : 18432;
     server = await startMultiTenantServer({
-      port: useRam ? 18433 : 18432,
+      port,
       logLevel: 'error',
       useRam
     });
 
-    // Wait for server to be fully ready
-    await new Promise(resolve => setTimeout(resolve, 2000));
-
-    const port = useRam ? 18433 : 18432;
-    const pool = new Pool({
-      host: 'localhost',
-      port,
-      database: 'bench_test',
-      user: 'postgres',
-      password: 'postgres',
-      max: 20,
-      connectionTimeoutMillis: 30000
-    });
-
-    // Wait for connection with retries
-    let connected = false;
-    for (let i = 0; i < 10; i++) {
-      try {
-        await pool.query('SELECT 1');
-        connected = true;
-        break;
-      } catch (error) {
-        if (i === 9) throw error;
-        await new Promise(resolve => setTimeout(resolve, 1000));
-      }
-    }
-
-    if (!connected) {
-      throw new Error('Failed to connect to pgserve');
-    }
-
-    // Setup schema
-    await pool.query(`
-      DROP TABLE IF EXISTS bench_messages;
-      CREATE TABLE bench_messages (
-        id SERIAL PRIMARY KEY,
-        content TEXT,
-        timestamp BIGINT
-      )
-    `);
-
-    const metrics = new Metrics();
-    metrics.start();
-
-    // Run operations (TRUE concurrent - pgserve handles this natively)
-    for (const op of scenario.operations) {
-      if (op.type === 'INSERT') {
-        const concurrent = op.concurrent || 1;
-        const perThread = Math.floor(op.count / concurrent);
-
-        const promises = [];
-        for (let i = 0; i < concurrent; i++) {
-          promises.push(
-            (async () => {
-              for (let j = 0; j < perThread; j++) {
-                const start = Date.now();
-                try {
-                  await pool.query(
-                    'INSERT INTO bench_messages (content, timestamp) VALUES ($1, $2)',
-                    [`Message ${i}-${j}`, Date.now()]
-                  );
-                  metrics.addLatency(Date.now() - start);
-                } catch (error) {
-                  metrics.addError(error);
-                }
-              }
-            })()
-          );
-        }
-
-        await Promise.all(promises);
-      } else if (op.type === 'SELECT') {
-        for (let i = 0; i < op.count; i++) {
-          const start = Date.now();
-          try {
-            await pool.query('SELECT * FROM bench_messages LIMIT 10');
-            metrics.addLatency(Date.now() - start);
-          } catch (error) {
-            metrics.addError(error);
-          }
-        }
-      } else if (op.type === 'UPDATE') {
-        for (let i = 0; i < op.count; i++) {
-          const start = Date.now();
-          try {
-            await pool.query(
-              'UPDATE bench_messages SET content = $1 WHERE id = $2',
-              [`Updated ${i}`, (i % 100) + 1]
-            );
-            metrics.addLatency(Date.now() - start);
-          } catch (error) {
-            metrics.addError(error);
-          }
-        }
-      }
-    }
-
-    metrics.end();
-
-    // Cleanup
-    await pool.end();
-    await server.stop();
-
-    return metrics.getReport();
+    pool = await openPgPool({ port, database: 'bench_test' });
+    return await runCrudScenarioOnPool(pool, scenario);
   } catch (error) {
-    console.error(`   pgserve (${mode}) benchmark failed:`, error.message);
-    if (server) {
-      try { await server.stop(); } catch (e) {}
-    }
-    return { throughput: 0, p50: 0, p99: 0, errors: 1, lockTimeouts: 0, totalOps: 0, skipped: true };
+    console.error(`   pgserve v2 (${mode}) benchmark failed:`, error.message);
+    return skippedCrud(error.message);
+  } finally {
+    await pool?.end().catch(() => {});
+    await server?.stop().catch(() => {});
   }
 }
 
@@ -754,247 +789,42 @@ async function benchmarkPgserve(scenario, useRam = false) {
 // ============================================================================
 
 /**
- * PGlite Vector Benchmark
+ * PostgreSQL Server Vector Benchmark
  * Supports both INSERT and SEARCH scenarios
  */
-async function benchmarkPGliteVector(scenario, embeddings, queryVectors, groundTruth) {
-  console.log('  🔹 Running PGlite vector benchmark...');
-
-  const dataDir = path.join(RESULTS_DIR, 'pglite-vector-bench');
-  if (fs.existsSync(dataDir)) {
-    fs.rmSync(dataDir, { recursive: true });
-  }
+async function benchmarkPostgreSQLVector(scenario, embeddings, queryVectors, groundTruth) {
+  console.log('  🔷 Running PostgreSQL vector benchmark...');
 
+  let pool;
   try {
-    // Create PGlite with pgvector extension
-    const db = new PGlite(dataDir, { extensions: { vector } });
-    await db.exec('CREATE EXTENSION IF NOT EXISTS vector');
-
-    // Setup schema
-    await db.exec(`
-      DROP TABLE IF EXISTS embeddings;
-      CREATE TABLE embeddings (
-        id INTEGER PRIMARY KEY,
-        vector vector(${scenario.dimension})
-      )
-    `);
-
-    // INSERT scenario - measure insert speed
-    if (scenario.type === 'INSERT') {
-      console.log(`    Inserting ${scenario.insertCount} vectors (measured)...`);
-      const latencies = [];
-
-      for (let i = 0; i < scenario.insertCount; i++) {
-        const vec = formatPgVector(embeddings.vectors[i]);
-        const start = performance.now();
-        await db.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
-        latencies.push(performance.now() - start);
-      }
-
-      const totalTime = latencies.reduce((a, b) => a + b, 0);
-      const qps = Math.round((scenario.insertCount / totalTime) * 1000);
-      latencies.sort((a, b) => a - b);
-      const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
-      const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
-
-      try { await db.close(); } catch { /* ignore */ }
-
-      return {
-        throughput: qps,
-        recall: 'N/A',
-        p50: parseFloat(p50),
-        p99: parseFloat(p99),
-        errors: 0,
-        totalOps: scenario.insertCount,
-        skipped: false
-      };
-    }
-
-    // SEARCH scenario - measure recall and QPS
-    // Phase 1: Insert all vectors (not measured)
-    console.log('    Inserting vectors...');
-    for (let i = 0; i < embeddings.vectors.length; i++) {
-      const vec = formatPgVector(embeddings.vectors[i]);
-      await db.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
-    }
-
-    // Phase 2: Warm-up queries (not measured)
-    console.log('    Warming up...');
-    for (let i = 0; i < scenario.warmupQueries; i++) {
-      const queryVec = formatPgVector(queryVectors[i % queryVectors.length]);
-      await db.query(`SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2`, [queryVec, scenario.k]);
-    }
-
-    // Phase 3: Measured queries with recall tracking
-    console.log('    Running measured queries...');
-    const latencies = [];
-    const approximateResults = [];
-
-    for (let i = 0; i < scenario.queryCount; i++) {
-      const queryVec = formatPgVector(queryVectors[i]);
-      const start = performance.now();
-      const result = await db.query(
-        `SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2`,
-        [queryVec, scenario.k]
-      );
-      latencies.push(performance.now() - start);
-
-      // Collect IDs for recall calculation
-      approximateResults.push(result.rows.map(r => r.id));
-    }
-
-    // Calculate recall
-    const { recall } = calculateRecall(approximateResults, groundTruth, scenario.k);
-
-    // Calculate metrics
-    const totalTime = latencies.reduce((a, b) => a + b, 0);
-    const qps = Math.round((scenario.queryCount / totalTime) * 1000);
-    latencies.sort((a, b) => a - b);
-    const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
-    const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
-
-    try { await db.close(); } catch { /* ignore */ }
-
-    return {
-      throughput: qps,
-      recall: (recall * 100).toFixed(1),  // as percentage
-      p50: parseFloat(p50),
-      p99: parseFloat(p99),
-      errors: 0,
-      totalOps: scenario.queryCount,
-      skipped: false
-    };
+    pool = await openPgPool({ ...POSTGRES_CONFIG });
+    return await runVectorScenarioOnPool(pool, scenario, embeddings, queryVectors, groundTruth);
   } catch (error) {
-    console.error('   PGlite vector benchmark failed:', error.message);
-    return { throughput: 0, recall: 0, p50: 0, p99: 0, errors: 1, totalOps: 0, skipped: true };
+    console.error('   PostgreSQL vector benchmark skipped:', error.message);
+    return skippedVector(error.message, 0);
+  } finally {
+    await pool?.end().catch(() => {});
   }
 }
 
 /**
- * PostgreSQL Server Vector Benchmark
- * Supports both INSERT and SEARCH scenarios
+ * pgserve 1.2.0 Vector Benchmark (published npm package)
  */
-async function benchmarkPostgreSQLVector(scenario, embeddings, queryVectors, groundTruth) {
-  console.log('  🔷 Running PostgreSQL vector benchmark...');
-
-  const pool = new Pool({
-    ...POSTGRES_CONFIG,
-    max: 20
-  });
+async function benchmarkPgserveV1Vector(scenario, embeddings, queryVectors, groundTruth) {
+  console.log(`  🧭 Running ${LEGACY_PGSERVE_SPEC} vector benchmark...`);
 
+  let legacy;
+  let pool;
   try {
-    // Test connection and check for pgvector
-    await pool.query('SELECT 1');
-
-    // Check if pgvector is available
-    try {
-      await pool.query('CREATE EXTENSION IF NOT EXISTS vector');
-    } catch (e) {
-      console.error('   pgvector extension not available. Use pgvector/pgvector:pg17 Docker image.');
-      await pool.end();
-      return { throughput: 0, recall: 'N/A', p50: 0, p99: 0, errors: 1, totalOps: 0, skipped: true };
-    }
-
-    // Setup schema
-    await pool.query(`
-      DROP TABLE IF EXISTS embeddings;
-      CREATE TABLE embeddings (
-        id INTEGER PRIMARY KEY,
-        vector vector(${scenario.dimension})
-      )
-    `);
-
-    // INSERT scenario - measure insert speed
-    if (scenario.type === 'INSERT') {
-      console.log(`    Inserting ${scenario.insertCount} vectors (measured)...`);
-      const latencies = [];
-
-      for (let i = 0; i < scenario.insertCount; i++) {
-        const vec = formatPgVector(embeddings.vectors[i]);
-        const start = performance.now();
-        await pool.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
-        latencies.push(performance.now() - start);
-      }
-
-      const totalTime = latencies.reduce((a, b) => a + b, 0);
-      const qps = Math.round((scenario.insertCount / totalTime) * 1000);
-      latencies.sort((a, b) => a - b);
-      const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
-      const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
-
-      await pool.query('DROP TABLE IF EXISTS embeddings');
-      await pool.end();
-
-      return {
-        throughput: qps,
-        recall: 'N/A',
-        p50: parseFloat(p50),
-        p99: parseFloat(p99),
-        errors: 0,
-        totalOps: scenario.insertCount,
-        skipped: false
-      };
-    }
-
-    // SEARCH scenario - Phase 1: Insert all vectors (not measured)
-    console.log('    Inserting vectors...');
-    for (let i = 0; i < embeddings.vectors.length; i++) {
-      const vec = formatPgVector(embeddings.vectors[i]);
-      await pool.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
-    }
-
-    // Phase 2: Warm-up queries (not measured)
-    console.log('    Warming up...');
-    for (let i = 0; i < scenario.warmupQueries; i++) {
-      const queryVec = formatPgVector(queryVectors[i % queryVectors.length]);
-      await pool.query(`SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2`, [queryVec, scenario.k]);
-    }
-
-    // Phase 3: Measured queries with recall tracking
-    console.log('    Running measured queries...');
-    const latencies = [];
-    const approximateResults = [];
-
-    for (let i = 0; i < scenario.queryCount; i++) {
-      const queryVec = formatPgVector(queryVectors[i]);
-      const start = performance.now();
-      const result = await pool.query(
-        `SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2`,
-        [queryVec, scenario.k]
-      );
-      latencies.push(performance.now() - start);
-
-      // Collect IDs for recall calculation
-      approximateResults.push(result.rows.map(r => r.id));
-    }
-
-    // Calculate recall
-    const { recall } = calculateRecall(approximateResults, groundTruth, scenario.k);
-
-    // Calculate metrics
-    const totalTime = latencies.reduce((a, b) => a + b, 0);
-    const qps = Math.round((scenario.queryCount / totalTime) * 1000);
-    latencies.sort((a, b) => a - b);
-    const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
-    const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
-
-    // Cleanup
-    await pool.query('DROP TABLE IF EXISTS embeddings');
-    await pool.end();
-
-    return {
-      throughput: qps,
-      recall: (recall * 100).toFixed(1),  // as percentage
-      p50: parseFloat(p50),
-      p99: parseFloat(p99),
-      errors: 0,
-      totalOps: scenario.queryCount,
-      skipped: false
-    };
+    legacy = await startLegacyPgserve({ port: 18434, enablePgvector: true });
+    pool = await openPgPool({ port: 18434, database: 'vector_bench' });
+    return await runVectorScenarioOnPool(pool, scenario, embeddings, queryVectors, groundTruth);
   } catch (error) {
-    console.error('   PostgreSQL vector benchmark skipped:', error.message);
-    await pool.end().catch(() => {});
-    return { throughput: 0, recall: 'N/A', p50: 0, p99: 0, errors: 0, totalOps: 0, skipped: true };
+    console.error(`   ${LEGACY_PGSERVE_SPEC} vector benchmark skipped:`, error.message);
+    return skippedVector(error.message);
+  } finally {
+    await pool?.end().catch(() => {});
+    await legacy?.stop().catch(() => {});
   }
 }
 
@@ -1004,162 +834,28 @@ async function benchmarkPostgreSQLVector(scenario, embeddings, queryVectors, gro
  */
 async function benchmarkPgserveVector(scenario, embeddings, queryVectors, groundTruth, useRam = false) {
   const mode = useRam ? 'RAM' : 'disk';
-  console.log(`  🚀 Running pgserve (${mode}) vector benchmark...`);
+  console.log(`  🚀 Running pgserve v2 (${mode}) vector benchmark...`);
 
   let server;
+  let pool;
   try {
     // Start pgserve (use different ports for vector benchmarks to avoid conflicts)
-    const port = useRam ? 18435 : 18434;
+    const port = useRam ? 18436 : 18435;
     server = await startMultiTenantServer({
       port,
       logLevel: 'error',
-      useRam
+      useRam,
+      enablePgvector: true
     });
 
-    // Wait for server to be fully ready
-    await new Promise(resolve => setTimeout(resolve, 2000));
-
-    const pool = new Pool({
-      host: 'localhost',
-      port,
-      database: 'vector_bench',
-      user: 'postgres',
-      password: 'postgres',
-      max: 20,
-      connectionTimeoutMillis: 30000
-    });
-
-    // Wait for connection with retries
-    let connected = false;
-    for (let i = 0; i < 10; i++) {
-      try {
-        await pool.query('SELECT 1');
-        connected = true;
-        break;
-      } catch (error) {
-        if (i === 9) throw error;
-        await new Promise(resolve => setTimeout(resolve, 1000));
-      }
-    }
-
-    if (!connected) {
-      throw new Error('Failed to connect to pgserve');
-    }
-
-    // Enable pgvector extension
-    try {
-      await pool.query('CREATE EXTENSION IF NOT EXISTS vector');
-    } catch (e) {
-      console.error(`   pgvector extension not available in pgserve. Install pgvector files to ~/.pgserve/bin/<platform>/`);
-      await pool.end();
-      await server.stop();
-      return { throughput: 0, recall: 'N/A', p50: 0, p99: 0, errors: 0, totalOps: 0, skipped: true, reason: 'pgvector not installed' };
-    }
-
-    // Setup schema
-    await pool.query(`
-      DROP TABLE IF EXISTS embeddings;
-      CREATE TABLE embeddings (
-        id INTEGER PRIMARY KEY,
-        vector vector(${scenario.dimension})
-      )
-    `);
-
-    // INSERT scenario - measure insert speed
-    if (scenario.type === 'INSERT') {
-      console.log(`    Inserting ${scenario.insertCount} vectors (measured)...`);
-      const latencies = [];
-
-      for (let i = 0; i < scenario.insertCount; i++) {
-        const vec = formatPgVector(embeddings.vectors[i]);
-        const start = performance.now();
-        await pool.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
-        latencies.push(performance.now() - start);
-      }
-
-      const totalTime = latencies.reduce((a, b) => a + b, 0);
-      const qps = Math.round((scenario.insertCount / totalTime) * 1000);
-      latencies.sort((a, b) => a - b);
-      const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
-      const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
-
-      await pool.query('DROP TABLE IF EXISTS embeddings');
-      await pool.end();
-      await server.stop();
-
-      return {
-        throughput: qps,
-        recall: 'N/A',
-        p50: parseFloat(p50),
-        p99: parseFloat(p99),
-        errors: 0,
-        totalOps: scenario.insertCount,
-        skipped: false
-      };
-    }
-
-    // SEARCH scenario - Phase 1: Insert all vectors (not measured)
-    console.log('    Inserting vectors...');
-    for (let i = 0; i < embeddings.vectors.length; i++) {
-      const vec = formatPgVector(embeddings.vectors[i]);
-      await pool.query('INSERT INTO embeddings (id, vector) VALUES ($1, $2::vector)', [i + 1, vec]);
-    }
-
-    // Phase 2: Warm-up queries (not measured)
-    console.log('    Warming up...');
-    for (let i = 0; i < scenario.warmupQueries; i++) {
-      const queryVec = formatPgVector(queryVectors[i % queryVectors.length]);
-      await pool.query(`SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2`, [queryVec, scenario.k]);
-    }
-
-    // Phase 3: Measured queries with recall tracking
-    console.log('    Running measured queries...');
-    const latencies = [];
-    const approximateResults = [];
-
-    for (let i = 0; i < scenario.queryCount; i++) {
-      const queryVec = formatPgVector(queryVectors[i]);
-      const start = performance.now();
-      const result = await pool.query(
-        `SELECT id FROM embeddings ORDER BY vector <-> $1::vector LIMIT $2`,
-        [queryVec, scenario.k]
-      );
-      latencies.push(performance.now() - start);
-
-      // Collect IDs for recall calculation
-      approximateResults.push(result.rows.map(r => r.id));
-    }
-
-    // Calculate recall
-    const { recall } = calculateRecall(approximateResults, groundTruth, scenario.k);
-
-    // Calculate metrics
-    const totalTime = latencies.reduce((a, b) => a + b, 0);
-    const qps = Math.round((scenario.queryCount / totalTime) * 1000);
-    latencies.sort((a, b) => a - b);
-    const p50 = latencies[Math.floor(latencies.length * 0.5)]?.toFixed(1) || 0;
-    const p99 = latencies[Math.floor(latencies.length * 0.99)]?.toFixed(1) || 0;
-
-    // Cleanup
-    await pool.query('DROP TABLE IF EXISTS embeddings');
-    await pool.end();
-    await server.stop();
-
-    return {
-      throughput: qps,
-      recall: (recall * 100).toFixed(1),  // as percentage
-      p50: parseFloat(p50),
-      p99: parseFloat(p99),
-      errors: 0,
-      totalOps: scenario.queryCount,
-      skipped: false
-    };
+    pool = await openPgPool({ port, database: 'vector_bench' });
+    return await runVectorScenarioOnPool(pool, scenario, embeddings, queryVectors, groundTruth);
   } catch (error) {
-    console.error(`   pgserve (${mode}) vector benchmark failed:`, error.message);
-    if (server) {
-      try { await server.stop(); } catch { /* ignore */ }
-    }
-    return { throughput: 0, recall: 'N/A', p50: 0, p99: 0, errors: 0, totalOps: 0, skipped: true, reason: error.message };
+    console.error(`   pgserve v2 (${mode}) vector benchmark failed:`, error.message);
+    return skippedVector(error.message, 0);
+  } finally {
+    await pool?.end().catch(() => {});
+    await server?.stop().catch(() => {});
   }
 }
 
@@ -1188,89 +884,66 @@ function generateReport(results, vectorResults = []) {
   md += 'psql postgresql://localhost:5432/mydb\n';
   md += '```\n\n';
 
+  const metricValue = (data, key) => {
+    if (!data || data.skipped) return 'N/A';
+    const value = data[key];
+    return value === undefined || value === null ? 'N/A' : value;
+  };
+  const metricNumber = (data, key) => {
+    if (!data || data.skipped) return null;
+    const value = Number.parseFloat(data[key]);
+    return Number.isFinite(value) ? value : null;
+  };
+  const winnerName = (rows, key, direction) => {
+    let winner = null;
+    for (const row of rows) {
+      const value = metricNumber(row.data, key);
+      if (value === null) continue;
+      if (!winner || (direction === 'max' ? value > winner.value : value < winner.value)) {
+        winner = { name: row.name, value };
+      }
+    }
+    return winner?.name || 'N/A';
+  };
+  const pctDelta = (current, baseline) => {
+    if (!current || !baseline || current.skipped || baseline.skipped || baseline.throughput <= 0) return null;
+    return ((current.throughput / baseline.throughput - 1) * 100).toFixed(1);
+  };
+  const renderMetricTable = (rows, metrics) => {
+    let table = `| Metric | ${rows.map(r => r.name).join(' | ')} | Winner |\n`;
+    table += `| --- | ${rows.map(() => '---:').join(' | ')} | --- |\n`;
+    for (const metric of metrics) {
+      table += `| ${metric.label} | ${rows.map(r => metric.format(metricValue(r.data, metric.key))).join(' | ')} | ${winnerName(rows, metric.key, metric.direction)} |\n`;
+    }
+    return `${table}\n`;
+  };
+  const plain = (value) => String(value);
+  const percent = (value) => value === 'N/A' ? value : `${value}%`;
+
   for (const scenario of results) {
     md += `## ${scenario.name}\n\n`;
     md += `${scenario.description}\n\n`;
 
-    const { sqlite, pglite, postgres, pgserve, pgserveRam } = scenario;
-    const hasRam = pgserveRam && !pgserveRam.skipped;
-
-    if (hasRam) {
-      // Extended table with RAM column
-      md += '```\n';
-      md += '┌─────────────────┬──────────┬──────────┬──────────┬──────────┬─────────────┬─────────────┐\n';
-      md += '│ Metric          │ SQLite   │ PGlite   │ PostgreSQL│ pgserve  │ pgserve RAM │ Winner      │\n';
-      md += '├─────────────────┼──────────┼──────────┼──────────┼──────────┼─────────────┼─────────────┤\n';
-
-      // Find winners (include RAM)
-      const throughputs = { sqlite: sqlite.throughput, pglite: pglite.throughput, postgres: postgres.throughput, pgserve: pgserve.throughput, pgserveRam: pgserveRam.throughput };
-      const p50s = { sqlite: sqlite.p50, pglite: pglite.p50, postgres: postgres.p50, pgserve: pgserve.p50, pgserveRam: pgserveRam.p50 };
-      const p99s = { sqlite: sqlite.p99, pglite: pglite.p99, postgres: postgres.p99, pgserve: pgserve.p99, pgserveRam: pgserveRam.p99 };
-      const errors = { sqlite: sqlite.errors, pglite: pglite.errors, postgres: postgres.errors, pgserve: pgserve.errors, pgserveRam: pgserveRam.errors };
-
-      const getMaxKey = (obj) => Object.entries(obj).reduce((a, b) => a[1] > b[1] ? a : b)[0];
-      const getMinKey = (obj) => Object.entries(obj).filter(([k,v]) => v > 0 || k === 'sqlite').reduce((a, b) => a[1] < b[1] ? a : b)[0];
-      const getMinErrorKey = (obj) => Object.entries(obj).reduce((a, b) => a[1] <= b[1] ? a : b)[0];
-
-      const nameMap = { sqlite: 'SQLite', pglite: 'PGlite', postgres: 'PostgreSQL', pgserve: 'pgserve', pgserveRam: 'pgserve RAM' };
-
-      const pad = (s, n) => String(s).padEnd(n);
-
-      md += `│ Throughput (qps)│ ${pad(sqlite.throughput, 8)} │ ${pad(pglite.throughput, 8)} │ ${pad(postgres.throughput, 9)} │ ${pad(pgserve.throughput, 8)} │ ${pad(pgserveRam.throughput, 11)} │ ${pad(nameMap[getMaxKey(throughputs)], 11)} │\n`;
-      md += `│ P50 latency (ms)│ ${pad(sqlite.p50, 8)} │ ${pad(pglite.p50, 8)} │ ${pad(postgres.p50, 9)} │ ${pad(pgserve.p50, 8)} │ ${pad(pgserveRam.p50, 11)} │ ${pad(nameMap[getMinKey(p50s)], 11)} │\n`;
-      md += `│ P99 latency (ms)│ ${pad(sqlite.p99, 8)} │ ${pad(pglite.p99, 8)} │ ${pad(postgres.p99, 9)} │ ${pad(pgserve.p99, 8)} │ ${pad(pgserveRam.p99, 11)} │ ${pad(nameMap[getMinKey(p99s)], 11)} │\n`;
-      md += `│ Errors          │ ${pad(sqlite.errors, 8)} │ ${pad(pglite.errors, 8)} │ ${pad(postgres.errors, 9)} │ ${pad(pgserve.errors, 8)} │ ${pad(pgserveRam.errors, 11)} │ ${pad(nameMap[getMinErrorKey(errors)], 11)} │\n`;
-      md += '└─────────────────┴──────────┴──────────┴──────────┴──────────┴─────────────┴─────────────┘\n';
-      md += '```\n\n';
-
-      // Analysis with RAM comparison
-      const winner = nameMap[getMaxKey(throughputs)];
-      if (winner === 'pgserve RAM') {
-        const vsDisk = pgserve.throughput > 0 ? ((pgserveRam.throughput / pgserve.throughput - 1) * 100).toFixed(1) : 'N/A';
-        const vsPGlite = pglite.throughput > 0 ? ((pgserveRam.throughput / pglite.throughput - 1) * 100).toFixed(1) : 'N/A';
-        md += `**pgserve RAM wins!** ${vsDisk}% faster than disk mode, ${vsPGlite}% faster than PGlite.\n\n`;
-      } else if (winner === 'pgserve') {
-        const vsPGlite = pglite.throughput > 0 ? ((pgserve.throughput / pglite.throughput - 1) * 100).toFixed(1) : 'N/A';
-        md += `**pgserve wins!** ${vsPGlite}% faster than PGlite for concurrent workloads.\n\n`;
-      } else {
-        md += `**${winner} wins** this scenario.\n\n`;
-      }
-    } else {
-      // Original table without RAM column
-      md += '```\n';
-      md += '┌─────────────────┬──────────┬──────────┬──────────┬──────────┬──────────┐\n';
-      md += '│ Metric          │ SQLite   │ PGlite   │ PostgreSQL│ pgserve  │ Winner   │\n';
-      md += '├─────────────────┼──────────┼──────────┼──────────┼──────────┼──────────┤\n';
-
-      // Find winners
-      const throughputs = { sqlite: sqlite.throughput, pglite: pglite.throughput, postgres: postgres.throughput, pgserve: pgserve.throughput };
-      const p50s = { sqlite: sqlite.p50, pglite: pglite.p50, postgres: postgres.p50, pgserve: pgserve.p50 };
-      const p99s = { sqlite: sqlite.p99, pglite: pglite.p99, postgres: postgres.p99, pgserve: pgserve.p99 };
-      const errors = { sqlite: sqlite.errors, pglite: pglite.errors, postgres: postgres.errors, pgserve: pgserve.errors };
-
-      const getMaxKey = (obj) => Object.entries(obj).reduce((a, b) => a[1] > b[1] ? a : b)[0];
-      const getMinKey = (obj) => Object.entries(obj).filter(([k,v]) => v > 0 || k === 'sqlite').reduce((a, b) => a[1] < b[1] ? a : b)[0];
-      const getMinErrorKey = (obj) => Object.entries(obj).reduce((a, b) => a[1] <= b[1] ? a : b)[0];
-
-      const nameMap = { sqlite: 'SQLite', pglite: 'PGlite', postgres: 'PostgreSQL', pgserve: 'pgserve' };
-
-      const pad = (s, n) => String(s).padEnd(n);
-
-      md += `│ Throughput (qps)│ ${pad(sqlite.throughput, 8)} │ ${pad(pglite.throughput, 8)} │ ${pad(postgres.throughput, 9)} │ ${pad(pgserve.throughput, 8)} │ ${pad(nameMap[getMaxKey(throughputs)], 8)} │\n`;
-      md += `│ P50 latency (ms)│ ${pad(sqlite.p50, 8)} │ ${pad(pglite.p50, 8)} │ ${pad(postgres.p50, 9)} │ ${pad(pgserve.p50, 8)} │ ${pad(nameMap[getMinKey(p50s)], 8)} │\n`;
-      md += `│ P99 latency (ms)│ ${pad(sqlite.p99, 8)} │ ${pad(pglite.p99, 8)} │ ${pad(postgres.p99, 9)} │ ${pad(pgserve.p99, 8)} │ ${pad(nameMap[getMinKey(p99s)], 8)} │\n`;
-      md += `│ Errors          │ ${pad(sqlite.errors, 8)} │ ${pad(pglite.errors, 8)} │ ${pad(postgres.errors, 9)} │ ${pad(pgserve.errors, 8)} │ ${pad(nameMap[getMinErrorKey(errors)], 8)} │\n`;
-      md += '└─────────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n';
-      md += '```\n\n';
-
-      // Analysis
-      const winner = nameMap[getMaxKey(throughputs)];
-      if (winner === 'pgserve') {
-        const vsPGlite = pglite.throughput > 0 ? ((pgserve.throughput / pglite.throughput - 1) * 100).toFixed(1) : 'N/A';
-        md += `**pgserve wins!** ${vsPGlite}% faster than PGlite for concurrent workloads.\n\n`;
-      } else {
-        md += `**${winner} wins** this scenario.\n\n`;
-      }
+    const rows = [
+      { name: 'SQLite', data: scenario.sqlite },
+      { name: 'PostgreSQL', data: scenario.postgres },
+      { name: 'pgserve 1.2.0', data: scenario.pgserveV1 },
+      { name: 'pgserve v2', data: scenario.pgserve },
+    ];
+    if (scenario.pgserveRam && !scenario.pgserveRam.skipped) {
+      rows.push({ name: 'pgserve v2 RAM', data: scenario.pgserveRam });
+    }
+
+    md += renderMetricTable(rows, [
+      { label: 'Throughput (qps)', key: 'throughput', direction: 'max', format: plain },
+      { label: 'P50 latency (ms)', key: 'p50', direction: 'min', format: plain },
+      { label: 'P99 latency (ms)', key: 'p99', direction: 'min', format: plain },
+      { label: 'Errors', key: 'errors', direction: 'min', format: plain },
+    ]);
+
+    const delta = pctDelta(scenario.pgserve, scenario.pgserveV1);
+    if (delta !== null) {
+      md += `**pgserve v2 vs 1.2.0:** ${delta}% throughput delta.\n\n`;
     }
   }
 
@@ -1284,34 +957,32 @@ function generateReport(results, vectorResults = []) {
       md += `### ${scenario.name}\n\n`;
       md += `${scenario.description}\n\n`;
 
-      const { pglite, postgres, pgserve, pgserveRam, k } = scenario;
-
-      md += '```\n';
-      md += '┌─────────────────┬──────────┬──────────┬──────────┬─────────────┐\n';
-      md += '│ Metric          │ PGlite   │ PostgreSQL│ pgserve  │ pgserve RAM │\n';
-      md += '├─────────────────┼──────────┼──────────┼──────────┼─────────────┤\n';
-
-      const pad = (s, n) => String(s).padEnd(n);
-      const val = (r, key) => r.skipped ? 'N/A' : r[key];
-      const recallVal = (r) => r.skipped ? 'N/A' : `${r.recall}%`;
+      const rows = [
+        { name: 'PostgreSQL', data: scenario.postgres },
+        { name: 'pgserve 1.2.0', data: scenario.pgserveV1 },
+        { name: 'pgserve v2', data: scenario.pgserve },
+      ];
+      if (scenario.pgserveRam && !scenario.pgserveRam.skipped) {
+        rows.push({ name: 'pgserve v2 RAM', data: scenario.pgserveRam });
+      }
 
-      md += `│ Recall@${String(k || 10).padEnd(8)}│ ${pad(recallVal(pglite), 8)} │ ${pad(recallVal(postgres), 9)} │ ${pad(recallVal(pgserve), 8)} │ ${pad(recallVal(pgserveRam), 11)} │\n`;
-      md += `│ Throughput (qps)│ ${pad(val(pglite, 'throughput'), 8)} │ ${pad(val(postgres, 'throughput'), 9)} │ ${pad(val(pgserve, 'throughput'), 8)} │ ${pad(val(pgserveRam, 'throughput'), 11)} │\n`;
-      md += `│ P50 latency (ms)│ ${pad(val(pglite, 'p50'), 8)} │ ${pad(val(postgres, 'p50'), 9)} │ ${pad(val(pgserve, 'p50'), 8)} │ ${pad(val(pgserveRam, 'p50'), 11)} │\n`;
-      md += `│ P99 latency (ms)│ ${pad(val(pglite, 'p99'), 8)} │ ${pad(val(postgres, 'p99'), 9)} │ ${pad(val(pgserve, 'p99'), 8)} │ ${pad(val(pgserveRam, 'p99'), 11)} │\n`;
-      md += `│ Errors          │ ${pad(val(pglite, 'errors'), 8)} │ ${pad(val(postgres, 'errors'), 9)} │ ${pad(val(pgserve, 'errors'), 8)} │ ${pad(val(pgserveRam, 'errors'), 11)} │\n`;
-      md += '└─────────────────┴──────────┴──────────┴──────────┴─────────────┘\n';
-      md += '```\n\n';
+      md += renderMetricTable(rows, [
+        { label: `Recall@${scenario.k || 10}`, key: 'recall', direction: 'max', format: percent },
+        { label: 'Throughput (qps)', key: 'throughput', direction: 'max', format: plain },
+        { label: 'P50 latency (ms)', key: 'p50', direction: 'min', format: plain },
+        { label: 'P99 latency (ms)', key: 'p99', direction: 'min', format: plain },
+        { label: 'Errors', key: 'errors', direction: 'min', format: plain },
+      ]);
 
       // Find winner among non-skipped (considering both recall and throughput)
       const candidates = {};
-      if (!pglite.skipped) candidates.pglite = { recall: parseFloat(pglite.recall), qps: pglite.throughput };
-      if (!postgres.skipped) candidates.postgres = { recall: parseFloat(postgres.recall), qps: postgres.throughput };
-      if (!pgserve.skipped) candidates.pgserve = { recall: parseFloat(pgserve.recall), qps: pgserve.throughput };
-      if (pgserveRam && !pgserveRam.skipped) candidates.pgserveRam = { recall: parseFloat(pgserveRam.recall), qps: pgserveRam.throughput };
+      if (!scenario.postgres.skipped) candidates.postgres = { recall: parseFloat(scenario.postgres.recall), qps: scenario.postgres.throughput };
+      if (!scenario.pgserveV1.skipped) candidates.pgserveV1 = { recall: parseFloat(scenario.pgserveV1.recall), qps: scenario.pgserveV1.throughput };
+      if (!scenario.pgserve.skipped) candidates.pgserve = { recall: parseFloat(scenario.pgserve.recall), qps: scenario.pgserve.throughput };
+      if (scenario.pgserveRam && !scenario.pgserveRam.skipped) candidates.pgserveRam = { recall: parseFloat(scenario.pgserveRam.recall), qps: scenario.pgserveRam.throughput };
 
       if (Object.keys(candidates).length > 0) {
-        const nameMap = { pglite: 'PGlite', postgres: 'PostgreSQL', pgserve: 'pgserve', pgserveRam: 'pgserve RAM' };
+        const nameMap = { postgres: 'PostgreSQL', pgserveV1: 'pgserve 1.2.0', pgserve: 'pgserve v2', pgserveRam: 'pgserve v2 RAM' };
         // Winner = highest QPS among those with 100% recall, otherwise highest recall
         const perfect = Object.entries(candidates).filter(([, v]) => v.recall === 100);
         let winnerKey;
@@ -1323,6 +994,11 @@ function generateReport(results, vectorResults = []) {
           md += `**${nameMap[winnerKey]} wins** (${candidates[winnerKey].recall}% recall @ ${candidates[winnerKey].qps} qps)\n\n`;
         }
       }
+
+      const delta = pctDelta(scenario.pgserve, scenario.pgserveV1);
+      if (delta !== null) {
+        md += `**pgserve v2 vs 1.2.0:** ${delta}% throughput delta.\n\n`;
+      }
     }
   }
 
@@ -1366,9 +1042,9 @@ Options:
   --help, -h         Show this help
 
 Vector benchmarks require:
-  - PGLite: Built-in pgvector support
+  - PostgreSQL: Built-in pgvector support
   - PostgreSQL: Docker image pgvector/pgvector:pg17
-  - pgserve: Not yet supported (marked as skipped)
+  - pgserve 1.2.0 and v2: --pgvector support
 `);
     process.exit(0);
   }
@@ -1401,8 +1077,8 @@ Vector benchmarks require:
       section(scenario.name, scenario.description);
 
       const sqlite = await benchmarkSQLite(scenario);
-      const pglite = await benchmarkPGlite(scenario);
       const postgres = await benchmarkPostgreSQL(scenario);
+      const pgserveV1 = await benchmarkPgserveV1(scenario);
       const pgserve = await benchmarkPgserve(scenario, false);  // disk mode
       const pgserveRam = canUseRam
         ? await benchmarkPgserve(scenario, true)  // RAM mode
@@ -1412,8 +1088,8 @@ Vector benchmarks require:
         name: scenario.name,
         description: scenario.description,
         sqlite,
-        pglite,
         postgres,
+        pgserveV1,
         pgserve,
         pgserveRam
       });
@@ -1422,11 +1098,11 @@ Vector benchmarks require:
       console.log(`\n  ${C.bold}Results:${C.reset}`);
       console.log(`  ${C.dim}──────────────────────────────────────────${C.reset}`);
       console.log(`  ${C.yellow}🔸${C.reset} SQLite:        ${C.bold}${sqlite.throughput}${C.reset} qps, P50=${sqlite.p50}ms, P99=${sqlite.p99}ms`);
-      console.log(`  ${C.blue}🔹${C.reset} PGlite:        ${C.bold}${pglite.throughput}${C.reset} qps, P50=${pglite.p50}ms, P99=${pglite.p99}ms`);
       console.log(`  ${C.cyan}🔷${C.reset} PostgreSQL:    ${postgres.skipped ? `${C.dim}SKIPPED${C.reset}` : `${C.bold}${postgres.throughput}${C.reset} qps, P50=${postgres.p50}ms, P99=${postgres.p99}ms`}`);
-      console.log(`  ${C.green}🚀${C.reset} pgserve:       ${C.bold}${pgserve.throughput}${C.reset} qps, P50=${pgserve.p50}ms, P99=${pgserve.p99}ms`);
+      console.log(`  ${C.blue}🧭${C.reset} pgserve 1.2.0: ${pgserveV1.skipped ? `${C.dim}SKIPPED${C.reset}` : `${C.bold}${pgserveV1.throughput}${C.reset} qps, P50=${pgserveV1.p50}ms, P99=${pgserveV1.p99}ms`}`);
+      console.log(`  ${C.green}🚀${C.reset} pgserve v2:    ${C.bold}${pgserve.throughput}${C.reset} qps, P50=${pgserve.p50}ms, P99=${pgserve.p99}ms`);
       if (canUseRam) {
-        console.log(`  ${C.magenta}⚡${C.reset} pgserve (RAM): ${C.bold}${pgserveRam.throughput}${C.reset} qps, P50=${pgserveRam.p50}ms, P99=${pgserveRam.p99}ms`);
+        console.log(`  ${C.magenta}⚡${C.reset} pgserve v2 RAM: ${C.bold}${pgserveRam.throughput}${C.reset} qps, P50=${pgserveRam.p50}ms, P99=${pgserveRam.p99}ms`);
       }
     }
   }
@@ -1466,8 +1142,8 @@ Vector benchmarks require:
       }
 
       // Run benchmarks
-      const pglite = await benchmarkPGliteVector(scenario, embeddings, queryVectors, groundTruth);
       const postgres = await benchmarkPostgreSQLVector(scenario, embeddings, queryVectors, groundTruth);
+      const pgserveV1 = await benchmarkPgserveV1Vector(scenario, embeddings, queryVectors, groundTruth);
       const pgserve = await benchmarkPgserveVector(scenario, embeddings, queryVectors, groundTruth, false);
       const pgserveRam = canUseRam
         ? await benchmarkPgserveVector(scenario, embeddings, queryVectors, groundTruth, true)
@@ -1478,8 +1154,8 @@ Vector benchmarks require:
         description: scenario.description,
         type: scenario.type,
         k: scenario.k,
-        pglite,
         postgres,
+        pgserveV1,
         pgserve,
         pgserveRam
       });
@@ -1495,11 +1171,11 @@ Vector benchmarks require:
         }
         return `  ${color}${icon}${C.reset} ${name.padEnd(14)} Recall: ${C.bold}${r.recall}%${C.reset}, ${C.bold}${r.throughput}${C.reset} qps, P50=${r.p50}ms`;
       };
-      console.log(formatResult(pglite, '🔹', C.blue, 'PGlite:'));
       console.log(formatResult(postgres, '🔷', C.cyan, 'PostgreSQL:'));
-      console.log(formatResult(pgserve, '🚀', C.green, 'pgserve:'));
+      console.log(formatResult(pgserveV1, '🧭', C.blue, 'pgserve 1.2.0:'));
+      console.log(formatResult(pgserve, '🚀', C.green, 'pgserve v2:'));
       if (canUseRam) {
-        console.log(formatResult(pgserveRam, '⚡', C.magenta, 'pgserve (RAM):'));
+        console.log(formatResult(pgserveRam, '⚡', C.magenta, 'pgserve v2 RAM:'));
       }
     }
   }