okmodel 0.6.0 → 0.8.0

package/dist/adapters/capabilities.d.ts

@@ -5,6 +5,9 @@
  * OKM11xx for a driver that lacks a flag: OKM1110 is the engine-version gate,
  * and OKM1801 is a dialect mismatch. This module does not invent a code and
  * does not throw for a missing flag.
+ *
+ * `stream` means the driver can open a server cursor. `.stream()` does not
+ * read it. That method walks keyset batches on every driver.
  */
 import type { DriverCapabilities } from "../contracts/driver.js";
 /** Capability names a caller can read. */
@@ -75,6 +78,38 @@ export declare const BUNSQL_CAPABILITIES: {
     readonly prepared: "unnamed";
     readonly describe: false;
 };
+/**
+ * Neon WebSocket pool execution flags.
+ *
+ * Interactive transactions pass on a direct connection. `stream`, `listen`,
+ * `cancel`, and `describe` stay false: a server cursor, `LISTEN`, and a
+ * side-channel cancel are session features the pooler does not keep, and the
+ * client has no describe API. Statements use the unnamed protocol.
+ * `prepared: "named"` is not for a transaction-mode pooler.
+ */
+export declare const NEON_WEBSOCKET_CAPABILITIES: {
+    readonly transactions: "interactive";
+    readonly stream: false;
+    readonly listen: false;
+    readonly cancel: false;
+    readonly prepared: "unnamed";
+    readonly describe: false;
+};
+/**
+ * Neon HTTP execution flags.
+ *
+ * One request is one statement. `sql.transaction` is the atomic batch.
+ * There is no interactive `tx()`, no `LISTEN`, no server cursor, and no
+ * cancel of a statement the server has already started.
+ */
+export declare const NEON_HTTP_CAPABILITIES: {
+    readonly transactions: "batch";
+    readonly stream: false;
+    readonly listen: false;
+    readonly cancel: false;
+    readonly prepared: "none";
+    readonly describe: false;
+};
 /**
  * Reads one capability flag.
  *

package/dist/adapters/failure.d.ts

@@ -13,10 +13,21 @@ export declare function driverErrors(): Promise<ErrorModule>;
 /**
  * Rejects with a closed-pool {@link import("./error.js").DriverError}.
  *
- * @param message - Error text
+ * The text and SQLSTATE `08006` load with the lazy error module. Classification
+ * reads the SQLSTATE. The message is "The pool is closed."
+ *
+ * @returns A rejected promise
+ */
+export declare function rejectClosed(): Promise<never>;
+/**
+ * Rejects with OKM1120 when a driver cannot cancel a positive timeout.
+ *
+ * The message stays `timeout`. Kind stays `invalid`. Bun.sql, PGlite, and Neon call
+ * this. Other drivers do not, so their connect graphs omit it.
+ *
  * @returns A rejected promise
  */
-export declare function rejectClosed(message?: string): Promise<never>;
+export declare function rejectUncancellable(): Promise<never>;
 /**
  * Rejects with kind `cancelled`.
  *

package/dist/adapters/lazy-errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Error text a connect entry does not need until a call fails.
+ *
+ * Loaded on the first closed pool or on a positive `timeout` for a driver
+ * that cannot cancel. A successful execute does not import this module.
+ */
+/**
+ * OKM1120 for a positive `timeout` on Bun.sql or PGlite.
+ *
+ * Kind stays `invalid`. The message stays `timeout` (D224, D239).
+ *
+ * @returns A rejected promise
+ */
+export declare function refused(): Promise<never>;
+/**
+ * A pool that has already been closed.
+ *
+ * The message is for people. Classification reads SQLSTATE `08006`.
+ *
+ * @returns A rejected promise
+ */
+export declare function closed(): Promise<never>;

