velocious 1.0.577 → 1.0.579

package/build/src/database/pool/single-multi-use.js

@@ -1,122 +1,299 @@
 // @ts-check
 import BasePool from "./base.js";
 import OperationLease from "../operation-lease.js";
+/**
+ * SinglePoolConnectionEntry type.
+ * @typedef {object} SinglePoolConnectionEntry
+ * @property {number} activeCheckoutCount - Active users of the connection.
+ * @property {string[]} checkoutNames - Nested checkout names.
+ * @property {import("../drivers/base.js").default} connection - Owned driver.
+ * @property {boolean} retained - Whether normal ambient use retains this idle entry.
+ * @property {string} reuseKey - Physical configuration reuse key.
+ */
+/**
+ * SinglePoolPendingCheckout type.
+ * @typedef {object} SinglePoolPendingCheckout
+ * @property {string | undefined} checkoutName - Checkout name.
+ * @property {Promise<void>} [closePromise] - Rejects if closeAll owns cancellation.
+ * @property {number} enqueuedAt - Enqueue timestamp.
+ * @property {(error: Error) => void} reject - Rejects a capacity waiter during closeAll.
+ * @property {string} reuseKey - Physical configuration reuse key.
+ * @property {number | null} timeoutAt - Timeout timestamp.
+ * @property {number | null} timeoutMillis - Configured timeout.
+ */
+const DEFAULT_MAX_CONNECTIONS = 10;
+const DEFAULT_CHECKOUT_TIMEOUT_MILLIS = 10000;
 export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     activeCheckoutCount = 0;
     suppressedConnectionContextCount = 0;
     operationLeaseQueue = Promise.resolve();
