prisma-pglite-bridge 0.3.0 → 0.3.1

package/dist/index.cjs

@@ -1,617 +1,679 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  PGliteBridge: () => PGliteBridge,
-  createPgliteAdapter: () => createPgliteAdapter,
-  createPool: () => createPool
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/pglite-bridge.ts
-var import_node_stream = require("stream");
-
-// src/session-lock.ts
-var STATUS_IDLE = 73;
-var STATUS_IN_TRANSACTION = 84;
-var STATUS_FAILED = 69;
-var createBridgeId = () => /* @__PURE__ */ Symbol("bridge");
-var extractRfqStatus = (response) => {
-  if (response.length < 6) return null;
-  const i = response.length - 6;
-  if (response[i] === 90 && response[i + 1] === 0 && response[i + 2] === 0 && response[i + 3] === 0 && response[i + 4] === 5) {
-    return response[i + 5] ?? null;
-  }
-  return null;
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let _prisma_adapter_pg = require("@prisma/adapter-pg");
+let _electric_sql_pglite = require("@electric-sql/pglite");
+let pg = require("pg");
+pg = __toESM(pg, 1);
+let node_stream = require("node:stream");
+//#region src/session-lock.ts
+/**
+* Session-level lock for PGlite's single-session model.
+*
+* PGlite runs PostgreSQL in single-user mode — one session shared by all
+* bridges. runExclusive serializes individual operations, but transactions
+* span multiple operations. Without session-level locking, Bridge A's BEGIN
+* and Bridge B's query interleave, corrupting transaction boundaries.
+*
+* The session lock tracks which bridge owns the session. When PGlite enters
+* transaction state (ReadyForQuery status 'T' or 'E'), the owning bridge
+* gets exclusive access until the transaction completes (status returns to 'I').
+*
+* Non-transactional operations from any bridge are allowed when no transaction
+* is active — they serialize naturally through runExclusive.
+*/
+const STATUS_IDLE = 73;
+const STATUS_IN_TRANSACTION = 84;
+const STATUS_FAILED = 69;
+const createBridgeId = () => Symbol("bridge");
+/**
+* Extracts the ReadyForQuery status byte from a response buffer.
+* Scans from the end since RFQ is always the last message.
+* Returns null if no RFQ found.
+*/
+const extractRfqStatus = (response) => {
+	if (response.length < 6) return null;
+	const i = response.length - 6;
+	if (response[i] === 90 && response[i + 1] === 0 && response[i + 2] === 0 && response[i + 3] === 0 && response[i + 4] === 5) return response[i + 5] ?? null;
+	return null;
 };
 var SessionLock = class {
-  owner = null;
-  waitQueue = [];
-  /**
-   * Acquire access to PGlite. Resolves immediately if no transaction is
-   * active or if this bridge owns the current transaction. Queues otherwise.
-   */
-  async acquire(id) {
-    if (this.owner === null || this.owner === id) return;
-    return new Promise((resolve) => {
-      this.waitQueue.push({ id, resolve });
-    });
-  }
-  /**
-   * Update session state based on the ReadyForQuery status byte.
-   * Call after every PGlite response that contains RFQ.
-   */
-  updateStatus(id, status) {
-    if (status === STATUS_IN_TRANSACTION || status === STATUS_FAILED) {
-      this.owner = id;
-    } else if (status === STATUS_IDLE) {
-      if (this.owner === id) {
-        this.owner = null;
-        this.drainWaitQueue();
-      }
-    }
-  }
-  /**
-   * Release ownership (e.g., when a bridge is destroyed mid-transaction).
-   */
-  release(id) {
-    if (this.owner === id) {
-      this.owner = null;
-      this.drainWaitQueue();
-    }
-  }
-  drainWaitQueue() {
-    const waiters = this.waitQueue;
-    this.waitQueue = [];
-    for (const waiter of waiters) {
-      waiter.resolve();
-    }
-  }
+	owner = null;
+	waitQueue = [];
+	/**
+	* Acquire access to PGlite. Resolves immediately if no transaction is
+	* active or if this bridge owns the current transaction. Queues otherwise.
+	*/
+	async acquire(id) {
+		if (this.owner === null || this.owner === id) return;
+		return new Promise((resolve) => {
+			this.waitQueue.push({
+				id,
+				resolve
+			});
+		});
+	}
+	/**
+	* Update session state based on the ReadyForQuery status byte.
+	* Call after every PGlite response that contains RFQ.
+	*/
+	updateStatus(id, status) {
+		if (status === STATUS_IN_TRANSACTION || status === STATUS_FAILED) this.owner = id;
+		else if (status === STATUS_IDLE) {
+			if (this.owner === id) {
+				this.owner = null;
+				this.drainWaitQueue();
+			}
+		}
+	}
+	/**
+	* Release ownership (e.g., when a bridge is destroyed mid-transaction).
+	*/
+	release(id) {
+		if (this.owner === id) {
+			this.owner = null;
+			this.drainWaitQueue();
+		}
+	}
+	drainWaitQueue() {
+		const waiters = this.waitQueue;
+		this.waitQueue = [];
+		for (const waiter of waiters) waiter.resolve();
+	}
 };
-
-// src/pglite-bridge.ts
-var PARSE = 80;
-var BIND = 66;
-var DESCRIBE = 68;
-var EXECUTE = 69;
-var CLOSE = 67;
-var FLUSH = 72;
-var SYNC = 83;
-var TERMINATE = 88;
-var READY_FOR_QUERY = 90;
-var EQP_MESSAGES = /* @__PURE__ */ new Set([PARSE, BIND, DESCRIBE, EXECUTE, CLOSE, FLUSH]);
-var stripIntermediateReadyForQuery = (response) => {
-  const rfqPositions = [];
-  let offset = 0;
-  while (offset < response.length) {
-    if (offset + 5 >= response.length) break;
-    if (response[offset] === READY_FOR_QUERY && response[offset + 1] === 0 && response[offset + 2] === 0 && response[offset + 3] === 0 && response[offset + 4] === 5) {
-      rfqPositions.push(offset);
-      offset += 6;
-    } else {
-      const b1 = response[offset + 1];
-      const b2 = response[offset + 2];
-      const b3 = response[offset + 3];
-      const b4 = response[offset + 4];
-      if (b1 === void 0 || b2 === void 0 || b3 === void 0 || b4 === void 0) break;
-      const msgLen = (b1 << 24 | b2 << 16 | b3 << 8 | b4) >>> 0;
-      if (msgLen < 4) break;
-      offset += 1 + msgLen;
-    }
-  }
-  if (rfqPositions.length <= 1) return response;
-  const removeCount = rfqPositions.length - 1;
-  const resultLen = response.length - removeCount * 6;
-  const result = new Uint8Array(resultLen);
-  let src = 0;
-  let dst = 0;
-  let removeIdx = 0;
-  while (src < response.length) {
-    const nextRemove = removeIdx < removeCount ? rfqPositions[removeIdx] ?? response.length : response.length;
-    if (src < nextRemove) {
-      const copyLen = nextRemove - src;
-      result.set(response.subarray(src, src + copyLen), dst);
-      dst += copyLen;
-      src += copyLen;
-    }
-    if (removeIdx < removeCount && src === rfqPositions[removeIdx]) {
-      src += 6;
-      removeIdx++;
-    }
-  }
-  return result;
+//#endregion
+//#region src/pglite-bridge.ts
+/**
+* PGlite bridge stream.
+*
+* A Duplex stream that replaces the TCP socket in pg.Client, routing
+* wire protocol messages directly to an in-process PGlite instance.
+*
+* pg.Client writes wire protocol bytes → bridge frames messages →
+* PGlite processes via execProtocolRawStream → bridge pushes responses back.
+*
+* Extended Query Protocol pipelines (Parse→Bind→Describe→Execute→Sync) are
+* concatenated into a single buffer and sent as one atomic execProtocolRawStream
+* call within one runExclusive. This prevents portal interleaving between
+* concurrent bridges AND reduces async overhead (1 WASM call instead of 5).
+*
+* The response from a batched pipeline contains spurious ReadyForQuery messages
+* after each sub-message (PGlite's single-user mode). These are stripped,
+* keeping only the final ReadyForQuery after Sync.
+*/
+const PARSE = 80;
+const BIND = 66;
+const DESCRIBE = 68;
+const EXECUTE = 69;
+const CLOSE = 67;
+const FLUSH = 72;
+const SYNC = 83;
+const TERMINATE = 88;
+const READY_FOR_QUERY = 90;
+const EQP_MESSAGES = new Set([
+	PARSE,
+	BIND,
+	DESCRIBE,
+	EXECUTE,
+	CLOSE,
+	FLUSH
+]);
+/**
+* Strips all intermediate ReadyForQuery messages from a response, keeping
+* only the last one. PGlite's single-user mode emits RFQ after every
+* sub-message; pg.Client expects exactly one after Sync.
+*
+* Operates in-place on the response by building a list of byte ranges to
+* keep, then assembling the result. Returns the original buffer (no copy)
+* if there are 0 or 1 RFQ messages.
+*/
+/** @internal — exported for testing only */
+const stripIntermediateReadyForQuery = (response) => {
+	const rfqPositions = [];
+	let offset = 0;
+	while (offset < response.length) {
+		if (offset + 5 >= response.length) break;
+		if (response[offset] === READY_FOR_QUERY && response[offset + 1] === 0 && response[offset + 2] === 0 && response[offset + 3] === 0 && response[offset + 4] === 5) {
+			rfqPositions.push(offset);
+			offset += 6;
+		} else {
+			const b1 = response[offset + 1];
+			const b2 = response[offset + 2];
+			const b3 = response[offset + 3];
+			const b4 = response[offset + 4];
+			if (b1 === void 0 || b2 === void 0 || b3 === void 0 || b4 === void 0) break;
+			const msgLen = (b1 << 24 | b2 << 16 | b3 << 8 | b4) >>> 0;
+			if (msgLen < 4) break;
+			offset += 1 + msgLen;
+		}
+	}
+	if (rfqPositions.length <= 1) return response;
+	const removeCount = rfqPositions.length - 1;
+	const resultLen = response.length - removeCount * 6;
+	const result = new Uint8Array(resultLen);
+	let src = 0;
+	let dst = 0;
+	let removeIdx = 0;
+	while (src < response.length) {
+		const nextRemove = removeIdx < removeCount ? rfqPositions[removeIdx] ?? response.length : response.length;
+		if (src < nextRemove) {
+			const copyLen = nextRemove - src;
+			result.set(response.subarray(src, src + copyLen), dst);
+			dst += copyLen;
+			src += copyLen;
+		}
+		if (removeIdx < removeCount && src === rfqPositions[removeIdx]) {
+			src += 6;
+			removeIdx++;
+		}
+	}
+	return result;
 };
-var concat = (parts) => {
-  if (parts.length === 1) return parts[0] ?? new Uint8Array(0);
-  const total = parts.reduce((sum, p) => sum + p.length, 0);
-  const result = new Uint8Array(total);
-  let offset = 0;
-  for (const part of parts) {
-    result.set(part, offset);
-    offset += part.length;
-  }
-  return result;
+/**
+* Concatenates multiple Uint8Array views into one contiguous buffer.
+*/
+const concat = (parts) => {
+	if (parts.length === 1) return parts[0] ?? new Uint8Array(0);
+	const total = parts.reduce((sum, p) => sum + p.length, 0);
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		result.set(part, offset);
+		offset += part.length;
+	}
+	return result;
 };
-var PGliteBridge = class extends import_node_stream.Duplex {
-  pglite;
-  sessionLock;
-  bridgeId;
-  /** Incoming bytes not yet compacted into buf */
-  pending = [];
-  pendingLen = 0;
-  /** Compacted input buffer for message framing */
-  buf = Buffer.alloc(0);
-  phase = "pre_startup";
-  draining = false;
-  tornDown = false;
-  /** Callbacks waiting for drain to process their data */
-  drainQueue = [];
-  /** Buffered EQP messages awaiting Sync */
-  pipeline = [];
-  pipelineLen = 0;
-  constructor(pglite, sessionLock) {
-    super();
-    this.pglite = pglite;
-    this.sessionLock = sessionLock ?? null;
-    this.bridgeId = createBridgeId();
-  }
-  // ── Socket compatibility (called by pg's Connection) ──
-  connect() {
-    setImmediate(() => this.emit("connect"));
-    return this;
-  }
-  setKeepAlive() {
-    return this;
-  }
-  setNoDelay() {
-    return this;
-  }
-  setTimeout() {
-    return this;
-  }
-  ref() {
-    return this;
-  }
-  unref() {
-    return this;
-  }
-  // ── Duplex implementation ──
-  _read() {
-  }
-  _write(chunk, _encoding, callback) {
-    this.pending.push(chunk);
-    this.pendingLen += chunk.length;
-    this.enqueue(callback);
-  }
-  /** Handles corked batches — pg.Client corks during prepared queries (P+B+D+E+S) */
-  _writev(chunks, callback) {
-    for (const { chunk } of chunks) {
-      this.pending.push(chunk);
-      this.pendingLen += chunk.length;
-    }
-    this.enqueue(callback);
-  }
-  _final(callback) {
-    this.sessionLock?.release(this.bridgeId);
-    this.push(null);
-    callback();
-  }
-  _destroy(error, callback) {
-    this.tornDown = true;
-    this.pipeline.length = 0;
-    this.pipelineLen = 0;
-    this.pending.length = 0;
-    this.pendingLen = 0;
-    this.sessionLock?.release(this.bridgeId);
-    const callbacks = this.drainQueue;
-    this.drainQueue = [];
-    for (const cb of callbacks) {
-      cb(error);
-    }
-    callback(error);
-  }
-  // ── Message processing ──
-  /** Merge pending chunks into buf only when needed for framing */
-  compact() {
-    if (this.pending.length === 0) return;
-    if (this.buf.length === 0 && this.pending.length === 1) {
-      this.buf = this.pending[0];
-    } else {
-      this.buf = Buffer.concat([this.buf, ...this.pending]);
-    }
-    this.pending.length = 0;
-    this.pendingLen = 0;
-  }
-  /**
-   * Enqueue a write callback and start draining if not already running.
-   * The callback is NOT called until drain has processed the data.
-   */
-  enqueue(callback) {
-    this.drainQueue.push(callback);
-    if (!this.draining) {
-      this.drain().catch(() => {
-      });
-    }
-  }
-  /**
-   * Process all pending data, looping until no new data arrives.
-   * Fires all queued callbacks on completion or error.
-   */
-  async drain() {
-    if (this.draining) return;
-    this.draining = true;
-    let error = null;
-    try {
-      while (this.pending.length > 0 || this.buf.length > 0) {
-        if (this.tornDown) break;
-        if (this.phase === "pre_startup") {
-          await this.processPreStartup();
-        }
-        if (this.phase === "ready") {
-          await this.processMessages();
-        }
-        if (this.pending.length === 0) break;
-      }
-    } catch (err) {
-      error = err instanceof Error ? err : new Error(String(err));
-      this.sessionLock?.release(this.bridgeId);
-    } finally {
-      this.draining = false;
-      const callbacks = this.drainQueue;
-      this.drainQueue = [];
-      for (const cb of callbacks) {
-        cb(error);
-      }
-    }
-  }
-  /**
-   * Frames and processes the startup message.
-   *
-   * Format: [4 bytes: total length] [4 bytes: protocol version] [key\0value\0 pairs]
-   * No type byte — length includes itself.
-   */
-  async processPreStartup() {
-    this.compact();
-    if (this.buf.length < 4) return;
-    const len = this.buf.readInt32BE(0);
-    if (this.buf.length < len) return;
-    const message = this.buf.subarray(0, len);
-    this.buf = this.buf.subarray(len);
-    await this.acquireSession();
-    await this.pglite.runExclusive(async () => {
-      await this.execAndPush(message);
-    });
-    this.phase = "ready";
-  }
-  /**
-   * Frames and processes regular wire protocol messages.
-   *
-   * Extended Query Protocol messages (Parse, Bind, Describe, Execute, Close,
-   * Flush) are buffered in `this.pipeline`. When Sync arrives, the entire
-   * pipeline is concatenated and sent to PGlite as one atomic
-   * execProtocolRawStream call within one runExclusive.
-   *
-   * SimpleQuery messages are sent directly (they're self-contained).
-   */
-  async processMessages() {
-    this.compact();
-    while (this.buf.length >= 5) {
-      const len = 1 + this.buf.readInt32BE(1);
-      if (len < 5 || this.buf.length < len) break;
-      const message = this.buf.subarray(0, len);
-      this.buf = this.buf.subarray(len);
-      const msgType = message[0] ?? 0;
-      if (msgType === TERMINATE) {
-        this.sessionLock?.release(this.bridgeId);
-        this.push(null);
-        return;
-      }
-      if (EQP_MESSAGES.has(msgType)) {
-        this.pipeline.push(message);
-        this.pipelineLen += message.length;
-        continue;
-      }
-      if (msgType === SYNC) {
-        this.pipeline.push(message);
-        this.pipelineLen += message.length;
-        await this.flushPipeline();
-        continue;
-      }
-      await this.acquireSession();
-      await this.pglite.runExclusive(async () => {
-        await this.execAndPush(message);
-      });
-    }
-  }
-  /**
-   * Sends the accumulated EQP pipeline as one atomic operation.
-   *
-   * All buffered messages are concatenated into a single buffer and sent
-   * as one execProtocolRawStream call. This is both correct (prevents
-   * portal interleaving) and fast (1 WASM call + 1 async boundary instead
-   * of 5). Intermediate ReadyForQuery messages are stripped from the
-   * combined response.
-   */
-  async flushPipeline() {
-    const messages = this.pipeline;
-    const totalLen = this.pipelineLen;
-    this.pipeline = [];
-    this.pipelineLen = 0;
-    let batch;
-    if (messages.length === 1) {
-      batch = messages[0] ?? new Uint8Array(0);
-    } else {
-      batch = new Uint8Array(totalLen);
-      let offset = 0;
-      for (const msg of messages) {
-        batch.set(msg, offset);
-        offset += msg.length;
-      }
-    }
-    await this.acquireSession();
-    await this.pglite.runExclusive(async () => {
-      const chunks = [];
-      await this.pglite.execProtocolRawStream(batch, {
-        onRawData: (chunk) => chunks.push(chunk)
-      });
-      if (this.tornDown || chunks.length === 0) return;
-      if (chunks.length === 1) {
-        const raw = chunks[0] ?? new Uint8Array(0);
-        this.trackSessionStatus(raw);
-        const cleaned2 = stripIntermediateReadyForQuery(raw);
-        if (cleaned2.length > 0) this.push(cleaned2);
-        return;
-      }
-      const combined = concat(chunks);
-      this.trackSessionStatus(combined);
-      const cleaned = stripIntermediateReadyForQuery(combined);
-      if (cleaned.length > 0) this.push(cleaned);
-    });
-  }
-  /**
-   * Sends a message to PGlite and pushes response chunks directly to the
-   * stream as they arrive. Avoids collecting and concatenating for large
-   * multi-row responses (e.g., findMany 500 rows = ~503 onRawData chunks).
-   *
-   * Must be called inside runExclusive.
-   */
-  async execAndPush(message) {
-    let lastChunk = null;
-    await this.pglite.execProtocolRawStream(message, {
-      onRawData: (chunk) => {
-        if (!this.tornDown && chunk.length > 0) {
-          this.push(chunk);
-          lastChunk = chunk;
-        }
-      }
-    });
-    if (lastChunk) this.trackSessionStatus(lastChunk);
-  }
-  // ── Session lock helpers ──
-  async acquireSession() {
-    await this.sessionLock?.acquire(this.bridgeId);
-  }
-  trackSessionStatus(response) {
-    if (!this.sessionLock) return;
-    const status = extractRfqStatus(response);
-    if (status !== null) {
-      this.sessionLock.updateStatus(this.bridgeId, status);
-    }
-  }
+/**
+* Duplex stream that bridges `pg.Client` to an in-process PGlite instance.
+*
+* Replaces the TCP socket in `pg.Client` via the `stream` option. Speaks
+* PostgreSQL wire protocol directly to PGlite — no TCP, no serialization
+* overhead beyond what the wire protocol requires.
+*
+* Pass to `pg.Client` or use via `createPool()` / `createPgliteAdapter()`:
+*
+* ```typescript
+* const client = new pg.Client({
+*   stream: () => new PGliteBridge(pglite),
+* });
+* ```
+*/
+var PGliteBridge = class extends node_stream.Duplex {
+	pglite;
+	sessionLock;
+	bridgeId;
+	/** Incoming bytes not yet compacted into buf */
+	pending = [];
+	pendingLen = 0;
+	/** Compacted input buffer for message framing */
+	buf = Buffer.alloc(0);
+	phase = "pre_startup";
+	draining = false;
+	tornDown = false;
+	/** Callbacks waiting for drain to process their data */
+	drainQueue = [];
+	/** Buffered EQP messages awaiting Sync */
+	pipeline = [];
+	pipelineLen = 0;
+	constructor(pglite, sessionLock) {
+		super();
+		this.pglite = pglite;
+		this.sessionLock = sessionLock ?? null;
+		this.bridgeId = createBridgeId();
+	}
+	connect() {
+		setImmediate(() => this.emit("connect"));
+		return this;
+	}
+	setKeepAlive() {
+		return this;
+	}
+	setNoDelay() {
+		return this;
+	}
+	setTimeout() {
+		return this;
+	}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+	_read() {}
+	_write(chunk, _encoding, callback) {
+		this.pending.push(chunk);
+		this.pendingLen += chunk.length;
+		this.enqueue(callback);
+	}
+	/** Handles corked batches — pg.Client corks during prepared queries (P+B+D+E+S) */
+	_writev(chunks, callback) {
+		for (const { chunk } of chunks) {
+			this.pending.push(chunk);
+			this.pendingLen += chunk.length;
+		}
+		this.enqueue(callback);
+	}
+	_final(callback) {
+		this.sessionLock?.release(this.bridgeId);
+		this.push(null);
+		callback();
+	}
+	_destroy(error, callback) {
+		this.tornDown = true;
+		this.pipeline.length = 0;
+		this.pipelineLen = 0;
+		this.pending.length = 0;
+		this.pendingLen = 0;
+		this.sessionLock?.release(this.bridgeId);
+		const callbacks = this.drainQueue;
+		this.drainQueue = [];
+		for (const cb of callbacks) cb(error);
+		callback(error);
+	}
+	/** Merge pending chunks into buf only when needed for framing */
+	compact() {
+		if (this.pending.length === 0) return;
+		if (this.buf.length === 0 && this.pending.length === 1) this.buf = this.pending[0];
+		else this.buf = Buffer.concat([this.buf, ...this.pending]);
+		this.pending.length = 0;
+		this.pendingLen = 0;
+	}
+	/**
+	* Enqueue a write callback and start draining if not already running.
+	* The callback is NOT called until drain has processed the data.
+	*/
+	enqueue(callback) {
+		this.drainQueue.push(callback);
+		if (!this.draining) this.drain().catch(() => {});
+	}
+	/**
+	* Process all pending data, looping until no new data arrives.
+	* Fires all queued callbacks on completion or error.
+	*/
+	async drain() {
+		if (this.draining) return;
+		this.draining = true;
+		let error = null;
+		try {
+			while (this.pending.length > 0 || this.buf.length > 0) {
+				if (this.tornDown) break;
+				if (this.phase === "pre_startup") await this.processPreStartup();
+				if (this.phase === "ready") await this.processMessages();
+				if (this.pending.length === 0) break;
+			}
+		} catch (err) {
+			error = err instanceof Error ? err : new Error(String(err));
+			this.sessionLock?.release(this.bridgeId);
+		} finally {
+			this.draining = false;
+			const callbacks = this.drainQueue;
+			this.drainQueue = [];
+			for (const cb of callbacks) cb(error);
+		}
+	}
+	/**
+	* Frames and processes the startup message.
+	*
+	* Format: [4 bytes: total length] [4 bytes: protocol version] [key\0value\0 pairs]
+	* No type byte — length includes itself.
+	*/
+	async processPreStartup() {
+		this.compact();
+		if (this.buf.length < 4) return;
+		const len = this.buf.readInt32BE(0);
+		if (this.buf.length < len) return;
+		const message = this.buf.subarray(0, len);
+		this.buf = this.buf.subarray(len);
+		await this.acquireSession();
+		await this.pglite.runExclusive(async () => {
+			await this.execAndPush(message);
+		});
+		this.phase = "ready";
+	}
+	/**
+	* Frames and processes regular wire protocol messages.
+	*
+	* Extended Query Protocol messages (Parse, Bind, Describe, Execute, Close,
+	* Flush) are buffered in `this.pipeline`. When Sync arrives, the entire
+	* pipeline is concatenated and sent to PGlite as one atomic
+	* execProtocolRawStream call within one runExclusive.
+	*
+	* SimpleQuery messages are sent directly (they're self-contained).
+	*/
+	async processMessages() {
+		this.compact();
+		while (this.buf.length >= 5) {
+			const len = 1 + this.buf.readInt32BE(1);
+			if (len < 5 || this.buf.length < len) break;
+			const message = this.buf.subarray(0, len);
+			this.buf = this.buf.subarray(len);
+			const msgType = message[0] ?? 0;
+			if (msgType === TERMINATE) {
+				this.sessionLock?.release(this.bridgeId);
+				this.push(null);
+				return;
+			}
+			if (EQP_MESSAGES.has(msgType)) {
+				this.pipeline.push(message);
+				this.pipelineLen += message.length;
+				continue;
+			}
+			if (msgType === SYNC) {
+				this.pipeline.push(message);
+				this.pipelineLen += message.length;
+				await this.flushPipeline();
+				continue;
+			}
+			await this.acquireSession();
+			await this.pglite.runExclusive(async () => {
+				await this.execAndPush(message);
+			});
+		}
+	}
+	/**
+	* Sends the accumulated EQP pipeline as one atomic operation.
+	*
+	* All buffered messages are concatenated into a single buffer and sent
+	* as one execProtocolRawStream call. This is both correct (prevents
+	* portal interleaving) and fast (1 WASM call + 1 async boundary instead
+	* of 5). Intermediate ReadyForQuery messages are stripped from the
+	* combined response.
+	*/
+	async flushPipeline() {
+		const messages = this.pipeline;
+		const totalLen = this.pipelineLen;
+		this.pipeline = [];
+		this.pipelineLen = 0;
+		let batch;
+		if (messages.length === 1) batch = messages[0] ?? new Uint8Array(0);
+		else {
+			batch = new Uint8Array(totalLen);
+			let offset = 0;
+			for (const msg of messages) {
+				batch.set(msg, offset);
+				offset += msg.length;
+			}
+		}
+		await this.acquireSession();
+		await this.pglite.runExclusive(async () => {
+			const chunks = [];
+			await this.pglite.execProtocolRawStream(batch, { onRawData: (chunk) => chunks.push(chunk) });
+			if (this.tornDown || chunks.length === 0) return;
+			if (chunks.length === 1) {
+				const raw = chunks[0] ?? new Uint8Array(0);
+				this.trackSessionStatus(raw);
+				const cleaned = stripIntermediateReadyForQuery(raw);
+				if (cleaned.length > 0) this.push(cleaned);
+				return;
+			}
+			const combined = concat(chunks);
+			this.trackSessionStatus(combined);
+			const cleaned = stripIntermediateReadyForQuery(combined);
+			if (cleaned.length > 0) this.push(cleaned);
+		});
+	}
+	/**
+	* Sends a message to PGlite and pushes response chunks directly to the
+	* stream as they arrive. Avoids collecting and concatenating for large
+	* multi-row responses (e.g., findMany 500 rows = ~503 onRawData chunks).
+	*
+	* Must be called inside runExclusive.
+	*/
+	async execAndPush(message) {
+		let lastChunk = null;
+		await this.pglite.execProtocolRawStream(message, { onRawData: (chunk) => {
+			if (!this.tornDown && chunk.length > 0) {
+				this.push(chunk);
+				lastChunk = chunk;
+			}
+		} });
+		if (lastChunk) this.trackSessionStatus(lastChunk);
+	}
+	async acquireSession() {
+		await this.sessionLock?.acquire(this.bridgeId);
+	}
+	trackSessionStatus(response) {
+		if (!this.sessionLock) return;
+		const status = extractRfqStatus(response);
+		if (status !== null) this.sessionLock.updateStatus(this.bridgeId, status);
+	}
 };
-
-// src/create-pool.ts
-var import_pglite = require("@electric-sql/pglite");
-var import_pg = __toESM(require("pg"), 1);
-var { Client, Pool } = import_pg.default;
-var createPool = async (options = {}) => {
-  const { dataDir, extensions, max = 5 } = options;
-  const ownsInstance = !options.pglite;
-  const pglite = options.pglite ?? new import_pglite.PGlite(dataDir, extensions ? { extensions } : void 0);
-  await pglite.waitReady;
-  const sessionLock = new SessionLock();
-  const BridgedClient = class extends Client {
-    constructor(config) {
-      const cfg = typeof config === "string" ? { connectionString: config } : config ?? {};
-      super({
-        ...cfg,
-        user: "postgres",
-        database: "postgres",
-        stream: (() => new PGliteBridge(pglite, sessionLock))
-      });
-    }
-  };
-  const pool = new Pool({
-    Client: BridgedClient,
-    max
-  });
-  const close = async () => {
-    await pool.end();
-    if (ownsInstance) {
-      await pglite.close();
-    }
-  };
-  return { pool, pglite, close };
+//#endregion
+//#region src/create-pool.ts
+/**
+* Pool factory — creates a pg.Pool backed by an in-process PGlite instance.
+*
+* Each pool connection gets its own PGliteBridge stream, all sharing the
+* same PGlite WASM instance and SessionLock. The session lock ensures
+* transaction isolation: when one bridge starts a transaction (BEGIN),
+* it gets exclusive PGlite access until COMMIT/ROLLBACK. Non-transactional
+* operations from any bridge serialize through PGlite's runExclusive mutex.
+*/
+const { Client, Pool } = pg.default;
+/**
+* Creates a pg.Pool where every connection is an in-process PGlite bridge.
+*
+* ```typescript
+* import { createPool } from 'prisma-pglite-bridge';
+* import { PrismaPg } from '@prisma/adapter-pg';
+* import { PrismaClient } from '@prisma/client';
+*
+* const { pool, close } = await createPool();
+* const adapter = new PrismaPg(pool);
+* const prisma = new PrismaClient({ adapter });
+* ```
+*/
+const createPool = async (options = {}) => {
+	const { dataDir, extensions, max = 5 } = options;
+	const ownsInstance = !options.pglite;
+	const pglite = options.pglite ?? new _electric_sql_pglite.PGlite(dataDir, extensions ? { extensions } : void 0);
+	await pglite.waitReady;
+	const sessionLock = new SessionLock();
+	const BridgedClient = class extends Client {
+		constructor(config) {
+			super({
+				...typeof config === "string" ? { connectionString: config } : config ?? {},
+				user: "postgres",
+				database: "postgres",
+				stream: (() => new PGliteBridge(pglite, sessionLock))
+			});
+		}
+	};
+	const pool = new Pool({
+		Client: BridgedClient,
+		max
+	});
+	const close = async () => {
+		await pool.end();
+		if (ownsInstance) await pglite.close();
+	};
+	return {
+		pool,
+		pglite,
+		close
+	};
 };
-
-// src/create-pglite-adapter.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_adapter_pg = require("@prisma/adapter-pg");
-var SNAPSHOT_SCHEMA = "_pglite_snapshot";
-var discoverMigrationsPath = async (configRoot) => {
-  try {
-    const { loadConfigFromFile } = await import("@prisma/config");
-    const { config, error } = await loadConfigFromFile({ configRoot: configRoot ?? process.cwd() });
-    if (error) return null;
-    if (config.migrations?.path) return config.migrations.path;
-    const schemaPath = config.schema;
-    if (schemaPath) return (0, import_node_path.join)((0, import_node_path.dirname)(schemaPath), "migrations");
-    return null;
-  } catch {
-    return null;
-  }
+//#endregion
+//#region src/create-pglite-adapter.ts
+/**
+* Creates a Prisma adapter backed by in-process PGlite.
+*
+* No TCP, no Docker, no worker threads — everything runs in the same process.
+* Works for testing, development, seeding, and scripts.
+*
+* ```typescript
+* import { createPgliteAdapter } from 'prisma-pglite-bridge';
+* import { PrismaClient } from '@prisma/client';
+*
+* const { adapter, resetDb } = await createPgliteAdapter();
+* const prisma = new PrismaClient({ adapter });
+*
+* beforeEach(() => resetDb());
+* ```
+*/
+const SNAPSHOT_SCHEMA = "_pglite_snapshot";
+/**
+* Discover the migrations directory via Prisma's config API.
+* Uses the same resolution as `prisma migrate dev` — reads prisma.config.ts,
+* resolves paths relative to config file location.
+*
+* Returns null if @prisma/config is not available or config cannot be loaded.
+*/
+const discoverMigrationsPath = async (configRoot) => {
+	try {
+		const { loadConfigFromFile } = await import("@prisma/config");
+		const { config, error } = await loadConfigFromFile({ configRoot: configRoot ?? process.cwd() });
+		if (error) return null;
+		if (config.migrations?.path) return config.migrations.path;
+		const schemaPath = config.schema;
+		if (schemaPath) return (0, node_path.join)((0, node_path.dirname)(schemaPath), "migrations");
+		return null;
+	} catch {
+		return null;
+	}
 };
-var tryReadMigrationFiles = (migrationsPath) => {
-  if (!(0, import_node_fs.existsSync)(migrationsPath)) return null;
-  const dirs = (0, import_node_fs.readdirSync)(migrationsPath).filter((d) => (0, import_node_fs.statSync)((0, import_node_path.join)(migrationsPath, d)).isDirectory()).sort();
-  const sqlParts = [];
-  for (const dir of dirs) {
-    const sqlPath = (0, import_node_path.join)(migrationsPath, dir, "migration.sql");
-    if ((0, import_node_fs.existsSync)(sqlPath)) {
-      sqlParts.push((0, import_node_fs.readFileSync)(sqlPath, "utf8"));
-    }
-  }
-  return sqlParts.length > 0 ? sqlParts.join("\n") : null;
+/**
+* Read migration SQL files from a migrations directory in directory order.
+* Returns null if the directory doesn't exist or has no migration files.
+*/
+const tryReadMigrationFiles = (migrationsPath) => {
+	if (!(0, node_fs.existsSync)(migrationsPath)) return null;
+	const dirs = (0, node_fs.readdirSync)(migrationsPath).filter((d) => (0, node_fs.statSync)((0, node_path.join)(migrationsPath, d)).isDirectory()).sort();
+	const sqlParts = [];
+	for (const dir of dirs) {
+		const sqlPath = (0, node_path.join)(migrationsPath, dir, "migration.sql");
+		if ((0, node_fs.existsSync)(sqlPath)) sqlParts.push((0, node_fs.readFileSync)(sqlPath, "utf8"));
+	}
+	return sqlParts.length > 0 ? sqlParts.join("\n") : null;
 };
-var resolveSQL = async (options) => {
-  if (options.sql) return options.sql;
-  if (options.migrationsPath) {
-    const sql = tryReadMigrationFiles(options.migrationsPath);
-    if (sql) return sql;
-    throw new Error(
-      `No migration.sql files found in ${options.migrationsPath}. Run \`prisma migrate dev\` to generate migration files.`
-    );
-  }
-  const migrationsPath = await discoverMigrationsPath(options.configRoot);
-  if (migrationsPath) {
-    const sql = tryReadMigrationFiles(migrationsPath);
-    if (sql) return sql;
-  }
-  throw new Error(
-    "No migration files found. Run `prisma migrate dev` to generate them, or pass pre-generated SQL via the `sql` option."
-  );
+/**
+* Resolve schema SQL. Priority:
+*   1. Explicit `sql` option — use directly
+*   2. Explicit `migrationsPath` — read migration files
+*   3. Auto-discovered migrations (via prisma.config.ts) — read migration files
+*   4. Error — tell the user to generate migration files
+*/
+const resolveSQL = async (options) => {
+	if (options.sql) return options.sql;
+	if (options.migrationsPath) {
+		const sql = tryReadMigrationFiles(options.migrationsPath);
+		if (sql) return sql;
+		throw new Error(`No migration.sql files found in ${options.migrationsPath}. Run \`prisma migrate dev\` to generate migration files.`);
+	}
+	const migrationsPath = await discoverMigrationsPath(options.configRoot);
+	if (migrationsPath) {
+		const sql = tryReadMigrationFiles(migrationsPath);
+		if (sql) return sql;
+	}
+	throw new Error("No migration files found. Run `prisma migrate dev` to generate them, or pass pre-generated SQL via the `sql` option.");
 };
-var createPgliteAdapter = async (options = {}) => {
-  const sql = await resolveSQL(options);
-  const {
-    pool,
-    pglite,
-    close: poolClose
-  } = await createPool({
-    dataDir: options.dataDir,
-    extensions: options.extensions,
-    max: options.max
-  });
-  try {
-    await pglite.exec(sql);
-  } catch (err) {
-    throw new Error("Failed to apply schema SQL to PGlite. Check your schema or migration files.", {
-      cause: err
-    });
-  }
-  const adapter = new import_adapter_pg.PrismaPg(pool);
-  let cachedTables = null;
-  let hasSnapshot = false;
-  const discoverTables = async () => {
-    if (cachedTables !== null) return cachedTables;
-    const { rows } = await pglite.query(
-      `SELECT quote_ident(schemaname) || '.' || quote_ident(tablename) AS qualified
+/**
+* Creates a Prisma adapter backed by an in-process PGlite instance.
+*
+* Applies the schema and returns a ready-to-use adapter + a `resetDb`
+* function for clearing tables between tests.
+*/
+const createPgliteAdapter = async (options = {}) => {
+	const sql = await resolveSQL(options);
+	const { pool, pglite, close: poolClose } = await createPool({
+		dataDir: options.dataDir,
+		extensions: options.extensions,
+		max: options.max
+	});
+	try {
+		await pglite.exec(sql);
+	} catch (err) {
+		throw new Error("Failed to apply schema SQL to PGlite. Check your schema or migration files.", { cause: err });
+	}
+	const adapter = new _prisma_adapter_pg.PrismaPg(pool);
+	let cachedTables = null;
+	let hasSnapshot = false;
+	const discoverTables = async () => {
+		if (cachedTables !== null) return cachedTables;
+		const { rows } = await pglite.query(`SELECT quote_ident(schemaname) || '.' || quote_ident(tablename) AS qualified
        FROM pg_tables
        WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
        AND schemaname != '${SNAPSHOT_SCHEMA}'
-       AND tablename NOT LIKE '_prisma%'`
-    );
-    cachedTables = rows.length > 0 ? rows.map((r) => r.qualified).join(", ") : "";
-    return cachedTables;
-  };
-  const snapshotDb = async () => {
-    await pglite.exec(`DROP SCHEMA IF EXISTS "${SNAPSHOT_SCHEMA}" CASCADE`);
-    await pglite.exec(`CREATE SCHEMA "${SNAPSHOT_SCHEMA}"`);
-    const { rows: tables } = await pglite.query(
-      `SELECT quote_ident(tablename) AS tablename FROM pg_tables
+       AND tablename NOT LIKE '_prisma%'`);
+		cachedTables = rows.length > 0 ? rows.map((r) => r.qualified).join(", ") : "";
+		return cachedTables;
+	};
+	const snapshotDb = async () => {
+		await pglite.exec(`DROP SCHEMA IF EXISTS "${SNAPSHOT_SCHEMA}" CASCADE`);
+		await pglite.exec(`CREATE SCHEMA "${SNAPSHOT_SCHEMA}"`);
+		const { rows: tables } = await pglite.query(`SELECT quote_ident(tablename) AS tablename FROM pg_tables
        WHERE schemaname = 'public'
-       AND tablename NOT LIKE '_prisma%'`
-    );
-    for (const { tablename } of tables) {
-      await pglite.exec(
-        `CREATE TABLE "${SNAPSHOT_SCHEMA}".${tablename} AS SELECT * FROM public.${tablename}`
-      );
-    }
-    const { rows: seqs } = await pglite.query(
-      `SELECT quote_literal(sequencename) AS name, last_value::text AS value
-       FROM pg_sequences WHERE schemaname = 'public' AND last_value IS NOT NULL`
-    );
-    await pglite.exec(`CREATE TABLE "${SNAPSHOT_SCHEMA}".__sequences (name text, value bigint)`);
-    for (const { name, value } of seqs) {
-      await pglite.exec(`INSERT INTO "${SNAPSHOT_SCHEMA}".__sequences VALUES (${name}, ${value})`);
-    }
-    hasSnapshot = true;
-  };
-  const resetSnapshot = async () => {
-    hasSnapshot = false;
-    await pglite.exec(`DROP SCHEMA IF EXISTS "${SNAPSHOT_SCHEMA}" CASCADE`);
-  };
-  const resetDb = async () => {
-    const tables = await discoverTables();
-    if (hasSnapshot && tables) {
-      try {
-        await pglite.exec("SET session_replication_role = replica");
-        await pglite.exec(`TRUNCATE TABLE ${tables} CASCADE`);
-        const { rows: snapshotTables } = await pglite.query(
-          `SELECT quote_ident(tablename) AS tablename FROM pg_tables
+       AND tablename NOT LIKE '_prisma%'`);
+		for (const { tablename } of tables) await pglite.exec(`CREATE TABLE "${SNAPSHOT_SCHEMA}".${tablename} AS SELECT * FROM public.${tablename}`);
+		const { rows: seqs } = await pglite.query(`SELECT quote_literal(sequencename) AS name, last_value::text AS value
+       FROM pg_sequences WHERE schemaname = 'public' AND last_value IS NOT NULL`);
+		await pglite.exec(`CREATE TABLE "${SNAPSHOT_SCHEMA}".__sequences (name text, value bigint)`);
+		for (const { name, value } of seqs) await pglite.exec(`INSERT INTO "${SNAPSHOT_SCHEMA}".__sequences VALUES (${name}, ${value})`);
+		hasSnapshot = true;
+	};
+	const resetSnapshot = async () => {
+		hasSnapshot = false;
+		await pglite.exec(`DROP SCHEMA IF EXISTS "${SNAPSHOT_SCHEMA}" CASCADE`);
+	};
+	const resetDb = async () => {
+		const tables = await discoverTables();
+		if (hasSnapshot && tables) {
+			try {
+				await pglite.exec("SET session_replication_role = replica");
+				await pglite.exec(`TRUNCATE TABLE ${tables} CASCADE`);
+				const { rows: snapshotTables } = await pglite.query(`SELECT quote_ident(tablename) AS tablename FROM pg_tables
            WHERE schemaname = '${SNAPSHOT_SCHEMA}'
-           AND tablename != '__sequences'`
-        );
-        for (const { tablename } of snapshotTables) {
-          await pglite.exec(
-            `INSERT INTO public.${tablename} SELECT * FROM "${SNAPSHOT_SCHEMA}".${tablename}`
-          );
-        }
-      } finally {
-        await pglite.exec("SET session_replication_role = DEFAULT");
-      }
-      const { rows: seqs } = await pglite.query(
-        `SELECT quote_literal(name) AS name, value::text AS value FROM "${SNAPSHOT_SCHEMA}".__sequences`
-      );
-      for (const { name, value } of seqs) {
-        await pglite.exec(`SELECT setval(${name}, ${value})`);
-      }
-    } else if (tables) {
-      try {
-        await pglite.exec("SET session_replication_role = replica");
-        await pglite.exec(`TRUNCATE TABLE ${tables} CASCADE`);
-      } finally {
-        await pglite.exec("SET session_replication_role = DEFAULT");
-      }
-    }
-    await pglite.exec("RESET ALL");
-    await pglite.exec("DEALLOCATE ALL");
-  };
-  return { adapter, pglite, resetDb, snapshotDb, resetSnapshot, close: poolClose };
+           AND tablename != '__sequences'`);
+				for (const { tablename } of snapshotTables) await pglite.exec(`INSERT INTO public.${tablename} SELECT * FROM "${SNAPSHOT_SCHEMA}".${tablename}`);
+			} finally {
+				await pglite.exec("SET session_replication_role = DEFAULT");
+			}
+			const { rows: seqs } = await pglite.query(`SELECT quote_literal(name) AS name, value::text AS value FROM "${SNAPSHOT_SCHEMA}".__sequences`);
+			for (const { name, value } of seqs) await pglite.exec(`SELECT setval(${name}, ${value})`);
+		} else if (tables) try {
+			await pglite.exec("SET session_replication_role = replica");
+			await pglite.exec(`TRUNCATE TABLE ${tables} CASCADE`);
+		} finally {
+			await pglite.exec("SET session_replication_role = DEFAULT");
+		}
+		await pglite.exec("RESET ALL");
+		await pglite.exec("DEALLOCATE ALL");
+	};
+	return {
+		adapter,
+		pglite,
+		resetDb,
+		snapshotDb,
+		resetSnapshot,
+		close: poolClose
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PGliteBridge,
-  createPgliteAdapter,
-  createPool
-});
+//#endregion
+exports.PGliteBridge = PGliteBridge;
+exports.createPgliteAdapter = createPgliteAdapter;
+exports.createPool = createPool;
+
 //# sourceMappingURL=index.cjs.map