package/dist/adapters/pg/bun-sql.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The slice of Bun.sql this adapter uses.
+ *
+ * `bun` is the runtime, not an npm package, and it ships no types. The
+ * published declarations name these types instead of importing `bun`, so a
+ * consumer can typecheck `okmodel/pg/bun` without `bun-types`.
+ */
+/** A pending query. `raw()` asks for rows as arrays. */
+export interface SQLQuery extends Promise<unknown> {
+    /** Rows as arrays instead of objects. */
+    raw(): SQLQuery;
+}
+/** One pooled Bun.sql client. */
+export interface SQL {
+    /**
+     * Runs a statement.
+     *
+     * @param text - SQL text
+     * @param values - Positional parameters
+     */
+    unsafe(text: string, values?: readonly unknown[]): SQLQuery;
+    /**
+     * Checks out one connection.
+     *
+     * @param options - `signal` aborts the wait
+     */
+    reserve(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<ReservedSQL>;
+    /** Closes the pool. */
+    close(): Promise<void>;
+    /**
+     * Subscribes to one `LISTEN` channel.
+     *
+     * @param channel - Channel name
+     * @param onnotify - Payload callback
+     */
+    listen(channel: string, onnotify: (payload: string) => void): Promise<SQLListen>;
+}
+/** A `LISTEN` registration. */
+export interface SQLListen {
+    /** Drops this registration. */
+    unlisten(): Promise<void>;
+}
+/**
+ * One connection reserved from {@link SQL.reserve}.
+ *
+ * `release` returns it to the pool.
+ */
+export interface ReservedSQL extends SQL {
+    /** Returns the connection to the pool. */
+    release(): void;
+}

package/dist/adapters/pg/bunsql-extra.d.ts

@@ -1,9 +1,11 @@
 /**
  * Reserved connections for Bun.sql.
  *
- * Loaded on the first reserve, batch, or stream. A read does not use it.
+ * Loaded on the first reserve, batch, stream, or dead connection. A read that
+ * succeeds does not use it.
  */
-import type { DriverConnection } from "../../contracts/driver.js";
+import type { ReservedSQL, SQL } from "./bun-sql.js";
+import type { DriverConnection, WireValue } from "../../contracts/driver.js";
 import { type HeldPool } from "./bunsql.js";
 /**
  * Checks out one connection and clears it on release.
@@ -14,4 +16,53 @@ import { type HeldPool } from "./bunsql.js";
  * @param held - The pool and its counters
  * @returns A connection the caller must release
  */
-export declare function checkout(held: HeldPool): Promise<DriverConnection>;
+/**
+ * Drops a dead pooled socket, then runs `again` once when that is safe.
+ *
+ * A `57P01` or a socket Bun has already closed is evicted before another
+ * statement can take it. A client read is tried once more when `depth` is 0.
+ * A raw pool retries only when the socket had already closed, or Bun rejected
+ * the statement before the server saw it, so a query killed while it was
+ * running is not started again. `again` does not pass through `recover`.
+ *
+ * @param sql - The pool
+ * @param error - The failure from the first attempt
+ * @param text - Statement text, used to decide the retry
+ * @param depth - Open transaction depth. Above zero, an earlier command was sent
+ * @param clientRead - The pool was opened for a client, which retries a read once
+ * @param closedDuring - `onclose` ran after this statement was sent
+ * @param again - The same statement, on whatever connection the pool hands out next
+ * @returns The retried result, or a rejection of `error`
+ */
+export declare function recover<T>(sql: SQL, error: unknown, text: string, depth: number, clientRead: boolean, closedDuring: boolean, again: () => Promise<T>): Promise<T>;
+/**
+ * Spends a closed socket before the caller's statement is sent.
+ *
+ * @param sql - The pool
+ */
+export declare function drainClosed(sql: SQL): Promise<void>;
+/**
+ * Subscribes on one pooled connection.
+ *
+ * @param sql - The pool
+ * @param parked - Reserved handles to put back first
+ * @param closed - The pool is closed
+ * @param channel - Notify channel
+ * @param onNotify - Payload callback
+ * @returns Stops the subscription
+ */
+export declare function listen(sql: SQL, parked: ReservedSQL[], closed: boolean, channel: string, onNotify: (payload: string) => void): Promise<() => Promise<void>>;
+export declare function checkout(held: HeldPool): Promise<DriverConnection & {
+    evict(): void;
+}>;
+/**
+ * Yields cursor chunks from one checked-out Bun.sql connection.
+ *
+ * @param checkout - Reserves the connection
+ * @param text - Query to stream
+ * @param params - Wire parameters
+ * @returns Chunks of wire rows
+ */
+export declare function streamRows(checkout: () => Promise<DriverConnection & {
+    evict?: () => void;
+}>, text: string, params: readonly WireValue[] | undefined): AsyncIterable<readonly (readonly WireValue[])[]>;

package/dist/adapters/pg/bunsql.d.ts

@@ -9,11 +9,12 @@
  * finished script exits without `close()`. `Query.cancel()` does not abort
  * the backend, so `cancel` is false. Server notices are not surfaced.
  */
-import { SQL, type ReservedSQL } from "bun";
+import type { ReservedSQL, SQL } from "./bun-sql.js";
 import type { DriverPool, DriverPoolConfig, WireValue } from "../../contracts/driver.js";
+import { DriverError } from "../error.js";
 import { noticeBuffer, type WireQuery } from "./session.js";
 export { BUNSQL_CAPABILITIES as capabilities, hasCapability, readCapability, } from "../capabilities.js";
-export { DriverError } from "../error.js";
+export { DriverError };
 /** TLS values Bun.sql accepts that this adapter forwards. */
 export type BunSqlTls = boolean | "disable" | "allow" | "prefer" | "require" | "verify-ca" | "verify-full";
 /** Options for {@link open}. */
@@ -40,7 +41,19 @@ export type HeldPool = {
     readonly counters: Counters;
     readonly notices: ReturnType<typeof noticeBuffer>;
     readonly isClosed: () => boolean;
+    /** Sockets this pool has closed. The count never returns to zero. */
+    readonly closures: () => number;
 };
+/**
+ * Marks a pool opened for a client.
+ *
+ * A client read that finds a dead socket is tried once. A pool from raw
+ * {@link open} is not marked, so a statement the server killed while it was
+ * running is not started again.
+ *
+ * @param pool - The pool `connect` just opened
+ */
+export declare function markClientPool(pool: DriverPool): void;
 /** Pool occupancy. */
 export type Counters = {
     reserved: number;

package/dist/adapters/pg/cursor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Server-side cursor for drivers that stream through a checked-out connection.
+ *
+ * Loaded with the stream chunk. A read does not import this.
+ */
+import type { ExecuteResult, WireValue } from "../../contracts/driver.js";
+/**
+ * Yields cursor chunks from one connection that is already checked out.
+ *
+ * The cursor is session-local. `ROLLBACK` in the end drops it.
+ *
+ * @param run - Executes on the checked-out connection
+ * @param text - Query to stream
+ * @param params - Wire parameters
+ * @returns Chunks of wire rows
+ */
+export declare function cursorStream(run: (text: string, params?: readonly WireValue[]) => Promise<ExecuteResult>, text: string, params: readonly WireValue[] | undefined): AsyncIterable<readonly (readonly WireValue[])[]>;

package/dist/adapters/pg/neon-extra.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Reserved connections for the Neon WebSocket pool.
+ *
+ * Loaded on the first reserve or batch. A read does not use it.
+ */
+import type { DriverConnection } from "../../contracts/driver.js";
+import { type HeldPool } from "./neon.js";
+/**
+ * Checks out one client and clears it on release.
+ *
+ * A client whose connection is gone is destroyed on release, and nothing more
+ * is sent to it. A checked-out client has no pool error listener, so one is
+ * set here: without it a dropped socket is an uncaught `error` event.
+ *
+ * @param held - The pool and its counters
+ * @returns A connection the caller must release
+ */
+export declare function checkout(held: HeldPool): Promise<DriverConnection>;

package/dist/adapters/pg/neon.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Neon adapter (`okmodel/pg/neon`).
+ *
+ * `@neondatabase/serverless` is an optional peer. This module is the only
+ * place that imports it. `mode: "websocket"` (the default) is a pooled
+ * WebSocket client with interactive transactions. `mode: "http"` is one HTTP
+ * request per statement, and `batch` is the driver's non-interactive
+ * transaction. A positive `timeout` is refused: neither mode aborts a
+ * statement the server has already started.
+ *
+ * The first WebSocket `open` sets `webSocketConstructor` only when it is
+ * still unset, so a caller can install one first. A transaction-mode pooler
+ * does not promise session state. One small compute can reuse a backend, so
+ * a custom `SET`, `LISTEN`, or a prepared statement may still be visible.
+ */
+import { Pool, type PoolClient } from "@neondatabase/serverless";
+import type { DriverPool, DriverPoolConfig, WireValue } from "../../contracts/driver.js";
+import { noticeBuffer, type WireQuery } from "./session.js";
+export { NEON_WEBSOCKET_CAPABILITIES as capabilities, NEON_HTTP_CAPABILITIES as httpCapabilities, hasCapability, readCapability, } from "../capabilities.js";
+export { DriverError } from "../error.js";
+/** How {@link open} talks to Neon. */
+export type NeonMode = "websocket" | "http";
+/** Options for {@link open}. */
+export type NeonConfig = DriverPoolConfig & {
+    /** Connection URL for this endpoint. */
+    readonly url: string;
+    /**
+     * `websocket` is a pooled WebSocket client. `http` is one-shot HTTP.
+     *
+     * Omitted means `websocket`.
+     */
+    readonly mode?: NeonMode;
+    /**
+     * Named prepared statements, or the unnamed protocol.
+     *
+     * Unnamed is the default. It stays valid behind a pooler in transaction mode.
+     * `prepared: "named"` is not for transaction-mode poolers. HTTP ignores it.
+     */
+    readonly prepared?: "named" | "unnamed";
+    /** Session search path for every WebSocket connection in the pool. */
+    readonly searchPath?: string;
+};
+/** Pool occupancy. */
+export type Counters = {
+    reserved: number;
+    busy: number;
+    reservedBusy: number;
+    waiting: number;
+};
+/** What a WebSocket checkout needs from the pool that opened it. */
+export type HeldPool = {
+    readonly pool: Pool;
+    readonly acquireMs: number | undefined;
+    readonly counters: Counters;
+    readonly notices: ReturnType<typeof noticeBuffer>;
+    readonly named: boolean;
+    readonly isClosed: () => boolean;
+};
+/** A client that can run one array-mode statement. */
+type Queryable = {
+    query(config: {
+        text: string;
+        values?: readonly WireValue[];
+        rowMode: "array";
+        types: typeof WIRE;
+        name?: string;
+    }): Promise<unknown>;
+};
+declare const WIRE: {
+    getTypeParser(): (value: string) => string;
+};
+/**
+ * Opens a Neon pool for one endpoint.
+ *
+ * WebSocket mode connects once before returning, so a later short acquire
+ * timeout measures the queue and not a cold start. HTTP mode does not open a
+ * socket.
+ *
+ * @param config - URL, mode, pool size, and acquire timeout
+ * @returns The pool
+ */
+export declare function open(config: NeonConfig): Promise<DriverPool>;
+/**
+ * Checks out one WebSocket client.
+ *
+ * The wait uses `timeouts.acquire`. A timeout is OKM1846 and does not keep the
+ * client.
+ *
+ * @param pool - Neon pool
+ * @param acquireMs - Wait ceiling, when one was set
+ * @param counters - Pool occupancy
+ * @returns The client
+ */
+export declare function connectClient(pool: Pool, acquireMs: number | undefined, counters: Counters): Promise<PoolClient>;
+/**
+ * Sends one statement and returns the driver's promise.
+ *
+ * @param runner - Pool or checked-out client
+ * @param text - SQL
+ * @param params - Wire parameters
+ * @param named - Use a named prepared statement
+ * @returns The pending result
+ */
+export declare function send(runner: Queryable, text: string, params: readonly WireValue[] | undefined, named: boolean): WireQuery;

package/dist/adapters/pg/no-inflight-timeout.d.ts

@@ -1,17 +1,20 @@
 /**
  * Refusal for a driver that cannot cancel an in-flight statement (D224).
  *
- * Bun.sql and PGlite throw OKM1120 for a positive `timeout`. The message
- * stays `timeout` because the PGlite connect graph has two gzip bytes left.
- * Kind is `invalid`, which separates it from kind `timeout`. `timeout: 0`
- * still fails immediately as kind `timeout`. `signal` is unchanged.
- * postgres.js and node-postgres do not import this.
+ * Bun.sql, PGlite, and Neon refuse a positive `timeout`. The OKM1120 text loads with
+ * the lazy error module, so a connect entry does not carry it. Kind is
+ * `invalid`, which separates it from kind `timeout`. `timeout: 0` still fails
+ * immediately as kind `timeout`. `signal` is unchanged. postgres.js and
+ * node-postgres do not import this.
  */
 /**
- * Throws OKM1120 when `timeout` is a positive number.
+ * Returns a rejected OKM1120 when `timeout` is a positive number.
  *
- * @param options - Per-call options. Absent, and a non-positive timeout, pass through
+ * Absent, and a non-positive timeout, return `undefined` so the caller runs.
+ *
+ * @param options - Per-call options
+ * @returns A rejected promise, or `undefined` when the call may run
  */
 export declare function noTimeout(options: {
     readonly timeout?: number;
-} | undefined): void;
+} | undefined): Promise<never> | undefined;

