@vibeorm/adapter-pg 4.3.0 → 5.0.0

package/dist/index.js

@@ -27,10 +27,11 @@ import {
   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
@@ -39,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;
@@ -97,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++) {
@@ -186,12 +197,162 @@ 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) => {
@@ -199,16 +360,17 @@ function createClientTurns() {
         resolve(send());
       }) : previous.then(send);
       outstanding += 1;
-      previous = running.then(release, release);
+      previous = running.then(release, fail);
       return running;
     },
-    outstanding: () => outstanding
+    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
@@ -217,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",
@@ -264,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 });
@@ -287,7 +449,7 @@ function mapPgDriverError(params) {
   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 VibeError({ code, message, meta, cause: error });
+  return new VibeError3({ code, message, meta, cause: error });
 }
 async function runMapped(fn) {
   try {
@@ -310,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));
@@ -364,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 = () => {
@@ -381,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();
@@ -393,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;
@@ -424,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;
         });
@@ -511,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);
@@ -520,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 }
@@ -550,19 +712,31 @@ function assertIdleTimeout(params) {
   const { value } = params;
   if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 2147483647)
     return value;
-  throw new VibeError3({
+  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, idleTimeout } = 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)
@@ -719,7 +893,7 @@ function parsePlainTimestampText(params) {
 }
 
 // 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",
@@ -742,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 }
@@ -778,19 +952,42 @@ 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 VibeError5({
+  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 VibeError5({ code: "VIBE_INTERNAL", message: `pipeline(): ${params.message}`, meta: { reason: "pipeline-ordered-lane" } });
+  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;
@@ -798,13 +995,13 @@ function finalResult(params) {
 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" },
@@ -833,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)))
@@ -870,7 +1067,7 @@ 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";
@@ -900,7 +1097,7 @@ function parseZoneLessAsUtc(value) {
     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) => {
@@ -960,24 +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 }
@@ -999,6 +1224,7 @@ 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 },
@@ -1048,14 +1274,22 @@ function pgAdapter(options) {
     return { rows: final.rows, affectedRows: final.rowCount ?? 0 };
   }
   function createClientAdapter(params) {
-    const { dispatch, scope, budget, deferred, cancellation, pipelines, lane } = params;
+    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 })
+      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 },
@@ -1074,22 +1308,46 @@ function pgAdapter(options) {
       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 VibeError5({ code: "VIBE_VALIDATION", message: "pipeline() needs a positive whole number of lanes", meta: { lanes: count } });
+            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 VibeError5({
+            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 or a timeout, outside a pipeline lane)",
+              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 }),
+            adapter: createClientAdapter({ dispatch, scope, budget, deferred, cancellation, pipelines, lane: opened, connection, ...params.commits === true && opened.seat === undefined ? { commits: true } : {} }),
             close: () => {
               pipelines.close(opened);
             },
@@ -1098,6 +1356,19 @@ function pgAdapter(options) {
                 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);
@@ -1114,7 +1385,7 @@ function pgAdapter(options) {
             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, ...laneOf }) };
+          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 }));
         } });
       },
@@ -1128,6 +1399,10 @@ function pgAdapter(options) {
       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({
@@ -1137,7 +1412,7 @@ function pgAdapter(options) {
           body: (child) => {
             leave();
             const ordered = lane === undefined && params.ordered === true ? { ordered: true } : {};
-            return fn(createClientAdapter({ dispatch, scope: child, budget, deferred, cancellation, pipelines, ...laneOf, ...ordered }));
+            return fn(createClientAdapter({ dispatch, scope: child, budget, deferred, cancellation, pipelines, connection, ...laneOf, ...ordered }));
           }
         }).finally(leave);
       },
@@ -1287,8 +1562,14 @@ function pgAdapter(options) {
       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) => turns.run(() => client.query(config)),
+        query: (config) => runTurn(() => client.query(config)),
         get pipeline() {
           return client.pipeline;
         },
@@ -1307,11 +1588,55 @@ function pgAdapter(options) {
       const scope = createSavepointScope();
       const budget = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
       const capable = supportsBatch({ client });
-      const deferOpening = settingsStatement === undefined && 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 = () => {
@@ -1320,9 +1645,11 @@ function pgAdapter(options) {
           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)
@@ -1342,24 +1669,39 @@ function pgAdapter(options) {
           });
         }
         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 = turns.run(() => 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);
+            }
+            if (gatheringsPending > 0) {
+              const mapped = openingFailed && openingFailure !== undefined ? openingFailure : mapPgDriverError({ error: failure.error });
+              if (typeof mapped.meta.sqlstate === "string")
+                markTransactionAborted({ scope, cause: mapped });
             }
-            throw failure.error;
+            throw openingFailed && settingsDeferred && failure.index === opening.length && openingFailure !== undefined ? openingFailure : failure.error;
           }
           if (statement.length === 0)
             return handOver();
@@ -1410,14 +1752,14 @@ function pgAdapter(options) {
           });
           return;
         }
-        const mapped = mapPgDriverError({ error: failure.error });
+        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 ? transactionAbortedError({ cause: openingFailure ?? mapped }) : mapped;
+          const later = answered || openingFailure !== undefined ? transactionAbortedError2({ cause: openingFailure ?? mapped }) : mapped;
           live.forEach((entry, index) => {
             settleQueued(entry, { error: index === 0 ? mapped : later });
           });