+    connectionsBeingSpawned = 0;
+    /** @type {Map<string, SinglePoolConnectionEntry>} */
+    connectionEntries = new Map();
+    /** @type {Map<string, Promise<SinglePoolConnectionEntry>>} */
+    connectionEntrySpawnPromises = new Map();
+    /** @type {Map<string, Promise<void>>} */
+    capturedOperationQueues = new Map();
+    /** @type {SinglePoolPendingCheckout[]} */
+    pendingCheckouts = [];
+    /** @type {Set<() => boolean>} */
+    capacityWaiters = new Set();
+    closeGeneration = 0;
     /**
-     * Checkout names of the currently-active nested checkouts, innermost last. The
-     * shared connection carries a single checkout name, so nesting requires restoring
-     * the enclosing scope's name when an inner checkout checks in.
-     * @type {Array<string | undefined>}
-     */
-    checkoutNameStack = [];
-    /**
-     * Runs checkin.
+     * Checks a connection back into its keyed physical entry.
      * @param {import("../drivers/base.js").default} connection - Connection.
-     * @returns {Promise<void>} - Resolves when complete.
+     * @returns {Promise<void>} - Resolves when cleanup completes.
      */
     async checkin(connection) {
-        if (this.connection === connection && this.activeCheckoutCount > 0) {
-            this.activeCheckoutCount--;
-            this.checkoutNameStack.pop();
-            // A nested checkout is checking in while an outer one is still active: restore
-            // the enclosing scope's checkout name instead of leaving this inner name (or
-            // clearing it) on the shared connection.
-            if (this.activeCheckoutCount > 0) {
-                await connection.setConnectionCheckoutName(this.checkoutNameStack[this.checkoutNameStack.length - 1]);
-                return;
-            }
+        const entry = this.entryForConnection(connection);
+        if (!entry || entry.activeCheckoutCount < 1)
+            return;
+        entry.activeCheckoutCount--;
+        entry.checkoutNames.pop();
+        this.activeCheckoutCount--;
+        if (entry.activeCheckoutCount > 0) {
+            await connection.setConnectionCheckoutName(entry.checkoutNames[entry.checkoutNames.length - 1]);
+            return;
         }
         try {
             await connection.releaseHeldAdvisoryLocks();
             await connection.clearConnectionCheckoutName();
         }
         catch (error) {
-            if (this.connection === connection) {
-                this.activeCheckoutCount = 0;
-                this.checkoutNameStack = [];
-                this.connection = undefined;
-            }
             try {
-                await connection.close();
+                await this.removeAndCloseEntry(entry);
             }
             catch (closeError) {
-                const cleanupError = error instanceof Error ? error : new Error("Failed to clean checked-in database connection", { cause: error });
-                const connectionCloseError = closeError instanceof Error ? closeError : new Error("Failed to close database connection after check-in cleanup failed", { cause: closeError });
-                throw new AggregateError([cleanupError, connectionCloseError], "Failed to clean and close checked-in database connection", { cause: closeError });
+                throw new AggregateError([error, closeError], "Database checkout cleanup and connection close both failed", { cause: closeError });
             }
             throw error;
         }
+        if (!entry.retained || this.capacityWaiters.size > 0)
+            await this.removeAndCloseEntry(entry);
     }
     /**
-     * Runs checkout.
+     * Checks out the ambient configuration and retains it as the single mutable
+     * browser fallback connection.
      * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
-     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
+     * @returns {Promise<import("../drivers/base.js").default>} - Checked-out connection.
      */
     async checkout(options = {}) {
-        if (this.connection && !this.connectionMatchesCurrentConfiguration(this.connection)) {
-            const previousConnection = this.connection;
-            this.activeCheckoutCount = 0;
-            this.checkoutNameStack = [];
-            this.connection = undefined;
-            await previousConnection.close();
+        return await this.checkoutForConfiguration(this.getConfiguration(), options, { retain: true });
+    }
+    /**
+     * Checks out an explicitly captured physical configuration.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Captured configuration.
+     * @param {import("./base.js").ConnectionCheckoutOptions} options - Checkout options.
+     * @param {{retain: boolean}} args - Whether this becomes the ambient retained connection.
+     * @returns {Promise<import("../drivers/base.js").default>} - Checked-out connection.
+     */
+    async checkoutForConfiguration(databaseConfiguration, options, { retain }) {
+        const reuseKey = this.getConfigurationReuseKey(databaseConfiguration);
+        let entry = this.connectionEntries.get(reuseKey);
+        if (!entry) {
+            let spawnPromise = this.connectionEntrySpawnPromises.get(reuseKey);
+            let waitedForCapacityReservation = false;
+            if (!spawnPromise) {
+                if (this.capacityWaiters.size === 0 && this.tryReserveConnectionCapacity(databaseConfiguration)) {
+                    spawnPromise = this.spawnConnectionEntry(databaseConfiguration, reuseKey, this.closeGeneration);
+                    this.connectionEntrySpawnPromises.set(reuseKey, spawnPromise);
+                }
+                else {
+                    await this.reserveConnectionCapacity(databaseConfiguration, { name: options.name, reuseKey });
+                    waitedForCapacityReservation = true;
+                }
+                entry = this.connectionEntries.get(reuseKey);
+                spawnPromise = this.connectionEntrySpawnPromises.get(reuseKey);
+                if (!entry && !spawnPromise) {
+                    spawnPromise = this.spawnConnectionEntry(databaseConfiguration, reuseKey, this.closeGeneration);
+                    this.connectionEntrySpawnPromises.set(reuseKey, spawnPromise);
+                }
+                else if (waitedForCapacityReservation) {
+                    this.releaseConnectionCapacityReservation();
+                }
+            }
+            if (!entry && spawnPromise) {
+                try {
+                    entry = await spawnPromise;
+                }
+                finally {
+                    if (this.connectionEntrySpawnPromises.get(reuseKey) === spawnPromise) {
+                        this.connectionEntrySpawnPromises.delete(reuseKey);
+                    }
+                }
+            }
         }
-        if (!this.connection) {
-            this.connection = await this.spawnConnection();
+        if (!entry)
+            throw new Error("Database connection entry was not created");
+        if (retain) {
+            const previousConnection = this.connection;
+            entry.retained = true;
+            this.connection = entry.connection;
+            if (previousConnection && previousConnection !== entry.connection) {
+                const previousEntry = this.entryForConnection(previousConnection);
+                if (previousEntry) {
+                    previousEntry.retained = false;
+                    if (previousEntry.activeCheckoutCount === 0)
+                        await this.removeAndCloseEntry(previousEntry);
+                }
+            }
         }
-        this.checkoutNameStack.push(options.name);
-        await this.connection.setConnectionCheckoutName(options.name);
+        entry.checkoutNames.push(options.name || "");
+        await entry.connection.setConnectionCheckoutName(options.name);
+        entry.activeCheckoutCount++;
         this.activeCheckoutCount++;
-        return this.connection;
+        return entry.connection;
+    }
+    /**
+     * Ensures capacity exists for another physical connection.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Requested configuration.
+     * @param {{name?: string, reuseKey: string}} options - Pending checkout identity.
+     * @returns {Promise<void>} - Resolves when capacity is available.
+     */
+    async reserveConnectionCapacity(databaseConfiguration, options) {
+        while (true) {
+            const idleEntry = [...this.connectionEntries.values()].find((entry) => entry.activeCheckoutCount === 0);
+            if (idleEntry) {
+                await this.removeAndCloseEntry(idleEntry);
+                continue;
+            }
+            await this.waitForCapacity(databaseConfiguration, options);
+            return;
+        }
+    }
+    /**
+     * Waits for pool capacity with normal timeout and closeAll ownership.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Requested configuration.
+     * @param {{name?: string, reuseKey: string}} options - Pending checkout identity.
+     * @returns {Promise<void>} - Resolves on a capacity change.
+     */
+    async waitForCapacity(databaseConfiguration, options) {
+        const timeoutMillis = this.checkoutTimeoutMillis(databaseConfiguration);
+        const enqueuedAt = Date.now();
+        await new Promise((resolve, reject) => {
+            /** @type {ReturnType<typeof setTimeout> | undefined} */
+            let timer;
+            const finish = () => {
+                if (timer)
+                    clearTimeout(timer);
+                this.capacityWaiters.delete(capacityAvailable);
+                this.removePendingCheckout(pending);
+            };
+            const capacityAvailable = () => {
+                if (!this.tryReserveConnectionCapacity(databaseConfiguration))
+                    return false;
+                finish();
+                resolve(undefined);
+                return true;
+            };
+            /** @type {SinglePoolPendingCheckout} */
+            const pending = {
+                checkoutName: options.name,
+                enqueuedAt,
+                reject: (error) => {
+                    finish();
+                    reject(error);
+                },
+                reuseKey: options.reuseKey,
+                timeoutAt: timeoutMillis === null ? null : enqueuedAt + timeoutMillis,
+                timeoutMillis
+            };
+            this.pendingCheckouts.push(pending);
+            this.capacityWaiters.add(capacityAvailable);
+            if (timeoutMillis !== null) {
+                timer = setTimeout(() => {
+                    pending.reject(new Error(`Timed out waiting for database connection checkout after ${timeoutMillis}ms.`));
+                }, timeoutMillis);
+            }
+        });
     }
     /**
      * Runs with connection.
      * @template T
-     * @param {import("./base.js").ConnectionCheckoutOptions | function(import("../drivers/base.js").default) : Promise<T>} optionsOrCallback - Checkout options or callback function.
-     * @param {function(import("../drivers/base.js").default) : Promise<T>} [callback] - Callback function.
-     * @returns {Promise<T>} - Resolves with the callback result.
+     * @param {import("./base.js").ConnectionCheckoutOptions | ((arg: import("../drivers/base.js").default) => Promise<T>)} optionsOrCallback - Options or callback.
+     * @param {(arg: import("../drivers/base.js").default) => Promise<T>} [callback] - Callback.
+     * @returns {Promise<T>} - 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);
         try {
-            if (typeof optionsOrCallback == "function")
-                return await optionsOrCallback(connection);
-            if (!callback)
-                throw new Error("withConnection requires a callback");
-            return await callback(connection);
+            return await actualCallback(connection);
         }
         finally {
             await this.checkin(connection);
         }
     }
     /**
-     * Runs an operation under an exclusive FIFO lease on the reusable physical connection.
+     * Runs a legacy ambient operation under one pool-wide FIFO lease.
      * @template T
      * @param {import("./base.js").ConnectionCheckoutOptions} options - Checkout options.
-     * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Operation callback.
-     * @returns {Promise<T>} - Resolves with the callback result.
+     * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Callback.
+     * @returns {Promise<T>} - Callback result.
      */
     async withOperationConnection(options, callback) {
         const previousLease = this.operationLeaseQueue;
-        /**
-         * Resolves this FIFO queue turn.
-         * @type {() => void} */
         let releaseQueue = () => { };
-        const queueTurn = new Promise((resolve) => {
-            releaseQueue = () => resolve(undefined);
-        });
+        const queueTurn = new Promise((resolve) => { releaseQueue = () => resolve(undefined); });
         this.operationLeaseQueue = previousLease.then(async () => await queueTurn);
         await previousLease;
+        try {
+            const databaseConfiguration = this.getConfiguration();
+            return await this.runOwnedOperation(databaseConfiguration, options, { retain: true }, callback);
+        }
+        finally {
+            releaseQueue();
+        }
+    }
+    /**
+     * Runs a captured operation under a FIFO lease scoped only to its physical
+     * database identity, so unrelated tenant databases remain concurrent.
+     * @template T
+     * @param {import("./base.js").CapturedConnectionOptions} options - Captured options.
+     * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async withCapturedOperationConnection({ databaseConfiguration, name }, callback) {
+        const reuseKey = this.getConfigurationReuseKey(databaseConfiguration);
+        const previousTurn = this.capturedOperationQueues.get(reuseKey) || Promise.resolve();
+        let releaseTurn = () => { };
+        const turn = new Promise((resolve) => { releaseTurn = () => resolve(undefined); });
+        const queueTail = previousTurn.then(async () => await turn);
+        const wasQueued = this.capturedOperationQueues.has(reuseKey);
+        const pending = wasQueued ? this.addOperationPendingCheckout(databaseConfiguration, { name, reuseKey }) : undefined;
+        this.capturedOperationQueues.set(reuseKey, queueTail);
+        try {
+            await this.waitForOperationTurn(previousTurn, pending);
+            return await this.runOwnedOperation(databaseConfiguration, { name }, { retain: false }, callback);
+        }
+        finally {
+            if (pending)
+                this.removePendingCheckout(pending);
+            releaseTurn();
+            void queueTail.finally(() => {
+                if (this.capturedOperationQueues.get(reuseKey) === queueTail)
+                    this.capturedOperationQueues.delete(reuseKey);
+            });
+        }
+    }
+    /**
+     * Runs one callback with an installed driver operation lease.
+     * @template T
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration.
+     * @param {import("./base.js").ConnectionCheckoutOptions} options - Checkout options.
+     * @param {{retain: boolean}} checkoutArgs - Checkout retention.
+     * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async runOwnedOperation(databaseConfiguration, options, checkoutArgs, callback) {
         const owner = Symbol("single-pool-operation-owner");
         const operationLease = new OperationLease(owner);
-        /** @type {import("../drivers/base.js").default | undefined} */
-        let connection;
+        const connection = await this.checkoutForConfiguration(databaseConfiguration, options, checkoutArgs);
         let operationLeaseInstalled = false;
         try {
-            connection = await this.checkout(options);
             await connection.setOperationLease(operationLease);
             operationLeaseInstalled = true;
             return await callback(connection, owner);
@@ -124,24 +301,52 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
         finally {
             operationLease.release();
             try {
-                if (connection && operationLeaseInstalled)
+                if (operationLeaseInstalled)
                     connection.clearOperationLease(operationLease);
             }
             finally {
-                try {
-                    if (connection)
-                        await this.checkin(connection);
-                }
-                finally {
-                    releaseQueue();
-                }
+                await this.checkin(connection);
             }
         }
     }
+    /**
+     * Waits for a same-physical-database operation queue turn.
+     * @param {Promise<void>} previousTurn - Previous queue tail.
+     * @param {SinglePoolPendingCheckout | undefined} pending - Pending debug entry.
+     * @returns {Promise<void>} - Resolves when the previous turn releases.
+     */
+    async waitForOperationTurn(previousTurn, pending) {
+        if (!pending) {
+            await previousTurn;
+            return;
+        }
+        if (pending.timeoutMillis === null) {
+            await new Promise((resolve, reject) => {
+                previousTurn.then(resolve, reject);
+                pending.closePromise?.catch(reject);
+            });
+            return;
+        }
+        const timeoutMillis = pending.timeoutMillis;
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`Timed out waiting for database connection checkout after ${timeoutMillis}ms.`)), timeoutMillis);
+            previousTurn.then(() => {
+                clearTimeout(timer);
+                resolve(undefined);
+            }, (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+            pending.closePromise?.catch((error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
     /**
      * Runs without current connection context.
      * @template T
-     * @param {() => T} callback - Callback to run without the shared current connection.
+     * @param {() => T} callback - Callback.
      * @returns {T} - Callback result.
      */
     withoutCurrentConnectionContext(callback) {
@@ -149,9 +354,7 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
         try {
             const result = callback();
             if (result instanceof Promise) {
-                return /** @type {T} */ (result.finally(() => {
-                    this.suppressedConnectionContextCount -= 1;
-                }));
+                return /** @type {T} */ (result.finally(() => { this.suppressedConnectionContextCount -= 1; }));
             }
             this.suppressedConnectionContextCount -= 1;
             return result;
@@ -161,39 +364,39 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
             throw error;
         }
     }
-    /**
-     * Clears schema metadata cached by the reusable connection if it exists.
-     * @returns {void} - No return value.
-     */
+    /** Clears schema metadata on every live physical connection. */
     clearSchemaCache() {
-        if (this.connection)
-            this._clearConnectionSchemaCache(this.connection);
+        for (const entry of this.connectionEntries.values())
+            this._clearConnectionSchemaCache(entry.connection);
     }
-    /**
-     * Closes the cached connection if it exists.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
+    /** Closes every pool-owned connection and rejects queued capacity requests. */
     async closeAll() {
-        if (!this.connection)
-            return;
-        const connection = this.connection;
-        this.activeCheckoutCount = 0;
+        const closeError = new Error("Database pool was closed before checkout completed.");
+        this.closeGeneration++;
+        for (const pending of [...this.pendingCheckouts])
+            pending.reject(closeError);
+        this.notifyCapacityWaiters();
+        await Promise.allSettled([...this.connectionEntrySpawnPromises.values()]);
+        const entries = [...this.connectionEntries.values()];
+        this.connectionEntries.clear();
+        this.connectionEntrySpawnPromises.clear();
         this.connection = undefined;
-        await connection.close();
+        this.activeCheckoutCount = 0;
+        for (const entry of entries)
+            await entry.connection.close();
     }
     /**
-     * Runs get current connection.
-     * @returns {import("../drivers/base.js").default} - The current connection.
+     * Returns the mutable ambient fallback connection.
+     * @returns {import("../drivers/base.js").default} - Mutable ambient fallback connection.
      */
     getCurrentConnection() {
-        if (!this.connection) {
+        if (!this.connection)
             throw new Error("A connection hasn't been made yet");
-        }
         return this.connection;
     }
     /**
-     * Runs get current context connection.
-     * @returns {import("../drivers/base.js").default | undefined} - The current context connection.
+     * Returns the current context fallback connection when it is not suppressed.
+     * @returns {import("../drivers/base.js").default | undefined} - Current fallback connection.
      */
     getCurrentContextConnection() {
         if (this.suppressedConnectionContextCount > 0)
@@ -201,25 +404,186 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
         return this.connection;
     }
     /**
-     * Returns whether the shared connection is available to the current execution context.
-     * @returns {boolean} - Whether nested code can reuse the shared connection.
+     * Returns whether fallback context is available.
+     * @returns {boolean} - Whether fallback context is available.
      */
     hasCurrentConnectionContext() {
         return this.suppressedConnectionContextCount === 0;
     }
     /**
-     * Runs get debug snapshot.
-     * @returns {import("./base.js").DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.
+     * Returns pool diagnostics for retained and temporary keyed connections.
+     * @returns {import("./base.js").DatabasePoolDebugSnapshot} - Pool diagnostics.
      */
     getDebugSnapshot() {
-        const connections = this.connection
-            ? [this.debugConnectionSnapshot(this.connection, { state: "shared" })]
-            : [];
+        const connections = [...this.connectionEntries.values()].map((entry) => this.debugConnectionSnapshot(entry.connection, {
+            activeCheckoutCount: entry.activeCheckoutCount,
+            state: entry.retained ? "shared" : entry.activeCheckoutCount > 0 ? "in-use" : "idle"
+        }));
+        const now = Date.now();
         return {
             ...super.getDebugSnapshot(),
             connections,
-            idleCount: this.connection ? 1 : 0
+            connectionsBeingSpawned: this.connectionsBeingSpawned,
+            idleCount: [...this.connectionEntries.values()].filter((entry) => entry.activeCheckoutCount === 0).length,
+            inUseCount: [...this.connectionEntries.values()].filter((entry) => entry.activeCheckoutCount > 0).length,
+            pendingCheckouts: this.pendingCheckouts.map((pending, index) => ({
+                checkoutName: pending.checkoutName,
+                enqueuedAt: pending.enqueuedAt,
+                index,
+                remainingTimeoutMs: pending.timeoutAt === null ? null : Math.max(0, pending.timeoutAt - now),
+                reuseKey: pending.reuseKey,
+                timeoutAt: pending.timeoutAt,
+                timeoutMillis: pending.timeoutMillis,
+                waitingForMs: Math.max(0, now - pending.enqueuedAt)
+            })),
+            pendingCheckoutCount: this.pendingCheckouts.length
+        };
+    }
+    /**
+     * Returns the configured connection maximum.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration.
+     * @returns {number | null} - Configured connection maximum.
+     */
+    maxConnections(databaseConfiguration) {
+        const value = databaseConfiguration.pool?.max;
+        if (value === null)
+            return null;
+        if (typeof value === "number" && Number.isFinite(value) && value >= 1)
+            return value;
+        return DEFAULT_MAX_CONNECTIONS;
+    }
+    /**
+     * Returns the configured checkout timeout.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration.
+     * @returns {number | null} - Configured checkout timeout.
+     */
+    checkoutTimeoutMillis(databaseConfiguration) {
+        const value = databaseConfiguration.pool?.checkoutTimeoutMillis;
+        if (value === null)
+            return null;
+        if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+            return value;
+        return DEFAULT_CHECKOUT_TIMEOUT_MILLIS;
+    }
+    /**
+     * Returns whether another physical connection may be spawned.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration.
+     * @returns {boolean} - Whether another physical connection may be spawned.
+     */
+    canSpawnConnection(databaseConfiguration) {
+        const max = this.maxConnections(databaseConfiguration);
+        return max === null || this.connectionEntries.size + this.connectionsBeingSpawned < max;
+    }
+    /**
+     * Atomically claims one connection slot without yielding.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration whose maximum applies.
+     * @returns {boolean} - Whether a slot was reserved.
+     */
+    tryReserveConnectionCapacity(databaseConfiguration) {
+        if (!this.canSpawnConnection(databaseConfiguration))
+            return false;
+        this.connectionsBeingSpawned++;
+        return true;
+    }
+    /** Releases one previously claimed connection slot. */
+    releaseConnectionCapacityReservation() {
+        if (this.connectionsBeingSpawned < 1) {
+            throw new Error("Cannot release an unreserved database connection slot");
+        }
+        this.connectionsBeingSpawned--;
+        this.notifyCapacityWaiters();
+    }
+    /**
+     * Spawns and tracks a physical connection entry.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration.
+     * @param {string} reuseKey - Physical reuse key.
+     * @param {number} closeGeneration - Pool lifecycle generation at spawn start.
+     * @returns {Promise<SinglePoolConnectionEntry>} - New entry.
+     */
+    async spawnConnectionEntry(databaseConfiguration, reuseKey, closeGeneration) {
+        try {
+            const connection = await this.spawnConnectionForConfiguration(databaseConfiguration);
+            if (this.closeGeneration !== closeGeneration) {
+                await connection.close();
+                throw new Error("Database pool was closed before checkout completed.");
+            }
+            /** @type {SinglePoolConnectionEntry} */
+            const entry = { activeCheckoutCount: 0, checkoutNames: [], connection, retained: false, reuseKey };
+            this.connectionEntries.set(reuseKey, entry);
+            return entry;
+        }
+        finally {
+            this.releaseConnectionCapacityReservation();
+        }
+    }
+    /**
+     * Removes and closes an entry.
+     * @param {import("../drivers/base.js").default} connection - Connection.
+     * @returns {SinglePoolConnectionEntry | undefined} - Entry owning a connection.
+     */
+    entryForConnection(connection) {
+        return [...this.connectionEntries.values()].find((entry) => entry.connection === connection);
+    }
+    /**
+     * Adds a same-key operation pending entry.
+     * @param {SinglePoolConnectionEntry} entry - Entry to close.
+     * @returns {Promise<void>} - Resolves after close.
+     */
+    async removeAndCloseEntry(entry) {
+        if (this.connectionEntries.get(entry.reuseKey) !== entry)
+            return;
+        this.connectionEntries.delete(entry.reuseKey);
+        if (this.connection === entry.connection)
+            this.connection = undefined;
+        await entry.connection.close();
+        this.notifyCapacityWaiters();
+    }
+    /** Wakes all capacity waiters to re-check the bounded pool. */
+    notifyCapacityWaiters() {
+        for (const reserveAndResolve of this.capacityWaiters) {
+            if (reserveAndResolve())
+                return;
+        }
+    }
+    /**
+     * Adds a same-key operation pending entry.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Physical configuration.
+     * @param {{name?: string, reuseKey: string}} options - Pending identity.
+     * @returns {SinglePoolPendingCheckout} - Added same-key operation pending entry.
+     */
+    addOperationPendingCheckout(databaseConfiguration, { name, reuseKey }) {
+        const timeoutMillis = this.checkoutTimeoutMillis(databaseConfiguration);
+        const enqueuedAt = Date.now();
+        /**
+         * Rejects the close-owned promise.
+         * @type {(error: Error) => void}
+         */
+        let rejectClose = () => { };
+        const closePromise = new Promise((resolve, reject) => {
+            void resolve;
+            rejectClose = reject;
+        });
+        const pending = {
+            checkoutName: name,
+            closePromise,
+            enqueuedAt,
+            reject: rejectClose,
+            reuseKey,
+            timeoutAt: timeoutMillis === null ? null : enqueuedAt + timeoutMillis,
+            timeoutMillis
         };
+        this.pendingCheckouts.push(pending);
+        return pending;
+    }
+    /**
+     * Removes a pending checkout debug entry.
+     * @param {SinglePoolPendingCheckout} pending - Pending entry.
+     * @returns {void}
+     */
+    removePendingCheckout(pending) {
+        const index = this.pendingCheckouts.indexOf(pending);
+        if (index !== -1)
+            this.pendingCheckouts.splice(index, 1);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single-multi-use.js","sourceRoot":"","sources":["../../../../src/database/pool/single-multi-use.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BasePool from \"./base.js\"\nimport OperationLease from \"../operation-lease.js\"\n\nexport default class VelociousDatabasePoolSingleMultiUser extends BasePool {\n  activeCheckoutCount = 0\n  suppressedConnectionContextCount = 0\n  operationLeaseQueue = Promise.resolve()\n\n  /**\n   * Checkout names of the currently-active nested checkouts, innermost last. The\n   * shared connection carries a single checkout name, so nesting requires restoring\n   * the enclosing scope's name when an inner checkout checks in.\n   * @type {Array<string | undefined>}\n   */\n  checkoutNameStack = []\n\n  /**\n   * Runs checkin.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async checkin(connection) {\n    if (this.connection === connection && this.activeCheckoutCount > 0) {\n      this.activeCheckoutCount--\n      this.checkoutNameStack.pop()\n\n      // A nested checkout is checking in while an outer one is still active: restore\n      // the enclosing scope's checkout name instead of leaving this inner name (or\n      // clearing it) on the shared connection.\n      if (this.activeCheckoutCount > 0) {\n        await connection.setConnectionCheckoutName(this.checkoutNameStack[this.checkoutNameStack.length - 1])\n\n        return\n      }\n    }\n\n    try {\n      await connection.releaseHeldAdvisoryLocks()\n      await connection.clearConnectionCheckoutName()\n    } catch (error) {\n      if (this.connection === connection) {\n        this.activeCheckoutCount = 0\n        this.checkoutNameStack = []\n        this.connection = undefined\n      }\n\n      try {\n        await connection.close()\n      } catch (closeError) {\n        const cleanupError = error instanceof Error ? error : new Error(\"Failed to clean checked-in database connection\", {cause: error})\n        const connectionCloseError = closeError instanceof Error ? closeError : new Error(\"Failed to close database connection after check-in cleanup failed\", {cause: closeError})\n\n        throw new AggregateError([cleanupError, connectionCloseError], \"Failed to clean and close checked-in database connection\", {cause: closeError})\n      }\n\n      throw error\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    if (this.connection && !this.connectionMatchesCurrentConfiguration(this.connection)) {\n      const previousConnection = this.connection\n\n      this.activeCheckoutCount = 0\n      this.checkoutNameStack = []\n      this.connection = undefined\n\n      await previousConnection.close()\n    }\n\n    if (!this.connection) {\n      this.connection = await this.spawnConnection()\n    }\n\n    this.checkoutNameStack.push(options.name)\n    await this.connection.setConnectionCheckoutName(options.name)\n    this.activeCheckoutCount++\n\n    return this.connection\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 function.\n   * @param {function(import(\"../drivers/base.js\").default) : Promise<T>} [callback] - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withConnection(optionsOrCallback, callback) {\n    const options = typeof optionsOrCallback == \"function\" ? {} : optionsOrCallback\n\n    const connection = await this.checkout(options)\n\n    try {\n      if (typeof optionsOrCallback == \"function\") return await optionsOrCallback(connection)\n\n      if (!callback) throw new Error(\"withConnection requires a callback\")\n\n      return await callback(connection)\n    } finally {\n      await this.checkin(connection)\n    }\n  }\n\n  /**\n   * Runs an operation under an exclusive FIFO lease on the reusable physical connection.\n   * @template T\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} options - Checkout options.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Operation callback.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withOperationConnection(options, callback) {\n    const previousLease = this.operationLeaseQueue\n    /**\n     * Resolves this FIFO queue turn.\n     * @type {() => void} */\n    let releaseQueue = () => {}\n    const queueTurn = new Promise((resolve) => {\n      releaseQueue = () => resolve(undefined)\n    })\n\n    this.operationLeaseQueue = previousLease.then(async () => await queueTurn)\n    await previousLease\n\n    const owner = Symbol(\"single-pool-operation-owner\")\n    const operationLease = new OperationLease(owner)\n    /** @type {import(\"../drivers/base.js\").default | undefined} */\n    let connection\n    let operationLeaseInstalled = false\n\n    try {\n      connection = await this.checkout(options)\n      await connection.setOperationLease(operationLease)\n      operationLeaseInstalled = true\n\n      return await callback(connection, owner)\n    } finally {\n      operationLease.release()\n\n      try {\n        if (connection && operationLeaseInstalled) connection.clearOperationLease(operationLease)\n      } finally {\n        try {\n          if (connection) await this.checkin(connection)\n        } finally {\n          releaseQueue()\n        }\n      }\n    }\n  }\n\n  /**\n   * Runs without current connection context.\n   * @template T\n   * @param {() => T} callback - Callback to run without the shared current connection.\n   * @returns {T} - Callback result.\n   */\n  withoutCurrentConnectionContext(callback) {\n    this.suppressedConnectionContextCount += 1\n\n    try {\n      const result = callback()\n\n      if (result instanceof Promise) {\n        return /** @type {T} */ (result.finally(() => {\n          this.suppressedConnectionContextCount -= 1\n        }))\n      }\n\n      this.suppressedConnectionContextCount -= 1\n      return result\n    } catch (error) {\n      this.suppressedConnectionContextCount -= 1\n      throw error\n    }\n  }\n\n  /**\n   * Clears schema metadata cached by the reusable connection if it exists.\n   * @returns {void} - No return value.\n   */\n  clearSchemaCache() {\n    if (this.connection) this._clearConnectionSchemaCache(this.connection)\n  }\n\n  /**\n   * Closes the cached connection if it exists.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeAll() {\n    if (!this.connection) return\n\n    const connection = this.connection\n\n    this.activeCheckoutCount = 0\n    this.connection = undefined\n\n    await connection.close()\n  }\n\n  /**\n   * Runs get current connection.\n   * @returns {import(\"../drivers/base.js\").default} - The current connection.\n   */\n  getCurrentConnection() {\n    if (!this.connection) {\n      throw new Error(\"A connection hasn't been made yet\")\n    }\n\n    return this.connection\n  }\n\n  /**\n   * Runs get current context connection.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - The current context connection.\n   */\n  getCurrentContextConnection() {\n    if (this.suppressedConnectionContextCount > 0) return undefined\n\n    return this.connection\n  }\n\n  /**\n   * Returns whether the shared connection is available to the current execution context.\n   * @returns {boolean} - Whether nested code can reuse the shared connection.\n   */\n  hasCurrentConnectionContext() {\n    return this.suppressedConnectionContextCount === 0\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {import(\"./base.js\").DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.\n   */\n  getDebugSnapshot() {\n    const connections = this.connection\n      ? [this.debugConnectionSnapshot(this.connection, {state: \"shared\"})]\n      : []\n\n    return {\n      ...super.getDebugSnapshot(),\n      connections,\n      idleCount: this.connection ? 1 : 0\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single-multi-use.js","sourceRoot":"","sources":["../../../../src/database/pool/single-multi-use.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BasePool from \"./base.js\"\nimport OperationLease from \"../operation-lease.js\"\n\n/**\n * SinglePoolConnectionEntry type.\n * @typedef {object} SinglePoolConnectionEntry\n * @property {number} activeCheckoutCount - Active users of the connection.\n * @property {string[]} checkoutNames - Nested checkout names.\n * @property {import(\"../drivers/base.js\").default} connection - Owned driver.\n * @property {boolean} retained - Whether normal ambient use retains this idle entry.\n * @property {string} reuseKey - Physical configuration reuse key.\n */\n/**\n * SinglePoolPendingCheckout type.\n * @typedef {object} SinglePoolPendingCheckout\n * @property {string | undefined} checkoutName - Checkout name.\n * @property {Promise<void>} [closePromise] - Rejects if closeAll owns cancellation.\n * @property {number} enqueuedAt - Enqueue timestamp.\n * @property {(error: Error) => void} reject - Rejects a capacity waiter during closeAll.\n * @property {string} reuseKey - Physical configuration reuse key.\n * @property {number | null} timeoutAt - Timeout timestamp.\n * @property {number | null} timeoutMillis - Configured timeout.\n */\n\nconst DEFAULT_MAX_CONNECTIONS = 10\nconst DEFAULT_CHECKOUT_TIMEOUT_MILLIS = 10000\n\nexport default class VelociousDatabasePoolSingleMultiUser extends BasePool {\n  activeCheckoutCount = 0\n  suppressedConnectionContextCount = 0\n  operationLeaseQueue = Promise.resolve()\n  connectionsBeingSpawned = 0\n\n  /** @type {Map<string, SinglePoolConnectionEntry>} */\n  connectionEntries = new Map()\n  /** @type {Map<string, Promise<SinglePoolConnectionEntry>>} */\n  connectionEntrySpawnPromises = new Map()\n  /** @type {Map<string, Promise<void>>} */\n  capturedOperationQueues = new Map()\n  /** @type {SinglePoolPendingCheckout[]} */\n  pendingCheckouts = []\n  /** @type {Set<() => boolean>} */\n  capacityWaiters = new Set()\n  closeGeneration = 0\n\n  /**\n   * Checks a connection back into its keyed physical entry.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @returns {Promise<void>} - Resolves when cleanup completes.\n   */\n  async checkin(connection) {\n    const entry = this.entryForConnection(connection)\n\n    if (!entry || entry.activeCheckoutCount < 1) return\n\n    entry.activeCheckoutCount--\n    entry.checkoutNames.pop()\n    this.activeCheckoutCount--\n\n    if (entry.activeCheckoutCount > 0) {\n      await connection.setConnectionCheckoutName(entry.checkoutNames[entry.checkoutNames.length - 1])\n      return\n    }\n\n    try {\n      await connection.releaseHeldAdvisoryLocks()\n      await connection.clearConnectionCheckoutName()\n    } catch (error) {\n      try {\n        await this.removeAndCloseEntry(entry)\n      } catch (closeError) {\n        throw new AggregateError([error, closeError], \"Database checkout cleanup and connection close both failed\", {cause: closeError})\n      }\n      throw error\n    }\n\n    if (!entry.retained || this.capacityWaiters.size > 0) await this.removeAndCloseEntry(entry)\n  }\n\n  /**\n   * Checks out the ambient configuration and retains it as the single mutable\n   * browser fallback connection.\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} [options] - Checkout options.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Checked-out connection.\n   */\n  async checkout(options = {}) {\n    return await this.checkoutForConfiguration(this.getConfiguration(), options, {retain: true})\n  }\n\n  /**\n   * Checks out an explicitly captured physical configuration.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Captured configuration.\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} options - Checkout options.\n   * @param {{retain: boolean}} args - Whether this becomes the ambient retained connection.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Checked-out connection.\n   */\n  async checkoutForConfiguration(databaseConfiguration, options, {retain}) {\n    const reuseKey = this.getConfigurationReuseKey(databaseConfiguration)\n    let entry = this.connectionEntries.get(reuseKey)\n\n    if (!entry) {\n      let spawnPromise = this.connectionEntrySpawnPromises.get(reuseKey)\n      let waitedForCapacityReservation = false\n\n      if (!spawnPromise) {\n        if (this.capacityWaiters.size === 0 && this.tryReserveConnectionCapacity(databaseConfiguration)) {\n          spawnPromise = this.spawnConnectionEntry(databaseConfiguration, reuseKey, this.closeGeneration)\n          this.connectionEntrySpawnPromises.set(reuseKey, spawnPromise)\n        } else {\n          await this.reserveConnectionCapacity(databaseConfiguration, {name: options.name, reuseKey})\n          waitedForCapacityReservation = true\n        }\n\n        entry = this.connectionEntries.get(reuseKey)\n        spawnPromise = this.connectionEntrySpawnPromises.get(reuseKey)\n\n        if (!entry && !spawnPromise) {\n          spawnPromise = this.spawnConnectionEntry(databaseConfiguration, reuseKey, this.closeGeneration)\n          this.connectionEntrySpawnPromises.set(reuseKey, spawnPromise)\n        } else if (waitedForCapacityReservation) {\n          this.releaseConnectionCapacityReservation()\n        }\n      }\n\n      if (!entry && spawnPromise) {\n        try {\n          entry = await spawnPromise\n        } finally {\n          if (this.connectionEntrySpawnPromises.get(reuseKey) === spawnPromise) {\n            this.connectionEntrySpawnPromises.delete(reuseKey)\n          }\n        }\n      }\n    }\n    if (!entry) throw new Error(\"Database connection entry was not created\")\n\n    if (retain) {\n      const previousConnection = this.connection\n\n      entry.retained = true\n      this.connection = entry.connection\n\n      if (previousConnection && previousConnection !== entry.connection) {\n        const previousEntry = this.entryForConnection(previousConnection)\n\n        if (previousEntry) {\n          previousEntry.retained = false\n          if (previousEntry.activeCheckoutCount === 0) await this.removeAndCloseEntry(previousEntry)\n        }\n      }\n    }\n\n    entry.checkoutNames.push(options.name || \"\")\n    await entry.connection.setConnectionCheckoutName(options.name)\n    entry.activeCheckoutCount++\n    this.activeCheckoutCount++\n\n    return entry.connection\n  }\n\n  /**\n   * Ensures capacity exists for another physical connection.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Requested configuration.\n   * @param {{name?: string, reuseKey: string}} options - Pending checkout identity.\n   * @returns {Promise<void>} - Resolves when capacity is available.\n   */\n  async reserveConnectionCapacity(databaseConfiguration, options) {\n    while (true) {\n      const idleEntry = [...this.connectionEntries.values()].find((entry) => entry.activeCheckoutCount === 0)\n\n      if (idleEntry) {\n        await this.removeAndCloseEntry(idleEntry)\n        continue\n      }\n\n      await this.waitForCapacity(databaseConfiguration, options)\n      return\n    }\n  }\n\n  /**\n   * Waits for pool capacity with normal timeout and closeAll ownership.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Requested configuration.\n   * @param {{name?: string, reuseKey: string}} options - Pending checkout identity.\n   * @returns {Promise<void>} - Resolves on a capacity change.\n   */\n  async waitForCapacity(databaseConfiguration, options) {\n    const timeoutMillis = this.checkoutTimeoutMillis(databaseConfiguration)\n    const enqueuedAt = Date.now()\n\n    await new Promise((resolve, reject) => {\n      /** @type {ReturnType<typeof setTimeout> | undefined} */\n      let timer\n      const finish = () => {\n        if (timer) clearTimeout(timer)\n        this.capacityWaiters.delete(capacityAvailable)\n        this.removePendingCheckout(pending)\n      }\n      const capacityAvailable = () => {\n        if (!this.tryReserveConnectionCapacity(databaseConfiguration)) return false\n\n        finish()\n        resolve(undefined)\n\n        return true\n      }\n      /** @type {SinglePoolPendingCheckout} */\n      const pending = {\n        checkoutName: options.name,\n        enqueuedAt,\n        reject: (error) => {\n          finish()\n          reject(error)\n        },\n        reuseKey: options.reuseKey,\n        timeoutAt: timeoutMillis === null ? null : enqueuedAt + timeoutMillis,\n        timeoutMillis\n      }\n\n      this.pendingCheckouts.push(pending)\n      this.capacityWaiters.add(capacityAvailable)\n\n      if (timeoutMillis !== null) {\n        timer = setTimeout(() => {\n          pending.reject(new Error(`Timed out waiting for database connection checkout after ${timeoutMillis}ms.`))\n        }, timeoutMillis)\n      }\n    })\n  }\n\n  /**\n   * Runs with connection.\n   * @template T\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions | ((arg: import(\"../drivers/base.js\").default) => Promise<T>)} optionsOrCallback - Options or callback.\n   * @param {(arg: import(\"../drivers/base.js\").default) => Promise<T>} [callback] - Callback.\n   * @returns {Promise<T>} - 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\n    try {\n      return await actualCallback(connection)\n    } finally {\n      await this.checkin(connection)\n    }\n  }\n\n  /**\n   * Runs a legacy ambient operation under one pool-wide FIFO lease.\n   * @template T\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} options - Checkout options.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async withOperationConnection(options, callback) {\n    const previousLease = this.operationLeaseQueue\n    let releaseQueue = () => {}\n    const queueTurn = new Promise((resolve) => { releaseQueue = () => resolve(undefined) })\n\n    this.operationLeaseQueue = previousLease.then(async () => await queueTurn)\n    await previousLease\n\n    try {\n      const databaseConfiguration = this.getConfiguration()\n\n      return await this.runOwnedOperation(databaseConfiguration, options, {retain: true}, callback)\n    } finally {\n      releaseQueue()\n    }\n  }\n\n  /**\n   * Runs a captured operation under a FIFO lease scoped only to its physical\n   * database identity, so unrelated tenant databases remain concurrent.\n   * @template T\n   * @param {import(\"./base.js\").CapturedConnectionOptions} options - Captured options.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async withCapturedOperationConnection({databaseConfiguration, name}, callback) {\n    const reuseKey = this.getConfigurationReuseKey(databaseConfiguration)\n    const previousTurn = this.capturedOperationQueues.get(reuseKey) || Promise.resolve()\n    let releaseTurn = () => {}\n    const turn = new Promise((resolve) => { releaseTurn = () => resolve(undefined) })\n    const queueTail = previousTurn.then(async () => await turn)\n    const wasQueued = this.capturedOperationQueues.has(reuseKey)\n    const pending = wasQueued ? this.addOperationPendingCheckout(databaseConfiguration, {name, reuseKey}) : undefined\n\n    this.capturedOperationQueues.set(reuseKey, queueTail)\n\n    try {\n      await this.waitForOperationTurn(previousTurn, pending)\n\n      return await this.runOwnedOperation(databaseConfiguration, {name}, {retain: false}, callback)\n    } finally {\n      if (pending) this.removePendingCheckout(pending)\n      releaseTurn()\n      void queueTail.finally(() => {\n        if (this.capturedOperationQueues.get(reuseKey) === queueTail) this.capturedOperationQueues.delete(reuseKey)\n      })\n    }\n  }\n\n  /**\n   * Runs one callback with an installed driver operation lease.\n   * @template T\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration.\n   * @param {import(\"./base.js\").ConnectionCheckoutOptions} options - Checkout options.\n   * @param {{retain: boolean}} checkoutArgs - Checkout retention.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async runOwnedOperation(databaseConfiguration, options, checkoutArgs, callback) {\n    const owner = Symbol(\"single-pool-operation-owner\")\n    const operationLease = new OperationLease(owner)\n    const connection = await this.checkoutForConfiguration(databaseConfiguration, options, checkoutArgs)\n    let operationLeaseInstalled = false\n\n    try {\n      await connection.setOperationLease(operationLease)\n      operationLeaseInstalled = true\n\n      return await callback(connection, owner)\n    } finally {\n      operationLease.release()\n\n      try {\n        if (operationLeaseInstalled) connection.clearOperationLease(operationLease)\n      } finally {\n        await this.checkin(connection)\n      }\n    }\n  }\n\n  /**\n   * Waits for a same-physical-database operation queue turn.\n   * @param {Promise<void>} previousTurn - Previous queue tail.\n   * @param {SinglePoolPendingCheckout | undefined} pending - Pending debug entry.\n   * @returns {Promise<void>} - Resolves when the previous turn releases.\n   */\n  async waitForOperationTurn(previousTurn, pending) {\n    if (!pending) {\n      await previousTurn\n      return\n    }\n\n    if (pending.timeoutMillis === null) {\n      await new Promise((resolve, reject) => {\n        previousTurn.then(resolve, reject)\n        pending.closePromise?.catch(reject)\n      })\n      return\n    }\n\n    const timeoutMillis = pending.timeoutMillis\n\n    await new Promise((resolve, reject) => {\n      const timer = setTimeout(() => reject(new Error(`Timed out waiting for database connection checkout after ${timeoutMillis}ms.`)), timeoutMillis)\n\n      previousTurn.then(() => {\n        clearTimeout(timer)\n        resolve(undefined)\n      }, (error) => {\n        clearTimeout(timer)\n        reject(error)\n      })\n      pending.closePromise?.catch((error) => {\n        clearTimeout(timer)\n        reject(error)\n      })\n    })\n  }\n\n  /**\n   * Runs without current connection context.\n   * @template T\n   * @param {() => T} callback - Callback.\n   * @returns {T} - Callback result.\n   */\n  withoutCurrentConnectionContext(callback) {\n    this.suppressedConnectionContextCount += 1\n\n    try {\n      const result = callback()\n\n      if (result instanceof Promise) {\n        return /** @type {T} */ (result.finally(() => { this.suppressedConnectionContextCount -= 1 }))\n      }\n\n      this.suppressedConnectionContextCount -= 1\n      return result\n    } catch (error) {\n      this.suppressedConnectionContextCount -= 1\n      throw error\n    }\n  }\n\n  /** Clears schema metadata on every live physical connection. */\n  clearSchemaCache() {\n    for (const entry of this.connectionEntries.values()) this._clearConnectionSchemaCache(entry.connection)\n  }\n\n  /** Closes every pool-owned connection and rejects queued capacity requests. */\n  async closeAll() {\n    const closeError = new Error(\"Database pool was closed before checkout completed.\")\n\n    this.closeGeneration++\n\n    for (const pending of [...this.pendingCheckouts]) pending.reject(closeError)\n    this.notifyCapacityWaiters()\n    await Promise.allSettled([...this.connectionEntrySpawnPromises.values()])\n\n    const entries = [...this.connectionEntries.values()]\n\n    this.connectionEntries.clear()\n    this.connectionEntrySpawnPromises.clear()\n    this.connection = undefined\n    this.activeCheckoutCount = 0\n\n    for (const entry of entries) await entry.connection.close()\n  }\n\n  /**\n   * Returns the mutable ambient fallback connection.\n   * @returns {import(\"../drivers/base.js\").default} - Mutable ambient fallback connection.\n   */\n  getCurrentConnection() {\n    if (!this.connection) throw new Error(\"A connection hasn't been made yet\")\n\n    return this.connection\n  }\n\n  /**\n   * Returns the current context fallback connection when it is not suppressed.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - Current fallback connection.\n   */\n  getCurrentContextConnection() {\n    if (this.suppressedConnectionContextCount > 0) return undefined\n\n    return this.connection\n  }\n\n  /**\n   * Returns whether fallback context is available.\n   * @returns {boolean} - Whether fallback context is available.\n   */\n  hasCurrentConnectionContext() {\n    return this.suppressedConnectionContextCount === 0\n  }\n\n  /**\n   * Returns pool diagnostics for retained and temporary keyed connections.\n   * @returns {import(\"./base.js\").DatabasePoolDebugSnapshot} - Pool diagnostics.\n   */\n  getDebugSnapshot() {\n    const connections = [...this.connectionEntries.values()].map((entry) => this.debugConnectionSnapshot(entry.connection, {\n      activeCheckoutCount: entry.activeCheckoutCount,\n      state: entry.retained ? \"shared\" : entry.activeCheckoutCount > 0 ? \"in-use\" : \"idle\"\n    }))\n    const now = Date.now()\n\n    return {\n      ...super.getDebugSnapshot(),\n      connections,\n      connectionsBeingSpawned: this.connectionsBeingSpawned,\n      idleCount: [...this.connectionEntries.values()].filter((entry) => entry.activeCheckoutCount === 0).length,\n      inUseCount: [...this.connectionEntries.values()].filter((entry) => entry.activeCheckoutCount > 0).length,\n      pendingCheckouts: this.pendingCheckouts.map((pending, index) => ({\n        checkoutName: pending.checkoutName,\n        enqueuedAt: pending.enqueuedAt,\n        index,\n        remainingTimeoutMs: pending.timeoutAt === null ? null : Math.max(0, pending.timeoutAt - now),\n        reuseKey: pending.reuseKey,\n        timeoutAt: pending.timeoutAt,\n        timeoutMillis: pending.timeoutMillis,\n        waitingForMs: Math.max(0, now - pending.enqueuedAt)\n      })),\n      pendingCheckoutCount: this.pendingCheckouts.length\n    }\n  }\n\n  /**\n   * Returns the configured connection maximum.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration.\n   * @returns {number | null} - Configured connection maximum.\n   */\n  maxConnections(databaseConfiguration) {\n    const value = databaseConfiguration.pool?.max\n\n    if (value === null) return null\n    if (typeof value === \"number\" && Number.isFinite(value) && value >= 1) return value\n\n    return DEFAULT_MAX_CONNECTIONS\n  }\n\n  /**\n   * Returns the configured checkout timeout.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration.\n   * @returns {number | null} - Configured checkout timeout.\n   */\n  checkoutTimeoutMillis(databaseConfiguration) {\n    const value = databaseConfiguration.pool?.checkoutTimeoutMillis\n\n    if (value === null) return null\n    if (typeof value === \"number\" && Number.isFinite(value) && value >= 0) return value\n\n    return DEFAULT_CHECKOUT_TIMEOUT_MILLIS\n  }\n\n  /**\n   * Returns whether another physical connection may be spawned.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration.\n   * @returns {boolean} - Whether another physical connection may be spawned.\n   */\n  canSpawnConnection(databaseConfiguration) {\n    const max = this.maxConnections(databaseConfiguration)\n\n    return max === null || this.connectionEntries.size + this.connectionsBeingSpawned < max\n  }\n\n  /**\n   * Atomically claims one connection slot without yielding.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration whose maximum applies.\n   * @returns {boolean} - Whether a slot was reserved.\n   */\n  tryReserveConnectionCapacity(databaseConfiguration) {\n    if (!this.canSpawnConnection(databaseConfiguration)) return false\n\n    this.connectionsBeingSpawned++\n\n    return true\n  }\n\n  /** Releases one previously claimed connection slot. */\n  releaseConnectionCapacityReservation() {\n    if (this.connectionsBeingSpawned < 1) {\n      throw new Error(\"Cannot release an unreserved database connection slot\")\n    }\n\n    this.connectionsBeingSpawned--\n    this.notifyCapacityWaiters()\n  }\n\n  /**\n   * Spawns and tracks a physical connection entry.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration.\n   * @param {string} reuseKey - Physical reuse key.\n   * @param {number} closeGeneration - Pool lifecycle generation at spawn start.\n   * @returns {Promise<SinglePoolConnectionEntry>} - New entry.\n   */\n  async spawnConnectionEntry(databaseConfiguration, reuseKey, closeGeneration) {\n    try {\n      const connection = await this.spawnConnectionForConfiguration(databaseConfiguration)\n\n      if (this.closeGeneration !== closeGeneration) {\n        await connection.close()\n        throw new Error(\"Database pool was closed before checkout completed.\")\n      }\n\n      /** @type {SinglePoolConnectionEntry} */\n      const entry = {activeCheckoutCount: 0, checkoutNames: [], connection, retained: false, reuseKey}\n\n      this.connectionEntries.set(reuseKey, entry)\n\n      return entry\n    } finally {\n      this.releaseConnectionCapacityReservation()\n    }\n  }\n\n  /**\n   * Removes and closes an entry.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @returns {SinglePoolConnectionEntry | undefined} - Entry owning a connection.\n   */\n  entryForConnection(connection) {\n    return [...this.connectionEntries.values()].find((entry) => entry.connection === connection)\n  }\n\n  /**\n   * Adds a same-key operation pending entry.\n   * @param {SinglePoolConnectionEntry} entry - Entry to close.\n   * @returns {Promise<void>} - Resolves after close.\n   */\n  async removeAndCloseEntry(entry) {\n    if (this.connectionEntries.get(entry.reuseKey) !== entry) return\n\n    this.connectionEntries.delete(entry.reuseKey)\n    if (this.connection === entry.connection) this.connection = undefined\n    await entry.connection.close()\n    this.notifyCapacityWaiters()\n  }\n\n  /** Wakes all capacity waiters to re-check the bounded pool. */\n  notifyCapacityWaiters() {\n    for (const reserveAndResolve of this.capacityWaiters) {\n      if (reserveAndResolve()) return\n    }\n  }\n\n  /**\n   * Adds a same-key operation pending entry.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Physical configuration.\n   * @param {{name?: string, reuseKey: string}} options - Pending identity.\n   * @returns {SinglePoolPendingCheckout} - Added same-key operation pending entry.\n   */\n  addOperationPendingCheckout(databaseConfiguration, {name, reuseKey}) {\n    const timeoutMillis = this.checkoutTimeoutMillis(databaseConfiguration)\n    const enqueuedAt = Date.now()\n    /**\n     * Rejects the close-owned promise.\n     * @type {(error: Error) => void}\n     */\n    let rejectClose = () => {}\n    const closePromise = new Promise((resolve, reject) => {\n      void resolve\n      rejectClose = reject\n    })\n    const pending = {\n      checkoutName: name,\n      closePromise,\n      enqueuedAt,\n      reject: rejectClose,\n      reuseKey,\n      timeoutAt: timeoutMillis === null ? null : enqueuedAt + timeoutMillis,\n      timeoutMillis\n    }\n\n    this.pendingCheckouts.push(pending)\n\n    return pending\n  }\n\n  /**\n   * Removes a pending checkout debug entry.\n   * @param {SinglePoolPendingCheckout} pending - Pending entry.\n   * @returns {void}\n   */\n  removePendingCheckout(pending) {\n    const index = this.pendingCheckouts.indexOf(pending)\n\n    if (index !== -1) this.pendingCheckouts.splice(index, 1)\n  }\n}\n"]}