prisma-pglite-bridge 0.3.0 → 0.3.2

package/dist/index.d.cts

@@ -1,246 +1,207 @@
-import { Duplex } from 'node:stream';
-import * as _electric_sql_pglite from '@electric-sql/pglite';
-import { PGlite, Extensions } from '@electric-sql/pglite';
-import pg from 'pg';
-import { PrismaPg } from '@prisma/adapter-pg';
+import * as _$_electric_sql_pglite0 from "@electric-sql/pglite";
+import { Extensions, PGlite } from "@electric-sql/pglite";
+import { PrismaPg } from "@prisma/adapter-pg";
+import pg from "pg";
+import { Duplex } from "node:stream";
 
-/**
- * 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.
- */
-/** Opaque bridge identity token */
-type BridgeId = symbol;
-declare class SessionLock {
-    private owner;
-    private waitQueue;
-    /**
-     * Acquire access to PGlite. Resolves immediately if no transaction is
-     * active or if this bridge owns the current transaction. Queues otherwise.
-     */
-    acquire(id: BridgeId): Promise<void>;
-    /**
-     * Update session state based on the ReadyForQuery status byte.
-     * Call after every PGlite response that contains RFQ.
-     */
-    updateStatus(id: BridgeId, status: number): void;
-    /**
-     * Release ownership (e.g., when a bridge is destroyed mid-transaction).
-     */
-    release(id: BridgeId): void;
-    private drainWaitQueue;
+//#region src/create-pglite-adapter.d.ts
+interface CreatePgliteAdapterOptions {
+  /** Path to prisma/migrations/ directory (auto-discovered via prisma.config.ts if omitted) */
+  migrationsPath?: string;
+  /** Pre-generated SQL to apply instead of auto-generating from schema */
+  sql?: string;
+  /** Root directory for prisma.config.ts discovery (default: process.cwd()). Set this in monorepos where tests run from the workspace root. */
+  configRoot?: string;
+  /** PGlite data directory. Omit for in-memory. */
+  dataDir?: string;
+  /** PGlite extensions (e.g., `{ uuid_ossp: uuidOssp() }`) */
+  extensions?: _$_electric_sql_pglite0.Extensions;
+  /** Maximum pool connections (default: 5) */
+  max?: number;
 }
-
-/**
- * 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.
- */
-
-/**
- * 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),
- * });
- * ```
- */
-declare class PGliteBridge extends Duplex {
-    private readonly pglite;
-    private readonly sessionLock;
-    private readonly bridgeId;
-    /** Incoming bytes not yet compacted into buf */
-    private pending;
-    private pendingLen;
-    /** Compacted input buffer for message framing */
-    private buf;
-    private phase;
-    private draining;
-    private tornDown;
-    /** Callbacks waiting for drain to process their data */
-    private drainQueue;
-    /** Buffered EQP messages awaiting Sync */
-    private pipeline;
-    private pipelineLen;
-    constructor(pglite: PGlite, sessionLock?: SessionLock);
-    connect(): this;
-    setKeepAlive(): this;
-    setNoDelay(): this;
-    setTimeout(): this;
-    ref(): this;
-    unref(): this;
-    _read(): void;
-    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    /** Handles corked batches — pg.Client corks during prepared queries (P+B+D+E+S) */
-    _writev(chunks: Array<{
-        chunk: Buffer;
-        encoding: BufferEncoding;
-    }>, callback: (error?: Error | null) => void): void;
-    _final(callback: (error?: Error | null) => void): void;
-    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
-    /** Merge pending chunks into buf only when needed for framing */
-    private compact;
-    /**
-     * Enqueue a write callback and start draining if not already running.
-     * The callback is NOT called until drain has processed the data.
-     */
-    private enqueue;
-    /**
-     * Process all pending data, looping until no new data arrives.
-     * Fires all queued callbacks on completion or error.
-     */
-    private drain;
-    /**
-     * 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.
-     */
-    private processPreStartup;
-    /**
-     * 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).
-     */
-    private processMessages;
-    /**
-     * 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.
-     */
-    private flushPipeline;
-    /**
-     * 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.
-     */
-    private execAndPush;
-    private acquireSession;
-    private trackSessionStatus;
+/** Clear all user tables. Call in `beforeEach` for per-test isolation. */
+type ResetDbFn = () => Promise<void>;
+type SnapshotDbFn = () => Promise<void>;
+type ResetSnapshotFn = () => Promise<void>;
+interface PgliteAdapter {
+  /** Prisma adapter — pass directly to `new PrismaClient({ adapter })` */
+  adapter: PrismaPg;
+  /** The underlying PGlite instance for direct SQL, snapshots, or extensions. */
+  pglite: _$_electric_sql_pglite0.PGlite;
+  /** Clear all user tables. Call in `beforeEach` for per-test isolation. */
+  resetDb: ResetDbFn;
+  /** Snapshot current DB state. Subsequent `resetDb` calls restore to this snapshot. */
+  snapshotDb: SnapshotDbFn;
+  /** Discard the current snapshot. Subsequent `resetDb` calls truncate to empty. */
+  resetSnapshot: ResetSnapshotFn;
+  /** Shut down pool and PGlite. Not needed in tests (process exit handles it). */
+  close: () => Promise<void>;
 }
-
 /**
- * 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.
- */
-
+* 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.
+*/
+declare const createPgliteAdapter: (options?: CreatePgliteAdapterOptions) => Promise<PgliteAdapter>;
+//#endregion
+//#region src/create-pool.d.ts
 interface CreatePoolOptions {
-    /** PGlite data directory. Omit for in-memory. */
-    dataDir?: string;
-    /** PGlite extensions (e.g., `{ uuid_ossp: uuidOssp() }`) */
-    extensions?: Extensions;
-    /** Maximum pool connections (default: 5) */
-    max?: number;
-    /** Existing PGlite instance to use instead of creating one */
-    pglite?: PGlite;
+  /** PGlite data directory. Omit for in-memory. */
+  dataDir?: string;
+  /** PGlite extensions (e.g., `{ uuid_ossp: uuidOssp() }`) */
+  extensions?: Extensions;
+  /** Maximum pool connections (default: 5) */
+  max?: number;
+  /** Existing PGlite instance to use instead of creating one */
+  pglite?: PGlite;
 }
 interface PoolResult {
-    /** pg.Pool backed by PGlite — pass to PrismaPg */
-    pool: pg.Pool;
-    /** The underlying PGlite instance */
-    pglite: PGlite;
-    /** Shut down pool and PGlite */
-    close: () => Promise<void>;
+  /** pg.Pool backed by PGlite — pass to PrismaPg */
+  pool: pg.Pool;
+  /** The underlying PGlite instance */
+  pglite: PGlite;
+  /** Shut down pool and PGlite */
+  close: () => Promise<void>;
 }
 /**
- * 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 });
- * ```
- */
+* 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 });
+* ```
+*/
 declare const createPool: (options?: CreatePoolOptions) => Promise<PoolResult>;
-
-interface CreatePgliteAdapterOptions {
-    /** Path to prisma/migrations/ directory (auto-discovered via prisma.config.ts if omitted) */
-    migrationsPath?: string;
-    /** Pre-generated SQL to apply instead of auto-generating from schema */
-    sql?: string;
-    /** Root directory for prisma.config.ts discovery (default: process.cwd()). Set this in monorepos where tests run from the workspace root. */
-    configRoot?: string;
-    /** PGlite data directory. Omit for in-memory. */
-    dataDir?: string;
-    /** PGlite extensions (e.g., `{ uuid_ossp: uuidOssp() }`) */
-    extensions?: _electric_sql_pglite.Extensions;
-    /** Maximum pool connections (default: 5) */
-    max?: number;
-}
-/** Clear all user tables. Call in `beforeEach` for per-test isolation. */
-type ResetDbFn = () => Promise<void>;
-type SnapshotDbFn = () => Promise<void>;
-type ResetSnapshotFn = () => Promise<void>;
-interface PgliteAdapter {
-    /** Prisma adapter — pass directly to `new PrismaClient({ adapter })` */
-    adapter: PrismaPg;
-    /** The underlying PGlite instance for direct SQL, snapshots, or extensions. */
-    pglite: _electric_sql_pglite.PGlite;
-    /** Clear all user tables. Call in `beforeEach` for per-test isolation. */
-    resetDb: ResetDbFn;
-    /** Snapshot current DB state. Subsequent `resetDb` calls restore to this snapshot. */
-    snapshotDb: SnapshotDbFn;
-    /** Discard the current snapshot. Subsequent `resetDb` calls truncate to empty. */
-    resetSnapshot: ResetSnapshotFn;
-    /** Shut down pool and PGlite. Not needed in tests (process exit handles it). */
-    close: () => Promise<void>;
+//#endregion
+//#region src/session-lock.d.ts
+/** Opaque bridge identity token */
+type BridgeId = symbol;
+declare class SessionLock {
+  private owner;
+  private waitQueue;
+  /**
+  * Acquire access to PGlite. Resolves immediately if no transaction is
+  * active or if this bridge owns the current transaction. Queues otherwise.
+  */
+  acquire(id: BridgeId): Promise<void>;
+  /**
+  * Update session state based on the ReadyForQuery status byte.
+  * Call after every PGlite response that contains RFQ.
+  */
+  updateStatus(id: BridgeId, status: number): void;
+  /**
+  * Release ownership (e.g., when a bridge is destroyed mid-transaction).
+  */
+  release(id: BridgeId): void;
+  private drainWaitQueue;
 }
+//#endregion
+//#region src/pglite-bridge.d.ts
 /**
- * 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.
- */
-declare const createPgliteAdapter: (options?: CreatePgliteAdapterOptions) => Promise<PgliteAdapter>;
-
-export { type CreatePgliteAdapterOptions, type CreatePoolOptions, PGliteBridge, type PgliteAdapter, type PoolResult, type ResetDbFn, type ResetSnapshotFn, type SnapshotDbFn, createPgliteAdapter, createPool };
+* 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),
+* });
+* ```
+*/
+declare class PGliteBridge extends Duplex {
+  private readonly pglite;
+  private readonly sessionLock;
+  private readonly bridgeId;
+  /** Incoming bytes not yet compacted into buf */
+  private pending;
+  private pendingLen;
+  /** Compacted input buffer for message framing */
+  private buf;
+  private phase;
+  private draining;
+  private tornDown;
+  /** Callbacks waiting for drain to process their data */
+  private drainQueue;
+  /** Buffered EQP messages awaiting Sync */
+  private pipeline;
+  private pipelineLen;
+  constructor(pglite: PGlite, sessionLock?: SessionLock);
+  connect(): this;
+  setKeepAlive(): this;
+  setNoDelay(): this;
+  setTimeout(): this;
+  ref(): this;
+  unref(): this;
+  override _read(): void;
+  override _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  /** Handles corked batches — pg.Client corks during prepared queries (P+B+D+E+S) */
+  override _writev(chunks: Array<{
+    chunk: Buffer;
+    encoding: BufferEncoding;
+  }>, callback: (error?: Error | null) => void): void;
+  override _final(callback: (error?: Error | null) => void): void;
+  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  /** Merge pending chunks into buf only when needed for framing */
+  private compact;
+  /**
+  * Enqueue a write callback and start draining if not already running.
+  * The callback is NOT called until drain has processed the data.
+  */
+  private enqueue;
+  /**
+  * Process all pending data, looping until no new data arrives.
+  * Fires all queued callbacks on completion or error.
+  */
+  private drain;
+  /**
+  * 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.
+  */
+  private processPreStartup;
+  /**
+  * 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).
+  */
+  private processMessages;
+  /**
+  * 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.
+  */
+  private flushPipeline;
+  /**
+  * 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.
+  */
+  private execAndPush;
+  private acquireSession;
+  private trackSessionStatus;
+}
+//#endregion
+export { type CreatePgliteAdapterOptions, type CreatePoolOptions, PGliteBridge, type PgliteAdapter, type PoolResult, type ResetDbFn, type ResetSnapshotFn, SessionLock, type SnapshotDbFn, createPgliteAdapter, createPool };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,207 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import * as _$_electric_sql_pglite0 from "@electric-sql/pglite";
+import { Extensions, PGlite } from "@electric-sql/pglite";
+import pg from "pg";
+import { Duplex } from "node:stream";
+
+//#region src/create-pglite-adapter.d.ts
+interface CreatePgliteAdapterOptions {
+  /** Path to prisma/migrations/ directory (auto-discovered via prisma.config.ts if omitted) */
+  migrationsPath?: string;
+  /** Pre-generated SQL to apply instead of auto-generating from schema */
+  sql?: string;
+  /** Root directory for prisma.config.ts discovery (default: process.cwd()). Set this in monorepos where tests run from the workspace root. */
+  configRoot?: string;
+  /** PGlite data directory. Omit for in-memory. */
+  dataDir?: string;
+  /** PGlite extensions (e.g., `{ uuid_ossp: uuidOssp() }`) */
+  extensions?: _$_electric_sql_pglite0.Extensions;
+  /** Maximum pool connections (default: 5) */
+  max?: number;
+}
+/** Clear all user tables. Call in `beforeEach` for per-test isolation. */
+type ResetDbFn = () => Promise<void>;
+type SnapshotDbFn = () => Promise<void>;
+type ResetSnapshotFn = () => Promise<void>;
+interface PgliteAdapter {
+  /** Prisma adapter — pass directly to `new PrismaClient({ adapter })` */
+  adapter: PrismaPg;
+  /** The underlying PGlite instance for direct SQL, snapshots, or extensions. */
+  pglite: _$_electric_sql_pglite0.PGlite;
+  /** Clear all user tables. Call in `beforeEach` for per-test isolation. */
+  resetDb: ResetDbFn;
+  /** Snapshot current DB state. Subsequent `resetDb` calls restore to this snapshot. */
+  snapshotDb: SnapshotDbFn;
+  /** Discard the current snapshot. Subsequent `resetDb` calls truncate to empty. */
+  resetSnapshot: ResetSnapshotFn;
+  /** Shut down pool and PGlite. Not needed in tests (process exit handles it). */
+  close: () => Promise<void>;
+}
+/**
+* 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.
+*/
+declare const createPgliteAdapter: (options?: CreatePgliteAdapterOptions) => Promise<PgliteAdapter>;
+//#endregion
+//#region src/create-pool.d.ts
+interface CreatePoolOptions {
+  /** PGlite data directory. Omit for in-memory. */
+  dataDir?: string;
+  /** PGlite extensions (e.g., `{ uuid_ossp: uuidOssp() }`) */
+  extensions?: Extensions;
+  /** Maximum pool connections (default: 5) */
+  max?: number;
+  /** Existing PGlite instance to use instead of creating one */
+  pglite?: PGlite;
+}
+interface PoolResult {
+  /** pg.Pool backed by PGlite — pass to PrismaPg */
+  pool: pg.Pool;
+  /** The underlying PGlite instance */
+  pglite: PGlite;
+  /** Shut down pool and PGlite */
+  close: () => Promise<void>;
+}
+/**
+* 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 });
+* ```
+*/
+declare const createPool: (options?: CreatePoolOptions) => Promise<PoolResult>;
+//#endregion
+//#region src/session-lock.d.ts
+/** Opaque bridge identity token */
+type BridgeId = symbol;
+declare class SessionLock {
+  private owner;
+  private waitQueue;
+  /**
+  * Acquire access to PGlite. Resolves immediately if no transaction is
+  * active or if this bridge owns the current transaction. Queues otherwise.
+  */
+  acquire(id: BridgeId): Promise<void>;
+  /**
+  * Update session state based on the ReadyForQuery status byte.
+  * Call after every PGlite response that contains RFQ.
+  */
+  updateStatus(id: BridgeId, status: number): void;
+  /**
+  * Release ownership (e.g., when a bridge is destroyed mid-transaction).
+  */
+  release(id: BridgeId): void;
+  private drainWaitQueue;
+}
+//#endregion
+//#region src/pglite-bridge.d.ts
+/**
+* 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),
+* });
+* ```
+*/
+declare class PGliteBridge extends Duplex {
+  private readonly pglite;
+  private readonly sessionLock;
+  private readonly bridgeId;
+  /** Incoming bytes not yet compacted into buf */
+  private pending;
+  private pendingLen;
+  /** Compacted input buffer for message framing */
+  private buf;
+  private phase;
+  private draining;
+  private tornDown;
+  /** Callbacks waiting for drain to process their data */
+  private drainQueue;
+  /** Buffered EQP messages awaiting Sync */
+  private pipeline;
+  private pipelineLen;
+  constructor(pglite: PGlite, sessionLock?: SessionLock);
+  connect(): this;
+  setKeepAlive(): this;
+  setNoDelay(): this;
+  setTimeout(): this;
+  ref(): this;
+  unref(): this;
+  override _read(): void;
+  override _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  /** Handles corked batches — pg.Client corks during prepared queries (P+B+D+E+S) */
+  override _writev(chunks: Array<{
+    chunk: Buffer;
+    encoding: BufferEncoding;
+  }>, callback: (error?: Error | null) => void): void;
+  override _final(callback: (error?: Error | null) => void): void;
+  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  /** Merge pending chunks into buf only when needed for framing */
+  private compact;
+  /**
+  * Enqueue a write callback and start draining if not already running.
+  * The callback is NOT called until drain has processed the data.
+  */
+  private enqueue;
+  /**
+  * Process all pending data, looping until no new data arrives.
+  * Fires all queued callbacks on completion or error.
+  */
+  private drain;
+  /**
+  * 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.
+  */
+  private processPreStartup;
+  /**
+  * 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).
+  */
+  private processMessages;
+  /**
+  * 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.
+  */
+  private flushPipeline;
+  /**
+  * 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.
+  */
+  private execAndPush;
+  private acquireSession;
+  private trackSessionStatus;
+}
+//#endregion
+export { type CreatePgliteAdapterOptions, type CreatePoolOptions, PGliteBridge, type PgliteAdapter, type PoolResult, type ResetDbFn, type ResetSnapshotFn, SessionLock, type SnapshotDbFn, createPgliteAdapter, createPool };
+//# sourceMappingURL=index.d.mts.map