velocious 1.0.430 → 1.0.431

package/build/src/database/pool/async-tracked-multi-connection.js

@@ -1,10 +1,13 @@
 // @ts-check
-import { AsyncLocalStorage } from "async_hooks";
-import BasePool, { POOL_CONFIGURATION_KEY } from "./base.js";
-export const CLOSED_CONNECTION = Symbol("velociousClosedConnection");
-const IDLE_CONNECTION_CHECKED_IN_AT = Symbol("velociousIdleConnectionCheckedInAt");
-const CONNECTION_CHECKED_OUT_AT = Symbol("velociousConnectionCheckedOutAt");
-const DEFAULT_IDLE_TIMEOUT_MILLIS = 5000;
+
+import {AsyncLocalStorage} from "async_hooks"
+import BasePool, {POOL_CONFIGURATION_KEY} from "./base.js"
+
+export const CLOSED_CONNECTION = Symbol("velociousClosedConnection")
+const IDLE_CONNECTION_CHECKED_IN_AT = Symbol("velociousIdleConnectionCheckedInAt")
+const CONNECTION_CHECKED_OUT_AT = Symbol("velociousConnectionCheckedOutAt")
+const DEFAULT_IDLE_TIMEOUT_MILLIS = 5000
+
 /**
  * PendingCheckout type.
  * @typedef {object} PendingCheckout
@@ -15,1000 +18,1147 @@ const DEFAULT_IDLE_TIMEOUT_MILLIS = 5000;
  * @property {(connection: import("../drivers/base.js").default) => void} resolve - Resolves with an activated connection.
  * @property {(error: Error) => void} reject - Rejects when checkout cannot complete.
  */