@@ -1428,7 +1770,7 @@ function pgAdapter(options) {
           const position = controlSteps + index;
           const step = outcome.steps[position];
           if (step === undefined) {
-            settleQueued(entry, { error: position === failure.index || openingFailure === undefined ? mapped : transactionAbortedError({ cause: openingFailure }) });
+            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") {
@@ -1437,12 +1779,36 @@ function pgAdapter(options) {
               abortCause = error;
             settleQueued(entry, { error });
           } else {
-            settleQueued(entry, { error: transactionAbortedError({ cause: abortCause }) });
+            settleQueued(entry, { error: transactionAbortedError2({ cause: abortCause }) });
           }
         });
       };
-      const sendRefusal = () => cancellationAttempted ? transactionAbortedError({ cause: readCancelledError2({ stage: "running" }) }) : openingFailure !== undefined ? transactionAbortedError({ cause: openingFailure }) : scope.state.poisoned ?? (scope.state.aborted === null ? undefined : transactionAbortedError({ cause: scope.state.aborted.cause }));
-      const sendQueued = (entries) => {
+      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) {
@@ -1455,11 +1821,19 @@ function pgAdapter(options) {
         }
         if (live.length === 0)
           return Promise.resolve();
-        const carriesOpening = !deferred.opened();
-        const control = deferred.take();
-        const openingSteps = carriesOpening ? opening.length : 0;
-        const burst = turns.run(() => runBatch({ client, steps: [...control.map((text) => ({ text })), ...live.map((entry) => ({ text: entry.text, values: entry.values }))], types: EXACT_TYPES })).then((outcome) => {
-          distributeBurst({ outcome, live, controlSteps: control.length, openingSteps });
+        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 });
@@ -1475,6 +1849,81 @@ function pgAdapter(options) {
         }
         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) {
@@ -1524,7 +1973,7 @@ function pgAdapter(options) {
           if (failed === undefined)
             live.push(entry);
           else
-            settleQueued(entry, { error: sendRefusal() ?? transactionAbortedError({ cause: failed.cause }) });
+            settleQueued(entry, { error: sendRefusal() ?? transactionAbortedError2({ cause: failed.cause }) });
         }
         if (live.length === 0)
           return Promise.resolve();
@@ -1577,11 +2026,12 @@ function pgAdapter(options) {
       const flushQueue = () => {
         if (queued.length === 0)
           return;
+        closeGathering();
         if (queued.some((entry) => entry.lane.order !== undefined)) {
           flushOrdered();
           return;
         }
-        const entries = queued;
+        const entries = queued.some((entry) => entry.lane.seat !== undefined) ? seatOrder(queued) : queued;
         queued = [];
         if (inFlight === null)
           sendQueued(entries);
@@ -1598,6 +2048,26 @@ function pgAdapter(options) {
             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 };
@@ -1629,15 +2099,7 @@ function pgAdapter(options) {
           lanes.add(next);
           return next;
         },
-        close: (lane) => {
-          if (!lane.open)
-            return;
-          lane.open = false;
-          lanes.delete(lane);
-          if (lane.order !== undefined)
-            refuseOrphaned();
-          flushIfReady();
-        },
+        close: closeLane,
         waitAs: ({ lane, wait }) => {
           if (!lane.open)
             return wait;
@@ -1664,7 +2126,43 @@ function pgAdapter(options) {
             lane.waiting -= 1;
           };
         },
-        flush: flushQueue
+        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)
@@ -1674,9 +2172,11 @@ function pgAdapter(options) {
       };
       const enqueue = (dispatchParams, lane, alone) => {
         if (cancellationAttempted)
-          throw transactionAbortedError({ cause: readCancelledError2({ stage: "running" }) });
+          throw transactionAbortedError2({ cause: readCancelledError2({ stage: "running" }) });
         if (openingFailure !== undefined)
-          throw transactionAbortedError({ cause: openingFailure });
+          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) => {
@@ -1686,6 +2186,7 @@ function pgAdapter(options) {
             values,
             ...dispatchParams.execution === undefined ? {} : { execution: dispatchParams.execution },
             ...alone === true ? { alone: dispatchParams } : {},
+            ...dispatchParams.commit === true ? { commit: true } : {},
             lane,
             resolve,
             reject,
@@ -1699,9 +2200,23 @@ function pgAdapter(options) {
         flushIfReady();
         return pending;
       };
-      const coalescable = (dispatchParams) => capable && budget.totalMs === null && !cancellationQueue && dispatchParams.batchable === true && dispatchParams.cleanup !== true && dispatchParams.stage === undefined && dispatchParams.sent === undefined && dispatchParams.execution?.cancellation !== "running";
+      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(() => {
@@ -1728,16 +2243,32 @@ function pgAdapter(options) {
         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;
@@ -1788,7 +2319,7 @@ function pgAdapter(options) {
         throw transactionSettingRefusedError({ provider: PROVIDER, settings, setting, cause });
       };
       try {
-        if (settingsStatement !== undefined)
+        if (settingsStatement !== undefined && !settingsDeferred)
           await openWithSettings(settingsStatement);
         else if (!deferOpening)
           await runMapped(() => onClient.query({ text: openText }));
@@ -1801,17 +2332,30 @@ function pgAdapter(options) {
             deferred: capable ? deferred : null,
             cancellation,
             pipelines: capable ? pipelines : null,
-            ordered: capable && budget.totalMs === null && openingOptions.timeout === undefined && !((client.connectionParameters?.query_timeout ?? 0) > 0)
+            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",
@@ -1835,12 +2379,20 @@ 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" });
@@ -1873,10 +2425,57 @@ 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,
     provider: PROVIDER,
@@ -1888,6 +2487,15 @@ function pgAdapter(options) {
     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) }) }) });
     },
@@ -1940,4 +2548,4 @@ export {
   validateTransactionDeadline2 as validateTransactionDeadline
 };
 
-//# debugId=FB5284F22EED8D0A64756E2164756E21
+//# debugId=96B1BE63991D190764756E2164756E21