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

package/build/drivers/patchPgProtocol.js

@@ -1,274 +1,253 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LazyDataRowMessage = void 0;
-exports.ensureLazyDataRows = ensureLazyDataRows;
-const node_path_1 = require("node:path");
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+//#region src/drivers/patchPgProtocol.ts
+const runtimeRequire = createRequire(import.meta.url);
 /**
- * Patches pg-protocol at runtime so that DataRow messages are lazy *and* their bytes are
- * immutable, i.e. so `WireRowData` can retain raw row payloads by reference — no per-cell
- * strings, no per-row copies, no arena.
- *
- * We patch at runtime (instead of shipping a patched pg-protocol) so that installing joist-orm
- * requires no package-manager patch steps; see JS-ROW-STORE-DESIGN.md "Distribution". Two
- * prototype methods are replaced, porting brianc/node-postgres#3719 (which may or may not ever
- * land upstream — this patch is how we run its design in production regardless):
- *
- * - `handlePacket` (stable across pg-protocol 1.10-1.15) returns a {@link LazyDataRowMessage}
- *   for DataRow packets and delegates every other message type to the original.
- * - `parse` replaces the recycled-scratch buffer management: each socket chunk is parsed *in
- *   place*, and only the one message per chunk that straddles a read boundary is reassembled
- *   into a buffer of its own, which is handed to that message and never touched again. Every
- *   message therefore stays valid for as long as it is held (holding one pins the ~64 KiB chunk
- *   it came from) — versus stock pg-protocol, which copies whole chunks into a scratch buffer
- *   and compacts it in place over the bytes earlier messages point into.
- *
- * The patch verifies itself by round-tripping synthetic DataRows through a fresh `Parser` —
- * including a message that straddles chunks, retained across later reads that would clobber it
- * under the stock buffer management. On any mismatch (i.e. a future pg-protocol internals
- * rewrite), it un-patches and reports failure so the driver can fall back to classic rows.
- *
- * The lazy message's memoized `fields` getter decodes identically to the original for classic
- * consumers, i.e. pg's own `Result.parseRow(msg.fields)`.
- */
+* Patches pg-protocol at runtime so that DataRow messages are lazy *and* their bytes are
+* immutable, i.e. so `WireRowData` can retain raw row payloads by reference — no per-cell
+* strings, no per-row copies, no arena.
+*
+* We patch at runtime (instead of shipping a patched pg-protocol) so that installing joist-orm
+* requires no package-manager patch steps; see JS-ROW-STORE-DESIGN.md "Distribution". Two
+* prototype methods are replaced, porting brianc/node-postgres#3719 (which may or may not ever
+* land upstream — this patch is how we run its design in production regardless):
+*
+* - `handlePacket` (stable across pg-protocol 1.10-1.15) returns a {@link LazyDataRowMessage}
+*   for DataRow packets and delegates every other message type to the original.
+* - `parse` replaces the recycled-scratch buffer management: each socket chunk is parsed *in
+*   place*, and only the one message per chunk that straddles a read boundary is reassembled
+*   into a buffer of its own, which is handed to that message and never touched again. Every
+*   message therefore stays valid for as long as it is held (holding one pins the ~64 KiB chunk
+*   it came from) — versus stock pg-protocol, which copies whole chunks into a scratch buffer
+*   and compacts it in place over the bytes earlier messages point into.
+*
+* The patch verifies itself by round-tripping synthetic DataRows through a fresh `Parser` —
+* including a message that straddles chunks, retained across later reads that would clobber it
+* under the stock buffer management. On any mismatch (i.e. a future pg-protocol internals
+* rewrite), it un-patches and reports failure so the driver can fall back to classic rows.
+*
+* The lazy message's memoized `fields` getter decodes identically to the original for classic
+* consumers, i.e. pg's own `Result.parseRow(msg.fields)`.
+*/
 function ensureLazyDataRows() {
-    patched ??= tryPatch() ? "applied" : "failed";
-    return patched === "applied";
+	patched ??= tryPatch() ? "applied" : "failed";
+	return patched === "applied";
 }
 /** A drop-in `DataRowMessage` that defers cell decoding; lazy consumers read `bytes`/`offset`. */
