@vibeorm/adapter-pg 4.2.0 → 5.0.0

package/dist/index.js

@@ -16,17 +16,22 @@ import {
   transactionLifecycleRefusal,
   createSavepointScope,
   engineStatementBudgetMs,
+  findRefusedSetting,
   isSavepointRollbackFailedError,
   readOnlyRequested,
+  readTransactionSettings,
+  renderTransactionSettings,
+  transactionSettingRefusedError,
   runNestedSavepoint,
   runRootScope,
   scopeTurn,
   settleFailedTransaction,
   startTransactionBudget,
-  transactionAbortedError,
-  validateTransactionDeadline
+  transactionAbortedError as transactionAbortedError2,
+  validateTransactionDeadline,
+  parseExtendedDateTimeText
 } from "@vibeorm/runtime/adapter-kit";
-import { VibeError as VibeError5 } from "@vibeorm/schema";
+import { VibeError as VibeError7 } from "@vibeorm/schema";
 import pg3 from "pg";
 
 // packages/adapter-pg/src/batch.ts
@@ -35,6 +40,9 @@ var prepareValue = (() => {
   const utils = pg.utils;
   return typeof utils?.prepareValue === "function" ? utils.prepareValue : undefined;
 })();
+function batchDriverAvailable() {
+  return prepareValue !== undefined;
+}
 function supportsBatch(params) {
   if (prepareValue === undefined)
     return false;
@@ -93,13 +101,20 @@ class PgBatch {
     }
   }
   handleRowDescription(message) {
+    this.rows = [];
+    if (this.steps[this.outcomes.length]?.discardRows === true) {
+      this.fields = [];
+      this.parsers = [];
+      return;
+    }
     this.fields = message.fields;
     this.parsers = message.fields.map((field) => this.types.getTypeParser(field.dataTypeID, field.format ?? "text"));
-    this.rows = [];
   }
   handleDataRow(message) {
     if (this.settled || this.rowError !== undefined)
       return;
+    if (this.steps[this.outcomes.length]?.discardRows === true)
+      return;
     const row = {};
     try {
       for (let index = 0;index < this.fields.length; index++) {
@@ -182,9 +197,180 @@ function firstBatchFailure(params) {
   return;
 }
 
+// packages/adapter-pg/src/connection-group.ts
+import { VibeError } from "@vibeorm/schema";
+import { transactionAbortedError } from "@vibeorm/runtime/adapter-kit";
+function connectionGroupMisuse(params) {
+  return new VibeError({ code: "VIBE_INTERNAL", message: `pipeline lane group: ${params.message}`, meta: { reason: "pipeline-lane-group" } });
+}
+function openConnectionGroup(params) {
+  const { driver } = params;
+  const seats = [];
+  let sealed = false;
+  let sent = false;
+  const settle = (entries, outcome) => {
+    let failure;
+    entries.forEach((seat, index) => {
+      const issued = seat.issued;
+      if (issued === undefined)
+        return;
+      const step = outcome.steps[index];
+      if (step === undefined) {
+        const error = driver.mapError(outcome.transportError);
+        failure ??= error;
+        issued.reject(error);
+      } else if (step.status === "ok") {
+        issued.resolve(step.result.rows);
+      } else if (step.status === "failed") {
+        const error = driver.mapError(step.error);
+        failure ??= error;
+        issued.reject(error);
+      } else {
+        issued.reject(transactionAbortedError({ cause: failure }));
+      }
+    });
+  };
+  const flushIfReady = () => {
+    if (!sealed || sent)
+      return;
+    for (const seat of seats)
+      if (seat.open && seat.issued === undefined && !seat.done)
+        return;
+    sent = true;
+    const entries = seats.filter((seat) => seat.issued !== undefined);
+    if (entries.length === 0)
+      return;
+    const sending = new Promise((resolve) => {
+      resolve(driver.send(entries.map((seat) => seat.issued.entry)));
+    });
+    sending.then((outcome) => {
+      settle(entries, outcome);
+    }, (error) => {
+      const mapped = driver.mapError(error);
+      for (const seat of entries)
+        seat.issued?.reject(mapped);
+    });
+  };
+  const refused = (message) => () => Promise.reject(connectionGroupMisuse({ message }));
+  const subAdapter = (seat) => ({
+    ...driver.base,
+    execute: (call) => {
+      if (seat.issued !== undefined || seat.done)
+        return Promise.reject(connectionGroupMisuse({ message: "a sub-lane issues ONE statement" }));
+      if (!seat.open || sent)
+        return Promise.reject(connectionGroupMisuse({ message: "a closed sub-lane issues nothing" }));
+      if (call.execution !== undefined) {
+        seat.done = true;
+        flushIfReady();
+        return Promise.reject(connectionGroupMisuse({ message: "a sub-lane statement takes no read options" }));
+      }
+      const pending = new Promise((resolve, reject) => {
+        const step = driver.prepare(call);
+        seat.issued = { entry: { step, call }, resolve, reject };
+      });
+      if (seat.issued === undefined) {
+        seat.done = true;
+        flushIfReady();
+        return pending.then(undefined, (error) => {
+          throw driver.mapError(error);
+        });
+      }
+      flushIfReady();
+      return pending;
+    },
+    executeUnsafe: refused("a sub-lane runs no raw statement"),
+    transaction: refused("a sub-lane opens no transaction"),
+    connect: refused("a sub-lane does not connect"),
+    disconnect: refused("a sub-lane does not disconnect")
+  });
+  return {
+    lane: () => {
+      if (sealed)
+        throw connectionGroupMisuse({ message: "a sub-lane is opened only before the group is sealed" });
+      const seat = { index: seats.length, open: true, done: false };
+      seats.push(seat);
+      return {
+        adapter: subAdapter(seat),
+        close: () => {
+          if (!seat.open)
+            return;
+          seat.open = false;
+          flushIfReady();
+        }
+      };
+    },
+    seal: () => {
+      if (sealed)
+        return;
+      sealed = true;
+      flushIfReady();
+    }
+  };
+}
+
+// packages/adapter-pg/src/connection-string.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+function lastValue(params) {
+  const values = params.search.getAll(params.key);
+  return values.length === 0 ? undefined : values[values.length - 1];
+}
+function honourSystemRootCert(params) {
+  const { connectionString, option } = params;
+  const queryStart = connectionString.indexOf("?");
+  if (queryStart === -1)
+    return connectionString;
+  const hashStart = connectionString.indexOf("#", queryStart);
+  const queryEnd = hashStart === -1 ? connectionString.length : hashStart;
+  const search = new URLSearchParams(connectionString.slice(queryStart + 1, queryEnd));
+  if (lastValue({ search, key: "sslrootcert" }) !== "system")
+    return connectionString;
+  const sslmode = lastValue({ search, key: "sslmode" });
+  const ssl = lastValue({ search, key: "ssl" });
+  const weaker = sslmode !== undefined && sslmode !== "verify-full" ? { parameter: "sslmode", value: sslmode } : ssl !== undefined && ssl !== "true" && ssl !== "1" ? { parameter: "ssl", value: ssl } : undefined;
+  if (weaker !== undefined) {
+    throw new VibeError2({
+      code: "VIBE_CONFIG",
+      message: `pgAdapter \`${option}\` combines sslrootcert=system with ${weaker.parameter}=${JSON.stringify(weaker.value)}. ` + "libpq allows sslrootcert=system only with sslmode=verify-full (its default when sslmode is omitted): any certificate " + "the system trusts would otherwise vouch for a server that is not yours. Use sslmode=verify-full, or remove the setting.",
+      meta: { adapter: "pg", reason: "sslrootcert-system-weak-sslmode", option, parameter: weaker.parameter, value: weaker.value }
+    });
+  }
+  search.delete("sslrootcert");
+  search.delete("ssl");
+  search.set("sslmode", "verify-full");
+  const query = search.toString().replace(/\+/g, "%20");
+  return `${connectionString.slice(0, queryStart)}?${query}${connectionString.slice(queryEnd)}`;
+}
+
+// packages/adapter-pg/src/client-turns.ts
+function createClientTurns() {
+  let outstanding = 0;
+  let failure;
+  let previous = Promise.resolve();
+  const release = () => {
+    outstanding -= 1;
+    failure = undefined;
+  };
+  const fail = (error) => {
+    outstanding -= 1;
+    failure = { error };
+  };
+  return {
+    run: (send) => {
+      const running = outstanding === 0 ? new Promise((resolve) => {
+        resolve(send());
+      }) : previous.then(send);
+      outstanding += 1;
+      previous = running.then(release, fail);
+      return running;
+    },
+    outstanding: () => outstanding,
+    lastFailure: () => failure
+  };
+}
+
 // packages/adapter-pg/src/read-cancellation.ts
 import pg2 from "pg";
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { VibeError as VibeError4 } from "@vibeorm/schema";
 import { assertReadExecution, readCancelledError } from "@vibeorm/runtime/adapter-kit";
 
 // packages/adapter-pg/src/config.ts
@@ -193,7 +379,7 @@ var PG_READ_CANCELLATION = Object.freeze({
 });
 
 // packages/adapter-pg/src/errors.ts
-import { VibeError } from "@vibeorm/schema";
+import { VibeError as VibeError3 } from "@vibeorm/schema";
 var PG_SQLSTATE_ERROR_CODES = Object.freeze({
   "23P01": "VIBE_EXCLUSION_VIOLATION",
   "23505": "VIBE_UNIQUE_VIOLATION",
@@ -221,6 +407,11 @@ var PG_SQLSTATE_REASONS = Object.freeze({
   "40001": "serialization-failure",
   "25006": "read-only-transaction"
 });
+var NAMED_STATEMENT_POOLER_HINT = "Hint: with preparedStatements: true every query must reach the backend that prepared its name. " + "Use a direct connection, session pooling, or PgBouncer 1.21+ with max_prepared_statements > 0; " + "behind a transaction-mode pooler without prepared-statement support, turn preparedStatements off.";
+var PG_SQLSTATE_HINTS = Object.freeze({
+  "26000": NAMED_STATEMENT_POOLER_HINT,
+  "42P05": NAMED_STATEMENT_POOLER_HINT
+});
 var SQLSTATE_PATTERN = /^(?=[A-Z]*\d)[0-9A-Z]{5}$/;
 function readStringField(params) {
   const value = params.source[params.key];
@@ -235,7 +426,7 @@ function pgErrorSqlstate(params) {
 }
 function mapPgDriverError(params) {
   const { error } = params;
-  if (error instanceof VibeError)
+  if (error instanceof VibeError3)
     return error;
   const source = error !== null && typeof error === "object" ? error : {};
   const sqlstate = pgErrorSqlstate({ error });
@@ -255,8 +446,10 @@ function mapPgDriverError(params) {
   const reason = sqlstate === undefined ? undefined : PG_SQLSTATE_REASONS[sqlstate];
   if (reason !== undefined)
     meta.reason = reason;
-  const message = readStringField({ source, key: "message" }) ?? (typeof error === "string" ? error : "unknown postgres driver error");
-  return new VibeError({ code, message, meta, cause: error });
+  const driverMessage = readStringField({ source, key: "message" }) ?? (typeof error === "string" ? error : "unknown postgres driver error");
+  const hint = sqlstate === undefined ? undefined : PG_SQLSTATE_HINTS[sqlstate];
+  const message = hint === undefined ? driverMessage : `${driverMessage}. ${hint}`;
+  return new VibeError3({ code, message, meta, cause: error });
 }
 async function runMapped(fn) {
   try {
@@ -279,14 +472,14 @@ function createPgReadCancellation(params) {
       if (query.execution?.cancellation !== "running")
         return query.send();
       if (params.target.pipeline === true || (params.target.connectionParameters?.query_timeout ?? 0) > 0) {
-        throw new VibeError2({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Running cancellation requires a non-pipelined target without local query_timeout", meta: { capability: "readCancellation", reason: "target-lifetime" } });
+        throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Running cancellation requires a non-pipelined target without local query_timeout", meta: { capability: "readCancellation", reason: "target-lifetime" } });
       }
       const address = params.connectionString;
       if (address === undefined)
-        throw new VibeError2({ code: "VIBE_INTERNAL", message: "Running cancellation requires a control address" });
+        throw new VibeError4({ code: "VIBE_INTERNAL", message: "Running cancellation requires a control address" });
       const token = `vibe_cancel_${crypto.randomUUID()}`;
       if (!URL.canParse(address))
-        throw new VibeError2({ code: "VIBE_CONFIG", message: "The PostgreSQL cancellation control address must be a URL" });
+        throw new VibeError4({ code: "VIBE_CONFIG", message: "The PostgreSQL cancellation control address must be a URL" });
       const url = new URL(address);
       url.searchParams.delete("query_timeout");
       url.searchParams.set("connect_timeout", String(PG_READ_CANCELLATION.controlTimeoutMs / 1000));
@@ -333,7 +526,7 @@ function createPgReadCancellation(params) {
         if (preflightAborted)
           throw readCancelledError({ stage: "waiting-for-connection" });
         if (witness === undefined || typeof witness.pid !== "number" || typeof witness.backend_start !== "string" || typeof witness.datname !== "string" || typeof witness.usename !== "string" || witness.tag !== token) {
-          throw new VibeError2({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Cannot prove the exact PostgreSQL cancellation target", meta: { capability: "readCancellation", reason: "target-witness" } });
+          throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Cannot prove the exact PostgreSQL cancellation target", meta: { capability: "readCancellation", reason: "target-witness" } });
         }
         assertReadExecution({ execution: query.execution, effect: "read", support, provider: "postgresql", stage: "waiting-for-connection" });
         listener = () => {
@@ -350,7 +543,7 @@ function createPgReadCancellation(params) {
             throw error;
           };
           settlementTimer = setTimeout(() => {
-            controlFailure = new VibeError2({ code: "VIBE_ADAPTER", message: "PostgreSQL read did not settle after cancellation; its exact session was discarded", meta: { reason: "read-cancellation-unsettled", databaseCancelled: false } });
+            controlFailure = new VibeError4({ code: "VIBE_ADAPTER", message: "PostgreSQL read did not settle after cancellation; its exact session was discarded", meta: { reason: "read-cancellation-unsettled", databaseCancelled: false } });
             if (!terminated) {
               terminated = true;
               params.terminate();
@@ -362,7 +555,7 @@ function createPgReadCancellation(params) {
           })).then((result) => {
             signalSent = rowsOf(result)[0]?.signalled === true;
             if (!signalSent)
-              failControl(new VibeError2({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "The control endpoint did not signal the exact PostgreSQL target", meta: { capability: "readCancellation", reason: "target-not-signalled", databaseCancelled: false } }));
+              failControl(new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "The control endpoint did not signal the exact PostgreSQL target", meta: { capability: "readCancellation", reason: "target-not-signalled", databaseCancelled: false } }));
           }, failControl);
           cancel.then(() => {
             return;
@@ -393,12 +586,12 @@ function createPgReadCancellation(params) {
             }, () => {
               return;
             });
-          const sqlstate = error instanceof VibeError2 ? error.meta.sqlstate : pgErrorSqlstate({ error });
+          const sqlstate = error instanceof VibeError4 ? error.meta.sqlstate : pgErrorSqlstate({ error });
           if (terminated && controlFailure !== undefined && sqlstate === undefined)
             throw controlFailure;
           if (attempted && signalSent && sqlstate === "57014") {
             const cancelled = readCancelledError({ stage: "running", databaseCancelled: true, cause: error });
-            throw new VibeError2({ code: cancelled.code, message: cancelled.message, meta: { ...cancelled.meta, sqlstate: "57014" }, cause: error });
+            throw new VibeError4({ code: cancelled.code, message: cancelled.message, meta: { ...cancelled.meta, sqlstate: "57014" }, cause: error });
           }
           throw error;
         });
@@ -480,7 +673,7 @@ function serializeParamsRaw(params) {
 }
 
 // packages/adapter-pg/src/pool-config.ts
-import { VibeError as VibeError3 } from "@vibeorm/schema";
+import { VibeError as VibeError5 } from "@vibeorm/schema";
 var PLAN_CACHE_MODES = ["auto", "force_custom_plan", "force_generic_plan"];
 function isPlanCacheMode(value) {
   return typeof value === "string" && PLAN_CACHE_MODES.includes(value);
@@ -489,7 +682,7 @@ function assertPlanCacheMode(params) {
   const { value } = params;
   if (isPlanCacheMode(value))
     return value;
-  throw new VibeError3({
+  throw new VibeError5({
     code: "VIBE_CONFIG",
     message: `planCacheMode must be one of ${PLAN_CACHE_MODES.map((mode) => `"${mode}"`).join(", ")}, received ${JSON.stringify(value)}`,
     meta: { planCacheMode: value, allowed: PLAN_CACHE_MODES }
@@ -515,32 +708,76 @@ function placePlanCacheMode(params) {
   url.searchParams.set("options", merged);
   return { connectionString: url.toString(), options: merged };
 }
+function assertIdleTimeout(params) {
+  const { value } = params;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 2147483647)
+    return value;
+  throw new VibeError5({
+    code: "VIBE_CONFIG",
+    message: "pgAdapter `idleTimeout` must be integer milliseconds from 0 through 2,147,483,647 (0 keeps idle connections open).",
+    meta: { adapter: "pg", reason: "invalid-idle-timeout", option: "idleTimeout" }
+  });
+}
+function assertPoolMin(params) {
+  const { value, max } = params;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= max)
+    return value;
+  throw new VibeError5({
+    code: "VIBE_CONFIG",
+    message: `pgAdapter \`min\` must be an integer from 0 through \`max\` (${max}).`,
+    meta: { adapter: "pg", reason: "invalid-pool-min", option: "min", max }
+  });
+}
 function buildPoolConfig(params) {
-  const { max, statementTimeout, connectionTimeout } = params;
+  const { max, min, statementTimeout, connectionTimeout, idleTimeout } = params;
   const placement = placePlanCacheMode({
     connectionString: params.connectionString,
     planCacheMode: params.planCacheMode ?? "auto"
   });
   const config = { connectionString: placement.connectionString, max };
+  if (min !== undefined)
+    config.min = min;
   if (statementTimeout !== undefined)
     config.statement_timeout = statementTimeout;
   if (connectionTimeout !== undefined)
     config.connectionTimeoutMillis = connectionTimeout;
+  if (idleTimeout !== undefined)
+    config.idleTimeoutMillis = idleTimeout;
   if (placement.options !== undefined)
     config.options = placement.options;
   return config;
 }
 
 // packages/adapter-pg/src/statement-cache.ts
+import { createHash } from "crypto";
 var DEFAULT_PROMOTE_AFTER = 2;
 var SIGHTINGS_PER_NAME = 4;
+var NAME_PREFIX = "vibeorm_";
+var BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+function statementNameFor(params) {
+  const digest = createHash("sha256").update(params.text, "utf8").digest();
+  let name = NAME_PREFIX;
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of digest) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      name += BASE32_ALPHABET[buffer >>> bits & 31];
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits > 0)
+    name += BASE32_ALPHABET[buffer << 5 - bits & 31];
+  return name;
+}
 function createStatementNameCache(params) {
   const max = Math.max(0, params.max);
   const promoteAfter = Math.max(1, params.promoteAfter ?? DEFAULT_PROMOTE_AFTER);
   const sightingsMax = max * SIGHTINGS_PER_NAME;
   const names = new Map;
   const sightings = new Map;
-  let counter = 0;
   return {
     getName(nameParams) {
       const { text } = nameParams;
@@ -562,7 +799,7 @@ function createStatementNameCache(params) {
         return;
       }
       sightings.delete(text);
-      const name = `vibeorm_${counter++}`;
+      const name = statementNameFor({ text });
       names.set(text, name);
       return name;
     },
@@ -575,8 +812,88 @@ function createStatementNameCache(params) {
   };
 }
 
+// packages/adapter-pg/src/timestamp-text.ts
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var DIGIT_POSITIONS = [0, 1, 2, 3, 5, 6, 8, 9, 11, 12, 14, 15, 17, 18];
+function parsePlainTimestampText(params) {
+  const { text, zoned } = params;
+  const length = text.length;
+  if (length < 19 || text.charCodeAt(4) !== 45 || text.charCodeAt(7) !== 45 || text.charCodeAt(10) !== 32 || text.charCodeAt(13) !== 58 || text.charCodeAt(16) !== 58) {
+    return;
+  }
+  for (let position = 0;position < DIGIT_POSITIONS.length; position++) {
+    const code = text.charCodeAt(DIGIT_POSITIONS[position]);
+    if (code < 48 || code > 57)
+      return;
+  }
+  const year = (text.charCodeAt(0) - 48) * 1000 + (text.charCodeAt(1) - 48) * 100 + (text.charCodeAt(2) - 48) * 10 + (text.charCodeAt(3) - 48);
+  const month = (text.charCodeAt(5) - 48) * 10 + (text.charCodeAt(6) - 48);
+  const day = (text.charCodeAt(8) - 48) * 10 + (text.charCodeAt(9) - 48);
+  const hour = (text.charCodeAt(11) - 48) * 10 + (text.charCodeAt(12) - 48);
+  const minute = (text.charCodeAt(14) - 48) * 10 + (text.charCodeAt(15) - 48);
+  const second = (text.charCodeAt(17) - 48) * 10 + (text.charCodeAt(18) - 48);
+  if (year < 1000 || month < 1 || month > 12 || day < 1 || hour > 23 || minute > 59 || second > 59)
+    return;
+  if (day > 28) {
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = month === 2 ? leap ? 29 : 28 : DAYS_IN_MONTH[month - 1];
+    if (day > days)
+      return;
+  }
+  let index = 19;
+  let milliseconds = 0;
+  if (index < length && text.charCodeAt(index) === 46) {
+    index++;
+    const start = index;
+    while (index < length) {
+      const code = text.charCodeAt(index);
+      if (code < 48 || code > 57)
+        break;
+      if (index - start < 3)
+        milliseconds = milliseconds * 10 + (code - 48);
+      index++;
+    }
+    const digits = index - start;
+    if (digits === 0 || digits > 6)
+      return;
+    if (digits === 1)
+      milliseconds *= 100;
+    else if (digits === 2)
+      milliseconds *= 10;
+  }
+  let offsetMinutes = 0;
+  if (zoned) {
+    if (index + 3 > length)
+      return;
+    const sign = text.charCodeAt(index);
+    if (sign !== 43 && sign !== 45)
+      return;
+    const hours1 = text.charCodeAt(index + 1) - 48;
+    const hours2 = text.charCodeAt(index + 2) - 48;
+    if (hours1 < 0 || hours1 > 9 || hours2 < 0 || hours2 > 9)
+      return;
+    offsetMinutes = (hours1 * 10 + hours2) * 60;
+    index += 3;
+    if (index < length) {
+      if (index + 3 !== length || text.charCodeAt(index) !== 58)
+        return;
+      const minutes1 = text.charCodeAt(index + 1) - 48;
+      const minutes2 = text.charCodeAt(index + 2) - 48;
+      if (minutes1 < 0 || minutes1 > 9 || minutes2 < 0 || minutes2 > 9)
+        return;
+      offsetMinutes += minutes1 * 10 + minutes2;
+      index = length;
+    }
+    if (sign === 45)
+      offsetMinutes = -offsetMinutes;
+  }
+  if (index !== length)
+    return;
+  return new Date(Date.UTC(year, month - 1, day, hour, minute, second, milliseconds) - offsetMinutes * 60000);
+}
+
 // packages/adapter-pg/src/transaction-sql.ts
-import { VibeError as VibeError4 } from "@vibeorm/schema";
+import { VibeError as VibeError6 } from "@vibeorm/schema";
 import { refuseNestedTransactionOptions } from "@vibeorm/runtime/adapter-kit";
 var ISOLATION_LEVEL_SQL = Object.freeze({
   ReadCommitted: "READ COMMITTED",
@@ -599,7 +916,7 @@ function openTransactionStatement(params) {
 function statementTimeoutStatement(params) {
   const { timeout } = params;
   if (!Number.isInteger(timeout) || timeout < 0) {
-    throw new VibeError4({
+    throw new VibeError6({
       code: "VIBE_VALIDATION",
       message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,
       meta: { timeout }
@@ -616,6 +933,12 @@ function classifyRawTransactionControl(params) {
     return "close";
   return null;
 }
+var NOT_PROVABLY_ONE_STATEMENT = /[;$\u0000]|--|\/\*/;
+var OWN_TURN_VERBS = /^\s*(?:begin|start|commit|end|rollback|abort|savepoint|release|prepare|copy)\b/i;
+function isSingleStatementText(params) {
+  const { text } = params;
+  return text.trim() !== "" && !NOT_PROVABLY_ONE_STATEMENT.test(text) && !OWN_TURN_VERBS.test(text);
+}
 
 // packages/adapter-pg/src/index.ts
 import { createSavepointCounter, nextSavepointName } from "@vibeorm/runtime/adapter-kit";
@@ -629,23 +952,56 @@ import {
   transactionOutcomeUnknownError,
   validateTransactionDeadline as validateTransactionDeadline2
 } from "@vibeorm/runtime/adapter-kit";
+function laneGroupMisuse(params) {
+  return new VibeError7({ code: "VIBE_INTERNAL", message: `pipeline lane group: ${params.message}`, meta: { reason: "pipeline-lane-group" } });
+}
 var MAX_STATEMENT_TIMEOUT_MS = 2147483647;
 var ignore = () => {
   return;
 };
+function predecessorClosedError() {
+  return new VibeError7({
+    code: "VIBE_TRANSACTION",
+    message: "pipeline(): an earlier lane of this ordered scope closed without issuing its statement, so this statement was not sent " + "(the operation before it failed before it reached the database)",
+    meta: { reason: "pipeline-predecessor-closed" }
+  });
+}
+function orderedLaneMisuse(params) {
+  return new VibeError7({ code: "VIBE_INTERNAL", message: `pipeline(): ${params.message}`, meta: { reason: "pipeline-ordered-lane" } });
+}
+var COMMIT_STEP = Object.freeze({ text: "COMMIT" });
+function commitSentRefusal() {
+  return new VibeError7({
+    code: "VIBE_TRANSACTION",
+    message: "this transaction already sent its COMMIT together with its last statement, so it accepts no further statement",
+    meta: { provider: PROVIDER, reason: "commit-sent" }
+  });
+}
+function finalStatementMisuse() {
+  return new VibeError7({
+    code: "VIBE_INTERNAL",
+    message: "withCommit(): a view carries ONE statement, the transaction's last",
+    meta: { reason: "with-commit-second-statement" }
+  });
+}
+function beforeCommit(params) {
+  const { outcome, commitIndex } = params;
+  const steps = outcome.steps.slice(0, commitIndex);
+  return steps.length < commitIndex && outcome.transportError !== undefined ? { steps, transportError: outcome.transportError } : { steps };
+}
 function finalResult(params) {
   return Array.isArray(params.result) ? params.result.at(-1) ?? { rows: [], rowCount: 0 } : params.result;
 }
 var POOL_STATEMENT_NAMES = new WeakMap;
 function isConnectionLoss(params) {
   const { error } = params;
-  if (!(error instanceof VibeError5))
+  if (!(error instanceof VibeError7))
     return true;
   const sqlstate = error.meta.sqlstate;
   return typeof sqlstate !== "string" || sqlstate.startsWith("08") || ["57P01", "57P02", "57P03"].includes(sqlstate);
 }
 function commitOutcomeUnknownError(params) {
-  return new VibeError5({
+  return new VibeError7({
     code: "VIBE_TRANSACTION",
     message: "the connection was lost while COMMIT was in flight, so the transaction's outcome is unknown: the write may have committed. The connection was discarded; inspect the data before retrying.",
     meta: { provider: PROVIDER, reason: "transaction-outcome-unknown", outcome: "unknown", stage: "commit" },
@@ -674,7 +1030,7 @@ function observeReadyForQuery(params) {
   client.on("end", onEnd);
   return {
     reusableAfter: async ({ error, named }) => {
-      if (!(error instanceof VibeError5))
+      if (!(error instanceof VibeError7))
         return false;
       const sqlstate = error.meta.sqlstate;
       if (typeof sqlstate !== "string" || NEVER_REUSE_SQLSTATE_CLASSES.has(sqlstate.slice(0, 2)))
@@ -711,8 +1067,10 @@ function guardBackgroundErrors(params) {
 }
 var DIALECT = "postgres";
 var PROVIDER = "postgresql";
-var WIRE = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
+var WIRE = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native", bytes: "buffer" });
 var ROUND_TRIPS = "network";
+var READ_SNAPSHOT = Object.freeze({ isolationLevel: "RepeatableRead", accessMode: "readOnly" });
+var PIPELINING = "batched";
 var BUDGETS = Object.freeze({
   acquireTimeout: true,
   statementTimeout: "all-statements",
@@ -725,16 +1083,21 @@ var TIMESTAMP_OID = 1114;
 var TIMESTAMP_ARRAY_OID = 1115;
 var DATE_OID = 1082;
 var DATE_ARRAY_OID = 1182;
+var TIMESTAMPTZ_OID = 1184;
+var TIMESTAMPTZ_ARRAY_OID = 1185;
 var driverTypeParser = pg3.types.getTypeParser;
 var ZONE_LESS_TEXT = /^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)?$/;
 function parseZoneLessAsUtc(value) {
+  const plain = parsePlainTimestampText({ text: value, zoned: false });
+  if (plain !== undefined)
+    return plain;
   if (ZONE_LESS_TEXT.test(value)) {
     const iso = value.includes(" ") ? `${value.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z` : value;
     const parsed = new Date(iso);
     if (!Number.isNaN(parsed.getTime()))
       return parsed;
   }
-  return driverTypeParser(TIMESTAMP_OID, "text")(value);
+  return parseExtendedDateTimeText({ text: value }) ?? driverTypeParser(TIMESTAMP_OID, "text")(value);
 }
 function parseZoneLessArrayAsUtc(value) {
   const mapElements = (element) => {
@@ -746,6 +1109,28 @@ function parseZoneLessArrayAsUtc(value) {
   };
   return mapElements(driverTypeParser(TEXT_ARRAY_OID, "text")(value));
 }
+var pgTypesArrayParser = (() => {
+  const candidate = pg3.types.arrayParser;
+  return typeof candidate?.create === "function" ? candidate : undefined;
+})();
+function recogniseBuiltinParser(params) {
+  const parser = driverTypeParser(params.oid, "text");
+  return parser.name === params.name && params.peers.every((peer) => driverTypeParser(peer, "text") === parser) ? parser : undefined;
+}
+var BUILTIN_TIMESTAMPTZ_PARSER = recogniseBuiltinParser({
+  oid: TIMESTAMPTZ_OID,
+  peers: [TIMESTAMP_OID, DATE_OID],
+  name: "parseDate"
+});
+var BUILTIN_TIMESTAMPTZ_ARRAY_PARSER = pgTypesArrayParser === undefined || BUILTIN_TIMESTAMPTZ_PARSER === undefined ? undefined : recogniseBuiltinParser({ oid: TIMESTAMPTZ_ARRAY_OID, peers: [TIMESTAMP_ARRAY_OID, DATE_ARRAY_OID], name: "parseDateArray" });
+function parseTimestamptzText(value) {
+  return parsePlainTimestampText({ text: value, zoned: true }) ?? BUILTIN_TIMESTAMPTZ_PARSER(value);
+}
+function parseTimestamptzArrayText(value) {
+  if (!value)
+    return null;
+  return pgTypesArrayParser.create(value, (entry) => entry !== null ? parseTimestamptzText(entry) : entry).parse();
+}
 var EXACT_TYPES = {
   getTypeParser(oid, format) {
     if (format === undefined || format === "text") {
@@ -755,6 +1140,14 @@ var EXACT_TYPES = {
         return parseZoneLessAsUtc;
       if (oid === TIMESTAMP_ARRAY_OID || oid === DATE_ARRAY_OID)
         return parseZoneLessArrayAsUtc;
+      if (oid === TIMESTAMPTZ_OID) {
+        const driver = driverTypeParser(oid, "text");
+        return driver === BUILTIN_TIMESTAMPTZ_PARSER ? parseTimestamptzText : driver;
+      }
+      if (oid === TIMESTAMPTZ_ARRAY_OID) {
+        const driver = driverTypeParser(oid, "text");
+        return driver === BUILTIN_TIMESTAMPTZ_ARRAY_PARSER ? parseTimestamptzArrayText : driver;
+      }
     }
     return driverTypeParser(oid, format);
   }
@@ -764,23 +1157,52 @@ function takeAddress(params) {
   if (options?.pool !== undefined && options.pool !== null)
     return { pool: options.pool };
   const connectionString = options?.connectionString;
-  if (typeof connectionString === "string" && connectionString.trim() !== "")
-    return { connectionString };
-  throw new VibeError5({
+  if (typeof connectionString === "string" && connectionString.trim() !== "") {
+    return { connectionString: honourSystemRootCert({ connectionString, option: "connectionString" }) };
+  }
+  throw new VibeError7({
     code: "VIBE_CONFIG",
     message: "pgAdapter needs an explicit address: pass `connectionString` (a PostgreSQL URL) or an existing `pool`. " + "The adapter does not read DATABASE_URL or the PG* environment variables.",
     meta: { adapter: "pg", reason: "missing-address" }
   });
 }
+function transactionsTakeOneRoundTrip(params) {
+  const { address } = params;
+  if (!batchDriverAvailable())
+    return false;
+  const config = "pool" in address ? address.pool.options ?? {} : { connectionString: address.connectionString };
+  if (config.pipeline === true)
+    return false;
+  let timeout = config.query_timeout;
+  const connectionString = config.connectionString;
+  if (typeof connectionString === "string") {
+    if (!URL.canParse(connectionString))
+      return false;
+    const fromUrl = new URL(connectionString).searchParams.get("query_timeout");
+    if (fromUrl !== null)
+      timeout = fromUrl;
+  }
+  timeout ||= pg3.defaults.query_timeout;
+  return !(Number(timeout ?? 0) > 0);
+}
 function pgAdapter(options) {
   const address = takeAddress({ options });
-  const cancellationAddress = options.cancellationConnectionString ?? ("connectionString" in address ? address.connectionString : undefined);
+  const cancellationAddress = options.cancellationConnectionString !== undefined ? honourSystemRootCert({ connectionString: options.cancellationConnectionString, option: "cancellationConnectionString" }) : ("connectionString" in address) ? address.connectionString : undefined;
   const readCancellation = cancellationAddress === undefined ? "before-dispatch" : "running";
   const usePrepared = options?.preparedStatements ?? false;
   const stmtCacheMax = options?.stmtCacheMax ?? 1000;
   const planCacheMode = options?.planCacheMode === undefined ? "auto" : assertPlanCacheMode({ value: options.planCacheMode });
+  const idleTimeout = "pool" in address || options?.idleTimeout === undefined ? undefined : assertIdleTimeout({ value: options.idleTimeout });
+  if (options?.min !== undefined && "pool" in address) {
+    throw new VibeError7({
+      code: "VIBE_CONFIG",
+      message: "pgAdapter `min` configures the pool the adapter builds \u2014 it cannot be applied to a caller-supplied `pool`; set `min` (and `idleTimeoutMillis`) on that pool instead",
+      meta: { adapter: "pg", reason: "pool-min-with-injected-pool", option: "min" }
+    });
+  }
+  const poolMin = options?.min === undefined ? undefined : assertPoolMin({ value: options.min, max: options.max ?? 10 });
   if (planCacheMode !== "auto" && "pool" in address) {
-    throw new VibeError5({
+    throw new VibeError7({
       code: "VIBE_CONFIG",
       message: "planCacheMode configures the pool the adapter builds \u2014 it cannot be applied to a caller-supplied `pool`; " + 'set `options: "-c plan_cache_mode=\u2026"` on that pool instead',
       meta: { planCacheMode }
@@ -802,8 +1224,10 @@ function pgAdapter(options) {
     const config = buildPoolConfig({
       connectionString: address.connectionString,
       max: options?.max ?? 10,
+      ...poolMin === undefined ? {} : { min: poolMin },
       ...options?.statementTimeout === undefined ? {} : { statementTimeout: options.statementTimeout },
       ...options?.connectionTimeout === undefined ? {} : { connectionTimeout: options.connectionTimeout },
+      ...idleTimeout === undefined ? {} : { idleTimeout },
       planCacheMode
     });
     const PoolCtor = pg3.Pool;
@@ -850,16 +1274,29 @@ function pgAdapter(options) {
     return { rows: final.rows, affectedRows: final.rowCount ?? 0 };
   }
   function createClientAdapter(params) {
-    const { dispatch, scope, budget, deferred, cancellation } = params;
-    const rawClient = { query: (config) => dispatch({ config, batchable: (config.values?.length ?? 0) > 0 }) };
+    const { dispatch, scope, budget, deferred, cancellation, pipelines, lane, connection, final } = params;
+    const laneOf = lane === undefined ? {} : { lane };
+    const finalOf = () => {
+      if (final === undefined)
+        return {};
+      if (final.used)
+        throw finalStatementMisuse();
+      final.used = true;
+      return { commit: true, ...final.discardRows === true ? { discardRows: true } : {} };
+    };
+    const waitAsLane = (wait) => lane === undefined || pipelines === null ? wait : pipelines.waitAs({ lane, wait });
+    const rawClient = {
+      query: (config) => dispatch({ config, batchable: (config.values?.length ?? 0) > 0 || isSingleStatementText({ text: config.text }), ...laneOf, ...finalOf() })
+    };
     const savepointControl = (statement, cleanup) => {
-      if (deferred !== null && deferred.routeSavepoint({ text: statement }) !== "send")
+      if (deferred !== null && deferred.routeSavepoint({ text: statement, cleanup }) !== "send")
         return;
       return runMapped(() => dispatch({
         config: { text: statement },
         stage: "nested",
         batchable: true,
-        ...cleanup ? { cleanup: true } : {}
+        ...cleanup ? { cleanup: true } : {},
+        ...laneOf
       }));
     };
     return {
@@ -869,6 +1306,74 @@ function pgAdapter(options) {
       budgets: BUDGETS,
       readCancellation: cancellation.support,
       roundTrips: ROUND_TRIPS,
+      readSnapshot: READ_SNAPSHOT,
+      pipelining: pipelines === null ? "ordered" : PIPELINING,
+      connectionIdentity: connection,
+      ...params.topLevel !== true || deferred === null ? {} : {
+        deferStatement: (statement) => {
+          budget.assertUsable({ stage: "statement" });
+          deferred.defer({ text: statement.text, values: prepareBatchValues({ values: statement.values }) });
+        }
+      },
+      ...params.commits !== true || deferred === null || scope.depth !== 0 || final !== undefined ? {} : {
+        withCommit: (options) => createClientAdapter({
+          dispatch,
+          scope,
+          budget,
+          deferred,
+          cancellation,
+          pipelines,
+          ...laneOf,
+          connection,
+          final: { used: false, ...options?.rows === "discard" ? { discardRows: true } : {} }
+        })
+      },
+      ...pipelines === null ? {} : {
+        ...params.ordered === true ? { orderedPipeline: true } : {},
+        pipeline: ({ lanes: count, ordered }) => {
+          budget.assertUsable({ stage: "statement" });
+          if (lane?.seat !== undefined)
+            throw laneGroupMisuse({ message: "a sub-lane opens no pipeline scope" });
+          if (lane?.group !== undefined)
+            throw laneGroupMisuse({ message: "a lane opens no pipeline scope while its group is open" });
+          if (!Number.isSafeInteger(count) || count < 1) {
+            throw new VibeError7({ code: "VIBE_VALIDATION", message: "pipeline() needs a positive whole number of lanes", meta: { lanes: count } });
+          }
+          if (ordered === true && params.ordered !== true) {
+            throw new VibeError7({
+              code: "VIBE_VALIDATION",
+              message: "pipeline({ ordered: true }) is offered only on a handle that declares orderedPipeline (the top-level or a savepoint handle of a transaction without a deadline, outside a pipeline lane)",
+              meta: { ordered: true, reason: "ordered-pipeline-undeclared" }
+            });
+          }
+          const laneHandle = (opened) => ({
+            adapter: createClientAdapter({ dispatch, scope, budget, deferred, cancellation, pipelines, lane: opened, connection, ...params.commits === true && opened.seat === undefined ? { commits: true } : {} }),
+            close: () => {
+              pipelines.close(opened);
+            },
+            ...opened.order === undefined ? {} : {
+              follow: () => {
+                budget.assertUsable({ stage: "statement" });
+                return laneHandle(pipelines.follow(opened));
+              }
+            },
+            ...opened.order !== undefined || opened.seat !== undefined || lane !== undefined ? {} : {
+              group: (options) => {
+                const opening = pipelines.group(opened, options?.final === true && params.commits === true);
+                if (opening === undefined)
+                  return;
+                return {
+                  lane: () => laneHandle(pipelines.seat(opening)),
+                  seal: () => {
+                    pipelines.seal(opening);
+                  }
+                };
+              }
+            }
+          });
+          return (ordered === true ? pipelines.openOrdered(count) : pipelines.open(count)).map(laneHandle);
+        }
+      },
       rowChanges: () => {
         budget.assertUsable({ stage: "statement" });
         return readRowChanges({ scope });
@@ -877,29 +1382,39 @@ function pgAdapter(options) {
         return runReadExecution({ ...execParams, support: cancellation.support, provider: PROVIDER, run: async () => {
           const turn = scopeTurn({ scope });
           if (turn !== undefined)
-            await turn;
+            await waitAsLane(turn);
           budget.assertUsable({ stage: "statement" });
           assertReadExecution2({ ...execParams, support: cancellation.support, provider: PROVIDER, stage: "waiting-for-connection" });
-          const queryable = { query: (config) => dispatch({ config, batchable: execParams.execution?.cancellation !== "running", execution: execParams.execution, onReadControl: execParams.onReadControl }) };
+          const queryable = { query: (config) => dispatch({ config, batchable: execParams.execution?.cancellation !== "running", execution: execParams.execution, onReadControl: execParams.onReadControl, ...laneOf, ...finalOf() }) };
           return runExecute({ queryable, scope, ...execParams }).catch((error) => abortTransactionOnServerFailure({ scope, error }));
         } });
       },
       async executeUnsafe(execParams) {
         const turn = scopeTurn({ scope });
         if (turn !== undefined)
-          await turn;
+          await waitAsLane(turn);
         budget.assertUsable({ stage: "statement" });
         return runExecuteUnsafe({ queryable: rawClient, scope, ...execParams }).catch((error) => abortTransactionOnServerFailure({ scope, error }));
       },
       async transaction(fn, nestedOptions) {
         refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
         budget.assertUsable({ stage: "nested" });
+        if (lane?.group !== undefined)
+          throw laneGroupMisuse({ message: "a lane opens no savepoint while its group is open" });
+        if (lane?.seat !== undefined)
+          throw laneGroupMisuse({ message: "a sub-lane opens no savepoint" });
+        pipelines?.flush();
+        const leave = lane === undefined || pipelines === null ? ignore : pipelines.enter(lane);
         return runNestedSavepoint({
           scope,
           execute: (statement) => savepointControl(statement, false),
           cleanup: (statement) => savepointControl(statement, true),
-          body: (child) => fn(createClientAdapter({ dispatch, scope: child, budget, deferred, cancellation }))
-        });
+          body: (child) => {
+            leave();
+            const ordered = lane === undefined && params.ordered === true ? { ordered: true } : {};
+            return fn(createClientAdapter({ dispatch, scope: child, budget, deferred, cancellation, pipelines, connection, ...laneOf, ...ordered }));
+          }
+        }).finally(leave);
       },
       async connect() {
         budget.assertUsable({ stage: "statement" });
@@ -1034,7 +1549,8 @@ function pgAdapter(options) {
       validateTransactionDeadline({
         options: transactionOptions,
         support: BUDGETS.transactionDeadline,
-        provider: PROVIDER
+        provider: PROVIDER,
+        settings: "transaction-local"
       });
       const openingOptions = {
         isolationLevel: transactionOptions?.isolationLevel,
@@ -1042,7 +1558,25 @@ function pgAdapter(options) {
         timeout: transactionOptions?.timeout
       };
       const openText = openTransactionStatement(openingOptions);
+      const settings = readTransactionSettings({ settings: transactionOptions?.settings, provider: PROVIDER });
+      const settingsStatement = settings.length === 0 ? undefined : renderTransactionSettings({ settings });
       const client = await runMapped(() => getPool().connect());
+      const turns = createClientTurns();
+      let gathering = null;
+      let gatheringsPending = 0;
+      const runTurn = (send) => {
+        gathering = null;
+        return turns.run(send);
+      };
+      const onClient = {
+        query: (config) => runTurn(() => client.query(config)),
+        get pipeline() {
+          return client.pipeline;
+        },
+        get connectionParameters() {
+          return client.connectionParameters;
+        }
+      };
       let connectionFailure;
       const unguard = guardBackgroundErrors({
         client,
@@ -1054,22 +1588,68 @@ function pgAdapter(options) {
       const scope = createSavepointScope();
       const budget = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
       const capable = supportsBatch({ client });
-      const deferOpening = capable && (openingOptions.timeout === undefined || openingOptions.timeout <= MAX_STATEMENT_TIMEOUT_MS);
+      const deferOpening = (settingsStatement === undefined || transactionOptions?.deferSettings === true) && capable && (openingOptions.timeout === undefined || openingOptions.timeout <= MAX_STATEMENT_TIMEOUT_MS);
       const opening = deferOpening ? [beginStatement(openingOptions), ...openingOptions.timeout === undefined ? [] : [statementTimeoutStatement({ timeout: openingOptions.timeout })]] : [];
-      const deferred = createDeferredControl({ opening });
+      const deferred = createDeferredControl({ opening, ...budget.totalMs === null ? { deferReleases: true } : {} });
+      const settingsDeferred = deferOpening && settingsStatement !== undefined;
+      if (settingsDeferred)
+        deferred.defer({ text: settingsStatement.text, values: prepareBatchValues({ values: settingsStatement.values }) });
+      const openingLength = opening.length + (settingsDeferred ? 1 : 0);
+      const openingStepError = (index, error) => {
+        const mapped = mapPgDriverError({ error });
+        if (!settingsDeferred || index !== opening.length || typeof mapped.meta.sqlstate !== "string")
+          return mapped;
+        return transactionSettingRefusedError({ provider: PROVIDER, settings, setting: findRefusedSetting({ settings, cause: mapped }), cause: mapped, deferred: true });
+      };
       let openingFailure;
       let inFlight = null;
+      const commits = capable && budget.totalMs === null && !((client.connectionParameters?.query_timeout ?? 0) > 0);
+      let ridden;
+      let ordinaryOpen = 0;
+      const ridesNow = () => commits && ridden === undefined && !cancellationQueue && !cancellationAttempted && connectionFailure === undefined && openingFailure === undefined && scope.state.open === null && scope.state.aborted === null && scope.state.poisoned === null;
+      const settleRidden = (entry, outcome, commitIndex) => {
+        const step = outcome.steps[commitIndex];
+        const answeredError = step?.status === "failed" ? mapPgDriverError({ error: step.error }) : undefined;
+        if (step === undefined || answeredError !== undefined && isConnectionLoss({ error: answeredError })) {
+          commitProgress = "unanswered";
+          discard = true;
+          budget.close({ outcome: "unknown" });
+          entry.state = "lost";
+          entry.error = commitOutcomeUnknownError({ cause: answeredError ?? outcome.transportError ?? firstBatchFailure({ outcome })?.error });
+        } else if (step.status === "skipped") {
+          commitProgress = "not-sent";
+          entry.state = "skipped";
+        } else if (step.status === "failed" || step.result.command === "ROLLBACK") {
+          commitProgress = "answered";
+          entry.state = "failed";
+          entry.error = answeredError ?? transactionAbortedError2({ cause: scope.state.aborted?.cause });
+        } else {
+          entry.state = "committed";
+        }
+      };
+      const trackRidden = (batch, commitIndex) => {
+        commitProgress = "sent";
+        const entry = { settled: Promise.resolve(), state: "in-flight" };
+        entry.settled = batch.then((outcome) => {
+          settleRidden(entry, outcome, commitIndex);
+        }, (error) => {
+          settleRidden(entry, { steps: [], transportError: error }, commitIndex);
+        });
+        ridden = entry;
+      };
       const sendWithControl = (dispatchParams) => {
         const { config, cleanup } = dispatchParams;
         const handOver = () => {
           assertReadExecution2({ execution: dispatchParams.execution, effect: "read", support: readCancellation, provider: PROVIDER, stage: "waiting-for-connection" });
           dispatchParams.sent?.();
-          return cancellation.run({ config, execution: dispatchParams.execution, onReadControl: dispatchParams.onReadControl, send: () => client.query(config) });
+          return cancellation.run({ config, execution: dispatchParams.execution, onReadControl: dispatchParams.onReadControl, send: () => onClient.query(config) });
         };
         if (cleanup !== true && cancellationAttempted)
-          throw transactionAbortedError({ cause: readCancelledError2({ stage: "running" }) });
+          throw transactionAbortedError2({ cause: readCancelledError2({ stage: "running" }) });
         if (cleanup !== true && openingFailure !== undefined)
-          throw transactionAbortedError({ cause: openingFailure });
+          throw transactionAbortedError2({ cause: openingFailure });
+        if (cleanup !== true && ridden !== undefined)
+          throw commitSentRefusal();
         let bound;
         if (cleanup !== true && budget.totalMs !== null) {
           if (scope.state.poisoned !== null)
@@ -1083,30 +1663,45 @@ function pgAdapter(options) {
           if (bound === undefined)
             return handOver();
           const stage = dispatchParams.stage ?? "statement";
-          return runMapped(() => client.query({ text: bound })).then(() => {
+          return runMapped(() => onClient.query({ text: bound })).then(() => {
             budget.assertUsable({ stage });
             return handOver();
           });
         }
         const pendingControl = cleanup !== true && deferred.hasPending();
-        if (!pendingControl && bound === undefined)
+        const rides = dispatchParams.commit === true && cleanup !== true && dispatchParams.batchable === true && bound === undefined && ordinaryOpen === 1 && ridesNow();
+        if (!pendingControl && bound === undefined && !rides) {
+          if ((gathering?.phase === "turn" || turns.outstanding() > 0) && gathers(dispatchParams) && deferred.opened())
+            return gatherInTurn(dispatchParams);
           return handOver();
-        const statement = dispatchParams.batchable === true ? [{ text: config.text, values: prepareBatchValues({ values: config.values ?? [] }) }] : [];
+        }
+        const statement = dispatchParams.batchable === true ? [{ text: config.text, values: prepareBatchValues({ values: config.values ?? [] }), ...rides && dispatchParams.discardRows === true ? { discardRows: true } : {} }] : [];
+        assertReadExecution2({ execution: dispatchParams.execution, effect: "read", support: readCancellation, provider: PROVIDER, stage: "waiting-for-connection" });
         const carriesOpening = !deferred.opened();
-        const control = pendingControl ? [...deferred.take()] : [];
+        const control = pendingControl ? [...deferred.takeSteps()] : [];
         if (bound !== undefined)
-          control.push(bound);
-        const openingSteps = carriesOpening ? opening.length : 0;
-        assertReadExecution2({ execution: dispatchParams.execution, effect: "read", support: readCancellation, provider: PROVIDER, stage: "waiting-for-connection" });
+          control.push({ text: bound });
+        const openingSteps = carriesOpening ? openingLength : 0;
         if (statement.length > 0)
           dispatchParams.sent?.();
-        const burst = runBatch({ client, steps: [...control.map((text) => ({ text })), ...statement], types: EXACT_TYPES }).then((outcome) => {
+        const commitIndex = control.length + statement.length;
+        const batch = runTurn(() => runBatch({ client, steps: [...control, ...statement, ...rides ? [COMMIT_STEP] : []], types: EXACT_TYPES }));
+        if (rides)
+          trackRidden(batch, commitIndex);
+        const burst = batch.then((received) => {
+          const outcome = rides ? beforeCommit({ outcome: received, commitIndex }) : received;
           const failure = firstBatchFailure({ outcome });
           if (failure !== undefined) {
-            if (failure.index < openingSteps || outcome.transportError !== undefined && openingSteps > 0) {
-              openingFailure = mapPgDriverError({ error: failure.error });
+            const openingFailed = failure.index < openingSteps || outcome.transportError !== undefined && openingSteps > 0;
+            if (openingFailed) {
+              openingFailure = openingStepError(failure.index, failure.error);
             }
-            throw failure.error;
+            if (gatheringsPending > 0) {
+              const mapped = openingFailed && openingFailure !== undefined ? openingFailure : mapPgDriverError({ error: failure.error });
+              if (typeof mapped.meta.sqlstate === "string")
+                markTransactionAborted({ scope, cause: mapped });
+            }
+            throw openingFailed && settingsDeferred && failure.index === opening.length && openingFailure !== undefined ? openingFailure : failure.error;
           }
           if (statement.length === 0)
             return handOver();
@@ -1122,35 +1717,564 @@ function pgAdapter(options) {
         }
         return burst;
       };
-      const send = (dispatchParams) => {
+      const guarded = (run) => {
         try {
-          return sendWithControl(dispatchParams);
+          return run();
         } catch (error) {
           return Promise.reject(error);
         }
       };
+      const send = (dispatchParams) => guarded(() => sendWithControl(dispatchParams));
       let tail = Promise.resolve();
       const activeDispatches = new Set;
       let cancellationQueue = false;
+      const lanes = new Set;
+      let queued = [];
+      const settleQueued = (entry, outcome) => {
+        if (entry.settled)
+          return;
+        entry.settled = true;
+        entry.lane.waiting -= 1;
+        if ("result" in outcome) {
+          entry.resolve(outcome.result);
+        } else {
+          entry.failure = outcome.error;
+          entry.reject(outcome.error);
+        }
+      };
+      const distributeBurst = (burst) => {
+        const { outcome, live, controlSteps, openingSteps } = burst;
+        const failure = firstBatchFailure({ outcome });
+        if (failure === undefined) {
+          live.forEach((entry, index) => {
+            const step = outcome.steps[controlSteps + index];
+            settleQueued(entry, { result: step?.status === "ok" ? step.result : { rows: [], rowCount: 0 } });
+          });
+          return;
+        }
+        const mapped = failure.index < openingSteps ? openingStepError(failure.index, failure.error) : mapPgDriverError({ error: failure.error });
+        if (failure.index < openingSteps || outcome.transportError !== undefined && openingSteps > 0)
+          openingFailure = mapped;
+        if (typeof mapped.meta.sqlstate === "string")
+          markTransactionAborted({ scope, cause: mapped });
+        const answered = outcome.transportError === undefined;
+        if (failure.index < controlSteps) {
+          const later = answered || openingFailure !== undefined ? transactionAbortedError2({ cause: openingFailure ?? mapped }) : mapped;
+          live.forEach((entry, index) => {
+            settleQueued(entry, { error: index === 0 ? mapped : later });
+          });
+          return;
+        }
+        let abortCause = mapped;
+        live.forEach((entry, index) => {
+          const position = controlSteps + index;
+          const step = outcome.steps[position];
+          if (step === undefined) {
+            settleQueued(entry, { error: position === failure.index || openingFailure === undefined ? mapped : transactionAbortedError2({ cause: openingFailure }) });
+          } else if (step.status === "ok") {
+            settleQueued(entry, { result: step.result });
+          } else if (step.status === "failed") {
+            const error = position === failure.index ? mapped : mapPgDriverError({ error: step.error });
+            if (typeof error.meta.sqlstate === "string")
+              abortCause = error;
+            settleQueued(entry, { error });
+          } else {
+            settleQueued(entry, { error: transactionAbortedError2({ cause: abortCause }) });
+          }
+        });
+      };
+      const sendRefusal = () => ridden !== undefined ? commitSentRefusal() : cancellationAttempted ? transactionAbortedError2({ cause: readCancelledError2({ stage: "running" }) }) : openingFailure !== undefined ? transactionAbortedError2({ cause: openingFailure }) : scope.state.poisoned ?? (scope.state.aborted === null ? undefined : transactionAbortedError2({ cause: scope.state.aborted.cause }));
+      const ridesQueued = (live) => {
+        const last = live.at(-1);
+        if (last === undefined || last.commit !== true && last.lane.seat?.group.final !== true || queued.length > 0 || inFlight !== null || ordinaryOpen > 0 || !ridesNow())
+          return false;
+        const counts = new Map;
+        for (const entry of live) {
+          if (entry.commit !== true && entry.lane.order?.followed !== true && entry.lane.seat?.group.final !== true)
+            return false;
+          counts.set(entry.lane, (counts.get(entry.lane) ?? 0) + 1);
+        }
+        for (const open of lanes) {
+          const count = counts.get(open) ?? 0;
+          if (count > 0 && open.waiting === count)
+            continue;
+          const group = open.group;
+          if (count === 0 && group?.final === true && group.sealed && open.waiting === 1 && live.some((entry) => entry.lane.seat?.group === group))
+            continue;
+          if (count === 0 && open.final === true && open.waiting === 0)
+            continue;
+          return false;
+        }
+        return true;
+      };
+      const sendQueued = (entries, options) => {
+        const inTurn = options?.inTurn === true;
+        const refusal = sendRefusal();
+        const live = [];
+        for (const entry of entries) {
+          if (refusal !== undefined)
+            settleQueued(entry, { error: refusal });
+          else if (entry.execution?.signal?.aborted === true)
+            settleQueued(entry, { error: readCancelledError2({ stage: "waiting-for-connection" }) });
+          else
+            live.push(entry);
+        }
+        if (live.length === 0)
+          return Promise.resolve();
+        const carriesOpening = !inTurn && !deferred.opened();
+        const rides = !inTurn && live.length === entries.length && ridesQueued(live);
+        const control = inTurn ? [] : deferred.takeSteps();
+        const openingSteps = carriesOpening ? openingLength : 0;
+        const commitIndex = control.length + live.length;
+        const sendBatch = () => runBatch({ client, steps: [...control, ...live.map((entry) => ({ text: entry.text, values: entry.values })), ...rides ? [COMMIT_STEP] : []], types: EXACT_TYPES });
+        const batch = inTurn ? new Promise((resolve) => {
+          resolve(sendBatch());
+        }) : runTurn(sendBatch);
+        if (rides)
+          trackRidden(batch, commitIndex);
+        const burst = batch.then((received) => {
+          distributeBurst({ outcome: rides ? beforeCommit({ outcome: received, commitIndex }) : received, live, controlSteps: control.length, openingSteps });
+        }).then(undefined, (error) => {
+          if (openingSteps > 0)
+            openingFailure ??= mapPgDriverError({ error });
+          for (const entry of live)
+            settleQueued(entry, { error });
+        });
+        if (carriesOpening) {
+          const settled = burst.then(() => {
+            if (inFlight === settled)
+              inFlight = null;
+          });
+          inFlight = settled;
+        }
+        return burst;
+      };
+      const gathers = (dispatchParams) => dispatchParams.commit !== true && coalescable(dispatchParams);
+      const closeGathering = () => {
+        gathering = null;
+      };
+      const gatheredLane = { open: false, waiting: 0 };
+      const joinGathering = (group, dispatchParams, values) => new Promise((resolve, reject) => {
+        group.members.push({ params: dispatchParams, values, resolve, reject });
+      });
+      const sendGathered = (members, options) => sendQueued(members.map((member) => {
+        gatheredLane.waiting += 1;
+        return {
+          text: member.params.config.text,
+          values: member.values,
+          ...member.params.execution === undefined || options?.inTurn === true ? {} : { execution: member.params.execution },
+          lane: gatheredLane,
+          resolve: member.resolve,
+          reject: member.reject,
+          settled: false
+        };
+      }), options);
+      const gatherBehind = (dispatchParams, behind) => {
+        const values = prepareBatchValues({ values: dispatchParams.config.values ?? [] });
+        const open = gathering;
+        if (open !== null && open.phase === "opening" && open.behind === behind)
+          return joinGathering(open, dispatchParams, values);
+        const group = { phase: "opening", behind, members: [] };
+        gathering = group;
+        gatheringsPending += 1;
+        const joined = joinGathering(group, dispatchParams, values);
+        behind.then(() => {
+          if (gathering === group)
+            gathering = null;
+          gatheringsPending -= 1;
+          const [only, ...more] = group.members;
+          if (only !== undefined && more.length === 0) {
+            send(only.params).then(only.resolve, only.reject);
+            return;
+          }
+          sendGathered(group.members);
+        });
+        return joined;
+      };
+      const gatherInTurn = (dispatchParams) => {
+        assertReadExecution2({ execution: dispatchParams.execution, effect: "read", support: readCancellation, provider: PROVIDER, stage: "waiting-for-connection" });
+        const values = prepareBatchValues({ values: dispatchParams.config.values ?? [] });
+        const open = gathering;
+        if (open !== null && open.phase === "turn")
+          return joinGathering(open, dispatchParams, values);
+        const group = { phase: "turn", members: [] };
+        gatheringsPending += 1;
+        const joined = joinGathering(group, dispatchParams, values);
+        turns.run(() => sendTurnGroup(group));
+        gathering = group;
+        return joined;
+      };
+      const sendTurnGroup = (group) => {
+        if (gathering === group)
+          gathering = null;
+        gatheringsPending -= 1;
+        const [only, ...more] = group.members;
+        if (only !== undefined && more.length === 0) {
+          const query = new Promise((resolve) => {
+            resolve(client.query(only.params.config));
+          });
+          query.then(only.resolve, only.reject);
+          return query;
+        }
+        const prior = turns.lastFailure();
+        if (prior !== undefined) {
+          const mapped = mapPgDriverError({ error: prior.error });
+          if (typeof mapped.meta.sqlstate === "string")
+            markTransactionAborted({ scope, cause: mapped });
+        }
+        return sendGathered(group.members, { inTurn: true });
+      };
+      const sendAlone = (entry, alone) => {
+        const refusal = sendRefusal();
+        if (refusal !== undefined) {
+          settleQueued(entry, { error: refusal });
+          return Promise.resolve();
+        }
+        return dispatchOrdinary(alone).then((result) => {
+          settleQueued(entry, { result });
+        }, (error) => {
+          const mapped = mapPgDriverError({ error });
+          if (typeof mapped.meta.sqlstate === "string")
+            markTransactionAborted({ scope, cause: mapped });
+          settleQueued(entry, { error });
+        });
+      };
+      const prefixOf = (lane) => {
+        const order = lane.order;
+        if (order === undefined)
+          return "issued";
+        let state = "issued";
+        for (let index = 0;index < order.index; index++) {
+          const earlier = order.scope.lanes[index];
+          if (earlier.order.issued > 0)
+            continue;
+          if (!earlier.open)
+            return "closed";
+          state = "open";
+        }
+        return state;
+      };
+      const refuseOrphaned = () => {
+        if (!queued.some((entry) => prefixOf(entry.lane) === "closed"))
+          return;
+        const kept = [];
+        for (const entry of queued) {
+          if (prefixOf(entry.lane) === "closed")
+            settleQueued(entry, { error: predecessorClosedError() });
+          else
+            kept.push(entry);
+        }
+        queued = kept;
+      };
+      const orderedSend = (entries, send) => () => {
+        const live = [];
+        for (const entry of entries) {
+          const failed = entry.lane.order?.scope.failed;
+          if (failed === undefined)
+            live.push(entry);
+          else
+            settleQueued(entry, { error: sendRefusal() ?? transactionAbortedError2({ cause: failed.cause }) });
+        }
+        if (live.length === 0)
+          return Promise.resolve();
+        return send(live).then(() => {
+          for (const entry of live) {
+            const order = entry.lane.order;
+            if (order !== undefined && entry.failure !== undefined)
+              order.scope.failed ??= { cause: mapPgDriverError({ error: entry.failure }) };
+          }
+        });
+      };
+      let orderedTail = null;
+      const flushOrdered = () => {
+        refuseOrphaned();
+        const ready = [];
+        const held = [];
+        for (const entry of queued)
+          (prefixOf(entry.lane) === "issued" ? ready : held).push(entry);
+        queued = held;
+        if (ready.length === 0)
+          return;
+        ready.sort((first, second) => (first.lane.order?.index ?? 0) - (second.lane.order?.index ?? 0));
+        const sends = [];
+        let run = [];
+        for (const entry of ready) {
+          const alone = entry.alone;
+          if (alone === undefined) {
+            run.push(entry);
+            continue;
+          }
+          if (run.length > 0) {
+            sends.push(orderedSend(run, sendQueued));
+            run = [];
+          }
+          sends.push(orderedSend([entry], () => sendAlone(entry, alone)));
+        }
+        if (run.length > 0)
+          sends.push(orderedSend(run, sendQueued));
+        const before = [orderedTail, inFlight].filter((wait) => wait !== null);
+        let chain = before.length === 0 ? sends.shift()() : Promise.all(before).then(ignore);
+        for (const next of sends)
+          chain = chain.then(next);
+        const tail = chain;
+        orderedTail = tail;
+        tail.then(() => {
+          if (orderedTail === tail)
+            orderedTail = null;
+        });
+      };
+      const flushQueue = () => {
+        if (queued.length === 0)
+          return;
+        closeGathering();
+        if (queued.some((entry) => entry.lane.order !== undefined)) {
+          flushOrdered();
+          return;
+        }
+        const entries = queued.some((entry) => entry.lane.seat !== undefined) ? seatOrder(queued) : queued;
+        queued = [];
+        if (inFlight === null)
+          sendQueued(entries);
+        else
+          inFlight.then(() => {
+            sendQueued(entries);
+          });
+      };
+      const flushIfReady = () => {
+        if (queued.length === 0)
+          return;
+        for (const open of lanes)
+          if (open.waiting === 0)
+            return;
+        flushQueue();
+      };
+      const seatOrder = (entries) => [...entries].sort((first, second) => (first.lane.seat?.index ?? -1) - (second.lane.seat?.index ?? -1));
+      const endGroupIfOver = (opening) => {
+        if (!opening.sealed || opening.live > 0 || opening.parent.group !== opening)
+          return;
+        opening.parent.group = undefined;
+        opening.parent.waiting -= 1;
+      };
+      const closeLane = (lane) => {
+        if (!lane.open)
+          return;
+        lane.open = false;
+        lanes.delete(lane);
+        if (lane.order !== undefined)
+          refuseOrphaned();
+        if (lane.seat !== undefined) {
+          lane.seat.group.live -= 1;
+          endGroupIfOver(lane.seat.group);
+        }
+        flushIfReady();
+      };
+      const pipelines = {
+        open: (count) => Array.from({ length: count }, () => {
+          const opened = { open: true, waiting: 0 };
+          lanes.add(opened);
+          return opened;
+        }),
+        openOrdered: (count) => {
+          const ordered = { lanes: [] };
+          for (let index = 0;index < count; index++) {
+            const opened = { open: true, waiting: 0, order: { scope: ordered, index, issued: 0, followed: false } };
+            ordered.lanes.push(opened);
+            lanes.add(opened);
+          }
+          return [...ordered.lanes];
+        },
+        follow: (lane) => {
+          const order = lane.order;
+          if (order === undefined)
+            throw orderedLaneMisuse({ message: "follow() exists only on the lanes of an ordered scope" });
+          if (!lane.open)
+            throw orderedLaneMisuse({ message: "follow() on a closed lane" });
+          if (order.followed || order.scope.lanes.at(-1) !== lane)
+            throw orderedLaneMisuse({ message: "follow() opens one lane after the LAST lane of its scope" });
+          if (order.issued > 0)
+            throw orderedLaneMisuse({ message: "follow() must come before the lane issues its statement" });
+          order.followed = true;
+          const next = { open: true, waiting: 0, order: { scope: order.scope, index: order.scope.lanes.length, issued: 0, followed: false } };
+          order.scope.lanes.push(next);
+          lanes.add(next);
+          return next;
+        },
+        close: closeLane,
+        waitAs: ({ lane, wait }) => {
+          if (!lane.open)
+            return wait;
+          lane.waiting += 1;
+          flushIfReady();
+          return wait.then((value) => {
+            lane.waiting -= 1;
+            return value;
+          }, (error) => {
+            lane.waiting -= 1;
+            throw error;
+          });
+        },
+        enter: (lane) => {
+          if (!lane.open)
+            return ignore;
+          lane.waiting += 1;
+          flushIfReady();
+          let left = false;
+          return () => {
+            if (left)
+              return;
+            left = true;
+            lane.waiting -= 1;
+          };
+        },
+        flush: flushQueue,
+        group: (lane, final) => {
+          if (!lane.open || lane.order !== undefined || lane.seat !== undefined || lane.gate === true || lane.group !== undefined || lane.final === true)
+            return;
+          if (!capable || budget.totalMs !== null || cancellationQueue || sendRefusal() !== undefined)
+            return;
+          if ((client.connectionParameters?.query_timeout ?? 0) > 0)
+            return;
+          for (const other of lanes) {
+            if (other !== lane && (other.final !== true || other.waiting > 0))
+              return;
+          }
+          const gate = { open: true, waiting: 0, gate: true };
+          const opening = { parent: lane, gate, opened: 0, live: 0, sealed: false, final };
+          lanes.add(gate);
+          lane.group = opening;
+          lane.waiting += 1;
+          return opening;
+        },
+        seat: (opening) => {
+          if (opening.sealed)
+            throw laneGroupMisuse({ message: "a sub-lane is opened only before the group is sealed" });
+          if (!opening.parent.open)
+            throw laneGroupMisuse({ message: "a sub-lane of a closed lane" });
+          const seat = { open: true, waiting: 0, seat: { group: opening, index: opening.opened, issued: false } };
+          opening.opened += 1;
+          opening.live += 1;
+          lanes.add(seat);
+          return seat;
+        },
+        seal: (opening) => {
+          if (opening.sealed)
+            return;
+          opening.sealed = true;
+          endGroupIfOver(opening);
+          closeLane(opening.gate);
+        }
+      };
+      const endPipeline = () => {
+        for (const open of lanes)
+          open.open = false;
+        lanes.clear();
+        flushQueue();
+      };
+      const enqueue = (dispatchParams, lane, alone) => {
+        if (cancellationAttempted)
+          throw transactionAbortedError2({ cause: readCancelledError2({ stage: "running" }) });
+        if (openingFailure !== undefined)
+          throw transactionAbortedError2({ cause: openingFailure });
+        if (ridden !== undefined)
+          throw commitSentRefusal();
+        assertReadExecution2({ execution: dispatchParams.execution, effect: "read", support: readCancellation, provider: PROVIDER, stage: "waiting-for-connection" });
+        const values = alone === true ? [] : prepareBatchValues({ values: dispatchParams.config.values ?? [] });
+        const pending = new Promise((resolve, reject) => {
+          lane.waiting += 1;
+          queued.push({
+            text: dispatchParams.config.text,
+            values,
+            ...dispatchParams.execution === undefined ? {} : { execution: dispatchParams.execution },
+            ...alone === true ? { alone: dispatchParams } : {},
+            ...dispatchParams.commit === true ? { commit: true } : {},
+            lane,
+            resolve,
+            reject,
+            settled: false
+          });
+        });
+        if (lane.order !== undefined)
+          lane.order.issued += 1;
+        activeDispatches.add(pending);
+        pending.then(() => activeDispatches.delete(pending), () => activeDispatches.delete(pending));
+        flushIfReady();
+        return pending;
+      };
+      const coalescable = (dispatchParams) => capable && budget.totalMs === null && !cancellationQueue && !((client.connectionParameters?.query_timeout ?? 0) > 0) && dispatchParams.batchable === true && dispatchParams.cleanup !== true && dispatchParams.stage === undefined && dispatchParams.sent === undefined && dispatchParams.execution?.cancellation !== "running";
       const dispatch = (dispatchParams) => {
+        const lane = dispatchParams.lane?.open === true ? dispatchParams.lane : undefined;
+        if (lane !== undefined && dispatchParams.cleanup !== true) {
+          if (lane.group !== undefined)
+            return Promise.reject(laneGroupMisuse({ message: "a lane issues nothing while its group is open" }));
+          const seat = lane.seat;
+          if (seat !== undefined) {
+            if (seat.issued)
+              return Promise.reject(laneGroupMisuse({ message: "a sub-lane issues ONE statement" }));
+            if (!coalescable(dispatchParams))
+              return Promise.reject(laneGroupMisuse({ message: "a sub-lane statement must be able to join a batch" }));
+            seat.issued = true;
+          }
+          if (dispatchParams.commit === true)
+            lane.final = true;
+        }
+        const order = lane?.order;
+        if (lane !== undefined && order !== undefined && dispatchParams.cleanup !== true) {
+          return guarded(() => {
+            if (order.followed && order.issued > 0)
+              throw orderedLaneMisuse({ message: "a lane that has a follower may issue ONE statement" });
+            return coalescable(dispatchParams) ? enqueue(dispatchParams, lane) : enqueue(dispatchParams, lane, true);
+          });
+        }
+        if (lane !== undefined && coalescable(dispatchParams))
+          return guarded(() => enqueue(dispatchParams, lane));
+        if (lane === undefined)
+          return dispatchOrdinary(dispatchParams);
+        const leave = pipelines.enter(lane);
+        flushQueue();
+        return dispatchOrdinary(dispatchParams).then((result) => {
+          leave();
+          return result;
+        }, (error) => {
+          leave();
+          throw error;
+        });
+      };
+      const dispatchOrdinary = (dispatchParams) => {
         if (dispatchParams.execution?.cancellation === "running" && !cancellationQueue) {
+          flushQueue();
           cancellationQueue = true;
+          closeGathering();
           tail = Promise.allSettled([...activeDispatches]);
         }
         if (budget.totalMs === null && !cancellationQueue) {
-          const pending = inFlight === null ? send(dispatchParams) : inFlight.then(() => send(dispatchParams));
+          ordinaryOpen += 1;
+          const behind = gathering?.phase === "opening" ? gathering.behind ?? null : inFlight;
+          let pending;
+          if (behind === null)
+            pending = send(dispatchParams);
+          else if (gathers(dispatchParams))
+            pending = guarded(() => gatherBehind(dispatchParams, behind));
+          else {
+            closeGathering();
+            pending = behind.then(() => send(dispatchParams));
+          }
           activeDispatches.add(pending);
-          pending.then(() => activeDispatches.delete(pending), () => activeDispatches.delete(pending));
+          const settle = () => {
+            activeDispatches.delete(pending);
+            ordinaryOpen -= 1;
+          };
+          pending.then(settle, settle);
           return pending;
         }
         const pending = tail.then(() => send(dispatchParams));
         tail = pending.then(ignore, ignore);
+        closeGathering();
         return pending;
       };
       let discard = false;
       let released = false;
       let cancellationAttempted = false;
-      const cancellation = createPgReadCancellation({ connectionString: cancellationAddress, target: client, terminate: () => {
+      const cancellation = createPgReadCancellation({ connectionString: cancellationAddress, target: onClient, terminate: () => {
         if (!released) {
           released = true;
           client.release(true);
@@ -1161,20 +2285,77 @@ function pgAdapter(options) {
         markTransactionAborted({ scope, cause: readCancelledError2({ stage: "running" }) });
       } });
       let commitProgress = "not-sent";
+      let openingRollback;
+      const openWithSettings = async (statement) => {
+        let failed;
+        if (capable) {
+          const control = [beginStatement(openingOptions), ...openingOptions.timeout === undefined ? [] : [statementTimeoutStatement({ timeout: openingOptions.timeout })]];
+          const outcome = await turns.run(() => runBatch({
+            client,
+            steps: [...control.map((text) => ({ text })), { text: statement.text, values: prepareBatchValues({ values: statement.values }) }],
+            types: EXACT_TYPES
+          }));
+          const failure = firstBatchFailure({ outcome });
+          if (failure === undefined)
+            return;
+          if (failure.index < control.length || outcome.transportError !== undefined)
+            throw mapPgDriverError({ error: failure.error });
+          failed = { error: failure.error };
+        } else {
+          await runMapped(() => onClient.query({ text: openText }));
+          failed = await onClient.query({ text: statement.text, values: [...statement.values] }).then(() => {
+            return;
+          }, (error) => ({ error }));
+          if (failed === undefined)
+            return;
+        }
+        const cause = mapPgDriverError({ error: failed.error });
+        if (typeof cause.meta.sqlstate !== "string")
+          throw cause;
+        openingRollback = await onClient.query({ text: "ROLLBACK" }).then(() => "acknowledged", () => "failed");
+        if (openingRollback === "failed")
+          discard = true;
+        const setting = findRefusedSetting({ settings, cause });
+        throw transactionSettingRefusedError({ provider: PROVIDER, settings, setting, cause });
+      };
       try {
-        if (!deferOpening)
-          await runMapped(() => client.query({ text: openText }));
+        if (settingsStatement !== undefined && !settingsDeferred)
+          await openWithSettings(settingsStatement);
+        else if (!deferOpening)
+          await runMapped(() => onClient.query({ text: openText }));
         const result = await runRootScope({
           scope,
-          body: () => fn(createClientAdapter({ dispatch, scope, budget, deferred: capable ? deferred : null, cancellation }))
+          body: () => fn(createClientAdapter({
+            dispatch,
+            scope,
+            budget,
+            deferred: capable ? deferred : null,
+            cancellation,
+            pipelines: capable ? pipelines : null,
+            connection: client,
+            topLevel: true,
+            ordered: capable && budget.totalMs === null && !((client.connectionParameters?.query_timeout ?? 0) > 0),
+            commits
+          }))
         });
+        endPipeline();
+        const riding = ridden;
+        if (riding !== undefined) {
+          await riding.settled;
+          if (riding.state === "committed") {
+            budget.close({ outcome: "committed" });
+            return result;
+          }
+          throw riding.state === "skipped" ? transactionAbortedError2({ cause: scope.state.aborted?.cause }) : riding.error;
+        }
         budget.assertUsable({ stage: "commit" });
         if (!deferred.opened()) {
           budget.close({ outcome: "committed" });
           return result;
         }
         if (openingFailure !== undefined)
-          throw transactionAbortedError({ cause: openingFailure });
+          throw transactionAbortedError2({ cause: openingFailure });
+        deferred.dropReleases();
         const commit = await runMapped(() => dispatch({
           config: { text: "COMMIT" },
           stage: "commit",
@@ -1198,18 +2379,29 @@ function pgAdapter(options) {
         });
         if (finalResult({ result: commit }).command === "ROLLBACK") {
           commitProgress = "answered";
-          throw transactionAbortedError({ cause: scope.state.aborted?.cause });
+          throw transactionAbortedError2({ cause: scope.state.aborted?.cause });
         }
         budget.close({ outcome: "committed" });
         return result;
-      } catch (error) {
+      } catch (caught) {
+        endPipeline();
+        const riding = ridden;
+        if (riding !== undefined)
+          await riding.settled;
+        if (riding?.state === "committed") {
+          budget.close({ outcome: "committed" });
+          throw caught;
+        }
+        const error = riding?.state === "lost" ? riding.error : caught;
         if (isSavepointRollbackFailedError(error) || scope.state.poisoned !== null) {
           discard = true;
           budget.close({ outcome: "unknown" });
         }
         let rollback = "not-needed";
         try {
-          if (deferred.opened()) {
+          if (openingRollback !== undefined)
+            rollback = openingRollback;
+          else if (deferred.opened()) {
             await dispatch({ config: { text: "ROLLBACK" }, cleanup: true });
             rollback = "acknowledged";
           }
@@ -1233,9 +2425,56 @@ function pgAdapter(options) {
       }
     },
     async connect() {
-      const client = await runMapped(() => getPool().connect());
-      client.release();
+      const opened = await Promise.allSettled(Array.from({ length: Math.max(1, poolMin ?? 0) }, () => runMapped(() => getPool().connect())));
+      for (const outcome of opened) {
+        if (outcome.status === "fulfilled")
+          outcome.value.release();
+      }
+      const failed = opened.find((outcome) => outcome.status === "rejected");
+      if (failed !== undefined)
+        throw failed.reason;
+    }
+  };
+  const sendConnectionGroup = async (entries) => {
+    const rootPool = getPool();
+    const client = rootViaPoolQuery ? undefined : await runMapped(() => rootPool.connect());
+    if (client === undefined || !hasReadyForQuerySeam({ client }) || !supportsBatch({ client }) || (client.connectionParameters?.query_timeout ?? 0) > 0) {
+      client?.release();
+      const steps = [];
+      for (const entry of entries) {
+        if (steps.some((step) => step.status === "failed")) {
+          steps.push({ status: "skipped" });
+          continue;
+        }
+        steps.push(await root.execute(entry.call).then((rows) => ({ status: "ok", result: { rows, rowCount: rows.length } }), (error) => ({ status: "failed", error })));
+      }
+      return { steps };
     }
+    const seam = observeReadyForQuery({ client });
+    let reuse = false;
+    const outcome = await runBatch({ client, steps: entries.map((entry) => entry.step), types: EXACT_TYPES }).then((settled) => settled, (error) => ({ steps: [], transportError: error }));
+    const failure = firstBatchFailure({ outcome });
+    if (failure === undefined)
+      reuse = true;
+    else if (outcome.transportError === undefined)
+      reuse = await seam.reusableAfter({ error: mapPgDriverError({ error: failure.error }), named: false });
+    seam.detach();
+    client.release(!reuse);
+    return outcome;
+  };
+  const connectionGroupBase = {
+    dialect: DIALECT,
+    provider: PROVIDER,
+    wire: WIRE,
+    budgets: BUDGETS,
+    roundTrips: ROUND_TRIPS,
+    formatArrayParam: (values) => new PgArrayParam(values)
+  };
+  const connectionGroupDriver = {
+    base: connectionGroupBase,
+    prepare: (call) => ({ text: call.text, values: prepareBatchValues({ values: serializeParams({ values: call.values }) }) }),
+    send: (entries) => lifecycle.admit({ run: () => sendConnectionGroup(entries) }),
+    mapError: (error) => mapPgDriverError({ error })
   };
   return {
     dialect: DIALECT,
@@ -1244,7 +2483,19 @@ function pgAdapter(options) {
     budgets: BUDGETS,
     readCancellation,
     roundTrips: ROUND_TRIPS,
+    readSnapshot: READ_SNAPSHOT,
+    pipelining: PIPELINING,
     transactionOutcome: "reported",
+    transactionSettings: "transaction-local",
+    ...transactionsTakeOneRoundTrip({ address }) ? {
+      oneRoundTripTransactions: true,
+      connectionGroup: () => {
+        const closed = lifecycle.refusal();
+        if (closed !== undefined)
+          throw closed;
+        return rootViaPoolQuery ? undefined : openConnectionGroup({ driver: connectionGroupDriver });
+      }
+    } : {},
     withSession({ run }) {
       return lifecycle.admit({ run: () => root.withSession({ run: (executor) => lifecycle.inCallback({ run: () => run(executor) }) }) });
     },
@@ -1297,4 +2548,4 @@ export {
   validateTransactionDeadline2 as validateTransactionDeadline
 };
 
-//# debugId=3DBA8F0584DC025664756E2164756E21
+//# debugId=96B1BE63991D190764756E2164756E21