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

package/build/drivers/binaryParsers.js.map

@@ -1 +1 @@
-{"version":3,"file":"binaryParsers.js","sourceRoot":"","sources":["../../src/drivers/binaryParsers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"binaryParsers.js","names":["fail"],"sources":["../../src/drivers/binaryParsers.ts"],"sourcesContent":["import { requireTemporal } from \"joist-core\";\n\n/**\n * Joist's registry of PostgreSQL *binary-format* cell parsers, used by `WireRowData` for lazy\n * `em.find`/`em.load` results (which request binary output; see `executeRowDataQuery`).\n *\n * This registry is deliberately **separate from `pg.types`**: `pg.types.setTypeParser` and\n * pool/client `TypeOverrides` continue to govern classic *text* results (knex, `pool.query`,\n * non-lazy drivers), while binary cells decode wire-bytes -> values directly — ints via\n * `readInt32BE`, timestamps via µs arithmetic, Temporal values constructed without ever\n * materializing a string. There is no fallback from one registry to the other:\n *\n * - Built-in parsers cover the standard scalar/array types below; `setupLatestPgTypes`\n *   registers the date/time parsers appropriate to Date-vs-Temporal mode.\n * - Custom/extension types (native enums, citext, domains, hstore, ...) must be registered\n *   explicitly with {@link setBinaryTypeParser} — text-like types can use\n *   {@link binaryTextParser}, arrays of registered elements can use {@link binaryArrayParser}.\n * - A query selecting a column whose oid has no registered parser **fails** with a descriptive\n *   error (see `WireRowData.setRowDescription`), rather than guessing at a lossy decoding.\n *\n * Values produced here should match what the classic text path produces for the same column\n * (i.e. `numeric` stays a string, `int8` stays a string, Date-mode timestamps become `Date`s),\n * so entities hydrate identically in either mode; Temporal-mode parsers construct\n * `Temporal.PlainDate`/`ZonedDateTime`/etc. directly, and the temporal mappers pass\n * already-constructed instances through.\n */\nexport function setBinaryTypeParser(oid: number, parse: BinaryParse): void {\n  parsers.set(oid, parse);\n}\n\n/** Returns the registered binary parser for `oid`, i.e. for tests to save/restore. */\nexport function getBinaryTypeParser(oid: number): BinaryParse | undefined {\n  return parsers.get(oid);\n}\n\n/** Decodes one binary cell directly from the payload chunk; `length` is the cell's byte length. */\nexport type BinaryParse = (chunk: Buffer, start: number, length: number) => any;\n\n/**\n * Auto-registers binary parsers for the database's text-like dynamic-oid types — native enums\n * and citext, plus their array types — so apps get those for free.\n *\n * `PostgresDriver` calls this lazily before its first lazy query; apps can also call it\n * directly (i.e. at boot) if they want the registrations eagerly. Explicit\n * `setBinaryTypeParser` registrations are never overwritten.\n */\nexport async function registerDatabaseBinaryParsers(pool: {\n  query(sql: string): Promise<{ rows: any[] }>;\n}): Promise<void> {\n  // Also capture the session's TimeZone, which zones temporal-mode timestamptz loads to match\n  // what classic text parsing would have produced (pg renders timestamps in the session zone)\n  const [{ rows: settings }, { rows }] = await Promise.all([\n    pool.query(`select current_setting('TimeZone') as tz`),\n    pool.query(\n      `select t.oid, t.typarray\n       from pg_type t\n       where t.typtype = 'e'\n          or t.typname = 'citext'\n          or (t.typtype = 'd' and (select b.typcategory from pg_type b where b.oid = t.typbasetype) = 'S')`,\n    ),\n  ]);\n  setSessionTimeZone(settings[0].tz);\n  for (const row of rows) {\n    const oid = Number(row.oid);\n    if (getBinaryTypeParser(oid) === undefined) setBinaryTypeParser(oid, binaryTextParser);\n    const arrayOid = Number(row.typarray);\n    if (arrayOid !== 0 && getBinaryTypeParser(arrayOid) === undefined) {\n      setBinaryTypeParser(arrayOid, binaryArrayParser);\n    }\n  }\n}\n\n/**\n * Sets the session `TimeZone` used to zone temporal-mode `timestamptz` loads; normally captured\n * automatically by {@link registerDatabaseBinaryParsers}. One zone per process — pools with\n * differing session TimeZones are not supported by the binary path.\n */\nexport function setSessionTimeZone(timeZone: string): void {\n  sessionTimeZone = timeZone === \"Etc/UTC\" ? \"UTC\" : timeZone;\n}\n\nlet sessionTimeZone = \"UTC\";\n\n/** Decodes a cell's bytes as utf8 text, i.e. for text-like custom types (enums, citext, domains). */\nexport function binaryTextParser(chunk: Buffer, start: number, length: number): string {\n  return chunk.toString(\"utf8\", start, start + length);\n}\n\n/**\n * Decodes a binary array cell into a JS array of element values.\n *\n * The element oid is embedded in the wire format, and each element decodes through this\n * registry — so arrays of any registered type (including custom-registered oids and the\n * mode-appropriate temporal types) work without separate element wiring. Registered for the\n * standard `_type` oids below; register it for custom array oids as needed.\n */\nexport function binaryArrayParser(chunk: Buffer, start: number, length: number): any[] {\n  const nDims = chunk.readInt32BE(start);\n  if (nDims === 0) return [];\n  const elemOid = chunk.readInt32BE(start + 8);\n  const parse =\n    parsers.get(elemOid) ??\n    fail(`joist-orm: no binary type parser registered for array element oid ${elemOid}; see setBinaryTypeParser`);\n  const dims: number[] = [];\n  for (let d = 0; d < nDims; d++) dims.push(chunk.readInt32BE(start + 12 + d * 8));\n  let pos = start + 12 + nDims * 8;\n  function readDim(dim: number): any[] {\n    const values: any[] = [];\n    for (let i = 0; i < dims[dim]; i++) {\n      if (dim < nDims - 1) {\n        values.push(readDim(dim + 1));\n      } else {\n        const len = chunk.readInt32BE(pos);\n        pos += 4;\n        if (len === -1) {\n          values.push(null);\n        } else {\n          values.push(parse(chunk, pos, len));\n          pos += len;\n        }\n      }\n    }\n    return values;\n  }\n  return readDim(0);\n}\n\n/** Decodes binary `date` cells to `Date`s, matching postgres-date's text semantics; Date mode. */\nexport function binaryDateToDate(chunk: Buffer, start: number): any {\n  const days = chunk.readInt32BE(start);\n  if (days === INFINITY_DAYS) return Infinity;\n  if (days === NEG_INFINITY_DAYS) return -Infinity;\n  const [year, month, day] = civilFromDays(days + PG_EPOCH_DAYS);\n  const date = new Date(year, month - 1, day);\n  // Mirror postgres-date's fixup for years 0-99 being interpreted as 1900-1999\n  if (year < 100) date.setFullYear(year);\n  return date;\n}\n\n/** Decodes binary `timestamp` (without zone) cells to local-time `Date`s; Date mode. */\nexport function binaryTimestampToDate(chunk: Buffer, start: number): any {\n  const pgMicros = chunk.readBigInt64BE(start);\n  if (pgMicros === INFINITY_US) return Infinity;\n  if (pgMicros === NEG_INFINITY_US) return -Infinity;\n  const { days, us } = splitPgMicros(pgMicros);\n  const [year, month, day] = civilFromDays(days);\n  const seconds = Math.floor(us / 1_000_000);\n  const date = new Date(\n    year,\n    month - 1,\n    day,\n    Math.floor(seconds / 3600),\n    Math.floor((seconds / 60) % 60),\n    seconds % 60,\n    Math.floor((us % 1_000_000) / 1000),\n  );\n  if (year < 100) date.setFullYear(year);\n  return date;\n}\n\n/** Decodes binary `timestamptz` cells to `Date`s (µs floor to ms, like the text parse); Date mode. */\nexport function binaryTimestamptzToDate(chunk: Buffer, start: number): any {\n  const pgMicros = chunk.readBigInt64BE(start);\n  if (pgMicros === INFINITY_US) return Infinity;\n  if (pgMicros === NEG_INFINITY_US) return -Infinity;\n  const epochMicros = pgMicros + PG_EPOCH_US;\n  let ms = epochMicros / 1000n;\n  if (epochMicros % 1000n < 0n) ms -= 1n;\n  return new Date(Number(ms));\n}\n\n/**\n * Registers the Temporal-mode binary parsers: date/time/timestamp/timestamptz cells construct\n * `Temporal` values *directly* from the wire µs/days — no intermediate strings, no\n * `temporalMappers.fromDb` parsing (the mappers pass already-constructed instances through).\n *\n * `timestamptz` matches the text path's zoning exactly: classic parsing zones the value by the\n * offset the session's `TimeZone` rendered (normalizing `+00` to `UTC`), so we compute the\n * session zone's offset at each instant (see `setSessionTimeZone`; the configured\n * `temporal.timeZone` only governs `now`-conversions, not loads).\n */\nexport function registerTemporalBinaryParsers(): void {\n  const { Temporal: t } = requireTemporal();\n  setBinaryTypeParser(oids.DATE, (chunk, start) => {\n    const days = chunk.readInt32BE(start);\n    if (days === INFINITY_DAYS || days === NEG_INFINITY_DAYS) failTemporalInfinity(\"date\");\n    const [year, month, day] = civilFromDays(days + PG_EPOCH_DAYS);\n    return new t.PlainDate(year, month, day);\n  });\n  setBinaryTypeParser(1083 /* time */, (chunk, start) => {\n    const us = Number(chunk.readBigInt64BE(start));\n    const seconds = Math.floor(us / 1_000_000);\n    return new t.PlainTime(\n      Math.floor(seconds / 3600),\n      Math.floor((seconds / 60) % 60),\n      seconds % 60,\n      Math.floor((us % 1_000_000) / 1000),\n      us % 1000,\n    );\n  });\n  setBinaryTypeParser(oids.TIMESTAMP, (chunk, start) => {\n    const pgMicros = chunk.readBigInt64BE(start);\n    if (pgMicros === INFINITY_US || pgMicros === NEG_INFINITY_US) failTemporalInfinity(\"timestamp\");\n    const { days, us } = splitPgMicros(pgMicros);\n    const [year, month, day] = civilFromDays(days);\n    const seconds = Math.floor(us / 1_000_000);\n    return new t.PlainDateTime(\n      year,\n      month,\n      day,\n      Math.floor(seconds / 3600),\n      Math.floor((seconds / 60) % 60),\n      seconds % 60,\n      Math.floor((us % 1_000_000) / 1000),\n      us % 1000,\n    );\n  });\n  setBinaryTypeParser(oids.TIMESTAMPTZ, (chunk, start) => {\n    const pgMicros = chunk.readBigInt64BE(start);\n    if (pgMicros === INFINITY_US || pgMicros === NEG_INFINITY_US) failTemporalInfinity(\"timestamptz\");\n    const instant = t.Instant.fromEpochNanoseconds((pgMicros + PG_EPOCH_US) * 1000n);\n    if (sessionTimeZone === \"UTC\") return instant.toZonedDateTimeISO(\"UTC\");\n    // Zone by the session zone's offset at this instant, i.e. what pg's text rendering carries\n    const zoned = instant.toZonedDateTimeISO(sessionTimeZone);\n    const { offset } = zoned;\n    return offset === \"+00:00\" ? zoned.withTimeZone(\"UTC\") : zoned.withTimeZone(offset);\n  });\n}\n\n// Microseconds between the Postgres epoch (2000-01-01) and the Unix epoch (1970-01-01)\nconst PG_EPOCH_US = 946_684_800_000_000n;\nconst PG_EPOCH_DAYS = 10_957;\nconst US_PER_DAY = 86_400_000_000n;\n// The wire sentinels for `infinity` / `-infinity` timestamps and dates\nconst INFINITY_US = 0x7fffffffffffffffn;\nconst NEG_INFINITY_US = -0x8000000000000000n;\nconst INFINITY_DAYS = 0x7fffffff;\nconst NEG_INFINITY_DAYS = -0x80000000;\n\n// pg's builtin oids, inlined to avoid importing pg here (these are protocol constants)\nconst oids = {\n  BOOL: 16,\n  BYTEA: 17,\n  INT8: 20,\n  INT2: 21,\n  INT4: 23,\n  TEXT: 25,\n  OID: 26,\n  JSON: 114,\n  FLOAT4: 700,\n  FLOAT8: 701,\n  BPCHAR: 1042,\n  VARCHAR: 1043,\n  DATE: 1082,\n  TIMESTAMP: 1114,\n  TIMESTAMPTZ: 1184,\n  NUMERIC: 1700,\n  UUID: 2950,\n  JSONB: 3802,\n};\n\nconst parsers = new Map<number, BinaryParse>();\n\n// The standard scalar builtins; values match what the classic text path produces for the same\n// column, i.e. int8/numeric stay strings, bytea stays a Buffer (byte-exact, where classic pg's\n// binary handling is utf8-lossy)\nsetBinaryTypeParser(oids.BOOL, (chunk, start) => chunk[start] !== 0);\nsetBinaryTypeParser(oids.INT2, (chunk, start) => chunk.readInt16BE(start));\nsetBinaryTypeParser(oids.INT4, (chunk, start) => chunk.readInt32BE(start));\nsetBinaryTypeParser(oids.OID, (chunk, start) => chunk.readUInt32BE(start));\nsetBinaryTypeParser(oids.INT8, (chunk, start) => chunk.readBigInt64BE(start).toString());\nsetBinaryTypeParser(oids.FLOAT4, (chunk, start) => readFloat4(chunk, start));\nsetBinaryTypeParser(oids.FLOAT8, (chunk, start) => chunk.readDoubleBE(start));\nsetBinaryTypeParser(oids.TEXT, binaryTextParser);\nsetBinaryTypeParser(oids.VARCHAR, binaryTextParser);\nsetBinaryTypeParser(oids.BPCHAR, binaryTextParser);\nsetBinaryTypeParser(19 /* name */, binaryTextParser);\nsetBinaryTypeParser(oids.UUID, (chunk, start) => renderUuid(chunk, start));\nsetBinaryTypeParser(oids.BYTEA, copyBytes);\nsetBinaryTypeParser(oids.JSON, (chunk, start, length) => JSON.parse(chunk.toString(\"utf8\", start, start + length)));\n// jsonb payloads have a 1-byte version prefix before the JSON text\nsetBinaryTypeParser(oids.JSONB, (chunk, start, length) =>\n  JSON.parse(chunk.toString(\"utf8\", start + 1, start + length)),\n);\nsetBinaryTypeParser(oids.NUMERIC, renderNumeric);\nsetBinaryTypeParser(3614 /* tsvector */, renderTsVector);\nsetBinaryTypeParser(3910 /* tstzrange */, (chunk, start) =>\n  renderRange(chunk, start, (c, s) => {\n    // pg quotes finite bounds (they contain spaces) but renders infinity bounds bare\n    const text = renderTimestamp(c.readBigInt64BE(s), \"+00\");\n    return text === \"infinity\" || text === \"-infinity\" ? text : `\"${text}\"`;\n  }),\n);\n// Rendered like pg's text output, which is also what the classic text path yields (no parser)\nsetBinaryTypeParser(1083 /* time */, (chunk, start) => renderTimeOfDay(Number(chunk.readBigInt64BE(start))));\n\n// The standard `_type` array oids; elements decode through the registry (see binaryArrayParser)\nfor (const arrayOid of [\n  1000, // bool[]\n  1001, // bytea[]\n  1005, // int2[]\n  1007, // int4[]\n  1009, // text[]\n  1014, // bpchar[]\n  1015, // varchar[]\n  1016, // int8[]\n  1021, // float4[]\n  1022, // float8[]\n  1182, // date[]\n  1183, // time[]\n  1115, // timestamp[]\n  1185, // timestamptz[]\n  1231, // numeric[]\n  2951, // uuid[]\n  199, // json[]\n  3807, // jsonb[]\n  3643, // tsvector[]\n  3911, // tstzrange[]\n]) {\n  setBinaryTypeParser(arrayOid, binaryArrayParser);\n}\n\n// Default the date/time oids to Date-mode semantics; `setupLatestPgTypes` re-registers the\n// Temporal-mode parsers when the app runs with `temporal` configured\nsetBinaryTypeParser(oids.DATE, binaryDateToDate);\nsetBinaryTypeParser(oids.TIMESTAMP, binaryTimestampToDate);\nsetBinaryTypeParser(oids.TIMESTAMPTZ, binaryTimestamptzToDate);\n\n/** Splits pg timestamp µs into days-since-1970 and µs-within-day, flooring correctly pre-epoch. */\nfunction splitPgMicros(pgMicros: bigint): { days: number; us: number } {\n  const epochMicros = pgMicros + PG_EPOCH_US;\n  let days = epochMicros / US_PER_DAY;\n  let micros = epochMicros % US_PER_DAY;\n  if (micros < 0n) {\n    days -= 1n;\n    micros += US_PER_DAY;\n  }\n  return { days: Number(days), us: Number(micros) };\n}\n\n/** Fails on the ±infinity wire sentinels, which have no Temporal representation. */\nfunction failTemporalInfinity(type: string): never {\n  return fail(`joist-orm: cannot represent an 'infinity' ${type} as a Temporal value`);\n}\n\n/** Reads a float4 as its shortest round-trip decimal, matching pg's shortest text output. */\nfunction readFloat4(chunk: Buffer, start: number): number {\n  const value = chunk.readFloatBE(start);\n  if (!Number.isFinite(value)) return value;\n  // ±0 as-is: toPrecision would drop -0's sign, and === cannot tell the zeros apart\n  if (value === 0) return value;\n  // The raw float32 -> float64 widening (i.e. 0.1f -> 0.10000000149...) diverges from the text\n  // path, which parses pg's shortest repr; find the shortest decimal that round-trips instead\n  // (binary32 needs at most 9 significant decimal digits)\n  for (let precision = 1; precision <= 9; precision++) {\n    const shortest = Number(value.toPrecision(precision));\n    if (Math.fround(shortest) === value) return shortest;\n  }\n  return value;\n}\n\n/** Copies the exact cell bytes, i.e. for bytea values. */\nfunction copyBytes(chunk: Buffer, start: number, length: number): Buffer {\n  const cell = Buffer.allocUnsafe(length);\n  chunk.copy(cell, 0, start, start + length);\n  return cell;\n}\n\n/** Renders a binary uuid (16 bytes) as the canonical dashed-hex string. */\nfunction renderUuid(chunk: Buffer, start: number): string {\n  const hex = chunk.toString(\"hex\", start, start + 16);\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n}\n\n/** Renders a binary numeric (base-10000 digit groups) to pg's text form, i.e. `-12.340`. */\nfunction renderNumeric(chunk: Buffer, start: number): string {\n  const nDigits = chunk.readInt16BE(start);\n  const weight = chunk.readInt16BE(start + 2);\n  const sign = chunk.readUInt16BE(start + 4);\n  const dscale = chunk.readUInt16BE(start + 6);\n  if (sign === 0xc000) return \"NaN\";\n  if (sign === 0xd000) return \"Infinity\";\n  if (sign === 0xf000) return \"-Infinity\";\n  // Integer part: digit groups from `weight` down to 0 (missing groups are zero)\n  let integer = \"\";\n  for (let w = weight, i = 0; w >= 0; w--, i++) {\n    const group = i < nDigits ? chunk.readUInt16BE(start + 8 + i * 2) : 0;\n    integer += integer === \"\" ? String(group) : String(group).padStart(4, \"0\");\n  }\n  if (integer === \"\") integer = \"0\";\n  if (dscale === 0) return sign === 0x4000 ? `-${integer}` : integer;\n  // Fraction part: the group at weight -k is digits[weight + k]; pad/trim to exactly `dscale` digits\n  let fraction = \"\";\n  for (let k = 1; fraction.length < dscale; k++) {\n    const i = weight + k;\n    const group = i >= 0 && i < nDigits ? chunk.readUInt16BE(start + 8 + i * 2) : 0;\n    fraction += String(group).padStart(4, \"0\");\n  }\n  fraction = fraction.slice(0, dscale);\n  return `${sign === 0x4000 ? \"-\" : \"\"}${integer}.${fraction}`;\n}\n\n/** Renders a binary tsvector (lexeme cstrings + position/weight words) to pg's text form, i.e. `'new':2A`. */\nfunction renderTsVector(chunk: Buffer, start: number): string {\n  const count = chunk.readInt32BE(start);\n  let pos = start + 4;\n  const lexemes: string[] = [];\n  for (let i = 0; i < count; i++) {\n    const end = chunk.indexOf(0, pos);\n    // pg's output doubles both backslashes and quotes inside lexemes\n    const word = chunk.toString(\"utf8\", pos, end).replace(/\\\\/g, \"\\\\\\\\\").replace(/'/g, \"''\");\n    pos = end + 1;\n    const nPositions = chunk.readUInt16BE(pos);\n    pos += 2;\n    const positions: string[] = [];\n    for (let p = 0; p < nPositions; p++) {\n      // Each word entry packs the weight in the top 2 bits (3=A, 2=B, 1=C, 0=D/default)\n      const entry = chunk.readUInt16BE(pos);\n      pos += 2;\n      positions.push(`${entry & 0x3fff}${weightSuffixes[entry >> 14]}`);\n    }\n    lexemes.push(positions.length > 0 ? `'${word}':${positions.join(\",\")}` : `'${word}'`);\n  }\n  return lexemes.join(\" \");\n}\n\nconst weightSuffixes = [\"\", \"C\", \"B\", \"A\"];\n\n/** Renders a binary range (flags byte + length-prefixed bounds) to pg's text form, i.e. `[\"a\",\"b\")`. */\nfunction renderRange(chunk: Buffer, start: number, bound: (c: Buffer, s: number) => string): string {\n  const flags = chunk[start];\n  if (flags & 0x01) return \"empty\";\n  let pos = start + 1;\n  let lower = \"\";\n  let upper = \"\";\n  if (!(flags & 0x08)) {\n    const len = chunk.readInt32BE(pos);\n    lower = bound(chunk, pos + 4);\n    pos += 4 + len;\n  }\n  if (!(flags & 0x10)) {\n    upper = bound(chunk, pos + 4);\n  }\n  return `${flags & 0x02 ? \"[\" : \"(\"}${lower},${upper}${flags & 0x04 ? \"]\" : \")\"}`;\n}\n\n/** Renders days-since-1970 as pg's date text, i.e. `2020-01-02` or `0001-01-01 BC`. */\nfunction renderDate(epochDays: number): string {\n  const { text, bc } = renderDatePart(epochDays);\n  return bc ? `${text} BC` : text;\n}\n\n/**\n * Renders the `YYYY-MM-DD` part, converting astronomical years to pg's BC numbering\n * (astronomical year 0 = `0001 BC`); timestamps append the ` BC` marker after the time/zone.\n */\nfunction renderDatePart(epochDays: number): { text: string; bc: boolean } {\n  const [year, month, day] = civilFromDays(epochDays);\n  const bc = year <= 0;\n  const displayYear = bc ? 1 - year : year;\n  return {\n    text: `${String(displayYear).padStart(4, \"0\")}-${String(month).padStart(2, \"0\")}-${String(day).padStart(2, \"0\")}`,\n    bc,\n  };\n}\n\n/** Renders a binary timestamp (µs since 2000-01-01) to pg's text form, i.e. `2020-01-02 03:04:05.678+00`. */\nfunction renderTimestamp(pgMicros: bigint, suffix: string): string {\n  if (pgMicros === INFINITY_US) return \"infinity\";\n  if (pgMicros === NEG_INFINITY_US) return \"-infinity\";\n  const { days, us } = splitPgMicros(pgMicros);\n  const { text: date, bc } = renderDatePart(days);\n  return `${date} ${renderTimeOfDay(us)}${suffix}${bc ? \" BC\" : \"\"}`;\n}\n\n/** Renders µs-since-midnight to pg's time text, i.e. `03:04:05.678` with trailing zeros trimmed. */\nfunction renderTimeOfDay(us: number): string {\n  const seconds = Math.floor(us / 1_000_000);\n  const hh = String(Math.floor(seconds / 3600)).padStart(2, \"0\");\n  const mm = String(Math.floor((seconds / 60) % 60)).padStart(2, \"0\");\n  const ss = String(seconds % 60).padStart(2, \"0\");\n  // pg renders up to 6 fractional digits with trailing zeros trimmed, and no \".\" when zero\n  let fraction = \"\";\n  const usPart = us % 1_000_000;\n  if (usPart > 0) fraction = `.${String(usPart).padStart(6, \"0\")}`.replace(/0+$/, \"\");\n  return `${hh}:${mm}:${ss}${fraction}`;\n}\n\n/** Converts days-since-1970 to a civil [year, month, day], i.e. Howard Hinnant's algorithm. */\nfunction civilFromDays(epochDays: number): [number, number, number] {\n  const z = epochDays + 719_468;\n  const era = Math.floor(z / 146_097);\n  const doe = z - era * 146_097;\n  const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);\n  const y = yoe + era * 400;\n  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));\n  const mp = Math.floor((5 * doy + 2) / 153);\n  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;\n  const m = mp < 10 ? mp + 3 : mp - 9;\n  return [m <= 2 ? y + 1 : y, m, d];\n}\n\n/** Throws an `Error` with `message`. */\nfunction fail(message: string): never {\n  throw new Error(message);\n}\n"],"mappings":"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"}