-class LazyDataRowMessage {
-    length;
-    bytes;
-    offset;
-    name = "dataRow";
-    fieldCount;
-    #fields = undefined;
-    constructor(length, 
-    /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
-    bytes, offset) {
-        this.length = length;
-        this.bytes = bytes;
-        this.offset = offset;
-        this.fieldCount = bytes.readInt16BE(offset);
-    }
-    /** Lazily materializes the per-cell strings for classic consumers, i.e. pg's `Result.parseRow`. */
-    get fields() {
-        let fields = this.#fields;
-        if (fields === undefined) {
-            const { bytes, fieldCount } = this;
-            fields = new Array(fieldCount);
-            let pos = this.offset + 2;
-            for (let i = 0; i < fieldCount; i++) {
-                const len = bytes.readInt32BE(pos);
-                pos += 4;
-                if (len === -1) {
-                    fields[i] = null;
-                }
-                else {
-                    fields[i] = bytes.toString("utf8", pos, pos + len);
-                    pos += len;
-                }
-            }
-            this.#fields = fields;
-        }
-        return fields;
-    }
-}
-exports.LazyDataRowMessage = LazyDataRowMessage;
+var LazyDataRowMessage = class {
+	length;
+	bytes;
+	offset;
+	name = "dataRow";
+	fieldCount;
+	#fields = void 0;
+	constructor(length, bytes, offset) {
+		this.length = length;
+		this.bytes = bytes;
+		this.offset = offset;
+		this.fieldCount = bytes.readInt16BE(offset);
+	}
+	/** Lazily materializes the per-cell strings for classic consumers, i.e. pg's `Result.parseRow`. */
+	get fields() {
+		let fields = this.#fields;
+		if (fields === void 0) {
+			const { bytes, fieldCount } = this;
+			fields = new Array(fieldCount);
+			let pos = this.offset + 2;
+			for (let i = 0; i < fieldCount; i++) {
+				const len = bytes.readInt32BE(pos);
+				pos += 4;
+				if (len === -1) fields[i] = null;
+				else {
+					fields[i] = bytes.toString("utf8", pos, pos + len);
+					pos += len;
+				}
+			}
+			this.#fields = fields;
+		}
+		return fields;
+	}
+};
 let patched;
 /** The 'D' message-type byte identifying a DataRow packet. */
 const DATA_ROW_CODE = 68;
 const CODE_LENGTH = 1;
 const HEADER_LENGTH = 5;
 /** Cap on up-front allocation for a straddling message's claimed length, i.e. corrupt streams. */