+
 export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {
-    /**
-     * Global fallback connections keyed by configuration instance and pool identifier.
-     * @type {WeakMap<import("../../configuration.js").default, Record<string, import("../drivers/base.js").default>>}
-     */
-    static globalConnections = new WeakMap();
-    asyncLocalStorage = new AsyncLocalStorage();
-    /**
-     * When set, returned by getCurrentContextConnection when no async context exists.
-     * Used by the test runner to share a connection between test code and HTTP handlers
-     * running in the same process (in-process test server mode).
-     * @type {import("../drivers/base.js").default | undefined}
-     */
-    _testSharedConnection = undefined;
+  /**
+   * Global fallback connections keyed by configuration instance and pool identifier.
+   * @type {WeakMap<import("../../configuration.js").default, Record<string, import("../drivers/base.js").default>>}
+   */
+  static globalConnections = new WeakMap()
+
+  asyncLocalStorage = new AsyncLocalStorage()
+
+  /**
+   * When set, returned by getCurrentContextConnection when no async context exists.
+   * Used by the test runner to share a connection between test code and HTTP handlers
+   * running in the same process (in-process test server mode).
+   * @type {import("../drivers/base.js").default | undefined}
+   */
+  _testSharedConnection = undefined
+
+  /**
+   * Connections.
+    @type {import("../drivers/base.js").default[]} */
+  connections = []
+
+  /**
+   * Connections in use.
+    @type {Record<number, import("../drivers/base.js").default>} */
+  connectionsInUse = {}
+
+  /**
+   * Pending checkouts.
+    @type {PendingCheckout[]} */
+  pendingCheckouts = []
+
+  /**
+   * Connections being spawned.
+    @type {number} */
+  connectionsBeingSpawned = 0
+
+  /**
+   * Pending checkout drain promise.
+    @type {Promise<void> | undefined} */
+  pendingCheckoutDrainPromise = undefined
+
+  /**
+   * Idle connection reaper timer.
+    @type {ReturnType<typeof setTimeout> | undefined} */
+  idleConnectionReaperTimer = undefined
+
+  /**
+   * In-flight connection-close promises. The idle reaper is armed on check-in
+   * and runs fire-and-forget when its timer fires, so a scheduled reap can be
+   * closing a connection while an explicit `reapIdleConnections()` (or
+   * `clearIdleConnectionReaperTimer()`) runs. Tracking the in-flight closes lets
+   * those callers await them, so once a reap resolves the connections it
+   * expired are fully closed instead of half-closed mid-`close()`.
+   * @type {Set<Promise<void>>}
+   */
+  inflightConnectionCloses = new Set()
+
+  /**
+   * In-flight close promise per connection, so concurrent closes of the same
+   * connection await the same close rather than closing the driver handle twice.
+   * @type {WeakMap<object, Promise<void>>}
+   */
+  connectionClosePromises = new WeakMap()
+
+  idSeq = 0
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+   * @param {string} args.identifier - Identifier.
+   */
+  constructor({configuration, identifier}) {
+    super({configuration, identifier})
+    this._withoutCurrentConnectionContext = /**
+                                             * Narrows the runtime value to the documented type.
+                                              @type {(callback: () => ?) => ?} */ ((callback) => this.asyncLocalStorage.run(undefined, callback))
+  }
+
+  /**
+   * Runs checkin.
+   * @param {import("../drivers/base.js").default} connection - Database connection instance.
+   * @returns {Promise<void>} - Resolves when the connection is checked in or closed.
+   */
+  async checkin(connection) {
+    const id = connection.getIdSeq()
+    const trackedConnection = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
+
+    if (trackedConnection[CLOSED_CONNECTION]) {
+      this.untrackConnectionInUse(connection, id)
+      await this.drainPendingCheckouts()
+      return
+    }
+
+    try {
+      await this.rollbackLeftOpenTransaction(connection)
+      await connection.clearConnectionCheckoutName()
+    } catch (error) {
+      await this.closeCheckedOutConnectionAfterCheckinFailure(connection, id, error)
+      throw error
+    }
+
+    this.untrackConnectionInUse(connection, id)
+    trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT] = Date.now()
+    delete trackedConnection[CONNECTION_CHECKED_OUT_AT]
+    this.connections.push(connection)
+    await this.drainPendingCheckouts()
+    if (this.connections.includes(connection)) await this.handleCheckedInIdleConnection()
+  }
+
+  /**
+   * Runs close checked out connection after checkin failure.
+   * @param {import("../drivers/base.js").default} connection - Connection that failed check-in cleanup.
+   * @param {number | undefined} id - Connection checkout id.
+   * @param {?} originalError - Error that caused check-in cleanup to fail.
+   * @returns {Promise<void>} - Resolves when cleanup has been attempted.
+   */
+  async closeCheckedOutConnectionAfterCheckinFailure(connection, id, originalError) {
+    this.untrackConnectionInUse(connection, id)
+
+    try {
+      await this.closeConnection(connection)
+    } catch (error) {
+      this.logger.warn("Failed to close database connection after check-in cleanup failed", {error, originalError})
+    }
+
+    try {
+      await this.drainPendingCheckouts()
+    } catch (error) {
+      this.logger.warn("Failed to drain pending database checkouts after check-in cleanup failed", {error, originalError})
+    }
+  }
+
+  /**
+   * Runs untrack connection in use.
+   * @param {import("../drivers/base.js").default} connection - Connection being checked in.
+   * @param {number | undefined} id - Connection checkout id.
+   * @returns {void}
+   */
+  untrackConnectionInUse(connection, id) {
+    if (typeof id !== "number") {
+      throw new Error(`idSeq on connection wasn't set? '${typeof id}' = ${id}`)
+    }
+
+    delete this.connectionsInUse[id]
+    connection.setIdSeq(undefined)
+  }
+
+  /**
+   * Runs handle checked in idle connection.
+   * @returns {Promise<void>} - Resolves once idle reaping has been scheduled or run.
+   */
+  async handleCheckedInIdleConnection() {
+    if (this.idleTimeoutMillis() === 0) {
+      await this.reapIdleConnections()
+    } else {
+      this.scheduleIdleConnectionReaper()
+    }
+  }
+
+  /**
+   * Runs checkout.
+   * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
+   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
+   */
+  async checkout(options = {}) {
+    const databaseConfig = this.getConfiguration()
+    const reuseKey = this.getConfigurationReuseKey()
+    let connection = this.takeIdleConnectionForReuseKey(reuseKey)
+
+    if (connection) return await this.activateConnection(connection, options)
+
+    await this.reapIdleConnections()
+    connection = this.takeIdleConnectionForReuseKey(reuseKey)
+
+    if (connection) return await this.activateConnection(connection, options)
+
+    if (this.canSpawnConnection()) {
+      // Spawn via spawnConnection() so the tenant-aware configuration is resolved FRESH at
+      // spawn time for the current caller. Reusing the databaseConfig captured at the top of
+      // checkout() could bind the connection to a stale tenant/database, which breaks
+      // per-request isolation (e.g. test truncation appearing not to take effect). The queued
+      // path below keeps the waiting caller's captured config via waitForCheckout().
+      connection = await this.spawnConnectionForCheckout(this.getConfiguration(), this.getConfigurationReuseKey())
+
+      return await this.activateConnection(connection, options)
+    }
+
+    return await this.waitForCheckout(databaseConfig, reuseKey, options)
+  }
+
+  /**
+   * Runs take idle connection for reuse key.
+   * @param {string} reuseKey - Database configuration reuse key.
+   * @param {object} [args] - Options.
+   * @param {boolean} [args.includeOpenTransactions] - Whether connections with open transactions may be returned.
+   * @returns {import("../drivers/base.js").default | undefined} - Matching idle connection.
+   */
+  takeIdleConnectionForReuseKey(reuseKey, {includeOpenTransactions = true} = {}) {
+    const connectionIndex = this.connections.findIndex((queuedConnection) => {
+      if (!includeOpenTransactions && this.connectionHasOpenTransaction(queuedConnection)) return false
+
+      return this.connectionMatchesReuseKey(queuedConnection, reuseKey)
+    })
+    const connection = connectionIndex === -1 ? undefined : this.connections.splice(connectionIndex, 1)[0]
+
+    return connection
+  }
+
+  /**
+   * Runs connection matches reuse key.
+   * @param {import("../drivers/base.js").default} connection - Connection.
+   * @param {string} reuseKey - Database configuration reuse key.
+   * @returns {boolean} - Whether the connection matches the reuse key.
+   */
+  connectionMatchesReuseKey(connection, reuseKey) {
+    const connectionWithPoolKey = /**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
+
+    return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === reuseKey
+  }
+
+  /**
+   * Runs activate connection.
+   * @param {import("../drivers/base.js").default} connection - Connection.
+   * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
+   * @returns {Promise<import("../drivers/base.js").default>} - Activated connection.
+   */
+  async activateConnection(connection, options = {}) {
+    if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)
+
+    const id = this.idSeq++
+
+    const trackedConnection = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("../drivers/base.js").default & {[CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
+    delete trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]
+    trackedConnection[CONNECTION_CHECKED_OUT_AT] = Date.now()
+
+    connection.setIdSeq(id)
+    this.connectionsInUse[id] = connection
+
+    try {
+      await connection.setConnectionCheckoutName(options.name)
+    } catch (error) {
+      delete this.connectionsInUse[id]
+      connection.setIdSeq(undefined)
+      await this.closeConnection(connection)
+
+      throw error
+    }
+
+    return connection
+  }
+
+  /**
+   * Runs max connections.
+   * @returns {number | undefined} - Configured max live connections.
+   */
+  maxConnections() {
+    const value = this.getConfiguration().pool?.max
+
+    if (this.validMaxConnections(value)) return value
+
+    return
+  }
+
+  /**
+   * Runs valid max connections.
+   * @param {?} value - Candidate max connection count.
+   * @returns {value is number} - Whether the value is a valid max connection count.
+   */
+  validMaxConnections(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 1
+  }
+
+  /**
+   * Runs live connection count.
+   * @returns {number} - Number of live and in-progress connections.
+   */
+  liveConnectionCount() {
+    const connections = new Set([
+      ...this.connections,
+      ...Object.values(this.connectionsInUse),
+      this.getGlobalConnectionForIdentifier()
+    ].filter(Boolean))
+
+    return connections.size + this.connectionsBeingSpawned
+  }
+
+  /**
+   * Runs can spawn connection.
+   * @returns {boolean} - Whether a new connection can be spawned.
+   */
+  canSpawnConnection() {
+    const maxConnections = this.maxConnections()
+
+    return maxConnections === undefined || this.liveConnectionCount() < maxConnections
+  }
+
+  /**
+   * Runs spawn connection for checkout.
+   * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.
+   * @param {string} reuseKey - Database configuration reuse key for the checkout.
+   * @returns {Promise<import("../drivers/base.js").default>} - Spawned connection.
+   */
+  async spawnConnectionForCheckout(databaseConfig, reuseKey) {
+    this.connectionsBeingSpawned++
+
+    try {
+      const connection = await this.spawnConnectionWithConfiguration(databaseConfig)
+      const connectionWithPoolKey = /**
+                                     * Narrows the runtime value to the documented type.
+                                      @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
+
+      connectionWithPoolKey[POOL_CONFIGURATION_KEY] = reuseKey
+      connection.setSchemaCacheInvalidator(() => {
+        this.clearSchemaCache()
+        this.configuration.clearSchemaCachesForReuseKey(reuseKey)
+      })
+
+      return connection
+    } finally {
+      this.connectionsBeingSpawned--
+    }
+  }
+
+  /**
+   * Runs wait for checkout.
+   * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.
+   * @param {string} reuseKey - Database configuration reuse key.
+   * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
+   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with an activated connection.
+   */
+  async waitForCheckout(databaseConfig, reuseKey, options = {}) {
+    return await new Promise((resolve, reject) => {
+      this.pendingCheckouts.push({databaseConfig, enqueuedAt: Date.now(), options, reject, resolve, reuseKey})
+      void this.drainPendingCheckouts().catch((error) => {
+        const checkoutError = error instanceof Error ? error : new Error("Failed to drain pending database connection checkouts.", {cause: error})
+
+        this.rejectPendingCheckouts(checkoutError)
+      })
+    })
+  }
+
+  /**
+   * Runs drain pending checkouts.
+   * @returns {Promise<void>} - Resolves when pending checkouts have been drained as far as possible.
+   */
+  async drainPendingCheckouts() {
+    if (this.pendingCheckoutDrainPromise) {
+      await this.pendingCheckoutDrainPromise
+      return
+    }
+
+    this.pendingCheckoutDrainPromise = this.drainPendingCheckoutsActual()
+
+    try {
+      await this.pendingCheckoutDrainPromise
+    } finally {
+      this.pendingCheckoutDrainPromise = undefined
+    }
+  }
+
+  /**
+   * Runs drain pending checkouts actual.
+   * @returns {Promise<void>} - Resolves when pending checkouts have been drained as far as possible.
+   */
+  async drainPendingCheckoutsActual() {
+    while (this.pendingCheckouts.length > 0) {
+      if (await this.resolvePendingCheckoutWithMatchingIdleConnection()) continue
+
+      const checkout = this.pendingCheckouts[0]
+
+      if (await this.closeIdleConnectionForPendingCheckoutCapacity(checkout)) continue
+      if (this.canSpawnConnection()) {
+        this.pendingCheckouts.shift()
+        await this.spawnAndResolvePendingCheckout(checkout)
+        continue
+      }
+
+      const reapedConnection = await this.idleConnectionForPendingCheckout(checkout)
+
+      if (!reapedConnection) return
+
+      this.pendingCheckouts.shift()
+      await this.resolvePendingCheckout(checkout, reapedConnection)
+    }
+  }
+
+  /**
+   * Runs resolve pending checkout with matching idle connection.
+   * @returns {Promise<boolean>} - Whether a pending checkout was resolved with an idle connection.
+   */
+  async resolvePendingCheckoutWithMatchingIdleConnection() {
+    for (let index = 0; index < this.pendingCheckouts.length; index++) {
+      const checkout = this.pendingCheckouts[index]
+      const connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, {includeOpenTransactions: false})
+
+      if (!connection) continue
+
+      this.pendingCheckouts.splice(index, 1)
+      await this.resolvePendingCheckout(checkout, connection)
+
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Runs close idle connection for pending checkout capacity.
+   * @param {PendingCheckout} checkout - Checkout waiting for a connection.
+   * @returns {Promise<boolean>} - Whether an idle connection was closed to free capacity.
+   */
+  async closeIdleConnectionForPendingCheckoutCapacity(checkout) {
+    const connection = this.findIdleConnectionForReuseKey(checkout.reuseKey)
+
+    if (connection) return false
+
+    await this.reapIdleConnections()
+
+    if (this.findIdleConnectionForReuseKey(checkout.reuseKey)) return false
+
+    return this.canSpawnConnection() ? false : await this.closeOneIdleConnectionForCapacity()
+  }
+
+  /**
+   * Runs find idle connection for reuse key.
+   * @param {string} reuseKey - Database configuration reuse key.
+   * @returns {import("../drivers/base.js").default | undefined} - Matching idle connection, if present.
+   */
+  findIdleConnectionForReuseKey(reuseKey) {
+    return this.connections.find((connection) => !this.connectionHasOpenTransaction(connection) && this.connectionMatchesReuseKey(connection, reuseKey))
+  }
+
+  /**
+   * Runs idle connection for pending checkout.
+   * @param {PendingCheckout} checkout - Checkout waiting for a connection.
+   * @returns {Promise<import("../drivers/base.js").default | undefined>} - Matching idle connection, if one can be reused.
+   */
+  async idleConnectionForPendingCheckout(checkout) {
+    let connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, {includeOpenTransactions: false})
+
+    if (connection) return connection
+
+    await this.reapIdleConnections()
+    connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, {includeOpenTransactions: false})
+
+    return connection
+  }
+
+  /**
+   * Runs spawn and resolve pending checkout.
+   * @param {PendingCheckout} checkout - Checkout request to resolve.
+   * @returns {Promise<void>} - Resolves when the checkout has been handled.
+   */
+  async spawnAndResolvePendingCheckout(checkout) {
+    let connection
+
+    try {
+      connection = await this.spawnConnectionForCheckout(checkout.databaseConfig, checkout.reuseKey)
+    } catch (error) {
+      checkout.reject(error instanceof Error ? error : new Error("Failed to spawn database connection.", {cause: error}))
+      return
+    }
+
+    await this.resolvePendingCheckout(checkout, connection)
+  }
+
+  /**
+   * Runs resolve pending checkout.
+   * @param {PendingCheckout} checkout - Checkout request to resolve.
+   * @param {import("../drivers/base.js").default} connection - Connection to activate.
+   * @returns {Promise<void>} - Resolves when the checkout has been handled.
+   */
+  async resolvePendingCheckout(checkout, connection) {
+    try {
+      checkout.resolve(await this.activateConnection(connection, checkout.options))
+    } catch (error) {
+      checkout.reject(error instanceof Error ? error : new Error("Failed to activate database connection.", {cause: error}))
+    }
+  }
+
+  /**
+   * Runs close one idle connection for capacity.
+   * @returns {Promise<boolean>} - Whether an idle connection was closed to free capacity.
+   */
+  async closeOneIdleConnectionForCapacity() {
+    const connection = this.connections.find((candidate) => !this.connectionHasOpenTransaction(candidate))
+
+    if (!connection) return false
+
+    this.connections = this.connections.filter((candidate) => candidate !== connection)
+    await this.closeConnection(connection)
+
+    return true
+  }
+
+  /**
+   * Runs with connection.
+   * @template T
+   * @param {import("./base.js").ConnectionCheckoutOptions | function(import("../drivers/base.js").default) : Promise<T>} optionsOrCallback - Checkout options or callback to invoke with the connection.
+   * @param {function(import("../drivers/base.js").default) : Promise<T>} [callback] - Callback to invoke with the connection.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withConnection(optionsOrCallback, callback) {
+    const options = typeof optionsOrCallback == "function" ? {} : optionsOrCallback
+    const actualCallback = typeof optionsOrCallback == "function" ? optionsOrCallback : callback
+
+    if (!actualCallback) throw new Error("withConnection requires a callback")
+
+    const connection = await this.checkout(options)
+    const id = connection.getIdSeq()
+
+    return await this.asyncLocalStorage.run(id, async () => {
+      try {
+        return await actualCallback(connection)
+      } finally {
+        await this.checkin(connection)
+      }
+    })
+  }
+
+  /**
+   * Runs get current connection.
+   * @returns {import("../drivers/base.js").default} - The current connection.
+   */
+  getCurrentConnection() {
+    const id = this.asyncLocalStorage.getStore()
+
+    if (id === undefined) return this.currentFallbackConnectionOrFail()
+
+    this.ensureConnectionIsInUse(id)
+
+    const currentConnection = this.connectionsInUse[id]
+
+    if (!currentConnection) {
+      throw new Error(`Couldn't get current connection from that ID: ${id}`)
+    }
+
+    return currentConnection
+  }
+
+  /**
+   * Runs current fallback connection or fail.
+   * @returns {import("../drivers/base.js").default} - Fallback connection, if present.
+   */
+  currentFallbackConnectionOrFail() {
+    const fallbackConnection = this.getGlobalConnection()
+
+    if (fallbackConnection) return fallbackConnection
+
+    throw new Error("ID hasn't been set for this async context")
+  }
+
+  /**
+   * Runs ensure connection is in use.
+   * @param {number} id - Checked-out connection id.
+   * @returns {void}
+   */
+  ensureConnectionIsInUse(id) {
+    if (!(id in this.connectionsInUse)) {
+      throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`)
+    }
+  }
+
+  /**
+   * Registers a fallback connection for this pool identifier that will be used when no async context is available.
+   * @param {import("../drivers/base.js").default} connection - Connection.
+   * @returns {void} - No return value.
+   */
+  setGlobalConnection(connection) {
+    const klass = /**
+                   * Narrows the runtime value to the documented type.
+                    @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor)
+    let mapForConfiguration = klass.globalConnections.get(this.configuration)
+
+    if (!mapForConfiguration) {
+      mapForConfiguration = {}
+      klass.globalConnections.set(this.configuration, mapForConfiguration)
+    }
+
+    mapForConfiguration[this.identifier] = connection
+  }
+
+  /**
+   * Ensures a global fallback connection exists for this pool identifier and returns it.
+   * If one is already set, it is returned and also made available in the pool queue.
+   * Otherwise a new connection is spawned, registered, and queued.
+   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the global connection.
+   */
+  async ensureGlobalConnection() {
+    const existing = this.getGlobalConnection()
+
+    if (existing) return existing
+
+    const connection = await this.spawnConnection()
+
+    this.setGlobalConnection(connection)
+
+    return connection
+  }
+
+  /**
+   * Set a shared connection for test mode so that HTTP handlers running
+   * in the same process can reuse the test runner's database connection.
+   * @param {import("../drivers/base.js").default} connection - Shared connection.
+   * @returns {void}
+   */
+  setTestSharedConnection(connection) {
+    this._testSharedConnection = connection
+  }
+
+  /**
+   * Runs clear test shared connection.
+    @returns {void} */
+  clearTestSharedConnection() {
+    this._testSharedConnection = undefined
+  }
+
+  /**
+   * Returns the connection tied to the current async context, if any.
+   * Falls back to the test shared connection when no async context exists.
+   * @returns {import("../drivers/base.js").default | undefined} - The current context connection.
+   */
+  getCurrentContextConnection() {
+    const id = this.asyncLocalStorage.getStore()
+
+    if (id === undefined) return this._testSharedConnection
+
+    return this.getCurrentConnection()
+  }
+
+  /**
+   * Runs get debug snapshot.
+   * @returns {import("./base.js").DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.
+   */
+  getDebugSnapshot() {
+    const snapshot = super.getDebugSnapshot()
+    const now = Date.now()
+    const {connections} = this.debugConnectionSnapshots(now)
+
+    return {
+      ...snapshot,
+      connections,
+      connectionsBeingSpawned: this.connectionsBeingSpawned,
+      idleCount: this.connections.length,
+      inUseCount: Object.keys(this.connectionsInUse).length,
+      pendingCheckouts: this.pendingCheckoutDebugSnapshots(now),
+      pendingCheckoutCount: this.pendingCheckouts.length
+    }
+  }
+
+  /**
+   * Runs debug connection snapshots.
+   * @param {number} now - Current timestamp.
+   * @returns {{connections: Array<Record<string, ?>>, seenConnections: Set<import("../drivers/base.js").default>}} - Connection snapshots and seen set.
+   */
+  debugConnectionSnapshots(now) {
     /**
      * Connections.
+      @type {Array<Record<string, ?>>} */
+    const connections = []
+    const seenConnections = new Set()
+
+    this.addInUseDebugConnectionSnapshots({connections, now, seenConnections})
+    this.addIdleDebugConnectionSnapshots({connections, now, seenConnections})
+    this.addFallbackDebugConnectionSnapshots({connections, seenConnections})
+
+    return {connections, seenConnections}
+  }
+
+  /**
+   * Runs add in use debug connection snapshots.
+   * @param {{connections: Array<Record<string, ?>>, now: number, seenConnections: Set<import("../drivers/base.js").default>}} args - Snapshot collection state.
+   * @returns {void}
+   */
+  addInUseDebugConnectionSnapshots({connections, now, seenConnections}) {
+    for (const [id, connection] of Object.entries(this.connectionsInUse)) {
+      const trackedConnection = /**
+                                 * Narrows the runtime value to the documented type.
+                                  @type {import("../drivers/base.js").default & {[CONNECTION_CHECKED_OUT_AT]?: number}} */ (connection)
+      const checkedOutAt = trackedConnection[CONNECTION_CHECKED_OUT_AT]
+      const checkedOutForMs = typeof checkedOutAt === "number" ? Math.max(0, now - checkedOutAt) : undefined
+
+      seenConnections.add(connection)
+      connections.push(this.debugConnectionSnapshot(connection, {checkedOutAt, checkedOutForMs, checkoutId: id, state: "in-use"}))
+    }
+  }
+
+  /**
+   * Runs add idle debug connection snapshots.
+   * @param {{connections: Array<Record<string, ?>>, now: number, seenConnections: Set<import("../drivers/base.js").default>}} args - Snapshot collection state.
+   * @returns {void}
+   */
+  addIdleDebugConnectionSnapshots({connections, now, seenConnections}) {
+    for (const connection of this.connections) {
+      if (seenConnections.has(connection)) continue
+
+      seenConnections.add(connection)
+
+      const trackedConnection = /**
+                                 * Narrows the runtime value to the documented type.
+                                  @type {import("../drivers/base.js").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
+      const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]
+      const idleForMs = typeof checkedInAt === "number" ? Math.max(0, now - checkedInAt) : undefined
+
+      connections.push(this.debugConnectionSnapshot(connection, {checkedInAt, idleForMs, state: "idle"}))
+    }
+  }
+
+  /**
+   * Runs add fallback debug connection snapshots.
+   * @param {{connections: Array<Record<string, ?>>, seenConnections: Set<import("../drivers/base.js").default>}} args - Snapshot collection state.
+   * @returns {void}
+   */
+  addFallbackDebugConnectionSnapshots({connections, seenConnections}) {
+    this.addDebugConnectionSnapshotIfUnseen({connection: this.getGlobalConnectionForIdentifier(), connections, reapable: false, seenConnections, state: "global"})
+    this.addDebugConnectionSnapshotIfUnseen({connection: this._testSharedConnection, connections, reapable: false, seenConnections, state: "test-shared"})
+  }
+
+  /**
+   * Runs add debug connection snapshot if unseen.
+   * @param {{connection: import("../drivers/base.js").default | undefined, connections: Array<Record<string, ?>>, reapable?: boolean, seenConnections: Set<import("../drivers/base.js").default>, state: string}} args - Snapshot collection state.
+   * @returns {void}
+   */
+  addDebugConnectionSnapshotIfUnseen({connection, connections, reapable, seenConnections, state}) {
+    if (!connection || seenConnections.has(connection)) return
+
+    seenConnections.add(connection)
+    connections.push(this.debugConnectionSnapshot(connection, {reapable, state}))
+  }
+
+  /**
+   * Runs pending checkout debug snapshots.
+   * @param {number} now - Current timestamp.
+   * @returns {Array<Record<string, ?>>} - Pending checkout snapshots.
+   */
+  pendingCheckoutDebugSnapshots(now) {
+    return this.pendingCheckouts.map((checkout, index) => ({
+      checkoutName: checkout.options.name,
+      enqueuedAt: checkout.enqueuedAt,
+      index,
+      reuseKey: checkout.reuseKey,
+      waitingForMs: Math.max(0, now - checkout.enqueuedAt)
+    }))
+  }
+
+  /**
+   * Runs get global connection.
+   * @returns {import("../drivers/base.js").default | undefined} - The global connection.
+   */
+  getGlobalConnection() {
+    const connection = this.getGlobalConnectionForIdentifier()
+
+    if (!connection) return
+    if (!this.connectionMatchesCurrentConfiguration(connection)) return
+
+    return connection
+  }
+
+  /**
+   * Runs get global connection for identifier.
+   * @returns {import("../drivers/base.js").default | undefined} - The global connection for this pool identifier.
+   */
+  getGlobalConnectionForIdentifier() {
+    const klass = /**
+                   * Narrows the runtime value to the documented type.
+                    @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor)
+    const mapForConfiguration = klass.globalConnections.get(this.configuration)
+
+    return mapForConfiguration?.[this.identifier]
+  }
+
+  /**
+   * Runs clear global connection for identifier.
+   * @returns {void} - No return value.
+   */
+  clearGlobalConnectionForIdentifier() {
+    const klass = /**
+                   * Narrows the runtime value to the documented type.
+                    @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor)
+    const mapForConfiguration = klass.globalConnections.get(this.configuration)
+
+    if (!mapForConfiguration) return
+
+    delete mapForConfiguration[this.identifier]
+  }
+
+  /**
+   * Clears schema metadata cached by every live connection owned by this pool.
+   * @returns {void} - No return value.
+   */
+  clearSchemaCache() {
+    const connections = new Set([
+      ...this.connections,
+      ...Object.values(this.connectionsInUse),
+      this.getGlobalConnection(),
+      this._testSharedConnection
+    ].filter(Boolean))
+
+    for (const connection of connections) {
+      if (connection) this._clearConnectionSchemaCache(connection)
+    }
+  }
+
+  /**
+   * Runs idle timeout millis.
+   * @returns {number | null} - Idle timeout in milliseconds, or null when disabled.
+   */
+  idleTimeoutMillis() {
+    const value = this.getConfiguration().pool?.idleTimeoutMillis
+
+    if (value === null) return null
+    if (this.validIdleTimeoutMillis(value)) return value
+
+    return DEFAULT_IDLE_TIMEOUT_MILLIS
+  }
+
+  /**
+   * Runs valid idle timeout millis.
+   * @param {?} value - Candidate idle timeout value.
+   * @returns {value is number} - Whether the value is a valid idle timeout.
+   */
+  validIdleTimeoutMillis(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+  }
+
+  /**
+   * Runs schedule idle connection reaper.
+    @returns {void} */
+  scheduleIdleConnectionReaper() {
+    if (this.idleConnectionReaperTimer) return
+    if (!this.hasIdleConnectionsToReap()) return
+
+    const delay = this.nextIdleConnectionReapDelay(/**
+                                                    * Narrows the runtime value to the documented type.
+                                                     @type {number} */ (this.idleTimeoutMillis()))
+
+    this.idleConnectionReaperTimer = setTimeout(() => {
+      this.idleConnectionReaperTimer = undefined
+      void this.reapIdleConnections().catch((error) => {
+        this.logger.warn(() => ["Failed to reap idle database connections:", error])
+      })
+    }, delay)
+
+    if (typeof this.idleConnectionReaperTimer.unref === "function") {
+      this.idleConnectionReaperTimer.unref()
+    }
+  }
+
+  /**
+   * Runs has idle connections to reap.
+   * @returns {boolean} - Whether an idle reaper timer should be scheduled.
+   */
+  hasIdleConnectionsToReap() {
+    return this.connections.length > 0 && this.idleTimeoutMillis() !== null
+  }
+
+  /**
+   * Runs next idle connection reap delay.
+   * @param {number} idleTimeoutMillis - Idle timeout in milliseconds.
+   * @returns {number} - Delay before the next reap.
+   */
+  nextIdleConnectionReapDelay(idleTimeoutMillis) {
+    let delay = idleTimeoutMillis
+    const now = Date.now()
+
+    for (const connection of this.connections) {
+      if (this.connectionHasOpenTransaction(connection)) continue
+
+      const trackedConnection = /**
+                                 * Narrows the runtime value to the documented type.
+                                  @type {import("../drivers/base.js").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
+      const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]
+
+      if (typeof checkedInAt !== "number") continue
+
+      delay = Math.min(delay, Math.max(0, idleTimeoutMillis - (now - checkedInAt)))
+    }
+
+    return delay
+  }
+
+  /**
+   * Closes idle checked-in connections that have exceeded the configured timeout.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async reapIdleConnections() {
+    if (this.connections.length === 0) return
+
+    const idleTimeoutMillis = this.idleTimeoutMillis()
+
+    if (idleTimeoutMillis === null) return
+
+    const {expiredConnections, keptConnections} = this.classifyIdleConnectionsForReaping({idleTimeoutMillis, now: Date.now()})
+
+    this.connections = keptConnections
+    await this.closeExpiredIdleConnections(expiredConnections)
+    await this.awaitInflightConnectionCloses()
+    if (this.connections.length > 0) this.scheduleIdleConnectionReaper()
+  }
+
+  /**
+   * Runs close expired idle connections.
+   * @param {import("../drivers/base.js").default[]} expiredConnections - Connections to close.
+   * @returns {Promise<void>} - Resolves when closed.
+   */
+  async closeExpiredIdleConnections(expiredConnections) {
+    for (const connection of expiredConnections) {
+      await this.closeConnection(connection)
+    }
+  }
+
+  /**
+   * Runs await inflight connection closes.
+   * @returns {Promise<void>} - Resolves once in-flight connection closes settle.
+   */
+  async awaitInflightConnectionCloses() {
+    if (this.inflightConnectionCloses.size > 0) {
+      await Promise.allSettled([...this.inflightConnectionCloses])
+    }
+  }
+
+  /**
+   * Runs classify idle connections for reaping.
+   * @param {{idleTimeoutMillis: number, now: number}} args - Reaper classification inputs.
+   * @returns {{expiredConnections: import("../drivers/base.js").default[], keptConnections: import("../drivers/base.js").default[]}} - Classified idle connections.
+   */
+  classifyIdleConnectionsForReaping({idleTimeoutMillis, now}) {
+    /**
+     * Kept connections.
       @type {import("../drivers/base.js").default[]} */
-    connections = [];
-    /**
-     * Connections in use.
-      @type {Record<number, import("../drivers/base.js").default>} */
-    connectionsInUse = {};
-    /**
-     * Pending checkouts.
-      @type {PendingCheckout[]} */
-    pendingCheckouts = [];
-    /**
-     * Connections being spawned.
-      @type {number} */
-    connectionsBeingSpawned = 0;
-    /**
-     * Pending checkout drain promise.
-      @type {Promise<void> | undefined} */
-    pendingCheckoutDrainPromise = undefined;
-    /**
-     * Idle connection reaper timer.
-      @type {ReturnType<typeof setTimeout> | undefined} */
-    idleConnectionReaperTimer = undefined;
-    /**
-     * In-flight connection-close promises. The idle reaper is armed on check-in
-     * and runs fire-and-forget when its timer fires, so a scheduled reap can be
-     * closing a connection while an explicit `reapIdleConnections()` (or
-     * `clearIdleConnectionReaperTimer()`) runs. Tracking the in-flight closes lets
-     * those callers await them, so once a reap resolves the connections it
-     * expired are fully closed instead of half-closed mid-`close()`.
-     * @type {Set<Promise<void>>}
-     */
-    inflightConnectionCloses = new Set();
-    /**
-     * In-flight close promise per connection, so concurrent closes of the same
-     * connection await the same close rather than closing the driver handle twice.
-     * @type {WeakMap<object, Promise<void>>}
-     */
-    connectionClosePromises = new WeakMap();
-    idSeq = 0;
-    /**
-     * Runs constructor.
-     * @param {object} args - Options object.
-     * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
-     * @param {string} args.identifier - Identifier.
-     */
-    constructor({ configuration, identifier }) {
-        super({ configuration, identifier });
-        this._withoutCurrentConnectionContext = /**
-                                                 * Narrows the runtime value to the documented type.
-                                                  @type {(callback: () => ?) => ?} */
-            ((callback) => this.asyncLocalStorage.run(undefined, callback));
-    }
-    /**
-     * Runs checkin.
-     * @param {import("../drivers/base.js").default} connection - Database connection instance.
-     * @returns {Promise<void>} - Resolves when the connection is checked in or closed.
-     */
-    async checkin(connection) {
-        const id = connection.getIdSeq();
-        const trackedConnection = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection);
-        if (trackedConnection[CLOSED_CONNECTION]) {
-            this.untrackConnectionInUse(connection, id);
-            await this.drainPendingCheckouts();
-            return;
-        }
-        try {
-            await this.rollbackLeftOpenTransaction(connection);
-            await connection.clearConnectionCheckoutName();
-        }
-        catch (error) {
-            await this.closeCheckedOutConnectionAfterCheckinFailure(connection, id, error);
-            throw error;
-        }
-        this.untrackConnectionInUse(connection, id);
-        trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT] = Date.now();
-        delete trackedConnection[CONNECTION_CHECKED_OUT_AT];
-        this.connections.push(connection);
-        await this.drainPendingCheckouts();
-        if (this.connections.includes(connection))
-            await this.handleCheckedInIdleConnection();
-    }
-    /**
-     * Runs close checked out connection after checkin failure.
-     * @param {import("../drivers/base.js").default} connection - Connection that failed check-in cleanup.
-     * @param {number | undefined} id - Connection checkout id.
-     * @param {?} originalError - Error that caused check-in cleanup to fail.
-     * @returns {Promise<void>} - Resolves when cleanup has been attempted.
-     */
-    async closeCheckedOutConnectionAfterCheckinFailure(connection, id, originalError) {
-        this.untrackConnectionInUse(connection, id);
-        try {
-            await this.closeConnection(connection);
-        }
-        catch (error) {
-            this.logger.warn("Failed to close database connection after check-in cleanup failed", { error, originalError });
-        }
-        try {
-            await this.drainPendingCheckouts();
-        }
-        catch (error) {
-            this.logger.warn("Failed to drain pending database checkouts after check-in cleanup failed", { error, originalError });
-        }
-    }
-    /**
-     * Runs untrack connection in use.
-     * @param {import("../drivers/base.js").default} connection - Connection being checked in.
-     * @param {number | undefined} id - Connection checkout id.
-     * @returns {void}
-     */
-    untrackConnectionInUse(connection, id) {
-        if (typeof id !== "number") {
-            throw new Error(`idSeq on connection wasn't set? '${typeof id}' = ${id}`);
-        }
-        delete this.connectionsInUse[id];
-        connection.setIdSeq(undefined);
-    }
-    /**
-     * Runs handle checked in idle connection.
-     * @returns {Promise<void>} - Resolves once idle reaping has been scheduled or run.
-     */
-    async handleCheckedInIdleConnection() {
-        if (this.idleTimeoutMillis() === 0) {
-            await this.reapIdleConnections();
-        }
-        else {
-            this.scheduleIdleConnectionReaper();
-        }
-    }
-    /**
-     * Runs checkout.
-     * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
-     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
-     */
-    async checkout(options = {}) {
-        const databaseConfig = this.getConfiguration();
-        const reuseKey = this.getConfigurationReuseKey();
-        let connection = this.takeIdleConnectionForReuseKey(reuseKey);
-        if (connection)
-            return await this.activateConnection(connection, options);
-        await this.reapIdleConnections();
-        connection = this.takeIdleConnectionForReuseKey(reuseKey);
-        if (connection)
-            return await this.activateConnection(connection, options);
-        if (this.canSpawnConnection()) {
-            // Spawn via spawnConnection() so the tenant-aware configuration is resolved FRESH at
-            // spawn time for the current caller. Reusing the databaseConfig captured at the top of
-            // checkout() could bind the connection to a stale tenant/database, which breaks
-            // per-request isolation (e.g. test truncation appearing not to take effect). The queued
-            // path below keeps the waiting caller's captured config via waitForCheckout().
-            connection = await this.spawnConnectionForCheckout(this.getConfiguration(), this.getConfigurationReuseKey());
-            return await this.activateConnection(connection, options);
-        }
-        return await this.waitForCheckout(databaseConfig, reuseKey, options);
-    }
-    /**
-     * Runs take idle connection for reuse key.
-     * @param {string} reuseKey - Database configuration reuse key.
-     * @param {object} [args] - Options.
-     * @param {boolean} [args.includeOpenTransactions] - Whether connections with open transactions may be returned.
-     * @returns {import("../drivers/base.js").default | undefined} - Matching idle connection.
-     */
-    takeIdleConnectionForReuseKey(reuseKey, { includeOpenTransactions = true } = {}) {
-        const connectionIndex = this.connections.findIndex((queuedConnection) => {
-            if (!includeOpenTransactions && this.connectionHasOpenTransaction(queuedConnection))
-                return false;
-            return this.connectionMatchesReuseKey(queuedConnection, reuseKey);
-        });
-        const connection = connectionIndex === -1 ? undefined : this.connections.splice(connectionIndex, 1)[0];
-        return connection;
-    }
-    /**
-     * Runs connection matches reuse key.
-     * @param {import("../drivers/base.js").default} connection - Connection.
-     * @param {string} reuseKey - Database configuration reuse key.
-     * @returns {boolean} - Whether the connection matches the reuse key.
-     */
-    connectionMatchesReuseKey(connection, reuseKey) {
-        const connectionWithPoolKey = /**
-                                       * Narrows the runtime value to the documented type.
-                                        @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
-        return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === reuseKey;
-    }
-    /**
-     * Runs activate connection.
-     * @param {import("../drivers/base.js").default} connection - Connection.
-     * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
-     * @returns {Promise<import("../drivers/base.js").default>} - Activated connection.
-     */
-    async activateConnection(connection, options = {}) {
-        if (connection.getIdSeq() !== undefined)
-            throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`);
-        const id = this.idSeq++;
-        const trackedConnection = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection);
-        delete trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT];
-        trackedConnection[CONNECTION_CHECKED_OUT_AT] = Date.now();
-        connection.setIdSeq(id);
-        this.connectionsInUse[id] = connection;
-        try {
-            await connection.setConnectionCheckoutName(options.name);
-        }
-        catch (error) {
-            delete this.connectionsInUse[id];
-            connection.setIdSeq(undefined);
-            await this.closeConnection(connection);
-            throw error;
-        }
-        return connection;
-    }
-    /**
-     * Runs max connections.
-     * @returns {number | undefined} - Configured max live connections.
-     */
-    maxConnections() {
-        const value = this.getConfiguration().pool?.max;
-        if (this.validMaxConnections(value))
-            return value;
-        return;
-    }
-    /**
-     * Runs valid max connections.
-     * @param {?} value - Candidate max connection count.
-     * @returns {value is number} - Whether the value is a valid max connection count.
-     */
-    validMaxConnections(value) {
-        return typeof value === "number" && Number.isFinite(value) && value >= 1;
-    }
-    /**
-     * Runs live connection count.
-     * @returns {number} - Number of live and in-progress connections.
-     */
-    liveConnectionCount() {
-        const connections = new Set([
-            ...this.connections,
-            ...Object.values(this.connectionsInUse),
-            this.getGlobalConnectionForIdentifier()
-        ].filter(Boolean));
-        return connections.size + this.connectionsBeingSpawned;
-    }
-    /**
-     * Runs can spawn connection.
-     * @returns {boolean} - Whether a new connection can be spawned.
-     */
-    canSpawnConnection() {
-        const maxConnections = this.maxConnections();
-        return maxConnections === undefined || this.liveConnectionCount() < maxConnections;
-    }
-    /**
-     * Runs spawn connection for checkout.
-     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.
-     * @param {string} reuseKey - Database configuration reuse key for the checkout.
-     * @returns {Promise<import("../drivers/base.js").default>} - Spawned connection.
-     */
-    async spawnConnectionForCheckout(databaseConfig, reuseKey) {
-        this.connectionsBeingSpawned++;
-        try {
-            const connection = await this.spawnConnectionWithConfiguration(databaseConfig);
-            const connectionWithPoolKey = /**
-                                           * Narrows the runtime value to the documented type.
-                                            @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
-            connectionWithPoolKey[POOL_CONFIGURATION_KEY] = reuseKey;
-            connection.setSchemaCacheInvalidator(() => {
-                this.clearSchemaCache();
-                this.configuration.clearSchemaCachesForReuseKey(reuseKey);
-            });
-            return connection;
-        }
-        finally {
-            this.connectionsBeingSpawned--;
-        }
-    }
-    /**
-     * Runs wait for checkout.
-     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.
-     * @param {string} reuseKey - Database configuration reuse key.
-     * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
-     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with an activated connection.
-     */
-    async waitForCheckout(databaseConfig, reuseKey, options = {}) {
-        return await new Promise((resolve, reject) => {
-            this.pendingCheckouts.push({ databaseConfig, enqueuedAt: Date.now(), options, reject, resolve, reuseKey });
-            void this.drainPendingCheckouts().catch((error) => {
-                const checkoutError = error instanceof Error ? error : new Error("Failed to drain pending database connection checkouts.", { cause: error });
-                this.rejectPendingCheckouts(checkoutError);
-            });
-        });
-    }
-    /**
-     * Runs drain pending checkouts.
-     * @returns {Promise<void>} - Resolves when pending checkouts have been drained as far as possible.
-     */
-    async drainPendingCheckouts() {
-        if (this.pendingCheckoutDrainPromise) {
-            await this.pendingCheckoutDrainPromise;
-            return;
-        }
-        this.pendingCheckoutDrainPromise = this.drainPendingCheckoutsActual();
-        try {
-            await this.pendingCheckoutDrainPromise;
-        }
-        finally {
-            this.pendingCheckoutDrainPromise = undefined;
-        }
-    }
-    /**
-     * Runs drain pending checkouts actual.
-     * @returns {Promise<void>} - Resolves when pending checkouts have been drained as far as possible.
-     */
-    async drainPendingCheckoutsActual() {
-        while (this.pendingCheckouts.length > 0) {
-            if (await this.resolvePendingCheckoutWithMatchingIdleConnection())
-                continue;
-            const checkout = this.pendingCheckouts[0];
-            if (await this.closeIdleConnectionForPendingCheckoutCapacity(checkout))
-                continue;
-            if (this.canSpawnConnection()) {
-                this.pendingCheckouts.shift();
-                await this.spawnAndResolvePendingCheckout(checkout);
-                continue;
-            }
-            const reapedConnection = await this.idleConnectionForPendingCheckout(checkout);
-            if (!reapedConnection)
-                return;
-            this.pendingCheckouts.shift();
-            await this.resolvePendingCheckout(checkout, reapedConnection);
-        }
-    }
-    /**
-     * Runs resolve pending checkout with matching idle connection.
-     * @returns {Promise<boolean>} - Whether a pending checkout was resolved with an idle connection.
-     */
-    async resolvePendingCheckoutWithMatchingIdleConnection() {
-        for (let index = 0; index < this.pendingCheckouts.length; index++) {
-            const checkout = this.pendingCheckouts[index];
-            const connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, { includeOpenTransactions: false });
-            if (!connection)
-                continue;
-            this.pendingCheckouts.splice(index, 1);
-            await this.resolvePendingCheckout(checkout, connection);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Runs close idle connection for pending checkout capacity.
-     * @param {PendingCheckout} checkout - Checkout waiting for a connection.
-     * @returns {Promise<boolean>} - Whether an idle connection was closed to free capacity.
-     */
-    async closeIdleConnectionForPendingCheckoutCapacity(checkout) {
-        const connection = this.findIdleConnectionForReuseKey(checkout.reuseKey);
-        if (connection)
-            return false;
-        await this.reapIdleConnections();
-        if (this.findIdleConnectionForReuseKey(checkout.reuseKey))
-            return false;
-        return this.canSpawnConnection() ? false : await this.closeOneIdleConnectionForCapacity();
-    }
-    /**
-     * Runs find idle connection for reuse key.
-     * @param {string} reuseKey - Database configuration reuse key.
-     * @returns {import("../drivers/base.js").default | undefined} - Matching idle connection, if present.
-     */
-    findIdleConnectionForReuseKey(reuseKey) {
-        return this.connections.find((connection) => !this.connectionHasOpenTransaction(connection) && this.connectionMatchesReuseKey(connection, reuseKey));
-    }
-    /**
-     * Runs idle connection for pending checkout.
-     * @param {PendingCheckout} checkout - Checkout waiting for a connection.
-     * @returns {Promise<import("../drivers/base.js").default | undefined>} - Matching idle connection, if one can be reused.
-     */
-    async idleConnectionForPendingCheckout(checkout) {
-        let connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, { includeOpenTransactions: false });
-        if (connection)
-            return connection;
-        await this.reapIdleConnections();
-        connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, { includeOpenTransactions: false });
-        return connection;
-    }
-    /**
-     * Runs spawn and resolve pending checkout.
-     * @param {PendingCheckout} checkout - Checkout request to resolve.
-     * @returns {Promise<void>} - Resolves when the checkout has been handled.
-     */
-    async spawnAndResolvePendingCheckout(checkout) {
-        let connection;
-        try {
-            connection = await this.spawnConnectionForCheckout(checkout.databaseConfig, checkout.reuseKey);
-        }
-        catch (error) {
-            checkout.reject(error instanceof Error ? error : new Error("Failed to spawn database connection.", { cause: error }));
-            return;
-        }
-        await this.resolvePendingCheckout(checkout, connection);
-    }
-    /**
-     * Runs resolve pending checkout.
-     * @param {PendingCheckout} checkout - Checkout request to resolve.
-     * @param {import("../drivers/base.js").default} connection - Connection to activate.
-     * @returns {Promise<void>} - Resolves when the checkout has been handled.
-     */
-    async resolvePendingCheckout(checkout, connection) {
-        try {
-            checkout.resolve(await this.activateConnection(connection, checkout.options));
-        }
-        catch (error) {
-            checkout.reject(error instanceof Error ? error : new Error("Failed to activate database connection.", { cause: error }));
-        }
-    }
-    /**
-     * Runs close one idle connection for capacity.
-     * @returns {Promise<boolean>} - Whether an idle connection was closed to free capacity.
-     */
-    async closeOneIdleConnectionForCapacity() {
-        const connection = this.connections.find((candidate) => !this.connectionHasOpenTransaction(candidate));
-        if (!connection)
-            return false;
-        this.connections = this.connections.filter((candidate) => candidate !== connection);
-        await this.closeConnection(connection);
-        return true;
-    }
-    /**
-     * Runs with connection.
-     * @template T
-     * @param {import("./base.js").ConnectionCheckoutOptions | function(import("../drivers/base.js").default) : Promise<T>} optionsOrCallback - Checkout options or callback to invoke with the connection.
-     * @param {function(import("../drivers/base.js").default) : Promise<T>} [callback] - Callback to invoke with the connection.
-     * @returns {Promise<T>} - Resolves with the callback result.
-     */
-    async withConnection(optionsOrCallback, callback) {
-        const options = typeof optionsOrCallback == "function" ? {} : optionsOrCallback;
-        const actualCallback = typeof optionsOrCallback == "function" ? optionsOrCallback : callback;
-        if (!actualCallback)
-            throw new Error("withConnection requires a callback");
-        const connection = await this.checkout(options);
-        const id = connection.getIdSeq();
-        return await this.asyncLocalStorage.run(id, async () => {
-            try {
-                return await actualCallback(connection);
-            }
-            finally {
-                await this.checkin(connection);
-            }
-        });
-    }
-    /**
-     * Runs get current connection.
-     * @returns {import("../drivers/base.js").default} - The current connection.
-     */
-    getCurrentConnection() {
-        const id = this.asyncLocalStorage.getStore();
-        if (id === undefined)
-            return this.currentFallbackConnectionOrFail();
-        this.ensureConnectionIsInUse(id);
-        const currentConnection = this.connectionsInUse[id];
-        if (!currentConnection) {
-            throw new Error(`Couldn't get current connection from that ID: ${id}`);
-        }
-        return currentConnection;
-    }
-    /**
-     * Runs current fallback connection or fail.
-     * @returns {import("../drivers/base.js").default} - Fallback connection, if present.
-     */
-    currentFallbackConnectionOrFail() {
-        const fallbackConnection = this.getGlobalConnection();
-        if (fallbackConnection)
-            return fallbackConnection;
-        throw new Error("ID hasn't been set for this async context");
-    }
-    /**
-     * Runs ensure connection is in use.
-     * @param {number} id - Checked-out connection id.
-     * @returns {void}
-     */
-    ensureConnectionIsInUse(id) {
-        if (!(id in this.connectionsInUse)) {
-            throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`);
-        }
-    }
-    /**
-     * Registers a fallback connection for this pool identifier that will be used when no async context is available.
-     * @param {import("../drivers/base.js").default} connection - Connection.
-     * @returns {void} - No return value.
-     */
-    setGlobalConnection(connection) {
-        const klass = /**
-                       * Narrows the runtime value to the documented type.
-                        @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor);
-        let mapForConfiguration = klass.globalConnections.get(this.configuration);
-        if (!mapForConfiguration) {
-            mapForConfiguration = {};
-            klass.globalConnections.set(this.configuration, mapForConfiguration);
-        }
-        mapForConfiguration[this.identifier] = connection;
-    }
-    /**
-     * Ensures a global fallback connection exists for this pool identifier and returns it.
-     * If one is already set, it is returned and also made available in the pool queue.
-     * Otherwise a new connection is spawned, registered, and queued.
-     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the global connection.
-     */
-    async ensureGlobalConnection() {
-        const existing = this.getGlobalConnection();
-        if (existing)
-            return existing;
-        const connection = await this.spawnConnection();
-        this.setGlobalConnection(connection);
-        return connection;
-    }
+    const keptConnections = []
     /**
-     * Set a shared connection for test mode so that HTTP handlers running
-     * in the same process can reuse the test runner's database connection.
-     * @param {import("../drivers/base.js").default} connection - Shared connection.
-     * @returns {void}
-     */
-    setTestSharedConnection(connection) {
-        this._testSharedConnection = connection;
-    }
-    /**
-     * Runs clear test shared connection.
-      @returns {void} */
-    clearTestSharedConnection() {
-        this._testSharedConnection = undefined;
-    }
-    /**
-     * Returns the connection tied to the current async context, if any.
-     * Falls back to the test shared connection when no async context exists.
-     * @returns {import("../drivers/base.js").default | undefined} - The current context connection.
-     */
-    getCurrentContextConnection() {
-        const id = this.asyncLocalStorage.getStore();
-        if (id === undefined)
-            return this._testSharedConnection;
-        return this.getCurrentConnection();
-    }
-    /**
-     * Runs get debug snapshot.
-     * @returns {import("./base.js").DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.
-     */
-    getDebugSnapshot() {
-        const snapshot = super.getDebugSnapshot();
-        const now = Date.now();
-        const { connections } = this.debugConnectionSnapshots(now);
-        return {
-            ...snapshot,
-            connections,
-            connectionsBeingSpawned: this.connectionsBeingSpawned,
-            idleCount: this.connections.length,
-            inUseCount: Object.keys(this.connectionsInUse).length,
-            pendingCheckouts: this.pendingCheckoutDebugSnapshots(now),
-            pendingCheckoutCount: this.pendingCheckouts.length
-        };
-    }
-    /**
-     * Runs debug connection snapshots.
-     * @param {number} now - Current timestamp.
-     * @returns {{connections: Array<Record<string, ?>>, seenConnections: Set<import("../drivers/base.js").default>}} - Connection snapshots and seen set.
-     */
-    debugConnectionSnapshots(now) {
-        /**
-         * Connections.
-          @type {Array<Record<string, ?>>} */
-        const connections = [];
-        const seenConnections = new Set();
-        this.addInUseDebugConnectionSnapshots({ connections, now, seenConnections });
-        this.addIdleDebugConnectionSnapshots({ connections, now, seenConnections });
-        this.addFallbackDebugConnectionSnapshots({ connections, seenConnections });
-        return { connections, seenConnections };
-    }
-    /**
-     * Runs add in use debug connection snapshots.
-     * @param {{connections: Array<Record<string, ?>>, now: number, seenConnections: Set<import("../drivers/base.js").default>}} args - Snapshot collection state.
-     * @returns {void}
-     */
-    addInUseDebugConnectionSnapshots({ connections, now, seenConnections }) {
-        for (const [id, connection] of Object.entries(this.connectionsInUse)) {
-            const trackedConnection = /**
-                                       * Narrows the runtime value to the documented type.
-                                        @type {import("../drivers/base.js").default & {[CONNECTION_CHECKED_OUT_AT]?: number}} */ (connection);
-            const checkedOutAt = trackedConnection[CONNECTION_CHECKED_OUT_AT];
-            const checkedOutForMs = typeof checkedOutAt === "number" ? Math.max(0, now - checkedOutAt) : undefined;
-            seenConnections.add(connection);
-            connections.push(this.debugConnectionSnapshot(connection, { checkedOutAt, checkedOutForMs, checkoutId: id, state: "in-use" }));
-        }
-    }
-    /**
-     * Runs add idle debug connection snapshots.
-     * @param {{connections: Array<Record<string, ?>>, now: number, seenConnections: Set<import("../drivers/base.js").default>}} args - Snapshot collection state.
-     * @returns {void}
-     */
-    addIdleDebugConnectionSnapshots({ connections, now, seenConnections }) {
-        for (const connection of this.connections) {
-            if (seenConnections.has(connection))
-                continue;
-            seenConnections.add(connection);
-            const trackedConnection = /**
-                                       * Narrows the runtime value to the documented type.
-                                        @type {import("../drivers/base.js").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection);
-            const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT];
-            const idleForMs = typeof checkedInAt === "number" ? Math.max(0, now - checkedInAt) : undefined;
-            connections.push(this.debugConnectionSnapshot(connection, { checkedInAt, idleForMs, state: "idle" }));
-        }
-    }
-    /**
-     * Runs add fallback debug connection snapshots.
-     * @param {{connections: Array<Record<string, ?>>, seenConnections: Set<import("../drivers/base.js").default>}} args - Snapshot collection state.
-     * @returns {void}
-     */
-    addFallbackDebugConnectionSnapshots({ connections, seenConnections }) {
-        this.addDebugConnectionSnapshotIfUnseen({ connection: this.getGlobalConnectionForIdentifier(), connections, reapable: false, seenConnections, state: "global" });
-        this.addDebugConnectionSnapshotIfUnseen({ connection: this._testSharedConnection, connections, reapable: false, seenConnections, state: "test-shared" });
-    }
-    /**
-     * Runs add debug connection snapshot if unseen.
-     * @param {{connection: import("../drivers/base.js").default | undefined, connections: Array<Record<string, ?>>, reapable?: boolean, seenConnections: Set<import("../drivers/base.js").default>, state: string}} args - Snapshot collection state.
-     * @returns {void}
-     */
-    addDebugConnectionSnapshotIfUnseen({ connection, connections, reapable, seenConnections, state }) {
-        if (!connection || seenConnections.has(connection))
-            return;
-        seenConnections.add(connection);
-        connections.push(this.debugConnectionSnapshot(connection, { reapable, state }));
-    }
-    /**
-     * Runs pending checkout debug snapshots.
-     * @param {number} now - Current timestamp.
-     * @returns {Array<Record<string, ?>>} - Pending checkout snapshots.
-     */
-    pendingCheckoutDebugSnapshots(now) {
-        return this.pendingCheckouts.map((checkout, index) => ({
-            checkoutName: checkout.options.name,
-            enqueuedAt: checkout.enqueuedAt,
-            index,
-            reuseKey: checkout.reuseKey,
-            waitingForMs: Math.max(0, now - checkout.enqueuedAt)
-        }));
-    }
-    /**
-     * Runs get global connection.
-     * @returns {import("../drivers/base.js").default | undefined} - The global connection.
-     */
-    getGlobalConnection() {
-        const connection = this.getGlobalConnectionForIdentifier();
-        if (!connection)
-            return;
-        if (!this.connectionMatchesCurrentConfiguration(connection))
-            return;
-        return connection;
-    }
-    /**
-     * Runs get global connection for identifier.
-     * @returns {import("../drivers/base.js").default | undefined} - The global connection for this pool identifier.
-     */
-    getGlobalConnectionForIdentifier() {
-        const klass = /**
-                       * Narrows the runtime value to the documented type.
-                        @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor);
-        const mapForConfiguration = klass.globalConnections.get(this.configuration);
-        return mapForConfiguration?.[this.identifier];
-    }
-    /**
-     * Runs clear global connection for identifier.
-     * @returns {void} - No return value.
-     */
-    clearGlobalConnectionForIdentifier() {
-        const klass = /**
-                       * Narrows the runtime value to the documented type.
-                        @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor);
-        const mapForConfiguration = klass.globalConnections.get(this.configuration);
-        if (!mapForConfiguration)
-            return;
-        delete mapForConfiguration[this.identifier];
-    }
-    /**
-     * Clears schema metadata cached by every live connection owned by this pool.
-     * @returns {void} - No return value.
-     */
-    clearSchemaCache() {
-        const connections = new Set([
-            ...this.connections,
-            ...Object.values(this.connectionsInUse),
-            this.getGlobalConnection(),
-            this._testSharedConnection
-        ].filter(Boolean));
-        for (const connection of connections) {
-            if (connection)
-                this._clearConnectionSchemaCache(connection);
-        }
-    }
-    /**
-     * Runs idle timeout millis.
-     * @returns {number | null} - Idle timeout in milliseconds, or null when disabled.
-     */
-    idleTimeoutMillis() {
-        const value = this.getConfiguration().pool?.idleTimeoutMillis;
-        if (value === null)
-            return null;
-        if (this.validIdleTimeoutMillis(value))
-            return value;
-        return DEFAULT_IDLE_TIMEOUT_MILLIS;
-    }
-    /**
-     * Runs valid idle timeout millis.
-     * @param {?} value - Candidate idle timeout value.
-     * @returns {value is number} - Whether the value is a valid idle timeout.
-     */
-    validIdleTimeoutMillis(value) {
-        return typeof value === "number" && Number.isFinite(value) && value >= 0;
-    }
-    /**
-     * Runs schedule idle connection reaper.
-      @returns {void} */
-    scheduleIdleConnectionReaper() {
-        if (this.idleConnectionReaperTimer)
-            return;
-        if (!this.hasIdleConnectionsToReap())
-            return;
-        const delay = this.nextIdleConnectionReapDelay(/**
-                                                        * Narrows the runtime value to the documented type.
-                                                         @type {number} */ (this.idleTimeoutMillis()));
-        this.idleConnectionReaperTimer = setTimeout(() => {
-            this.idleConnectionReaperTimer = undefined;
-            void this.reapIdleConnections().catch((error) => {
-                this.logger.warn(() => ["Failed to reap idle database connections:", error]);
-            });
-        }, delay);
-        if (typeof this.idleConnectionReaperTimer.unref === "function") {
-            this.idleConnectionReaperTimer.unref();
-        }
-    }
-    /**
-     * Runs has idle connections to reap.
-     * @returns {boolean} - Whether an idle reaper timer should be scheduled.
-     */
-    hasIdleConnectionsToReap() {
-        return this.connections.length > 0 && this.idleTimeoutMillis() !== null;
-    }
-    /**
-     * Runs next idle connection reap delay.
-     * @param {number} idleTimeoutMillis - Idle timeout in milliseconds.
-     * @returns {number} - Delay before the next reap.
-     */
-    nextIdleConnectionReapDelay(idleTimeoutMillis) {
-        let delay = idleTimeoutMillis;
-        const now = Date.now();
-        for (const connection of this.connections) {
-            if (this.connectionHasOpenTransaction(connection))
-                continue;
-            const trackedConnection = /**
-                                       * Narrows the runtime value to the documented type.
-                                        @type {import("../drivers/base.js").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection);
-            const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT];
-            if (typeof checkedInAt !== "number")
-                continue;
-            delay = Math.min(delay, Math.max(0, idleTimeoutMillis - (now - checkedInAt)));
-        }
-        return delay;
-    }
-    /**
-     * Closes idle checked-in connections that have exceeded the configured timeout.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async reapIdleConnections() {
-        if (this.connections.length === 0)
-            return;
-        const idleTimeoutMillis = this.idleTimeoutMillis();
-        if (idleTimeoutMillis === null)
-            return;
-        const { expiredConnections, keptConnections } = this.classifyIdleConnectionsForReaping({ idleTimeoutMillis, now: Date.now() });
-        this.connections = keptConnections;
-        await this.closeExpiredIdleConnections(expiredConnections);
-        await this.awaitInflightConnectionCloses();
-        if (this.connections.length > 0)
-            this.scheduleIdleConnectionReaper();
-    }
-    /**
-     * Runs close expired idle connections.
-     * @param {import("../drivers/base.js").default[]} expiredConnections - Connections to close.
-     * @returns {Promise<void>} - Resolves when closed.
-     */
-    async closeExpiredIdleConnections(expiredConnections) {
-        for (const connection of expiredConnections) {
-            await this.closeConnection(connection);
-        }
-    }
-    /**
-     * Runs await inflight connection closes.
-     * @returns {Promise<void>} - Resolves once in-flight connection closes settle.
-     */
-    async awaitInflightConnectionCloses() {
-        if (this.inflightConnectionCloses.size > 0) {
-            await Promise.allSettled([...this.inflightConnectionCloses]);
-        }
-    }
-    /**
-     * Runs classify idle connections for reaping.
-     * @param {{idleTimeoutMillis: number, now: number}} args - Reaper classification inputs.
-     * @returns {{expiredConnections: import("../drivers/base.js").default[], keptConnections: import("../drivers/base.js").default[]}} - Classified idle connections.
-     */
-    classifyIdleConnectionsForReaping({ idleTimeoutMillis, now }) {
-        /**
-         * Kept connections.
-          @type {import("../drivers/base.js").default[]} */
-        const keptConnections = [];
-        /**
-         * Expired connections.
-          @type {import("../drivers/base.js").default[]} */
-        const expiredConnections = [];
-        for (const connection of this.connections) {
-            this.classifyIdleConnectionForReaping({ connection, expiredConnections, idleTimeoutMillis, keptConnections, now });
-        }
-        return { expiredConnections, keptConnections };
-    }
-    /**
-     * Runs classify idle connection for reaping.
-     * @param {{connection: import("../drivers/base.js").default, expiredConnections: import("../drivers/base.js").default[], idleTimeoutMillis: number, keptConnections: import("../drivers/base.js").default[], now: number}} args - Classification state.
-     * @returns {void}
-     */
-    classifyIdleConnectionForReaping({ connection, expiredConnections, idleTimeoutMillis, keptConnections, now }) {
-        if (this.connectionIsClosed(connection))
-            return;
-        if (this.connectionHasOpenTransaction(connection)) {
-            keptConnections.push(connection);
-            return;
-        }
-        const target = this.idleConnectionExpired({ connection, idleTimeoutMillis, now }) ? expiredConnections : keptConnections;
-        target.push(connection);
-    }
-    /**
-     * Runs connection is closed.
-     * @param {import("../drivers/base.js").default} connection - Connection to inspect.
-     * @returns {boolean} - Whether the connection is marked closed.
-     */
-    connectionIsClosed(connection) {
-        const trackedConnection = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean}} */ (connection);
-        return Boolean(trackedConnection[CLOSED_CONNECTION]);
-    }
-    /**
-     * Runs idle connection expired.
-     * @param {{connection: import("../drivers/base.js").default, idleTimeoutMillis: number, now: number}} args - Expiry inputs.
-     * @returns {boolean} - Whether the idle connection expired.
-     */
-    idleConnectionExpired({ connection, idleTimeoutMillis, now }) {
-        const trackedConnection = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection);
-        const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT];
-        return typeof checkedInAt === "number" && now - checkedInAt >= idleTimeoutMillis;
-    }
-    /**
-     * Runs connection has open transaction.
-     * @param {import("../drivers/base.js").default} connection - Connection to inspect.
-     * @returns {boolean} - Whether the connection has an open transaction.
-     */
-    connectionHasOpenTransaction(connection) {
-        return connection._transactionsCount > 0;
-    }
-    /**
-     * Rolls back any transaction a previous holder left open before a connection
-     * re-enters the idle pool. A connection returned to the pool with an open
-     * transaction would otherwise be handed to an unrelated checkout, whose
-     * startTransaction() then fails with "A transaction is already running" and
-     * poisons every following caller that reuses it.
-     * @param {import("../drivers/base.js").default} connection - Connection being checked in.
-     * @returns {Promise<void>} - Resolves when the connection holds no open transaction.
-     */
-    async rollbackLeftOpenTransaction(connection) {
-        if (!this.connectionHasOpenTransaction(connection))
-            return;
-        this.logger.warn(() => [`Rolling back a transaction left open on a connection being checked in (identifier=${this.identifier}).`]);
-        while (this.connectionHasOpenTransaction(connection)) {
-            await connection.rollbackTransaction();
-        }
-    }
-    /**
-     * Runs close connection.
-     * @param {import("../drivers/base.js").default} connection - Connection to close.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async closeConnection(connection) {
-        // Idempotent: a fire-and-forget scheduled reap and an explicit reap can both
-        // target the same connection. Await the in-flight close instead of closing
-        // twice (which can throw on the driver) or returning while the underlying
-        // handle is still open.
-        const existingClose = this.connectionClosePromises.get(connection);
-        if (existingClose) {
-            return await existingClose;
-        }
-        const trackedConnection = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection);
-        trackedConnection[CLOSED_CONNECTION] = true;
-        delete trackedConnection[CONNECTION_CHECKED_OUT_AT];
-        delete trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT];
-        const closePromise = (async () => {
-            await trackedConnection.close();
-        })();
-        this.connectionClosePromises.set(connection, closePromise);
-        this.inflightConnectionCloses.add(closePromise);
-        try {
-            await closePromise;
-        }
-        finally {
-            this.inflightConnectionCloses.delete(closePromise);
-        }
-    }
-    /**
-     * Runs clear idle connection reaper timer.
-      @returns {void} */
-    clearIdleConnectionReaperTimer() {
-        if (!this.idleConnectionReaperTimer)
-            return;
-        clearTimeout(this.idleConnectionReaperTimer);
-        this.idleConnectionReaperTimer = undefined;
-    }
-    /**
-     * Closes all active and cached connections for this pool.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async closeAll() {
-        this.clearIdleConnectionReaperTimer();
-        this.rejectPendingCheckouts(new Error("Database pool was closed before checkout completed."));
-        const connections = new Set([
-            ...this.connections,
-            ...Object.values(this.connectionsInUse),
-            this.getGlobalConnectionForIdentifier(),
-            this._testSharedConnection
-        ].filter(Boolean));
-        this.connections = [];
-        this.connectionsInUse = {};
-        this._testSharedConnection = undefined;
-        this.clearGlobalConnectionForIdentifier();
-        for (const connection of connections) {
-            if (!connection)
-                continue;
-            await this.closeConnection(connection);
-        }
-    }
-    /**
-     * Runs reject pending checkouts.
-     * @param {Error} error - Error to reject pending checkouts with.
-     * @returns {void}
-     */
-    rejectPendingCheckouts(error) {
-        const pendingCheckouts = this.pendingCheckouts;
-        this.pendingCheckouts = [];
-        for (const checkout of pendingCheckouts) {
-            checkout.reject(error);
-        }
-    }
-    /**
-     * Replaces all globally registered fallback connections.
-     * @param {Record<string, import("../drivers/base.js").default>} [connections] - Connections.
-     * @param {import("../../configuration.js").default} [configuration] - Configuration instance.
-     * @returns {void} - No return value.
-     */
-    static setGlobalConnections(connections, configuration) {
-        if (!configuration) {
-            this.globalConnections = new WeakMap();
-            return;
-        }
-        this.globalConnections.set(configuration, connections || {});
-    }
-    /**
-     * Clears globally registered fallback connections for all configurations or a single configuration.
-     * @param {import("../../configuration.js").default} [configuration] - Configuration instance.
-     * @returns {void} - No return value.
-     */
-    static clearGlobalConnections(configuration) {
-        if (!configuration) {
-            this.globalConnections = new WeakMap();
-            return;
-        }
-        this.globalConnections.delete(configuration);
-    }
+     * Expired connections.
+      @type {import("../drivers/base.js").default[]} */
+    const expiredConnections = []
+
+    for (const connection of this.connections) {
+      this.classifyIdleConnectionForReaping({connection, expiredConnections, idleTimeoutMillis, keptConnections, now})
+    }
+
+    return {expiredConnections, keptConnections}
+  }
+
+  /**
+   * Runs classify idle connection for reaping.
+   * @param {{connection: import("../drivers/base.js").default, expiredConnections: import("../drivers/base.js").default[], idleTimeoutMillis: number, keptConnections: import("../drivers/base.js").default[], now: number}} args - Classification state.
+   * @returns {void}
+   */
+  classifyIdleConnectionForReaping({connection, expiredConnections, idleTimeoutMillis, keptConnections, now}) {
+    if (this.connectionIsClosed(connection)) return
+    if (this.connectionHasOpenTransaction(connection)) {
+      keptConnections.push(connection)
+      return
+    }
+
+    const target = this.idleConnectionExpired({connection, idleTimeoutMillis, now}) ? expiredConnections : keptConnections
+
+    target.push(connection)
+  }
+
+  /**
+   * Runs connection is closed.
+   * @param {import("../drivers/base.js").default} connection - Connection to inspect.
+   * @returns {boolean} - Whether the connection is marked closed.
+   */
+  connectionIsClosed(connection) {
+    const trackedConnection = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean}} */ (connection)
+
+    return Boolean(trackedConnection[CLOSED_CONNECTION])
+  }
+
+  /**
+   * Runs idle connection expired.
+   * @param {{connection: import("../drivers/base.js").default, idleTimeoutMillis: number, now: number}} args - Expiry inputs.
+   * @returns {boolean} - Whether the idle connection expired.
+   */
+  idleConnectionExpired({connection, idleTimeoutMillis, now}) {
+    const trackedConnection = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("../drivers/base.js").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
+    const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]
+
+    return typeof checkedInAt === "number" && now - checkedInAt >= idleTimeoutMillis
+  }
+
+  /**
+   * Runs connection has open transaction.
+   * @param {import("../drivers/base.js").default} connection - Connection to inspect.
+   * @returns {boolean} - Whether the connection has an open transaction.
+   */
+  connectionHasOpenTransaction(connection) {
+    return connection._transactionsCount > 0
+  }
+
+  /**
+   * Rolls back any transaction a previous holder left open before a connection
+   * re-enters the idle pool. A connection returned to the pool with an open
+   * transaction would otherwise be handed to an unrelated checkout, whose
+   * startTransaction() then fails with "A transaction is already running" and
+   * poisons every following caller that reuses it.
+   * @param {import("../drivers/base.js").default} connection - Connection being checked in.
+   * @returns {Promise<void>} - Resolves when the connection holds no open transaction.
+   */
+  async rollbackLeftOpenTransaction(connection) {
+    if (!this.connectionHasOpenTransaction(connection)) return
+
+    this.logger.warn(() => [`Rolling back a transaction left open on a connection being checked in (identifier=${this.identifier}).`])
+
+    while (this.connectionHasOpenTransaction(connection)) {
+      await connection.rollbackTransaction()
+    }
+  }
+
+  /**
+   * Runs close connection.
+   * @param {import("../drivers/base.js").default} connection - Connection to close.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async closeConnection(connection) {
+    // Idempotent: a fire-and-forget scheduled reap and an explicit reap can both
+    // target the same connection. Await the in-flight close instead of closing
+    // twice (which can throw on the driver) or returning while the underlying
+    // handle is still open.
+    const existingClose = this.connectionClosePromises.get(connection)
+
+    if (existingClose) {
+      return await existingClose
+    }
+
+    const trackedConnection = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
+
+    trackedConnection[CLOSED_CONNECTION] = true
+    delete trackedConnection[CONNECTION_CHECKED_OUT_AT]
+    delete trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]
+
+    const closePromise = (async () => {
+      await trackedConnection.close()
+    })()
+
+    this.connectionClosePromises.set(connection, closePromise)
+    this.inflightConnectionCloses.add(closePromise)
+
+    try {
+      await closePromise
+    } finally {
+      this.inflightConnectionCloses.delete(closePromise)
+    }
+  }
+
+  /**
+   * Runs clear idle connection reaper timer.
+    @returns {void} */
+  clearIdleConnectionReaperTimer() {
+    if (!this.idleConnectionReaperTimer) return
+
+    clearTimeout(this.idleConnectionReaperTimer)
+    this.idleConnectionReaperTimer = undefined
+  }
+
+  /**
+   * Closes all active and cached connections for this pool.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async closeAll() {
+    this.clearIdleConnectionReaperTimer()
+    this.rejectPendingCheckouts(new Error("Database pool was closed before checkout completed."))
+
+    const connections = new Set([
+      ...this.connections,
+      ...Object.values(this.connectionsInUse),
+      this.getGlobalConnectionForIdentifier(),
+      this._testSharedConnection
+    ].filter(Boolean))
+
+    this.connections = []
+    this.connectionsInUse = {}
+    this._testSharedConnection = undefined
+    this.clearGlobalConnectionForIdentifier()
+
+    for (const connection of connections) {
+      if (!connection) continue
+
+      await this.closeConnection(connection)
+    }
+
+  }
+
+  /**
+   * Runs reject pending checkouts.
+   * @param {Error} error - Error to reject pending checkouts with.
+   * @returns {void}
+   */
+  rejectPendingCheckouts(error) {
+    const pendingCheckouts = this.pendingCheckouts
+
+    this.pendingCheckouts = []
+
+    for (const checkout of pendingCheckouts) {
+      checkout.reject(error)
+    }
+  }
+
+  /**
+   * Replaces all globally registered fallback connections.
+   * @param {Record<string, import("../drivers/base.js").default>} [connections] - Connections.
+   * @param {import("../../configuration.js").default} [configuration] - Configuration instance.
+   * @returns {void} - No return value.
+   */
+  static setGlobalConnections(connections, configuration) {
+    if (!configuration) {
+      this.globalConnections = new WeakMap()
+      return
+    }
+
+    this.globalConnections.set(configuration, connections || {})
+  }
+
+  /**
+   * Clears globally registered fallback connections for all configurations or a single configuration.
+   * @param {import("../../configuration.js").default} [configuration] - Configuration instance.
+   * @returns {void} - No return value.
+   */
+  static clearGlobalConnections(configuration) {
+    if (!configuration) {
+      this.globalConnections = new WeakMap()
+      return
+    }
+
+    this.globalConnections.delete(configuration)
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-tracked-multi-connection.js","sourceRoot":"","sources":["../../../../src/database/pool/async-tracked-multi-connection.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {AsyncLocalStorage} from \"async_hooks\"\nimport BasePool, {POOL_CONFIGURATION_KEY} from \"./base.js\"\n\nexport const CLOSED_CONNECTION = Symbol(\"velociousClosedConnection\")\nconst IDLE_CONNECTION_CHECKED_IN_AT = Symbol(\"velociousIdleConnectionCheckedInAt\")\nconst CONNECTION_CHECKED_OUT_AT = Symbol(\"velociousConnectionCheckedOutAt\")\nconst DEFAULT_IDLE_TIMEOUT_MILLIS = 5000\n\n/**\n * PendingCheckout type.\n * @typedef {object} PendingCheckout\n * @property {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfig - Resolved database configuration needed by the checkout.\n * @property {number} enqueuedAt - Timestamp when the checkout started waiting.\n * @property {import(\"./base.js\").ConnectionCheckoutOptions} options - Checkout options.\n * @property {string} reuseKey - Database configuration reuse key needed by the checkout.\n * @property {(connection: import(\"../drivers/base.js\").default) => void} resolve - Resolves with an activated connection.\n * @property {(error: Error) => void} reject - Rejects when checkout cannot complete.\n */\n\nexport default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {\n  /**\n   * Global fallback connections keyed by configuration instance and pool identifier.\n   * @type {WeakMap<import(\"../../configuration.js\").default, Record<string, import(\"../drivers/base.js\").default>>}\n   */\n  static globalConnections = new WeakMap()\n\n  asyncLocalStorage = new AsyncLocalStorage()\n\n  /**\n   * When set, returned by getCurrentContextConnection when no async context exists.\n   * Used by the test runner to share a connection between test code and HTTP handlers\n   * running in the same process (in-process test server mode).\n   * @type {import(\"../drivers/base.js\").default | undefined}\n   */\n  _testSharedConnection = undefined\n\n  /**\n   * Connections.\n    @type {import(\"../drivers/base.js\").default[]} */\n  connections = []\n\n  /**\n   * Connections in use.\n    @type {Record<number, import(\"../drivers/base.js\").default>} */\n  connectionsInUse = {}\n\n  /**\n   * Pending checkouts.\n    @type {PendingCheckout[]} */\n  pendingCheckouts = []\n\n  /**\n   * Connections being spawned.\n    @type {number} */\n  connectionsBeingSpawned = 0\n\n  /**\n   * Pending checkout drain promise.\n    @type {Promise<void> | undefined} */\n  pendingCheckoutDrainPromise = undefined\n\n  /**\n   * Idle connection reaper timer.\n    @type {ReturnType<typeof setTimeout> | undefined} */\n  idleConnectionReaperTimer = undefined\n\n  /**\n   * In-flight connection-close promises. The idle reaper is armed on check-in\n   * and runs fire-and-forget when its timer fires, so a scheduled reap can be\n   * closing a connection while an explicit `reapIdleConnections()` (or\n   * `clearIdleConnectionReaperTimer()`) runs. Tracking the in-flight closes lets\n   * those callers await them, so once a reap resolves the connections it\n   * expired are fully closed instead of half-closed mid-`close()`.\n   * @type {Set<Promise<void>>}\n   */\n  inflightConnectionCloses = new Set()\n\n  /**\n   * In-flight close promise per connection, so concurrent closes of the same\n   * connection await the same close rather than closing the driver handle twice.\n   * @type {WeakMap<object, Promise<void>>}\n   */\n  connectionClosePromises = new WeakMap()\n\n  idSeq = 0\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} args.identifier - Identifier.\n   */\n  constructor({configuration, identifier}) {\n    super({configuration, identifier})\n    this._withoutCurrentConnectionContext = /**\n                                             * Narrows the runtime value to the documented type.\n                                              @type {(callback: () => ?) => ?} */ ((callback) => this.asyncLocalStorage.run(undefined, callback))\n  }\n\n  /**\n   * Runs checkin.\n   * @param {import(\"../drivers/base.js\").default} connection - Database connection instance.\n   * @returns {Promise<void>} - Resolves when the connection is checked in or closed.\n   */\n  async checkin(connection) {\n    const id = connection.getIdSeq()\n    const trackedConnection = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"../drivers/base.js\").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)\n\n    if (trackedConnection[CLOSED_CONNECTION]) {\n      this.untrackConnectionInUse(connection, id)\n      await this.drainPendingCheckouts()\n      return\n    }\n\n    try {\n      await this.rollbackLeftOpenTransaction(connection)\n      await connection.clearConnectionCheckoutName()\n    } catch (error) {\n      await this.closeCheckedOutConnectionAfterCheckinFailure(connection, id, error)\n      throw error\n    }\n\n    this.untrackConnectionInUse(connection, id)\n    trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT] = Date.now()\n    delete trackedConnection[CONNECTION_CHECKED_OUT_AT]\n    this.connections.push(connection)\n    await this.drainPendingCheckouts()\n    if (this.connections.includes(connection)) await this.handleCheckedInIdleConnection()\n  }\n\n  /**\n   * Runs close checked out connection after checkin failure.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection that failed check-in cleanup.\n   * @param {number | undefined} id - Connection checkout id.\n   * @param {?} originalError - Error that caused check-in cleanup to fail.\n   * @returns {Promise<void>} - Resolves when cleanup has been attempted.\n   */\n  async closeCheckedOutConnectionAfterCheckinFailure(connection, id, originalError) {\n    this.untrackConnectionInUse(connection, id)\n\n    try {\n      await this.closeConnection(connection)\n    } catch (error) {\n      this.logger.warn(\"Failed to close database connection after check-in cleanup failed\", {error, originalError})\n    }\n\n    try {\n      await this.drainPendingCheckouts()\n    } catch (error) {\n      this.logger.warn(\"Failed to drain pending database checkouts after check-in cleanup failed\", {error, originalError})\n    }\n  }\n\n  /**\n   * Runs untrack connection in use.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection being checked in.\n   * @param {number | undefined} id - Connection checkout id.\n   * @returns {void}\n   */\n  untrackConnectionInUse(connection, id) {\n    if (typeof id !== \"number\") {\n      throw new Error(`idSeq on connection wasn't set? '${typeof id}' = ${id}`)\n    }\n\n    delete this.connectionsInUse[id]\n    connection.setIdSeq(undefined)\n  }\n\n  /**\n   * Runs handle checked in idle connection.\n   * @returns {Promise<void>} - Resolves once idle reaping has been scheduled or run.\n   */\n  async handleCheckedInIdleConnection() {\n    if (this.idleTimeoutMillis() === 0) {\n      await this.reapIdleConnections()\n    } else {\n      this.scheduleIdleConnectionReaper()\n    }\n  }\n\n  /**\n   * Runs checkout.\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} [options] - Checkout options.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the checkout.\n   */\n  async checkout(options = {}) {\n    const databaseConfig = this.getConfiguration()\n    const reuseKey = this.getConfigurationReuseKey()\n    let connection = this.takeIdleConnectionForReuseKey(reuseKey)\n\n    if (connection) return await this.activateConnection(connection, options)\n\n    await this.reapIdleConnections()\n    connection = this.takeIdleConnectionForReuseKey(reuseKey)\n\n    if (connection) return await this.activateConnection(connection, options)\n\n    if (this.canSpawnConnection()) {\n      // Spawn via spawnConnection() so the tenant-aware configuration is resolved FRESH at\n      // spawn time for the current caller. Reusing the databaseConfig captured at the top of\n      // checkout() could bind the connection to a stale tenant/database, which breaks\n      // per-request isolation (e.g. test truncation appearing not to take effect). The queued\n      // path below keeps the waiting caller's captured config via waitForCheckout().\n      connection = await this.spawnConnectionForCheckout(this.getConfiguration(), this.getConfigurationReuseKey())\n\n      return await this.activateConnection(connection, options)\n    }\n\n    return await this.waitForCheckout(databaseConfig, reuseKey, options)\n  }\n\n  /**\n   * Runs take idle connection for reuse key.\n   * @param {string} reuseKey - Database configuration reuse key.\n   * @param {object} [args] - Options.\n   * @param {boolean} [args.includeOpenTransactions] - Whether connections with open transactions may be returned.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - Matching idle connection.\n   */\n  takeIdleConnectionForReuseKey(reuseKey, {includeOpenTransactions = true} = {}) {\n    const connectionIndex = this.connections.findIndex((queuedConnection) => {\n      if (!includeOpenTransactions && this.connectionHasOpenTransaction(queuedConnection)) return false\n\n      return this.connectionMatchesReuseKey(queuedConnection, reuseKey)\n    })\n    const connection = connectionIndex === -1 ? undefined : this.connections.splice(connectionIndex, 1)[0]\n\n    return connection\n  }\n\n  /**\n   * Runs connection matches reuse key.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @param {string} reuseKey - Database configuration reuse key.\n   * @returns {boolean} - Whether the connection matches the reuse key.\n   */\n  connectionMatchesReuseKey(connection, reuseKey) {\n    const connectionWithPoolKey = /**\n                                   * Narrows the runtime value to the documented type.\n                                    @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n\n    return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === reuseKey\n  }\n\n  /**\n   * Runs activate connection.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} [options] - Checkout options.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Activated connection.\n   */\n  async activateConnection(connection, options = {}) {\n    if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)\n\n    const id = this.idSeq++\n\n    const trackedConnection = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"../drivers/base.js\").default & {[CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)\n    delete trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]\n    trackedConnection[CONNECTION_CHECKED_OUT_AT] = Date.now()\n\n    connection.setIdSeq(id)\n    this.connectionsInUse[id] = connection\n\n    try {\n      await connection.setConnectionCheckoutName(options.name)\n    } catch (error) {\n      delete this.connectionsInUse[id]\n      connection.setIdSeq(undefined)\n      await this.closeConnection(connection)\n\n      throw error\n    }\n\n    return connection\n  }\n\n  /**\n   * Runs max connections.\n   * @returns {number | undefined} - Configured max live connections.\n   */\n  maxConnections() {\n    const value = this.getConfiguration().pool?.max\n\n    if (this.validMaxConnections(value)) return value\n\n    return\n  }\n\n  /**\n   * Runs valid max connections.\n   * @param {?} value - Candidate max connection count.\n   * @returns {value is number} - Whether the value is a valid max connection count.\n   */\n  validMaxConnections(value) {\n    return typeof value === \"number\" && Number.isFinite(value) && value >= 1\n  }\n\n  /**\n   * Runs live connection count.\n   * @returns {number} - Number of live and in-progress connections.\n   */\n  liveConnectionCount() {\n    const connections = new Set([\n      ...this.connections,\n      ...Object.values(this.connectionsInUse),\n      this.getGlobalConnectionForIdentifier()\n    ].filter(Boolean))\n\n    return connections.size + this.connectionsBeingSpawned\n  }\n\n  /**\n   * Runs can spawn connection.\n   * @returns {boolean} - Whether a new connection can be spawned.\n   */\n  canSpawnConnection() {\n    const maxConnections = this.maxConnections()\n\n    return maxConnections === undefined || this.liveConnectionCount() < maxConnections\n  }\n\n  /**\n   * Runs spawn connection for checkout.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.\n   * @param {string} reuseKey - Database configuration reuse key for the checkout.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Spawned connection.\n   */\n  async spawnConnectionForCheckout(databaseConfig, reuseKey) {\n    this.connectionsBeingSpawned++\n\n    try {\n      const connection = await this.spawnConnectionWithConfiguration(databaseConfig)\n      const connectionWithPoolKey = /**\n                                     * Narrows the runtime value to the documented type.\n                                      @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n\n      connectionWithPoolKey[POOL_CONFIGURATION_KEY] = reuseKey\n      connection.setSchemaCacheInvalidator(() => {\n        this.clearSchemaCache()\n        this.configuration.clearSchemaCachesForReuseKey(reuseKey)\n      })\n\n      return connection\n    } finally {\n      this.connectionsBeingSpawned--\n    }\n  }\n\n  /**\n   * Runs wait for checkout.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.\n   * @param {string} reuseKey - Database configuration reuse key.\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} [options] - Checkout options.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with an activated connection.\n   */\n  async waitForCheckout(databaseConfig, reuseKey, options = {}) {\n    return await new Promise((resolve, reject) => {\n      this.pendingCheckouts.push({databaseConfig, enqueuedAt: Date.now(), options, reject, resolve, reuseKey})\n      void this.drainPendingCheckouts().catch((error) => {\n        const checkoutError = error instanceof Error ? error : new Error(\"Failed to drain pending database connection checkouts.\", {cause: error})\n\n        this.rejectPendingCheckouts(checkoutError)\n      })\n    })\n  }\n\n  /**\n   * Runs drain pending checkouts.\n   * @returns {Promise<void>} - Resolves when pending checkouts have been drained as far as possible.\n   */\n  async drainPendingCheckouts() {\n    if (this.pendingCheckoutDrainPromise) {\n      await this.pendingCheckoutDrainPromise\n      return\n    }\n\n    this.pendingCheckoutDrainPromise = this.drainPendingCheckoutsActual()\n\n    try {\n      await this.pendingCheckoutDrainPromise\n    } finally {\n      this.pendingCheckoutDrainPromise = undefined\n    }\n  }\n\n  /**\n   * Runs drain pending checkouts actual.\n   * @returns {Promise<void>} - Resolves when pending checkouts have been drained as far as possible.\n   */\n  async drainPendingCheckoutsActual() {\n    while (this.pendingCheckouts.length > 0) {\n      if (await this.resolvePendingCheckoutWithMatchingIdleConnection()) continue\n\n      const checkout = this.pendingCheckouts[0]\n\n      if (await this.closeIdleConnectionForPendingCheckoutCapacity(checkout)) continue\n      if (this.canSpawnConnection()) {\n        this.pendingCheckouts.shift()\n        await this.spawnAndResolvePendingCheckout(checkout)\n        continue\n      }\n\n      const reapedConnection = await this.idleConnectionForPendingCheckout(checkout)\n\n      if (!reapedConnection) return\n\n      this.pendingCheckouts.shift()\n      await this.resolvePendingCheckout(checkout, reapedConnection)\n    }\n  }\n\n  /**\n   * Runs resolve pending checkout with matching idle connection.\n   * @returns {Promise<boolean>} - Whether a pending checkout was resolved with an idle connection.\n   */\n  async resolvePendingCheckoutWithMatchingIdleConnection() {\n    for (let index = 0; index < this.pendingCheckouts.length; index++) {\n      const checkout = this.pendingCheckouts[index]\n      const connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, {includeOpenTransactions: false})\n\n      if (!connection) continue\n\n      this.pendingCheckouts.splice(index, 1)\n      await this.resolvePendingCheckout(checkout, connection)\n\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs close idle connection for pending checkout capacity.\n   * @param {PendingCheckout} checkout - Checkout waiting for a connection.\n   * @returns {Promise<boolean>} - Whether an idle connection was closed to free capacity.\n   */\n  async closeIdleConnectionForPendingCheckoutCapacity(checkout) {\n    const connection = this.findIdleConnectionForReuseKey(checkout.reuseKey)\n\n    if (connection) return false\n\n    await this.reapIdleConnections()\n\n    if (this.findIdleConnectionForReuseKey(checkout.reuseKey)) return false\n\n    return this.canSpawnConnection() ? false : await this.closeOneIdleConnectionForCapacity()\n  }\n\n  /**\n   * Runs find idle connection for reuse key.\n   * @param {string} reuseKey - Database configuration reuse key.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - Matching idle connection, if present.\n   */\n  findIdleConnectionForReuseKey(reuseKey) {\n    return this.connections.find((connection) => !this.connectionHasOpenTransaction(connection) && this.connectionMatchesReuseKey(connection, reuseKey))\n  }\n\n  /**\n   * Runs idle connection for pending checkout.\n   * @param {PendingCheckout} checkout - Checkout waiting for a connection.\n   * @returns {Promise<import(\"../drivers/base.js\").default | undefined>} - Matching idle connection, if one can be reused.\n   */\n  async idleConnectionForPendingCheckout(checkout) {\n    let connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, {includeOpenTransactions: false})\n\n    if (connection) return connection\n\n    await this.reapIdleConnections()\n    connection = this.takeIdleConnectionForReuseKey(checkout.reuseKey, {includeOpenTransactions: false})\n\n    return connection\n  }\n\n  /**\n   * Runs spawn and resolve pending checkout.\n   * @param {PendingCheckout} checkout - Checkout request to resolve.\n   * @returns {Promise<void>} - Resolves when the checkout has been handled.\n   */\n  async spawnAndResolvePendingCheckout(checkout) {\n    let connection\n\n    try {\n      connection = await this.spawnConnectionForCheckout(checkout.databaseConfig, checkout.reuseKey)\n    } catch (error) {\n      checkout.reject(error instanceof Error ? error : new Error(\"Failed to spawn database connection.\", {cause: error}))\n      return\n    }\n\n    await this.resolvePendingCheckout(checkout, connection)\n  }\n\n  /**\n   * Runs resolve pending checkout.\n   * @param {PendingCheckout} checkout - Checkout request to resolve.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection to activate.\n   * @returns {Promise<void>} - Resolves when the checkout has been handled.\n   */\n  async resolvePendingCheckout(checkout, connection) {\n    try {\n      checkout.resolve(await this.activateConnection(connection, checkout.options))\n    } catch (error) {\n      checkout.reject(error instanceof Error ? error : new Error(\"Failed to activate database connection.\", {cause: error}))\n    }\n  }\n\n  /**\n   * Runs close one idle connection for capacity.\n   * @returns {Promise<boolean>} - Whether an idle connection was closed to free capacity.\n   */\n  async closeOneIdleConnectionForCapacity() {\n    const connection = this.connections.find((candidate) => !this.connectionHasOpenTransaction(candidate))\n\n    if (!connection) return false\n\n    this.connections = this.connections.filter((candidate) => candidate !== connection)\n    await this.closeConnection(connection)\n\n    return true\n  }\n\n  /**\n   * Runs with connection.\n   * @template T\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions | function(import(\"../drivers/base.js\").default) : Promise<T>} optionsOrCallback - Checkout options or callback to invoke with the connection.\n   * @param {function(import(\"../drivers/base.js\").default) : Promise<T>} [callback] - Callback to invoke with the connection.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withConnection(optionsOrCallback, callback) {\n    const options = typeof optionsOrCallback == \"function\" ? {} : optionsOrCallback\n    const actualCallback = typeof optionsOrCallback == \"function\" ? optionsOrCallback : callback\n\n    if (!actualCallback) throw new Error(\"withConnection requires a callback\")\n\n    const connection = await this.checkout(options)\n    const id = connection.getIdSeq()\n\n    return await this.asyncLocalStorage.run(id, async () => {\n      try {\n        return await actualCallback(connection)\n      } finally {\n        await this.checkin(connection)\n      }\n    })\n  }\n\n  /**\n   * Runs get current connection.\n   * @returns {import(\"../drivers/base.js\").default} - The current connection.\n   */\n  getCurrentConnection() {\n    const id = this.asyncLocalStorage.getStore()\n\n    if (id === undefined) return this.currentFallbackConnectionOrFail()\n\n    this.ensureConnectionIsInUse(id)\n\n    const currentConnection = this.connectionsInUse[id]\n\n    if (!currentConnection) {\n      throw new Error(`Couldn't get current connection from that ID: ${id}`)\n    }\n\n    return currentConnection\n  }\n\n  /**\n   * Runs current fallback connection or fail.\n   * @returns {import(\"../drivers/base.js\").default} - Fallback connection, if present.\n   */\n  currentFallbackConnectionOrFail() {\n    const fallbackConnection = this.getGlobalConnection()\n\n    if (fallbackConnection) return fallbackConnection\n\n    throw new Error(\"ID hasn't been set for this async context\")\n  }\n\n  /**\n   * Runs ensure connection is in use.\n   * @param {number} id - Checked-out connection id.\n   * @returns {void}\n   */\n  ensureConnectionIsInUse(id) {\n    if (!(id in this.connectionsInUse)) {\n      throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`)\n    }\n  }\n\n  /**\n   * Registers a fallback connection for this pool identifier that will be used when no async context is available.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @returns {void} - No return value.\n   */\n  setGlobalConnection(connection) {\n    const klass = /**\n                   * Narrows the runtime value to the documented type.\n                    @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor)\n    let mapForConfiguration = klass.globalConnections.get(this.configuration)\n\n    if (!mapForConfiguration) {\n      mapForConfiguration = {}\n      klass.globalConnections.set(this.configuration, mapForConfiguration)\n    }\n\n    mapForConfiguration[this.identifier] = connection\n  }\n\n  /**\n   * Ensures a global fallback connection exists for this pool identifier and returns it.\n   * If one is already set, it is returned and also made available in the pool queue.\n   * Otherwise a new connection is spawned, registered, and queued.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the global connection.\n   */\n  async ensureGlobalConnection() {\n    const existing = this.getGlobalConnection()\n\n    if (existing) return existing\n\n    const connection = await this.spawnConnection()\n\n    this.setGlobalConnection(connection)\n\n    return connection\n  }\n\n  /**\n   * Set a shared connection for test mode so that HTTP handlers running\n   * in the same process can reuse the test runner's database connection.\n   * @param {import(\"../drivers/base.js\").default} connection - Shared connection.\n   * @returns {void}\n   */\n  setTestSharedConnection(connection) {\n    this._testSharedConnection = connection\n  }\n\n  /**\n   * Runs clear test shared connection.\n    @returns {void} */\n  clearTestSharedConnection() {\n    this._testSharedConnection = undefined\n  }\n\n  /**\n   * Returns the connection tied to the current async context, if any.\n   * Falls back to the test shared connection when no async context exists.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - The current context connection.\n   */\n  getCurrentContextConnection() {\n    const id = this.asyncLocalStorage.getStore()\n\n    if (id === undefined) return this._testSharedConnection\n\n    return this.getCurrentConnection()\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {import(\"./base.js\").DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.\n   */\n  getDebugSnapshot() {\n    const snapshot = super.getDebugSnapshot()\n    const now = Date.now()\n    const {connections} = this.debugConnectionSnapshots(now)\n\n    return {\n      ...snapshot,\n      connections,\n      connectionsBeingSpawned: this.connectionsBeingSpawned,\n      idleCount: this.connections.length,\n      inUseCount: Object.keys(this.connectionsInUse).length,\n      pendingCheckouts: this.pendingCheckoutDebugSnapshots(now),\n      pendingCheckoutCount: this.pendingCheckouts.length\n    }\n  }\n\n  /**\n   * Runs debug connection snapshots.\n   * @param {number} now - Current timestamp.\n   * @returns {{connections: Array<Record<string, ?>>, seenConnections: Set<import(\"../drivers/base.js\").default>}} - Connection snapshots and seen set.\n   */\n  debugConnectionSnapshots(now) {\n    /**\n     * Connections.\n      @type {Array<Record<string, ?>>} */\n    const connections = []\n    const seenConnections = new Set()\n\n    this.addInUseDebugConnectionSnapshots({connections, now, seenConnections})\n    this.addIdleDebugConnectionSnapshots({connections, now, seenConnections})\n    this.addFallbackDebugConnectionSnapshots({connections, seenConnections})\n\n    return {connections, seenConnections}\n  }\n\n  /**\n   * Runs add in use debug connection snapshots.\n   * @param {{connections: Array<Record<string, ?>>, now: number, seenConnections: Set<import(\"../drivers/base.js\").default>}} args - Snapshot collection state.\n   * @returns {void}\n   */\n  addInUseDebugConnectionSnapshots({connections, now, seenConnections}) {\n    for (const [id, connection] of Object.entries(this.connectionsInUse)) {\n      const trackedConnection = /**\n                                 * Narrows the runtime value to the documented type.\n                                  @type {import(\"../drivers/base.js\").default & {[CONNECTION_CHECKED_OUT_AT]?: number}} */ (connection)\n      const checkedOutAt = trackedConnection[CONNECTION_CHECKED_OUT_AT]\n      const checkedOutForMs = typeof checkedOutAt === \"number\" ? Math.max(0, now - checkedOutAt) : undefined\n\n      seenConnections.add(connection)\n      connections.push(this.debugConnectionSnapshot(connection, {checkedOutAt, checkedOutForMs, checkoutId: id, state: \"in-use\"}))\n    }\n  }\n\n  /**\n   * Runs add idle debug connection snapshots.\n   * @param {{connections: Array<Record<string, ?>>, now: number, seenConnections: Set<import(\"../drivers/base.js\").default>}} args - Snapshot collection state.\n   * @returns {void}\n   */\n  addIdleDebugConnectionSnapshots({connections, now, seenConnections}) {\n    for (const connection of this.connections) {\n      if (seenConnections.has(connection)) continue\n\n      seenConnections.add(connection)\n\n      const trackedConnection = /**\n                                 * Narrows the runtime value to the documented type.\n                                  @type {import(\"../drivers/base.js\").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)\n      const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]\n      const idleForMs = typeof checkedInAt === \"number\" ? Math.max(0, now - checkedInAt) : undefined\n\n      connections.push(this.debugConnectionSnapshot(connection, {checkedInAt, idleForMs, state: \"idle\"}))\n    }\n  }\n\n  /**\n   * Runs add fallback debug connection snapshots.\n   * @param {{connections: Array<Record<string, ?>>, seenConnections: Set<import(\"../drivers/base.js\").default>}} args - Snapshot collection state.\n   * @returns {void}\n   */\n  addFallbackDebugConnectionSnapshots({connections, seenConnections}) {\n    this.addDebugConnectionSnapshotIfUnseen({connection: this.getGlobalConnectionForIdentifier(), connections, reapable: false, seenConnections, state: \"global\"})\n    this.addDebugConnectionSnapshotIfUnseen({connection: this._testSharedConnection, connections, reapable: false, seenConnections, state: \"test-shared\"})\n  }\n\n  /**\n   * Runs add debug connection snapshot if unseen.\n   * @param {{connection: import(\"../drivers/base.js\").default | undefined, connections: Array<Record<string, ?>>, reapable?: boolean, seenConnections: Set<import(\"../drivers/base.js\").default>, state: string}} args - Snapshot collection state.\n   * @returns {void}\n   */\n  addDebugConnectionSnapshotIfUnseen({connection, connections, reapable, seenConnections, state}) {\n    if (!connection || seenConnections.has(connection)) return\n\n    seenConnections.add(connection)\n    connections.push(this.debugConnectionSnapshot(connection, {reapable, state}))\n  }\n\n  /**\n   * Runs pending checkout debug snapshots.\n   * @param {number} now - Current timestamp.\n   * @returns {Array<Record<string, ?>>} - Pending checkout snapshots.\n   */\n  pendingCheckoutDebugSnapshots(now) {\n    return this.pendingCheckouts.map((checkout, index) => ({\n      checkoutName: checkout.options.name,\n      enqueuedAt: checkout.enqueuedAt,\n      index,\n      reuseKey: checkout.reuseKey,\n      waitingForMs: Math.max(0, now - checkout.enqueuedAt)\n    }))\n  }\n\n  /**\n   * Runs get global connection.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - The global connection.\n   */\n  getGlobalConnection() {\n    const connection = this.getGlobalConnectionForIdentifier()\n\n    if (!connection) return\n    if (!this.connectionMatchesCurrentConfiguration(connection)) return\n\n    return connection\n  }\n\n  /**\n   * Runs get global connection for identifier.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - The global connection for this pool identifier.\n   */\n  getGlobalConnectionForIdentifier() {\n    const klass = /**\n                   * Narrows the runtime value to the documented type.\n                    @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor)\n    const mapForConfiguration = klass.globalConnections.get(this.configuration)\n\n    return mapForConfiguration?.[this.identifier]\n  }\n\n  /**\n   * Runs clear global connection for identifier.\n   * @returns {void} - No return value.\n   */\n  clearGlobalConnectionForIdentifier() {\n    const klass = /**\n                   * Narrows the runtime value to the documented type.\n                    @type {typeof VelociousDatabasePoolAsyncTrackedMultiConnection} */ (this.constructor)\n    const mapForConfiguration = klass.globalConnections.get(this.configuration)\n\n    if (!mapForConfiguration) return\n\n    delete mapForConfiguration[this.identifier]\n  }\n\n  /**\n   * Clears schema metadata cached by every live connection owned by this pool.\n   * @returns {void} - No return value.\n   */\n  clearSchemaCache() {\n    const connections = new Set([\n      ...this.connections,\n      ...Object.values(this.connectionsInUse),\n      this.getGlobalConnection(),\n      this._testSharedConnection\n    ].filter(Boolean))\n\n    for (const connection of connections) {\n      if (connection) this._clearConnectionSchemaCache(connection)\n    }\n  }\n\n  /**\n   * Runs idle timeout millis.\n   * @returns {number | null} - Idle timeout in milliseconds, or null when disabled.\n   */\n  idleTimeoutMillis() {\n    const value = this.getConfiguration().pool?.idleTimeoutMillis\n\n    if (value === null) return null\n    if (this.validIdleTimeoutMillis(value)) return value\n\n    return DEFAULT_IDLE_TIMEOUT_MILLIS\n  }\n\n  /**\n   * Runs valid idle timeout millis.\n   * @param {?} value - Candidate idle timeout value.\n   * @returns {value is number} - Whether the value is a valid idle timeout.\n   */\n  validIdleTimeoutMillis(value) {\n    return typeof value === \"number\" && Number.isFinite(value) && value >= 0\n  }\n\n  /**\n   * Runs schedule idle connection reaper.\n    @returns {void} */\n  scheduleIdleConnectionReaper() {\n    if (this.idleConnectionReaperTimer) return\n    if (!this.hasIdleConnectionsToReap()) return\n\n    const delay = this.nextIdleConnectionReapDelay(/**\n                                                    * Narrows the runtime value to the documented type.\n                                                     @type {number} */ (this.idleTimeoutMillis()))\n\n    this.idleConnectionReaperTimer = setTimeout(() => {\n      this.idleConnectionReaperTimer = undefined\n      void this.reapIdleConnections().catch((error) => {\n        this.logger.warn(() => [\"Failed to reap idle database connections:\", error])\n      })\n    }, delay)\n\n    if (typeof this.idleConnectionReaperTimer.unref === \"function\") {\n      this.idleConnectionReaperTimer.unref()\n    }\n  }\n\n  /**\n   * Runs has idle connections to reap.\n   * @returns {boolean} - Whether an idle reaper timer should be scheduled.\n   */\n  hasIdleConnectionsToReap() {\n    return this.connections.length > 0 && this.idleTimeoutMillis() !== null\n  }\n\n  /**\n   * Runs next idle connection reap delay.\n   * @param {number} idleTimeoutMillis - Idle timeout in milliseconds.\n   * @returns {number} - Delay before the next reap.\n   */\n  nextIdleConnectionReapDelay(idleTimeoutMillis) {\n    let delay = idleTimeoutMillis\n    const now = Date.now()\n\n    for (const connection of this.connections) {\n      if (this.connectionHasOpenTransaction(connection)) continue\n\n      const trackedConnection = /**\n                                 * Narrows the runtime value to the documented type.\n                                  @type {import(\"../drivers/base.js\").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)\n      const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]\n\n      if (typeof checkedInAt !== \"number\") continue\n\n      delay = Math.min(delay, Math.max(0, idleTimeoutMillis - (now - checkedInAt)))\n    }\n\n    return delay\n  }\n\n  /**\n   * Closes idle checked-in connections that have exceeded the configured timeout.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async reapIdleConnections() {\n    if (this.connections.length === 0) return\n\n    const idleTimeoutMillis = this.idleTimeoutMillis()\n\n    if (idleTimeoutMillis === null) return\n\n    const {expiredConnections, keptConnections} = this.classifyIdleConnectionsForReaping({idleTimeoutMillis, now: Date.now()})\n\n    this.connections = keptConnections\n    await this.closeExpiredIdleConnections(expiredConnections)\n    await this.awaitInflightConnectionCloses()\n    if (this.connections.length > 0) this.scheduleIdleConnectionReaper()\n  }\n\n  /**\n   * Runs close expired idle connections.\n   * @param {import(\"../drivers/base.js\").default[]} expiredConnections - Connections to close.\n   * @returns {Promise<void>} - Resolves when closed.\n   */\n  async closeExpiredIdleConnections(expiredConnections) {\n    for (const connection of expiredConnections) {\n      await this.closeConnection(connection)\n    }\n  }\n\n  /**\n   * Runs await inflight connection closes.\n   * @returns {Promise<void>} - Resolves once in-flight connection closes settle.\n   */\n  async awaitInflightConnectionCloses() {\n    if (this.inflightConnectionCloses.size > 0) {\n      await Promise.allSettled([...this.inflightConnectionCloses])\n    }\n  }\n\n  /**\n   * Runs classify idle connections for reaping.\n   * @param {{idleTimeoutMillis: number, now: number}} args - Reaper classification inputs.\n   * @returns {{expiredConnections: import(\"../drivers/base.js\").default[], keptConnections: import(\"../drivers/base.js\").default[]}} - Classified idle connections.\n   */\n  classifyIdleConnectionsForReaping({idleTimeoutMillis, now}) {\n    /**\n     * Kept connections.\n      @type {import(\"../drivers/base.js\").default[]} */\n    const keptConnections = []\n    /**\n     * Expired connections.\n      @type {import(\"../drivers/base.js\").default[]} */\n    const expiredConnections = []\n\n    for (const connection of this.connections) {\n      this.classifyIdleConnectionForReaping({connection, expiredConnections, idleTimeoutMillis, keptConnections, now})\n    }\n\n    return {expiredConnections, keptConnections}\n  }\n\n  /**\n   * Runs classify idle connection for reaping.\n   * @param {{connection: import(\"../drivers/base.js\").default, expiredConnections: import(\"../drivers/base.js\").default[], idleTimeoutMillis: number, keptConnections: import(\"../drivers/base.js\").default[], now: number}} args - Classification state.\n   * @returns {void}\n   */\n  classifyIdleConnectionForReaping({connection, expiredConnections, idleTimeoutMillis, keptConnections, now}) {\n    if (this.connectionIsClosed(connection)) return\n    if (this.connectionHasOpenTransaction(connection)) {\n      keptConnections.push(connection)\n      return\n    }\n\n    const target = this.idleConnectionExpired({connection, idleTimeoutMillis, now}) ? expiredConnections : keptConnections\n\n    target.push(connection)\n  }\n\n  /**\n   * Runs connection is closed.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection to inspect.\n   * @returns {boolean} - Whether the connection is marked closed.\n   */\n  connectionIsClosed(connection) {\n    const trackedConnection = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"../drivers/base.js\").default & {[CLOSED_CONNECTION]?: boolean}} */ (connection)\n\n    return Boolean(trackedConnection[CLOSED_CONNECTION])\n  }\n\n  /**\n   * Runs idle connection expired.\n   * @param {{connection: import(\"../drivers/base.js\").default, idleTimeoutMillis: number, now: number}} args - Expiry inputs.\n   * @returns {boolean} - Whether the idle connection expired.\n   */\n  idleConnectionExpired({connection, idleTimeoutMillis, now}) {\n    const trackedConnection = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"../drivers/base.js\").default & {[IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)\n    const checkedInAt = trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]\n\n    return typeof checkedInAt === \"number\" && now - checkedInAt >= idleTimeoutMillis\n  }\n\n  /**\n   * Runs connection has open transaction.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection to inspect.\n   * @returns {boolean} - Whether the connection has an open transaction.\n   */\n  connectionHasOpenTransaction(connection) {\n    return connection._transactionsCount > 0\n  }\n\n  /**\n   * Rolls back any transaction a previous holder left open before a connection\n   * re-enters the idle pool. A connection returned to the pool with an open\n   * transaction would otherwise be handed to an unrelated checkout, whose\n   * startTransaction() then fails with \"A transaction is already running\" and\n   * poisons every following caller that reuses it.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection being checked in.\n   * @returns {Promise<void>} - Resolves when the connection holds no open transaction.\n   */\n  async rollbackLeftOpenTransaction(connection) {\n    if (!this.connectionHasOpenTransaction(connection)) return\n\n    this.logger.warn(() => [`Rolling back a transaction left open on a connection being checked in (identifier=${this.identifier}).`])\n\n    while (this.connectionHasOpenTransaction(connection)) {\n      await connection.rollbackTransaction()\n    }\n  }\n\n  /**\n   * Runs close connection.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection to close.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeConnection(connection) {\n    // Idempotent: a fire-and-forget scheduled reap and an explicit reap can both\n    // target the same connection. Await the in-flight close instead of closing\n    // twice (which can throw on the driver) or returning while the underlying\n    // handle is still open.\n    const existingClose = this.connectionClosePromises.get(connection)\n\n    if (existingClose) {\n      return await existingClose\n    }\n\n    const trackedConnection = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"../drivers/base.js\").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)\n\n    trackedConnection[CLOSED_CONNECTION] = true\n    delete trackedConnection[CONNECTION_CHECKED_OUT_AT]\n    delete trackedConnection[IDLE_CONNECTION_CHECKED_IN_AT]\n\n    const closePromise = (async () => {\n      await trackedConnection.close()\n    })()\n\n    this.connectionClosePromises.set(connection, closePromise)\n    this.inflightConnectionCloses.add(closePromise)\n\n    try {\n      await closePromise\n    } finally {\n      this.inflightConnectionCloses.delete(closePromise)\n    }\n  }\n\n  /**\n   * Runs clear idle connection reaper timer.\n    @returns {void} */\n  clearIdleConnectionReaperTimer() {\n    if (!this.idleConnectionReaperTimer) return\n\n    clearTimeout(this.idleConnectionReaperTimer)\n    this.idleConnectionReaperTimer = undefined\n  }\n\n  /**\n   * Closes all active and cached connections for this pool.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeAll() {\n    this.clearIdleConnectionReaperTimer()\n    this.rejectPendingCheckouts(new Error(\"Database pool was closed before checkout completed.\"))\n\n    const connections = new Set([\n      ...this.connections,\n      ...Object.values(this.connectionsInUse),\n      this.getGlobalConnectionForIdentifier(),\n      this._testSharedConnection\n    ].filter(Boolean))\n\n    this.connections = []\n    this.connectionsInUse = {}\n    this._testSharedConnection = undefined\n    this.clearGlobalConnectionForIdentifier()\n\n    for (const connection of connections) {\n      if (!connection) continue\n\n      await this.closeConnection(connection)\n    }\n\n  }\n\n  /**\n   * Runs reject pending checkouts.\n   * @param {Error} error - Error to reject pending checkouts with.\n   * @returns {void}\n   */\n  rejectPendingCheckouts(error) {\n    const pendingCheckouts = this.pendingCheckouts\n\n    this.pendingCheckouts = []\n\n    for (const checkout of pendingCheckouts) {\n      checkout.reject(error)\n    }\n  }\n\n  /**\n   * Replaces all globally registered fallback connections.\n   * @param {Record<string, import(\"../drivers/base.js\").default>} [connections] - Connections.\n   * @param {import(\"../../configuration.js\").default} [configuration] - Configuration instance.\n   * @returns {void} - No return value.\n   */\n  static setGlobalConnections(connections, configuration) {\n    if (!configuration) {\n      this.globalConnections = new WeakMap()\n      return\n    }\n\n    this.globalConnections.set(configuration, connections || {})\n  }\n\n  /**\n   * Clears globally registered fallback connections for all configurations or a single configuration.\n   * @param {import(\"../../configuration.js\").default} [configuration] - Configuration instance.\n   * @returns {void} - No return value.\n   */\n  static clearGlobalConnections(configuration) {\n    if (!configuration) {\n      this.globalConnections = new WeakMap()\n      return\n    }\n\n    this.globalConnections.delete(configuration)\n  }\n}\n"]}