package/build/drivers/patchPgProtocol.cjs

@@ -0,0 +1,255 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_module = require("node:module");
+let node_path = require("node:path");
+//#region src/drivers/patchPgProtocol.ts
+const runtimeRequire = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+/**
+* 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";
+}
+/** A drop-in `DataRowMessage` that defers cell decoding; lazy consumers read `bytes`/`offset`. */
+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 = 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();
+		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.
+*/
+function patchedParse(chunk, callback) {
+	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;
+	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.
+*/
+function completePartial(parser, chunk, callback) {
+	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;
+	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() {
+	const pgPath = runtimeRequire.resolve("pg");
+	const parserPath = runtimeRequire.resolve("pg-protocol/dist/parser.js", { paths: [(0, node_path.dirname)(pgPath)] });
+	const { version } = runtimeRequire((0, node_path.join)((0, node_path.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]),
+		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.
+*/
+function verifyImmutableBytes(Parser) {
+	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
+	]);
+}
+/** Returns a 4-byte big-endian buffer for `value`. */
+function int32(value) {
+	const buffer = Buffer.alloc(4);
+	buffer.writeInt32BE(value);
+	return buffer;
+}
+//#endregion
+exports.LazyDataRowMessage = LazyDataRowMessage;
+exports.ensureLazyDataRows = ensureLazyDataRows;
+
+//# sourceMappingURL=patchPgProtocol.cjs.map

package/build/drivers/patchPgProtocol.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"patchPgProtocol.cjs","names":["createRequire","#fields","dirname","join"],"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/drivers/{patchPgProtocol.d.ts → patchPgProtocol.d.cts}

@@ -1,3 +1,4 @@
+//#region src/drivers/patchPgProtocol.d.ts
 /**
  * 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
@@ -25,19 +26,22 @@
  * The lazy message's memoized `fields` getter decodes identically to the original for classic
  * consumers, i.e. pg's own `Result.parseRow(msg.fields)`.
  */
-export declare function ensureLazyDataRows(): boolean;
+declare function ensureLazyDataRows(): boolean;
 /** A drop-in `DataRowMessage` that defers cell decoding; lazy consumers read `bytes`/`offset`. */
-export declare class LazyDataRowMessage {
-    #private;
-    readonly length: number;
-    /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
-    readonly bytes: Buffer;
-    readonly offset: number;
-    readonly name = "dataRow";
-    readonly fieldCount: number;
-    constructor(length: number, 
-    /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
-    bytes: Buffer, offset: number);
-    /** Lazily materializes the per-cell strings for classic consumers, i.e. pg's `Result.parseRow`. */
-    get fields(): (string | null)[];
+declare class LazyDataRowMessage {
+  #private;
+  readonly length: number;
+  /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
+  readonly bytes: Buffer;
+  readonly offset: number;
+  readonly name = "dataRow";
+  readonly fieldCount: number;
+  constructor(length: number,
+  /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
+  bytes: Buffer, offset: number);
+  /** Lazily materializes the per-cell strings for classic consumers, i.e. pg's `Result.parseRow`. */
+  get fields(): (string | null)[];
 }
+//#endregion
+export { LazyDataRowMessage, ensureLazyDataRows };
+//# sourceMappingURL=patchPgProtocol.d.cts.map

package/build/drivers/patchPgProtocol.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patchPgProtocol.d.cts","names":[],"sources":["../../src/drivers/patchPgProtocol.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCgB;;cAMH;;WAMO;;WAEA,OAAO;WACP;WARF;WACA;EAGhB,YACkB,gBAEA;;EAAA,OAAO,QACP;;MAMd"}

package/build/drivers/patchPgProtocol.d.mts

@@ -0,0 +1,47 @@
+//#region src/drivers/patchPgProtocol.d.ts
+/**
+ * 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)`.
+ */
+declare function ensureLazyDataRows(): boolean;
+/** A drop-in `DataRowMessage` that defers cell decoding; lazy consumers read `bytes`/`offset`. */
+declare class LazyDataRowMessage {
+  #private;
+  readonly length: number;
+  /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
+  readonly bytes: Buffer;
+  readonly offset: number;
+  readonly name = "dataRow";
+  readonly fieldCount: number;
+  constructor(length: number,
+  /** The row's payload bytes; immutable under our `parse` patch, so safe to retain. */
+  bytes: Buffer, offset: number);
+  /** Lazily materializes the per-cell strings for classic consumers, i.e. pg's `Result.parseRow`. */
+  get fields(): (string | null)[];
+}
+//#endregion
+export { LazyDataRowMessage, ensureLazyDataRows };
+//# sourceMappingURL=patchPgProtocol.d.mts.map

package/build/drivers/patchPgProtocol.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patchPgProtocol.d.mts","names":[],"sources":["../../src/drivers/patchPgProtocol.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCgB;;cAMH;;WAMO;;WAEA,OAAO;WACP;WARF;WACA;EAGhB,YACkB,gBAEA;;EAAA,OAAO,QACP;;MAMd"}