-const MAX_EAGER_MESSAGE_LENGTH = 1024 * 1024;
+const MAX_EAGER_MESSAGE_LENGTH = 1048576;
 const emptyBuffer = Buffer.allocUnsafe(0);
 /** Resolves pg's own pg-protocol Parser class and swaps in the lazy/immutable DataRow handling. */
 function tryPatch() {
-    try {
-        const { Parser, version } = resolvePgProtocol();
-        // Only patch the protocol major we've verified `handlePacket`'s shape against (1.10-1.15);
-        // anything else fails closed (the driver then uses classic rows) until explicitly vetted
-        if (!/^1\./.test(version))
-            return false;
-        const originalHandlePacket = Parser.prototype.handlePacket;
-        const originalParse = Parser.prototype.parse;
-        if (typeof originalHandlePacket !== "function" || typeof originalParse !== "function")
-            return false;
-        Parser.prototype.handlePacket = function (offset, code, length, bytes) {
-            if (code === DATA_ROW_CODE)
-                return new LazyDataRowMessage(length, bytes, offset);
-            return originalHandlePacket.call(this, offset, code, length, bytes);
-        };
-        Parser.prototype.parse = patchedParse;
-        if (!verifyLazyDataRows(Parser) || !verifyImmutableBytes(Parser)) {
-            Parser.prototype.handlePacket = originalHandlePacket;
-            Parser.prototype.parse = originalParse;
-            return false;
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
+	try {
+		const { Parser, version } = resolvePgProtocol();
+		if (!version.startsWith("1.")) return false;
+		const originalHandlePacket = Parser.prototype.handlePacket;
+		const originalParse = Parser.prototype.parse;
+		if (typeof originalHandlePacket !== "function" || typeof originalParse !== "function") return false;
+		Parser.prototype.handlePacket = function(offset, code, length, bytes) {
+			if (code === DATA_ROW_CODE) return new LazyDataRowMessage(length, bytes, offset);
+			return originalHandlePacket.call(this, offset, code, length, bytes);
+		};
+		Parser.prototype.parse = patchedParse;
+		if (!verifyLazyDataRows(Parser) || !verifyImmutableBytes(Parser)) {
+			Parser.prototype.handlePacket = originalHandlePacket;
+			Parser.prototype.parse = originalParse;
+			return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
 }
 /**
- * The ported #3719 `parse`: chunks are parsed in place, and only the message that straddles a
- * read boundary is reassembled into its own buffer (see `completePartial`). Partial state lives
- * on the parser instance under `_joist`-prefixed keys, so the stock fields are simply unused.
- */
+* The ported #3719 `parse`: chunks are parsed in place, and only the message that straddles a
+* read boundary is reassembled into its own buffer (see `completePartial`). Partial state lives
+* on the parser instance under `_joist`-prefixed keys, so the stock fields are simply unused.
+*/
 function patchedParse(chunk, callback) {
-    const chunkLength = chunk.byteLength;
-    // finish the message the previous chunk cut in half, if any, before parsing this one
-    let offset = this._joistPartialLength > 0 ? completePartial(this, chunk, callback) : 0;
-    while (offset + HEADER_LENGTH <= chunkLength) {
-        const code = chunk[offset];
-        const length = chunk.readUInt32BE(offset + CODE_LENGTH);
-        const fullMessageLength = CODE_LENGTH + length;
-        if (fullMessageLength + offset <= chunkLength) {
-            const message = this.handlePacket(offset + HEADER_LENGTH, code, length, chunk);
-            callback(message);
-            offset += fullMessageLength;
-        }
-        else {
-            break;
-        }
-    }
-    if (offset < chunkLength) {
-        startPartial(this, chunk, offset);
-    }
+	const chunkLength = chunk.byteLength;
+	let offset = this._joistPartialLength > 0 ? completePartial(this, chunk, callback) : 0;
+	while (offset + HEADER_LENGTH <= chunkLength) {
+		const code = chunk[offset];
+		const length = chunk.readUInt32BE(offset + CODE_LENGTH);
+		const fullMessageLength = CODE_LENGTH + length;
+		if (fullMessageLength + offset <= chunkLength) {
+			callback(this.handlePacket(offset + HEADER_LENGTH, code, length, chunk));
+			offset += fullMessageLength;
+		} else break;
+	}
+	if (offset < chunkLength) startPartial(this, chunk, offset);
 }
 /** Copies the trailing bytes of `chunk` that do not yet form a whole message into their own buffer. */
 function startPartial(parser, chunk, offset) {
-    const remaining = chunk.byteLength - offset;
-    parser._joistPartial = emptyBuffer;
-    parser._joistPartialLength = 0;
-    // the length is only known once the header is complete
-    parser._joistPartialTotal = remaining >= HEADER_LENGTH ? CODE_LENGTH + chunk.readUInt32BE(offset + CODE_LENGTH) : -1;
-    growPartial(parser, remaining);
-    chunk.copy(parser._joistPartial, 0, offset);
-    parser._joistPartialLength = remaining;
+	const remaining = chunk.byteLength - offset;
+	parser._joistPartial = emptyBuffer;
+	parser._joistPartialLength = 0;
+	parser._joistPartialTotal = remaining >= HEADER_LENGTH ? CODE_LENGTH + chunk.readUInt32BE(offset + CODE_LENGTH) : -1;
+	growPartial(parser, remaining);
+	chunk.copy(parser._joistPartial, 0, offset);
+	parser._joistPartialLength = remaining;
 }
 /**
- * Fills the straddling message from the head of `chunk` and emits it once whole, returning the
- * offset in `chunk` where parsing continues. The buffer is handed to the message and forgotten,
- * so nothing is ever parsed twice out of the same bytes and the message stays valid when held.
- */
+* Fills the straddling message from the head of `chunk` and emits it once whole, returning the
+* offset in `chunk` where parsing continues. The buffer is handed to the message and forgotten,
+* so nothing is ever parsed twice out of the same bytes and the message stays valid when held.
+*/
 function completePartial(parser, chunk, callback) {
-    let consumed = 0;
-    if (parser._joistPartialTotal === -1) {
-        // the header itself was split, so complete it before its length can be read
-        consumed = Math.min(HEADER_LENGTH - parser._joistPartialLength, chunk.byteLength);
-        chunk.copy(parser._joistPartial, parser._joistPartialLength, 0, consumed);
-        parser._joistPartialLength += consumed;
-        if (parser._joistPartialLength < HEADER_LENGTH)
-            return consumed;
-        parser._joistPartialTotal = CODE_LENGTH + parser._joistPartial.readUInt32BE(CODE_LENGTH);
-    }
-    if (parser._joistPartialLength < parser._joistPartialTotal) {
-        const available = Math.min(parser._joistPartialTotal - parser._joistPartialLength, chunk.byteLength - consumed);
-        growPartial(parser, parser._joistPartialLength + available);
-        chunk.copy(parser._joistPartial, parser._joistPartialLength, consumed, consumed + available);
-        parser._joistPartialLength += available;
-        consumed += available;
-        if (parser._joistPartialLength < parser._joistPartialTotal)
-            return consumed;
-    }
-    const partial = parser._joistPartial;
-    parser._joistPartial = emptyBuffer;
-    parser._joistPartialLength = 0;
-    parser._joistPartialTotal = -1;
-    const message = parser.handlePacket(HEADER_LENGTH, partial[0], partial.readUInt32BE(CODE_LENGTH), partial);
-    callback(message);
-    return consumed;
+	let consumed = 0;
+	if (parser._joistPartialTotal === -1) {
+		consumed = Math.min(HEADER_LENGTH - parser._joistPartialLength, chunk.byteLength);
+		chunk.copy(parser._joistPartial, parser._joistPartialLength, 0, consumed);
+		parser._joistPartialLength += consumed;
+		if (parser._joistPartialLength < HEADER_LENGTH) return consumed;
+		parser._joistPartialTotal = CODE_LENGTH + parser._joistPartial.readUInt32BE(CODE_LENGTH);
+	}
+	if (parser._joistPartialLength < parser._joistPartialTotal) {
+		const available = Math.min(parser._joistPartialTotal - parser._joistPartialLength, chunk.byteLength - consumed);
+		growPartial(parser, parser._joistPartialLength + available);
+		chunk.copy(parser._joistPartial, parser._joistPartialLength, consumed, consumed + available);
+		parser._joistPartialLength += available;
+		consumed += available;
+		if (parser._joistPartialLength < parser._joistPartialTotal) return consumed;
+	}
+	const partial = parser._joistPartial;
+	parser._joistPartial = emptyBuffer;
+	parser._joistPartialLength = 0;
+	parser._joistPartialTotal = -1;
+	callback(parser.handlePacket(HEADER_LENGTH, partial[0], partial.readUInt32BE(CODE_LENGTH), partial));
+	return consumed;
 }
 /** Sizes the partial buffer to hold at least `needed` bytes, i.e. the whole message when known. */
 function growPartial(parser, needed) {
-    if (needed <= parser._joistPartial.byteLength)
-        return;
-    const total = parser._joistPartialTotal;
-    // grow geometrically, jumping straight to the message's full length when known and modest
-    const whole = total === -1 ? HEADER_LENGTH : Math.min(total, MAX_EAGER_MESSAGE_LENGTH);
-    let capacity = Math.max(needed, whole, parser._joistPartial.byteLength * 2);
-    if (total !== -1 && capacity > total)
-        capacity = total;
-    const grown = Buffer.allocUnsafe(capacity);
-    parser._joistPartial.copy(grown, 0, 0, parser._joistPartialLength);
-    parser._joistPartial = grown;
+	if (needed <= parser._joistPartial.byteLength) return;
+	const total = parser._joistPartialTotal;
+	let capacity = Math.max(needed, total === -1 ? HEADER_LENGTH : Math.min(total, MAX_EAGER_MESSAGE_LENGTH), parser._joistPartial.byteLength * 2);
+	if (total !== -1 && capacity > total) capacity = total;
+	const grown = Buffer.allocUnsafe(capacity);
+	parser._joistPartial.copy(grown, 0, 0, parser._joistPartialLength);
+	parser._joistPartial = grown;
 }
 /** Loads the Parser class + version from the pg-protocol instance that `pg` itself resolves to. */
 function resolvePgProtocol() {
-    // Resolve pg-protocol relative to pg, so that we patch the copy pg's Connections actually
-    // use, even if the dependency tree has multiple pg-protocol installs
-    const pgPath = require.resolve("pg");
-    const parserPath = require.resolve("pg-protocol/dist/parser.js", { paths: [(0, node_path_1.dirname)(pgPath)] });
-    // An absolute-path require bypasses the package's exports map, so this is always readable
-    const { version } = require((0, node_path_1.join)((0, node_path_1.dirname)(parserPath), "..", "package.json"));
-    return { Parser: require(parserPath).Parser, version };
+	const pgPath = runtimeRequire.resolve("pg");
+	const parserPath = runtimeRequire.resolve("pg-protocol/dist/parser.js", { paths: [dirname(pgPath)] });
+	const { version } = runtimeRequire(join(dirname(parserPath), "..", "package.json"));
+	return {
+		Parser: runtimeRequire(parserPath).Parser,
+		version
+	};
 }
 /** Round-trips a synthetic two-cell DataRow (utf8 + NULL) through a fresh patched Parser. */
 function verifyLazyDataRows(Parser) {
-    const cell = Buffer.from("wörld", "utf8");
-    const payload = Buffer.concat([
-        Buffer.from([0, 2]), // int16 fieldCount
-        int32(cell.length),
-        cell,
-        int32(-1), // NULL cell
-    ]);
-    const frame = Buffer.concat([Buffer.from("D"), int32(payload.length + 4), payload]);
-    let ok = false;
-    new Parser().parse(frame, (msg) => {
-        ok =
-            msg.name === "dataRow" &&
-                msg.fieldCount === 2 &&
-                msg.bytes !== undefined &&
-                typeof msg.offset === "number" &&
-                msg.fields.length === 2 &&
-                msg.fields[0] === "wörld" &&
-                msg.fields[1] === null;
-    });
-    return ok;
+	const cell = Buffer.from("wörld", "utf8");
+	const payload = Buffer.concat([
+		Buffer.from([0, 2]),
+		int32(cell.length),
+		cell,
+		int32(-1)
+	]);
+	const frame = Buffer.concat([
+		Buffer.from("D"),
+		int32(payload.length + 4),
+		payload
+	]);
+	let ok = false;
+	new Parser().parse(frame, (msg) => {
+		ok = msg.name === "dataRow" && msg.fieldCount === 2 && msg.bytes !== void 0 && typeof msg.offset === "number" && msg.fields.length === 2 && msg.fields[0] === "wörld" && msg.fields[1] === null;
+	});
+	return ok;
 }
 /**
- * Verifies a straddling DataRow's bytes survive later parser reads.
- *
- * We retain a message that straddles two chunks, drive a third read shaped to trigger the stock
- * parser's move-to-front compaction over its bytes, and only then decode the retained message's
- * cell (the `fields` getter memoizes, so it must not be read earlier). Under our `parse` patch
- * the straddler owns its buffer, so the cell decodes intact.
- */
+* Verifies a straddling DataRow's bytes survive later parser reads.
+*
+* We retain a message that straddles two chunks, drive a third read shaped to trigger the stock
+* parser's move-to-front compaction over its bytes, and only then decode the retained message's
+* cell (the `fields` getter memoizes, so it must not be read earlier). Under our `parse` patch
+* the straddler owns its buffer, so the cell decodes intact.
+*/
 function verifyImmutableBytes(Parser) {
-    const cellB = "b".repeat(85);
-    const frameA = dataRowFrame("aaaa"); // 15 bytes, fully inside chunk1
-    const frameB = dataRowFrame(cellB); // 96 bytes, straddles chunk1/chunk2
-    const frameC = dataRowFrame("c".repeat(45)); // 56 bytes, straddles chunk2/chunk3
-    const chunk1 = Buffer.concat([frameA, frameB.subarray(0, 50)]);
-    const chunk2 = Buffer.concat([frameB.subarray(50), frameC.subarray(0, 30)]);
-    const chunk3 = Buffer.from(frameC.subarray(30));
-    const messages = [];
-    const parser = new Parser();
-    function collect(msg) {
-        messages.push(msg);
-    }
-    parser.parse(chunk1, collect);
-    parser.parse(chunk2, collect);
-    parser.parse(chunk3, collect);
-    try {
-        return messages.length === 3 && messages[1].name === "dataRow" && messages[1].fields[0] === cellB;
-    }
-    catch {
-        return false;
-    }
+	const cellB = "b".repeat(85);
+	const frameA = dataRowFrame("aaaa");
+	const frameB = dataRowFrame(cellB);
+	const frameC = dataRowFrame("c".repeat(45));
+	const chunk1 = Buffer.concat([frameA, frameB.subarray(0, 50)]);
+	const chunk2 = Buffer.concat([frameB.subarray(50), frameC.subarray(0, 30)]);
+	const chunk3 = Buffer.from(frameC.subarray(30));
+	const messages = [];
+	const parser = new Parser();
+	function collect(msg) {
+		messages.push(msg);
+	}
+	parser.parse(chunk1, collect);
+	parser.parse(chunk2, collect);
+	parser.parse(chunk3, collect);
+	try {
+		return messages.length === 3 && messages[1].name === "dataRow" && messages[1].fields[0] === cellB;
+	} catch {
+		return false;
+	}
 }
 /** Builds a complete one-cell DataRow frame (code + int32 length + payload) for `cell`. */
 function dataRowFrame(cell) {
-    const bytes = Buffer.from(cell, "utf8");
-    const payload = Buffer.concat([Buffer.from([0, 1]), int32(bytes.length), bytes]);
-    return Buffer.concat([Buffer.from("D"), int32(payload.length + 4), payload]);
+	const bytes = Buffer.from(cell, "utf8");
+	const payload = Buffer.concat([
+		Buffer.from([0, 1]),
+		int32(bytes.length),
+		bytes
+	]);
+	return Buffer.concat([
+		Buffer.from("D"),
+		int32(payload.length + 4),
+		payload
+	]);
 }
 /** Returns a 4-byte big-endian buffer for `value`. */
 function int32(value) {
-    const buffer = Buffer.alloc(4);
-    buffer.writeInt32BE(value);
-    return buffer;
+	const buffer = Buffer.alloc(4);
+	buffer.writeInt32BE(value);
+	return buffer;
 }
+//#endregion
+export { LazyDataRowMessage, ensureLazyDataRows };
+
 //# sourceMappingURL=patchPgProtocol.js.map

package/build/drivers/patchPgProtocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"patchPgProtocol.js","sourceRoot":"","sources":["../../src/drivers/patchPgProtocol.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"patchPgProtocol.js","names":["#fields"],"sources":["../../src/drivers/patchPgProtocol.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\n\nconst runtimeRequire = createRequire(import.meta.url);\n\n/**\n * Patches pg-protocol at runtime so that DataRow messages are lazy *and* their bytes are\n * immutable, i.e. so `WireRowData` can retain raw row payloads by reference — no per-cell\n * strings, no per-row copies, no arena.\n *\n * We patch at runtime (instead of shipping a patched pg-protocol) so that installing joist-orm\n * requires no package-manager patch steps; see JS-ROW-STORE-DESIGN.md \"Distribution\". Two\n * prototype methods are replaced, porting brianc/node-postgres#3719 (which may or may not ever\n * land upstream — this patch is how we run its design in production regardless):\n *\n * - `handlePacket` (stable across pg-protocol 1.10-1.15) returns a {@link LazyDataRowMessage}\n *   for DataRow packets and delegates every other message type to the original.\n * - `parse` replaces the recycled-scratch buffer management: each socket chunk is parsed *in\n *   place*, and only the one message per chunk that straddles a read boundary is reassembled\n *   into a buffer of its own, which is handed to that message and never touched again. Every\n *   message therefore stays valid for as long as it is held (holding one pins the ~64 KiB chunk\n *   it came from) — versus stock pg-protocol, which copies whole chunks into a scratch buffer\n *   and compacts it in place over the bytes earlier messages point into.\n *\n * The patch verifies itself by round-tripping synthetic DataRows through a fresh `Parser` —\n * including a message that straddles chunks, retained across later reads that would clobber it\n * under the stock buffer management. On any mismatch (i.e. a future pg-protocol internals\n * rewrite), it un-patches and reports failure so the driver can fall back to classic rows.\n *\n * The lazy message's memoized `fields` getter decodes identically to the original for classic\n * consumers, i.e. pg's own `Result.parseRow(msg.fields)`.\n */\nexport function ensureLazyDataRows(): boolean {\n  patched ??= tryPatch() ? \"applied\" : \"failed\";\n  return patched === \"applied\";\n}\n\n/** A drop-in `DataRowMessage` that defers cell decoding; lazy consumers read `bytes`/`offset`. */\nexport class LazyDataRowMessage {\n  public readonly name = \"dataRow\";\n  public readonly fieldCount: number;\n  #fields: (string | null)[] | undefined = undefined;\n\n  constructor(\n    public readonly length: number,\n    /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */\n    public readonly bytes: Buffer,\n    public readonly offset: number,\n  ) {\n    this.fieldCount = bytes.readInt16BE(offset);\n  }\n\n  /** Lazily materializes the per-cell strings for classic consumers, i.e. pg's `Result.parseRow`. */\n  get fields(): (string | null)[] {\n    let fields = this.#fields;\n    if (fields === undefined) {\n      const { bytes, fieldCount } = this;\n      fields = new Array(fieldCount);\n      let pos = this.offset + 2;\n      for (let i = 0; i < fieldCount; i++) {\n        const len = bytes.readInt32BE(pos);\n        pos += 4;\n        if (len === -1) {\n          fields[i] = null;\n        } else {\n          fields[i] = bytes.toString(\"utf8\", pos, pos + len);\n          pos += len;\n        }\n      }\n      this.#fields = fields;\n    }\n    return fields;\n  }\n}\n\nlet patched: \"applied\" | \"failed\" | undefined;\n\n/** The 'D' message-type byte identifying a DataRow packet. */\nconst DATA_ROW_CODE = 68;\nconst CODE_LENGTH = 1;\nconst HEADER_LENGTH = 5;\n/** Cap on up-front allocation for a straddling message's claimed length, i.e. corrupt streams. */\nconst MAX_EAGER_MESSAGE_LENGTH = 1024 * 1024;\nconst emptyBuffer = Buffer.allocUnsafe(0);\n\n/** Resolves pg's own pg-protocol Parser class and swaps in the lazy/immutable DataRow handling. */\nfunction tryPatch(): boolean {\n  try {\n    const { Parser, version } = resolvePgProtocol();\n    // Only patch the protocol major we've verified `handlePacket`'s shape against (1.10-1.15);\n    // anything else fails closed (the driver then uses classic rows) until explicitly vetted\n    if (!version.startsWith(\"1.\")) return false;\n    const originalHandlePacket = Parser.prototype.handlePacket;\n    const originalParse = Parser.prototype.parse;\n    if (typeof originalHandlePacket !== \"function\" || typeof originalParse !== \"function\") return false;\n    Parser.prototype.handlePacket = function (offset: number, code: number, length: number, bytes: Buffer) {\n      if (code === DATA_ROW_CODE) return new LazyDataRowMessage(length, bytes, offset);\n      return originalHandlePacket.call(this, offset, code, length, bytes);\n    };\n    Parser.prototype.parse = patchedParse;\n    if (!verifyLazyDataRows(Parser) || !verifyImmutableBytes(Parser)) {\n      Parser.prototype.handlePacket = originalHandlePacket;\n      Parser.prototype.parse = originalParse;\n      return false;\n    }\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * The ported #3719 `parse`: chunks are parsed in place, and only the message that straddles a\n * read boundary is reassembled into its own buffer (see `completePartial`). Partial state lives\n * on the parser instance under `_joist`-prefixed keys, so the stock fields are simply unused.\n */\nfunction patchedParse(this: any, chunk: Buffer, callback: (msg: any) => void): void {\n  const chunkLength = chunk.byteLength;\n  // finish the message the previous chunk cut in half, if any, before parsing this one\n  let offset = this._joistPartialLength > 0 ? completePartial(this, chunk, callback) : 0;\n  while (offset + HEADER_LENGTH <= chunkLength) {\n    const code = chunk[offset];\n    const length = chunk.readUInt32BE(offset + CODE_LENGTH);\n    const fullMessageLength = CODE_LENGTH + length;\n    if (fullMessageLength + offset <= chunkLength) {\n      const message = this.handlePacket(offset + HEADER_LENGTH, code, length, chunk);\n      callback(message);\n      offset += fullMessageLength;\n    } else {\n      break;\n    }\n  }\n  if (offset < chunkLength) {\n    startPartial(this, chunk, offset);\n  }\n}\n\n/** Copies the trailing bytes of `chunk` that do not yet form a whole message into their own buffer. */\nfunction startPartial(parser: any, chunk: Buffer, offset: number): void {\n  const remaining = chunk.byteLength - offset;\n  parser._joistPartial = emptyBuffer;\n  parser._joistPartialLength = 0;\n  // the length is only known once the header is complete\n  parser._joistPartialTotal = remaining >= HEADER_LENGTH ? CODE_LENGTH + chunk.readUInt32BE(offset + CODE_LENGTH) : -1;\n  growPartial(parser, remaining);\n  chunk.copy(parser._joistPartial, 0, offset);\n  parser._joistPartialLength = remaining;\n}\n\n/**\n * Fills the straddling message from the head of `chunk` and emits it once whole, returning the\n * offset in `chunk` where parsing continues. The buffer is handed to the message and forgotten,\n * so nothing is ever parsed twice out of the same bytes and the message stays valid when held.\n */\nfunction completePartial(parser: any, chunk: Buffer, callback: (msg: any) => void): number {\n  let consumed = 0;\n  if (parser._joistPartialTotal === -1) {\n    // the header itself was split, so complete it before its length can be read\n    consumed = Math.min(HEADER_LENGTH - parser._joistPartialLength, chunk.byteLength);\n    chunk.copy(parser._joistPartial, parser._joistPartialLength, 0, consumed);\n    parser._joistPartialLength += consumed;\n    if (parser._joistPartialLength < HEADER_LENGTH) return consumed;\n    parser._joistPartialTotal = CODE_LENGTH + parser._joistPartial.readUInt32BE(CODE_LENGTH);\n  }\n  if (parser._joistPartialLength < parser._joistPartialTotal) {\n    const available = Math.min(parser._joistPartialTotal - parser._joistPartialLength, chunk.byteLength - consumed);\n    growPartial(parser, parser._joistPartialLength + available);\n    chunk.copy(parser._joistPartial, parser._joistPartialLength, consumed, consumed + available);\n    parser._joistPartialLength += available;\n    consumed += available;\n    if (parser._joistPartialLength < parser._joistPartialTotal) return consumed;\n  }\n  const partial = parser._joistPartial;\n  parser._joistPartial = emptyBuffer;\n  parser._joistPartialLength = 0;\n  parser._joistPartialTotal = -1;\n  const message = parser.handlePacket(HEADER_LENGTH, partial[0], partial.readUInt32BE(CODE_LENGTH), partial);\n  callback(message);\n  return consumed;\n}\n\n/** Sizes the partial buffer to hold at least `needed` bytes, i.e. the whole message when known. */\nfunction growPartial(parser: any, needed: number): void {\n  if (needed <= parser._joistPartial.byteLength) return;\n  const total = parser._joistPartialTotal;\n  // grow geometrically, jumping straight to the message's full length when known and modest\n  const whole = total === -1 ? HEADER_LENGTH : Math.min(total, MAX_EAGER_MESSAGE_LENGTH);\n  let capacity = Math.max(needed, whole, parser._joistPartial.byteLength * 2);\n  if (total !== -1 && capacity > total) capacity = total;\n  const grown = Buffer.allocUnsafe(capacity);\n  parser._joistPartial.copy(grown, 0, 0, parser._joistPartialLength);\n  parser._joistPartial = grown;\n}\n\n/** Loads the Parser class + version from the pg-protocol instance that `pg` itself resolves to. */\nfunction resolvePgProtocol(): { Parser: any; version: string } {\n  // Resolve pg-protocol relative to pg, so that we patch the copy pg's Connections actually\n  // use, even if the dependency tree has multiple pg-protocol installs\n  const pgPath = runtimeRequire.resolve(\"pg\");\n  const parserPath = runtimeRequire.resolve(\"pg-protocol/dist/parser.js\", { paths: [dirname(pgPath)] });\n  // An absolute-path require bypasses the package's exports map, so this is always readable\n  const { version } = runtimeRequire(join(dirname(parserPath), \"..\", \"package.json\"));\n  return { Parser: runtimeRequire(parserPath).Parser, version };\n}\n\n/** Round-trips a synthetic two-cell DataRow (utf8 + NULL) through a fresh patched Parser. */\nfunction verifyLazyDataRows(Parser: any): boolean {\n  const cell = Buffer.from(\"wörld\", \"utf8\");\n  const payload = Buffer.concat([\n    Buffer.from([0, 2]), // int16 fieldCount\n    int32(cell.length),\n    cell,\n    int32(-1), // NULL cell\n  ]);\n  const frame = Buffer.concat([Buffer.from(\"D\"), int32(payload.length + 4), payload]);\n  let ok = false;\n  new Parser().parse(frame, (msg: any) => {\n    ok =\n      msg.name === \"dataRow\" &&\n      msg.fieldCount === 2 &&\n      msg.bytes !== undefined &&\n      typeof msg.offset === \"number\" &&\n      msg.fields.length === 2 &&\n      msg.fields[0] === \"wörld\" &&\n      msg.fields[1] === null;\n  });\n  return ok;\n}\n\n/**\n * Verifies a straddling DataRow's bytes survive later parser reads.\n *\n * We retain a message that straddles two chunks, drive a third read shaped to trigger the stock\n * parser's move-to-front compaction over its bytes, and only then decode the retained message's\n * cell (the `fields` getter memoizes, so it must not be read earlier). Under our `parse` patch\n * the straddler owns its buffer, so the cell decodes intact.\n */\nfunction verifyImmutableBytes(Parser: any): boolean {\n  const cellB = \"b\".repeat(85);\n  const frameA = dataRowFrame(\"aaaa\"); // 15 bytes, fully inside chunk1\n  const frameB = dataRowFrame(cellB); // 96 bytes, straddles chunk1/chunk2\n  const frameC = dataRowFrame(\"c\".repeat(45)); // 56 bytes, straddles chunk2/chunk3\n  const chunk1 = Buffer.concat([frameA, frameB.subarray(0, 50)]);\n  const chunk2 = Buffer.concat([frameB.subarray(50), frameC.subarray(0, 30)]);\n  const chunk3 = Buffer.from(frameC.subarray(30));\n  const messages: any[] = [];\n  const parser = new Parser();\n  function collect(msg: any): void {\n    messages.push(msg);\n  }\n  parser.parse(chunk1, collect);\n  parser.parse(chunk2, collect);\n  parser.parse(chunk3, collect);\n  try {\n    return messages.length === 3 && messages[1].name === \"dataRow\" && messages[1].fields[0] === cellB;\n  } catch {\n    return false;\n  }\n}\n\n/** Builds a complete one-cell DataRow frame (code + int32 length + payload) for `cell`. */\nfunction dataRowFrame(cell: string): Buffer {\n  const bytes = Buffer.from(cell, \"utf8\");\n  const payload = Buffer.concat([Buffer.from([0, 1]), int32(bytes.length), bytes]);\n  return Buffer.concat([Buffer.from(\"D\"), int32(payload.length + 4), payload]);\n}\n\n/** Returns a 4-byte big-endian buffer for `value`. */\nfunction int32(value: number): Buffer {\n  const buffer = Buffer.alloc(4);\n  buffer.writeInt32BE(value);\n  return buffer;\n}\n"],"mappings":"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"}

package/build/graphql-codegen-export.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var joist_graphql_codegen = require("joist-graphql-codegen");
+Object.keys(joist_graphql_codegen).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return joist_graphql_codegen[k];
+		}
+	});
+});

package/build/graphql-codegen-export.d.cts

@@ -0,0 +1 @@
+export * from "joist-graphql-codegen";

package/build/graphql-codegen-export.d.mts

@@ -0,0 +1 @@
+export * from "joist-graphql-codegen";

package/build/graphql-codegen-export.js

@@ -1,19 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// Re-export everything from joist-graphql-codegen
-__exportStar(require("joist-graphql-codegen"), exports);
-//# sourceMappingURL=graphql-codegen-export.js.map
+export * from "joist-graphql-codegen";
+export {};

package/build/graphql-export.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var joist_graphql_resolver_utils = require("joist-graphql-resolver-utils");
+Object.keys(joist_graphql_resolver_utils).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return joist_graphql_resolver_utils[k];
+		}
+	});
+});

package/build/graphql-export.d.cts

@@ -0,0 +1 @@
+export * from "joist-graphql-resolver-utils";

package/build/graphql-export.d.mts

@@ -0,0 +1 @@
+export * from "joist-graphql-resolver-utils";