postgrejs 3.6.0 → 3.7.0

package/CHANGELOG.md

@@ -1,6 +1,65 @@
 ## Changelog
 
-### [v3.6.0](https://github.com/panates/postgrejs/compare/v3.5.0...v3.6.0) - 
+### [v3.7.0](https://github.com/panates/postgrejs/compare/v3.6.1...v3.7.0) -  20 September 2026 
+
+#### Breaking Changes :warning:
+
+- feat!: decode a numeric that a double cannot hold into a Numeric @Eray Hanoğlu  
+- build: let the changelog template see a breaking change @Eray Hanoğlu  
+
+#### 🚀 New Features
+
+- feat: decode the network types @Eray Hanoğlu 
+- feat: decode line, path and polygon @Eray Hanoğlu 
+- feat: decode the system columns, and name the types that cannot be @Eray Hanoğlu 
+- feat: decode the range and multirange types @Eray Hanoğlu 
+- feat: decode the geometric types into classes of their own @Eray Hanoğlu 
+- feat: decode tsvector and tsquery @Eray Hanoğlu 
+- feat: decode interval @Eray Hanoğlu 
+- feat: decode bit, varbit and jsonpath @Eray Hanoğlu 
+- feat: decode timetz @Eray Hanoğlu 
+- feat: decode refcursor, pg_node_tree and the snapshot types @Eray Hanoğlu 
+- feat: add unknownTypesAsString @Eray Hanoğlu 
+- feat: let a decoded value carry the type it came from @Eray Hanoğlu 
+- feat: reject the in-flight query with ConnectionLostError too @Eray Hanoğlu 
+
+#### 🪲 Fixes
+
+- fix: write an object as its own SQL literal, not as json @Eray Hanoğlu 
+- fix: complete the type OID table, and check it against the catalog @Eray Hanoğlu 
+- fix: recover when a recreated type invalidates a cached statement @Eray Hanoğlu 
+- fix: keep a quoted empty element when parsing an array literal @Eray Hanoğlu 
+
+#### 📖 Documentation Changes
+
+- docs: cut the Features list back down @Eray Hanoğlu 
+- docs: drop the Features section @Eray Hanoğlu 
+- docs: bring the data type counts up to what is registered @Eray Hanoğlu 
+- docs: give the documentation link its own heading @Eray Hanoğlu 
+
+#### ⚡️ Performance Improvments
+
+- perf: build a numeric's digits without a concatenation per digit @Eray Hanoğlu 
+
+### [v3.6.1](https://github.com/panates/postgrejs/compare/v3.6.0...v3.6.1) -  20 September 2026 
+
+#### 🚀 New Features
+
+- feat: report a pooled connection that dies @Eray Hanoğlu 
+
+#### 🛠 Refactoring and Updates
+
+- refactor: give a lost connection its own error type @Eray Hanoğlu 
+
+#### 💬 General Changes
+
+- ci: pin the runner image and stop naming the PostgreSQL it ships @Eray Hanoğlu 
+
+### [v3.6.0](https://github.com/panates/postgrejs/compare/v3.5.0...v3.6.0) -  20 September 2026 
+
+#### Breaking Changes :warning:
+
+- feat!: fetch every row by default instead of the first 100 @Eray Hanoğlu  
 
 #### 🚀 New Features
 
@@ -21,10 +80,6 @@
 
 - docs: record what 3.6 changes for existing code @Eray Hanoğlu 
 
-#### 💬 General Changes
-
-- feat!: fetch every row by default instead of the first 100 @Eray Hanoğlu 
-
 ### [v3.5.0](https://github.com/panates/postgrejs/compare/v3.4.0...v3.5.0) -  16 September 2026 
 
 #### 🚀 New Features
@@ -81,6 +136,10 @@
 
 ### [v3.3.0](https://github.com/panates/postgrejs/compare/v3.2.0...v3.3.0) -  14 September 2026 
 
+#### Breaking Changes :warning:
+
+- feat!: give decodeBinary the value's length, not a slice of it @Eray Hanoğlu  
+
 #### 🚀 New Features
 
 - feat: add first-class Bun support with dedicated benchmark suite @Eray Hanoğlu 