package/dist/adapters/pg/nodepostgres-extra.d.ts

@@ -3,7 +3,7 @@
  *
  * Loaded on the first reserve, batch, or stream. A read does not use it.
  */
-import type { DriverConnection } from "../../contracts/driver.js";
+import type { DriverConnection, WireValue } from "../../contracts/driver.js";
 import { type HeldPool } from "./nodepostgres.js";
 /**
  * Checks out one client and clears it on release.
@@ -16,3 +16,24 @@ import { type HeldPool } from "./nodepostgres.js";
  * @returns A connection the caller must release
  */
 export declare function checkout(held: HeldPool): Promise<DriverConnection>;
+/**
+ * Listens on one checked-out client.
+ *
+ * The client has no pool error listener. One is set here so a dropped socket
+ * is not an uncaught `error` event.
+ *
+ * @param held - The pool and its counters
+ * @param channel - Notification channel
+ * @param onNotify - Called with each payload
+ * @returns Stops the listener
+ */
+export declare function listen(held: HeldPool, channel: string, onNotify: (payload: string) => void): Promise<() => Promise<void>>;
+/**
+ * Yields cursor chunks from one checked-out client.
+ *
+ * @param checkout - Reserves the connection
+ * @param text - Query to stream
+ * @param params - Wire parameters
+ * @returns Chunks of wire rows
+ */
+export declare function streamRows(checkout: () => Promise<DriverConnection>, text: string, params: readonly WireValue[] | undefined): AsyncIterable<readonly (readonly WireValue[])[]>;

