pgserve 1.1.5 → 1.1.7-rc.2

package/.husky/pre-commit

@@ -1,2 +1,2 @@
-pnpm exec lint-staged
-pnpm deadcode
+bunx lint-staged
+bun run deadcode

package/README.md

@@ -5,7 +5,7 @@
   <p>
     <a href="https://www.npmjs.com/package/pgserve"><img src="https://img.shields.io/npm/v/pgserve?style=flat-square&color=00D9FF" alt="npm version"></a>
     <img src="https://img.shields.io/badge/node-%3E%3D18-green?style=flat-square" alt="Node.js">
-    <img src="https://img.shields.io/badge/PostgreSQL-17.7-blue?style=flat-square" alt="PostgreSQL">
+    <img src="https://img.shields.io/badge/PostgreSQL-18-blue?style=flat-square" alt="PostgreSQL">
     <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
     <a href="https://discord.gg/xcW8c7fF3R"><img src="https://img.shields.io/discord/1095114867012292758?style=flat-square&color=00D9FF&label=discord" alt="Discord"></a>
   </p>
@@ -41,7 +41,7 @@ psql postgresql://localhost:8432/myapp
 
 <table>
   <tr>
-    <td><b>Real PostgreSQL 17</b></td>
+    <td><b>Real PostgreSQL 18</b></td>
     <td>Native binaries, not WASM — full compatibility, extensions support</td>
   </tr>
   <tr>
@@ -450,7 +450,7 @@ CREATE EXTENSION IF NOT EXISTS vector;
   </tr>
 </table>
 
-> <b>Methodology:</b> Recall@k measured against brute-force ground truth (industry standard). PostgreSQL baseline is Docker <code>pgvector/pgvector:pg17</code>. RAM mode available on Linux and WSL2.
+> <b>Methodology:</b> Recall@k measured against brute-force ground truth (industry standard). PostgreSQL baseline is Docker <code>pgvector/pgvector:pg18</code>. RAM mode available on Linux and WSL2.
 >
 > Run benchmarks yourself: <code>bun tests/benchmarks/runner.js --include-vector</code>
 

package/bun.lock