@@ -109,7 +168,6 @@
 #### 💬 General Changes
 
 - bench: report near-ties as ties instead of ranking them @Eray Hanoğlu 
-- feat!: give decodeBinary the value's length, not a slice of it @Eray Hanoğlu 
 - bench: stop measuring type-declaration policy in the Extended Query scenarios @Eray Hanoğlu 
 - bench: stop one stalled repeat from making every result a tie @Eray Hanoğlu 
 - bench: document why concurrent Simple Query varies its literal @Eray Hanoğlu 

package/README.md

@@ -56,8 +56,7 @@ $ npm install postgrejs --save
 
 ## Documentation
 
-Please read :small_orange_diamond: [DOCUMENTATION](https://www.postgrejs.com/) :small_orange_diamond: for detailed
-usage.
+### Please read 🔸 [DOCUMENTATION](https://www.postgrejs.com/) 🔸 for detailed usage
 
 Upgrading from 3.5? See [doc/MIGRATION-v3.5-to-v3.6.md](doc/MIGRATION-v3.5-to-v3.6.md) - `query()` no longer stops at
 100 rows, and `fetchAsString` now returns the server's own text.
@@ -71,78 +70,6 @@ Upgrading from 3.5? See [doc/MIGRATION-v3.5-to-v3.6.md](doc/MIGRATION-v3.5-to-v3
 - **Rigorously tested:** A test suite covering the wire protocol, every data type, and connection-handling edge case,
   run on every push against PostgreSQL 12 through 18.
 
-## Features
-
-- **Connection Management:** Supports both single connection and advanced pooling, providing scalability and efficient
-  resource management.
-- **Binary Wire Protocol:** Implements the full binary wire protocol for all PostgreSQL data types, ensuring robust and
-  efficient data handling.
-- **Prepared Statements:** Named prepared statements for optimized query execution, and a per-connection cache that
-  reuses one automatically for SQL the connection has run before - a repeated query costs `Bind`/`Execute` instead of
-  parsing again, worth 3.2x on fifty concurrent calls and 2.9x again on a query inside an open transaction. On by
-  default, `prepare: false` to opt out.
-- **Statement-Level Rollback:** Inside a transaction each statement runs under a savepoint of its own, so a failed
-  statement leaves the transaction usable instead of aborting the whole block. The `SAVEPOINT`/`RELEASE` pair travels
-  in the statement's own round trip rather than costing one each - 36µs for the pair, against 507µs sent separately.
-  `rollbackOnError: false` to opt out.
-- **Complete Results:** `query()` returns every row the statement produced. A `fetchCount` limit is a limit rather
-  than a silent cap: the result carries `suspended: true` when the server stopped at it, so a prefix can never be
-  mistaken for the whole answer. `0` means unlimited, as it does in the protocol.
-- **Cursors:** Features fast double-link cache cursors for efficient data retrieval, iterable with `for await` a row
-  at a time and closed when the loop ends - by exhaustion, a `break`, or a throw. A cursor reads through a portal, and
-  a portal lives as long as the transaction that created it - `Pool.query()` keeps its connection out of the pool
-  until the cursor closes, and on a bare `Connection` open the cursor inside a transaction if anything else will run
-  on that connection meanwhile.
-- **Scoped Transactions:** `transaction(fn)` commits when the callback returns and rolls back when it throws, on a
-  connection or straight from the pool. A call made while a transaction is already open takes a savepoint rather than
-  a second `BEGIN`, so a nested scope that fails rolls back its own work and leaves the outer transaction standing.
-- **Batch Execution:** `executeBatch()` runs one prepared statement over many parameter sets under a single `Sync`,
-  reporting each set's row count - 1000 updates in 20ms where the same calls pipelined individually take 188ms.
-- **Notifications:**  High-level implementation for PostgreSQL notifications (LISTEN/NOTIFY), enabling real-time data
-  updates. Channel names are quoted rather than pattern-matched, so any name PostgreSQL accepts works.
-- **Extensibility:** Extensible data-types and type mapping to accommodate custom requirements. A type can set
-  `inferrable: false` to stay out of parameter type inference while still decoding its own columns.
-- **Parameter Binding:**  Bind parameters with OID mappings for precise and efficient query execution.
-- **Array Handling:** Supports multidimensional arrays with fast binary encoding/decoding.
-- **Performance Optimization:**  Low memory utilization and boosted performance through the use of shared buffers.
-- **Authorization:** Supports various password algorithms including Clear text, MD5, and SASL, ensuring secure
-  authentication.
-- **Bulk Import/Export:** `COPY TO STDOUT` and `COPY FROM STDIN` as Node streams, with backpressure in both directions,
-  plus `copyFromRows()`, which encodes rows straight into binary `COPY` - around 4x faster than the CSV equivalent and
-  no text escaping to get wrong. Takes arrays or objects from anything iterable, so a file larger than memory streams in.
-- **Query Pipelining:** Pooled queries can share connections so a burst is not capped by pool size - opt-in per call.
-  `pipeline()` goes further for a known set of statements: several different ones travel under a single `Sync`, so they
-  cost one round trip instead of one each and commit or roll back together - around 2x faster than the same calls
-  through `Promise.all()`, which is already pipelined. Statements the connection has run before bind to their cached
-  prepared names, so a repeated set sends no `Parse` at all - worth 2.5x on twenty statements.
-- **Dynamic SQL:** A `sql` tag builds statements from composable fragments - values become parameters, names are quoted,
-  and `sql.values()`/`sql.set()` write INSERT and UPDATE clauses from objects.
-- **Multiple Hosts:** A connection can list several servers and pick one by role
-  (`target_session_attrs`), so a cluster that has failed over is found on the next connect.
-- **Large Objects:** File-like access to binary data stored outside the row - seek, partial reads, streams - for
-  values past what a `bytea` column can hold.
-- **Logical Replication:** `LogicalReplication` streams committed row changes as an async iterable, decoding
-  `pgoutput` itself, with client-side filtering and positions confirmed as you consume.
-- **Channel Binding:** SCRAM authentication binds itself to the TLS channel when the server offers it, the way libpq
-  does by default, so a relayed login is detected even where the certificate is not verified.
-- **Two-phase commit:** `prepareTransaction()` leaves a transaction waiting under a name for `commitPrepared()`/
-  `rollbackPrepared()`, from any connection.
-- **Cancellation:** Any call takes an `AbortSignal`, which also gives per-query timeouts via `AbortSignal.timeout()`.
-- **Flexible Data Retrieval:**  Can return both array and object rows to suit different data processing needs.
-- **Values as Text:** `fetchAsString: [DataTypeOIDs.int8]` asks the server for those columns in its own text format
-  and hands the bytes back unparsed - so `count(*)` arrives as `'3'`, one consistent type where a decoded `int8` is a
-  `number` or a `BigInt` depending on magnitude. Any OID, arrays included. The string is PostgreSQL's own rendering
-  rather than one reconstructed from the binary value, so it cannot drift from what the server would print.
-- **Resource Management:** Auto disposal of resources with the "using" syntax
-  ([TC39 Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management)), ensuring
-  efficient resource cleanup.
-- **Long Cancel Key:** Opt in to protocol 3.2 (PostgreSQL 18+) with `longCancelKey`, so a `cancel()` in progress can't
-  be forged by an attacker guessing a short secret key.
-- **Legacy Function Call Protocol:** `callFunction()` calls a function by OID directly over the wire, bypassing SQL
-  entirely - kept for protocol completeness even though `SELECT func(...)` covers the same ground.
-- **Graceful Protocol Renegotiation:** A server that doesn't recognize a requested protocol version or startup option
-  reports back instead of erroring out, surfaced on `Connection.protocolNegotiation`.
-
 ## Feature Comparison
 
 How PostgreJS compares to [`pg`](https://github.com/brianc/node-postgres) (node-postgres) and
@@ -200,10 +127,10 @@ in · 🟡 partial or needs a separate package · ❌ not supported.
 | Multiple hosts                    |           ✅           |          ❌           |        ✅        |
 | LISTEN/NOTIFY                     |           ✅           |   🟡 <sup>15</sup>    |        ✅        |
 | ***Data types***                  |                        |                       |                  |
-| Text encoders                     |           56           | generic <sup>16</sup> |        14        |
-| Text decoders                     |           56           |          44           | 12 <sup>17</sup> |
-| Binary encoders                   |           56           |          ❌           |        ❌        |
-| Binary decoders                   |           56           |          16           |        ❌        |
+| Text encoders                     |          125           | generic <sup>16</sup> |        14        |
+| Text decoders                     |          125           |          44           | 12 <sup>17</sup> |
+| Binary encoders                   |   121 <sup>27</sup>    |          ❌           |        ❌        |
+| Binary decoders                   |          125           |          16           |        ❌        |
 | Multidimensional arrays           |       ✅ binary        | 🟡 text <sup>18</sup> |     🟡 text      |
 | ***Security***                    |                        |                       |                  |
 | SSL/TLS                           |           ✅           |          ✅           |        ✅        |
@@ -290,7 +217,10 @@ in · 🟡 partial or needs a separate package · ❌ not supported.
   a savepoint, so nesting needs nothing from the caller. postgres.js has `sql.begin(fn)` (`src/index.js`), where a
   nested scope is opened explicitly with `sql.savepoint(fn)` instead. pg has no such helper in `lib/` - `BEGIN` and
   `COMMIT` are statements the caller sends, and getting a transaction onto one connection is the caller's problem too.
-
+- <sup>27</sup> Every registered type but `tsvector` and `tsquery`, which have none deliberately: the server's own
+  input parser is what sorts and deduplicates a vector and what defines a query's grammar, so encoding either here
+  would make the same text mean one thing written as a literal and another bound as a parameter. They are sent as
+  text instead, which is exact.
 
 ## Benchmarks
 

package/connection/intl-connection.d.ts

@@ -194,9 +194,11 @@ export declare class IntlConnection extends SafeEventEmitter {
      *
      * A cached statement can be invalidated under us - `alter table` between
      * two calls makes PostgreSQL answer 0A000, "cached plan must not change
-     * result type". That is caught here: the entry is dropped and the query
-     * runs again unprepared, so a migration against a live connection
-     * recovers instead of failing every call from then on.
+     * result type", and a dropped and recreated type makes it answer XX000,
+     * "cache lookup failed for type". Both are caught here (see
+     * isStaleCachedPlan): the entry is dropped and the query runs again
+     * unprepared, so a migration against a live connection recovers instead
+     * of failing every call from then on.
      */
     queryCached(sql: string, paramTypes: Maybe<Maybe<OID>[]>, params: Maybe<Maybe<any>[]>, options: QueryOptions): Promise<QueryResult>;
     /**

package/connection/intl-connection.js

@@ -28,6 +28,30 @@ function columnFormatsEqual(a, b) {
             return false;
     return true;
 }
+/**
+ * Whether the server is saying that a statement this connection had under
+ * a name can no longer be executed as it stands, so the cache entry is
+ * stale and the query is worth running again unprepared.
+ *
+ * Two SQLSTATEs say it. `0A000` is the documented one - "cached plan must
+ * not change result type", after an `alter table`. `XX000` is what a
+ * dropped and recreated *type* produces ("cache lookup failed for type
+ * <oid>"): it is the server's catch-all internal_error rather than
+ * something specific, but it is rare enough in ordinary operation that
+ * retrying it costs nothing, and the alternative - matching the English
+ * message - breaks under a different `lc_messages` or a server version
+ * that rewords it.
+ *
+ * Deliberately narrow. Dropping the entry on *any* failure would also
+ * self-heal, but it would retire a perfectly good prepared statement
+ * every time an ordinary error came back - a unique violation on a hot
+ * upsert would keep costing the statement its name - and re-running a
+ * statement that failed for its own reasons buys nothing.
+ */
+function isStaleCachedPlan(e) {
+    const code = e?.code;
+    return code === '0A000' || code === 'XX000';
+}
 /**
  * Whether a command tag's row count describes rows the statement changed,
  * rather than rows it returned or moved. SELECT, FETCH, MOVE and COPY all
@@ -96,7 +120,9 @@ export class IntlConnection extends SafeEventEmitter {
         this._config = Object.freeze(getConnectionConfig(config));
         this.socket = new PgSocket(this._config);
         this.socket.on('error', err => this._onError(err));
-        this.socket.on('close', () => this.emit('close'));
+        // The reason travels with it: 'close' on its own cannot tell an
+        // ordinary shutdown from the backend being terminated under us.
+        this.socket.on('close', (reason) => this.emit('close', reason));
         this.socket.on('notification', payload => this.emit('notification', payload));
         this.socket.on('connecting', () => this.emit('connecting'));
         this._onErrorSavePoint = 'SP_' + Math.round(Math.random() * 100000000);
@@ -163,7 +189,7 @@ export class IntlConnection extends SafeEventEmitter {
             // IntlConnection TWICE per close() call - confirmed live: a single
             // close() left two listeners registered on the far side (e.g. two
             // NOTIFY deliveries after Pool's reconnect re-subscribed twice).
-            this.socket.once('close', resolve);
+            this.socket.once('close', () => resolve());
             this.socket.sendTerminateMessage(() => {
                 this.socket.close();
             });
@@ -615,9 +641,11 @@ export class IntlConnection extends SafeEventEmitter {
      *
      * A cached statement can be invalidated under us - `alter table` between
      * two calls makes PostgreSQL answer 0A000, "cached plan must not change
-     * result type". That is caught here: the entry is dropped and the query
-     * runs again unprepared, so a migration against a live connection
-     * recovers instead of failing every call from then on.
+     * result type", and a dropped and recreated type makes it answer XX000,
+     * "cache lookup failed for type". Both are caught here (see
+     * isStaleCachedPlan): the entry is dropped and the query runs again
+     * unprepared, so a migration against a live connection recovers instead
+     * of failing every call from then on.
      */
     async queryCached(sql, paramTypes, params, options) {
         const savepoint = this._inlineSavepointFor(sql, options);
@@ -661,7 +689,7 @@ export class IntlConnection extends SafeEventEmitter {
                 return await this.executeReused(cached.name, cached.fields, paramTypes, params, options, savepoint);
             }
             catch (e) {
-                if (e?.code !== '0A000')
+                if (!isStaleCachedPlan(e))
                     throw e;
                 this._preparedCache.delete(key);
                 // ROLLBACK TO leaves the savepoint itself in place, so the retry
@@ -681,7 +709,10 @@ export class IntlConnection extends SafeEventEmitter {
         // Parse+Describe round trip per connection instead of leaving every
         // call until the statement earns a name asking for the whole row as
         // text (what queryOnce() falls back to).
-        if (!options.fetchAsString?.length && !this._earnsAName(key))
+        // unknownTypesAsString needs the columns known before the Bind for
+        // the same reason fetchAsString does, so it earns a name the same way.
+        const needsFields = !!options.fetchAsString?.length || !!options.unknownTypesAsString;
+        if (!needsFields && !this._earnsAName(key))
             return this.queryOnce(sql, paramTypes, params, options, savepoint);
         const name = 'C_' + ++this._preparedCounter;
         // A Parse that fails caches nothing and reports itself; the statement
@@ -769,7 +800,7 @@ export class IntlConnection extends SafeEventEmitter {
             // _queryCached() prepares a fetchAsString query on first sight
             // precisely so it can send per-column codes from the second call on
             // (from the first, for every connection that has seen the SQL).
-            const columnFormat = options.fetchAsString?.length
+            const columnFormat = options.fetchAsString?.length || options.unknownTypesAsString
                 ? DataFormat.text
                 : options.columnFormat != null
                     ? options.columnFormat
@@ -1027,8 +1058,8 @@ export class IntlConnection extends SafeEventEmitter {
                 // per-column codes; the rest fall back to asking for the whole row
                 // as text, exactly as queryOnce() does and for the same reason.
                 plan.columnFormat = plan.fields
-                    ? resolveColumnFormats(plan.fields, options)
-                    : options.fetchAsString?.length
+                    ? resolveColumnFormats(plan.fields, options, typeMap)
+                    : options.fetchAsString?.length || options.unknownTypesAsString
                         ? DataFormat.text
                         : options.columnFormat != null
                             ? options.columnFormat
@@ -1129,11 +1160,10 @@ export class IntlConnection extends SafeEventEmitter {
             }
             catch (e) {
                 // A cached statement can be invalidated between two pipelines the
-                // same way a cached single query can (0A000, "cached plan must not
-                // change result type"). Drop what this pipeline reused and run it
-                // again unprepared - once, since the second attempt has nothing
-                // cached left to reuse.
-                if (e?.code !== '0A000' || !cachedKeys.length)
+                // same way a cached single query can - see isStaleCachedPlan().
+                // Drop what this pipeline reused and run it again unprepared -
+                // once, since the second attempt has nothing cached left to reuse.
+                if (!isStaleCachedPlan(e) || !cachedKeys.length)
                     throw e;
                 for (const k of cachedKeys)
                     this._preparedCache.delete(k);
@@ -1178,7 +1208,7 @@ export class IntlConnection extends SafeEventEmitter {
             const rowDecoder = resolveRowDecoder(options);
             let parsers;
             let resultFields;
-            const columnFormat = resolveColumnFormats(cachedFields, options);
+            const columnFormat = resolveColumnFormats(cachedFields, options, typeMap);
             if (cachedFields) {
                 const resolved = this._resolveReusedParsers(cachedFields, typeMap, options, columnFormat);
                 parsers = resolved.parsers;
@@ -1289,7 +1319,7 @@ export class IntlConnection extends SafeEventEmitter {
             // RowDescription is already in hand, so fetchAsString's OID list can
             // become the per-column result format codes this Bind carries, with
             // no extra round trip to find out what the columns are.
-            const columnFormat = resolveColumnFormats(cachedFields, options);
+            const columnFormat = resolveColumnFormats(cachedFields, options, typeMap);
             if (cachedFields) {
                 const resolved = this._resolveReusedParsers(cachedFields, typeMap, options, columnFormat);
                 parsers = resolved.parsers;

package/connection/pool.d.ts

@@ -37,6 +37,14 @@ export declare class Pool extends SafeEventEmitter {
     protected readonly _notificationListeners: SafeEventEmitter;
     protected _notificationConnection?: Connection;
     protected readonly _pipelineSlots: PipelineSlot[];
+    /**
+     * Why a connection is about to be destroyed, for the ones that were not
+     * destroyed on purpose. lightning-pool's own 'destroy' carries the
+     * resource and nothing else, so the reason is recorded on the way in -
+     * when the connection reports its close - and read back out when the
+     * pool reports the removal.
+     */
+    protected readonly _destroyReasons: WeakMap<IntlConnection, Error>;
     protected _pipelineMaxQueries: number;
     protected _pipelineMaxConnections: number;
     readonly config: PoolConfiguration;
@@ -91,6 +99,20 @@ export declare class Pool extends SafeEventEmitter {
     listen(channel: string, callback: NotificationCallback): Promise<void>;
     unListen(channel: string): Promise<void>;
     unListenAll(): Promise<void>;
+    /**
+     * A pooled connection reported that its socket closed. `reason` is set
+     * only when that was not asked for - see PgSocket._handleClose().
+     */
+    protected _onConnectionClosed(intlCon: IntlConnection, reason?: Error): void;
+    /**
+     * The pool has removed a connection. `destroy` fires the same way for an
+     * ordinary eviction (idle timeout, close(), a failed validate) as for a
+     * connection that died, so the reason is what tells them apart - an
+     * admin kill, a failover and a network fault were otherwise
+     * indistinguishable from a timeout, with nothing at all reported when
+     * the connection had no query in flight to reject.
+     */
+    protected _onConnectionDestroyed(intlCon: IntlConnection): void;
     protected _canPipeline(pipeline: boolean | undefined, sql: string, autoCommit: boolean | undefined, signal: AbortSignal | undefined): boolean;
     /**
      * Picks the pooled connection a pipelined query should ride on, or

package/connection/pool.js

@@ -13,6 +13,14 @@ export class Pool extends SafeEventEmitter {
     _notificationListeners = new SafeEventEmitter();
     _notificationConnection;
     _pipelineSlots = [];
+    /**
+     * Why a connection is about to be destroyed, for the ones that were not
+     * destroyed on purpose. lightning-pool's own 'destroy' carries the
+     * resource and nothing else, so the reason is recorded on the way in -
+     * when the connection reports its close - and read back out when the
+     * pool reports the removal.
+     */
+    _destroyReasons = new WeakMap();
     _pipelineMaxQueries;
     _pipelineMaxConnections;
     config;
@@ -46,7 +54,7 @@ export class Pool extends SafeEventEmitter {
                 /* c8 ignore stop */
                 const intlCon = new IntlConnection(cfg);
                 await intlCon.connect();
-                intlCon.on('close', () => this._pool.destroy(intlCon));
+                intlCon.on('close', (reason) => this._onConnectionClosed(intlCon, reason));
                 /* c8 ignore start */
                 if (this.listenerCount('debug')) {
                     this.emit('debug', {
@@ -82,7 +90,7 @@ export class Pool extends SafeEventEmitter {
                 /* c8 ignore stop */
                 intlCon.owner = undefined;
                 intlCon.removeAllListeners();
-                intlCon.once('close', () => this._pool.destroy(intlCon));
+                intlCon.once('close', (reason) => this._onConnectionClosed(intlCon, reason));
                 intlCon._refCount = 0;
             },
             validate: async (intlCon) => {
@@ -104,7 +112,7 @@ export class Pool extends SafeEventEmitter {
         this._pool.on('return', (...args) => this.emit('release', ...args));
         this._pool.on('error', (...args) => this.emit('error', ...args));
         this._pool.on('acquire', (...args) => this.emit('acquire', ...args));
-        this._pool.on('destroy', (...args) => this.emit('destroy', ...args));
+        this._pool.on('destroy', (intlCon) => this._onConnectionDestroyed(intlCon));
     }
     /**
      * Returns the number of connections that are currently acquired
@@ -313,6 +321,40 @@ export class Pool extends SafeEventEmitter {
             await conn.close();
         }
     }
+    /**
+     * A pooled connection reported that its socket closed. `reason` is set
+     * only when that was not asked for - see PgSocket._handleClose().
+     */
+    _onConnectionClosed(intlCon, reason) {
+        if (reason)
+            this._destroyReasons.set(intlCon, reason);
+        this._pool.destroy(intlCon);
+    }
+    /**
+     * The pool has removed a connection. `destroy` fires the same way for an
+     * ordinary eviction (idle timeout, close(), a failed validate) as for a
+     * connection that died, so the reason is what tells them apart - an
+     * admin kill, a failover and a network fault were otherwise
+     * indistinguishable from a timeout, with nothing at all reported when
+     * the connection had no query in flight to reject.
+     */
+    _onConnectionDestroyed(intlCon) {
+        const reason = this._destroyReasons.get(intlCon);
+        if (reason)
+            this._destroyReasons.delete(intlCon);
+        this.emit('destroy', intlCon, reason);
+        if (!reason)
+            return;
+        // Reported on 'error' as well, which is where pg puts a pooled
+        // connection dying and where code ported from it listens. Safe to do
+        // unconditionally here: SafeEventEmitter drops an 'error' that has no
+        // listener instead of throwing, so this cannot turn a recovery the
+        // pool already made into a crashed process. The error names the pid
+        // and carries the socket error as its cause; no second argument, so
+        // the existing `(err, meta)` shape lightning-pool emits for a
+        // connection that could not be created stays unambiguous.
+        this.emit('error', reason);
+    }
     _canPipeline(pipeline, sql, autoCommit, signal) {
         return (pipeline === true &&
             !signal &&

package/connection/prepared-statement.js

@@ -211,9 +211,9 @@ export class PreparedStatement extends SafeEventEmitter {
                 // prepare() already fetched this statement's RowDescription, so
                 // fetchAsString's OID list can become per-column result format
                 // codes on the Bind below with no round trip of its own.
-                const columnFormat = resolveColumnFormats(this._fields, options);
-                const fields = await portal.bindAndRetrieveFields(options.params, options, columnFormat);
                 const typeMap = options.typeMap || GlobalTypeMap;
+                const columnFormat = resolveColumnFormats(this._fields, options, typeMap);
+                const fields = await portal.bindAndRetrieveFields(options.params, options, columnFormat);
                 const parsers = getParsers(typeMap, fields, options);
                 const resultFields = wrapRowDescription(typeMap, fields, columnFormat, options);
                 const result = {

package/constants.d.ts

@@ -27,6 +27,7 @@ export declare const DataTypeOIDs: {
     oidvector: number;
     json: number;
     xml: number;
+    pg_node_tree: number;
     point: number;
     lseg: number;
     path: number;
@@ -42,6 +43,7 @@ export declare const DataTypeOIDs: {
     money: number;
     macaddr: number;
     inet: number;
+    aclitem: number;
     bpchar: number;
     varchar: number;
     date: number;
@@ -70,14 +72,40 @@ export declare const DataTypeOIDs: {
     anyelement: number;
     anynonarray: number;
     uuid: number;
+    txid_snapshot: number;
+    pg_lsn: number;
+    pg_ndistinct: number;
+    pg_dependencies: number;
+    tsvector: number;
+    tsquery: number;
+    gtsvector: number;
+    regconfig: number;
+    regdictionary: number;
     jsonb: number;
     anyrange: number;
     int4range: number;
     numrange: number;
     tsrange: number;
+    tstzrange: number;
+    /** @deprecated Misspelling of `tstzrange`, kept so it keeps resolving. */
     rstzrange: number;
     daterange: number;
     int8range: number;
+    jsonpath: number;
+    regnamespace: number;
+    regrole: number;
+    regcollation: number;
+    int4multirange: number;
+    nummultirange: number;
+    tsmultirange: number;
+    tstzmultirange: number;
+    datemultirange: number;
+    int8multirange: number;
+    pg_brin_bloom_summary: number;
+    pg_brin_minmax_multi_summary: number;
+    pg_mcv_list: number;
+    pg_snapshot: number;
+    xid8: number;
     _xml: number;
     _json: number;
     _xid8: number;
@@ -110,6 +138,7 @@ export declare const DataTypeOIDs: {
     _float8: number;
     _polygon: number;
     _oid: number;
+    _aclitem: number;
     _macaddr: number;
     _inet: number;
     _timestamp: number;
@@ -122,7 +151,38 @@ export declare const DataTypeOIDs: {
     _timetz: number;
     _bit: number;
     _varbit: number;
+    _refcursor: number;
+    _regprocedure: number;
+    _regoper: number;
+    _regoperator: number;
+    _regclass: number;
+    _regtype: number;
+    _record: number;
+    _txid_snapshot: number;
     _uuid: number;
+    _pg_lsn: number;
+    _tsvector: number;
+    _gtsvector: number;
+    _tsquery: number;
+    _regconfig: number;
+    _regdictionary: number;
     _jsonb: number;
+    _int4range: number;
+    _numrange: number;
+    _tsrange: number;
+    _tstzrange: number;
+    _daterange: number;
+    _int8range: number;
+    _jsonpath: number;
+    _regnamespace: number;
+    _regrole: number;
+    _regcollation: number;
+    _pg_snapshot: number;
+    _int4multirange: number;
+    _nummultirange: number;
+    _tsmultirange: number;
+    _tstzmultirange: number;
+    _datemultirange: number;
+    _int8multirange: number;
 };
 export declare const DataTypeNames: Record<string, string>;