@coffre/db 0.14.5 → 0.15.0

package/dist/{database-BadNeeN-.js → database-D55ENPX-.js}

@@ -1,10 +1,11 @@
 import { n as trackCommits } from "./commits-BuW-NL3n.js";
+import { s as textTypes } from "./postgres-BI3xTnyw.js";
 import { t as schema_exports } from "./schema.js";
 import { engineOf } from "./dialect.js";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { Table, createTableRelationsHelpers, extractTablesRelationalConfig, getTableName, is } from "drizzle-orm";
-import { NodePgDatabase, NodePgDriver } from "drizzle-orm/node-postgres";
-import { PgDialect } from "drizzle-orm/pg-core";
+import { Table, getTableName, is } from "drizzle-orm";
+import { PgDatabase, PgDialect } from "drizzle-orm/pg-core";
+import { PostgresJsSession, PostgresJsTransaction } from "drizzle-orm/postgres-js/session";
 //#region src/prepared.ts
 /**
 * A select built once per process, or once per isolate on Workers, and run
@@ -59,21 +60,29 @@ var QueryOutsideTransaction = class extends Error {
 		this.name = "QueryOutsideTransaction";
 	}
 };
-/** The transaction a flow of work runs inside, with the pool it holds, while it is open. */
+/** The transaction a flow of work runs inside, with the client it holds, while it is open. */
 const inside = new AsyncLocalStorage();
+/** What Drizzle asks of the client: a statement, or a transaction, which postgres.js runs on a connection it holds. */
+const ASKS = /* @__PURE__ */ new Set([
+	"unsafe",
+	"begin",
+	"reserve"
+]);
 /**
-* `pool`, refusing a query or a transaction asked from inside a transaction
+* `client`, refusing a query or a transaction asked from inside a transaction
 * it is already running. Work from any other flow, a concurrent request's,
 * or what the transaction left running once its work was done, goes on as before.
 */