@@ -17,23 +17,23 @@
         "pg": "^8.16.3",
       },
       "optionalDependencies": {
-        "@embedded-postgres/darwin-arm64": "17.7.0-beta.15",
-        "@embedded-postgres/darwin-x64": "17.7.0-beta.15",
-        "@embedded-postgres/linux-x64": "17.7.0-beta.15",
-        "@embedded-postgres/windows-x64": "17.7.0-beta.15",
+        "@embedded-postgres/darwin-arm64": "18.2.0-beta.16",
+        "@embedded-postgres/darwin-x64": "18.2.0-beta.16",
+        "@embedded-postgres/linux-x64": "18.2.0-beta.16",
+        "@embedded-postgres/windows-x64": "18.2.0-beta.16",
       },
     },
   },
   "packages": {
     "@electric-sql/pglite": ["@electric-sql/pglite@0.2.17", "", {}, "sha512-qEpKRT2oUaWDH6tjRxLHjdzMqRUGYDnGZlKrnL4dJ77JVMcP2Hpo3NYnOSPKdZdeec57B6QPprCUFg0picx5Pw=="],
 
-    "@embedded-postgres/darwin-arm64": ["@embedded-postgres/darwin-arm64@17.7.0-beta.15", "", { "os": "darwin", "cpu": "arm64" }, "sha512-yIo9ACgWI3U84lZpRD2G3ELzVM7fXCaTWCpH+9+lLeEj7+F9eTWYsG3DE/fcsPcDcDDxhLTqX71p9oFeX/KOZA=="],
+    "@embedded-postgres/darwin-arm64": ["@embedded-postgres/darwin-arm64@18.2.0-beta.16", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wnswaF+uDvGeitqajJ8v8xOG4ttFrzixElwKNe2MIxBXSLWPV3xhi6tBY0Sjw8Lmiu6UG9vNLFZSjHPrIeokBg=="],
 
-    "@embedded-postgres/darwin-x64": ["@embedded-postgres/darwin-x64@17.7.0-beta.15", "", { "os": "darwin", "cpu": "x64" }, "sha512-KXXBbiyJ8fNYNQt9ondhVUayQ0+qCi6Uoma23Oa40xoyzXY6kRNjXwlGB7Bvf9ZV8PsiBdlnEv/fSpYeRcDjSA=="],
+    "@embedded-postgres/darwin-x64": ["@embedded-postgres/darwin-x64@18.2.0-beta.16", "", { "os": "darwin", "cpu": "x64" }, "sha512-u9WtTPxRuO0uOny5IniXHSDaLmtOujwzDoExIV/jFT0Fu8SzpX7wdoPbsSPBLgyQWdr/nPA77K9QI4r6P1/fKA=="],
 
-    "@embedded-postgres/linux-x64": ["@embedded-postgres/linux-x64@17.7.0-beta.15", "", { "os": "linux", "cpu": "x64" }, "sha512-HeaxSHsw6ccVh8l5iC4OgXqvaaCGWnnZR9CpgNgrAfnKPPGiEhUPBmO2XhEsFQIhc+ad/+36h0NTvKo4bdi40w=="],
+    "@embedded-postgres/linux-x64": ["@embedded-postgres/linux-x64@18.2.0-beta.16", "", { "os": "linux", "cpu": "x64" }, "sha512-BIt485ioL8/AwDgw37IcdraOfRgHNDOtGM6Hh63vnNaUAG4Z0qtJd5zXS5fr2wZTEsYHyC5PC60k7zkCRZXSzg=="],
 
-    "@embedded-postgres/windows-x64": ["@embedded-postgres/windows-x64@17.7.0-beta.15", "", { "os": "win32", "cpu": "x64" }, "sha512-Oq11yyKxISjefuYdKljcp3Q+uxx237zn9YpP9hO43+6Feorq7USuMIDqk5ofLSQ30FAnVyTqaIQK8ZIjW+tQXQ=="],
+    "@embedded-postgres/windows-x64": ["@embedded-postgres/windows-x64@18.2.0-beta.16", "", { "os": "win32", "cpu": "x64" }, "sha512-Sj6GhCZrvtMwchATEtWuEmexEBWpRNMHPTUHsqPuyDrHX/XgKfpIxz2/AMHa4sp7SZ0JOHGouH8AFIVsWQrQsQ=="],
 
     "@emnapi/core": ["@emnapi/core@1.7.1", "", { "dependencies": { "@emnapi/wasi-threads": "1.1.0", "tslib": "^2.4.0" } }, "sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgserve",
-  "version": "1.1.5",
+  "version": "1.1.7-rc.2",
   "description": "Embedded PostgreSQL server with true concurrent connections - zero config, auto-provision databases",
   "main": "src/index.js",
   "type": "module",
@@ -41,10 +41,10 @@
   },
   "homepage": "https://github.com/namastexlabs/pgserve#readme",
   "optionalDependencies": {
-    "@embedded-postgres/darwin-arm64": "17.7.0-beta.15",
-    "@embedded-postgres/darwin-x64": "17.7.0-beta.15",
-    "@embedded-postgres/linux-x64": "17.7.0-beta.15",
-    "@embedded-postgres/windows-x64": "17.7.0-beta.15"
+    "@embedded-postgres/darwin-arm64": "18.2.0-beta.16",
+    "@embedded-postgres/darwin-x64": "18.2.0-beta.16",
+    "@embedded-postgres/linux-x64": "18.2.0-beta.16",
+    "@embedded-postgres/windows-x64": "18.2.0-beta.16"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.2.17",

package/src/cluster.js

@@ -23,6 +23,17 @@ const SSL_REQUEST_CODE = 80877103;
 const GSSAPI_REQUEST_CODE = 80877104;
 const CANCEL_REQUEST_CODE = 80877102;
 
+/**
+ * Attempt to write a pending buffer to a target socket.
+ * Returns remaining unwritten bytes, or null if fully flushed.
+ */
+function flushPending(target, pending) {
+  const written = target.write(pending);
+  if (written === pending.byteLength) return null;
+  if (written === 0) return pending;
+  return pending.subarray(written);
+}
+
 // Stats collection constants
 const WORKER_STATS_TIMEOUT_MS = 10000; // Worker stats older than this are considered stale
 const WORKER_STATS_REPORT_INTERVAL_MS = 4000; // How often workers report stats to primary
@@ -100,8 +111,14 @@ class ClusterRouter extends EventEmitter {
         },
         drain(socket) {
           const state = router.socketState.get(socket);
-          if (state?.pgSocket) {
-            state.pgSocket.resume?.();
+          if (!state) return;
+          // Flush any pending PG→Client data
+          if (state.pendingToClient) {
+            state.pendingToClient = flushPending(socket, state.pendingToClient);
+          }
+          // If fully flushed, resume reading from PostgreSQL
+          if (!state.pendingToClient && state.pgSocket) {
+            state.pgSocket.resume();
           }
         }
       }
@@ -182,7 +199,9 @@ class ClusterRouter extends EventEmitter {
       buffer: null,
       pgSocket: null,
       dbName: null,
-      handshakeComplete: false
+      handshakeComplete: false,
+      pendingToPg: null,
+      pendingToClient: null
     });
     this.connections.add(socket);
     this.connectionStats.totalConnected++;
@@ -197,7 +216,17 @@ class ClusterRouter extends EventEmitter {
 
     // If handshake complete, forward to PostgreSQL
     if (state.handshakeComplete && state.pgSocket) {
-      state.pgSocket.write(data);
+      // If there's already pending data, append to it
+      if (state.pendingToPg) {
+        state.pendingToPg = Buffer.concat([state.pendingToPg, data]);
+        return;
+      }
+      const written = state.pgSocket.write(data);
+      if (written < data.byteLength) {
+        // Partial write — buffer remainder and pause client
+        state.pendingToPg = written === 0 ? Buffer.from(data) : Buffer.from(data.subarray(written));
+        socket.pause();
+      }
       return;
     }
 
@@ -250,50 +279,47 @@ class ClusterRouter extends EventEmitter {
 
       const router = this;
 
-      // Connect to PRIMARY's PostgreSQL using Bun.connect()
-      if (this.pgSocketPath) {
-        state.pgSocket = await Bun.connect({
-          unix: this.pgSocketPath,
-          socket: {
-            data(_pgSocket, pgData) {
-              socket.write(pgData);
-            },
-            open(pgSocket) {
-              pgSocket.write(startupMessage);
-              state.handshakeComplete = true;
-            },
-            close(_pgSocket) {
-              socket.end();
-            },
-            error(_pgSocket, error) {
-              router.logger.error({ dbName, err: error }, 'PostgreSQL socket error');
-              socket.end();
-            },
-            drain(_pgSocket) {}
+      // Shared handler for pgSocket (used by both unix and TCP paths)
+      const pgHandler = {
+        data(_pgSocket, pgData) {
+          // Forward PostgreSQL response to client with backpressure
+          if (state.pendingToClient) {
+            state.pendingToClient = Buffer.concat([state.pendingToClient, pgData]);
+            return;
           }
-        });
-      } else {
-        state.pgSocket = await Bun.connect({
-          hostname: '127.0.0.1',
-          port: this.pgPort,
-          socket: {
-            data(_pgSocket, pgData) {
-              socket.write(pgData);
-            },
-            open(pgSocket) {
-              pgSocket.write(startupMessage);
-              state.handshakeComplete = true;
-            },
-            close(_pgSocket) {
-              socket.end();
-            },
-            error(_pgSocket, error) {
-              router.logger.error({ dbName, err: error }, 'PostgreSQL socket error');
-              socket.end();
-            },
-            drain(_pgSocket) {}
+          const written = socket.write(pgData);
+          if (written < pgData.byteLength) {
+            state.pendingToClient = written === 0 ? Buffer.from(pgData) : Buffer.from(pgData.subarray(written));
+            _pgSocket.pause();
           }
-        });
+        },
+        open(pgSocket) {
+          pgSocket.write(startupMessage);
+          state.handshakeComplete = true;
+        },
+        close(_pgSocket) {
+          socket.end();
+        },
+        error(_pgSocket, error) {
+          router.logger.error({ dbName, err: error }, 'PostgreSQL socket error');
+          socket.end();
+        },
+        drain(_pgSocket) {
+          // Flush any pending Client→PG data
+          if (state.pendingToPg) {
+            state.pendingToPg = flushPending(_pgSocket, state.pendingToPg);
+          }
+          // If fully flushed, resume reading from client
+          if (!state.pendingToPg) {
+            socket.resume();
+          }
+        }
+      };
+
+      if (this.pgSocketPath) {
+        state.pgSocket = await Bun.connect({ unix: this.pgSocketPath, socket: pgHandler });
+      } else {
+        state.pgSocket = await Bun.connect({ hostname: '127.0.0.1', port: this.pgPort, socket: pgHandler });
       }
     } catch (error) {
       this.logger.error({ dbName, err: error }, 'Connection error');
@@ -306,8 +332,10 @@ class ClusterRouter extends EventEmitter {
    */
   handleSocketClose(socket) {
     const state = this.socketState.get(socket);
-    if (state?.pgSocket) {
-      state.pgSocket.end();
+    if (state) {
+      state.pendingToPg = null;
+      state.pendingToClient = null;
+      if (state.pgSocket) state.pgSocket.end();
     }
     this.connections.delete(socket);
     this.socketState.delete(socket);
@@ -334,8 +362,10 @@ class ClusterRouter extends EventEmitter {
     if (error.code !== 'ECONNRESET') {
       this.logger.error({ err: error, dbName: state?.dbName }, 'Socket error');
     }
-    if (state?.pgSocket) {
-      state.pgSocket.end();
+    if (state) {
+      state.pendingToPg = null;
+      state.pendingToClient = null;
+      if (state.pgSocket) state.pgSocket.end();
     }
     this.connections.delete(socket);
     this.socketState.delete(socket);

package/src/postgres.js

@@ -66,7 +66,7 @@ async function downloadPostgresBinaries() {
 
   const platformKey = getPlatformKey();
   const pkgName = `@embedded-postgres/${platformKey}`;
-  const pkgVersion = '17.7.0-beta.15';
+  const pkgVersion = '18.2.0-beta.16';
 
   console.log(`[pgserve] PostgreSQL binaries not found.`);
   console.log(`[pgserve] Downloading ${pkgName}@${pkgVersion}...`);
@@ -509,6 +509,12 @@ export class PostgresManager {
       persistent: this.persistent
     }, 'PostgreSQL started successfully');
 
+    // Pre-install pgvector extension files if enabled
+    // This ensures vector.so + vector.control are ready before any CREATE EXTENSION call
+    if (this.enablePgvector) {
+      await this.ensurePgvectorFiles();
+    }
+
     return this;
   }
 
@@ -917,12 +923,137 @@ export class PostgresManager {
     }
   }
 
+  /**
+   * Ensure pgvector extension files are installed in the PG binary dirs.
+   * Downloads prebuilt vector.so from apt.postgresql.org on first use (cached).
+   * Patches vector.control to use absolute module_pathname.
+   *
+   * Linux only — .deb extraction requires dpkg-deb or ar+tar.
+   * Serialized via _pgvectorInstallPromise to prevent concurrent races.
+   */
+  async ensurePgvectorFiles() {
+    // Serialize: only one install runs at a time
+    if (this._pgvectorInstallPromise) {
+      return this._pgvectorInstallPromise;
+    }
+    this._pgvectorInstallPromise = this._doEnsurePgvectorFiles();
+    try {
+      await this._pgvectorInstallPromise;
+    } finally {
+      this._pgvectorInstallPromise = null;
+    }
+  }
+
+  async _doEnsurePgvectorFiles() {
+    if (!this.binaries?.libDir) return;
+
+    // Linux only — .deb packages are Linux-specific
+    if (os.platform() !== 'linux') {
+      this.logger.info('pgvector auto-install is Linux-only. On macOS, install via: brew install pgvector');
+      return;
+    }
+
+    const libDir = this.binaries.libDir;
+    const binDir = this.binaries.binDir;
+    const extDir = path.join(path.dirname(binDir), 'share', 'postgresql', 'extension');
+    const vectorSo = path.join(libDir, 'vector.so');
+    const vectorControl = path.join(extDir, 'vector.control');
+
+    // Already installed
+    if (fs.existsSync(vectorSo) && fs.existsSync(vectorControl)) return;
+
+    this.logger.info('pgvector extension files not found — downloading prebuilt binary...');
+
+    try {
+      // Detect PG major version from the postgres binary
+      const { execSync } = await import('node:child_process');
+      const pgVersion = execSync(`${this.binaries.postgres} --version`, { encoding: 'utf-8' }).trim();
+      const majorMatch = pgVersion.match(/PostgreSQL (\d+)/);
+      const pgMajor = majorMatch ? majorMatch[1] : '17';
+
+      // Detect architecture — fail explicitly on unsupported platforms
+      const nodeArch = os.arch();
+      let arch;
+      if (nodeArch === 'x64') arch = 'amd64';
+      else if (nodeArch === 'arm64') arch = 'arm64';
+      else {
+        this.logger.warn({ arch: nodeArch }, 'Unsupported architecture for pgvector auto-install. Supported: x64, arm64');
+        return;
+      }
+
+      // Download prebuilt pgvector .deb from apt.postgresql.org (HTTPS)
+      // Version 0.8.1-2 — update when new releases ship
+      const debUrl = `https://apt.postgresql.org/pub/repos/apt/pool/main/p/pgvector/postgresql-${pgMajor}-pgvector_0.8.1-2.pgdg%2B1_${arch}.deb`;
+      this.logger.info({ url: debUrl }, 'Downloading pgvector...');
+
+      const res = await fetch(debUrl);
+      if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+
+      const buffer = Buffer.from(await res.arrayBuffer());
+
+      // Extract .deb (it's an ar archive containing data.tar.xz)
+      const tmpDir = path.join(os.tmpdir(), `pgserve-pgvector-${process.pid}-${Date.now()}`);
+      fs.mkdirSync(tmpDir, { recursive: true });
+      const debPath = path.join(tmpDir, 'pgvector.deb');
+      fs.writeFileSync(debPath, buffer);
+
+      // Use dpkg-deb or ar to extract
+      try {
+        execSync(`dpkg-deb -x ${debPath} ${tmpDir}/extracted`, { stdio: 'pipe' });
+      } catch {
+        // Fallback: try ar + tar
+        fs.mkdirSync(path.join(tmpDir, 'extracted'), { recursive: true });
+        execSync(`cd ${tmpDir} && ar x pgvector.deb && tar xf data.tar.* -C ${tmpDir}/extracted 2>/dev/null || tar xf data.tar.xz -C ${tmpDir}/extracted`, { stdio: 'pipe' });
+      }
+
+      // Copy .so file
+      const soSrc = path.join(tmpDir, 'extracted', 'usr', 'lib', 'postgresql', pgMajor, 'lib', 'vector.so');
+      if (fs.existsSync(soSrc)) {
+        fs.copyFileSync(soSrc, vectorSo);
+        this.logger.info({ path: vectorSo }, 'Installed vector.so');
+      }
+
+      // Copy extension SQL + control files
+      const extSrc = path.join(tmpDir, 'extracted', 'usr', 'share', 'postgresql', pgMajor, 'extension');
+      if (fs.existsSync(extSrc)) {
+        fs.mkdirSync(extDir, { recursive: true });
+        for (const f of fs.readdirSync(extSrc)) {
+          if (f.startsWith('vector')) {
+            fs.copyFileSync(path.join(extSrc, f), path.join(extDir, f));
+          }
+        }
+        this.logger.info({ path: extDir }, 'Installed vector extension SQL files');
+      }
+
+      // Patch vector.control to use absolute module_pathname
+      // (embedded PG's $libdir doesn't match the compiled-in path)
+      if (fs.existsSync(vectorControl)) {
+        let control = fs.readFileSync(vectorControl, 'utf-8');
+        control = control.replace(
+          /module_pathname\s*=\s*'\$libdir\/vector'/,
+          `module_pathname = '${vectorSo.replace('.so', '')}'`
+        );
+        fs.writeFileSync(vectorControl, control);
+        this.logger.info('Patched vector.control with absolute module path');
+      }
+
+      // Cleanup
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      this.logger.info('pgvector extension installed successfully');
+    } catch (error) {
+      this.logger.warn({ err: error.message }, 'Failed to install pgvector extension files (non-fatal)');
+    }
+  }
+
   /**
    * Enable pgvector extension on a database
    * Creates a temporary connection to the specific database to run CREATE EXTENSION
    * @param {string} dbName - Database name to enable pgvector on
    */
   async enablePgvectorExtension(dbName) {
+    // Ensure extension files are installed first
+    await this.ensurePgvectorFiles();
+
     const { SQL } = await import('bun');
     let dbPool = null;
 

package/src/router.js

@@ -28,6 +28,17 @@ const SSL_REQUEST_CODE = 80877103;
 const GSSAPI_REQUEST_CODE = 80877104;
 const CANCEL_REQUEST_CODE = 80877102;
 
+/**
+ * Attempt to write a pending buffer to a target socket.
+ * Returns remaining unwritten bytes, or null if fully flushed.
+ */
+function flushPending(target, pending) {
+  const written = target.write(pending);
+  if (written === pending.byteLength) return null;
+  if (written === 0) return pending;
+  return pending.subarray(written);
+}
+
 /**
  * Multi-Tenant Router Server
  */
@@ -175,12 +186,17 @@ export class MultiTenantRouter extends EventEmitter {
         error(socket, error) {
           router.handleSocketError(socket, error);
         },
-        // Called when socket is ready to receive more data
+        // Called when client socket is ready to receive more data
         drain(socket) {
-          // Resume reading from PostgreSQL if backpressure cleared
           const state = router.socketState.get(socket);
-          if (state?.pgSocket) {
-            state.pgSocket.resume?.();
+          if (!state) return;
+          // Flush any pending PG→Client data
+          if (state.pendingToClient) {
+            state.pendingToClient = flushPending(socket, state.pendingToClient);
+          }
+          // If fully flushed, resume reading from PostgreSQL
+          if (!state.pendingToClient && state.pgSocket) {
+            state.pgSocket.resume();
           }
         }
       }
@@ -214,7 +230,9 @@ export class MultiTenantRouter extends EventEmitter {
       buffer: null,
       pgSocket: null,
       dbName: null,
-      handshakeComplete: false
+      handshakeComplete: false,
+      pendingToPg: null,
+      pendingToClient: null
     });
 
     // Track connection
@@ -231,9 +249,16 @@ export class MultiTenantRouter extends EventEmitter {
 
     // If handshake complete, forward to PostgreSQL
     if (state.handshakeComplete && state.pgSocket) {
+      // If there's already pending data, append to it
+      if (state.pendingToPg) {
+        state.pendingToPg = Buffer.concat([state.pendingToPg, data]);
+        return;
+      }
       const written = state.pgSocket.write(data);
-      if (written === 0) {
-        // Backpressure - Bun handles this automatically
+      if (written < data.byteLength) {
+        // Partial write — buffer remainder and pause client
+        state.pendingToPg = written === 0 ? Buffer.from(data) : Buffer.from(data.subarray(written));
+        socket.pause();
       }
       return;
     }
@@ -300,56 +325,47 @@ export class MultiTenantRouter extends EventEmitter {
       const socketPath = this.pgManager.getSocketPath();
       const router = this;
 
-      if (socketPath) {
-        // Unix socket connection (Linux/macOS) - ~30% faster than TCP
-        state.pgSocket = await Bun.connect({
-          unix: socketPath,
-          socket: {
-            data(_pgSocket, pgData) {
-              // Forward PostgreSQL response to client
-              socket.write(pgData);
-            },
-            open(pgSocket) {
-              // Send buffered startup message to PostgreSQL
-              pgSocket.write(startupMessage);
-              state.handshakeComplete = true;
-            },
-            close(_pgSocket) {
-              // PostgreSQL closed - close client
-              socket.end();
-            },
-            error(_pgSocket, error) {
-              router.logger.error({ dbName, err: error }, 'PostgreSQL socket error');
-              socket.end();
-            },
-            drain(_pgSocket) {
-              // Ready for more data
-            }
+      // Shared handler for pgSocket (used by both unix and TCP paths)
+      const pgHandler = {
+        data(_pgSocket, pgData) {
+          // Forward PostgreSQL response to client with backpressure
+          if (state.pendingToClient) {
+            state.pendingToClient = Buffer.concat([state.pendingToClient, pgData]);
+            return;
           }
-        });
-      } else {
-        // TCP fallback (Windows)
-        state.pgSocket = await Bun.connect({
-          hostname: '127.0.0.1',
-          port: this.pgPort,
-          socket: {
-            data(_pgSocket, pgData) {
-              socket.write(pgData);
-            },
-            open(pgSocket) {
-              pgSocket.write(startupMessage);
-              state.handshakeComplete = true;
-            },
-            close(_pgSocket) {
-              socket.end();
-            },
-            error(_pgSocket, error) {
-              router.logger.error({ dbName, err: error }, 'PostgreSQL socket error');
-              socket.end();
-            },
-            drain(_pgSocket) {}
+          const written = socket.write(pgData);
+          if (written < pgData.byteLength) {
+            state.pendingToClient = written === 0 ? Buffer.from(pgData) : Buffer.from(pgData.subarray(written));
+            _pgSocket.pause();
+          }
+        },
+        open(pgSocket) {
+          pgSocket.write(startupMessage);
+          state.handshakeComplete = true;
+        },
+        close(_pgSocket) {
+          socket.end();
+        },
+        error(_pgSocket, error) {
+          router.logger.error({ dbName, err: error }, 'PostgreSQL socket error');
+          socket.end();
+        },
+        drain(_pgSocket) {
+          // Flush any pending Client→PG data
+          if (state.pendingToPg) {
+            state.pendingToPg = flushPending(_pgSocket, state.pendingToPg);
+          }
+          // If fully flushed, resume reading from client
+          if (!state.pendingToPg) {
+            socket.resume();
           }
-        });
+        }
+      };
+
+      if (socketPath) {
+        state.pgSocket = await Bun.connect({ unix: socketPath, socket: pgHandler });
+      } else {
+        state.pgSocket = await Bun.connect({ hostname: '127.0.0.1', port: this.pgPort, socket: pgHandler });
       }
 
       this.emit('connection', { dbName, socket });
@@ -365,8 +381,10 @@ export class MultiTenantRouter extends EventEmitter {
    */
   handleSocketClose(socket) {
     const state = this.socketState.get(socket);
-    if (state?.pgSocket) {
-      state.pgSocket.end();
+    if (state) {
+      state.pendingToPg = null;
+      state.pendingToClient = null;
+      if (state.pgSocket) state.pgSocket.end();
     }
     this.connections.delete(socket);
     this.socketState.delete(socket);
@@ -381,8 +399,10 @@ export class MultiTenantRouter extends EventEmitter {
     if (error.code !== 'ECONNRESET') {
       this.logger.error({ err: error, dbName: state?.dbName }, 'Socket error');
     }
-    if (state?.pgSocket) {
-      state.pgSocket.end();
+    if (state) {
+      state.pendingToPg = null;
+      state.pendingToClient = null;
+      if (state.pgSocket) state.pgSocket.end();
     }
     this.connections.delete(socket);
     this.socketState.delete(socket);

package/tests/backpressure.test.js

@@ -0,0 +1,167 @@
+/**
+ * Backpressure / Large Message Regression Tests
+ *
+ * Reproduces the deadlock from issue #14: TCP proxy drops bytes when
+ * socket buffers are full, causing PostgreSQL to wait forever for the
+ * remainder of a truncated wire protocol message.
+ */
+
+import { startMultiTenantServer } from '../src/index.js';
+import pg from 'pg';
+import { test, expect } from 'bun:test';
+import fs from 'fs';
+
+const { Client } = pg;
+
+const TEST_PORT = 15433;
+const testDataDir = './test-data-backpressure';
+
+function cleanup() {
+  if (fs.existsSync(testDataDir)) {
+    fs.rmSync(testDataDir, { recursive: true, force: true });
+  }
+}
+
+/** Create a connected pg.Client */
+async function connect(dbName) {
+  const client = new Client({
+    host: '127.0.0.1',
+    port: TEST_PORT,
+    database: dbName,
+    user: 'postgres',
+    password: 'postgres',
+  });
+  await client.connect();
+  return client;
+}
+
+test('Large INSERT (~360KB payload) does not deadlock', async () => {
+  cleanup();
+  const router = await startMultiTenantServer({
+    port: TEST_PORT,
+    baseDir: testDataDir,
+    logLevel: 'warn',
+  });
+
+  let client;
+  try {
+    client = await connect('bp_insert');
+    await client.query('CREATE TABLE big (id SERIAL PRIMARY KEY, payload TEXT)');
+
+    // ~360KB of text — exceeds typical socket buffer size
+    const bigPayload = 'x'.repeat(360_000);
+    await client.query('INSERT INTO big (payload) VALUES ($1)', [bigPayload]);
+
+    const res = await client.query('SELECT length(payload) AS len FROM big');
+    expect(Number(res.rows[0].len)).toBe(360000);
+  } finally {
+    if (client) await client.end().catch(() => {});
+    await router.stop();
+    cleanup();
+  }
+}, 30_000);
+
+test('Large SELECT result (500KB+) does not deadlock', async () => {
+  cleanup();
+  const router = await startMultiTenantServer({
+    port: TEST_PORT,
+    baseDir: testDataDir,
+    logLevel: 'warn',
+  });
+
+  let client;
+  try {
+    client = await connect('bp_select');
+    await client.query('CREATE TABLE chunks (id SERIAL PRIMARY KEY, data TEXT)');
+
+    // Insert many rows that sum to >500KB
+    const chunkSize = 10_000;
+    const numChunks = 60; // 60 * 10KB = 600KB total
+    const chunk = 'y'.repeat(chunkSize);
+
+    for (let i = 0; i < numChunks; i++) {
+      await client.query('INSERT INTO chunks (data) VALUES ($1)', [chunk]);
+    }
+
+    // Fetch all rows in a single result set (PG→Client backpressure)
+    const res = await client.query('SELECT * FROM chunks');
+    expect(res.rows.length).toBe(numChunks);
+    expect(res.rows[0].data.length).toBe(chunkSize);
+  } finally {
+    if (client) await client.end().catch(() => {});
+    await router.stop();
+    cleanup();
+  }
+}, 30_000);
+
+test('Large single query with multi-value INSERT (500KB+)', async () => {
+  cleanup();
+  const router = await startMultiTenantServer({
+    port: TEST_PORT,
+    baseDir: testDataDir,
+    logLevel: 'warn',
+  });
+
+  let client;
+  try {
+    client = await connect('bp_multivalue');
+    await client.query('CREATE TABLE items (id INT, val TEXT)');
+
+    // Build a single INSERT with many value tuples to produce a large wire message
+    const rowCount = 500;
+    const rowValue = 'z'.repeat(1_000); // 1KB per row → ~500KB total
+    const values = [];
+    const params = [];
+    for (let i = 0; i < rowCount; i++) {
+      values.push(`($${i * 2 + 1}, $${i * 2 + 2})`);
+      params.push(i, rowValue);
+    }
+
+    const sql = `INSERT INTO items (id, val) VALUES ${values.join(', ')}`;
+    await client.query(sql, params);
+
+    const res = await client.query('SELECT count(*)::int AS cnt FROM items');
+    expect(res.rows[0].cnt).toBe(rowCount);
+  } finally {
+    if (client) await client.end().catch(() => {});
+    await router.stop();
+    cleanup();
+  }
+}, 30_000);
+
+test('Concurrent large operations (5 clients x 300KB)', async () => {
+  cleanup();
+  const router = await startMultiTenantServer({
+    port: TEST_PORT,
+    baseDir: testDataDir,
+    logLevel: 'warn',
+  });
+
+  try {
+    const numClients = 5;
+    const payloadSize = 300_000;
+    const payload = 'c'.repeat(payloadSize);
+
+    // Run all clients concurrently
+    const results = await Promise.all(
+      Array.from({ length: numClients }, async (_, i) => {
+        const dbName = `bp_concurrent_${i}`;
+        const client = await connect(dbName);
+        await client.query('CREATE TABLE stress (id SERIAL PRIMARY KEY, data TEXT)');
+        await client.query('INSERT INTO stress (data) VALUES ($1)', [payload]);
+
+        const res = await client.query('SELECT length(data) AS len FROM stress');
+        await client.end();
+        return parseInt(res.rows[0].len, 10);
+      })
+    );
+
+    // All clients should have successfully stored the full payload
+    for (const len of results) {
+      expect(len).toBe(payloadSize);
+    }
+  } finally {
+    await router.stop();
+    cleanup();
+  }
+}, 60_000);