pgserve 0.1.4 → 1.0.1

package/tests/benchmarks/runner.js

@@ -2,13 +2,12 @@
 
 /**
  * Benchmark Runner
- * Compares SQLite, PGlite, and PostgreSQL performance
+ * Compares SQLite, PGlite, PostgreSQL Server, and pgserve performance
  */
 
 import Database from 'better-sqlite3';
 import { PGlite } from '@electric-sql/pglite';
-import { startServer, cleanup } from '../../src/index.js';
-import { execSync } from 'child_process';
+import { startMultiTenantServer } from '../../src/index.js';
 import fs from 'fs';
 import path from 'path';
 import pg from 'pg';
@@ -17,38 +16,41 @@ const { Pool } = pg;
 
 // Global error handlers (suppress expected PGlite WASM ExitStatus errors)
 process.on('unhandledRejection', (reason, promise) => {
-  // ExitStatus errors are expected from PGlite WASM cleanup - ignore them
-  if (reason && reason.name === 'ExitStatus') {
-    return;
-  }
-  console.error('❌ Unhandled Promise Rejection:', reason);
+  if (reason && reason.name === 'ExitStatus') return;
+  console.error('Unhandled Promise Rejection:', reason);
 });
 
 process.on('uncaughtException', (error) => {
-  // ExitStatus errors are expected from PGlite WASM cleanup - ignore them
-  if (error && error.name === 'ExitStatus') {
-    return;
-  }
-  console.error('❌ Uncaught Exception:', error);
+  if (error && error.name === 'ExitStatus') return;
+  console.error('Uncaught Exception:', error);
   process.exit(1);
 });
 
 const RESULTS_DIR = new URL('./results', import.meta.url).pathname;
 
+// PostgreSQL Server configuration (Docker with tmpfs for fair RAM-to-RAM comparison)
+const POSTGRES_CONFIG = {
+  host: 'localhost',
+  port: 15432,
+  user: 'postgres',
+  password: 'benchpass',
+  database: 'bench'
+};
+
 /**
  * Benchmark scenario configuration
  */
 const scenarios = [
   {
     name: 'Concurrent Writes (10 agents)',
-    description: 'Simulates Hive agent sessions writing simultaneously',
+    description: 'Simulates 10 concurrent agents writing simultaneously',
     operations: [
       { type: 'INSERT', count: 100, concurrent: 10 }
     ]
   },
   {
     name: 'Mixed Workload (messages)',
-    description: 'Simulates Evolution API message operations',
+    description: 'Simulates typical API message operations',
     operations: [
       { type: 'INSERT', count: 500 },
       { type: 'SELECT', count: 2000 },
@@ -57,7 +59,7 @@ const scenarios = [
   },
   {
     name: 'Write Lock Contention',
-    description: 'Stress test for lock handling',
+    description: 'Stress test for lock handling with 50 concurrent writers',
     operations: [
       { type: 'INSERT', count: 100, concurrent: 50 }
     ]
@@ -163,6 +165,29 @@ async function benchmarkSQLite(scenario) {
           }
         }
       }
+    } 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();
+          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 {
+          db.prepare('UPDATE messages SET content = ? WHERE id = ?').run(
+            `Updated ${i}`,
+            (i % 100) + 1
+          );
+          metrics.addLatency(Date.now() - start);
+        } catch (error) {
+          metrics.addError(error);
+        }
+      }
     }
   }
 
@@ -173,58 +198,20 @@ async function benchmarkSQLite(scenario) {
 }
 
 /**
- * PGlite Benchmark
+ * PGlite Benchmark (in-process WASM PostgreSQL)
  */
 async function benchmarkPGlite(scenario) {
   console.log('  🔹 Running PGlite benchmark...');
 
-  // Clean up stale instances
-  cleanup();
-
   const dataDir = path.join(RESULTS_DIR, 'pglite-bench');
   if (fs.existsSync(dataDir)) {
     fs.rmSync(dataDir, { recursive: true });
   }
 
-  const instance = await startServer({
-    dataDir,
-    port: 12999,
-    autoPort: true,
-    logLevel: 'error'
-  });
-
-  // Connect via PostgreSQL pool (proper way to use the server)
-  const pool = new Pool({
-    host: 'localhost',
-    port: instance.port,
-    database: 'postgres',
-    max: 20,
-    connectionTimeoutMillis: 10000,
-    ssl: false
-  });
-
-  // Give server a moment to be fully ready
-  await new Promise(resolve => setTimeout(resolve, 1000));
-
-  // Wait for server to be ready 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, 500));
-    }
-  }
-
-  if (!connected) {
-    throw new Error('Failed to connect to PGlite server');
-  }
+  const db = new PGlite(dataDir);
 
   // Setup schema
