@prisma/orm-target-mysql 8.0.0-rc.22-dev.10 → 8.0.0-rc.22-dev.12

package/dist/driver__runtime.mjs

@@ -1,4 +1,4 @@
-import { a as connectingCannotSucceed, c as isFatal, d as mysqlPoolOptions, f as normalizeMysqlError, l as mysqlConnectionOptions, m as statementFor, n as SessionSettingsGuard, r as acquireClientQueryLock, t as DEFAULT_CONNECT_TIMEOUT_MILLIS, u as mysqlDriverDescriptorMeta } from "./statement-kfMRMKIt-D6cAOKys.mjs";
+import { c as mysqlConnectionOptions, d as mysqlPoolOptions, f as normalizeMysqlError, i as connectingCannotSucceed, l as mysqlDriverDescriptorMeta, m as statementFor, n as acquireClientQueryLock, s as isFatal, t as SessionSettingsGuard, u as mysqlPoolIdleTimeoutMillis } from "./statement-DC62oiSx-Buzptbpk.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { errorRuntime } from "@prisma/orm-framework/errors/execution";
@@ -6,6 +6,100 @@ import { createConnection, createPool } from "mariadb";
 import { EventEmitter } from "node:events";
 import { finished } from "node:stream/promises";
 //#region ../../../3-targets/mysql/3-driver/dist/runtime.mjs