package/dist/adapters/pg/nodepostgres.d.ts

@@ -44,6 +44,18 @@ export type Counters = {
     reservedBusy: number;
     waiting: number;
 };
+/**
+ * Attaches the one error listener a pool or a checked-out client can use.
+ *
+ * node-postgres types list `connect` and `notification` only. An idle pool
+ * client and a `LISTEN` client both emit `error` with no listener, and that
+ * is an uncaught exception. The default handler ignores it. The pool has
+ * already removed an idle client.
+ *
+ * @param source - Pool or client
+ * @param handle - What to do with the error
+ */
+export declare function armDriverError(source: object, handle?: () => void): void;
 /**
  * Opens a node-postgres pool for one endpoint.
  *

package/dist/adapters/pg/pglite-wire.d.ts

@@ -0,0 +1,24 @@
+/**
+ * PGlite wire codecs, loaded from {@link import("./pglite.ts").open}.
+ *
+ * A JS number, bigint, or boolean is sent as wire text. An `08P01` from a
+ * bad parameter is a driver error. A lost connection stays `unavailable`.
+ */
+declare const parsers: Record<number, (value: string) => string>;
+declare const serializers: Record<number, (value: unknown) => string>;
+/** Identity parsers. The dialect owns parsing. */
+export { parsers };
+/** Wire-text serializers. Number, bigint, and boolean are text. */
+export { serializers };
+/**
+ * Maps a PGlite failure.
+ *
+ * `08P01` means the parameter did not fit the protocol message. The
+ * replacement carries the message and neither a SQLSTATE nor a cause, so the
+ * kind is `driver`. Any other failure, including a closed connection, is
+ * mapped unchanged.
+ *
+ * @param error - Caught value
+ * @returns A normalised driver error
+ */
+export declare function fail(error: unknown): Promise<unknown>;