-  await pool.query(`
+  await db.exec(`
     CREATE TABLE IF NOT EXISTS messages (
       id SERIAL PRIMARY KEY,
       content TEXT,
@@ -235,71 +222,75 @@ async function benchmarkPGlite(scenario) {
   const metrics = new Metrics();
   metrics.start();
 
-  // Run operations
+  // Run operations (PGlite is single-threaded, so concurrent = sequential)
   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 messages (content, timestamp) VALUES ($1, $2)',
-                  [`Message ${i}-${j}`, Date.now()]
-                );
-                metrics.addLatency(Date.now() - start);
-              } catch (error) {
-                metrics.addError(error);
-              }
-            }
-          })()
-        );
+      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);
+        }
+      }
+    } 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');
+          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 db.query(
+            'UPDATE messages SET content = $1 WHERE id = $2',
+            [`Updated ${i}`, (i % 100) + 1]
+          );
+          metrics.addLatency(Date.now() - start);
+        } catch (error) {
+          metrics.addError(error);
+        }
       }
-
-      await Promise.all(promises);
     }
   }
 
   metrics.end();
 
-  // Cleanup
-  await pool.end();
-
-  // Stop instance
   try {
-    await instance.stop();
-  } catch (error) {
-    // ExitStatus errors are expected during WASM cleanup - ignore them
-    if (error.name !== 'ExitStatus') {
-      console.error('⚠️  Error stopping instance:', error.message);
-    }
+    await db.close();
+  } catch (e) {
+    // Ignore ExitStatus errors from WASM cleanup
   }
 
   return metrics.getReport();
 }
 
 /**
- * PostgreSQL Server Benchmark
+ * PostgreSQL Server Benchmark (remote real PostgreSQL)
  */
 async function benchmarkPostgreSQL(scenario) {
   console.log('  🔷 Running PostgreSQL Server benchmark...');
 
   const pool = new Pool({
-    host: '192.168.112.135',
-    port: 5432,
-    user: 'postgres',
-    password: '#Duassenha#2024',
-    database: 'genie_evolution',
-    max: 20 // Connection pool size
+    ...POSTGRES_CONFIG,
+    max: 20
   });
 
   try {
-    // Setup schema (use bench_ prefix to avoid conflicts)
+    // Test connection first
+    await pool.query('SELECT 1');
+
+    // Setup schema
     await pool.query(`
       DROP TABLE IF EXISTS bench_messages;
       CREATE TABLE bench_messages (
@@ -339,6 +330,29 @@ async function benchmarkPostgreSQL(scenario) {
         }
 
         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);
+          }
+        }
       }
     }
 
@@ -350,9 +364,135 @@ async function benchmarkPostgreSQL(scenario) {
 
     return metrics.getReport();
   } catch (error) {
-    console.error('   ❌ PostgreSQL benchmark failed:', error.message);
+    console.error('   PostgreSQL benchmark failed:', error.message);
+    await pool.end();
+    return { throughput: 0, p50: 0, p99: 0, errors: 1, lockTimeouts: 0, totalOps: 0, skipped: true };
+  }
+}
+
+/**
+ * pgserve Benchmark (our solution - embedded PostgreSQL with TRUE concurrency)
+ */
+async function benchmarkPgserve(scenario) {
+  console.log('  🚀 Running pgserve benchmark...');
+
+  let server;
+  try {
+    // Start pgserve in memory mode
+    server = await startMultiTenantServer({
+      port: 18432,
+      logLevel: 'error'
+    });
+
+    // Wait for server to be fully ready
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    const pool = new Pool({
+      host: 'localhost',
+      port: 18432,
+      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();
-    throw error;
+    await server.stop();
+
+    return metrics.getReport();
+  } catch (error) {
+    console.error('   pgserve 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 };
   }
 }
 
@@ -372,70 +512,69 @@ function generateReport(results) {
   // Generate markdown
   let md = '# Benchmark Results\n\n';
   md += `**Date:** ${new Date().toLocaleString()}\n\n`;
+  md += '## Quick Start\n\n';
+  md += '```bash\n';
+  md += '# Zero install - just run!\n';
+  md += 'npx pgserve\n\n';
+  md += '# Connect from any PostgreSQL client\n';
+  md += 'psql postgresql://localhost:5432/mydb\n';
+  md += '```\n\n';
 
   for (const scenario of results) {
     md += `## ${scenario.name}\n\n`;
     md += `${scenario.description}\n\n`;
 
+    const { sqlite, pglite, postgres, pgserve } = scenario;
+
     md += '```\n';
-    md += '┌─────────────────┬──────────┬──────────┬──────────┬──────────┐\n';
-    md += '│ Database        │ SQLite   │ PGlite   │ PostgreSQL│ Winner   │\n';
-    md += '├─────────────────┼──────────┼──────────┼──────────┼──────────┤\n';
-
-    const sqlite = scenario.sqlite;
-    const pglite = scenario.pglite;
-    const postgres = scenario.postgres;
-
-    // Find winner for each metric
-    const maxThroughput = Math.max(sqlite.throughput, pglite.throughput, postgres.throughput);
-    const minP50 = Math.min(sqlite.p50, pglite.p50, postgres.p50);
-    const minP99 = Math.min(sqlite.p99, pglite.p99, postgres.p99);
-    const minErrors = Math.min(sqlite.errors, pglite.errors, postgres.errors);
-
-    const getThroughputWinner = () => {
-      if (postgres.throughput === maxThroughput) return 'PostgreSQL';
-      if (pglite.throughput === maxThroughput) return 'PGlite';
-      return 'SQLite';
-    };
+    md += '┌─────────────────┬──────────┬──────────┬──────────┬──────────┬──────────┐\n';
+    md += '│ Metric          │ SQLite   │ PGlite   │ PostgreSQL│ pgserve  │ Winner   │\n';
+    md += '├─────────────────┼──────────┼──────────┼──────────┼──────────┼──────────┤\n';
 
-    const getLatencyWinner = (metric) => {
-      const pg = postgres[metric];
-      const pgl = pglite[metric];
-      const sql = sqlite[metric];
-      if (pg === Math.min(pg, pgl, sql)) return 'PostgreSQL';
-      if (pgl === Math.min(pg, pgl, sql)) return 'PGlite';
-      return 'SQLite';
-    };
+    // 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 };
 
-    md += `│ Throughput (qps)│ ${String(sqlite.throughput).padEnd(8)} │ ${String(pglite.throughput).padEnd(8)} │ ${String(postgres.throughput).padEnd(9)} │ ${getThroughputWinner().padEnd(8)} │\n`;
-    md += `│ P50 latency (ms)│ ${String(sqlite.p50).padEnd(8)} │ ${String(pglite.p50).padEnd(8)} │ ${String(postgres.p50).padEnd(9)} │ ${getLatencyWinner('p50').padEnd(8)} │\n`;
-    md += `│ P99 latency (ms)│ ${String(sqlite.p99).padEnd(8)} │ ${String(pglite.p99).padEnd(8)} │ ${String(postgres.p99).padEnd(9)} │ ${getLatencyWinner('p99').padEnd(8)} │\n`;
-    md += `│ Errors          │ ${String(sqlite.errors).padEnd(8)} │ ${String(pglite.errors).padEnd(8)} │ ${String(postgres.errors).padEnd(9)} │ ${postgres.errors === minErrors ? 'PostgreSQL' : (pglite.errors === minErrors ? 'PGlite' : 'SQLite').padEnd(8)} │\n`;
-    md += `│ Lock timeouts   │ ${String(sqlite.lockTimeouts).padEnd(8)} │ ${String(pglite.lockTimeouts).padEnd(8)} │ ${String(postgres.lockTimeouts).padEnd(9)} │ N/A      │\n`;
-    md += '└─────────────────┴──────────┴──────────┴──────────┴──────────┘\n';
+    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 = getThroughputWinner();
-    if (winner === 'PostgreSQL') {
-      const vsSQL = ((postgres.throughput / sqlite.throughput - 1) * 100).toFixed(1);
-      const vsPGL = ((postgres.throughput / pglite.throughput - 1) * 100).toFixed(1);
-      md += `💡 **PostgreSQL Server is ${vsSQL}% faster than SQLite and ${vsPGL}% faster than PGlite**\n\n`;
-    } else if (winner === 'PGlite') {
-      const vsSQL = ((pglite.throughput / sqlite.throughput - 1) * 100).toFixed(1);
-      const vsPG = ((pglite.throughput / postgres.throughput - 1) * 100).toFixed(1);
-      md += `💡 **PGlite is ${vsSQL}% faster than SQLite and ${vsPG}% faster than PostgreSQL Server**\n\n`;
+    const winner = nameMap[getMaxKey(throughputs)];
+    if (winner === 'pgserve') {
+      const vsSQLite = sqlite.throughput > 0 ? ((pgserve.throughput / sqlite.throughput - 1) * 100).toFixed(1) : 'N/A';
+      const vsPGlite = pglite.throughput > 0 ? ((pgserve.throughput / pglite.throughput - 1) * 100).toFixed(1) : 'N/A';
+      const vsPostgres = postgres.throughput > 0 ? ((pgserve.throughput / postgres.throughput - 1) * 100).toFixed(1) : 'N/A';
+      md += `**pgserve wins!** ${vsPGlite}% faster than PGlite for concurrent workloads.\n\n`;
     } else {
-      const vsPGL = ((sqlite.throughput / pglite.throughput - 1) * 100).toFixed(1);
-      const vsPG = ((sqlite.throughput / postgres.throughput - 1) * 100).toFixed(1);
-      md += `💡 **SQLite is ${vsPGL}% faster than PGlite and ${vsPG}% faster than PostgreSQL Server**\n\n`;
+      md += `**${winner} wins** this scenario.\n\n`;
     }
   }
 
+  md += '---\n\n';
+  md += '## Why pgserve?\n\n';
+  md += '- **TRUE Concurrency**: Native PostgreSQL process forking\n';
+  md += '- **Zero Config**: Just run `npx pgserve`\n';
+  md += '- **Auto-Provision**: Databases created on first connection\n';
+  md += '- **PostgreSQL 17.7**: Latest stable, native binaries\n';
+
   const mdPath = path.join(RESULTS_DIR, 'benchmark-results.md');
   fs.writeFileSync(mdPath, md);
 
-  console.log(`\n✅ Results saved to:`);
+  console.log(`\nResults saved to:`);
   console.log(`   JSON: ${jsonPath}`);
   console.log(`   Markdown: ${mdPath}\n`);
 
@@ -446,9 +585,10 @@ function generateReport(results) {
  * Main runner
  */
 async function main() {
-  console.log('╔═══════════════════════════════════════════════════════════════╗');
-  console.log('║  PGlite Embedded Server - Benchmark Suite                    ║');
-  console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+  console.log('╔════════════════════════════════════════════════════════════════╗');
+  console.log('║  pgserve Benchmark Suite                                       ║');
+  console.log('║  Comparing: SQLite | PGlite | PostgreSQL | pgserve            ║');
+  console.log('╚════════════════════════════════════════════════════════════════╝\n');
 
   // Ensure results directory exists
   if (!fs.existsSync(RESULTS_DIR)) {
@@ -464,26 +604,31 @@ async function main() {
     const sqlite = await benchmarkSQLite(scenario);
     const pglite = await benchmarkPGlite(scenario);
     const postgres = await benchmarkPostgreSQL(scenario);
+    const pgserve = await benchmarkPgserve(scenario);
 
     results.push({
       name: scenario.name,
       description: scenario.description,
       sqlite,
       pglite,
-      postgres
+      postgres,
+      pgserve
     });
 
     console.log(`\n   SQLite:      ${sqlite.throughput} qps, P50=${sqlite.p50}ms, errors=${sqlite.errors}`);
     console.log(`   PGlite:      ${pglite.throughput} qps, P50=${pglite.p50}ms, errors=${pglite.errors}`);
     console.log(`   PostgreSQL:  ${postgres.throughput} qps, P50=${postgres.p50}ms, errors=${postgres.errors}`);
+    console.log(`   pgserve:     ${pgserve.throughput} qps, P50=${pgserve.p50}ms, errors=${pgserve.errors}`);
   }
 
   console.log('\n📄 Generating report...\n');
-  const report = generateReport(results);
+  generateReport(results);
 
-  console.log('╔═══════════════════════════════════════════════════════════════╗');
-  console.log('║  ✅ Benchmarks Complete!                                      ║');
-  console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+  console.log('╔════════════════════════════════════════════════════════════════╗');
+  console.log('║  Benchmarks Complete!                                         ║');
+  console.log('║                                                                ║');
+  console.log('║  Try it yourself:  npx pgserve                                ║');
+  console.log('╚════════════════════════════════════════════════════════════════╝\n');
 }
 
 main().catch(console.error);