+/** How long the canceller waits to open its connection, and for MySQL to answer a `KILL QUERY`. */
+const CANCEL_TIMEOUT_MILLIS = 2e3;
+function timeout(millis) {
+	let timer;
+	return {
+		expired: new Promise((resolve) => {
+			timer = setTimeout(() => resolve("expired"), millis);
+		}),
+		clear: () => clearTimeout(timer)
+	};
+}
+/**
+* Cancels statements with `KILL QUERY`, which MySQL takes only from another connection. It keeps one connection of its own, outside the pool, so a cancel neither waits for a pooled connection nor normally opens one; it opens it on first need, and ends it once it has been idle for the pool's idle timeout, as the pool ends its own; with a timeout of 0 it keeps it open, as the pool keeps its own. Opening it and each `KILL QUERY` are bounded by two seconds. The connection is never destroyed: the package's `destroy()` sends a `KILL` of its own whose failure it does not handle (`mariadb` 3.5.4). A connection that stops answering is set aside and ended with `end()` once its statement settles.
+*/
+var Canceller = class {
+	#url;
+	#idleTimeoutMillis;
+	#connection;
+	#pending = /* @__PURE__ */ new WeakMap();
+	#closed = false;
+	#idleTimer;
+	constructor(url, idleTimeoutMillis) {
+		this.#url = url;
+		this.#idleTimeoutMillis = idleTimeoutMillis;
+	}
+	/** Sends `KILL QUERY` for `threadId`. Never rejects. A kept connection that is no longer valid is replaced once. */
+	async cancel(threadId, replaced = false) {
+		if (this.#closed || threadId === null) return "unsent";
+		clearTimeout(this.#idleTimer);
+		const opening = this.#connection ?? this.#open();
+		this.#connection = opening;
+		const connection = await opening;
+		if (connection === void 0) {
+			this.#setAside(opening);
+			return "unsent";
+		}
+		if (!connection.isValid()) {
+			this.#setAside(opening);
+			return replaced ? "unsent" : this.cancel(threadId, true);
+		}
+		this.#pending.set(connection, this.#pendingOn(connection) + 1);
+		const killing = connection.query("KILL QUERY ?", [threadId]).then(() => "sent", (error) => isFatal(error) ? "unconfirmed" : "unsent");
+		killing.then(() => {
+			this.#pending.set(connection, this.#pendingOn(connection) - 1);
+			this.#idleLater(opening, connection);
+		});
+		const limit = timeout(CANCEL_TIMEOUT_MILLIS);
+		const result = await Promise.race([killing, limit.expired]);
+		limit.clear();
+		if (result === "sent" || result === "unsent") return result;
+		this.#setAside(opening);
+		connection.end().catch(() => void 0);
+		return "unconfirmed";
+	}
+	/** Ends the connection: `end()` sends `QUIT` once any `KILL QUERY` on it settles. Waits for that only when no `KILL QUERY` is pending on it, so a connection that stopped answering cannot hold `close()` up. */
+	async close() {
+		this.#closed = true;
+		clearTimeout(this.#idleTimer);
+		const connection = await this.#connection;
+		this.#connection = void 0;
+		if (connection === void 0) return;
+		const ending = connection.end().catch(() => void 0);
+		if (this.#pendingOn(connection) === 0) await ending;
+	}
+	#idleLater(opening, connection) {
+		if (this.#idleTimeoutMillis === 0 || this.#pendingOn(connection) > 0 || this.#connection !== opening) return;
+		clearTimeout(this.#idleTimer);
+		this.#idleTimer = setTimeout(() => {
+			if (this.#pendingOn(connection) > 0 || this.#connection !== opening) return;
+			this.#connection = void 0;
+			connection.end().catch(() => void 0);
+		}, this.#idleTimeoutMillis);
+		this.#idleTimer.unref();
+	}
+	#pendingOn(connection) {
+		return this.#pending.get(connection) ?? 0;
+	}
+	#setAside(opening) {
+		if (this.#connection === opening) this.#connection = void 0;
+	}
+	async #open() {
+		try {
+			const connection = await createConnection(mysqlConnectionOptions(this.#url, { connectTimeoutMs: CANCEL_TIMEOUT_MILLIS }));
+			connection.on("error", () => void 0);
+			if (this.#closed) {
+				await connection.end().catch(() => void 0);
+				return;
+			}
+			return connection;
+		} catch {
+			return;
+		}
+	}
+};
 function notConnected(message) {
 	return errorRuntime("DRIVER.NOT_CONNECTED", message, { fix: "Call connect(binding) before running queries, and do not use the driver after close()." });
 }
@@ -23,8 +117,15 @@ function startStream(client, request, outcome) {
 		throw settle(error, outcome);
 	}
 }
-function affectedRows(result) {
-	return typeof result === "object" && result !== null && "affectedRows" in result && typeof result.affectedRows === "number" ? result.affectedRows : 0;
+/** What a statement's result reports: the rows it changed, and, when it changed one row, the value MySQL numbered for it. MySQL reports 0 when it numbered none. */
+function statementStats(result) {
+	if (typeof result !== "object" || result === null) return { affectedRows: 0 };
+	const affectedRows = "affectedRows" in result && typeof result.affectedRows === "number" ? result.affectedRows : 0;
+	const insertId = "insertId" in result ? result.insertId : void 0;
+	return affectedRows === 1 && (typeof insertId === "bigint" || typeof insertId === "number") && insertId > 0 ? {
+		affectedRows,
+		insertId: String(insertId)
+	} : { affectedRows };
 }
 /** The error to report for `error`, after noting in `outcome` whether it left the client unusable. */
 function settle(error, outcome) {
@@ -38,56 +139,58 @@ function resultReceived(rows) {
 	const state = Reflect.get(rows, "_readableState");
 	return typeof state === "object" && state !== null && "ended" in state && state.ended === true;
 }
-/** Reads and drops the rest of `rows` and settles once it has ended or failed. A caller that abandoned its loop over the stream leaves the loop's `'readable'` listener behind, which would keep the stream paused, so it is removed. */
+/**
+* Reads and drops what is left of a stream's result. The package's `close()` stops it keeping new rows; the rows already buffered are read here with `read()`, which works whether or not the caller's iterator is still attached to the stream, so an iterator the caller abandoned cannot hold the drain up.
+*/
 async function dropRest(rows) {
 	rows.close?.();
-	rows.removeAllListeners("readable");
-	rows.resume();
-	await finished(rows);
-}
-/** The package can report an error on a stream after the caller stopped reading it, such as the one for a connection destroyed mid-result; the generator has already settled by then. */
-function ignoreAfterStop() {}
-/** Waiting for a statement to end needs only that it settled; its own caller handles how. */
-function settledEither() {}
-/** Waits for `work` to settle, but no longer than `ms`. */
-async function settledWithin(work, ms) {
-	let timer;
-	const elapsed = new Promise((resolve) => {
-		timer = setTimeout(resolve, ms);
-	});
+	const drain = () => {
+		while (rows.read() !== null);
+	};
+	rows.on("readable", drain);
 	try {
-		await Promise.race([work.then(settledEither, settledEither), elapsed]);
+		drain();
+		await finished(rows);
 	} finally {
-		clearTimeout(timer);
+		rows.off("readable", drain);
 	}
 }
-function noConnection() {}
-/** The server may have run a `KILL` whose reply was lost, so the statement may still end; the caller waits for it either way. */
-function killReplyLost() {}
-/**
-* Sends `KILL QUERY` for the statement running on the connection with id `threadId`, over a short-lived connection of its own, because MySQL cannot interrupt a statement from the connection that runs it. That connection waits for the reply no longer than it waits to connect. Resolves `true` once the `KILL` was sent, whatever the reply, and `false` when the connection could not be opened. Never rejects.
-*
-* The package does the same when it destroys a connection with a statement still running, but leaves a failure of its `KILL` unhandled, which ends a Node.js process. So the driver interrupts the statement itself and destroys the connection only once the statement has ended, when the package has nothing left to interrupt.
-*/
-async function interruptStatement(options, threadId) {
-	const connection = await createConnection({
-		...options,
-		...ifDefined("socketTimeout", options.connectTimeout)
-	}).catch(noConnection);
-	if (connection === void 0) return false;
-	await connection.query("KILL QUERY ?", [threadId]).catch(killReplyLost);
-	connection.destroy();
-	return true;
+function cancelNotConfirmed() {
+	return errorRuntime("DRIVER.NOT_CONNECTED", "A cancel on this MySQL connection could not be confirmed, so the connection can no longer be used", {
+		why: "The driver cancelled a stream the caller stopped early, and MySQL did not answer the KILL QUERY in time. It may still arrive and would interrupt whatever statement the connection runs then.",
+		fix: "Release the connection, which closes it; MySQL rolls back an open transaction on it. Acquire another connection and run the work again."
+	});
+}
+function connectionReleased() {
+	return errorRuntime("DRIVER.NOT_CONNECTED", "MySQL connection was released", { fix: "Send statements on a connection only until you release it, and await each one before release()." });
+}
+/** The package can report an error on a stream after the caller stopped reading it, such as MySQL's for a statement the driver cancelled; the generator has already settled by then. */
+function ignoreAfterStop() {}
+/** MySQL's error for a statement `KILL QUERY` cancelled (`ER_QUERY_INTERRUPTED`). The package marks it fatal when it arrives in the middle of a result, but the connection stays usable. */
+function isQueryInterrupted(error) {
+	return error instanceof Error && "errno" in error && error.errno === 1317;
 }
 var MysqlQueryable = class {
 	streams;
-	/** Called with each stream when it starts and with `undefined` when it ends, so a held connection can end a stream its caller abandoned. */
-	streamChanged(_rows) {}
-	/** Called with each buffered statement as it starts, so a held connection can wait for it to end. */
-	statementRunning(_running) {}
 	constructor(streams) {
 		this.streams = streams;
 	}
+	/** Records a stream that is open, and returns the call that records its end. */
+	streamOpened(_rows) {
+		return () => {};
+	}
+	/** Takes the client's lock, which keeps statements on it one at a time in the order sent. */
+	lockClient(client) {
+		return acquireClientQueryLock(client);
+	}
+	/** Runs one statement that is not a stream, under the client's lock. */
+	runStatement(work) {
+		return work();
+	}
+	/** Whether the client went back to the pool under this queryable, so it must send nothing more on it. */
+	get handedBack() {
+		return false;
+	}
 	async *query(request) {
 		if (this.streams) {
 			yield* this.#streamRows(request);
@@ -97,17 +200,15 @@ var MysqlQueryable = class {
 		for (const row of Array.isArray(result) ? result : []) yield blindCast(row);
 	}
 	async execute(request) {
-		return { affectedRows: affectedRows(await this.#runReleasing(request)) };
+		return statementStats(await this.#runReleasing(request));
 	}
 	async #runReleasing(request) {
 		const client = await this.acquireClient();
 		const outcome = { destroy: false };
 		try {
-			const releaseLock = await acquireClientQueryLock(client);
+			const releaseLock = await this.lockClient(client);
 			try {
-				const running = run(client, request);
-				this.statementRunning(running);
-				return await running;
+				return await this.runStatement(() => run(client, request));
 			} finally {
 				releaseLock();
 			}
@@ -118,17 +219,22 @@ var MysqlQueryable = class {
 		}
 	}
 	/**
-	* Streams the rows of `request` as they arrive; the package pauses the socket while the caller is busy. A caller that stops reading early is handled by {@link MysqlQueryable.#stopEarly}, or by {@link MysqlQueryable.#interruptAndEnd} for a pooled client whose result is still arriving, which then gives the client back in the background. A fatal error, such as a lost connection, destroys the client.
+	* Streams the rows of `request` as they arrive; the package pauses the socket while the caller is busy. A caller that stops reading early is handled by {@link MysqlQueryable.#stopEarly}. A fatal error, such as a lost connection, destroys the client.
 	*/
 	async *#streamRows(request) {
 		const client = await this.acquireClient();
 		const outcome = { destroy: false };
-		const releaseLock = await acquireClientQueryLock(client);
-		let ending;
+		let releaseLock;
+		try {
+			releaseLock = await this.lockClient(client);
+		} catch (error) {
+			await this.releaseClient(client, outcome);
+			throw error;
+		}
 		try {
 			const rows = startStream(client, request, outcome);
 			rows.on("error", ignoreAfterStop);
-			this.streamChanged(rows);
+			const streamClosed = this.streamOpened(rows);
 			let settled = false;
 			try {
 				for await (const row of rows.iterator({ destroyOnReturn: false })) yield blindCast(row);
@@ -137,94 +243,126 @@ var MysqlQueryable = class {
 				settled = true;
 				throw settle(error, outcome);
 			} finally {
-				if (!settled && !this.holdsClient && !resultReceived(rows)) {
-					outcome.destroy = true;
-					ending = this.#interruptAndEnd(client, rows);
-				} else if (!settled) await this.#stopEarly(rows, outcome);
-				if (outcome.destroy && ending === void 0) rows.destroy();
-				this.streamChanged(void 0);
+				if (!settled && !this.handedBack) await this.#stopEarly(client, rows, outcome);
+				if (outcome.destroy) rows.destroy();
+				streamClosed();
 			}
 		} finally {
-			if (ending === void 0) {
-				releaseLock();
-				await this.releaseClient(client, outcome);
-			} else ending.then(() => {
-				releaseLock();
-				return this.releaseClient(client, outcome);
-			}).catch(ignoreAfterStop);
+			releaseLock();
+			await this.releaseClient(client, outcome);
 		}
 	}
-	/** Ends a stream the caller stopped reading early whose client survives it: a held client, whose session must survive, or a pooled one whose whole result has arrived. The rest is read and dropped. */
-	async #stopEarly(rows, outcome) {
+	/**
+	* Ends a stream the caller stopped reading early, and keeps the client usable. While its result is still arriving, the statement is first cancelled with `KILL QUERY`, so a large result is not downloaded only to be thrown away; MySQL does not say how many rows remain. On a held connection or in a transaction, as on a pooled one: `KILL QUERY` ends only the statement, the session survives, and in a transaction MySQL rolls back only that statement. The rest of the result is then read and dropped, MySQL's error for the cancelled statement among it. The client is never destroyed while its statement runs: the package's `destroy()` would send `KILL` itself, on a connection whose failure it does not handle.
+	*/
+	async #stopEarly(client, rows, outcome) {
+		const cancel = resultReceived(rows) ? "unsent" : await this.cancelStatement(client.threadId);
 		await dropRest(rows).catch((error) => {
-			if (isFatal(error)) outcome.destroy = true;
+			if (isFatal(error) && !(cancel !== "unsent" && isQueryInterrupted(error))) outcome.destroy = true;
 		});
+		if (cancel === "unconfirmed") this.cancelUnconfirmed(outcome);
 	}
 	/**
-	* Ends a stream the caller stopped reading early on a pooled client whose result is still arriving. The client is destroyed rather than kept, so a large result is not downloaded only to be thrown away, since MySQL does not say how many rows remain; before that, its statement is interrupted and the rest of the result dropped, so the package finds nothing left to interrupt. Settles once the result has ended or the wait for it is over.
+	* A cancel that went out without an answer may still reach MySQL and interrupt the next statement on the client, so the client must not serve another caller. Once its rest has been read, nothing is receiving on it, so closing it sends no `KILL` of the package's own; a late `KILL QUERY` then finds no thread.
 	*/
-	async #interruptAndEnd(client, rows) {
-		await this.endStatement(client, dropRest(rows).catch(ignoreAfterStop));
-		rows.destroy();
+	cancelUnconfirmed(outcome) {
+		outcome.destroy = true;
 	}
 };
+function handedBackState() {
+	let refuse = () => {};
+	const signal = new Promise((_, reject) => {
+		refuse = () => reject(connectionReleased());
+	});
+	signal.catch(() => void 0);
+	const state = {
+		done: false,
+		signal,
+		refuse: () => {
+			state.done = true;
+			refuse();
+		}
+	};
+	return state;
+}
 /**
 * A queryable on a connection the caller holds, whose statements all run on the same session, in the order they are sent, under the client's lock. A statement sent while a stream on the connection is open waits for that stream to end; one awaited inside the stream's own loop never finishes, as on Postgres with a cursor.
 */
 var MysqlHeldQueryable = class extends MysqlQueryable {
 	client;
 	held;
-	end;
 	holdsClient = true;
-	constructor(client, held, streams, end) {
-		super(streams);
-		this.client = client;
-		this.held = held;
-		this.end = end;
+	get cancelStatement() {
+		return this.held.cancel;
+	}
+	streamOpened(rows) {
+		this.held.streams.add(rows);
+		return () => this.held.streams.delete(rows);
+	}
+	get handedBack() {
+		return this.held.handedBack.done;
+	}
+	cancelUnconfirmed() {
+		this.held.cancelUnconfirmed = true;
 	}
-	endStatement(client, ended) {
-		return this.end(client, ended);
+	/** Takes the client's lock, or fails once the connection is handed back, whether the statement was sent after that or was still waiting for the lock. A lock taken after that is given straight back. */
+	async lockClient(client) {
+		this.#refuseIfUnusable();
+		const locking = acquireClientQueryLock(client);
+		try {
+			const releaseLock = await Promise.race([locking, this.held.handedBack.signal]);
+			if (!this.held.handedBack.done && !this.held.cancelUnconfirmed) return releaseLock;
+			releaseLock();
+		} catch {
+			locking.then((releaseLock) => releaseLock());
+		}
+		this.#refuseIfUnusable();
+		throw connectionReleased();
 	}
-	streamChanged(rows) {
-		this.held.stream = rows;
+	/** Refuses a statement on a connection that was handed back, or whose cancel went out without an answer: a late `KILL QUERY` would interrupt it. */
+	#refuseIfUnusable() {
+		if (this.held.handedBack.done) throw connectionReleased();
+		if (this.held.cancelUnconfirmed) throw cancelNotConfirmed();
 	}
-	statementRunning(running) {
-		const settled = running.then(settledEither, settledEither);
-		this.held.statements.add(settled);
-		settled.then(() => this.held.statements.delete(settled));
+	runStatement(work) {
+		const running = work();
+		this.held.running.add(running);
+		running.then(() => this.held.running.delete(running), () => this.held.running.delete(running));
+		return running;
+	}
+	constructor(client, held, streams) {
+		super(streams);
+		this.client = client;
+		this.held = held;
 	}
 	async acquireClient() {
-		this.held.running += 1;
+		this.#refuseIfUnusable();
 		return this.client;
 	}
-	async releaseClient() {
-		this.held.running -= 1;
-	}
+	async releaseClient() {}
 	/** Runs one of the package's transaction calls under the client's lock, taken as a statement takes it, so it keeps its place among the statements sent. */
 	async underLock(call) {
 		const client = await this.acquireClient();
+		const releaseLock = await this.lockClient(client);
 		try {
-			const releaseLock = await acquireClientQueryLock(client);
-			try {
-				await call();
-			} finally {
-				releaseLock();
-			}
+			await this.runStatement(call);
 		} catch (error) {
 			throw normalizeMysqlError(error);
 		} finally {
-			await this.releaseClient();
+			releaseLock();
 		}
 	}
 };
 var MysqlConnectionImpl = class extends MysqlHeldQueryable {
 	#onRelease;
-	constructor(client, streams, end, onRelease) {
+	constructor(client, streams, cancel, onRelease) {
 		super(client, {
-			running: 0,
-			stream: void 0,
-			statements: /* @__PURE__ */ new Set()
-		}, streams, end);
+			streams: /* @__PURE__ */ new Set(),
+			cancelUnconfirmed: false,
+			running: /* @__PURE__ */ new Set(),
+			cancel,
+			handedBack: handedBackState()
+		}, streams);
 		this.#onRelease = onRelease;
 	}
 	#released() {
@@ -234,28 +372,46 @@ var MysqlConnectionImpl = class extends MysqlHeldQueryable {
 	}
 	async beginTransaction() {
 		await this.underLock(() => this.client.beginTransaction());
-		return new MysqlTransactionImpl(this.client, this.held, this.streams, this.end);
+		return new MysqlTransactionImpl(this.client, this.held, this.streams);
 	}
 	/**
-	* Returns the connection to the pool, as the Postgres driver's `release()` does. A connection with a statement still running, such as a stream the caller dropped, is destroyed instead: the package's release sends `ROLLBACK` behind that statement and waits for it, which would never finish, where `pg`'s release does not wait on the server.
+	* Returns the connection to the pool, as the Postgres driver's `release()` does. From then on the connection refuses every statement, those still waiting for its lock included, so none runs later in another caller's session. A statement that is not a stream and is already running finishes, as on Postgres. A stream still open, such as one the caller dropped, is cancelled and read to its end by the driver: the package's release sends `ROLLBACK` behind that statement and waits for it, which would otherwise never finish, where `pg`'s release does not wait on the server.
 	*/
 	async release() {
-		if (this.held.running > 0) return this.destroy();
+		if (this.held.handedBack.done) return;
+		this.held.handedBack.refuse();
 		try {
-			await this.client.release();
+			if (this.held.streams.size > 0) await this.#cancelRunning();
+			await this.#runningSettled();
+			if (this.held.cancelUnconfirmed) await this.#close();
+			else await this.client.release();
 		} finally {
 			this.#released();
 		}
 	}
-	/** Destroys the connection. A statement still running on it, buffered or a stream its caller abandoned, is interrupted first, and the connection destroyed once it has ended; see {@link interruptStatement}. */
+	/** Closes the connection instead of returning it. It refuses every statement from then on, cancels whatever still runs and waits for it to end, so the package's `destroy()` never sends a `KILL` of its own. */
 	async destroy(_reason) {
-		if (this.held.running > 0) {
-			const stream = this.held.stream;
-			const ended = Promise.all([...stream === void 0 ? [] : [dropRest(stream).catch(ignoreAfterStop)], ...this.held.statements]);
-			await this.endStatement(this.client, ended);
+		if (this.held.handedBack.done) return;
+		this.held.handedBack.refuse();
+		try {
+			if (this.held.streams.size > 0 || this.held.running.size > 0) await this.#cancelRunning();
+			await this.#runningSettled();
+			await this.#close();
+		} finally {
+			this.#released();
 		}
+	}
+	/** Closes the client once the `ping` queued behind anything left on it has answered, so nothing is receiving and the package's `destroy()` sends no `KILL` of its own. */
+	async #close() {
+		await this.client.ping().catch(() => void 0);
 		this.client.destroy();
-		this.#released();
+	}
+	async #cancelRunning() {
+		if (await this.held.cancel(this.client.threadId) === "unconfirmed") this.held.cancelUnconfirmed = true;
+		await Promise.all([...this.held.streams].map((rows) => dropRest(rows).catch(() => void 0)));
+	}
+	async #runningSettled() {
+		await Promise.allSettled([...this.held.running]);
 	}
 };
 var MysqlTransactionImpl = class extends MysqlHeldQueryable {
@@ -319,9 +475,9 @@ var MysqlDriver = class extends MysqlQueryable {
 	targetId = "mysql";
 	holdsClient = false;
 	#state = { kind: "unbound" };
-	/** The options of the short-lived connection that interrupts a statement, and how long to wait for an interrupted statement to end: as long as a connection may take to open, or the default when `connectionTimeoutMillis` is 0, which the package reads as no limit. Set by `connect()` and kept through `close()`, which waits for statements still ending. */
-	#interrupt;
 	#inUse = new ClientsInUse();
+	#canceller;
+	cancelStatement = (threadId) => this.#canceller?.cancel(threadId) ?? Promise.resolve("unsent");
 	#options;
 	#sessionSettings;
 	constructor(options = {}) {
@@ -340,33 +496,23 @@ var MysqlDriver = class extends MysqlQueryable {
 			logger: { error: (error) => waiting.reported(error) }
 		});
 		if (pool instanceof EventEmitter) pool.on("error", ignoreConnectionFailure);
-		const connectionTimeout = this.#options.poolOptions?.connectionTimeoutMillis;
-		const interruptTimeoutMs = connectionTimeout !== void 0 && connectionTimeout > 0 ? connectionTimeout : DEFAULT_CONNECT_TIMEOUT_MILLIS;
-		this.#interrupt = {
-			options: mysqlConnectionOptions(binding.url, { connectTimeoutMs: interruptTimeoutMs }),
-			waitMs: interruptTimeoutMs
-		};
 		this.#state = {
 			kind: "connected",
 			pool,
 			waiting
 		};
-	}
-	/** See {@link EndStatement}. When the `KILL` cannot be sent at all, there is no wait: the client is destroyed at once, and the package interrupts the statement itself. */
-	async endStatement(client, ended) {
-		const settled = ended.then(settledEither, settledEither);
-		const interrupt = this.#interrupt;
-		if (interrupt === void 0 || client.threadId === null) return;
-		if (await interruptStatement(interrupt.options, client.threadId)) await settledWithin(settled, interrupt.waitMs);
+		this.#canceller = new Canceller(binding.url, mysqlPoolIdleTimeoutMillis(this.#options.poolOptions));
 	}
 	async acquireConnection() {
-		return new MysqlConnectionImpl(await this.acquireClient(), this.streams, (held, ended) => this.endStatement(held, ended), () => this.#inUse.released());
+		return new MysqlConnectionImpl(await this.acquireClient(), this.streams, this.cancelStatement, () => this.#inUse.released());
 	}
 	async close() {
 		if (this.#state.kind !== "connected") return;
 		const { pool } = this.#state;
 		this.#state = { kind: "closed" };
 		await this.#inUse.none();
+		await this.#canceller?.close();
+		this.#canceller = void 0;
 		await pool.end();
 	}
 	async acquireClient() {
@@ -391,6 +537,9 @@ var MysqlDriver = class extends MysqlQueryable {
 		}
 		return client;
 	}
+	/**
+	* Destroys a client only after an error the package marks fatal, or after a cancel that went out without an answer once the rest of its result was read (`cancelUnconfirmed`). The package marks an error fatal when the connection's socket is gone or can no longer be trusted, and it has then already set the connection closed and failed every command on it (`fatalError` in its `connection.js`), so no command is receiving and its `destroy()` sends no `KILL`. A statement the caller stopped early is cancelled and read to its end instead (`#stopEarly`).
+	*/
 	async releaseClient(client, { destroy }) {
 		try {
 			if (destroy) client.destroy();