joist-orm 2.3.0-next.4 → 2.3.0-next.41

package/build/drivers/WireRowData.js

@@ -0,0 +1,430 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WireRowData = void 0;
+exports.executeRowDataQuery = executeRowDataQuery;
+exports.isRowDataCapableClient = isRowDataCapableClient;
+const pg_1 = __importDefault(require("pg"));
+const binaryParsers_1 = require("./binaryParsers");
+// pg's internal-but-exported Query class; subclassing it reuses its extended-protocol
+// submit/bind logic while letting us intercept row handling (the same seam pg-cursor uses).
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const PgQuery = require("pg/lib/query");
+// Each row is three consecutive entries in the `#rowSlices` table: chunk index, start, length
+const ROW_STRIDE = 3;
+/** The row-length sentinel for rows dropped by `finalize` compaction. */
+const DROPPED = 0xffffffff;
+/** Only compact when dropped rows hold more than this fraction of the payload bytes. */
+const COMPACT_THRESHOLD = 0.2;
+/**
+ * Only allocate the adaptive scan cursor once a fault targets at least this ordinal: shallower
+ * scans cost less than the cursor's bookkeeping, i.e. hydrate-only results (id is ordinal ~0)
+ * and narrow reads never pay the 6 bytes/row.
+ */
+const SCAN_CURSOR_MIN_ORDINAL = 8;
+/**
+ * A lazy wire-row {@link RowData} over raw Postgres `DataRow` payload bytes.
+ *
+ * Each query produces its own `WireRowData` — one query, one result; results are never combined
+ * or appended across queries, and the payload is read-only after the query completes (entity
+ * mutations go into `InstanceData.data`, never back into the row bytes).
+ *
+ * Rows are kept in their row-major wire format (`int16 fieldCount` + length-prefixed cells) as
+ * zero-copy views over the parser's own immutable buffers: `addRow` records each DataRow's
+ * `(bytes, offset, length)` by reference, deduping the socket chunk that consecutive rows
+ * share. (Our pg-protocol patch guarantees message bytes are never rewritten — chunks parse in
+ * place and straddling messages get a buffer of their own; see `patchPgProtocol.ts`.) A
+ * `row × column` cell is decoded on first field access by scanning the row's length-prefixed
+ * cells to the column's ordinal ("row-lazy" decode, see JS-ROW-STORE-DESIGN.md §3/C2). This is
+ * deferred decoding of row-major data, not a columnar layout.
+ *
+ * Because chunks are whole socket reads, retaining any row pins its ~64KiB chunk (plus whatever
+ * protocol frames share it); `finalize`'s compaction copies retained rows out into an
+ * exact-size owned buffer when enough of the payload was dropped.
+ *
+ * Text-format cells go through the same active text parsers node-postgres would resolve for
+ * the query (i.e. honoring pool/client `TypeOverrides`), so they parse identically to classic
+ * rows. Binary-format cells decode via `wireBinaryParser`: wire bytes -> value directly for
+ * default-parsed scalar types (no intermediate string), else rendered to pg's canonical text
+ * and fed through the active text parser for parity. (Classic node-postgres cannot do binary
+ * at all — it round-trips cells through a UTF-8 string, corrupting bytes >= 0x80.)
+ *
+ * Because decoding is deferred, a custom parser that throws will do so on first field access
+ * (or `toRow`/`toRows`), not while awaiting the query; `id` and inheritance-discriminator cells
+ * still decode during hydration.
+ *
+ * After hydration, `finalize` trims unused capacity and, when some rows were not retained (i.e.
+ * their entities were already in the identity map), compacts the payload down to only the
+ * retained rows, so retained memory tracks live entities rather than query history.
+ *
+ * Small results deliberately stay lazy — there is NO row-count threshold below which we
+ * materialize to a `PojoRowData` instead. Measured (benchmark-rowdata-small.ts, 40-col rows):
+ * for the typical sparse access pattern (~6 of 40 columns read), keeping the lazy result wins at
+ * every size including a single row (n=1: 4.3µs vs 7.6µs; n=1000: 0.76ms vs 3.0ms), because
+ * materialization eagerly decodes every column while lazy faults only what is read. Even full
+ * column coverage no longer flips the winner: with binary decode and `#readCell`'s adaptive
+ * scan cursor, reading all ~36 columns of every row measures ~parity with classic end-to-end
+ * (benchmark-lazy-parsing.ts), and small finds (n <= 10) are statistically identical.
+ */
+class WireRowData {
+    #chunks = [];
+    /** Where each row's bytes live: `(chunk index, start, length)` slices, `ROW_STRIDE` entries per row. */
+    #rowSlices = new Uint32Array(16 * ROW_STRIDE);
+    #rowCount = 0;
+    #payloadBytes = 0;
+    #retained = undefined;
+    #columns = new Map();
+    #fields = [];
+    /** The adaptive scan cursor: per row, the furthest scanned ordinal + its offset (see #readCell). */
+    #scanOrdinal = undefined;
+    #scanOffset = undefined;
+    get rowCount() {
+        return this.#rowCount;
+    }
+    /** The DataRow payload bytes currently indexed; drops when compaction discards rows. */
+    get payloadBytes() {
+        return this.#payloadBytes;
+    }
+    /** The bytes currently held by payload chunks + the row-slice table, i.e. for benchmarks. */
+    get memoryBytes() {
+        let bytes = this.#rowSlices.byteLength;
+        for (const chunk of this.#chunks)
+            bytes += chunk.length;
+        return bytes;
+    }
+    get(rowIndex, columnName) {
+        const column = this.#columns.get(columnName);
+        // Tolerate probes for columns the query didn't select, i.e. `__class` on non-CTI queries
+        if (column === undefined)
+            return undefined;
+        const base = this.#rowBase(rowIndex);
+        const slices = this.#rowSlices;
+        const start = slices[base + 1];
+        return this.#readCell(this.#chunks[slices[base]], start, start + slices[base + 2], column, rowIndex);
+    }
+    /** Materializes one row as a POJO, i.e. for debugging and differential tests; values are not cached. */
+    toRow(rowIndex) {
+        const base = this.#rowBase(rowIndex);
+        const slices = this.#rowSlices;
+        const chunk = this.#chunks[slices[base]];
+        const start = slices[base + 1];
+        const end = start + slices[base + 2];
+        const row = {};
+        let pos = start + 2;
+        for (const field of this.#fields) {
+            const len = this.#cellLength(chunk, pos, end, rowIndex);
+            pos += 4;
+            if (len === -1) {
+                row[field.name] = null;
+            }
+            else {
+                row[field.name] = field.decode(chunk, pos, len);
+                pos += len;
+            }
+        }
+        return row;
+    }
+    /** Materializes classic POJO rows, i.e. for `afterFind` observation or debugging; not cached. */
+    toRows() {
+        const rows = new Array(this.#rowCount);
+        for (let i = 0; i < this.#rowCount; i++)
+            rows[i] = this.toRow(i);
+        return rows;
+    }
+    /**
+     * Resolves each column's decoder from the query's RowDescription.
+     *
+     * Binary-format fields decode through Joist's own binary registry only (see
+     * `setBinaryTypeParser`) — `pg.types`/`TypeOverrides` are never consulted, and a column whose
+     * oid has no registered binary parser fails the query here, before any rows arrive, rather
+     * than guessing at a lossy decoding. Text-format fields (the `binary: false` escape hatch)
+     * decode by utf8-slicing the cell into the active text parser, resolved via `getTypeParser`
+     * (i.e. the pool/client `TypeOverrides` chain) or the global registry.
+     */
+    setRowDescription(fields, getTypeParser) {
+        for (let i = 0; i < fields.length; i++) {
+            const { name, dataTypeID, format } = fields[i];
+            let decode;
+            if (format === "binary") {
+                decode = (0, binaryParsers_1.getBinaryTypeParser)(dataTypeID);
+                if (decode === undefined) {
+                    throw new Error(`joist-orm: no binary type parser registered for oid ${dataTypeID} (column "${name}");` +
+                        ` register one with setBinaryTypeParser (i.e. binaryTextParser for text-like types)`);
+                }
+            }
+            else {
+                const parse = getTypeParser?.(dataTypeID) ?? pg_1.default.types.getTypeParser(dataTypeID, "text");
+                decode = textCellDecoder(parse);
+            }
+            const column = { name, ordinal: i, decode };
+            this.#columns.set(name, column);
+            this.#fields.push(column);
+        }
+    }
+    /**
+     * Records one DataRow payload *by reference* (zero-copy); called synchronously from the wire
+     * parser, whose patched buffer management guarantees the bytes are never rewritten.
+     *
+     * Consecutive rows usually share one socket chunk, so `bytes` is deduped against the last
+     * chunk ref; retaining any row of a chunk pins the whole chunk, which `finalize`'s compaction
+     * resolves by copying retained rows out when enough of the payload was dropped.
+     */
+    addRow(bytes, offset, payloadLength) {
+        if (payloadLength < 2 || offset + payloadLength > bytes.length) {
+            throw new Error(`Malformed DataRow payload (length ${payloadLength})`);
+        }
+        let chunkIndex = this.#chunks.length - 1;
+        if (chunkIndex === -1 || this.#chunks[chunkIndex] !== bytes) {
+            this.#chunks.push(bytes);
+            chunkIndex++;
+        }
+        let slices = this.#rowSlices;
+        const base = this.#rowCount * ROW_STRIDE;
+        if (base === slices.length) {
+            const grown = new Uint32Array(slices.length * 2);
+            grown.set(slices);
+            slices = this.#rowSlices = grown;
+        }
+        slices[base] = chunkIndex;
+        slices[base + 1] = offset;
+        slices[base + 2] = payloadLength;
+        this.#rowCount++;
+        this.#payloadBytes += payloadLength;
+    }
+    /** Marks `rowIndex` as retained by a hydrated entity; unmarked rows can be compacted away. */
+    retain(rowIndex) {
+        (this.#retained ??= []).push(rowIndex);
+    }
+    /**
+     * Trims unused capacity, and compacts down to only `retain`-ed rows when enough rows were not
+     * retained to be worth the copy.
+     *
+     * Compaction exists to release pinned socket buffers to the GC: rows are zero-copy views into
+     * whole ~64KiB chunks, so keeping any row alive pins its entire chunk — and unretained rows
+     * are typically duplicates whose entities were *already in memory* (identity-map hits that
+     * keep their original `rowData`), making the newly-arrived bytes dead weight. Copying the
+     * retained rows into one exact-size owned buffer lets every chunk reference drop.
+     *
+     * The copy re-copies every retained byte, so it only pays off when it buys back a meaningful
+     * fraction of the payload: we compact when the dropped rows hold more than 20% of the payload
+     * bytes, and otherwise just trim, accepting the (bounded) leftover bytes. Called once after
+     * hydration + sidecar reads (`_tags`, preload aggregates) are complete; retained entities keep
+     * their original `rowIndex`, and un-compacted unretained rows simply remain readable-but-unused.
+     */
+    finalize() {
+        const retained = this.#retained ?? [];
+        this.#retained = undefined;
+        if (retained.length < this.#rowCount) {
+            let retainedBytes = 0;
+            for (const i of retained)
+                retainedBytes += this.#rowSlices[i * ROW_STRIDE + 2];
+            const droppedBytes = this.#payloadBytes - retainedBytes;
+            if (droppedBytes > this.#payloadBytes * COMPACT_THRESHOLD) {
+                this.#compact(retained, retainedBytes);
+                return;
+            }
+        }
+        // Just shrink the row-slice table to its used size
+        if (this.#rowCount * ROW_STRIDE < this.#rowSlices.length) {
+            this.#rowSlices = this.#rowSlices.slice(0, this.#rowCount * ROW_STRIDE);
+        }
+    }
+    /** Copies retained rows into one owned buffer, releasing the pinned socket chunks to the GC. */
+    #compact(retained, bytes) {
+        const chunks = bytes > 0 ? [Buffer.allocUnsafe(bytes)] : [];
+        const slices = new Uint32Array(this.#rowCount * ROW_STRIDE);
+        for (let i = 0; i < this.#rowCount; i++)
+            slices[i * ROW_STRIDE + 2] = DROPPED;
+        let used = 0;
+        for (const i of retained) {
+            const base = i * ROW_STRIDE;
+            const source = this.#chunks[this.#rowSlices[base]];
+            const start = this.#rowSlices[base + 1];
+            const len = this.#rowSlices[base + 2];
+            source.copy(chunks[0], used, start, start + len);
+            slices[base] = 0;
+            slices[base + 1] = used;
+            slices[base + 2] = len;
+            used += len;
+        }
+        this.#chunks = chunks;
+        this.#rowSlices = slices;
+        this.#payloadBytes = used;
+        // The scan cursor survives: its cached offsets are relative to each row's (copied) payload
+    }
+    /** Validates `rowIndex` and returns its base index into the `#rowSlices` table. */
+    #rowBase(rowIndex) {
+        if (!(rowIndex >= 0 && rowIndex < this.#rowCount)) {
+            throw new Error(`Invalid rowIndex ${rowIndex} (rowCount ${this.#rowCount})`);
+        }
+        const base = rowIndex * ROW_STRIDE;
+        if (this.#rowSlices[base + 2] === DROPPED) {
+            throw new Error(`Row ${rowIndex} was compacted away (its entity was already loaded)`);
+        }
+        return base;
+    }
+    /**
+     * Scans a row's cells to `column`'s ordinal and decodes it.
+     *
+     * An adaptive per-row scan cursor caches the furthest cell boundary already scanned — the
+     * ordinal whose row-relative offset is known (`#scanOrdinal`/`#scanOffset`) — so ascending
+     * reads resume instead of re-scanning from the row start: a dense in-order read of all C
+     * columns costs one linear pass rather than O(C^2) length-prefix skips. Out-of-order
+     * (descending) faults simply scan from the start, i.e. never worse than without the cursor.
+     * The arrays are a fixed 6 bytes/row, allocated lazily on the first fault deep enough for
+     * resuming to matter, and — being row-relative — stay valid across compaction.
+     */
+    #readCell(chunk, start, end, column, rowIndex) {
+        const fieldCount = chunk.readInt16BE(start);
+        const { ordinal } = column;
+        if (ordinal >= fieldCount) {
+            throw new Error(`Row ${rowIndex} has ${fieldCount} cells but column ${column.name} is #${column.ordinal}`);
+        }
+        let pos = start + 2;
+        let c = 0;
+        let scanOrdinal = this.#scanOrdinal;
+        if (scanOrdinal === undefined && ordinal >= SCAN_CURSOR_MIN_ORDINAL) {
+            scanOrdinal = this.#scanOrdinal = new Uint16Array(this.#rowCount);
+            this.#scanOffset = new Uint32Array(this.#rowCount);
+        }
+        if (scanOrdinal !== undefined && rowIndex < scanOrdinal.length) {
+            // 0 = unset: caching cell #0 would be pointless (it is always at offset 2), so any real
+            // entry is the ordinal, >= 1, whose row-relative offset is in #scanOffset
+            const known = scanOrdinal[rowIndex];
+            if (known !== 0 && known <= ordinal) {
+                c = known;
+                pos = start + this.#scanOffset[rowIndex];
+            }
+        }
+        for (; c < ordinal; c++) {
+            const len = this.#cellLength(chunk, pos, end, rowIndex);
+            pos += len > 0 ? len + 4 : 4;
+        }
+        const len = this.#cellLength(chunk, pos, end, rowIndex);
+        if (scanOrdinal !== undefined && rowIndex < scanOrdinal.length && ordinal + 1 > scanOrdinal[rowIndex]) {
+            // advance-only: after reading cell #ordinal we know where cell #ordinal+1 starts
+            scanOrdinal[rowIndex] = ordinal + 1;
+            this.#scanOffset[rowIndex] = pos + 4 + (len > 0 ? len : 0) - start;
+        }
+        if (len === -1)
+            return null;
+        return column.decode(chunk, pos + 4, len);
+    }
+    /** Reads + validates one cell's length prefix. */
+    #cellLength(chunk, pos, end, rowIndex) {
+        if (pos + 4 > end)
+            throw new Error(`Truncated DataRow payload in row ${rowIndex}`);
+        const len = chunk.readInt32BE(pos);
+        if (len < -1 || (len > 0 && pos + 4 + len > end)) {
+            throw new Error(`Malformed cell length ${len} in row ${rowIndex}`);
+        }
+        return len;
+    }
+}
+exports.WireRowData = WireRowData;
+/**
+ * Executes `sql` on an already-checked-out client, returning a {@link RowData} instead of
+ * materialized POJO rows.
+ *
+ * Uses a `pg` Query subclass that records each DataRow's raw payload bytes into the result
+ * (via the lazy DataRow message from `patchPgProtocol`) and never materializes per-cell
+ * strings or per-row objects. If the client's connection turns out to use an unpatched
+ * pg-protocol copy (i.e. the app's pool was built from a different `pg` install than the one
+ * joist-orm patched), the query fails with a descriptive error — a misconfiguration any CI
+ * build/smoketest will surface immediately, so we fail loudly rather than silently degrade.
+ * The rows already streamed are discarded; the connection itself stays usable.
+ *
+ * By default the query requests *binary* result format (via the extended protocol), so scalar
+ * cells decode wire-bytes -> value with no intermediate strings; see `wireBinaryParser` for the
+ * parity strategy. Pass `binary: false` for classic text-format results, or set
+ * `JOIST_LAZY_BINARY=0` to flip the default while the binary path is a prototype (i.e. for
+ * A/B benchmarking or as an escape hatch).
+ */
+// The prototype escape hatch for binary results, i.e. for A/B benchmarking; read once at load
+const BINARY_BY_DEFAULT = process.env.JOIST_LAZY_BINARY !== "0";
+function executeRowDataQuery(client, sql, bindings, opts) {
+    const binary = opts?.binary ?? BINARY_BY_DEFAULT;
+    return new Promise((resolve, reject) => {
+        const query = new RowDataQuery(
+        // Binary results require the extended protocol; `queryMode` forces it for bindings-less queries
+        binary
+            ? { text: sql, values: bindings, binary: true, queryMode: "extended" }
+            : { text: sql, values: bindings }, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve(query.rowData);
+        });
+        client.query(query);
+    });
+}
+/** Returns whether `client` supports the lazy row-data query path, before submitting anything. */
+function isRowDataCapableClient(client) {
+    // Require the pure-JS pg client (pg-native has no `connection` and different query internals)
+    return (typeof client === "object" &&
+        client !== null &&
+        typeof client.query === "function" &&
+        client.connection !== undefined &&
+        client.native === undefined);
+}
+/** A pg Query that diverts DataRows into a {@link WireRowData} instead of a `Result`. */
+class RowDataQuery extends PgQuery {
+    #wire = new WireRowData();
+    constructor(config, callback) {
+        super(config, undefined, callback);
+    }
+    /**
+     * The query's result rows, i.e. once our callback has fired.
+     *
+     * If a small-result materialization threshold ever seems attractive, this is where it would
+     * go — but see the "Small results deliberately stay lazy" note on {@link WireRowData}: lazy
+     * won the measured comparison at every row count for sparse access, so no threshold exists.
+     */
+    get rowData() {
+        return this.#wire;
+    }
+    handleRowDescription(msg) {
+        if (this._canceledDueToError)
+            return;
+        try {
+            super.handleRowDescription(msg);
+            // Resolve active *text* parsers through the client's TypeOverrides chain (client.js
+            // injects `_types` at submit time); we can't reuse `Result._parsers` because in binary
+            // mode those resolve to pg's (broken) binary registry, while our binary decode path is
+            // built on text-parser parity — see `wireBinaryParser`
+            const types = this._result?._types;
+            this.#wire.setRowDescription(msg.fields, types && ((oid) => types.getTypeParser(oid, "text")));
+        }
+        catch (err) {
+            // Mirror pg's Query error containment: record + reject at ReadyForQuery, keeping the
+            // connection's protocol state intact
+            this._canceledDueToError = err;
+        }
+    }
+    handleDataRow(msg) {
+        if (this._canceledDueToError)
+            return;
+        try {
+            if (msg.bytes === undefined) {
+                // This connection's pg-protocol copy is unpatched (i.e. the pool came from a different
+                // `pg` install than the one joist-orm patched), so lazyRows cannot work — fail loudly
+                // rather than silently degrade; any CI build/smoketest will surface this immediately
+                throw new Error("joist-orm: lazyRows is enabled, but this connection's pg-protocol emits classic" +
+                    " DataRows (likely a duplicate pg install); fix the install or disable lazyRows.");
+            }
+            // `msg.length` includes the int32 length field itself, so the payload is `length - 4`;
+            // our patched message carries the real length from `handlePacket`'s argument
+            this.#wire.addRow(msg.bytes, msg.offset, msg.length - 4);
+        }
+        catch (err) {
+            this._canceledDueToError = err;
+        }
+    }
+}
+/** Builds a text-format cell decoder: utf8-slice the cell bytes into the active text parser. */
+function textCellDecoder(parse) {
+    return (chunk, start, length) => parse(chunk.toString("utf8", start, start + length));
+}
+//# sourceMappingURL=WireRowData.js.map

package/build/drivers/WireRowData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WireRowData.js","sourceRoot":"","sources":["../../src/drivers/WireRowData.ts"],"names":[],"mappings":"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"}

package/build/drivers/binaryParsers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Joist's registry of PostgreSQL *binary-format* cell parsers, used by `WireRowData` for lazy
+ * `em.find`/`em.load` results (which request binary output; see `executeRowDataQuery`).
+ *
+ * This registry is deliberately **separate from `pg.types`**: `pg.types.setTypeParser` and
+ * pool/client `TypeOverrides` continue to govern classic *text* results (knex, `pool.query`,
+ * non-lazy drivers), while binary cells decode wire-bytes -> values directly — ints via
+ * `readInt32BE`, timestamps via µs arithmetic, Temporal values constructed without ever
+ * materializing a string. There is no fallback from one registry to the other:
+ *
+ * - Built-in parsers cover the standard scalar/array types below; `setupLatestPgTypes`
+ *   registers the date/time parsers appropriate to Date-vs-Temporal mode.
+ * - Custom/extension types (native enums, citext, domains, hstore, ...) must be registered
+ *   explicitly with {@link setBinaryTypeParser} — text-like types can use
+ *   {@link binaryTextParser}, arrays of registered elements can use {@link binaryArrayParser}.
+ * - A query selecting a column whose oid has no registered parser **fails** with a descriptive
+ *   error (see `WireRowData.setRowDescription`), rather than guessing at a lossy decoding.
+ *
+ * Values produced here should match what the classic text path produces for the same column
+ * (i.e. `numeric` stays a string, `int8` stays a string, Date-mode timestamps become `Date`s),
+ * so entities hydrate identically in either mode; Temporal-mode parsers construct
+ * `Temporal.PlainDate`/`ZonedDateTime`/etc. directly, and the temporal mappers pass
+ * already-constructed instances through.
+ */
+export declare function setBinaryTypeParser(oid: number, parse: BinaryParse): void;
+/** Returns the registered binary parser for `oid`, i.e. for tests to save/restore. */
+export declare function getBinaryTypeParser(oid: number): BinaryParse | undefined;
+/** Decodes one binary cell directly from the payload chunk; `length` is the cell's byte length. */
+export type BinaryParse = (chunk: Buffer, start: number, length: number) => any;
+/**
+ * Auto-registers binary parsers for the database's text-like dynamic-oid types — native enums
+ * and citext, plus their array types — so apps get those for free.
+ *
+ * `PostgresDriver` calls this lazily before its first lazy query; apps can also call it
+ * directly (i.e. at boot) if they want the registrations eagerly. Explicit
+ * `setBinaryTypeParser` registrations are never overwritten.
+ */
+export declare function registerDatabaseBinaryParsers(pool: {
+    query(sql: string): Promise<{
+        rows: any[];
+    }>;
+}): Promise<void>;
+/**
+ * Sets the session `TimeZone` used to zone temporal-mode `timestamptz` loads; normally captured
+ * automatically by {@link registerDatabaseBinaryParsers}. One zone per process — pools with
+ * differing session TimeZones are not supported by the binary path.
+ */
+export declare function setSessionTimeZone(timeZone: string): void;
+/** Decodes a cell's bytes as utf8 text, i.e. for text-like custom types (enums, citext, domains). */
+export declare function binaryTextParser(chunk: Buffer, start: number, length: number): string;
+/**
+ * Decodes a binary array cell into a JS array of element values.
+ *
+ * The element oid is embedded in the wire format, and each element decodes through this
+ * registry — so arrays of any registered type (including custom-registered oids and the
+ * mode-appropriate temporal types) work without separate element wiring. Registered for the
+ * standard `_type` oids below; register it for custom array oids as needed.
+ */
+export declare function binaryArrayParser(chunk: Buffer, start: number, length: number): any[];
+/** Decodes binary `date` cells to `Date`s, matching postgres-date's text semantics; Date mode. */
+export declare function binaryDateToDate(chunk: Buffer, start: number): any;
+/** Decodes binary `timestamp` (without zone) cells to local-time `Date`s; Date mode. */
+export declare function binaryTimestampToDate(chunk: Buffer, start: number): any;
+/** Decodes binary `timestamptz` cells to `Date`s (µs floor to ms, like the text parse); Date mode. */
+export declare function binaryTimestamptzToDate(chunk: Buffer, start: number): any;
+/**
+ * Registers the Temporal-mode binary parsers: date/time/timestamp/timestamptz cells construct
+ * `Temporal` values *directly* from the wire µs/days — no intermediate strings, no
+ * `temporalMappers.fromDb` parsing (the mappers pass already-constructed instances through).
+ *
+ * `timestamptz` matches the text path's zoning exactly: classic parsing zones the value by the
+ * offset the session's `TimeZone` rendered (normalizing `+00` to `UTC`), so we compute the
+ * session zone's offset at each instant (see `setSessionTimeZone`; the configured
+ * `temporal.timeZone` only governs `now`-conversions, not loads).
+ */
+export declare function registerTemporalBinaryParsers(): void;