-function guarded(pool) {
-	return new Proxy(pool, { get(target, key) {
+function guarded(client) {
+	const refuse = (target) => {
+		const open = inside.getStore();
+		if (open?.open === true && open.client === target) throw new QueryOutsideTransaction();
+	};
+	return new Proxy(client, { get(target, key) {
 		const value = Reflect.get(target, key, target);
-		if (typeof value !== "function") return value;
-		if (key !== "query" && key !== "connect") return value.bind(target);
+		if (typeof value !== "function" || !ASKS.has(key)) return value;
 		return (...args) => {
-			const open = inside.getStore();
-			if (open?.open === true && open.pool === target) throw new QueryOutsideTransaction();
+			refuse(target);
 			return value.apply(target, args);
 		};
 	} });
@@ -82,26 +91,38 @@ function guarded(pool) {
 function brokenRule(error) {
 	for (let cause = error; cause instanceof Error; cause = cause.cause) if (cause instanceof QueryOutsideTransaction) return cause;
 }
-let relational;
-function relationalSchema() {
-	if (relational === void 0) {
-		const { tables, tableNamesMap } = extractTablesRelationalConfig(schema_exports, createTableRelationsHelpers);
-		relational = {
-			fullSchema: schema_exports,
-			schema: tables,
-			tableNamesMap
-		};
+const relational = {
+	fullSchema: schema_exports,
+	schema: {},
+	tableNamesMap: {}
+};
+/**
+* Drizzle's session for postgres.js, but for a transaction's options, which
+* go in its BEGIN, as node-postgres's session sends them, rather than in a
+* SET TRANSACTION of their own: a round trip less for a snapshot read.
+*/
+var Session = class extends PostgresJsSession {
+	transaction(work, config) {
+		const { dialect, schema: tables, options } = this;
+		return this.client.begin(config === void 0 ? "" : transactionOptions(config), (client) => work(new PostgresJsTransaction(dialect, new PostgresJsSession(client, dialect, tables, options), tables)));
 	}
-	return relational;
+};
+/** What follows BEGIN for `config`, as Drizzle writes it for SET TRANSACTION. */
+function transactionOptions(config) {
+	return [
+		config.isolationLevel === void 0 ? null : `isolation level ${config.isolationLevel}`,
+		config.accessMode ?? null,
+		config.deferrable === void 0 ? null : config.deferrable ? "deferrable" : "not deferrable"
+	].filter((option) => option !== null).join(" ");
 }
-function createDatabase(pool) {
+function createDatabase(client) {
+	if ("options" in client) textTypes(client);
 	const dialect = new PgDialect();
-	const config = relationalSchema();
-	const db = new NodePgDatabase(dialect, new NodePgDriver(guarded(pool), dialect).createSession(config), config);
+	const db = new PgDatabase(dialect, new Session(guarded(client), dialect, relational), relational);
 	const run = db.transaction.bind(db);
 	db.transaction = (async (work, config) => {
 		const open = {
-			pool,
+			client,
 			open: true
 		};
 		try {

package/dist/dialect.d.ts

@@ -1,4 +1,4 @@
-import { i as Queryable } from "./database-wq1AVRAP.js";
+import { a as Queryable } from "./database-CVteLhp1.js";
 import { SQL, SQLWrapper } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
 //#region src/dialect.d.ts
@@ -9,7 +9,7 @@ import { PgTable } from "drizzle-orm/pg-core";
  *                     Postgres                SQLite
  *   isolation         READ COMMITTED          one writer at a time
  *   lock a row        SELECT … FOR UPDATE     one writer at a time
- *   rows changed      rowCount                rowsAffected
+ *   rows changed      count                   rowsAffected
  *   duplicate key     SQLSTATE 23505          SQLITE_CONSTRAINT_UNIQUE
  *   clock             CURRENT_TIMESTAMP       strftime(…, 'now')
  *   clock, in ms      clock_timestamp()       unixepoch('subsec')
@@ -57,7 +57,8 @@ export declare function isUniqueViolation(error: unknown): boolean;
 /**
  * Whether a query failed because the database could not be reached or
  * dropped the connection: an outage, not an answer. Postgres's connection
- * exceptions are class 08; pg and Workers' sockets say so in words, and so
+ * exceptions are class 08; postgres.js says so in codes of its own, Workers'
+ * sockets in words, and so
  * does Hyperdrive when it has no connection to the database to give: every
  * one of its pool busy for 15 s ("Timed out while waiting for an open slot
  * in the pool", FATAL 58000; "Failed to acquire a connection from the

package/dist/dialect.js

@@ -27,7 +27,7 @@ function forUpdate(db, query, strength = "update") {
 * are the query's own, unmapped.
 */
 async function rowsOf(db, query) {
-	if (engineOf(db) === "postgres") return (await db.execute(query)).rows;
+	if (engineOf(db) === "postgres") return [...await db.execute(query)];
 	return db.all(query);
 }
 /** Insert the rows whose unique keys are free; returns how many that was. */
@@ -58,7 +58,7 @@ function truth(condition) {
 /** How many rows an insert, update or delete touched. */
 function changedRows(result) {
 	const header = result;
-	return header.rowCount ?? header.rowsAffected ?? 0;
+	return header.count ?? header.rowsAffected ?? 0;
 }
 const DUPLICATE_KEY = /* @__PURE__ */ new Set([
 	"23505",
@@ -74,7 +74,11 @@ function isUniqueViolation(error) {
 	}
 	return false;
 }
-/** The network's codes for a server that is not there, and Postgres's for one that will not take the connection, or has none left (53300). */
+/**
+* The network's codes for a server that is not there, postgres.js's for a
+* connection lost, cut short or never made, and Postgres's for one that will
+* not take the connection, or has none left (53300).
+*/
 const UNREACHABLE = /* @__PURE__ */ new Set([
 	"ECONNREFUSED",
 	"ECONNRESET",
@@ -84,17 +88,22 @@ const UNREACHABLE = /* @__PURE__ */ new Set([
 	"EHOSTUNREACH",
 	"ENETUNREACH",
 	"EPIPE",
+	"CONNECTION_CLOSED",
+	"CONNECTION_DESTROYED",
+	"CONNECTION_ENDED",
+	"CONNECT_TIMEOUT",
 	"53300",
 	"57P01",
 	"57P02",
 	"57P03"
 ]);
-/** Hyperdrive's words for having no connection to give, beside pg's and Workers' for one lost. */
+/** Hyperdrive's words for having no connection to give, beside Workers' for one lost. */
 const UNREACHABLE_WORDS = /connection terminated|network connection lost|connect(ion)? timeout|open slot in the pool|acquire a connection from the pool|server connection attempt failed/i;
 /**
 * Whether a query failed because the database could not be reached or
 * dropped the connection: an outage, not an answer. Postgres's connection
-* exceptions are class 08; pg and Workers' sockets say so in words, and so
+* exceptions are class 08; postgres.js says so in codes of its own, Workers'
+* sockets in words, and so
 * does Hyperdrive when it has no connection to the database to give: every
 * one of its pool busy for 15 s ("Timed out while waiting for an open slot
 * in the pool", FATAL 58000; "Failed to acquire a connection from the

package/dist/grants.d.ts

@@ -1,5 +1,5 @@
-import { i as Queryable } from "./database-wq1AVRAP.js";
-import { Authenticity, Newest } from "./log.js";
+import { a as Queryable } from "./database-CVteLhp1.js";
+import { f as Newest, n as Authenticity } from "./log-DaD7fyUq.js";
 import { StoredEntry } from "@coffre/core/audit";
 import { Conversion, ConversionInput, InstanceRole, Scope } from "@coffre/core/access";
 //#region src/grants.d.ts
@@ -136,8 +136,8 @@ export declare function tamperedMembers(db: Queryable, principal?: string): Prom
  * taken to.
  */
 export declare function reportStands(db: Queryable, principal: string, check: Authenticity): Promise<boolean>;
-/** The newest access entry about `principal` that `check` finds the vault's own. */
-export declare function newestAccess(db: Queryable, principal: string, check: Authenticity): Promise<Newest>;
+/** The newest access entry about `principal` that `check` finds the vault's own; at or below `through`, if given. */
+export declare function newestAccess(db: Queryable, principal: string, check: Authenticity, through?: bigint): Promise<Newest>;
 /** Up to `limit` of the vault's allowed access entries about `principal` before `before` (the newest when undefined), newest first. */
 export declare function accessEntriesAbout(db: Queryable, principal: string, limit: number, before?: bigint): Promise<StoredEntry[]>;
 //#endregion

package/dist/grants.js

@@ -1,5 +1,5 @@
 import { tombstone, truth } from "./dialect.js";
-import { a as prepared, i as tablesOf } from "./database-BadNeeN-.js";
+import { a as prepared, i as tablesOf } from "./database-D55ENPX-.js";
 import { entryColumns, newestAuthentic } from "./log.js";
 import { and, asc, desc, eq, gt, inArray, isNull, like, lt, or, sql } from "drizzle-orm";
 import { EVERYWHERE, administers, convertEveryProjectGrants, isInstanceRole, isScope, normalScope, unscoped } from "@coffre/core/access";
@@ -238,9 +238,9 @@ async function reportStands(db, principal, check) {
 	const report = await newestAuthentic((limit, before) => tamperReportsAbout(db, principal, limit, after, before), check);
 	return report === "unreached" || typeof report !== "string";
 }
-/** The newest access entry about `principal` that `check` finds the vault's own. */
-function newestAccess(db, principal, check) {
-	return newestAuthentic((limit, before) => accessEntriesAbout(db, principal, limit, before), check);
+/** The newest access entry about `principal` that `check` finds the vault's own; at or below `through`, if given. */
+function newestAccess(db, principal, check, through) {
+	return newestAuthentic((limit, before) => accessEntriesAbout(db, principal, limit, before ?? (through === void 0 ? void 0 : through + 1n)), check);
 }
 /** Up to `limit` of the vault's allowed access entries about `principal` before `before` (the newest when undefined), newest first. */
 async function accessEntriesAbout(db, principal, limit, before) {

package/dist/hyperdrive.d.ts

@@ -1,5 +1,4 @@
-import { n as PoolLike } from "./database-wq1AVRAP.js";
-import pg from "pg";
+import { f as PostgresClient, t as Client } from "./database-CVteLhp1.js";
 //#region src/hyperdrive.d.ts
 /** Postgres through a Hyperdrive binding: `postgres(env.HYPERDRIVE)`. */
 export type PostgresDatabase = {
@@ -13,8 +12,8 @@ export declare function postgres(hyperdrive: {
   readonly connectionString: string;
 }): PostgresDatabase;
 /**
- * node-postgres for one call on Workers, through Hyperdrive: one client,
- * connected on the first query, which every query and transaction of the
+ * postgres.js for one call on Workers, through Hyperdrive: one connection,
+ * opened by the first query, which every query and transaction of the
  * call takes its turn on.
  *
  * Hyperdrive keeps the pool to the database; a Worker's connections belong
@@ -23,33 +22,59 @@ export declare function postgres(hyperdrive: {
  * once was now and then cancelled as hung, with nothing left pending, and
  * every connection costs a round trip before the query can be sent.
  *
- * The turns keep a transaction whole: queries go to the client in the order
- * they are asked, a transaction holds it from BEGIN until it is released,
- * and a query asked meanwhile waits until then, so nothing runs inside a
- * transaction it is not part of. So code inside a transaction must query
- * through the transaction: a query on the database there would wait for the
- * transaction to end, which waits for it. Neither the vault nor the server
- * does.
+ * The turns keep a transaction whole: statements go to the connection in
+ * the order they are asked, each once the one before it has answered; a
+ * transaction holds the connection from BEGIN until it ends, and a query
+ * asked meanwhile waits until then, so nothing runs inside a transaction it
+ * is not part of. So code inside a transaction must query through the
+ * transaction: a query on the database there would wait for the transaction
+ * to end, which waits for it. Neither the vault nor the server does.
  *
- * The class name must end in `Pool`: that is how Drizzle knows to check out
- * a client for each transaction.
+ * With `groupReads`, the plain reads (`select …`, outside a transaction)
+ * asked while the pool waits for their turn, or in the same task, take it
+ * together, sent under one Sync (`group` in postgres-js/index.ts): on
+ * Hyperdrive, which sends a client's Syncs on one at a time, a round trip
+ * for them all, where each alone took one. They run as one implicit
+ * transaction, so if one fails they all do, with its error; each is a
+ * read, so none had anything to keep. Anything else asked meanwhile, a
+ * write or a transaction, closes the group, and goes after it: statements
+ * still go in the order they are asked.
+ *
+ * Closed by `end`, once what was asked has answered; asked again after, as
+ * a call's background work may, it opens a connection again. Unless `end`
+ * was given a time to close by and reached it: then the connection closes
+ * at once, failing what is still asked, and nothing opens it again. And
+ * `destroy` cuts it the same way, at any time.
  */
-export declare class HyperdrivePool implements Exclude<PoolLike, pg.Pool> {
+export declare class HyperdrivePool implements Client {
   #private;
   /**
    * `closeIdleMs`: for what outlives a call, a Durable Object, which queries
-   * now and then: the client closes once it has been idle that long, and
-   * the next query connects again.
+   * now and then: the connection closes once it has been idle that long,
+   * and the next query connects again. `groupReads`: plain reads asked
+   * together go together, under one Sync.
    */
   constructor(connectionString: string, options?: {
     closeIdleMs?: number;
+    groupReads?: boolean;
   });
-  readonly query: pg.Pool['query'];
-  /** The client, for a transaction: held from now until `release`. */
-  connect(): Promise<Pick<pg.PoolClient, 'query'> & {
-    release: () => void;
-  }>;
-  /** Close the client once nothing waits on it: what a Worker hands `waitUntil` when the call is done. */
-  end(): Promise<void>;
+  readonly unsafe: PostgresClient["unsafe"];
+  /** A transaction: its turn lasts until it has committed or rolled back. */
+  readonly begin: PostgresClient["begin"];
+  /**
+   * Close the connection once every turn asked is done: what a Worker hands `waitUntil` when the call is done. By
+   * `by` (ms since the epoch) at the latest, if given: then at once, what is still asked failing, the statement under
+   * way included, and none of it sent again. A use's call past its deadline, whose answer has gone, so lets go of
+   * Hyperdrive: what it asked and Hyperdrive had not sent goes with the connection (use.ts, `HELD_PAST_DEADLINE_MS`).
+   */
+  end(by?: number): Promise<void>;
+  /**
+   * The connection cut now, what it was asked failing at once, and every
+   * turn after refused: for what a host stopped waiting on, a connection
+   * gone dead or a connect that never answers (T169), so that whatever
+   * still awaits it fails rather than waits for good. Its statement may
+   * still run in the database.
+   */
+  destroy(): void;
 }
 //#endregion

package/dist/hyperdrive.js

@@ -1,17 +1,22 @@
-import { t as postgresConnection } from "./postgres-Bmar8y0q.js";
-import pg from "pg";
+import { c as plainRead, n as postgresClient, s as textTypes } from "./postgres-BI3xTnyw.js";
 //#region src/hyperdrive.ts
 /** Postgres through Hyperdrive, the one database a Worker runs on, the app's and the vault's. */
 function postgres(hyperdrive) {
-	if (typeof hyperdrive?.connectionString !== "string") throw new Error("postgres() takes the Hyperdrive binding, e.g. postgres(env.HYPERDRIVE)");
+	if (typeof hyperdrive?.connectionString !== "string") throw new Error("postgres() was given no Hyperdrive binding: one the code names (HYPERDRIVE, VAULT_HYPERDRIVE, HOT_HYPERDRIVE) is missing from its wrangler.jsonc, or bound under another name");
 	return {
 		engine: "postgres",
 		hyperdrive
 	};
 }
+/** What the client refuses to write of a group, before anything of it is sent (`build`, postgres-js/connection.ts). */
+const UNSENT = /* @__PURE__ */ new Set([
+	"GROUP_UNTYPED",
+	"MAX_PARAMETERS_EXCEEDED",
+	"UNDEFINED_VALUE"
+]);
 /**
-* node-postgres for one call on Workers, through Hyperdrive: one client,
-* connected on the first query, which every query and transaction of the
+* postgres.js for one call on Workers, through Hyperdrive: one connection,
+* opened by the first query, which every query and transaction of the
 * call takes its turn on.
 *
 * Hyperdrive keeps the pool to the database; a Worker's connections belong
@@ -20,119 +25,191 @@ function postgres(hyperdrive) {
 * once was now and then cancelled as hung, with nothing left pending, and
 * every connection costs a round trip before the query can be sent.
 *
-* The turns keep a transaction whole: queries go to the client in the order
-* they are asked, a transaction holds it from BEGIN until it is released,
-* and a query asked meanwhile waits until then, so nothing runs inside a
-* transaction it is not part of. So code inside a transaction must query
-* through the transaction: a query on the database there would wait for the
-* transaction to end, which waits for it. Neither the vault nor the server
-* does.
+* The turns keep a transaction whole: statements go to the connection in
+* the order they are asked, each once the one before it has answered; a
+* transaction holds the connection from BEGIN until it ends, and a query
+* asked meanwhile waits until then, so nothing runs inside a transaction it
+* is not part of. So code inside a transaction must query through the
+* transaction: a query on the database there would wait for the transaction
+* to end, which waits for it. Neither the vault nor the server does.
 *
-* The class name must end in `Pool`: that is how Drizzle knows to check out
-* a client for each transaction.
+* With `groupReads`, the plain reads (`select …`, outside a transaction)
+* asked while the pool waits for their turn, or in the same task, take it
+* together, sent under one Sync (`group` in postgres-js/index.ts): on
+* Hyperdrive, which sends a client's Syncs on one at a time, a round trip
+* for them all, where each alone took one. They run as one implicit
+* transaction, so if one fails they all do, with its error; each is a
+* read, so none had anything to keep. Anything else asked meanwhile, a
+* write or a transaction, closes the group, and goes after it: statements
+* still go in the order they are asked.
+*
+* Closed by `end`, once what was asked has answered; asked again after, as
+* a call's background work may, it opens a connection again. Unless `end`
+* was given a time to close by and reached it: then the connection closes
+* at once, failing what is still asked, and nothing opens it again. And
+* `destroy` cuts it the same way, at any time.
 */
 var HyperdrivePool = class {
 	#connectionString;
-	/** The client, connecting or connected; null before the first query, and once it has failed. */
+	/** How long the connection may sit idle before it closes, or undefined: closed by `end` alone. */
+	#closeIdleMs;
+	/** The client, made by the first statement; null before it, and once `end` closed it. */
 	#client = null;
-	/** Whether a transaction holds the client. */
-	#held = false;
-	/** What waits for its turn, in the order it asked. */
-	#waiting = [];
-	/** Queries and transactions asked and not done: waiting for the client, their turn, or an answer. */
+	/** The end of the last turn asked: the next one starts once it has. */
+	#tail = Promise.resolve();
+	/** Turns asked and not done: waiting, or under way. */
 	#busy = 0;
-	/** What waits for the client to be idle: `end`. */
+	/** What waits for every turn to be done: `end`. */
 	#idle = [];
-	/** How long the client may sit idle before it closes, or null: closed by `end` alone. */
-	#closeIdleMs;
-	#idleTimer;
+	/** Whether plain reads asked together go together (`groupReads`). */
+	#groupReads;
+	/** The reads that will take the next group's turn, while it has not started: what a read asked now joins. */
+	#gathering = null;
+	/** Closed at the time `end` was given, with turns still asked: none opens a connection again. */
+	#cut = false;
+	/** Set by `destroy`: every turn after it fails. */
+	#destroyed = false;
 	/**
 	* `closeIdleMs`: for what outlives a call, a Durable Object, which queries
-	* now and then: the client closes once it has been idle that long, and
-	* the next query connects again.
+	* now and then: the connection closes once it has been idle that long,
+	* and the next query connects again. `groupReads`: plain reads asked
+	* together go together, under one Sync.
 	*/
 	constructor(connectionString, options = {}) {
 		if (connectionString.trim().length === 0) throw new Error("Hyperdrive returned an empty connection string");
 		this.#connectionString = connectionString;
-		this.#closeIdleMs = options.closeIdleMs ?? null;
+		this.#closeIdleMs = options.closeIdleMs;
+		this.#groupReads = options.groupReads === true;
 	}
-	query = (async (...args) => {
-		this.#busy += 1;
-		clearTimeout(this.#idleTimer);
-		try {
-			const client = await this.#connected();
-			return await new Promise((resolve, reject) => {
-				this.#turn(() => client.query(...args).then(resolve, reject));
-			});
-		} finally {
-			this.#done();
-		}
+	unsafe = ((...args) => {
+		let values = false;
+		let answer;
+		const [text, parameters = [], options] = args;
+		/** Its turn, asked once: the first `then`, `catch`, `finally` or `execute` asks it. */
+		const asked = () => answer ??= this.#groupReads && options === void 0 && plainRead(text) ? this.#gather({
+			text,
+			values: parameters,
+			arrays: () => values
+		}) : this.#turn(() => {
+			const query = this.#connected().unsafe(...args);
+			return values ? query.values() : query;
+		});
+		const statement = {
+			values: () => {
+				values = true;
+				return statement;
+			},
+			execute: () => {
+				asked().catch(() => {});
+				return statement;
+			},
+			then: (resolve, reject) => asked().then(resolve, reject),
+			catch: (reject) => asked().catch(reject),
+			finally: (done) => asked().finally(done),
+			[Symbol.toStringTag]: "Statement"
+		};
+		return statement;
 	});
-	/** The client, for a transaction: held from now until `release`. */
-	async connect() {
-		this.#busy += 1;
-		clearTimeout(this.#idleTimer);
-		let client;
-		try {
-			client = await this.#connected();
-		} catch (error) {
-			this.#done();
-			throw error;
+	/** A transaction: its turn lasts until it has committed or rolled back. */
+	begin = ((...args) => this.#turn(() => this.#connected().begin(...args)));
+	/**
+	* A read, in the group gathering for the next turn, or in a new one: it
+	* starts a task later, so that the reads asked with it join, and once
+	* the turns before it are done, which those asked while they ran join.
+	*/
+	#gather(read) {
+		let members = this.#gathering;
+		if (members === null) {
+			const gathered = members = [];
+			const asked = new Promise((resolve) => setTimeout(resolve, 0));
+			this.#turn(async () => {
+				await asked;
+				if (this.#gathering === gathered) this.#gathering = null;
+				try {
+					const client = this.#connected();
+					const alone = async (member) => {
+						const query = client.unsafe(member.text, member.values);
+						member.resolve(await (member.arrays() ? query.values() : query));
+					};
+					if (gathered.length === 1) return await alone(gathered[0]);
+					try {
+						const answers = await client.group(gathered.map((member) => ({
+							query: member.text,
+							parameters: member.values,
+							arrays: member.arrays()
+						})));
+						gathered.forEach((member, i) => member.resolve(answers[i]));
+					} catch (error) {
+						if (!UNSENT.has(error.code)) throw error;
+						for (const member of gathered) await alone(member).catch(member.reject);
+					}
+				} catch (error) {
+					for (const member of gathered) member.reject(error);
+				}
+			});
+			this.#gathering = gathered;
 		}
-		await new Promise((resolve) => this.#turn(() => {
-			this.#held = true;
-			resolve();
+		return new Promise((resolve, reject) => members.push({
+			...read,
+			resolve,
+			reject
 		}));
-		let released = false;
-		return {
-			query: client.query.bind(client),
-			release: () => {
-				if (released) return;
-				released = true;
-				this.#held = false;
-				this.#next();
-				this.#done();
-			}
-		};
 	}
-	/** Close the client once nothing waits on it: what a Worker hands `waitUntil` when the call is done. */
-	async end() {
-		clearTimeout(this.#idleTimer);
-		while (this.#busy > 0) await new Promise((resolve) => this.#idle.push(resolve));
+	/**
+	* Close the connection once every turn asked is done: what a Worker hands `waitUntil` when the call is done. By
+	* `by` (ms since the epoch) at the latest, if given: then at once, what is still asked failing, the statement under
+	* way included, and none of it sent again. A use's call past its deadline, whose answer has gone, so lets go of
+	* Hyperdrive: what it asked and Hyperdrive had not sent goes with the connection (use.ts, `HELD_PAST_DEADLINE_MS`).
+	*/
+	async end(by) {
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		let timer;
+		const reached = by === void 0 ? null : new Promise((resolve) => timer = setTimeout(() => resolve("cut"), Math.max(0, by - Date.now())));
+		while (this.#busy > 0 && !this.#cut) {
+			const idle = new Promise((resolve) => this.#idle.push(resolve));
+			if (await (reached === null ? idle : Promise.race([idle, reached])) === "cut") this.#cut = true;
+		}
+		clearTimeout(timer);
 		const client = this.#client;
 		this.#client = null;
-		if (client === null) return;
-		await client.then((connected) => connected.end()).catch(() => {});
+		await client?.end(this.#cut ? { timeout: 0 } : void 0).catch(() => {});
 	}
-	/** Run `go` now if nothing holds the client or waits before it, otherwise at its turn. */
-	#turn(go) {
-		if (!this.#held && this.#waiting.length === 0) go();
-		else this.#waiting.push(go);
+	/**
+	* The connection cut now, what it was asked failing at once, and every
+	* turn after refused: for what a host stopped waiting on, a connection
+	* gone dead or a connect that never answers (T169), so that whatever
+	* still awaits it fails rather than waits for good. Its statement may
+	* still run in the database.
+	*/
+	destroy() {
+		this.#destroyed = true;
+		const client = this.#client;
+		this.#client = null;
+		client?.end({ timeout: 0 }).catch(() => {});
 	}
-	/** Give the next turns: queries until one is a transaction, which holds the client. */
-	#next() {
-		while (!this.#held && this.#waiting.length > 0) this.#waiting.shift()();
+	/** `go` once every turn asked before it is done. Anything but a group's closes the group gathering: it goes after. */
+	#turn(go) {
+		this.#gathering = null;
+		this.#busy += 1;
+		const answer = this.#tail.then(go);
+		this.#tail = answer.then(() => this.#done(), () => this.#done());
+		return answer;
 	}
-	/** One query or transaction done: once none is left, what waits for the client to be idle goes on. */
+	/** One turn done: once none is left, what waits for the pool to be idle goes on. */
 	#done() {
 		this.#busy -= 1;
-		if (this.#busy > 0) return;
-		for (const resolve of this.#idle.splice(0)) resolve();
-		if (this.#closeIdleMs !== null && this.#client !== null) this.#idleTimer = setTimeout(() => void this.end(), this.#closeIdleMs);
+		if (this.#busy === 0) for (const resolve of this.#idle.splice(0)) resolve();
 	}
-	/** The call's client, connecting it the first time. One that fails is dropped: the next query connects again. */
+	/** The call's client, made the first time. postgres.js opens its connection again when one is lost. */
 	#connected() {
-		if (this.#client !== null) return this.#client;
-		const client = new pg.Client(postgresConnection(this.#connectionString));
-		const connecting = client.connect().then(() => client);
-		const drop = () => {
-			if (this.#client === connecting) this.#client = null;
-		};
-		client.on("error", drop);
-		client.on("end", drop);
-		connecting.catch(drop);
-		this.#client = connecting;
-		return connecting;
+		if (this.#destroyed) throw new Error("this connection was cut: its call stopped waiting on it");
+		if (this.#cut) throw new Error("the call's connection was closed at the time it was given (`end`): nothing more is sent");
+		this.#client ??= textTypes(postgresClient(this.#connectionString, {
+			max: 1,
+			idle_timeout: this.#closeIdleMs === void 0 ? void 0 : this.#closeIdleMs / 1e3,
+			max_lifetime: null
+		}));
+		return this.#client;
 	}
 };
 //#endregion