package/dist/adapters/pg/pglite.d.ts

@@ -19,3 +19,13 @@ export type PgliteConfig = DriverPoolConfig & {
  * @returns The pool
  */
 export declare function open(config?: PgliteConfig): Promise<DriverPool>;
+/**
+ * A pool whose `close` marks this client only.
+ *
+ * The inner pool stays open. A later call fails as unavailable.
+ * The body stays this small: the PGlite incremental figure is 11,510, 500 under its gate.
+ *
+ * @param pool - The caller's pool
+ * @returns A pool the client owns
+ */
+export declare function seal(pool: DriverPool): DriverPool;

package/dist/adapters/pg/postgres-extra.d.ts

@@ -4,9 +4,14 @@
  * Loaded on the first reserve, batch, describe, or stream.
  */
 import type { Sql } from "postgres";
-import type { DescribeResult, DriverConnection, ExecuteResult, WireValue } from "../../contracts/driver.js";
+import type { DescribeResult, DriverConnection, ExecuteOptions, ExecuteResult, Statement, WireValue } from "../../contracts/driver.js";
 import { type Watch } from "./call.js";
 import { type Canceller, type Counters, type NoticeBuffer } from "./postgresjs.js";
+type Lost = {
+    on: boolean;
+    /** Rejects the reset or drain that is using this reserved connection. */
+    stop: () => void;
+};
 /** State `open` shares with a checkout. */
 export type HeldPool = {
     readonly sql: Sql;
@@ -23,7 +28,7 @@ export type HeldPool = {
  * @param pool - The open pool
  * @returns A connection the caller must release
  */
-export declare function checkout(pool: HeldPool): Promise<DriverConnection>;
+export declare function checkout(pool: HeldPool, timeoutMs?: number): Promise<DriverConnection>;
 /**
  * Describes a statement.
  *
@@ -42,18 +47,30 @@ export declare function describe(sql: Sql, text: string, params?: readonly WireV
  * @returns Chunks of wire rows
  */
 export declare function stream(sql: Sql, text: string, params?: readonly WireValue[]): AsyncIterable<readonly (readonly WireValue[])[]>;
-type Lost = {
-    on: boolean;
-};
 /**
- * Rejects later writes once postgres.js reports the reserved socket closed.
+ * Settles `run` when `ms` elapses, the reserved connection closes, or every
+ * slot in the pool has closed.
  *
- * The first statement installs `onclose`. The checkout guard then refuses
- * the next statement, savepoint, or COMMIT before `socket.write`.
+ * A positive `ms` rejects with `timeout` and does not use the pool close hook.
+ * `link` is the reserved connection's lost flag, or the pool client.
  *
- * @param sql - Reserved connection
- * @param lost - Set when that socket closes
+ * @param ms - Deadline in milliseconds. `0` waits for a close
+ * @param run - Driver operation
+ * @param link - Connection flag, or the pool client when the wait has no connection
+ * @returns The operation's value
+ */
+export declare function deadline<T>(ms: number, run: () => Promise<T>, link?: Lost | Sql): Promise<T>;
+/**
+ * Checks out one connection, runs one batch, and releases it.
+ *
+ * The call timeout covers acquiring the connection and clearing it on release.
+ *
+ * @param pool - The open pool
+ * @param statements - Statements in order
+ * @param options - Call timeout and signal
+ * @returns One result per statement
  */
+export declare function runBatch(pool: HeldPool, statements: readonly Statement[], options: ExecuteOptions | undefined): Promise<readonly ExecuteResult[]>;
 /**
  * Sets `lost` when the reserved socket closes.
  *
@@ -64,7 +81,6 @@ type Lost = {
  * @param lost - Set when that socket closes
  */
 export declare function watchReserved(sql: Sql, lost: Lost): void;
-/** Refcount a checkout or a listener borrows from the pool. */
 type Gate = {
     enter(): void;
     leave(): void;

package/dist/adapters/pg/reserved.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared reset and lost-connection guard for a reserved connection.
+ *
+ * node-postgres, Bun.sql, and PGlite load this with the first reserve.
+ * postgres.js keeps its own copy: a second module in that adapter bundle
+ * crosses the incremental size gate.
+ */
+/** Set when the reserved socket is gone. */
+export type Lost = {
+    on: boolean;
+};
+/**
+ * Clears session state on a reserved connection.
+ *
+ * A failed reset rolls back and tries once more. The caller supplies `run`.
+ *
+ * @param depth - Open transaction depth. Above zero, roll back first
+ * @param run - Executes one statement on the reserved connection
+ */
+export declare function resetSession(depth: number, run: (text: string) => Promise<unknown>): Promise<void>;
+/**
+ * Clears a PGlite session the same way {@link resetSession} clears the others.
+ *
+ * Rollback goes through the session so its depth is cleared on failure too.
+ *
+ * @param session - The single PGlite connection
+ */
+export declare function resetQueried(session: {
+    inTransaction(): boolean;
+    rollback(): Promise<void>;
+    query(text: string, params: undefined, watch: undefined): Promise<unknown>;
+}): Promise<void>;
+/**
+ * Refuses the next statement after the reserved connection is gone.
+ *
+ * The first lost-connection error sets the flag.
+ *
+ * @param lost - Set when the socket is gone
+ * @param run - The statement
+ * @returns The statement, or a closed-pool rejection
+ */
+export declare function refuseWhenLost<T>(lost: Lost, run: () => Promise<T>): Promise<T>;

package/dist/adapters/pg/session.d.ts

@@ -23,13 +23,6 @@ export type NoticeBuffer = {
         readonly code?: string | undefined;
     }): void;
 };
-/**
- * Quotes one identifier.
- *
- * @param name - Channel or cursor name
- * @returns A double-quoted identifier
- */
-export declare function quoteIdent(name: string): string;
 /**
  * An empty notice buffer the pool fills as the server sends notices.
  *
@@ -81,14 +74,3 @@ export declare class WireSession implements BatchSession {
     private watched;
     private finishWatched;
 }
-/**
- * Yields cursor chunks from one connection that is already checked out.
- *
- * The cursor is session-local. `ROLLBACK` in the end drops it.
- *
- * @param run - Executes on the checked-out connection
- * @param text - Query to stream
- * @param params - Wire parameters
- * @returns Chunks of wire rows
- */
-export declare function cursorStream(run: (text: string, params?: readonly WireValue[]) => Promise<ExecuteResult>, text: string, params: readonly WireValue[] | undefined): AsyncIterable<readonly (readonly WireValue[])[]>;