velocious 1.0.698 → 1.0.700

package/build/src/database/drivers/base.js

@@ -276,6 +276,30 @@ function formatElapsedMs(elapsedMs) {
     return `${Math.max(elapsedMs, 0).toFixed(1)}ms`;
 }
 export default class VelociousDatabaseDriversBase {
+    /**
+     * Process-wide state for the **process-local advisory-lock pre-filter
+     * tier** shared by every driver (SQLite, MySQL/MariaDB, PostgreSQL,
+     * MSSQL). It serializes concurrent acquisitions of the same lock name
+     * inside this process through a FIFO waiter queue before any caller
+     * contacts the driver-native tier, so a contended same-process waiter
+     * never parks a pooled database connection in a driver lock state
+     * (MariaDB `User lock`, `sp_getapplock` session hold, ...).
+     *
+     * This tier is a pre-filter, **never the authority**: a grant here only
+     * means "you are next in this process." Cross-process/cross-host
+     * exclusion is confirmed by the driver-native tier (or, once the
+     * STC-210 backend chain lands, the configured cross-host backend)
+     * before the acquisition succeeds.
+     *
+     * `ownersByName` maps each held lock name to the driver instance that
+     * acquired it so `releaseAdvisoryLock` can reject releases from drivers
+     * that do not own the lock.
+     * @type {{ownersByName: Map<string, VelociousDatabaseDriversBase>, waitersByName: Map<string, Array<() => void>>}}
+     */
+    static _advisoryLockState = {
+        ownersByName: new Map(),
+        waitersByName: new Map()
+    };
     /**
      * Id seq.
      * @type {number | undefined} */
@@ -2620,29 +2644,71 @@ export default class VelociousDatabaseDriversBase {
      * Advisory locks are connection-scoped and do not interact with row or
      * table locks; they are purely cooperative between callers that use the
      * same name and let you serialize functionality without blocking readers
-     * or writers that do not participate in the same lock.
+     * or writers that do not participate in the same named lock.
+     *
+     * Acquisition runs as a two-tier chain:
+     * 1. The **process-local pre-filter tier** (this class' FIFO waiter
+     *    queue) serializes same-process callers for the lock name without
+     *    issuing any driver-native lock query and without parking a
+     *    connection in a driver lock state. A queued caller never reaches
+     *    tier 2 until the in-process holder releases.
+     * 2. The **driver-native tier** (`_acquireAdvisoryLock`: MariaDB
+     *    `GET_LOCK`, PostgreSQL `pg_advisory_lock`, SQL Server
+     *    `sp_getapplock`, SQLite filesystem lock on Node) confirms the
+     *    cross-process/cross-host exclusion.
+     *
+     * The process-local tier is a pre-filter, **never the authority**: a
+     * lock name that other processes or hosts can request is only granted
+     * after the driver-native tier (or, once the STC-210 backend chain
+     * lands, the configured cross-host backend) confirms it. If the native
+     * tier denies or times out, the in-process hold is rolled back.
      * @param {string} name - Lock name.
-     * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null` blocks forever, and an omitted value uses the database's `advisoryLockAcquireTimeoutMs` or the framework default.
+     * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null` blocks forever, and an omitted value uses the database's `advisoryLockAcquireTimeoutMs` or the framework default. The bound covers the whole two-tier acquisition.
      * @returns {Promise<boolean>} - Resolves to true when the lock has been acquired, false if the timeout elapsed.
      */
     async acquireAdvisoryLock(name, args = {}) {
         const timeoutMs = this.advisoryLockAcquireTimeoutMs(args);
+        const deadlineMs = typeof timeoutMs === "number" && timeoutMs >= 0 ? Date.now() + timeoutMs : null;
+        const localAcquisition = await this._acquireProcessLocalAdvisoryLock(name, { timeoutMs });
+        if (!localAcquisition.acquired)
+            return false;
+        if (!this.supportsDriverNativeAdvisoryLock()) {
+            // No driver-native tier exists for this driver (plain SQLite): the
+            // process-local tier is the whole implementation, and callers must
+            // not read it as a cross-process guarantee.
+            this._trackAdvisoryLock(name);
+            return true;
+        }
+        // Only a caller that actually queued in the process-local tier spends
+        // part of the acquire budget; an uncontended acquisition passes the
+        // full bound on to the driver-native tier.
+        const nativeTimeoutMs = localAcquisition.waited && deadlineMs !== null
+            ? Math.max(0, deadlineMs - Date.now())
+            : timeoutMs;
         const startedAt = Date.now();
-        const acquired = await this._acquireAdvisoryLock(name, { timeoutMs });
+        /** @type {boolean} */
+        let nativeAcquired;
+        try {
+            nativeAcquired = await this._acquireAdvisoryLock(name, { timeoutMs: nativeTimeoutMs });
+        }
+        catch (error) {
+            this._releaseProcessLocalAdvisoryLock(name);
+            throw error;
+        }
         const durationMs = Date.now() - startedAt;
-        if (acquired) {
+        if (nativeAcquired) {
             this._trackAdvisoryLock(name);
             const slowAcquireMs = advisoryLockTelemetryThresholds(this.getArgs()).slowAcquireMs;
             if (slowAcquireMs !== null && durationMs > slowAcquireMs) {
                 await this._reportAdvisoryLockTelemetry({ event: "advisory-lock-slow-acquire", lockName: name, durationMs, outcome: "acquired", timeoutMs });
             }
+            return true;
         }
-        else {
-            // The wait exceeded its bound: attribute the lock to the holder that
-            // blocked it, captured at this moment on this tier.
-            await this._reportAdvisoryLockTelemetry({ event: "advisory-lock-acquire-timeout", lockName: name, durationMs, outcome: "timeout", timeoutMs, captureHolder: true });
-        }
-        return acquired;
+        this._releaseProcessLocalAdvisoryLock(name);
+        // The wait exceeded its bound: attribute the lock to the holder that
+        // blocked it, captured at this moment on this tier.
+        await this._reportAdvisoryLockTelemetry({ event: "advisory-lock-acquire-timeout", lockName: name, durationMs, outcome: "timeout", timeoutMs, captureHolder: true });
+        return false;
     }
     /**
      * Resolves the wait bound for one advisory-lock acquisition.
@@ -2663,8 +2729,130 @@ export default class VelociousDatabaseDriversBase {
             return configured;
         return DEFAULT_ADVISORY_LOCK_ACQUIRE_TIMEOUT_MS;
     }
+    /**
+     * Whether this driver has a driver-native advisory-lock tier behind the
+     * process-local pre-filter. MariaDB (`GET_LOCK`), PostgreSQL
+     * (`pg_advisory_lock`) and SQL Server (`sp_getapplock`) do; SQLite has
+     * no native primitive (the Node SQLite driver substitutes its
+     * filesystem lock directory, the web/native builds have nothing), so
+     * for plain SQLite the process-local tier IS the whole implementation
+     * and callers must not read it as a cross-process guarantee.
+     * @returns {boolean} - Whether the driver-native tier exists.
+     */
+    supportsDriverNativeAdvisoryLock() {
+        return true;
+    }
+    /**
+     * Whether the driver's native tier is re-entrant within the same
+     * session. `GET_LOCK`, `pg_advisory_lock` and `sp_getapplock` grant the
+     * same session repeatedly, so the process-local tier must let a
+     * re-acquisition by its own owner pass through to the native tier.
+     * SQLite's emulation (including the Node filesystem lock) is not
+     * re-entrant, so the tier keeps treating a re-acquisition as contention
+     * exactly as the SQLite emulation always has.
+     * @returns {boolean} - Whether same-instance re-acquisition is honored.
+     */
+    supportsReentrantAdvisoryLock() {
+        return true;
+    }
+    /**
+     * Process-local pre-filter tier: FIFO waiter queue for one lock name
+     * inside this process. This is the promoted SQLite emulation from
+     * STC-211 — it now runs in front of **every** driver's native tier so a
+     * same-process waiter never issues a driver-native lock query and never
+     * parks a pooled connection in a driver lock state while queued.
+     *
+     * A grant here means only "you are the next caller in this process."
+     * It is never the authority for cross-process/cross-host exclusion; the
+     * caller must still pass the driver-native tier before the lock counts
+     * as held. A re-entrant acquisition by the owning driver instance is
+     * granted immediately, mirroring the session-scoped re-entrancy of
+     * `GET_LOCK` / `pg_advisory_lock` / `sp_getapplock`.
+     * @param {string} name - Lock name.
+     * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
+     * @returns {Promise<{acquired: boolean, waited: boolean}>} - Whether the tier granted this caller, and whether it had to queue for it.
+     */
+    async _acquireProcessLocalAdvisoryLock(name, { timeoutMs } = {}) {
+        const state = VelociousDatabaseDriversBase._advisoryLockState;
+        let waited = false;
+        while (state.ownersByName.has(name)) {
+            if (state.ownersByName.get(name) === this && this.supportsReentrantAdvisoryLock())
+                break;
+            waited = true;
+            let remainingMs = null;
+            if (typeof timeoutMs === "number" && timeoutMs >= 0) {
+                remainingMs = timeoutMs;
+                if (remainingMs <= 0)
+                    return { acquired: false, waited };
+            }
+            await new Promise((resolve) => {
+                const waiters = state.waitersByName.get(name) || [];
+                /**
+                 * Timeout handle.
+                 * @type {ReturnType<typeof setTimeout> | null} */
+                let timeoutHandle = null;
+                /**
+                 * Remove and resolve.
+                 * @type {(() => void) | null} */
+                let removeAndResolve = null;
+                removeAndResolve = () => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    const current = state.waitersByName.get(name) || [];
+                    const index = current.indexOf(/** @type {() => void} */ (removeAndResolve));
+                    if (index >= 0)
+                        current.splice(index, 1);
+                    if (current.length === 0)
+                        state.waitersByName.delete(name);
+                    resolve(undefined);
+                };
+                waiters.push(removeAndResolve);
+                state.waitersByName.set(name, waiters);
+                if (remainingMs !== null) {
+                    timeoutHandle = setTimeout(() => {
+                        if (removeAndResolve)
+                            removeAndResolve();
+                    }, remainingMs);
+                }
+            });
+            if (typeof timeoutMs === "number" && timeoutMs >= 0 && state.ownersByName.has(name) && !(state.ownersByName.get(name) === this && this.supportsReentrantAdvisoryLock())) {
+                return { acquired: false, waited };
+            }
+        }
+        state.ownersByName.set(name, this);
+        return { acquired: true, waited };
+    }
+    /**
+     * Hands the process-local tier for one lock name to the next FIFO waiter,
+     * but only when **this** driver instance currently owns it. A release by
+     * a non-owner is a no-op, matching the "you can only release locks you
+     * own" contract of `RELEASE_LOCK` / `pg_advisory_unlock`.
+     * @param {string} name - Lock name.
+     * @returns {boolean} - Whether this instance owned the tier and released it.
+     */
+    _releaseProcessLocalAdvisoryLock(name) {
+        const state = VelociousDatabaseDriversBase._advisoryLockState;
+        const owner = state.ownersByName.get(name);
+        if (owner !== this)
+            return false;
+        state.ownersByName.delete(name);
+        const waiters = state.waitersByName.get(name);
+        if (waiters && waiters.length > 0) {
+            const nextWaiter = waiters.shift();
+            if (waiters.length === 0)
+                state.waitersByName.delete(name);
+            if (nextWaiter)
+                nextWaiter();
+        }
+        return true;
+    }
     /**
      * Driver-specific blocking advisory-lock acquisition hook.
+     * This is the **driver-native tier** of the acquisition chain: MariaDB
+     * `GET_LOCK`, PostgreSQL `pg_advisory_lock`, SQL Server `sp_getapplock`,
+     * the Node SQLite filesystem lock. It runs only after the process-local
+     * pre-filter tier has granted this caller its turn, and its result is
+     * what actually confirms cross-process/cross-host exclusion.
      * @abstract
      * @param {string} name - Lock name.
      * @param {{timeoutMs?: number | null}} [_args] - Lock timeout options.
@@ -2675,14 +2863,48 @@ export default class VelociousDatabaseDriversBase {
     }
     /**
      * Attempts to acquire a named advisory lock without blocking.
+     *
+     * Same two-tier chain as `acquireAdvisoryLock`: the process-local tier
+     * short-circuits contention between callers in this process (a queued
+     * name never reaches the driver-native hook), and the driver-native tier
+     * confirms cross-process/cross-host exclusion. A free in-process tier is
+     * NOT a grant — the native tier still has to agree.
      * @param {string} name - Lock name.
      * @returns {Promise<boolean>} - Resolves to true if the lock was acquired, false if it was already held.
      */
     async tryAcquireAdvisoryLock(name) {
-        const acquired = await this._tryAcquireAdvisoryLock(name);
-        if (acquired)
+        const owner = VelociousDatabaseDriversBase._advisoryLockState.ownersByName.get(name);
+        if (owner !== undefined && owner !== this)
+            return false;
+        // Same-instance re-acquisition mirrors the re-entrant semantics of the
+        // session-scoped driver-native locks; a non-re-entrant driver (SQLite)
+        // keeps treating it as contention, exactly as the emulation always did.
+        const reentrant = owner === this;
+        if (reentrant && !this.supportsReentrantAdvisoryLock())
+            return false;
+        if (!reentrant)
+            VelociousDatabaseDriversBase._advisoryLockState.ownersByName.set(name, this);
+        if (!this.supportsDriverNativeAdvisoryLock()) {
             this._trackAdvisoryLock(name);
-        return acquired;
+            return true;
+        }
+        /** @type {boolean} */
+        let acquired;
+        try {
+            acquired = await this._tryAcquireAdvisoryLock(name);
+        }
+        catch (error) {
+            if (!reentrant)
+                this._releaseProcessLocalAdvisoryLock(name);
+            throw error;
+        }
+        if (!acquired) {
+            if (!reentrant)
+                this._releaseProcessLocalAdvisoryLock(name);
+            return false;
+        }
+        this._trackAdvisoryLock(name);
+        return true;
     }
     /**
      * Driver-specific non-blocking advisory-lock acquisition hook.
@@ -2695,10 +2917,33 @@ export default class VelociousDatabaseDriversBase {
     }
     /**
      * Releases a named advisory lock previously acquired on this connection.
+     * The driver-native release runs first; the process-local tier is handed
+     * to the next waiter only once this connection's counted registry no
+     * longer holds the name, so re-entrant acquisitions release one level at
+     * a time exactly like the session-scoped driver locks.
      * @param {string} name - Lock name.
      * @returns {Promise<boolean>} - Resolves to true if the lock was held by this session and has now been released.
      */
     async releaseAdvisoryLock(name) {
+        const owner = VelociousDatabaseDriversBase._advisoryLockState.ownersByName.get(name);
+        // Another driver instance in this process owns the tier for this name,
+        // so this connection can never be the native holder either — refuse
+        // before issuing a release statement that could disturb the owner.
+        if (owner !== undefined && owner !== this)
+            return false;
+        if (!this.supportsDriverNativeAdvisoryLock()) {
+            // Plain SQLite: the process-local tier IS the lock, so the first
+            // release by the owner releases it fully, exactly as the SQLite
+            // emulation always has.
+            const released = this._releaseProcessLocalAdvisoryLock(name);
+            if (released) {
+                this._untrackAdvisoryLock(name);
+            }
+            else {
+                this._heldAdvisoryLocks.delete(name);
+            }
+            return released;
+        }
         const released = await this._releaseAdvisoryLock(name);
         if (released) {
             this._untrackAdvisoryLock(name);
@@ -2716,6 +2961,9 @@ export default class VelociousDatabaseDriversBase {
                     await this._reportAdvisoryLockTelemetry({ event: "advisory-lock-slow-hold", lockName: name, durationMs: holdDurationMs, outcome: null, timeoutMs: null });
                 }
             }
+            // Last connection-level release: hand the process-local tier to the
+            // next queued caller in this process.
+            this._releaseProcessLocalAdvisoryLock(name);
         }
         return released;
     }
@@ -2779,12 +3027,29 @@ export default class VelociousDatabaseDriversBase {
      * Checks whether a named advisory lock is currently held by any session.
      * Intended as an introspection helper; callers who need to act on the
      * result should prefer `tryAcquireAdvisoryLock` to avoid a TOCTOU race.
+     *
+     * The process-local tier answers first (a same-process holder is a
+     * holder, full stop); otherwise the question goes to the driver-native
+     * tier's introspection (`IS_USED_LOCK` / `pg_locks` / `APPLOCK_TEST`).
+     * @param {string} name - Lock name.
+     * @returns {Promise<boolean>} - Resolves to true if the lock is held by any session.
+     */
+    async isAdvisoryLockHeld(name) {
+        if (VelociousDatabaseDriversBase._advisoryLockState.ownersByName.has(name))
+            return true;
+        if (!this.supportsDriverNativeAdvisoryLock())
+            return false;
+        return await this._isAdvisoryLockHeldNative(name);
+    }
+    /**
+     * Driver-native advisory-lock introspection hook behind
+     * `isAdvisoryLockHeld`.
      * @abstract
      * @param {string} name - Lock name.
-     * @returns {Promise<boolean>} - Resolves to true if the lock is held by ? session.
+     * @returns {Promise<boolean>} - Resolves to true if the native tier reports the lock held.
      */
-    isAdvisoryLockHeld(name) {
-        throw new Error(`'isAdvisoryLockHeld' not implemented for ${this.constructor.name}`);
+    _isAdvisoryLockHeldNative(name) {
+        throw new Error(`'_isAdvisoryLockHeldNative' not implemented for ${this.constructor.name}`);
     }
     /**
      * Which advisory-lock backend tier this connection serves (STC-210 chain
@@ -2849,4 +3114,4 @@ export default class VelociousDatabaseDriversBase {
         emitAdvisoryLockTelemetryReport(this.configuration, report);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../src/database/drivers/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * CreateIndexSqlArgs type.\n * @typedef {object} CreateIndexSqlArgs\n * @property {Array<string | import(\"./../table-data/table-column.js\").default>} columns - Columns to include in the index.\n * @property {boolean} [ifNotExists] - Skip creation if the index already exists.\n * @property {string} [name] - Explicit index name to use.\n * @property {boolean} [unique] - Whether the index should enforce uniqueness.\n * @property {string} tableName - Name of the table to add the index to.\n */\n/**\n * RemoveIndexSqlArgs type.\n * @typedef {object} RemoveIndexSqlArgs\n * @property {string} name - Index name to drop.\n * @property {string} tableName - Name of the table the index belongs to.\n */\n/**\n * DropTableSqlArgsType type.\n * @typedef {object} DropTableSqlArgsType\n * @property {boolean} [cascade] - Whether dependent objects should be dropped too.\n * @property {boolean} [ifExists] - Skip dropping if the table does not exist.\n */\n/**\n * DeleteSqlArgsType type.\n * @typedef {object} DeleteSqlArgsType\n * @property {string} tableName - Table name to delete from.\n * @property {{[key: string]: ReturnType<typeof JSON.parse>}} conditions - Conditions used to build the delete WHERE clause.\n */\n/**\n * InsertSqlArgsType type.\n * @typedef {object} InsertSqlArgsType\n * @property {string[]} [columns] - Column names for `rows` inserts.\n * @property {{[key: string]: ReturnType<typeof JSON.parse>}} [data] - Column/value pairs for a single-row insert.\n * @property {boolean} [multiple] - Whether this insert should be treated as multi-row.\n * @property {string[]} [returnLastInsertedColumnNames] - Column names to return after insert.\n * @property {Array<Array<ReturnType<typeof JSON.parse>>>} [rows] - Row values for a multi-row insert.\n * @property {string} tableName - Table name to insert into.\n */\n/**\n * QueryRowType type.\n * @typedef {Record<string, ReturnType<typeof JSON.parse>>} QueryRowType\n * @typedef {Array<QueryRowType>} QueryResultType\n */\n/**\n * TransactionCallbackFrame type.\n * @typedef {object} TransactionCallbackFrame\n * @property {Array<() => void | Promise<void>>} afterCommitCallbacks - Callbacks to merge or run after commit.\n * @property {Array<() => void | Promise<void>>} beforeCommitCallbacks - Guards to run before this frame completes.\n */\n/**\n * RetryableDatabaseErrorResult type.\n * @typedef {object} RetryableDatabaseErrorResult\n * @property {boolean} retry - Whether the error should be retried.\n * @property {boolean} reconnect - Whether to reconnect before retrying.\n * @property {boolean} [deadlock] - Whether the error is a transaction deadlock/lock-wait-timeout that should retry the whole transaction.\n * @property {\"deadlock\" | \"lock-wait-timeout\"} [contentionKind] - Classified transaction contention kind.\n * @property {number} [maxTries] - Override the max retry attempts.\n * @property {number} [waitMs] - Wait time before retrying in milliseconds.\n */\n/**\n * QueryOptions type.\n * @typedef {object} QueryOptions\n * @property {string} [logName] - Query log subject.\n * @property {boolean} [logQuery] - Whether to log the query.\n * @property {boolean} [processListComment] - Whether to add process-list comments to the query.\n * @property {number} [requestTimeoutMs] - Per-request driver timeout in milliseconds; zero disables the deadline on supporting drivers.\n * @property {boolean} [retry] - Whether retryable errors may retry the query; defaults to true.\n * @property {boolean} [sessionTimeZone] - Whether to ensure the configured database session time zone before the query.\n * @property {boolean} [sqliteScript] - Internal SQLite flag selecting native multi-statement script execution.\n * @property {AbortSignal} [signal] - Aborts the in-flight query (destroying its connection) when it fires.\n * @property {string} [sourceStack] - Stack captured at the caller boundary.\n * @property {symbol} [operationOwner] - Opaque owner for an operation-leased connection.\n */\n\n/**\n * DeadlockRetryDiagnosticSnapshot type.\n * @typedef {object} DeadlockRetryDiagnosticSnapshot\n * @property {number} attempt - One-based transaction attempt.\n * @property {\"deadlock\" | \"lock-wait-timeout\"} contentionKind - Classified contention kind.\n * @property {string} [databaseIdentifier] - Redacted logical database pool identifier marker.\n * @property {string} [databaseIdentifierFingerprint] - Opaque logical database pool identity.\n * @property {string} [databaseIdentityFingerprint] - Opaque physical database identity.\n * @property {string} driverType - Driver type.\n * @property {number} maxAttempts - Configured transaction attempt budget.\n * @property {string} [operationName] - Redacted operation-name marker.\n * @property {string} [operationNameFingerprint] - Opaque operation-name identity.\n * @property {string} [sqlFingerprint] - Normalized SQL-shape fingerprint.\n * @property {string} [sqlOperation] - SQL verb.\n * @property {string} stage - Error-event stage.\n * @property {number} transactionAttemptDurationMs - Duration of the failed outer attempt.\n * @property {boolean} willRetry - Whether another outer transaction attempt will run.\n */\n\n/**\n * TestProfileQueryAttempt type.\n * @typedef {object} TestProfileQueryAttempt\n * @property {import(\"../../testing/test-profiler.js\").TestProfileAsyncContext} context - Captured async attribution.\n * @property {{sqlFingerprint: string, sqlOperation: string}} diagnostic - Redacted statement diagnostic.\n * @property {number} startedAtMs - Physical attempt start time.\n */\n\n/**\n * ActiveQueryDebugSnapshot type.\n * @typedef {object} ActiveQueryDebugSnapshot\n * @property {string[]} annotations - Database annotations active when the query started.\n * @property {string} logName - Query log name.\n * @property {number} startedAtUnixMs - Query start timestamp.\n * @property {number} runningMs - Query runtime in milliseconds.\n * @property {string} sqlPreview - Truncated SQL preview.\n */\n\n/**\n * DatabaseConnectionDebugSnapshot type.\n * @typedef {object} DatabaseConnectionDebugSnapshot\n * @property {ActiveQueryDebugSnapshot | null} activeQuery - Currently running query, if any.\n * @property {number | undefined} checkedOutAtUnixMs - Checkout start timestamp for active checkouts.\n * @property {number | undefined} checkoutAgeMs - Active checkout age in milliseconds.\n * @property {string | undefined} checkoutName - Human-readable checkout name.\n * @property {string} driverClass - Driver class name.\n * @property {number | undefined} idSeq - Pool checkout ID sequence.\n * @property {number} openTransactions - Number of open transaction frames.\n * @property {number} schemaCacheEntries - Number of cached schema metadata entries.\n */\n\n/**\n * ActiveQueryState type.\n * @typedef {object} ActiveQueryState\n * @property {string[]} annotations - Database annotations active when the query started.\n * @property {string} logName - Query log name.\n * @property {number} startedAtUnixMs - Query start timestamp.\n * @property {string} sqlPreview - Truncated SQL preview.\n */\n\n/**\n * UpdateSqlArgsType type.\n * @typedef {object}UpdateSqlArgsType\n * @property {object} conditions - Conditions used to build the update WHERE clause.\n * @property {object} data - Column/value pairs to update.\n * @property {string} tableName - Table name to update.\n */\n/**\n * UpsertSqlArgsType type.\n * @typedef {object}UpsertSqlArgsType\n * @property {string[]} conflictColumns - Columns that define a conflict.\n * @property {object} data - Column/value pairs to insert.\n * @property {string} tableName - Table name to upsert into.\n * @property {string[]} updateColumns - Columns to update on conflict.\n */\n\n/**\n * SqlTokenResult type.\n * @typedef {object} SqlTokenResult\n * @property {boolean} incomplete - Whether the scan hit its bound before finishing trivia/token parsing.\n * @property {string | undefined} token - Lowercased token when parsing completed; undefined when no token was found.\n * @property {number} index - Index immediately after the parsed token or trivia.\n */\n\nimport BacktraceCleaner from \"../../utils/backtrace-cleaner.js\"\nimport { getDatabaseAnnotations } from \"../annotations.js\"\nimport { formatDateForDatabase } from \"../datetime-storage.js\"\nimport isDate from \"../../utils/is-date.js\"\nimport {DEFAULT_ADVISORY_LOCK_ACQUIRE_TIMEOUT_MS} from \"../advisory-lock-bound.js\"\nimport {advisoryLockTelemetryThresholds, emitAdvisoryLockTelemetryReport} from \"../advisory-lock-telemetry.js\"\nimport Logger from \"../../logger.js\"\nimport Query from \"../query/index.js\"\nimport QueryAbortedError from \"../query-aborted-error.js\"\nimport Handler from \"../handler.js\"\nimport { utf8ByteLength } from \"../../utils/utf8-byte-length.js\"\nimport Mutex from \"epic-locks/build/mutex.js\"\nimport UUID from \"pure-uuid\"\nimport TableData from \"../table-data/index.js\"\nimport TableColumn from \"../table-data/table-column.js\"\nimport TableForeignKey from \"../table-data/table-foreign-key.js\"\nimport wait from \"awaitery/build/wait.js\"\nimport { ensureError, optionalPositiveInteger } from \"typanic\"\nimport {coordinateSharedTransactionConnection, runWithoutSharedTransactionCoordinatorOwner} from \"../../testing/shared-transaction-connection-coordinator.js\"\nimport { currentTestProfileContext } from \"../../testing/test-profile-context.js\"\nimport sha256Hex from \"../../utils/sha256-hex.js\"\n\n/** Maximum characters inspected when building the debug SQL preview. */\nconst SQL_PREVIEW_SCAN_LIMIT = 4096\n/** Maximum characters inspected when deciding whether a statement invalidates schema metadata. */\nconst SCHEMA_INVALIDATION_SCAN_LIMIT = 8192\n/** Maximum checkout-name characters inspected by retry diagnostics. */\nconst OPERATION_NAME_SCAN_LIMIT = 1024\nconst REDACTED_DIAGNOSTIC_LABEL = \"[REDACTED]\"\n/** First backoff between retries of a schema-metadata read blocked by concurrent online DDL. */\nconst SCHEMA_METADATA_RETRY_INITIAL_DELAY_MS = 250\n/** Largest backoff between retries of a schema-metadata read blocked by concurrent online DDL. */\nconst SCHEMA_METADATA_RETRY_MAX_DELAY_MS = 2000\n/** Default bounded deadline for outlasting a concurrent online-DDL metadata skip. */\nconst SCHEMA_METADATA_RETRY_DEADLINE_MS = 60000\n\n/**\n * Builds a non-reversible, stable SQL fingerprint without retaining SQL text. Literal spelling is\n * normalized first so the same statement shape produces the same fingerprint across values.\n * @param {string} sql - SQL to fingerprint.\n * @returns {{sqlFingerprint: string, sqlOperation: string}} - Bounded query diagnostic.\n */\nfunction sqlDiagnostic(sql) {\n  let fingerprintInput = \"\"\n\n  for (let index = 0; index < sql.length;) {\n    const character = sql[index]\n    const nextCharacter = sql[index + 1]\n\n    if (character == \"'\" || character == '\"') {\n      const quote = character\n      fingerprintInput += \"?\"\n      index++\n\n      while (index < sql.length) {\n        if (sql[index] == \"\\\\\") {\n          index += 2\n        } else if (sql[index] == quote && sql[index + 1] == quote) {\n          index += 2\n        } else if (sql[index] == quote) {\n          index++\n          break\n        } else {\n          index++\n        }\n      }\n    } else if (character == \"/\" && nextCharacter == \"*\") {\n      const commentEnd = sql.indexOf(\"*/\", index + 2)\n      fingerprintInput += \" \"\n      index = commentEnd == -1 ? sql.length : commentEnd + 2\n    } else if ((character == \"-\" && nextCharacter == \"-\") || character == \"#\") {\n      const lineEnd = sql.indexOf(\"\\n\", index + 1)\n      fingerprintInput += \" \"\n      index = lineEnd == -1 ? sql.length : lineEnd + 1\n    } else {\n      fingerprintInput += character\n      index++\n    }\n  }\n\n  const normalized = fingerprintInput\n    .replace(/\\b(?:0x[0-9a-f]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b/gi, \"?\")\n    .replace(/\\s+/g, \" \")\n    .trim()\n    .toLowerCase()\n  let hash = 0xcbf29ce484222325n\n\n  for (let index = 0; index < normalized.length; index++) {\n    hash ^= BigInt(normalized.charCodeAt(index))\n    hash = BigInt.asUintN(64, hash * 0x100000001b3n)\n  }\n\n  const operationMatch = /^([a-z]+)/.exec(normalized)\n\n  return {\n    sqlFingerprint: `fnv1a64:${hash.toString(16).padStart(16, \"0\")}`,\n    sqlOperation: operationMatch ? operationMatch[1].toUpperCase() : \"UNKNOWN\"\n  }\n}\n\n/**\n * Marks a callback failure that happened after the owning transaction was durably committed.\n * The public transaction boundary unwraps it before deadlock classification.\n */\nclass VelociousDatabaseAfterCommitCallbackError extends Error {\n  /**\n   * Runs constructor.\n   * @param {ReturnType<typeof JSON.parse>} callbackError - Original callback failure.\n   */\n  constructor(callbackError) {\n    super(\"Database afterCommit callback failed\")\n    this.callbackError = callbackError\n  }\n}\n\n/**\n * Runs now ms.\n * @returns {number} - Current high-resolution-ish timestamp in milliseconds.\n */\nfunction nowMs() {\n  if (globalThis.performance && typeof globalThis.performance.now == \"function\") {\n    return globalThis.performance.now()\n  }\n\n  return Date.now()\n}\n\n/**\n * Runs format elapsed ms.\n * @param {number} elapsedMs - Elapsed milliseconds.\n * @returns {string} - Formatted elapsed milliseconds.\n */\nfunction formatElapsedMs(elapsedMs) {\n  return `${Math.max(elapsedMs, 0).toFixed(1)}ms`\n}\n\nexport default class VelociousDatabaseDriversBase {\n  /**\n   * Id seq.\n   * @type {number | undefined} */\n  idSeq = undefined\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {TransactionCallbackFrame[]} */\n  _transactionCallbackFrames\n  /** @type {Promise<void>} */\n  _transactionCompletionPromise\n  /** @type {(() => void) | undefined} */\n  _resolveTransactionCompletion\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {Map<string, Promise<ReturnType<typeof JSON.parse>>>} */\n  _schemaCache\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {(() => void) | undefined} */\n  _schemaCacheInvalidator\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {string | undefined} */\n  _connectionCheckoutName\n  /** @type {string | undefined} */\n  _databaseIdentifier\n  /** @type {string | undefined} */\n  _databaseIdentityFingerprint\n  /**\n   * Active query.\n   * @type {ActiveQueryState | null} */\n  _activeQuery = null\n  /** @type {WeakMap<Error, {sqlFingerprint: string, sqlOperation: string}>} */\n  _failedQueryDiagnostics = new WeakMap()\n  /** @type {Map<string, number>} */\n  _heldAdvisoryLocks = new Map()\n  /**\n   * When each tracked advisory lock was first acquired, so the final release can\n   * report a hold that outlived `advisoryLockTelemetry.slowHoldMs`.\n   * @type {Map<string, number>}\n   */\n  _advisoryLockAcquiredAtByName = new Map()\n  /**\n   * Stable per-connection holder identity used by advisory-lock telemetry when\n   * the tier can only name local holders.\n   * @type {string | undefined}\n   */\n  _advisoryLockHolderId = undefined\n  /**\n   * Exclusive operation lease installed by a single-multi-use pool.\n   * @type {import(\"../operation-lease.js\").default | undefined}\n   */\n  _operationLease = undefined\n\n  /**\n   * Runs constructor.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} config - Configuration object.\n   * @param {import(\"../../configuration.js\").default} configuration - Configuration instance.\n   */\n  constructor(config, configuration) {\n    this._args = config\n    this.configuration = configuration\n    this.mutex = new Mutex() // Can be used to lock this instance for exclusive use\n    this.logger = new Logger(this)\n    this._transactionCallbackFrames = []\n    this._transactionsCount = 0\n    this._transactionCompletionPromise = Promise.resolve()\n    this._resolveTransactionCompletion = undefined\n    this._transactionsActionsMutex = new Mutex()\n    this._physicalConnectionMutex = new Mutex()\n    this._schemaCache = new Map()\n  }\n\n  /**\n   * Serializes access to one physical database session.\n   * @template T\n   * @param {() => Promise<T>} callback - Physical driver operation.\n   * @returns {Promise<T>} - Operation result.\n   */\n  async _runPhysicalConnectionRequest(callback) {\n    return await this._physicalConnectionMutex.sync(async () => {\n      return await runWithoutSharedTransactionCoordinatorOwner(this, callback)\n    })\n  }\n\n  /**\n   * Cleans driver-specific session state before this logical connection is reusable.\n   * Drivers whose physical sessions cannot be safely reset should dispose them here.\n   * @returns {Promise<void>} - Resolves when the next checkout cannot observe prior session state.\n   */\n  async cleanupSessionStateAfterCheckout() {}\n\n  /**\n   * Runs add foreign key.\n   * @param {string} tableName - Table name.\n   * @param {string} columnName - Column name.\n   * @param {string} referencedTableName - Referenced table name.\n   * @param {string} referencedColumnName - Referenced column name.\n   * @param {object} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, args) {\n    this._assertNotReadOnly()\n    const tableForeignKeyArgs = Object.assign(\n      {\n        columnName,\n        tableName,\n        referencedColumnName,\n        referencedTableName\n      },\n      args\n    )\n    const tableForeignKey = new TableForeignKey(tableForeignKeyArgs)\n    const tableData = new TableData(tableName)\n\n    tableData.addForeignKey(tableForeignKey)\n\n    const alterTableSQLs = await this.alterTableSQLs(tableData)\n\n    for (const alterTableSQL of alterTableSQLs) {\n      await this.query(alterTableSQL)\n    }\n  }\n\n  /**\n   * Runs remove foreign key.\n   * @param {string} tableName - Table name.\n   * @param {import(\"./base-foreign-key.js\").default} foreignKeyMetadata - Foreign key metadata.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async removeForeignKey(tableName, foreignKeyMetadata) {\n    this._assertNotReadOnly()\n\n    const tableForeignKey = new TableForeignKey({\n      columnName: foreignKeyMetadata.getColumnName(),\n      dropForeignKey: true,\n      name: foreignKeyMetadata.getName(),\n      referencedColumnName: foreignKeyMetadata.getReferencedColumnName(),\n      referencedTableName: foreignKeyMetadata.getReferencedTableName(),\n      tableName\n    })\n    const tableData = new TableData(tableName)\n\n    tableData.addForeignKey(tableForeignKey)\n\n    const alterTableSQLs = await this.alterTableSQLs(tableData)\n\n    for (const alterTableSQL of alterTableSQLs) {\n      await this.query(alterTableSQL)\n    }\n  }\n\n  /**\n   * Runs alter table sqls.\n   * @abstract\n   * @param {import(\"../table-data/index.js\").default} _tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  alterTableSQLs(_tableData) {\n    throw new Error(\"alterTableSQLs not implemented\")\n  }\n\n  /**\n   * Runs connect.\n   * @abstract\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  connect() {\n    throw new Error(\"'connect' not implemented\")\n  }\n\n  /**\n   * Releases tracked advisory locks and closes the physical database connection.\n   * @returns {Promise<void>} - Resolves when cleanup and close complete.\n   */\n  async close() {\n    /** @type {Error | undefined} */\n    let advisoryLockError\n\n    try {\n      await this.releaseHeldAdvisoryLocks()\n    } catch (error) {\n      advisoryLockError = error instanceof Error ? error : new Error(\"Failed to release held advisory locks\", {cause: error})\n    }\n\n    try {\n      await this._close()\n      this._heldAdvisoryLocks.clear()\n    } catch (error) {\n      const closeError = error instanceof Error ? error : new Error(\"Failed to close database connection\", {cause: error})\n\n      if (advisoryLockError) {\n        throw new AggregateError([advisoryLockError, closeError], \"Failed to release advisory locks and close database connection\", {cause: error})\n      }\n\n      throw closeError\n    }\n\n    if (advisoryLockError) throw advisoryLockError\n  }\n\n  /**\n   * Driver-specific physical close hook.\n   * @returns {Promise<void>} - Resolves when the underlying connection closes.\n   */\n  async _close() {\n    // No-op by default\n  }\n\n  /**\n   * Flushes pending writes that the driver delayed for persistence.\n   * @returns {Promise<void>} - Resolves when pending writes are durable.\n   */\n  async flushPendingWrites() {\n    // No-op by default\n  }\n\n  /**\n   * Returns whether delayed persistence writes remain.\n   * @returns {boolean} - Whether writes remain.\n   */\n  hasPendingWrites() { return false }\n\n  /**\n   * Deletes this driver's physical database storage without opening it.\n   * @returns {Promise<void>} - Resolves after deletion.\n   */\n  async deleteDatabaseStorage() { throw new Error(`Database storage deletion is not supported by ${this.constructor.name}`) }\n\n  /**\n   * Runs set connection checkout name.\n   * @param {string | undefined} name - Human-readable name for this active checkout.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async setConnectionCheckoutName(name) {\n    this._connectionCheckoutName = name\n    this._connectionCheckedOutAtUnixMs = Date.now()\n  }\n\n  /**\n   * Runs clear connection checkout name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async clearConnectionCheckoutName() {\n    this._connectionCheckoutName = undefined\n    this._connectionCheckedOutAtUnixMs = undefined\n  }\n\n  /**\n   * Sets the pool-owned identity used by safe database diagnostics.\n   * @param {{databaseIdentifier: string, databaseIdentityFingerprint: string}} identity - Pool-stamped identity redacted at diagnostic snapshot time.\n   * @returns {void}\n   */\n  setPoolDiagnosticIdentity({databaseIdentifier, databaseIdentityFingerprint}) {\n    this._databaseIdentifier = databaseIdentifier\n    this._databaseIdentityFingerprint = databaseIdentityFingerprint\n  }\n\n  /**\n   * Runs reconnect.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async reconnect() {\n    this.clearSchemaCache()\n    await this.close()\n    await this.connect()\n  }\n\n  /**\n   * Runs create database sql.\n   * @abstract\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifNotExists] - Whether if not exists.\n   * @param {string} [args.databaseCharset] - Database-default character set (driver-specific; mysql/mariadb).\n   * @param {string} [args.databaseCollation] - Database-default collation (driver-specific; mysql/mariadb).\n   * @returns {string[]} - SQL statements.\n   */\n  createDatabaseSql(databaseName, args) { throw new Error(\"'createDatabaseSql' not implemented\") } // eslint-disable-line no-unused-vars\n\n  /**\n   * Runs drop database sql.\n   * @abstract\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifExists] - Whether if exists.\n   * @returns {string[]} - SQL statements.\n   */\n  dropDatabaseSql(databaseName, args) { throw new Error(\"'dropDatabaseSql' not implemented\") } // eslint-disable-line no-unused-vars\n\n  /**\n   * Runs create index sqls.\n   * @abstract\n   * @param {CreateIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createIndexSQLs(indexData) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'createIndexSQLs' not implemented\")\n  }\n\n  /**\n   * Runs remove index sqls.\n   * @abstract\n   * @param {RemoveIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async removeIndexSQLs(indexData) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'removeIndexSQLs' not implemented\")\n  }\n\n  /**\n   * Runs create table.\n   * @param {import(\"../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async createTable(tableData) {\n    this._assertNotReadOnly()\n    const sqls = await this.createTableSql(tableData)\n\n    for (const sql of sqls) {\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs create table sql.\n   * @abstract\n   * @param {import(\"../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createTableSql(tableData) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'createTableSql' not implemented\")\n  }\n\n  /**\n   * Runs delete.\n   * @param {DeleteSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async delete(args) {\n    this._assertNotReadOnly()\n    const sql = this.deleteSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs delete sql.\n   * @abstract\n   * @param {DeleteSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  deleteSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(`'deleteSql' not implemented`)\n  }\n\n  /**\n   * Runs drop table.\n   * @param {string} tableName - Table name.\n   * @param {DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async dropTable(tableName, args) {\n    this._assertNotReadOnly()\n    const sqls = await this.dropTableSQLs(tableName, args)\n\n    for (const sql of sqls) {\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs drop table sqls.\n   * @abstract\n   * @param {string} tableName - Table name.\n   * @param {DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async dropTableSQLs(tableName, args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"dropTableSQLs not implemented\")\n  }\n\n  /**\n   * Runs escape.\n   * @abstract\n   * @param {ReturnType<typeof JSON.parse>} value - Value to use.\n   * @returns {ReturnType<typeof JSON.parse>} - The escape.\n   */\n  escape(value) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'escape' not implemented\")\n  }\n\n  /**\n   * Runs get args.\n   * @returns {import(\"../../configuration-types.js\").DatabaseConfigurationType} - The args.\n   */\n  getArgs() {\n    return this._args\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../../configuration.js\").default} - The configuration.\n   */\n  getConfiguration() {\n    if (!this.configuration) throw new Error(\"No configuration set\")\n\n    return this.configuration\n  }\n\n  /**\n   * Installs an operation lease atomically with ordinary transaction admission.\n   * @param {import(\"../operation-lease.js\").default} operationLease - Active lease.\n   * @returns {Promise<void>} - Resolves once the lease owns transaction admission.\n   */\n  async setOperationLease(operationLease) {\n    await this._transactionsActionsMutex.sync(async () => {\n      if (this._operationLease) throw new Error(\"A database operation lease is already active\")\n      if (this._transactionsCount > 0) {\n        throw new Error(\"Cannot start a database operation while an unrelated ordinary transaction is already active\")\n      }\n\n      this._operationLease = operationLease\n    })\n  }\n\n  /**\n   * Clears the matching operation lease.\n   * @param {import(\"../operation-lease.js\").default} operationLease - Lease to clear.\n   * @returns {void}\n   */\n  clearOperationLease(operationLease) {\n    if (this._operationLease !== operationLease) {\n      throw new Error(\"Cannot clear a database operation lease owned by another operation\")\n    }\n\n    this._operationLease = undefined\n  }\n\n  /**\n   * Waits for an unrelated operation lease to release.\n   * @param {symbol | undefined} operationOwner - Candidate operation owner.\n   * @returns {Promise<void>}\n   */\n  async _waitForOperationLease(operationOwner) {\n    const operationLease = this._operationLease\n\n    if (operationLease) await operationLease.wait(operationOwner)\n  }\n\n  /**\n   * Runs get id seq.\n   * @returns {number | undefined} - The id seq.\n   */\n  getIdSeq() {\n    return this.idSeq\n  }\n\n  /**\n   * Runs primary key type.\n   * @returns {string} - Configured primary key type, defaulting to UUID.\n   */\n  primaryKeyType() {\n    return this.getArgs().primaryKeyType || \"uuid\"\n  }\n\n  /**\n   * Clears cached schema metadata for this driver instance.\n   * @returns {void} - No return value.\n   */\n  clearSchemaCache() {\n    if (this._schemaCacheInvalidator) {\n      this._schemaCacheInvalidator()\n      return\n    }\n\n    this._clearLocalSchemaCache()\n  }\n\n  /**\n   * Clears only the metadata cached on this driver instance.\n   * @returns {void} - No return value.\n   */\n  _clearLocalSchemaCache() {\n    this._schemaCache.clear()\n  }\n\n  /**\n   * Runs set schema cache invalidator.\n   * @param {() => void} invalidator - Callback used to clear schema caches that share this driver pool.\n   * @returns {void} - No return value.\n   */\n  setSchemaCacheInvalidator(invalidator) {\n    this._schemaCacheInvalidator = invalidator\n  }\n\n  /**\n   * Runs schema cache enabled.\n   * @returns {boolean} - Whether schema metadata caching is enabled.\n   */\n  _schemaCacheEnabled() {\n    return this.getArgs().schemaCache !== false\n  }\n\n  /**\n   * Runs schema metadata retry deadline ms.\n   * @returns {number} - Bounded deadline for outlasting transient schema-metadata contention.\n   */\n  _schemaMetadataRetryDeadlineMs() {\n    const configured = this.getArgs().schemaMetadataRetryDeadlineMs\n\n    return typeof configured === \"number\" ? configured : SCHEMA_METADATA_RETRY_DEADLINE_MS\n  }\n\n  /**\n   * Whether an error raised by a schema-metadata read is transient contention that a bounded\n   * retry can outlast. Drivers override this for their own contention signatures; the default\n   * treats every failure as final so only drivers that prove the transient shape retry it.\n   * @param {unknown} _error - Error raised by a schema-metadata read.\n   * @returns {boolean} - Whether the read may be retried.\n   */\n  _isTransientSchemaMetadataError(_error) {\n    return false\n  }\n\n  /**\n   * Runs a schema-metadata read, retrying transient concurrent-DDL contention until the bounded\n   * deadline. Non-transient failures and exhausted deadlines propagate the original error.\n   * @template T\n   * @param {() => Promise<T>} callback - Cache-miss schema read.\n   * @returns {Promise<T>} - Resolves with the read result.\n   */\n  async _withSchemaMetadataDdlRetry(callback) {\n    const deadlineMs = this._schemaMetadataRetryDeadlineMs()\n    const startedAt = Date.now()\n    let delayMs = SCHEMA_METADATA_RETRY_INITIAL_DELAY_MS\n\n    for (;;) {\n      try {\n        return await callback()\n      } catch (error) {\n        if (!this._isTransientSchemaMetadataError(error)) throw error\n        if (Date.now() - startedAt + delayMs > deadlineMs) throw error\n\n        await wait(delayMs)\n        delayMs = Math.min(delayMs * 2, SCHEMA_METADATA_RETRY_MAX_DELAY_MS)\n      }\n    }\n  }\n\n  /**\n   * Runs cached schema metadata.\n   * @template T\n   * @param {string} cacheKey - Schema cache key.\n   * @param {() => Promise<T>} callback - Cache miss callback.\n   * @returns {Promise<T>} - Resolves with the cached metadata.\n   */\n  async _cachedSchemaMetadata(cacheKey, callback) {\n    if (!this._schemaCacheEnabled()) return await this._withSchemaMetadataDdlRetry(callback)\n\n    const existingPromise = this._schemaCache.get(cacheKey)\n\n    if (existingPromise) {\n      return /** @type {T} */ (this._schemaCacheReturnValue(await existingPromise))\n    }\n\n    const promise = (async () => await this._withSchemaMetadataDdlRetry(callback))()\n\n    this._schemaCache.set(cacheKey, promise)\n\n    try {\n      return /** @type {T} */ (this._schemaCacheReturnValue(await promise))\n    } catch (error) {\n      if (this._schemaCache.get(cacheKey) === promise) {\n        this._schemaCache.delete(cacheKey)\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs cached table schema metadata.\n   * @template T\n   * @param {string} tableName - Table name.\n   * @param {string} metadataName - Metadata name.\n   * @param {() => Promise<T>} callback - Cache miss callback.\n   * @returns {Promise<T>} - Resolves with the cached table metadata.\n   */\n  async _cachedTableSchemaMetadata(tableName, metadataName, callback) {\n    return await this._cachedSchemaMetadata(`table:${tableName}:${metadataName}`, callback)\n  }\n\n  /**\n   * Runs schema cache return value.\n   * @param {ReturnType<typeof JSON.parse>} value - Cached value.\n   * @returns {ReturnType<typeof JSON.parse>} - Value returned to callers.\n   */\n  _schemaCacheReturnValue(value) {\n    if (Array.isArray(value)) return value.slice()\n\n    return value\n  }\n\n  /**\n   * Runs get tables.\n   * @abstract\n   * @returns {Promise<Array<import(\"./base-table.js\").default>>} - Resolves with the tables.\n   */\n  getTables() {\n    throw new Error(`${this.constructor.name}#getTables not implemented`)\n  }\n\n  /**\n   * Runs structure sql.\n   * @returns {Promise<string | null>} - Resolves with SQL string.\n   */\n  async structureSql() {\n    return null\n  }\n\n  /**\n   * Executes a whole multi-statement structure SQL script in a single round-trip when\n   * the driver supports it, running on this connection (so the caller's foreign-key\n   * handling applies). Returns true if it ran the whole script; false when the caller\n   * should run the statements individually. The base driver has no batch path.\n   * @param {string} _structureSql - Full multi-statement structure SQL.\n   * @returns {Promise<boolean>} - Whether the script was executed as one batch.\n   */\n  async execStructureScript(_structureSql) {\n    return false\n  }\n\n  /**\n   * Runs get table by name.\n   * @param {string} name - Name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} args.throwError - Whether throw error.\n   * @returns {Promise<import(\"./base-table.js\").default | undefined>} - Resolves with the table by name.\n   */\n  async getTableByName(name, args) {\n    const tables = await this.getTables()\n    const tableNames = []\n    let table\n\n    for (const candidate of tables) {\n      const candidateName = candidate.getName()\n\n      if (candidateName == name) {\n        table = candidate\n        break\n      }\n\n      tableNames.push(candidateName)\n    }\n\n    if (!table && args?.throwError !== false) {\n      throw new Error(this._missingTableErrorMessage(name, tableNames))\n    }\n\n    return table\n  }\n\n  /**\n   * Runs missing table error message.\n   * @param {string} name - Table name.\n   * @param {string[]} tableNames - Available table names.\n   * @returns {string} - Error message.\n   */\n  _missingTableErrorMessage(name, tableNames) {\n    const environment = this.getConfiguration().getEnvironment()\n    const args = this.getArgs()\n    const databaseName = args?.database || args?.name || args?.useDatabase || \"unknown\"\n\n    return `Couldn't find a table by that name \"${name}\" in: ${tableNames.join(\", \")} (environment: ${environment}, database: ${databaseName})`\n  }\n\n  /**\n   * Runs get table by name or fail.\n   * @param {string} name - Name.\n   * @returns {Promise<import(\"./base-table.js\").default>} - Resolves with the table by name or fail.\n   */\n  async getTableByNameOrFail(name) {\n    return /** @type {import(\"./base-table.js\").default} */ (await this.getTableByName(name, {throwError: true}))\n  }\n\n  /**\n   * Runs get type.\n   * @abstract\n   * @returns {string} - The type.\n   */\n  getType() {\n    throw new Error(\"'type' not implemented\")\n  }\n\n  /**\n   * Whether this driver can combine unrelated alter-table operations into a\n   * single `ALTER TABLE` statement (Rails' `supports_bulk_alter`).\n   * @returns {boolean} - Whether bulk alter is supported.\n   */\n  supportsBulkAlter() {\n    return false\n  }\n\n  /**\n   * Whether a bulk `ALTER TABLE` statement can also carry `ADD INDEX` clauses.\n   * Only drivers that support this keep index adds inside the combined batch;\n   * the rest execute each index as its own statement.\n   * @returns {boolean} - Whether indexes can be added inside a bulk alter.\n   */\n  supportsBulkAlterIndexes() {\n    return false\n  }\n\n  /**\n   * Runs insert.\n   * @param {InsertSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insert(args) {\n    this._assertNotReadOnly()\n    const sql = this.insertSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Maximum rows per `INSERT ... VALUES (...), (...), ...` statement. Drivers\n   * that build multi-value inserts must stay below database-specific limits\n   * (SQLite's `MAX_VARIABLE_NUMBER`, SQL Server's 2100 parameters, PostgreSQL's\n   * 65535 parameters, and so on). 500 rows is safely under every major engine\n   * for tables with a moderate number of columns and keeps generated SQL small.\n   *\n   * Override via `maxRowsPerInsert` in the database configuration.\n   * @returns {number} - Maximum rows per insert statement.\n   */\n  maxRowsPerInsert() {\n    return optionalPositiveInteger(this.getArgs().maxRowsPerInsert, \"maxRowsPerInsert\") ?? 500\n  }\n\n  /**\n   * Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES`\n   * statement. Large text/JSON payloads can push a modest row count well beyond\n   * database wire/protocol limits, so chunking also stops when the next row\n   * would push the generated string over this threshold.\n   *\n   * Override via `maxInsertSqlBytes` in the database configuration.\n   * @returns {number} - Maximum bytes per insert statement.\n   */\n  maxInsertSqlBytes() {\n    return optionalPositiveInteger(this.getArgs().maxInsertSqlBytes, \"maxInsertSqlBytes\") ?? 1048576\n  }\n\n  /**\n   * Maximum values in a single `IN (...)` cohort used by preloads, association\n   * counts, and queryData aggregates. The default stays under SQLite's default\n   * `MAX_VARIABLE_NUMBER` compile-time limit.\n   *\n   * Override via `maxInClauseValues` in the database configuration.\n   * @returns {number} - Maximum values per IN clause cohort.\n   */\n  maxInClauseValues() {\n    return optionalPositiveInteger(this.getArgs().maxInClauseValues, \"maxInClauseValues\") ?? 999\n  }\n\n  /**\n   * Maximum serialized SQL size, in bytes, for a single cohort query used by\n   * preloads, association counts, and queryData aggregates. Cohort chunking\n   * stops when the next value would push the generated string over this threshold.\n   *\n   * Override via `maxQuerySqlBytes` in the database configuration.\n   * @returns {number} - Maximum bytes per cohort query.\n   */\n  maxQuerySqlBytes() {\n    return optionalPositiveInteger(this.getArgs().maxQuerySqlBytes, \"maxQuerySqlBytes\") ?? 1048576\n  }\n\n  /**\n   * Splits `values` into cohort chunks that stay within both `maxCount` and\n   * `maxBytes` while preserving order.\n   *\n   * A chunk always contains at least one value, even if that single value exceeds\n   * the byte limit, so progress is guaranteed.\n   * @template T\n   * @param {Array<T>} values - Values to chunk.\n   * @param {(values: Array<T>) => string} buildSql - Function that builds the full SQL for a candidate chunk.\n   * @param {{maxCount?: number, maxBytes?: number}} [options] - Chunking bounds.\n   * @returns {Array<Array<T>>} - Value cohorts.\n   */\n  chunkValues(values, buildSql, {maxCount = this.maxInClauseValues(), maxBytes = this.maxQuerySqlBytes()} = {}) {\n    if (values.length === 0) return []\n\n    /**\n     * Chunks.\n     * @type {Array<Array<T>>} */\n    const chunks = []\n    /**\n     * Current chunk.\n     * @type {Array<T>} */\n    let currentChunk = []\n\n    for (const value of values) {\n      const candidate = [...currentChunk, value]\n      const candidateBytes = utf8ByteLength(buildSql(candidate))\n\n      if (currentChunk.length > 0 && (candidate.length > maxCount || candidateBytes > maxBytes)) {\n        chunks.push(currentChunk)\n        currentChunk = [value]\n      } else {\n        currentChunk = candidate\n      }\n    }\n\n    if (currentChunk.length > 0) {\n      chunks.push(currentChunk)\n    }\n\n    return chunks\n  }\n\n  /**\n   * Splits `rows` into chunks that stay within both {@link maxRowsPerInsert}\n   * and {@link maxInsertSqlBytes} while preserving order.\n   *\n   * Byte accounting is incremental: `buildSql` is called once with `[]` to\n   * measure the statement prefix and once per row with `[row]` to measure the\n   * row's values tuple. This keeps chunking linear in the number of rows\n   * instead of rebuilding the full multi-row SQL for every candidate.\n   *\n   * A chunk always contains at least one row, even if that single row exceeds\n   * the byte limit, so progress is guaranteed.\n   * @param {Array<Array<ReturnType<typeof JSON.parse>>>} rows - Rows to insert.\n   * @param {(rows: Array<Array<ReturnType<typeof JSON.parse>>>) => string} buildSql - Function that builds the full SQL for a candidate chunk; called with `[]` to measure the statement prefix and with `[row]` to measure each row's values tuple.\n   * @returns {Array<Array<Array<ReturnType<typeof JSON.parse>>>>} - Row chunks.\n   */\n  _insertMultipleChunks(rows, buildSql) {\n    const chunks = []\n    const maxRows = this.maxRowsPerInsert()\n    const maxBytes = this.maxInsertSqlBytes()\n    const emptySql = buildSql([])\n    const prefix = `${emptySql} VALUES `\n    const baseByteLength = utf8ByteLength(prefix)\n\n    /**\n     * Current chunk.\n     * @type {Array<Array<ReturnType<typeof JSON.parse>>>} */\n    let currentChunk = []\n    let currentBytes = 0\n\n    for (const row of rows) {\n      const singleRowSql = buildSql([row])\n      const rowValuesSql = singleRowSql.slice(prefix.length)\n      const rowValuesSqlBytes = utf8ByteLength(rowValuesSql)\n\n      if (currentChunk.length > 0) {\n        const candidateRows = currentChunk.length + 1\n        const candidateBytes = currentBytes + 2 + rowValuesSqlBytes // \", \" separator\n\n        if (candidateRows > maxRows || candidateBytes > maxBytes) {\n          chunks.push(currentChunk)\n          currentChunk = []\n          currentBytes = 0\n        }\n      }\n\n      if (currentChunk.length === 0) {\n        currentBytes = baseByteLength + rowValuesSqlBytes\n      } else {\n        currentBytes += 2 + rowValuesSqlBytes\n      }\n\n      currentChunk.push(row)\n    }\n\n    if (currentChunk.length > 0) {\n      chunks.push(currentChunk)\n    }\n\n    return chunks\n  }\n\n  /**\n   * Runs insert multiple.\n   *\n   * Large row sets are split into multiple statements that each stay within\n   * {@link maxRowsPerInsert} rows and {@link maxInsertSqlBytes} serialized\n   * bytes so the generated SQL stays within database parameter and wire limits.\n   * When called outside a transaction each chunk commits independently; callers\n   * that need all-or-nothing semantics should wrap the call in {@link transaction}.\n   * @param {string} tableName - Table name.\n   * @param {Array<string>} columns - Column names.\n   * @param {Array<Array<ReturnType<typeof JSON.parse>>>} rows - Rows to insert.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insertMultiple(tableName, columns, rows) {\n    this._assertNotReadOnly()\n\n    const chunks = this._insertMultipleChunks(rows, (chunkRows) => this.insertSql({columns, tableName, rows: chunkRows}))\n\n    for (const chunk of chunks) {\n      const sql = this.insertSql({columns, tableName, rows: chunk})\n\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs insert sql.\n   * @abstract\n   * @param {InsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  insertSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'insertSql' not implemented\")\n  }\n\n  /**\n   * Runs upsert.\n   * @param {UpsertSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async upsert(args) {\n    this._assertNotReadOnly()\n    const sql = this.upsertSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs last insert id.\n   * @abstract\n   * @param {QueryOptions} [_options] - Query ownership options.\n   * @returns {Promise<number>} - Resolves with the last insert id.\n   */\n  lastInsertID(_options = {}) {\n    throw new Error(`${this.constructor.name}#lastInsertID not implemented`)\n  }\n\n  /**\n   * Runs convert value.\n   * @param {ReturnType<typeof JSON.parse>} value - Value to use.\n   * @returns {ReturnType<typeof JSON.parse>} - The convert value.\n   */\n  _convertValue(value) {\n    if (typeof value === \"boolean\") {\n      return value ? 1 : 0\n    }\n\n    // isDate instead of instanceof: a Date created in another realm (e.g. the console REPL) would\n    // fail instanceof, skip this conversion, and serialize as an empty SQL value downstream.\n    if (isDate(value)) {\n      return formatDateForDatabase(value, {databaseType: this.getType()})\n    }\n\n    // JSON-encode plain objects/arrays so they land in JSON/text columns as valid\n    // JSON. Without this, drivers like mysql's escape() turn an object into\n    // `key` = value assignment pairs (its `SET ?` form), producing invalid SQL in\n    // a value position. Only PLAIN objects and arrays are encoded — class\n    // instances (e.g. model records, which are circular via _changes) and Buffers\n    // pass through untouched, since JSON.stringify on a record throws on its\n    // circular structure and a record is never a valid column value to serialize.\n    if (this._isJsonEncodableValue(value)) {\n      return JSON.stringify(value)\n    }\n\n    return value\n  }\n\n  /**\n   * Whether a value is a plain object or array that should be JSON-encoded for a\n   * JSON/text column. Excludes Buffers and class instances (e.g. model records).\n   * @param {ReturnType<typeof JSON.parse>} value - Value to test.\n   * @returns {boolean} - Whether to JSON-encode the value.\n   */\n  _isJsonEncodableValue(value) {\n    if (value === null || typeof value !== \"object\") return false\n    if (typeof Buffer !== \"undefined\" && Buffer.isBuffer(value)) return false\n    if (Array.isArray(value)) return true\n\n    const prototype = Object.getPrototypeOf(value)\n\n    return prototype === Object.prototype || prototype === null\n  }\n\n  /**\n   * Runs options.\n   * @abstract\n   * @returns {import(\"../query-parser/options.js\").default} - The options options.\n   */\n  options() {\n    throw new Error(\"'options' not implemented.\")\n  }\n\n  /**\n   * Runs quote.\n   * @param {ReturnType<typeof JSON.parse>} value - Value to use.\n   * @returns {number | string} - The quote.\n   */\n  quote(value) {\n    if (typeof value == \"number\") return value\n\n    const escapedValue = this.escape(value)\n    const result = `\"${escapedValue}\"`\n\n    return result\n  }\n\n  /**\n   * Runs quote column.\n   * @param {string} columnName - Column name.\n   * @returns {string} - The quote column.\n   */\n  quoteColumn(columnName) {\n    return this.options().quoteColumnName(columnName)\n  }\n\n  /**\n   * Runs quote index.\n   * @param {string} columnName - Column name.\n   * @returns {string} - The quote index.\n   */\n  quoteIndex(columnName) {\n    return this.options().quoteIndexName(columnName)\n  }\n\n  /**\n   * Runs quote table.\n   * @param {string} tableName - Table name.\n   * @returns {string} - The quote table.\n   */\n  quoteTable(tableName) {\n    return this.options().quoteTableName(tableName)\n  }\n\n  /**\n   * Runs new query.\n   * @returns {Query} - The new query.\n   */\n  newQuery() {\n    const handler = new Handler()\n\n    return new Query({\n      driver: this,\n      handler\n    })\n  }\n\n  /**\n   * Runs select.\n   * @param {string} tableName - Table name.\n   * @returns {Promise<QueryResultType>} - Resolves with the select.\n   */\n  async select(tableName) {\n    const query = this.newQuery()\n\n    const sql = query\n      .from(tableName)\n      .toSql()\n\n    return await this.query(sql)\n  }\n\n  /**\n   * Runs set id seq.\n   * @param {number | undefined} newIdSeq - New id seq.\n   * @returns {void} - No return value.\n   */\n  setIdSeq(newIdSeq) {\n    this.idSeq = newIdSeq\n  }\n\n  /**\n   * Runs should set auto increment when primary key.\n   * @abstract\n   * @returns {boolean} - Whether set auto increment when primary key.\n   */\n  shouldSetAutoIncrementWhenPrimaryKey() {\n    throw new Error(`'shouldSetAutoIncrementWhenPrimaryKey' not implemented`)\n  }\n\n  /**\n   * Runs supports default primary key uuid.\n   * @returns {boolean} - Whether supports default primary key uuid.\n   */\n  supportsDefaultPrimaryKeyUUID() { return false }\n\n  /**\n   * Executes an insert that carries an explicit primary-key value\n   * (client-generated offline-sync ids). Drivers whose auto-increment columns\n   * reject explicit values (MSSQL IDENTITY) override this to run the insert\n   * with identity insert enabled in a single request.\n   * @param {object} args - Options object.\n   * @param {QueryOptions} args.options - Query options for the standard query path.\n   * @param {string} args.sql - Generated insert SQL.\n   * @param {string} args.tableName - Table being inserted into.\n   * @returns {Promise<QueryResultType>} - Insert result.\n   */\n  async insertWithExplicitPrimaryKey({options, sql, tableName}) {\n    void tableName\n\n    return await this.query(sql, options)\n  }\n\n  /**\n   * Runs supports insert into returning.\n   * @abstract\n   * @returns {boolean} - Whether supports insert into returning.\n   */\n  supportsInsertIntoReturning() { return false }\n\n  /**\n   * Whether a single connection can reference tables in another database on the same server via a\n   * two-part `database`.`table` identifier. When true, a query spanning several databases on this\n   * server can be expressed as one statement (a cross-tenant `UNION ALL`); when false, each database\n   * is queried on its own connection and the results merged in the caller. Only MySQL/MariaDB return\n   * true: PostgreSQL (one database per connection) and SQLite (one attached file per connection)\n   * cannot, and MSSQL is excluded because it reads a two-part name as `schema.table` (cross-database\n   * access needs a three-part `database.schema.table`), so it stays on the always-correct fan-out\n   * path. Consumed by `Tenant.aggregateAcross`.\n   * @returns {boolean} - Whether two-part cross-database references are supported.\n   */\n  supportsCrossDatabaseReferences() { return false }\n\n  /**\n   * Runs table exists.\n   * @param {string} tableName - Table name.\n   * @returns {Promise<boolean>} - Resolves with Whether table exists.\n   */\n  async tableExists(tableName) {\n    const tables = await this.getTables()\n    const table = tables.find((table) => table.getName() == tableName)\n\n    if (table) return true\n\n    return false\n  }\n\n  /**\n   * Runs a callback inside a database transaction (or a savepoint when already inside one).\n   * The outermost transaction retries the whole callback on a deadlock / lock-wait-timeout,\n   * because such errors roll the entire transaction back and the standard recovery is to\n   * restart it. Nested savepoints let the deadlock bubble up to this outer retry.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback function.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<T>} - Resolves with the transaction result.\n   */\n  async transaction(callback, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n\n    return await coordinateSharedTransactionConnection(this, async () => {\n      if (this._transactionsCount > 0) {\n        return await this._runTransactionAttempt(callback, options)\n      }\n\n      const args = this.getArgs()\n      const maxAttempts = optionalPositiveInteger(args.deadlockMaxRetries, \"deadlockMaxRetries\") ?? 8\n      const configuredBaseWaitMs = optionalPositiveInteger(args.deadlockBaseWaitMs, \"deadlockBaseWaitMs\")\n      const deadlockMaxWaitMs = optionalPositiveInteger(args.deadlockMaxWaitMs, \"deadlockMaxWaitMs\") ?? 1000\n      let attempt = 0\n\n      while (true) {\n        attempt++\n        const attemptStartedAtMs = this._nowMs()\n\n        try {\n          return await this._runTransactionAttempt(callback, options)\n        } catch (error) {\n          if (error instanceof VelociousDatabaseAfterCommitCallbackError) throw error.callbackError\n          if (!(error instanceof Error)) throw error\n\n          const retryInfo = this.retryableDatabaseError(error)\n          const willRetry = Boolean(retryInfo.deadlock && attempt < maxAttempts && this._transactionsCount == 0)\n\n          if (willRetry) {\n            this._reportDeadlockRetryDiagnostic({\n              attempt,\n              contentionKind: retryInfo.contentionKind || \"deadlock\",\n              error,\n              maxAttempts,\n              transactionAttemptDurationMs: Math.max(0, this._nowMs() - attemptStartedAtMs),\n              willRetry\n            })\n\n            // An explicitly-configured base wins so the tuning knob is effective even on drivers\n            // whose classifier supplies its own `waitMs` (MySQL/MariaDB return a fixed 50ms for\n            // deadlocks); otherwise honor that classifier hint, then fall back to 50ms.\n            const baseWaitMs = configuredBaseWaitMs ?? (typeof retryInfo.waitMs == \"number\" && retryInfo.waitMs > 0 ? retryInfo.waitMs : 50)\n\n            // Full-jitter exponential backoff: wait a uniform-random duration in\n            // [0, min(base * 2^(attempt-1), cap)]. The doubling ceiling spreads retries out as\n            // contention persists, and the jitter de-correlates transactions that deadlocked in\n            // lockstep so they stop re-colliding on the same wait (the linear `base * attempt`\n            // this replaces had every victim retry after an identical delay). `attempt` is\n            // 1-based here, so 2^(attempt-1) is 1, 2, 4, ... The cap keeps the tail sub-second.\n            const ceilingWaitMs = Math.min(baseWaitMs * (2 ** (attempt - 1)), deadlockMaxWaitMs)\n            const jitteredWaitMs = Math.floor(Math.random() * (ceilingWaitMs + 1))\n\n            const loggedContentionKind = retryInfo.contentionKind || \"transaction contention\"\n\n            this.logger.warn(`Retrying transaction after ${loggedContentionKind} (attempt ${attempt}/${maxAttempts})`)\n            await this._waitMs(jitteredWaitMs)\n            continue\n          }\n\n          throw error\n        }\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Waits `ms` milliseconds. Isolated in its own method so tests can observe (and skip) the\n   * deadlock-retry backoff without a real timer.\n   * @param {number} ms - Milliseconds to wait.\n   * @returns {Promise<void>} - Resolves after the delay.\n   */\n  async _waitMs(ms) {\n    await wait(ms)\n  }\n\n  /**\n   * Returns the clock used for transaction-attempt diagnostics.\n   * @returns {number} - Monotonic milliseconds where available.\n   */\n  _nowMs() {\n    return nowMs()\n  }\n\n  /**\n   * Starts best-effort deadlock diagnostics without joining the retry control flow. Subclasses may\n   * add bounded driver-specific context; capture and event-listener failures cannot affect retry.\n   * @param {{attempt: number, contentionKind: \"deadlock\" | \"lock-wait-timeout\", error: Error, maxAttempts: number, transactionAttemptDurationMs: number, willRetry: boolean}} args - Retry metadata.\n   * @returns {void}\n   */\n  _reportDeadlockRetryDiagnostic({attempt, contentionKind, error, maxAttempts, transactionAttemptDurationMs, willRetry}) {\n    let snapshot\n\n    try {\n      const queryDiagnostic = this._failedQueryDiagnostics.get(error)\n\n      snapshot = Object.freeze({\n        attempt,\n        contentionKind,\n        driverType: this.getType(),\n        maxAttempts,\n        stage: \"database-deadlock-retry\",\n        transactionAttemptDurationMs,\n        willRetry,\n        ...this._poolDiagnosticIdentityContext(),\n        ...this._operationDiagnosticContext(),\n        ...queryDiagnostic\n      })\n    } catch (diagnosticError) {\n      this._reportDeadlockDiagnosticPipelineFailure(diagnosticError)\n      return\n    }\n\n    let driverContextResult\n\n    try {\n      driverContextResult = this._deadlockDiagnosticContext(snapshot)\n    } catch (diagnosticError) {\n      this._reportDeadlockDiagnosticPipelineFailure(diagnosticError)\n      return\n    }\n\n    const hasPromiseContract = driverContextResult instanceof Promise\n\n    void Promise.resolve(driverContextResult)\n      .then((driverContext) => {\n        if (!hasPromiseContract) throw new Error(\"Database deadlock diagnostic context must return a Promise\")\n\n        const context = {\n          ...snapshot,\n          ...driverContext\n        }\n        const payload = {\n          context,\n          error: new Error(willRetry\n            ? `Database transaction ${contentionKind} will be retried`\n            : `Database transaction ${contentionKind} exhausted its retry budget`)\n        }\n        const errorEvents = this.configuration.getErrorEvents()\n\n        try {\n          errorEvents.emit(\"database-deadlock-retry\", payload)\n        } catch (eventError) {\n          this.logger.warn(\"Database deadlock retry diagnostic listener failed\", {error: eventError})\n        }\n\n        try {\n          errorEvents.emit(\"all-error\", {...payload, errorType: \"database-deadlock-retry\"})\n        } catch (eventError) {\n          this.logger.warn(\"Database deadlock retry all-error listener failed\", {error: eventError})\n        }\n      })\n      .catch((diagnosticError) => this._reportDeadlockDiagnosticPipelineFailure(diagnosticError))\n  }\n\n  /**\n   * Returns pool identity only when this driver was stamped by a pool.\n   * @returns {{databaseIdentifier?: string, databaseIdentifierFingerprint?: string, databaseIdentityFingerprint?: string}} - Safe pool identity.\n   */\n  _poolDiagnosticIdentityContext() {\n    if (this._databaseIdentifier === undefined || !this._databaseIdentityFingerprint) return {}\n\n    const identifierFingerprintInput = typeof this._databaseIdentifier === \"string\"\n      ? this._databaseIdentifier\n      : `invalid:${typeof this._databaseIdentifier}`\n    const databaseIdentifierFingerprint = `sha256:${sha256Hex(`database-logical-identifier:v1\\0${identifierFingerprintInput}`)}`\n\n    return {\n      databaseIdentifier: REDACTED_DIAGNOSTIC_LABEL,\n      databaseIdentifierFingerprint,\n      databaseIdentityFingerprint: this._databaseIdentityFingerprint\n    }\n  }\n\n  /**\n   * Builds the bounded operation portion of an immutable retry snapshot.\n   * @returns {{operationName?: string, operationNameFingerprint?: string}} - Safe operation fields.\n   */\n  _operationDiagnosticContext() {\n    const rawOperationName = this._connectionCheckoutName\n\n    if (rawOperationName === undefined) return {}\n    if (typeof rawOperationName !== \"string\") {\n      return {\n        operationName: REDACTED_DIAGNOSTIC_LABEL,\n        operationNameFingerprint: `sha256:${sha256Hex(`database-operation:v1\\0invalid:${typeof rawOperationName}`)}`\n      }\n    }\n\n    const scannedOperationName = rawOperationName.slice(0, OPERATION_NAME_SCAN_LIMIT)\n    const operationNameFingerprint = `sha256:${sha256Hex(`database-operation:v1\\0${scannedOperationName}\\0length:${rawOperationName.length}`)}`\n\n    return {\n      operationName: REDACTED_DIAGNOSTIC_LABEL,\n      operationNameFingerprint\n    }\n  }\n\n  /**\n   * Reports an unexpected detached diagnostics failure without changing transaction control flow.\n   * @param {ReturnType<typeof JSON.parse>} diagnosticError - Diagnostics failure.\n   * @returns {void}\n   */\n  _reportDeadlockDiagnosticPipelineFailure(diagnosticError) {\n    const normalizedError = diagnosticError instanceof Error\n      ? diagnosticError\n      : new Error(\"Database deadlock retry diagnostic failed\", {cause: diagnosticError})\n    const payload = {\n      context: {stage: \"database-deadlock-retry-diagnostic\"},\n      error: normalizedError\n    }\n    let errorEvents\n\n    try {\n      errorEvents = this.configuration.getErrorEvents()\n    } catch (reportingError) {\n      this.logger.warn(\"Database deadlock retry diagnostic pipeline reporting failed\", {error: normalizedError, reportingError})\n      return\n    }\n\n    try {\n      errorEvents.emit(\"framework-error\", payload)\n    } catch (reportingError) {\n      this.logger.warn(\"Database deadlock retry framework-error listener failed\", {error: normalizedError, reportingError})\n    }\n\n    try {\n      errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n    } catch (reportingError) {\n      this.logger.warn(\"Database deadlock retry all-error listener failed\", {error: normalizedError, reportingError})\n    }\n  }\n\n  /**\n   * Builds driver-specific deadlock context. The base driver has no server diagnostic source.\n   * @param {DeadlockRetryDiagnosticSnapshot} _snapshot - Immutable retry snapshot.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Safe context fields.\n   */\n  async _deadlockDiagnosticContext(_snapshot) {\n    return {}\n  }\n\n  /**\n   * Runs a single transaction attempt: starts a transaction (or a savepoint when nested), runs\n   * `callback`, and commits — rolling back on error. {@link transaction} wraps this with deadlock\n   * retry at the outermost level.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback function.\n   * @param {Pick<QueryOptions, \"operationOwner\">} options - Transaction ownership.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the transaction result.\n   */\n  async _runTransactionAttempt(callback, options) {\n    const savePointName = this.generateSavePointName()\n    /** @type {TransactionCallbackFrame} */\n    const callbackFrame = {\n      afterCommitCallbacks: [],\n      beforeCommitCallbacks: []\n    }\n    let transactionStarted = false\n    let savePointStarted = false\n\n    this._transactionCallbackFrames.push(callbackFrame)\n\n    try {\n      if (this._transactionsCount == 0) {\n        this.logger.debug(\"Start transaction\")\n        await this.startTransaction(options)\n        transactionStarted = true\n      } else {\n        this.logger.debug(\"Start savepoint\", savePointName)\n        await this.startSavePoint(savePointName, options)\n        savePointStarted = true\n      }\n    } catch (error) {\n      this._transactionCallbackFrames.pop()\n      throw error\n    }\n\n    let result\n\n    try {\n      result = await callback()\n      await this._runBeforeCommitCallbacks(callbackFrame)\n\n      if (savePointStarted) {\n        this.logger.debug(\"Release savepoint\", savePointName)\n        await this.releaseSavePoint(savePointName, options)\n      }\n\n      if (transactionStarted) {\n        this.logger.debug(\"Commit transaction\")\n        await this.commitTransaction(options)\n      }\n    } catch (error) {\n      if (error instanceof Error) {\n        this.logger.debug(\"Transaction error\", error.message)\n      } else {\n        this.logger.debug(\"Transaction error\", error)\n      }\n\n      try {\n        let transactionRolledBack = false\n\n        if (savePointStarted) {\n          this.logger.debug(\"Rollback savepoint\", savePointName)\n          try {\n            await this.rollbackSavePoint(savePointName, options)\n          } catch (savePointError) {\n            const message = savePointError instanceof Error ? savePointError.message : `${savePointError}`\n\n            // MySQL sometimes drops savepoints unexpectedly; fall back to rolling back the full transaction\n            if (message.includes(\"SAVEPOINT\") || message.includes(\"ER_SP_DOES_NOT_EXIST\")) {\n              this.logger.debug(\"Savepoint rollback failed; rolling back entire transaction instead\")\n              await this.rollbackTransaction(options)\n              transactionRolledBack = true\n            } else {\n              throw savePointError\n            }\n          }\n        }\n\n        // Only roll back if a transaction is still open. A nested savepoint whose rollback failed\n        // falls back to rolling back the whole transaction (above), which already closed it and\n        // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive\n        // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.\n        if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {\n          this.logger.debug(\"Rollback transaction\")\n          await this.rollbackTransaction(options)\n        }\n      } finally {\n        this._transactionCallbackFrames.pop()\n      }\n\n      throw error\n    }\n\n    try {\n      await this._commitTransactionCallbackFrame()\n    } catch (error) {\n      throw new VelociousDatabaseAfterCommitCallbackError(error)\n    }\n\n    return result\n  }\n\n  /**\n   * Registers a guard to run after the current transaction callback succeeds and before its\n   * outer commit or nested savepoint release.\n   * @param {() => void | Promise<void>} callback - Guard callback.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Callback ownership.\n   * @returns {Promise<void>} - Resolves when the guard has been registered.\n   */\n  async beforeCommit(callback, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n\n    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]\n\n    if (!currentFrame) throw new Error(\"beforeCommit requires an active transaction\")\n\n    currentFrame.beforeCommitCallbacks.push(callback)\n  }\n\n  /**\n   * Runs a callback after the surrounding transaction commits.\n   * If no transaction is active, the callback runs immediately.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Callback ownership.\n   * @returns {Promise<void>} - Resolves when the callback has been registered or run.\n   */\n  async afterCommit(callback, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n\n    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]\n\n    if (!currentFrame) {\n      await callback()\n      return\n    }\n\n    currentFrame.afterCommitCallbacks.push(callback)\n  }\n\n  /**\n   * Whether a transaction is currently open on this connection.\n   * @returns {boolean} - Whether inside a transaction.\n   */\n  insideTransaction() { return this._transactionsCount > 0 }\n\n  /**\n   * Returns the completion promise identifying the current outer transaction.\n   * @returns {Promise<void>} Resolves after that transaction commits or rolls back.\n   */\n  transactionCompletion() { return this._transactionCompletionPromise }\n\n  /**\n   * Runs start transaction.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async startTransaction(options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      while (true) {\n        /** @type {import(\"../operation-lease.js\").default | undefined} */\n        let blockingOperationLease\n\n        await this._transactionsActionsMutex.sync(async () => {\n          const operationLease = this._operationLease\n\n          if (operationLease && options.operationOwner !== operationLease.owner) {\n            blockingOperationLease = operationLease\n            return\n          }\n\n          await this._runProfiledTransactionAction(\"start\", async () => {\n            await this._startTransactionAction(options)\n          })\n          this._transactionsCount++\n\n          if (this._transactionsCount === 1) {\n            this._transactionCompletionPromise = new Promise((resolve) => {\n              this._resolveTransactionCompletion = resolve\n            })\n          }\n        })\n\n        if (!blockingOperationLease) return\n\n        await blockingOperationLease.wait(options.operationOwner)\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs start transaction action.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startTransactionAction(options = {}) {\n    await this.query(\"BEGIN TRANSACTION\", options)\n  }\n\n  /**\n   * Runs commit transaction.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async commitTransaction(options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._runProfiledTransactionAction(\"commit\", async () => {\n          await this._commitTransactionAction(options)\n        })\n        this._transactionsCount--\n        this._resolveCompletedTransaction()\n      })\n    }, options.operationOwner)\n  }\n\n  /** Resolves the current outer transaction completion when it has finished. */\n  _resolveCompletedTransaction() {\n    if (this._transactionsCount !== 0) return\n\n    const resolve = this._resolveTransactionCompletion\n\n    this._resolveTransactionCompletion = undefined\n    if (resolve) resolve()\n  }\n\n  /**\n   * Runs commit transaction action.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _commitTransactionAction(options = {}) {\n    await this.query(\"COMMIT\", options)\n  }\n\n  /**\n   * Times a physical transaction action only when test profiling is active.\n   * @template T\n   * @param {\"start\" | \"commit\" | \"rollback\"} action - Transaction action.\n   * @param {() => Promise<T>} callback - Physical action callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _runProfiledTransactionAction(action, callback) {\n    const profileContext = currentTestProfileContext(this.configuration)\n\n    if (!profileContext) return await callback()\n\n    const startedAtMs = nowMs()\n    let failed = true\n\n    try {\n      const result = await callback()\n\n      failed = false\n      return result\n    } finally {\n      profileContext.profiler.recordDatabaseTransaction(profileContext, {\n        action,\n        durationMs: nowMs() - startedAtMs,\n        failed\n      })\n    }\n  }\n\n  /**\n   * Starts an optional physical-query profile attempt without retaining SQL.\n   * @param {string} sql - Original SQL used only to derive its redacted diagnostic.\n   * @returns {TestProfileQueryAttempt | undefined} - Active profile handle.\n   */\n  _startProfiledQueryAttempt(sql) {\n    const context = currentTestProfileContext(this.configuration)\n\n    if (!context) return undefined\n\n    return {\n      context,\n      diagnostic: sqlDiagnostic(sql),\n      startedAtMs: nowMs()\n    }\n  }\n\n  /**\n   * Completes an optional physical-query profile attempt.\n   * @param {TestProfileQueryAttempt | undefined} attempt - Profile handle.\n   * @param {boolean} failed - Whether the physical driver call failed.\n   * @returns {void}\n   */\n  _finishProfiledQueryAttempt(attempt, failed) {\n    if (!attempt) return\n\n    attempt.context.profiler.recordDatabaseQuery(attempt.context, {\n      durationMs: nowMs() - attempt.startedAtMs,\n      failed,\n      ...attempt.diagnostic\n    })\n  }\n\n  /**\n   * Runs every guard registered to the transaction frame.\n   * @param {TransactionCallbackFrame} callbackFrame - Frame whose guards are completing.\n   * @returns {Promise<void>} - Resolves when every guard accepts the commit.\n   */\n  async _runBeforeCommitCallbacks(callbackFrame) {\n    for (const callback of callbackFrame.beforeCommitCallbacks) {\n      await callback()\n    }\n  }\n\n  /**\n   * Merges committed callbacks into the parent transaction frame or runs them when the outermost commit completes.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _commitTransactionCallbackFrame() {\n    const committedFrame = this._transactionCallbackFrames.pop()\n\n    if (!committedFrame || committedFrame.afterCommitCallbacks.length === 0) return\n\n    const parentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]\n\n    if (parentFrame) {\n      parentFrame.afterCommitCallbacks.push(...committedFrame.afterCommitCallbacks)\n      return\n    }\n\n    for (const callback of committedFrame.afterCommitCallbacks) {\n      await callback()\n    }\n  }\n\n  /**\n   * Streams the rows of `sql` one at a time instead of buffering the whole result set, so a\n   * caller can process an arbitrarily large result with bounded memory. This base implementation\n   * falls back to a buffered {@link query} and yields its rows; drivers backed by a cursor-capable\n   * client (the MySQL driver) override it with true server-side streaming.\n   * @param {string} sql - SQL string to stream.\n   * @param {QueryOptions} [options] - Query options, as for {@link query}.\n   * @yields {Record<string, unknown>} - The result rows, one at a time.\n   */\n  async *queryStream(sql, options = {}) {\n    const rows = await this.query(sql, options)\n\n    for (const row of Array.isArray(rows) ? rows : []) {\n      yield row\n    }\n  }\n\n  /**\n   * Runs query.\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} [options] - Query options.\n   * @returns {Promise<QueryResultType>} - Resolves with the query.\n   */\n  async query(sql, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n    this._assertWritableQuery(sql)\n\n    let tries = 0\n    const maxTries = 5\n    const requestTiming = this.configuration.getCurrentRequestTiming()\n    const logQuery = options.logQuery ?? this._queryLoggingEnabled()\n    const sourceStack = logQuery ? (options.sourceStack || Error().stack) : undefined\n    const querySql = this._querySqlWithProcessListComment(sql, options)\n\n    while (tries < maxTries) {\n      tries++\n\n      try {\n        return await this._queryActualWithLogging({originalSql: sql, querySql}, {...options, logQuery, sourceStack}, requestTiming, tries)\n      } catch (error) {\n        if (!(error instanceof Error)) throw error\n\n        this._failedQueryDiagnostics.set(error, sqlDiagnostic(sql))\n\n        // A deliberately-aborted query must never be silently re-run — its\n        // connection was destroyed on purpose, so treat it as terminal.\n        if (error instanceof QueryAbortedError) throw error\n\n        const retryInfo = this.retryableDatabaseError(error)\n\n        if (options.retry !== false && tries < maxTries && retryInfo.retry) {\n          if (retryInfo.reconnect) {\n            if (this._transactionsCount > 0) {\n              throw new Error(`Cannot reconnect while a transaction is active (${this._transactionsCount}). Original error: ${error.message}`, {cause: error})\n            }\n\n            await this.reconnect()\n          }\n\n          const waitMs = typeof retryInfo.waitMs === \"number\" && Number.isFinite(retryInfo.waitMs) ? retryInfo.waitMs : 100\n\n          if (waitMs > 0) await wait(waitMs)\n          const sensitiveValues = requestTiming ? requestTiming.getLogSensitiveValues() : new Set()\n          const loggedError = this.configuration.getLogRedactor().redactString(error.stack || error.message, sensitiveValues)\n\n          this.logger.warn(`Retrying query because failed with: ${loggedError}`)\n          // Retry\n        } else {\n          throw error\n        }\n      }\n    }\n\n    throw new Error(\"'query' unexpected came here\")\n  }\n\n  /**\n   * Executes a mutation and returns the number of rows changed by that statement.\n   * @param {string} sql - Mutation SQL string.\n   * @param {QueryOptions} [options] - Query ownership options.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async affectedRows(sql, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n    this._assertWritableQuery(sql)\n\n    return await coordinateSharedTransactionConnection(this, async () => {\n      await this.beforeQuery(sql, options)\n\n      try {\n        const profileAttempt = this._startProfiledQueryAttempt(sql)\n        let failed = true\n\n        try {\n          const affectedRows = await this._runPhysicalConnectionRequest(\n            async () => await this._affectedRowsActual(sql)\n          )\n\n          failed = false\n          return affectedRows\n        } finally {\n          this._finishProfiledQueryAttempt(profileAttempt, failed)\n        }\n      } finally {\n        await this.afterQuery(sql, options)\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs query actual with logging.\n   * @param {object} args - Options object.\n   * @param {string} args.originalSql - Original SQL string before process-list comments.\n   * @param {string} args.querySql - SQL string sent to the database.\n   * @param {QueryOptions} options - Query options.\n   * @param {import(\"../../http-server/client/request-timing.js\").default | undefined} requestTiming - Request timing.\n   * @param {number} tries - Query attempt count.\n   * @returns {Promise<QueryResultType>} - Resolves with the query.\n   */\n  async _queryActualWithLogging({originalSql, querySql}, options, requestTiming, tries) {\n    const startedAtMs = nowMs()\n    const previousActiveQuery = this._activeQuery\n    this._activeQuery = {\n      annotations: getDatabaseAnnotations(),\n      logName: options.logName || \"SQL\",\n      sqlPreview: this._debugSqlPreview(originalSql),\n      startedAtUnixMs: Date.now()\n    }\n    let result\n\n    try {\n      try {\n        const runQueryActualWithHooks = async () => await this._queryActualWithHooks(querySql, options, originalSql)\n\n        if (requestTiming && tries === 1) {\n          result = await requestTiming.measureDbQuery(runQueryActualWithHooks)\n        } else if (requestTiming) {\n          result = await requestTiming.measure(\"db\", runQueryActualWithHooks)\n        } else {\n          result = await runQueryActualWithHooks()\n        }\n      } finally {\n        this._activeQuery = previousActiveQuery\n      }\n    } catch (error) {\n      if (options.logQuery !== false) {\n        await this._logQuery({\n          elapsedMs: nowMs() - startedAtMs,\n          error: ensureError(error),\n          logName: options.logName || \"SQL\",\n          requestTiming,\n          sourceStack: options.sourceStack,\n          sql: originalSql\n        })\n      }\n\n      throw error\n    }\n\n    const elapsedMs = nowMs() - startedAtMs\n\n    if (options.logQuery !== false) {\n      await this._logQuery({\n        elapsedMs,\n        logName: options.logName || \"SQL\",\n        requestTiming,\n        sourceStack: options.sourceStack,\n        sql: originalSql\n      })\n    }\n\n    if (this._schemaCacheInvalidatingSql(originalSql)) {\n      this.clearSchemaCache()\n    }\n\n    return result\n  }\n\n  /**\n   * Runs query actual with before/after hooks.\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} options - Query options.\n   * @param {string} originalSql - SQL before process-list comments.\n   * @returns {Promise<QueryResultType>} - Resolves with the query.\n   */\n  async _queryActualWithHooks(sql, options, originalSql) {\n    return await coordinateSharedTransactionConnection(this, async () => {\n      await this.beforeQuery(sql, options)\n\n      try {\n        const profileAttempt = this._startProfiledQueryAttempt(originalSql)\n        let failed = true\n\n        try {\n          const result = await this._runPhysicalConnectionRequest(\n            async () => await this._queryActual(sql, options)\n          )\n\n          failed = false\n          return result\n        } finally {\n          this._finishProfiledQueryAttempt(profileAttempt, failed)\n        }\n      } finally {\n        await this.afterQuery(sql, options)\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Hook that runs immediately before a SQL query is sent to the driver.\n   * @param {string} _sql - SQL string.\n   * @param {QueryOptions} _options - Query options.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async beforeQuery(_sql, _options) {\n    // No-op by default\n  }\n\n  /**\n   * Hook that runs immediately after a SQL query has completed or failed.\n   * @param {string} _sql - SQL string.\n   * @param {QueryOptions} _options - Query options.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async afterQuery(_sql, _options) {\n    // No-op by default\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {DatabaseConnectionDebugSnapshot} - Diagnostic snapshot for this connection.\n   */\n  getDebugSnapshot() {\n    const now = Date.now()\n    const activeQuery = this._activeQuery\n\n    return {\n      activeQuery: activeQuery ? {...activeQuery, runningMs: Math.max(0, now - activeQuery.startedAtUnixMs)} : null,\n      checkoutAgeMs: this._connectionCheckedOutAtUnixMs ? Math.max(0, now - this._connectionCheckedOutAtUnixMs) : undefined,\n      checkedOutAtUnixMs: this._connectionCheckedOutAtUnixMs,\n      checkoutName: this._connectionCheckoutName,\n      driverClass: this.constructor.name,\n      idSeq: this.idSeq,\n      openTransactions: this._transactionsCount,\n      schemaCacheEntries: this._schemaCache.size\n    }\n  }\n\n  /**\n   * Returns a bounded prefix of `sql` for lightweight diagnostic scanning.\n   * @param {string} sql - SQL string.\n   * @param {number} limit - Maximum code units to inspect.\n   * @returns {string} - Prefix of `sql`.\n   */\n  _diagnosticSqlPrefix(sql, limit) {\n    return sql.length <= limit ? sql : sql.slice(0, limit)\n  }\n\n  /**\n   * Runs debug sql preview.\n   * @param {string} sql - SQL to preview.\n   * @returns {string} - Normalized truncated SQL preview for diagnostics.\n   */\n  _debugSqlPreview(sql) {\n    const prefix = this._diagnosticSqlPrefix(sql, SQL_PREVIEW_SCAN_LIMIT)\n\n    return prefix\n      .replace(/\\s+/g, \" \")\n      .trim()\n      .slice(0, 500)\n  }\n\n  /**\n   * Runs query sql with process list comment.\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} options - Query options.\n   * @returns {string} - SQL string with a leading process-list comment when annotations exist.\n   */\n  _querySqlWithProcessListComment(sql, options) {\n    if (options.processListComment === false) return sql\n\n    const parts = []\n\n    if (this._connectionCheckoutName) {\n      parts.push(`checkout=\"${this._processListCommentValue(this._connectionCheckoutName)}\"`)\n    }\n\n    const annotations = getDatabaseAnnotations()\n\n    if (annotations.length > 0) {\n      parts.push(`annotations=\"${this._processListCommentValue(annotations.join(\" > \"))}\"`)\n    }\n\n    if (parts.length === 0) return sql\n\n    return `/* velocious ${parts.join(\" \")} */ ${sql}`\n  }\n\n  /**\n   * Runs process list comment value.\n   * @param {string} value - Raw process-list comment value.\n   * @returns {string} - Sanitized process-list comment value.\n   */\n  _processListCommentValue(value) {\n    let sanitized = \"\"\n\n    for (const character of value) {\n      const codePoint = character.codePointAt(0)\n\n      sanitized += codePoint !== undefined && (codePoint < 32 || codePoint === 127) ? \" \" : character\n    }\n\n    return sanitized\n      .replace(/\\*\\//g, \"* /\")\n      .replace(/\\s+/g, \" \")\n      .trim()\n      .slice(0, 200)\n      .replace(/\"/g, \"'\")\n  }\n\n  /**\n   * Reads the next SQL token starting at `startIndex`, skipping leading trivia\n   * (BOM, whitespace, block comments, line comments). If the scan cannot finish\n   * skipping trivia before `limit`, the result is marked incomplete so callers\n   * can conservatively treat the statement as schema-invalidating.\n   * @param {string} sql - SQL string.\n   * @param {number} startIndex - Index to start scanning.\n   * @param {number} limit - Maximum absolute index to scan while skipping leading trivia.\n   * @returns {SqlTokenResult} - Token result.\n   */\n  _readSqlToken(sql, startIndex, limit) {\n    let i = startIndex\n    const len = sql.length\n\n    while (i < len && i < limit) {\n      const char = sql[i]\n\n      if (char === \"\\ufeff\" || /\\s/.test(char)) {\n        i++\n        continue\n      }\n\n      if (char === \"/\" && sql[i + 1] === \"*\") {\n        const close = sql.indexOf(\"*/\", i + 2)\n\n        if (close === -1 || close + 2 > limit) {\n          return {incomplete: true, index: i, token: undefined}\n        }\n\n        i = close + 2\n        continue\n      }\n\n      if (char === \"-\" && sql[i + 1] === \"-\") {\n        const newline = sql.indexOf(\"\\n\", i + 2)\n\n        if (newline === -1) {\n          return {incomplete: false, index: len, token: undefined}\n        }\n\n        if (newline + 1 > limit) {\n          return {incomplete: true, index: i, token: undefined}\n        }\n\n        i = newline + 1\n        continue\n      }\n\n      let token = \"\"\n\n      while (i < len) {\n        const c = sql[i]\n\n        if (/\\s/.test(c) || c === \"\\ufeff\") break\n        if (c === \"/\" && sql[i + 1] === \"*\") break\n        if (c === \"-\" && sql[i + 1] === \"-\") break\n\n        token += c\n        i++\n      }\n\n      return {incomplete: false, token: token.toLowerCase(), index: i}\n    }\n\n    if (i >= len) {\n      return {incomplete: false, index: len, token: undefined}\n    }\n\n    return {incomplete: true, index: i, token: undefined}\n  }\n\n  /**\n   * Runs schema cache invalidating sql.\n   * @param {string} sql - SQL string.\n   * @returns {boolean} - Whether the SQL should invalidate schema metadata.\n   */\n  _schemaCacheInvalidatingSql(sql) {\n    const first = this._readSqlToken(sql, 0, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n    if (first.incomplete) return true\n\n    const firstToken = first.token\n\n    if (!firstToken) return false\n    if (/^(create|alter|drop|rename)$/.test(firstToken)) return true\n\n    if (firstToken === \"comment\") {\n      const next = this._readSqlToken(sql, first.index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n      return next.incomplete || next.token === \"on\"\n    }\n\n    if (firstToken === \"exec\" || firstToken === \"execute\") {\n      const next = this._readSqlToken(sql, first.index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n      return next.incomplete || next.token === \"sp_rename\"\n    }\n\n    if (firstToken === \"if\") {\n      let index = first.index\n\n      while (true) {\n        const result = this._readSqlToken(sql, index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n        if (result.incomplete) return true\n        if (!result.token) return false\n        if (result.token === \"begin\") {\n          const ddlResult = this._readSqlToken(sql, result.index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n          return ddlResult.incomplete || /^(create|alter|drop|rename)$/.test(ddlResult.token || \"\")\n        }\n\n        index = result.index\n      }\n    }\n\n    return false\n  }\n\n  /**\n   * Runs query logging enabled.\n   * @returns {boolean} - Whether query logging is enabled for this driver.\n   */\n  _queryLoggingEnabled() {\n    if (!this.configuration) return true\n    if (!this.configuration.getQueryLoggingEnabled()) return false\n\n    const logger = new Logger(\"SQL\", {configuration: this.configuration})\n\n    return logger.isLevelEnabled(\"info\")\n  }\n\n  /**\n   * Runs log query.\n   * @param {object} args - Options object.\n   * @param {number} args.elapsedMs - Elapsed milliseconds.\n   * @param {Error} [args.error] - Query failure, when the driver call failed.\n   * @param {string} args.logName - Query log subject.\n   * @param {import(\"../../http-server/client/request-timing.js\").default | undefined} args.requestTiming - Request timing.\n   * @param {string | undefined} args.sourceStack - Source stack.\n   * @param {string} args.sql - SQL string.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _logQuery({elapsedMs, error, logName, requestTiming, sourceStack, sql}) {\n    const logger = new Logger(logName, {configuration: this.configuration})\n    const sourceLine = this._querySourceLine(sourceStack)\n    const sensitiveValues = requestTiming ? requestTiming.getLogSensitiveValues() : new Set()\n    const redactor = this.configuration.getLogRedactor()\n    const loggedSql = redactor.redactString(sql, sensitiveValues)\n    const failure = error\n      ? ` FAILED ${error.name}: ${redactor.redactString(error.message, sensitiveValues)}`\n      : \"\"\n    const message = sourceLine\n      ? `(${formatElapsedMs(elapsedMs)})${failure}  ${loggedSql}\\n  ↳ ${sourceLine}`\n      : `(${formatElapsedMs(elapsedMs)})${failure}  ${loggedSql}`\n\n    await logger.info(message)\n  }\n\n  /**\n   * Runs query source line.\n   * @param {string | undefined} sourceStack - Source stack.\n   * @returns {string | undefined} - Source line when an application frame is available.\n   */\n  _querySourceLine(sourceStack) {\n    if (!sourceStack) return undefined\n\n    const applicationDirectory = this.configuration\n      ? this.configuration.getDirectoryIfAvailable()\n      : undefined\n\n    if (!applicationDirectory) return undefined\n\n    const error = new Error(\"Query source\")\n\n    error.stack = sourceStack\n\n    return BacktraceCleaner.getApplicationSourceLine(error, {\n      applicationDirectory,\n      frameworkSourceDirectory: this.configuration.getEnvironmentHandler().getFrameworkSourceDirectory()\n    })\n  }\n\n  /**\n   * Runs query actual.\n   * @abstract\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} [options] - Query options (carries the optional abort signal).\n   * @returns {Promise<QueryResultType>} - Resolves with the query actual.\n   */\n  _queryActual(sql, options) { // eslint-disable-line no-unused-vars\n    throw new Error(`queryActual not implemented`)\n  }\n\n  /**\n   * Executes a mutation and returns its affected row count.\n   * @abstract\n   * @param {string} sql - Mutation SQL string.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  _affectedRowsActual(sql) { // eslint-disable-line no-unused-vars\n    throw new Error(`affectedRowsActual not implemented`)\n  }\n\n  /**\n   * Runs query to sql.\n   * @abstract\n   * @param {Query} _query - Query instance.\n   * @returns {string} - SQL string.\n   */\n  queryToSql(_query) { throw new Error(\"queryToSql not implemented\") }\n\n  /**\n   * Runs retryable database error.\n   * @param {Error} _error - Error instance.\n   * @returns {RetryableDatabaseErrorResult} - Retry info.\n   */\n  retryableDatabaseError(_error) {\n    return {retry: false, reconnect: false}\n  }\n\n  /**\n   * Runs assert writable query.\n   * @param {string} sql - SQL string.\n   * @returns {void} - No return value.\n   */\n  _assertWritableQuery(sql) {\n    if (!this.isReadOnly()) return\n    if (!this._sqlLooksLikeWrite(sql)) return\n\n    throw new Error(\"Database is read-only\")\n  }\n\n  /**\n   * Runs assert not read only.\n   * @returns {void} - No return value.\n   */\n  _assertNotReadOnly() {\n    if (this.isReadOnly()) {\n      throw new Error(\"Database is read-only\")\n    }\n  }\n\n  /**\n   * Runs sql looks like write.\n   * @param {string} sql - SQL string.\n   * @returns {boolean} - SQL representation.\n   */\n  _sqlLooksLikeWrite(sql) {\n    const normalized = sql.trim().toLowerCase()\n\n    if (!normalized) return false\n\n    if (\n      normalized.startsWith(\"select\") ||\n      normalized.startsWith(\"show\") ||\n      normalized.startsWith(\"pragma\") ||\n      normalized.startsWith(\"explain\") ||\n      normalized.startsWith(\"describe\")\n    ) {\n      return false\n    }\n\n    if (normalized.startsWith(\"with\")) {\n      const withMatch = normalized.match(/^\\s*with[\\s\\S]+?\\)\\s*(select|insert|update|delete|merge|replace)\\b/)\n\n      if (withMatch) {\n        return withMatch[1] !== \"select\"\n      }\n\n      return false\n    }\n\n    const keywordMatch = normalized.match(/^\\s*(\\w+)/)\n    const keyword = keywordMatch ? keywordMatch[1] : \"\"\n\n    return [\n      \"insert\",\n      \"update\",\n      \"delete\",\n      \"create\",\n      \"alter\",\n      \"drop\",\n      \"truncate\",\n      \"merge\",\n      \"replace\"\n    ].includes(keyword)\n  }\n\n  /**\n   * Runs is read only.\n   * @returns {boolean} - Whether read only.\n   */\n  isReadOnly() {\n    return Boolean(this.getArgs().readOnly)\n  }\n\n  /**\n   * Runs rollback transaction.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async rollbackTransaction(options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        try {\n          await this._runProfiledTransactionAction(\"rollback\", async () => {\n            await this._rollbackTransactionAction(options)\n          })\n        } finally {\n          // Driver recovery may need to clear a stale physical transaction when\n          // no logical transaction is active. Never let that cleanup underflow\n          // the logical depth and turn the next root transaction into a savepoint.\n          if (this._transactionsCount > 0) this._transactionsCount--\n          this._resolveCompletedTransaction()\n\n          // A rolled-back transaction may have reverted DDL (e.g. a CREATE TABLE\n          // run lazily inside the transaction), so any cached schema metadata is\n          // now stale and must be invalidated. Without this, a later tableExists()\n          // check can report a table that the rollback already removed, so callers\n          // skip recreating it and then fail with \"no such table\".\n          this.clearSchemaCache()\n        }\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs rollback transaction action.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _rollbackTransactionAction(options = {}) {\n    await this.query(\"ROLLBACK\", options)\n  }\n\n  /**\n   * Runs generate save point name.\n   * @returns {string} - The generate save point name.\n   */\n  generateSavePointName() {\n    return `sp${new UUID(4).format().replaceAll(\"-\", \"\")}`\n  }\n\n  /**\n   * Runs start save point.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async startSavePoint(savePointName, options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._startSavePointAction(savePointName, options)\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs start save point action.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startSavePointAction(savePointName, options = {}) {\n    await this.query(`SAVEPOINT ${savePointName}`, options)\n  }\n\n  /**\n   * Runs rename column.\n   * @param {string} tableName - Table name.\n   * @param {string} oldColumnName - Previous column name.\n   * @param {string} newColumnName - New column name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async renameColumn(tableName, oldColumnName, newColumnName) {\n    this._assertNotReadOnly()\n    const tableColumn = new TableColumn(oldColumnName)\n\n    tableColumn.setNewName(newColumnName)\n\n    const tableData = new TableData(tableName)\n\n    tableData.addColumn(tableColumn)\n\n    const alterTableSQLs = await this.alterTableSQLs(tableData)\n\n    for (const alterTableSQL of alterTableSQLs) {\n      await this.query(alterTableSQL)\n    }\n  }\n\n  /**\n   * Runs release save point.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async releaseSavePoint(savePointName, options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._releaseSavePointAction(savePointName, options)\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs release save point action.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _releaseSavePointAction(savePointName, options = {}) {\n    try {\n      await this.query(`RELEASE SAVEPOINT ${savePointName}`, options)\n    } catch (error) {\n      const message = error instanceof Error ? error.message : `${error}`\n\n      // Savepoint may already be gone if the database rolled back automatically\n      if (message.toLowerCase().includes(\"savepoint\") && message.toLowerCase().includes(\"does not exist\")) {\n        this.logger.debug(`Release savepoint ignored because it no longer exists: ${savePointName}`)\n        return\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs rollback save point.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async rollbackSavePoint(savePointName, options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._rollbackSavePointAction(savePointName, options)\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs rollback save point action.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _rollbackSavePointAction(savePointName, options = {}) {\n    await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`, options)\n  }\n\n  /**\n   * Truncates the given table snapshot. Drivers can override this to issue one batch.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} tables - Eligible tables for this cleanup attempt.\n   * @returns {Promise<void>} - Resolves when every table has been cleaned.\n   */\n  async truncateTables(tables) {\n    const truncateErrors = []\n\n    for (const table of tables) {\n      try {\n        await table.truncate({cascade: true})\n      } catch (error) {\n        truncateErrors.push(error)\n      }\n    }\n\n    if (truncateErrors.length > 0) throw truncateErrors[0]\n  }\n\n  /**\n   * Runs truncate all tables.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async truncateAllTables() {\n    this._assertNotReadOnly()\n    const tables = (await this.getTables()).filter((table) => table.getName() != \"schema_migrations\")\n\n    if (tables.length == 0) return\n\n    await this._truncateAllTables(tables)\n    await this.flushPendingWrites()\n  }\n\n  /**\n   * Owns the foreign-key boundary around every cleanup retry. Drivers that\n   * require one physical request for the full operation may override it.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} tables - Eligible tables.\n   * @returns {Promise<void>} - Resolves after cleanup succeeds.\n   */\n  async _truncateAllTables(tables) {\n    await this.withDisabledForeignKeys(async () => {\n      await this._truncateAllTablesWithRetries(tables)\n    })\n  }\n\n  /**\n   * Retries cleanup against refreshed schema snapshots. Drivers may override\n   * `_truncateAllTablesAttempt` to own a complete driver-specific attempt.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} initialTables - Initial eligible tables.\n   * @returns {Promise<void>} - Resolves after one cleanup attempt succeeds.\n   */\n  async _truncateAllTablesWithRetries(initialTables) {\n    let tables = initialTables\n\n    for (let tries = 1; tries <= 6; tries++) {\n      try {\n        await this._truncateAllTablesAttempt(tables)\n        return\n      } catch (error) {\n        console.error(error)\n\n        if (tries == 6) throw error\n\n        // A truncate failed — the schema cache may still list a table that was\n        // dropped out from under us (e.g. a db:rollback test that left the\n        // shared DB rolled back). Clear it so the next pass re-reads the live\n        // table list and no longer tries to truncate a table that is gone.\n        this.clearSchemaCache()\n        tables = (await this.getTables()).filter((table) => table.getName() != \"schema_migrations\")\n\n        if (tables.length == 0) return\n      }\n    }\n  }\n\n  /**\n   * Runs one cleanup attempt while the default owner has constraints disabled.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} tables - Current eligible tables.\n   * @returns {Promise<void>} - Resolves when the attempt completes.\n   */\n  async _truncateAllTablesAttempt(tables) {\n    await this.truncateTables(tables)\n  }\n\n  /**\n   * Runs update.\n   * @param {UpdateSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async update(args) {\n    this._assertNotReadOnly()\n    const sql = this.updateSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs update sql.\n   * @abstract\n   * @param {UpdateSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  updateSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'disableForeignKeys' not implemented\")\n  }\n\n  /**\n   * Runs upsert sql.\n   * @abstract\n   * @param {UpsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  upsertSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'upsertSql' not implemented\")\n  }\n\n  /**\n   * Runs disable foreign keys.\n   * @abstract\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  disableForeignKeys() {\n    throw new Error(\"'disableForeignKeys' not implemented\")\n  }\n\n  /**\n   * Runs enable foreign keys.\n   * @abstract\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  enableForeignKeys() {\n    throw new Error(\"'enableForeignKeys' not implemented\")\n  }\n\n  /**\n   * Runs with disabled foreign keys.\n   * @param {() => void} callback - Callback function.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the with disabled foreign keys.\n   */\n  async withDisabledForeignKeys(callback) {\n    await this.disableForeignKeys()\n\n    try {\n      return await callback()\n    } finally {\n      await this.enableForeignKeys()\n    }\n  }\n\n  /**\n   * Blocks until a named advisory lock is acquired on this connection.\n   * Advisory locks are connection-scoped and do not interact with row or\n   * table locks; they are purely cooperative between callers that use the\n   * same name and let you serialize functionality without blocking readers\n   * or writers that do not participate in the same lock.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null` blocks forever, and an omitted value uses the database's `advisoryLockAcquireTimeoutMs` or the framework default.\n   * @returns {Promise<boolean>} - Resolves to true when the lock has been acquired, false if the timeout elapsed.\n   */\n  async acquireAdvisoryLock(name, args = {}) {\n    const timeoutMs = this.advisoryLockAcquireTimeoutMs(args)\n    const startedAt = Date.now()\n    const acquired = await this._acquireAdvisoryLock(name, {timeoutMs})\n    const durationMs = Date.now() - startedAt\n\n    if (acquired) {\n      this._trackAdvisoryLock(name)\n\n      const slowAcquireMs = advisoryLockTelemetryThresholds(this.getArgs()).slowAcquireMs\n\n      if (slowAcquireMs !== null && durationMs > slowAcquireMs) {\n        await this._reportAdvisoryLockTelemetry({event: \"advisory-lock-slow-acquire\", lockName: name, durationMs, outcome: \"acquired\", timeoutMs})\n      }\n    } else {\n      // The wait exceeded its bound: attribute the lock to the holder that\n      // blocked it, captured at this moment on this tier.\n      await this._reportAdvisoryLockTelemetry({event: \"advisory-lock-acquire-timeout\", lockName: name, durationMs, outcome: \"timeout\", timeoutMs, captureHolder: true})\n    }\n\n    return acquired\n  }\n\n  /**\n   * Resolves the wait bound for one advisory-lock acquisition.\n   * An explicit `timeoutMs` — including an explicit `null` opt-out — always\n   * wins. Otherwise the database configuration's `advisoryLockAcquireTimeoutMs`\n   * applies, and a null there opts out too. Only when neither is configured does\n   * the framework default bound the wait.\n   * @param {{timeoutMs?: number | null}} [args] - Acquisition options from the caller.\n   * @returns {number | null} - Wait bound in milliseconds, or `null` for an indefinite wait.\n   */\n  advisoryLockAcquireTimeoutMs(args = {}) {\n    if (args.timeoutMs !== undefined) return args.timeoutMs\n\n    const configured = this.getArgs()?.advisoryLockAcquireTimeoutMs\n\n    if (configured === null) return null\n    if (typeof configured === \"number\" && configured >= 0) return configured\n\n    return DEFAULT_ADVISORY_LOCK_ACQUIRE_TIMEOUT_MS\n  }\n\n  /**\n   * Driver-specific blocking advisory-lock acquisition hook.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [_args] - Lock timeout options.\n   * @returns {Promise<boolean>} - Whether the lock was acquired.\n   */\n  _acquireAdvisoryLock(name, _args = {}) {\n    throw new Error(`'_acquireAdvisoryLock' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Attempts to acquire a named advisory lock without blocking.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the lock was acquired, false if it was already held.\n   */\n  async tryAcquireAdvisoryLock(name) {\n    const acquired = await this._tryAcquireAdvisoryLock(name)\n\n    if (acquired) this._trackAdvisoryLock(name)\n\n    return acquired\n  }\n\n  /**\n   * Driver-specific non-blocking advisory-lock acquisition hook.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Whether the lock was acquired.\n   */\n  _tryAcquireAdvisoryLock(name) { // eslint-disable-line no-unused-vars\n    throw new Error(`'_tryAcquireAdvisoryLock' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Releases a named advisory lock previously acquired on this connection.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the lock was held by this session and has now been released.\n   */\n  async releaseAdvisoryLock(name) {\n    const released = await this._releaseAdvisoryLock(name)\n\n    if (released) {\n      this._untrackAdvisoryLock(name)\n    } else {\n      this._heldAdvisoryLocks.delete(name)\n    }\n\n    if (!this._heldAdvisoryLocks.has(name)) {\n      const acquiredAt = this._advisoryLockAcquiredAtByName.get(name)\n\n      this._advisoryLockAcquiredAtByName.delete(name)\n\n      if (acquiredAt !== undefined) {\n        const holdDurationMs = Date.now() - acquiredAt\n        const slowHoldMs = advisoryLockTelemetryThresholds(this.getArgs()).slowHoldMs\n\n        if (slowHoldMs !== null && holdDurationMs > slowHoldMs) {\n          await this._reportAdvisoryLockTelemetry({event: \"advisory-lock-slow-hold\", lockName: name, durationMs: holdDurationMs, outcome: null, timeoutMs: null})\n        }\n      }\n    }\n\n    return released\n  }\n\n  /**\n   * Driver-specific advisory-lock release hook.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Whether the lock was released.\n   */\n  _releaseAdvisoryLock(name) { // eslint-disable-line no-unused-vars\n    throw new Error(`'_releaseAdvisoryLock' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Releases every advisory lock still tracked on this connection.\n   * @returns {Promise<void>} - Resolves when every tracked lock is released.\n   */\n  async releaseHeldAdvisoryLocks() {\n    /** @type {Error[]} */\n    const errors = []\n\n    for (const name of [...this._heldAdvisoryLocks.keys()]) {\n      while (this._heldAdvisoryLocks.has(name)) {\n        try {\n          await this.releaseAdvisoryLock(name)\n        } catch (error) {\n          errors.push(error instanceof Error ? error : new Error(`Failed to release advisory lock ${JSON.stringify(name)}`, {cause: error}))\n          break\n        }\n      }\n    }\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to release held advisory locks\")\n  }\n\n  /**\n   * Records one successful acquisition, including re-entrant acquisitions.\n   * @param {string} name - Lock name.\n   * @returns {void}\n   */\n  _trackAdvisoryLock(name) {\n    this._heldAdvisoryLocks.set(name, (this._heldAdvisoryLocks.get(name) || 0) + 1)\n\n    if (!this._advisoryLockAcquiredAtByName.has(name)) this._advisoryLockAcquiredAtByName.set(name, Date.now())\n  }\n\n  /**\n   * Removes one successful acquisition from the connection registry.\n   * @param {string} name - Lock name.\n   * @returns {void}\n   */\n  _untrackAdvisoryLock(name) {\n    const remainingCount = (this._heldAdvisoryLocks.get(name) || 0) - 1\n\n    if (remainingCount > 0) {\n      this._heldAdvisoryLocks.set(name, remainingCount)\n    } else {\n      this._heldAdvisoryLocks.delete(name)\n    }\n  }\n\n  /**\n   * Checks whether a named advisory lock is currently held by any session.\n   * Intended as an introspection helper; callers who need to act on the\n   * result should prefer `tryAcquireAdvisoryLock` to avoid a TOCTOU race.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the lock is held by ? session.\n   */\n  isAdvisoryLockHeld(name) { // eslint-disable-line no-unused-vars\n    throw new Error(`'isAdvisoryLockHeld' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Which advisory-lock backend tier this connection serves (STC-210 chain\n   * naming). The base driver is the driver-native tier; the SQLite drivers\n   * override to `process-local` / `file`.\n   * @returns {string} - Tier name reported on telemetry payloads.\n   */\n  advisoryLockBackendTier() {\n    return \"driver-native\"\n  }\n\n  /**\n   * Stable identity of this connection as a lock holder, reported on\n   * telemetry payloads so a slow acquire/hold is attributable to the reporting\n   * connection itself.\n   * @returns {string} - Holder id.\n   */\n  advisoryLockHolderId() {\n    if (!this._advisoryLockHolderId) this._advisoryLockHolderId = `advisory-lock-holder:${new UUID(4).format()}`\n\n    return this._advisoryLockHolderId\n  }\n\n  /**\n   * Best-effort identity of the connection currently holding the named lock,\n   * captured on the tier that served the acquisition. The base driver has no\n   * portable server-side lookup; MySQL/PostgreSQL/SQL Server/Node-SQLite\n   * override with their tier's holder attribution.\n   * @param {string} name - Lock name.\n   * @returns {Promise<string | null>} - Holder connection identity, or null when the tier cannot attribute it.\n   */\n  async advisoryLockHolderConnectionId(name) { // eslint-disable-line no-unused-vars\n    return null\n  }\n\n  /**\n   * Emit one event-driven advisory-lock telemetry report (slow acquire,\n   * acquire timeout with holder attribution, slow hold). The holder lookup is\n   * best-effort: a failed lookup is recorded on the report and never affects\n   * the acquisition that already settled.\n   * @param {{event: \"advisory-lock-slow-acquire\" | \"advisory-lock-acquire-timeout\" | \"advisory-lock-slow-hold\", lockName: string, durationMs: number, outcome: \"acquired\" | \"timeout\" | null, timeoutMs: number | null, captureHolder?: boolean}} args - Report args.\n   * @returns {Promise<void>} - Resolves after the report is emitted.\n   */\n  async _reportAdvisoryLockTelemetry(args) {\n    /** @type {import(\"../advisory-lock-telemetry.js\").AdvisoryLockTelemetryReport} */\n    const report = {\n      event: args.event,\n      lockName: args.lockName,\n      backendTier: this.advisoryLockBackendTier(),\n      durationMs: args.durationMs,\n      outcome: args.outcome,\n      timeoutMs: args.timeoutMs,\n      holderId: this.advisoryLockHolderId(),\n      holderConnectionId: null,\n      holderLookupError: null\n    }\n\n    if (args.captureHolder) {\n      try {\n        report.holderConnectionId = await this.advisoryLockHolderConnectionId(args.lockName)\n      } catch (error) {\n        report.holderLookupError = error instanceof Error ? error.message : String(error)\n      }\n    }\n\n    emitAdvisoryLockTelemetryReport(this.configuration, report)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../src/database/drivers/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * CreateIndexSqlArgs type.\n * @typedef {object} CreateIndexSqlArgs\n * @property {Array<string | import(\"./../table-data/table-column.js\").default>} columns - Columns to include in the index.\n * @property {boolean} [ifNotExists] - Skip creation if the index already exists.\n * @property {string} [name] - Explicit index name to use.\n * @property {boolean} [unique] - Whether the index should enforce uniqueness.\n * @property {string} tableName - Name of the table to add the index to.\n */\n/**\n * RemoveIndexSqlArgs type.\n * @typedef {object} RemoveIndexSqlArgs\n * @property {string} name - Index name to drop.\n * @property {string} tableName - Name of the table the index belongs to.\n */\n/**\n * DropTableSqlArgsType type.\n * @typedef {object} DropTableSqlArgsType\n * @property {boolean} [cascade] - Whether dependent objects should be dropped too.\n * @property {boolean} [ifExists] - Skip dropping if the table does not exist.\n */\n/**\n * DeleteSqlArgsType type.\n * @typedef {object} DeleteSqlArgsType\n * @property {string} tableName - Table name to delete from.\n * @property {{[key: string]: ReturnType<typeof JSON.parse>}} conditions - Conditions used to build the delete WHERE clause.\n */\n/**\n * InsertSqlArgsType type.\n * @typedef {object} InsertSqlArgsType\n * @property {string[]} [columns] - Column names for `rows` inserts.\n * @property {{[key: string]: ReturnType<typeof JSON.parse>}} [data] - Column/value pairs for a single-row insert.\n * @property {boolean} [multiple] - Whether this insert should be treated as multi-row.\n * @property {string[]} [returnLastInsertedColumnNames] - Column names to return after insert.\n * @property {Array<Array<ReturnType<typeof JSON.parse>>>} [rows] - Row values for a multi-row insert.\n * @property {string} tableName - Table name to insert into.\n */\n/**\n * QueryRowType type.\n * @typedef {Record<string, ReturnType<typeof JSON.parse>>} QueryRowType\n * @typedef {Array<QueryRowType>} QueryResultType\n */\n/**\n * TransactionCallbackFrame type.\n * @typedef {object} TransactionCallbackFrame\n * @property {Array<() => void | Promise<void>>} afterCommitCallbacks - Callbacks to merge or run after commit.\n * @property {Array<() => void | Promise<void>>} beforeCommitCallbacks - Guards to run before this frame completes.\n */\n/**\n * RetryableDatabaseErrorResult type.\n * @typedef {object} RetryableDatabaseErrorResult\n * @property {boolean} retry - Whether the error should be retried.\n * @property {boolean} reconnect - Whether to reconnect before retrying.\n * @property {boolean} [deadlock] - Whether the error is a transaction deadlock/lock-wait-timeout that should retry the whole transaction.\n * @property {\"deadlock\" | \"lock-wait-timeout\"} [contentionKind] - Classified transaction contention kind.\n * @property {number} [maxTries] - Override the max retry attempts.\n * @property {number} [waitMs] - Wait time before retrying in milliseconds.\n */\n/**\n * QueryOptions type.\n * @typedef {object} QueryOptions\n * @property {string} [logName] - Query log subject.\n * @property {boolean} [logQuery] - Whether to log the query.\n * @property {boolean} [processListComment] - Whether to add process-list comments to the query.\n * @property {number} [requestTimeoutMs] - Per-request driver timeout in milliseconds; zero disables the deadline on supporting drivers.\n * @property {boolean} [retry] - Whether retryable errors may retry the query; defaults to true.\n * @property {boolean} [sessionTimeZone] - Whether to ensure the configured database session time zone before the query.\n * @property {boolean} [sqliteScript] - Internal SQLite flag selecting native multi-statement script execution.\n * @property {AbortSignal} [signal] - Aborts the in-flight query (destroying its connection) when it fires.\n * @property {string} [sourceStack] - Stack captured at the caller boundary.\n * @property {symbol} [operationOwner] - Opaque owner for an operation-leased connection.\n */\n\n/**\n * DeadlockRetryDiagnosticSnapshot type.\n * @typedef {object} DeadlockRetryDiagnosticSnapshot\n * @property {number} attempt - One-based transaction attempt.\n * @property {\"deadlock\" | \"lock-wait-timeout\"} contentionKind - Classified contention kind.\n * @property {string} [databaseIdentifier] - Redacted logical database pool identifier marker.\n * @property {string} [databaseIdentifierFingerprint] - Opaque logical database pool identity.\n * @property {string} [databaseIdentityFingerprint] - Opaque physical database identity.\n * @property {string} driverType - Driver type.\n * @property {number} maxAttempts - Configured transaction attempt budget.\n * @property {string} [operationName] - Redacted operation-name marker.\n * @property {string} [operationNameFingerprint] - Opaque operation-name identity.\n * @property {string} [sqlFingerprint] - Normalized SQL-shape fingerprint.\n * @property {string} [sqlOperation] - SQL verb.\n * @property {string} stage - Error-event stage.\n * @property {number} transactionAttemptDurationMs - Duration of the failed outer attempt.\n * @property {boolean} willRetry - Whether another outer transaction attempt will run.\n */\n\n/**\n * TestProfileQueryAttempt type.\n * @typedef {object} TestProfileQueryAttempt\n * @property {import(\"../../testing/test-profiler.js\").TestProfileAsyncContext} context - Captured async attribution.\n * @property {{sqlFingerprint: string, sqlOperation: string}} diagnostic - Redacted statement diagnostic.\n * @property {number} startedAtMs - Physical attempt start time.\n */\n\n/**\n * ActiveQueryDebugSnapshot type.\n * @typedef {object} ActiveQueryDebugSnapshot\n * @property {string[]} annotations - Database annotations active when the query started.\n * @property {string} logName - Query log name.\n * @property {number} startedAtUnixMs - Query start timestamp.\n * @property {number} runningMs - Query runtime in milliseconds.\n * @property {string} sqlPreview - Truncated SQL preview.\n */\n\n/**\n * DatabaseConnectionDebugSnapshot type.\n * @typedef {object} DatabaseConnectionDebugSnapshot\n * @property {ActiveQueryDebugSnapshot | null} activeQuery - Currently running query, if any.\n * @property {number | undefined} checkedOutAtUnixMs - Checkout start timestamp for active checkouts.\n * @property {number | undefined} checkoutAgeMs - Active checkout age in milliseconds.\n * @property {string | undefined} checkoutName - Human-readable checkout name.\n * @property {string} driverClass - Driver class name.\n * @property {number | undefined} idSeq - Pool checkout ID sequence.\n * @property {number} openTransactions - Number of open transaction frames.\n * @property {number} schemaCacheEntries - Number of cached schema metadata entries.\n */\n\n/**\n * ActiveQueryState type.\n * @typedef {object} ActiveQueryState\n * @property {string[]} annotations - Database annotations active when the query started.\n * @property {string} logName - Query log name.\n * @property {number} startedAtUnixMs - Query start timestamp.\n * @property {string} sqlPreview - Truncated SQL preview.\n */\n\n/**\n * UpdateSqlArgsType type.\n * @typedef {object}UpdateSqlArgsType\n * @property {object} conditions - Conditions used to build the update WHERE clause.\n * @property {object} data - Column/value pairs to update.\n * @property {string} tableName - Table name to update.\n */\n/**\n * UpsertSqlArgsType type.\n * @typedef {object}UpsertSqlArgsType\n * @property {string[]} conflictColumns - Columns that define a conflict.\n * @property {object} data - Column/value pairs to insert.\n * @property {string} tableName - Table name to upsert into.\n * @property {string[]} updateColumns - Columns to update on conflict.\n */\n\n/**\n * SqlTokenResult type.\n * @typedef {object} SqlTokenResult\n * @property {boolean} incomplete - Whether the scan hit its bound before finishing trivia/token parsing.\n * @property {string | undefined} token - Lowercased token when parsing completed; undefined when no token was found.\n * @property {number} index - Index immediately after the parsed token or trivia.\n */\n\nimport BacktraceCleaner from \"../../utils/backtrace-cleaner.js\"\nimport { getDatabaseAnnotations } from \"../annotations.js\"\nimport { formatDateForDatabase } from \"../datetime-storage.js\"\nimport isDate from \"../../utils/is-date.js\"\nimport {DEFAULT_ADVISORY_LOCK_ACQUIRE_TIMEOUT_MS} from \"../advisory-lock-bound.js\"\nimport {advisoryLockTelemetryThresholds, emitAdvisoryLockTelemetryReport} from \"../advisory-lock-telemetry.js\"\nimport Logger from \"../../logger.js\"\nimport Query from \"../query/index.js\"\nimport QueryAbortedError from \"../query-aborted-error.js\"\nimport Handler from \"../handler.js\"\nimport { utf8ByteLength } from \"../../utils/utf8-byte-length.js\"\nimport Mutex from \"epic-locks/build/mutex.js\"\nimport UUID from \"pure-uuid\"\nimport TableData from \"../table-data/index.js\"\nimport TableColumn from \"../table-data/table-column.js\"\nimport TableForeignKey from \"../table-data/table-foreign-key.js\"\nimport wait from \"awaitery/build/wait.js\"\nimport { ensureError, optionalPositiveInteger } from \"typanic\"\nimport {coordinateSharedTransactionConnection, runWithoutSharedTransactionCoordinatorOwner} from \"../../testing/shared-transaction-connection-coordinator.js\"\nimport { currentTestProfileContext } from \"../../testing/test-profile-context.js\"\nimport sha256Hex from \"../../utils/sha256-hex.js\"\n\n/** Maximum characters inspected when building the debug SQL preview. */\nconst SQL_PREVIEW_SCAN_LIMIT = 4096\n/** Maximum characters inspected when deciding whether a statement invalidates schema metadata. */\nconst SCHEMA_INVALIDATION_SCAN_LIMIT = 8192\n/** Maximum checkout-name characters inspected by retry diagnostics. */\nconst OPERATION_NAME_SCAN_LIMIT = 1024\nconst REDACTED_DIAGNOSTIC_LABEL = \"[REDACTED]\"\n/** First backoff between retries of a schema-metadata read blocked by concurrent online DDL. */\nconst SCHEMA_METADATA_RETRY_INITIAL_DELAY_MS = 250\n/** Largest backoff between retries of a schema-metadata read blocked by concurrent online DDL. */\nconst SCHEMA_METADATA_RETRY_MAX_DELAY_MS = 2000\n/** Default bounded deadline for outlasting a concurrent online-DDL metadata skip. */\nconst SCHEMA_METADATA_RETRY_DEADLINE_MS = 60000\n\n/**\n * Builds a non-reversible, stable SQL fingerprint without retaining SQL text. Literal spelling is\n * normalized first so the same statement shape produces the same fingerprint across values.\n * @param {string} sql - SQL to fingerprint.\n * @returns {{sqlFingerprint: string, sqlOperation: string}} - Bounded query diagnostic.\n */\nfunction sqlDiagnostic(sql) {\n  let fingerprintInput = \"\"\n\n  for (let index = 0; index < sql.length;) {\n    const character = sql[index]\n    const nextCharacter = sql[index + 1]\n\n    if (character == \"'\" || character == '\"') {\n      const quote = character\n      fingerprintInput += \"?\"\n      index++\n\n      while (index < sql.length) {\n        if (sql[index] == \"\\\\\") {\n          index += 2\n        } else if (sql[index] == quote && sql[index + 1] == quote) {\n          index += 2\n        } else if (sql[index] == quote) {\n          index++\n          break\n        } else {\n          index++\n        }\n      }\n    } else if (character == \"/\" && nextCharacter == \"*\") {\n      const commentEnd = sql.indexOf(\"*/\", index + 2)\n      fingerprintInput += \" \"\n      index = commentEnd == -1 ? sql.length : commentEnd + 2\n    } else if ((character == \"-\" && nextCharacter == \"-\") || character == \"#\") {\n      const lineEnd = sql.indexOf(\"\\n\", index + 1)\n      fingerprintInput += \" \"\n      index = lineEnd == -1 ? sql.length : lineEnd + 1\n    } else {\n      fingerprintInput += character\n      index++\n    }\n  }\n\n  const normalized = fingerprintInput\n    .replace(/\\b(?:0x[0-9a-f]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b/gi, \"?\")\n    .replace(/\\s+/g, \" \")\n    .trim()\n    .toLowerCase()\n  let hash = 0xcbf29ce484222325n\n\n  for (let index = 0; index < normalized.length; index++) {\n    hash ^= BigInt(normalized.charCodeAt(index))\n    hash = BigInt.asUintN(64, hash * 0x100000001b3n)\n  }\n\n  const operationMatch = /^([a-z]+)/.exec(normalized)\n\n  return {\n    sqlFingerprint: `fnv1a64:${hash.toString(16).padStart(16, \"0\")}`,\n    sqlOperation: operationMatch ? operationMatch[1].toUpperCase() : \"UNKNOWN\"\n  }\n}\n\n/**\n * Marks a callback failure that happened after the owning transaction was durably committed.\n * The public transaction boundary unwraps it before deadlock classification.\n */\nclass VelociousDatabaseAfterCommitCallbackError extends Error {\n  /**\n   * Runs constructor.\n   * @param {ReturnType<typeof JSON.parse>} callbackError - Original callback failure.\n   */\n  constructor(callbackError) {\n    super(\"Database afterCommit callback failed\")\n    this.callbackError = callbackError\n  }\n}\n\n/**\n * Runs now ms.\n * @returns {number} - Current high-resolution-ish timestamp in milliseconds.\n */\nfunction nowMs() {\n  if (globalThis.performance && typeof globalThis.performance.now == \"function\") {\n    return globalThis.performance.now()\n  }\n\n  return Date.now()\n}\n\n/**\n * Runs format elapsed ms.\n * @param {number} elapsedMs - Elapsed milliseconds.\n * @returns {string} - Formatted elapsed milliseconds.\n */\nfunction formatElapsedMs(elapsedMs) {\n  return `${Math.max(elapsedMs, 0).toFixed(1)}ms`\n}\n\nexport default class VelociousDatabaseDriversBase {\n  /**\n   * Process-wide state for the **process-local advisory-lock pre-filter\n   * tier** shared by every driver (SQLite, MySQL/MariaDB, PostgreSQL,\n   * MSSQL). It serializes concurrent acquisitions of the same lock name\n   * inside this process through a FIFO waiter queue before any caller\n   * contacts the driver-native tier, so a contended same-process waiter\n   * never parks a pooled database connection in a driver lock state\n   * (MariaDB `User lock`, `sp_getapplock` session hold, ...).\n   *\n   * This tier is a pre-filter, **never the authority**: a grant here only\n   * means \"you are next in this process.\" Cross-process/cross-host\n   * exclusion is confirmed by the driver-native tier (or, once the\n   * STC-210 backend chain lands, the configured cross-host backend)\n   * before the acquisition succeeds.\n   *\n   * `ownersByName` maps each held lock name to the driver instance that\n   * acquired it so `releaseAdvisoryLock` can reject releases from drivers\n   * that do not own the lock.\n   * @type {{ownersByName: Map<string, VelociousDatabaseDriversBase>, waitersByName: Map<string, Array<() => void>>}}\n   */\n  static _advisoryLockState = {\n    ownersByName: new Map(),\n    waitersByName: new Map()\n  }\n\n  /**\n   * Id seq.\n   * @type {number | undefined} */\n  idSeq = undefined\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {TransactionCallbackFrame[]} */\n  _transactionCallbackFrames\n  /** @type {Promise<void>} */\n  _transactionCompletionPromise\n  /** @type {(() => void) | undefined} */\n  _resolveTransactionCompletion\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {Map<string, Promise<ReturnType<typeof JSON.parse>>>} */\n  _schemaCache\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {(() => void) | undefined} */\n  _schemaCacheInvalidator\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {string | undefined} */\n  _connectionCheckoutName\n  /** @type {string | undefined} */\n  _databaseIdentifier\n  /** @type {string | undefined} */\n  _databaseIdentityFingerprint\n  /**\n   * Active query.\n   * @type {ActiveQueryState | null} */\n  _activeQuery = null\n  /** @type {WeakMap<Error, {sqlFingerprint: string, sqlOperation: string}>} */\n  _failedQueryDiagnostics = new WeakMap()\n  /** @type {Map<string, number>} */\n  _heldAdvisoryLocks = new Map()\n  /**\n   * When each tracked advisory lock was first acquired, so the final release can\n   * report a hold that outlived `advisoryLockTelemetry.slowHoldMs`.\n   * @type {Map<string, number>}\n   */\n  _advisoryLockAcquiredAtByName = new Map()\n  /**\n   * Stable per-connection holder identity used by advisory-lock telemetry when\n   * the tier can only name local holders.\n   * @type {string | undefined}\n   */\n  _advisoryLockHolderId = undefined\n  /**\n   * Exclusive operation lease installed by a single-multi-use pool.\n   * @type {import(\"../operation-lease.js\").default | undefined}\n   */\n  _operationLease = undefined\n\n  /**\n   * Runs constructor.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} config - Configuration object.\n   * @param {import(\"../../configuration.js\").default} configuration - Configuration instance.\n   */\n  constructor(config, configuration) {\n    this._args = config\n    this.configuration = configuration\n    this.mutex = new Mutex() // Can be used to lock this instance for exclusive use\n    this.logger = new Logger(this)\n    this._transactionCallbackFrames = []\n    this._transactionsCount = 0\n    this._transactionCompletionPromise = Promise.resolve()\n    this._resolveTransactionCompletion = undefined\n    this._transactionsActionsMutex = new Mutex()\n    this._physicalConnectionMutex = new Mutex()\n    this._schemaCache = new Map()\n  }\n\n  /**\n   * Serializes access to one physical database session.\n   * @template T\n   * @param {() => Promise<T>} callback - Physical driver operation.\n   * @returns {Promise<T>} - Operation result.\n   */\n  async _runPhysicalConnectionRequest(callback) {\n    return await this._physicalConnectionMutex.sync(async () => {\n      return await runWithoutSharedTransactionCoordinatorOwner(this, callback)\n    })\n  }\n\n  /**\n   * Cleans driver-specific session state before this logical connection is reusable.\n   * Drivers whose physical sessions cannot be safely reset should dispose them here.\n   * @returns {Promise<void>} - Resolves when the next checkout cannot observe prior session state.\n   */\n  async cleanupSessionStateAfterCheckout() {}\n\n  /**\n   * Runs add foreign key.\n   * @param {string} tableName - Table name.\n   * @param {string} columnName - Column name.\n   * @param {string} referencedTableName - Referenced table name.\n   * @param {string} referencedColumnName - Referenced column name.\n   * @param {object} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, args) {\n    this._assertNotReadOnly()\n    const tableForeignKeyArgs = Object.assign(\n      {\n        columnName,\n        tableName,\n        referencedColumnName,\n        referencedTableName\n      },\n      args\n    )\n    const tableForeignKey = new TableForeignKey(tableForeignKeyArgs)\n    const tableData = new TableData(tableName)\n\n    tableData.addForeignKey(tableForeignKey)\n\n    const alterTableSQLs = await this.alterTableSQLs(tableData)\n\n    for (const alterTableSQL of alterTableSQLs) {\n      await this.query(alterTableSQL)\n    }\n  }\n\n  /**\n   * Runs remove foreign key.\n   * @param {string} tableName - Table name.\n   * @param {import(\"./base-foreign-key.js\").default} foreignKeyMetadata - Foreign key metadata.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async removeForeignKey(tableName, foreignKeyMetadata) {\n    this._assertNotReadOnly()\n\n    const tableForeignKey = new TableForeignKey({\n      columnName: foreignKeyMetadata.getColumnName(),\n      dropForeignKey: true,\n      name: foreignKeyMetadata.getName(),\n      referencedColumnName: foreignKeyMetadata.getReferencedColumnName(),\n      referencedTableName: foreignKeyMetadata.getReferencedTableName(),\n      tableName\n    })\n    const tableData = new TableData(tableName)\n\n    tableData.addForeignKey(tableForeignKey)\n\n    const alterTableSQLs = await this.alterTableSQLs(tableData)\n\n    for (const alterTableSQL of alterTableSQLs) {\n      await this.query(alterTableSQL)\n    }\n  }\n\n  /**\n   * Runs alter table sqls.\n   * @abstract\n   * @param {import(\"../table-data/index.js\").default} _tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  alterTableSQLs(_tableData) {\n    throw new Error(\"alterTableSQLs not implemented\")\n  }\n\n  /**\n   * Runs connect.\n   * @abstract\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  connect() {\n    throw new Error(\"'connect' not implemented\")\n  }\n\n  /**\n   * Releases tracked advisory locks and closes the physical database connection.\n   * @returns {Promise<void>} - Resolves when cleanup and close complete.\n   */\n  async close() {\n    /** @type {Error | undefined} */\n    let advisoryLockError\n\n    try {\n      await this.releaseHeldAdvisoryLocks()\n    } catch (error) {\n      advisoryLockError = error instanceof Error ? error : new Error(\"Failed to release held advisory locks\", {cause: error})\n    }\n\n    try {\n      await this._close()\n      this._heldAdvisoryLocks.clear()\n    } catch (error) {\n      const closeError = error instanceof Error ? error : new Error(\"Failed to close database connection\", {cause: error})\n\n      if (advisoryLockError) {\n        throw new AggregateError([advisoryLockError, closeError], \"Failed to release advisory locks and close database connection\", {cause: error})\n      }\n\n      throw closeError\n    }\n\n    if (advisoryLockError) throw advisoryLockError\n  }\n\n  /**\n   * Driver-specific physical close hook.\n   * @returns {Promise<void>} - Resolves when the underlying connection closes.\n   */\n  async _close() {\n    // No-op by default\n  }\n\n  /**\n   * Flushes pending writes that the driver delayed for persistence.\n   * @returns {Promise<void>} - Resolves when pending writes are durable.\n   */\n  async flushPendingWrites() {\n    // No-op by default\n  }\n\n  /**\n   * Returns whether delayed persistence writes remain.\n   * @returns {boolean} - Whether writes remain.\n   */\n  hasPendingWrites() { return false }\n\n  /**\n   * Deletes this driver's physical database storage without opening it.\n   * @returns {Promise<void>} - Resolves after deletion.\n   */\n  async deleteDatabaseStorage() { throw new Error(`Database storage deletion is not supported by ${this.constructor.name}`) }\n\n  /**\n   * Runs set connection checkout name.\n   * @param {string | undefined} name - Human-readable name for this active checkout.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async setConnectionCheckoutName(name) {\n    this._connectionCheckoutName = name\n    this._connectionCheckedOutAtUnixMs = Date.now()\n  }\n\n  /**\n   * Runs clear connection checkout name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async clearConnectionCheckoutName() {\n    this._connectionCheckoutName = undefined\n    this._connectionCheckedOutAtUnixMs = undefined\n  }\n\n  /**\n   * Sets the pool-owned identity used by safe database diagnostics.\n   * @param {{databaseIdentifier: string, databaseIdentityFingerprint: string}} identity - Pool-stamped identity redacted at diagnostic snapshot time.\n   * @returns {void}\n   */\n  setPoolDiagnosticIdentity({databaseIdentifier, databaseIdentityFingerprint}) {\n    this._databaseIdentifier = databaseIdentifier\n    this._databaseIdentityFingerprint = databaseIdentityFingerprint\n  }\n\n  /**\n   * Runs reconnect.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async reconnect() {\n    this.clearSchemaCache()\n    await this.close()\n    await this.connect()\n  }\n\n  /**\n   * Runs create database sql.\n   * @abstract\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifNotExists] - Whether if not exists.\n   * @param {string} [args.databaseCharset] - Database-default character set (driver-specific; mysql/mariadb).\n   * @param {string} [args.databaseCollation] - Database-default collation (driver-specific; mysql/mariadb).\n   * @returns {string[]} - SQL statements.\n   */\n  createDatabaseSql(databaseName, args) { throw new Error(\"'createDatabaseSql' not implemented\") } // eslint-disable-line no-unused-vars\n\n  /**\n   * Runs drop database sql.\n   * @abstract\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifExists] - Whether if exists.\n   * @returns {string[]} - SQL statements.\n   */\n  dropDatabaseSql(databaseName, args) { throw new Error(\"'dropDatabaseSql' not implemented\") } // eslint-disable-line no-unused-vars\n\n  /**\n   * Runs create index sqls.\n   * @abstract\n   * @param {CreateIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createIndexSQLs(indexData) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'createIndexSQLs' not implemented\")\n  }\n\n  /**\n   * Runs remove index sqls.\n   * @abstract\n   * @param {RemoveIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async removeIndexSQLs(indexData) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'removeIndexSQLs' not implemented\")\n  }\n\n  /**\n   * Runs create table.\n   * @param {import(\"../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async createTable(tableData) {\n    this._assertNotReadOnly()\n    const sqls = await this.createTableSql(tableData)\n\n    for (const sql of sqls) {\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs create table sql.\n   * @abstract\n   * @param {import(\"../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createTableSql(tableData) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'createTableSql' not implemented\")\n  }\n\n  /**\n   * Runs delete.\n   * @param {DeleteSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async delete(args) {\n    this._assertNotReadOnly()\n    const sql = this.deleteSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs delete sql.\n   * @abstract\n   * @param {DeleteSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  deleteSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(`'deleteSql' not implemented`)\n  }\n\n  /**\n   * Runs drop table.\n   * @param {string} tableName - Table name.\n   * @param {DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async dropTable(tableName, args) {\n    this._assertNotReadOnly()\n    const sqls = await this.dropTableSQLs(tableName, args)\n\n    for (const sql of sqls) {\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs drop table sqls.\n   * @abstract\n   * @param {string} tableName - Table name.\n   * @param {DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async dropTableSQLs(tableName, args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"dropTableSQLs not implemented\")\n  }\n\n  /**\n   * Runs escape.\n   * @abstract\n   * @param {ReturnType<typeof JSON.parse>} value - Value to use.\n   * @returns {ReturnType<typeof JSON.parse>} - The escape.\n   */\n  escape(value) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'escape' not implemented\")\n  }\n\n  /**\n   * Runs get args.\n   * @returns {import(\"../../configuration-types.js\").DatabaseConfigurationType} - The args.\n   */\n  getArgs() {\n    return this._args\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../../configuration.js\").default} - The configuration.\n   */\n  getConfiguration() {\n    if (!this.configuration) throw new Error(\"No configuration set\")\n\n    return this.configuration\n  }\n\n  /**\n   * Installs an operation lease atomically with ordinary transaction admission.\n   * @param {import(\"../operation-lease.js\").default} operationLease - Active lease.\n   * @returns {Promise<void>} - Resolves once the lease owns transaction admission.\n   */\n  async setOperationLease(operationLease) {\n    await this._transactionsActionsMutex.sync(async () => {\n      if (this._operationLease) throw new Error(\"A database operation lease is already active\")\n      if (this._transactionsCount > 0) {\n        throw new Error(\"Cannot start a database operation while an unrelated ordinary transaction is already active\")\n      }\n\n      this._operationLease = operationLease\n    })\n  }\n\n  /**\n   * Clears the matching operation lease.\n   * @param {import(\"../operation-lease.js\").default} operationLease - Lease to clear.\n   * @returns {void}\n   */\n  clearOperationLease(operationLease) {\n    if (this._operationLease !== operationLease) {\n      throw new Error(\"Cannot clear a database operation lease owned by another operation\")\n    }\n\n    this._operationLease = undefined\n  }\n\n  /**\n   * Waits for an unrelated operation lease to release.\n   * @param {symbol | undefined} operationOwner - Candidate operation owner.\n   * @returns {Promise<void>}\n   */\n  async _waitForOperationLease(operationOwner) {\n    const operationLease = this._operationLease\n\n    if (operationLease) await operationLease.wait(operationOwner)\n  }\n\n  /**\n   * Runs get id seq.\n   * @returns {number | undefined} - The id seq.\n   */\n  getIdSeq() {\n    return this.idSeq\n  }\n\n  /**\n   * Runs primary key type.\n   * @returns {string} - Configured primary key type, defaulting to UUID.\n   */\n  primaryKeyType() {\n    return this.getArgs().primaryKeyType || \"uuid\"\n  }\n\n  /**\n   * Clears cached schema metadata for this driver instance.\n   * @returns {void} - No return value.\n   */\n  clearSchemaCache() {\n    if (this._schemaCacheInvalidator) {\n      this._schemaCacheInvalidator()\n      return\n    }\n\n    this._clearLocalSchemaCache()\n  }\n\n  /**\n   * Clears only the metadata cached on this driver instance.\n   * @returns {void} - No return value.\n   */\n  _clearLocalSchemaCache() {\n    this._schemaCache.clear()\n  }\n\n  /**\n   * Runs set schema cache invalidator.\n   * @param {() => void} invalidator - Callback used to clear schema caches that share this driver pool.\n   * @returns {void} - No return value.\n   */\n  setSchemaCacheInvalidator(invalidator) {\n    this._schemaCacheInvalidator = invalidator\n  }\n\n  /**\n   * Runs schema cache enabled.\n   * @returns {boolean} - Whether schema metadata caching is enabled.\n   */\n  _schemaCacheEnabled() {\n    return this.getArgs().schemaCache !== false\n  }\n\n  /**\n   * Runs schema metadata retry deadline ms.\n   * @returns {number} - Bounded deadline for outlasting transient schema-metadata contention.\n   */\n  _schemaMetadataRetryDeadlineMs() {\n    const configured = this.getArgs().schemaMetadataRetryDeadlineMs\n\n    return typeof configured === \"number\" ? configured : SCHEMA_METADATA_RETRY_DEADLINE_MS\n  }\n\n  /**\n   * Whether an error raised by a schema-metadata read is transient contention that a bounded\n   * retry can outlast. Drivers override this for their own contention signatures; the default\n   * treats every failure as final so only drivers that prove the transient shape retry it.\n   * @param {unknown} _error - Error raised by a schema-metadata read.\n   * @returns {boolean} - Whether the read may be retried.\n   */\n  _isTransientSchemaMetadataError(_error) {\n    return false\n  }\n\n  /**\n   * Runs a schema-metadata read, retrying transient concurrent-DDL contention until the bounded\n   * deadline. Non-transient failures and exhausted deadlines propagate the original error.\n   * @template T\n   * @param {() => Promise<T>} callback - Cache-miss schema read.\n   * @returns {Promise<T>} - Resolves with the read result.\n   */\n  async _withSchemaMetadataDdlRetry(callback) {\n    const deadlineMs = this._schemaMetadataRetryDeadlineMs()\n    const startedAt = Date.now()\n    let delayMs = SCHEMA_METADATA_RETRY_INITIAL_DELAY_MS\n\n    for (;;) {\n      try {\n        return await callback()\n      } catch (error) {\n        if (!this._isTransientSchemaMetadataError(error)) throw error\n        if (Date.now() - startedAt + delayMs > deadlineMs) throw error\n\n        await wait(delayMs)\n        delayMs = Math.min(delayMs * 2, SCHEMA_METADATA_RETRY_MAX_DELAY_MS)\n      }\n    }\n  }\n\n  /**\n   * Runs cached schema metadata.\n   * @template T\n   * @param {string} cacheKey - Schema cache key.\n   * @param {() => Promise<T>} callback - Cache miss callback.\n   * @returns {Promise<T>} - Resolves with the cached metadata.\n   */\n  async _cachedSchemaMetadata(cacheKey, callback) {\n    if (!this._schemaCacheEnabled()) return await this._withSchemaMetadataDdlRetry(callback)\n\n    const existingPromise = this._schemaCache.get(cacheKey)\n\n    if (existingPromise) {\n      return /** @type {T} */ (this._schemaCacheReturnValue(await existingPromise))\n    }\n\n    const promise = (async () => await this._withSchemaMetadataDdlRetry(callback))()\n\n    this._schemaCache.set(cacheKey, promise)\n\n    try {\n      return /** @type {T} */ (this._schemaCacheReturnValue(await promise))\n    } catch (error) {\n      if (this._schemaCache.get(cacheKey) === promise) {\n        this._schemaCache.delete(cacheKey)\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs cached table schema metadata.\n   * @template T\n   * @param {string} tableName - Table name.\n   * @param {string} metadataName - Metadata name.\n   * @param {() => Promise<T>} callback - Cache miss callback.\n   * @returns {Promise<T>} - Resolves with the cached table metadata.\n   */\n  async _cachedTableSchemaMetadata(tableName, metadataName, callback) {\n    return await this._cachedSchemaMetadata(`table:${tableName}:${metadataName}`, callback)\n  }\n\n  /**\n   * Runs schema cache return value.\n   * @param {ReturnType<typeof JSON.parse>} value - Cached value.\n   * @returns {ReturnType<typeof JSON.parse>} - Value returned to callers.\n   */\n  _schemaCacheReturnValue(value) {\n    if (Array.isArray(value)) return value.slice()\n\n    return value\n  }\n\n  /**\n   * Runs get tables.\n   * @abstract\n   * @returns {Promise<Array<import(\"./base-table.js\").default>>} - Resolves with the tables.\n   */\n  getTables() {\n    throw new Error(`${this.constructor.name}#getTables not implemented`)\n  }\n\n  /**\n   * Runs structure sql.\n   * @returns {Promise<string | null>} - Resolves with SQL string.\n   */\n  async structureSql() {\n    return null\n  }\n\n  /**\n   * Executes a whole multi-statement structure SQL script in a single round-trip when\n   * the driver supports it, running on this connection (so the caller's foreign-key\n   * handling applies). Returns true if it ran the whole script; false when the caller\n   * should run the statements individually. The base driver has no batch path.\n   * @param {string} _structureSql - Full multi-statement structure SQL.\n   * @returns {Promise<boolean>} - Whether the script was executed as one batch.\n   */\n  async execStructureScript(_structureSql) {\n    return false\n  }\n\n  /**\n   * Runs get table by name.\n   * @param {string} name - Name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} args.throwError - Whether throw error.\n   * @returns {Promise<import(\"./base-table.js\").default | undefined>} - Resolves with the table by name.\n   */\n  async getTableByName(name, args) {\n    const tables = await this.getTables()\n    const tableNames = []\n    let table\n\n    for (const candidate of tables) {\n      const candidateName = candidate.getName()\n\n      if (candidateName == name) {\n        table = candidate\n        break\n      }\n\n      tableNames.push(candidateName)\n    }\n\n    if (!table && args?.throwError !== false) {\n      throw new Error(this._missingTableErrorMessage(name, tableNames))\n    }\n\n    return table\n  }\n\n  /**\n   * Runs missing table error message.\n   * @param {string} name - Table name.\n   * @param {string[]} tableNames - Available table names.\n   * @returns {string} - Error message.\n   */\n  _missingTableErrorMessage(name, tableNames) {\n    const environment = this.getConfiguration().getEnvironment()\n    const args = this.getArgs()\n    const databaseName = args?.database || args?.name || args?.useDatabase || \"unknown\"\n\n    return `Couldn't find a table by that name \"${name}\" in: ${tableNames.join(\", \")} (environment: ${environment}, database: ${databaseName})`\n  }\n\n  /**\n   * Runs get table by name or fail.\n   * @param {string} name - Name.\n   * @returns {Promise<import(\"./base-table.js\").default>} - Resolves with the table by name or fail.\n   */\n  async getTableByNameOrFail(name) {\n    return /** @type {import(\"./base-table.js\").default} */ (await this.getTableByName(name, {throwError: true}))\n  }\n\n  /**\n   * Runs get type.\n   * @abstract\n   * @returns {string} - The type.\n   */\n  getType() {\n    throw new Error(\"'type' not implemented\")\n  }\n\n  /**\n   * Whether this driver can combine unrelated alter-table operations into a\n   * single `ALTER TABLE` statement (Rails' `supports_bulk_alter`).\n   * @returns {boolean} - Whether bulk alter is supported.\n   */\n  supportsBulkAlter() {\n    return false\n  }\n\n  /**\n   * Whether a bulk `ALTER TABLE` statement can also carry `ADD INDEX` clauses.\n   * Only drivers that support this keep index adds inside the combined batch;\n   * the rest execute each index as its own statement.\n   * @returns {boolean} - Whether indexes can be added inside a bulk alter.\n   */\n  supportsBulkAlterIndexes() {\n    return false\n  }\n\n  /**\n   * Runs insert.\n   * @param {InsertSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insert(args) {\n    this._assertNotReadOnly()\n    const sql = this.insertSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Maximum rows per `INSERT ... VALUES (...), (...), ...` statement. Drivers\n   * that build multi-value inserts must stay below database-specific limits\n   * (SQLite's `MAX_VARIABLE_NUMBER`, SQL Server's 2100 parameters, PostgreSQL's\n   * 65535 parameters, and so on). 500 rows is safely under every major engine\n   * for tables with a moderate number of columns and keeps generated SQL small.\n   *\n   * Override via `maxRowsPerInsert` in the database configuration.\n   * @returns {number} - Maximum rows per insert statement.\n   */\n  maxRowsPerInsert() {\n    return optionalPositiveInteger(this.getArgs().maxRowsPerInsert, \"maxRowsPerInsert\") ?? 500\n  }\n\n  /**\n   * Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES`\n   * statement. Large text/JSON payloads can push a modest row count well beyond\n   * database wire/protocol limits, so chunking also stops when the next row\n   * would push the generated string over this threshold.\n   *\n   * Override via `maxInsertSqlBytes` in the database configuration.\n   * @returns {number} - Maximum bytes per insert statement.\n   */\n  maxInsertSqlBytes() {\n    return optionalPositiveInteger(this.getArgs().maxInsertSqlBytes, \"maxInsertSqlBytes\") ?? 1048576\n  }\n\n  /**\n   * Maximum values in a single `IN (...)` cohort used by preloads, association\n   * counts, and queryData aggregates. The default stays under SQLite's default\n   * `MAX_VARIABLE_NUMBER` compile-time limit.\n   *\n   * Override via `maxInClauseValues` in the database configuration.\n   * @returns {number} - Maximum values per IN clause cohort.\n   */\n  maxInClauseValues() {\n    return optionalPositiveInteger(this.getArgs().maxInClauseValues, \"maxInClauseValues\") ?? 999\n  }\n\n  /**\n   * Maximum serialized SQL size, in bytes, for a single cohort query used by\n   * preloads, association counts, and queryData aggregates. Cohort chunking\n   * stops when the next value would push the generated string over this threshold.\n   *\n   * Override via `maxQuerySqlBytes` in the database configuration.\n   * @returns {number} - Maximum bytes per cohort query.\n   */\n  maxQuerySqlBytes() {\n    return optionalPositiveInteger(this.getArgs().maxQuerySqlBytes, \"maxQuerySqlBytes\") ?? 1048576\n  }\n\n  /**\n   * Splits `values` into cohort chunks that stay within both `maxCount` and\n   * `maxBytes` while preserving order.\n   *\n   * A chunk always contains at least one value, even if that single value exceeds\n   * the byte limit, so progress is guaranteed.\n   * @template T\n   * @param {Array<T>} values - Values to chunk.\n   * @param {(values: Array<T>) => string} buildSql - Function that builds the full SQL for a candidate chunk.\n   * @param {{maxCount?: number, maxBytes?: number}} [options] - Chunking bounds.\n   * @returns {Array<Array<T>>} - Value cohorts.\n   */\n  chunkValues(values, buildSql, {maxCount = this.maxInClauseValues(), maxBytes = this.maxQuerySqlBytes()} = {}) {\n    if (values.length === 0) return []\n\n    /**\n     * Chunks.\n     * @type {Array<Array<T>>} */\n    const chunks = []\n    /**\n     * Current chunk.\n     * @type {Array<T>} */\n    let currentChunk = []\n\n    for (const value of values) {\n      const candidate = [...currentChunk, value]\n      const candidateBytes = utf8ByteLength(buildSql(candidate))\n\n      if (currentChunk.length > 0 && (candidate.length > maxCount || candidateBytes > maxBytes)) {\n        chunks.push(currentChunk)\n        currentChunk = [value]\n      } else {\n        currentChunk = candidate\n      }\n    }\n\n    if (currentChunk.length > 0) {\n      chunks.push(currentChunk)\n    }\n\n    return chunks\n  }\n\n  /**\n   * Splits `rows` into chunks that stay within both {@link maxRowsPerInsert}\n   * and {@link maxInsertSqlBytes} while preserving order.\n   *\n   * Byte accounting is incremental: `buildSql` is called once with `[]` to\n   * measure the statement prefix and once per row with `[row]` to measure the\n   * row's values tuple. This keeps chunking linear in the number of rows\n   * instead of rebuilding the full multi-row SQL for every candidate.\n   *\n   * A chunk always contains at least one row, even if that single row exceeds\n   * the byte limit, so progress is guaranteed.\n   * @param {Array<Array<ReturnType<typeof JSON.parse>>>} rows - Rows to insert.\n   * @param {(rows: Array<Array<ReturnType<typeof JSON.parse>>>) => string} buildSql - Function that builds the full SQL for a candidate chunk; called with `[]` to measure the statement prefix and with `[row]` to measure each row's values tuple.\n   * @returns {Array<Array<Array<ReturnType<typeof JSON.parse>>>>} - Row chunks.\n   */\n  _insertMultipleChunks(rows, buildSql) {\n    const chunks = []\n    const maxRows = this.maxRowsPerInsert()\n    const maxBytes = this.maxInsertSqlBytes()\n    const emptySql = buildSql([])\n    const prefix = `${emptySql} VALUES `\n    const baseByteLength = utf8ByteLength(prefix)\n\n    /**\n     * Current chunk.\n     * @type {Array<Array<ReturnType<typeof JSON.parse>>>} */\n    let currentChunk = []\n    let currentBytes = 0\n\n    for (const row of rows) {\n      const singleRowSql = buildSql([row])\n      const rowValuesSql = singleRowSql.slice(prefix.length)\n      const rowValuesSqlBytes = utf8ByteLength(rowValuesSql)\n\n      if (currentChunk.length > 0) {\n        const candidateRows = currentChunk.length + 1\n        const candidateBytes = currentBytes + 2 + rowValuesSqlBytes // \", \" separator\n\n        if (candidateRows > maxRows || candidateBytes > maxBytes) {\n          chunks.push(currentChunk)\n          currentChunk = []\n          currentBytes = 0\n        }\n      }\n\n      if (currentChunk.length === 0) {\n        currentBytes = baseByteLength + rowValuesSqlBytes\n      } else {\n        currentBytes += 2 + rowValuesSqlBytes\n      }\n\n      currentChunk.push(row)\n    }\n\n    if (currentChunk.length > 0) {\n      chunks.push(currentChunk)\n    }\n\n    return chunks\n  }\n\n  /**\n   * Runs insert multiple.\n   *\n   * Large row sets are split into multiple statements that each stay within\n   * {@link maxRowsPerInsert} rows and {@link maxInsertSqlBytes} serialized\n   * bytes so the generated SQL stays within database parameter and wire limits.\n   * When called outside a transaction each chunk commits independently; callers\n   * that need all-or-nothing semantics should wrap the call in {@link transaction}.\n   * @param {string} tableName - Table name.\n   * @param {Array<string>} columns - Column names.\n   * @param {Array<Array<ReturnType<typeof JSON.parse>>>} rows - Rows to insert.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insertMultiple(tableName, columns, rows) {\n    this._assertNotReadOnly()\n\n    const chunks = this._insertMultipleChunks(rows, (chunkRows) => this.insertSql({columns, tableName, rows: chunkRows}))\n\n    for (const chunk of chunks) {\n      const sql = this.insertSql({columns, tableName, rows: chunk})\n\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs insert sql.\n   * @abstract\n   * @param {InsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  insertSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'insertSql' not implemented\")\n  }\n\n  /**\n   * Runs upsert.\n   * @param {UpsertSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async upsert(args) {\n    this._assertNotReadOnly()\n    const sql = this.upsertSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs last insert id.\n   * @abstract\n   * @param {QueryOptions} [_options] - Query ownership options.\n   * @returns {Promise<number>} - Resolves with the last insert id.\n   */\n  lastInsertID(_options = {}) {\n    throw new Error(`${this.constructor.name}#lastInsertID not implemented`)\n  }\n\n  /**\n   * Runs convert value.\n   * @param {ReturnType<typeof JSON.parse>} value - Value to use.\n   * @returns {ReturnType<typeof JSON.parse>} - The convert value.\n   */\n  _convertValue(value) {\n    if (typeof value === \"boolean\") {\n      return value ? 1 : 0\n    }\n\n    // isDate instead of instanceof: a Date created in another realm (e.g. the console REPL) would\n    // fail instanceof, skip this conversion, and serialize as an empty SQL value downstream.\n    if (isDate(value)) {\n      return formatDateForDatabase(value, {databaseType: this.getType()})\n    }\n\n    // JSON-encode plain objects/arrays so they land in JSON/text columns as valid\n    // JSON. Without this, drivers like mysql's escape() turn an object into\n    // `key` = value assignment pairs (its `SET ?` form), producing invalid SQL in\n    // a value position. Only PLAIN objects and arrays are encoded — class\n    // instances (e.g. model records, which are circular via _changes) and Buffers\n    // pass through untouched, since JSON.stringify on a record throws on its\n    // circular structure and a record is never a valid column value to serialize.\n    if (this._isJsonEncodableValue(value)) {\n      return JSON.stringify(value)\n    }\n\n    return value\n  }\n\n  /**\n   * Whether a value is a plain object or array that should be JSON-encoded for a\n   * JSON/text column. Excludes Buffers and class instances (e.g. model records).\n   * @param {ReturnType<typeof JSON.parse>} value - Value to test.\n   * @returns {boolean} - Whether to JSON-encode the value.\n   */\n  _isJsonEncodableValue(value) {\n    if (value === null || typeof value !== \"object\") return false\n    if (typeof Buffer !== \"undefined\" && Buffer.isBuffer(value)) return false\n    if (Array.isArray(value)) return true\n\n    const prototype = Object.getPrototypeOf(value)\n\n    return prototype === Object.prototype || prototype === null\n  }\n\n  /**\n   * Runs options.\n   * @abstract\n   * @returns {import(\"../query-parser/options.js\").default} - The options options.\n   */\n  options() {\n    throw new Error(\"'options' not implemented.\")\n  }\n\n  /**\n   * Runs quote.\n   * @param {ReturnType<typeof JSON.parse>} value - Value to use.\n   * @returns {number | string} - The quote.\n   */\n  quote(value) {\n    if (typeof value == \"number\") return value\n\n    const escapedValue = this.escape(value)\n    const result = `\"${escapedValue}\"`\n\n    return result\n  }\n\n  /**\n   * Runs quote column.\n   * @param {string} columnName - Column name.\n   * @returns {string} - The quote column.\n   */\n  quoteColumn(columnName) {\n    return this.options().quoteColumnName(columnName)\n  }\n\n  /**\n   * Runs quote index.\n   * @param {string} columnName - Column name.\n   * @returns {string} - The quote index.\n   */\n  quoteIndex(columnName) {\n    return this.options().quoteIndexName(columnName)\n  }\n\n  /**\n   * Runs quote table.\n   * @param {string} tableName - Table name.\n   * @returns {string} - The quote table.\n   */\n  quoteTable(tableName) {\n    return this.options().quoteTableName(tableName)\n  }\n\n  /**\n   * Runs new query.\n   * @returns {Query} - The new query.\n   */\n  newQuery() {\n    const handler = new Handler()\n\n    return new Query({\n      driver: this,\n      handler\n    })\n  }\n\n  /**\n   * Runs select.\n   * @param {string} tableName - Table name.\n   * @returns {Promise<QueryResultType>} - Resolves with the select.\n   */\n  async select(tableName) {\n    const query = this.newQuery()\n\n    const sql = query\n      .from(tableName)\n      .toSql()\n\n    return await this.query(sql)\n  }\n\n  /**\n   * Runs set id seq.\n   * @param {number | undefined} newIdSeq - New id seq.\n   * @returns {void} - No return value.\n   */\n  setIdSeq(newIdSeq) {\n    this.idSeq = newIdSeq\n  }\n\n  /**\n   * Runs should set auto increment when primary key.\n   * @abstract\n   * @returns {boolean} - Whether set auto increment when primary key.\n   */\n  shouldSetAutoIncrementWhenPrimaryKey() {\n    throw new Error(`'shouldSetAutoIncrementWhenPrimaryKey' not implemented`)\n  }\n\n  /**\n   * Runs supports default primary key uuid.\n   * @returns {boolean} - Whether supports default primary key uuid.\n   */\n  supportsDefaultPrimaryKeyUUID() { return false }\n\n  /**\n   * Executes an insert that carries an explicit primary-key value\n   * (client-generated offline-sync ids). Drivers whose auto-increment columns\n   * reject explicit values (MSSQL IDENTITY) override this to run the insert\n   * with identity insert enabled in a single request.\n   * @param {object} args - Options object.\n   * @param {QueryOptions} args.options - Query options for the standard query path.\n   * @param {string} args.sql - Generated insert SQL.\n   * @param {string} args.tableName - Table being inserted into.\n   * @returns {Promise<QueryResultType>} - Insert result.\n   */\n  async insertWithExplicitPrimaryKey({options, sql, tableName}) {\n    void tableName\n\n    return await this.query(sql, options)\n  }\n\n  /**\n   * Runs supports insert into returning.\n   * @abstract\n   * @returns {boolean} - Whether supports insert into returning.\n   */\n  supportsInsertIntoReturning() { return false }\n\n  /**\n   * Whether a single connection can reference tables in another database on the same server via a\n   * two-part `database`.`table` identifier. When true, a query spanning several databases on this\n   * server can be expressed as one statement (a cross-tenant `UNION ALL`); when false, each database\n   * is queried on its own connection and the results merged in the caller. Only MySQL/MariaDB return\n   * true: PostgreSQL (one database per connection) and SQLite (one attached file per connection)\n   * cannot, and MSSQL is excluded because it reads a two-part name as `schema.table` (cross-database\n   * access needs a three-part `database.schema.table`), so it stays on the always-correct fan-out\n   * path. Consumed by `Tenant.aggregateAcross`.\n   * @returns {boolean} - Whether two-part cross-database references are supported.\n   */\n  supportsCrossDatabaseReferences() { return false }\n\n  /**\n   * Runs table exists.\n   * @param {string} tableName - Table name.\n   * @returns {Promise<boolean>} - Resolves with Whether table exists.\n   */\n  async tableExists(tableName) {\n    const tables = await this.getTables()\n    const table = tables.find((table) => table.getName() == tableName)\n\n    if (table) return true\n\n    return false\n  }\n\n  /**\n   * Runs a callback inside a database transaction (or a savepoint when already inside one).\n   * The outermost transaction retries the whole callback on a deadlock / lock-wait-timeout,\n   * because such errors roll the entire transaction back and the standard recovery is to\n   * restart it. Nested savepoints let the deadlock bubble up to this outer retry.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback function.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<T>} - Resolves with the transaction result.\n   */\n  async transaction(callback, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n\n    return await coordinateSharedTransactionConnection(this, async () => {\n      if (this._transactionsCount > 0) {\n        return await this._runTransactionAttempt(callback, options)\n      }\n\n      const args = this.getArgs()\n      const maxAttempts = optionalPositiveInteger(args.deadlockMaxRetries, \"deadlockMaxRetries\") ?? 8\n      const configuredBaseWaitMs = optionalPositiveInteger(args.deadlockBaseWaitMs, \"deadlockBaseWaitMs\")\n      const deadlockMaxWaitMs = optionalPositiveInteger(args.deadlockMaxWaitMs, \"deadlockMaxWaitMs\") ?? 1000\n      let attempt = 0\n\n      while (true) {\n        attempt++\n        const attemptStartedAtMs = this._nowMs()\n\n        try {\n          return await this._runTransactionAttempt(callback, options)\n        } catch (error) {\n          if (error instanceof VelociousDatabaseAfterCommitCallbackError) throw error.callbackError\n          if (!(error instanceof Error)) throw error\n\n          const retryInfo = this.retryableDatabaseError(error)\n          const willRetry = Boolean(retryInfo.deadlock && attempt < maxAttempts && this._transactionsCount == 0)\n\n          if (willRetry) {\n            this._reportDeadlockRetryDiagnostic({\n              attempt,\n              contentionKind: retryInfo.contentionKind || \"deadlock\",\n              error,\n              maxAttempts,\n              transactionAttemptDurationMs: Math.max(0, this._nowMs() - attemptStartedAtMs),\n              willRetry\n            })\n\n            // An explicitly-configured base wins so the tuning knob is effective even on drivers\n            // whose classifier supplies its own `waitMs` (MySQL/MariaDB return a fixed 50ms for\n            // deadlocks); otherwise honor that classifier hint, then fall back to 50ms.\n            const baseWaitMs = configuredBaseWaitMs ?? (typeof retryInfo.waitMs == \"number\" && retryInfo.waitMs > 0 ? retryInfo.waitMs : 50)\n\n            // Full-jitter exponential backoff: wait a uniform-random duration in\n            // [0, min(base * 2^(attempt-1), cap)]. The doubling ceiling spreads retries out as\n            // contention persists, and the jitter de-correlates transactions that deadlocked in\n            // lockstep so they stop re-colliding on the same wait (the linear `base * attempt`\n            // this replaces had every victim retry after an identical delay). `attempt` is\n            // 1-based here, so 2^(attempt-1) is 1, 2, 4, ... The cap keeps the tail sub-second.\n            const ceilingWaitMs = Math.min(baseWaitMs * (2 ** (attempt - 1)), deadlockMaxWaitMs)\n            const jitteredWaitMs = Math.floor(Math.random() * (ceilingWaitMs + 1))\n\n            const loggedContentionKind = retryInfo.contentionKind || \"transaction contention\"\n\n            this.logger.warn(`Retrying transaction after ${loggedContentionKind} (attempt ${attempt}/${maxAttempts})`)\n            await this._waitMs(jitteredWaitMs)\n            continue\n          }\n\n          throw error\n        }\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Waits `ms` milliseconds. Isolated in its own method so tests can observe (and skip) the\n   * deadlock-retry backoff without a real timer.\n   * @param {number} ms - Milliseconds to wait.\n   * @returns {Promise<void>} - Resolves after the delay.\n   */\n  async _waitMs(ms) {\n    await wait(ms)\n  }\n\n  /**\n   * Returns the clock used for transaction-attempt diagnostics.\n   * @returns {number} - Monotonic milliseconds where available.\n   */\n  _nowMs() {\n    return nowMs()\n  }\n\n  /**\n   * Starts best-effort deadlock diagnostics without joining the retry control flow. Subclasses may\n   * add bounded driver-specific context; capture and event-listener failures cannot affect retry.\n   * @param {{attempt: number, contentionKind: \"deadlock\" | \"lock-wait-timeout\", error: Error, maxAttempts: number, transactionAttemptDurationMs: number, willRetry: boolean}} args - Retry metadata.\n   * @returns {void}\n   */\n  _reportDeadlockRetryDiagnostic({attempt, contentionKind, error, maxAttempts, transactionAttemptDurationMs, willRetry}) {\n    let snapshot\n\n    try {\n      const queryDiagnostic = this._failedQueryDiagnostics.get(error)\n\n      snapshot = Object.freeze({\n        attempt,\n        contentionKind,\n        driverType: this.getType(),\n        maxAttempts,\n        stage: \"database-deadlock-retry\",\n        transactionAttemptDurationMs,\n        willRetry,\n        ...this._poolDiagnosticIdentityContext(),\n        ...this._operationDiagnosticContext(),\n        ...queryDiagnostic\n      })\n    } catch (diagnosticError) {\n      this._reportDeadlockDiagnosticPipelineFailure(diagnosticError)\n      return\n    }\n\n    let driverContextResult\n\n    try {\n      driverContextResult = this._deadlockDiagnosticContext(snapshot)\n    } catch (diagnosticError) {\n      this._reportDeadlockDiagnosticPipelineFailure(diagnosticError)\n      return\n    }\n\n    const hasPromiseContract = driverContextResult instanceof Promise\n\n    void Promise.resolve(driverContextResult)\n      .then((driverContext) => {\n        if (!hasPromiseContract) throw new Error(\"Database deadlock diagnostic context must return a Promise\")\n\n        const context = {\n          ...snapshot,\n          ...driverContext\n        }\n        const payload = {\n          context,\n          error: new Error(willRetry\n            ? `Database transaction ${contentionKind} will be retried`\n            : `Database transaction ${contentionKind} exhausted its retry budget`)\n        }\n        const errorEvents = this.configuration.getErrorEvents()\n\n        try {\n          errorEvents.emit(\"database-deadlock-retry\", payload)\n        } catch (eventError) {\n          this.logger.warn(\"Database deadlock retry diagnostic listener failed\", {error: eventError})\n        }\n\n        try {\n          errorEvents.emit(\"all-error\", {...payload, errorType: \"database-deadlock-retry\"})\n        } catch (eventError) {\n          this.logger.warn(\"Database deadlock retry all-error listener failed\", {error: eventError})\n        }\n      })\n      .catch((diagnosticError) => this._reportDeadlockDiagnosticPipelineFailure(diagnosticError))\n  }\n\n  /**\n   * Returns pool identity only when this driver was stamped by a pool.\n   * @returns {{databaseIdentifier?: string, databaseIdentifierFingerprint?: string, databaseIdentityFingerprint?: string}} - Safe pool identity.\n   */\n  _poolDiagnosticIdentityContext() {\n    if (this._databaseIdentifier === undefined || !this._databaseIdentityFingerprint) return {}\n\n    const identifierFingerprintInput = typeof this._databaseIdentifier === \"string\"\n      ? this._databaseIdentifier\n      : `invalid:${typeof this._databaseIdentifier}`\n    const databaseIdentifierFingerprint = `sha256:${sha256Hex(`database-logical-identifier:v1\\0${identifierFingerprintInput}`)}`\n\n    return {\n      databaseIdentifier: REDACTED_DIAGNOSTIC_LABEL,\n      databaseIdentifierFingerprint,\n      databaseIdentityFingerprint: this._databaseIdentityFingerprint\n    }\n  }\n\n  /**\n   * Builds the bounded operation portion of an immutable retry snapshot.\n   * @returns {{operationName?: string, operationNameFingerprint?: string}} - Safe operation fields.\n   */\n  _operationDiagnosticContext() {\n    const rawOperationName = this._connectionCheckoutName\n\n    if (rawOperationName === undefined) return {}\n    if (typeof rawOperationName !== \"string\") {\n      return {\n        operationName: REDACTED_DIAGNOSTIC_LABEL,\n        operationNameFingerprint: `sha256:${sha256Hex(`database-operation:v1\\0invalid:${typeof rawOperationName}`)}`\n      }\n    }\n\n    const scannedOperationName = rawOperationName.slice(0, OPERATION_NAME_SCAN_LIMIT)\n    const operationNameFingerprint = `sha256:${sha256Hex(`database-operation:v1\\0${scannedOperationName}\\0length:${rawOperationName.length}`)}`\n\n    return {\n      operationName: REDACTED_DIAGNOSTIC_LABEL,\n      operationNameFingerprint\n    }\n  }\n\n  /**\n   * Reports an unexpected detached diagnostics failure without changing transaction control flow.\n   * @param {ReturnType<typeof JSON.parse>} diagnosticError - Diagnostics failure.\n   * @returns {void}\n   */\n  _reportDeadlockDiagnosticPipelineFailure(diagnosticError) {\n    const normalizedError = diagnosticError instanceof Error\n      ? diagnosticError\n      : new Error(\"Database deadlock retry diagnostic failed\", {cause: diagnosticError})\n    const payload = {\n      context: {stage: \"database-deadlock-retry-diagnostic\"},\n      error: normalizedError\n    }\n    let errorEvents\n\n    try {\n      errorEvents = this.configuration.getErrorEvents()\n    } catch (reportingError) {\n      this.logger.warn(\"Database deadlock retry diagnostic pipeline reporting failed\", {error: normalizedError, reportingError})\n      return\n    }\n\n    try {\n      errorEvents.emit(\"framework-error\", payload)\n    } catch (reportingError) {\n      this.logger.warn(\"Database deadlock retry framework-error listener failed\", {error: normalizedError, reportingError})\n    }\n\n    try {\n      errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n    } catch (reportingError) {\n      this.logger.warn(\"Database deadlock retry all-error listener failed\", {error: normalizedError, reportingError})\n    }\n  }\n\n  /**\n   * Builds driver-specific deadlock context. The base driver has no server diagnostic source.\n   * @param {DeadlockRetryDiagnosticSnapshot} _snapshot - Immutable retry snapshot.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Safe context fields.\n   */\n  async _deadlockDiagnosticContext(_snapshot) {\n    return {}\n  }\n\n  /**\n   * Runs a single transaction attempt: starts a transaction (or a savepoint when nested), runs\n   * `callback`, and commits — rolling back on error. {@link transaction} wraps this with deadlock\n   * retry at the outermost level.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback function.\n   * @param {Pick<QueryOptions, \"operationOwner\">} options - Transaction ownership.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the transaction result.\n   */\n  async _runTransactionAttempt(callback, options) {\n    const savePointName = this.generateSavePointName()\n    /** @type {TransactionCallbackFrame} */\n    const callbackFrame = {\n      afterCommitCallbacks: [],\n      beforeCommitCallbacks: []\n    }\n    let transactionStarted = false\n    let savePointStarted = false\n\n    this._transactionCallbackFrames.push(callbackFrame)\n\n    try {\n      if (this._transactionsCount == 0) {\n        this.logger.debug(\"Start transaction\")\n        await this.startTransaction(options)\n        transactionStarted = true\n      } else {\n        this.logger.debug(\"Start savepoint\", savePointName)\n        await this.startSavePoint(savePointName, options)\n        savePointStarted = true\n      }\n    } catch (error) {\n      this._transactionCallbackFrames.pop()\n      throw error\n    }\n\n    let result\n\n    try {\n      result = await callback()\n      await this._runBeforeCommitCallbacks(callbackFrame)\n\n      if (savePointStarted) {\n        this.logger.debug(\"Release savepoint\", savePointName)\n        await this.releaseSavePoint(savePointName, options)\n      }\n\n      if (transactionStarted) {\n        this.logger.debug(\"Commit transaction\")\n        await this.commitTransaction(options)\n      }\n    } catch (error) {\n      if (error instanceof Error) {\n        this.logger.debug(\"Transaction error\", error.message)\n      } else {\n        this.logger.debug(\"Transaction error\", error)\n      }\n\n      try {\n        let transactionRolledBack = false\n\n        if (savePointStarted) {\n          this.logger.debug(\"Rollback savepoint\", savePointName)\n          try {\n            await this.rollbackSavePoint(savePointName, options)\n          } catch (savePointError) {\n            const message = savePointError instanceof Error ? savePointError.message : `${savePointError}`\n\n            // MySQL sometimes drops savepoints unexpectedly; fall back to rolling back the full transaction\n            if (message.includes(\"SAVEPOINT\") || message.includes(\"ER_SP_DOES_NOT_EXIST\")) {\n              this.logger.debug(\"Savepoint rollback failed; rolling back entire transaction instead\")\n              await this.rollbackTransaction(options)\n              transactionRolledBack = true\n            } else {\n              throw savePointError\n            }\n          }\n        }\n\n        // Only roll back if a transaction is still open. A nested savepoint whose rollback failed\n        // falls back to rolling back the whole transaction (above), which already closed it and\n        // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive\n        // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.\n        if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {\n          this.logger.debug(\"Rollback transaction\")\n          await this.rollbackTransaction(options)\n        }\n      } finally {\n        this._transactionCallbackFrames.pop()\n      }\n\n      throw error\n    }\n\n    try {\n      await this._commitTransactionCallbackFrame()\n    } catch (error) {\n      throw new VelociousDatabaseAfterCommitCallbackError(error)\n    }\n\n    return result\n  }\n\n  /**\n   * Registers a guard to run after the current transaction callback succeeds and before its\n   * outer commit or nested savepoint release.\n   * @param {() => void | Promise<void>} callback - Guard callback.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Callback ownership.\n   * @returns {Promise<void>} - Resolves when the guard has been registered.\n   */\n  async beforeCommit(callback, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n\n    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]\n\n    if (!currentFrame) throw new Error(\"beforeCommit requires an active transaction\")\n\n    currentFrame.beforeCommitCallbacks.push(callback)\n  }\n\n  /**\n   * Runs a callback after the surrounding transaction commits.\n   * If no transaction is active, the callback runs immediately.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Callback ownership.\n   * @returns {Promise<void>} - Resolves when the callback has been registered or run.\n   */\n  async afterCommit(callback, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n\n    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]\n\n    if (!currentFrame) {\n      await callback()\n      return\n    }\n\n    currentFrame.afterCommitCallbacks.push(callback)\n  }\n\n  /**\n   * Whether a transaction is currently open on this connection.\n   * @returns {boolean} - Whether inside a transaction.\n   */\n  insideTransaction() { return this._transactionsCount > 0 }\n\n  /**\n   * Returns the completion promise identifying the current outer transaction.\n   * @returns {Promise<void>} Resolves after that transaction commits or rolls back.\n   */\n  transactionCompletion() { return this._transactionCompletionPromise }\n\n  /**\n   * Runs start transaction.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async startTransaction(options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      while (true) {\n        /** @type {import(\"../operation-lease.js\").default | undefined} */\n        let blockingOperationLease\n\n        await this._transactionsActionsMutex.sync(async () => {\n          const operationLease = this._operationLease\n\n          if (operationLease && options.operationOwner !== operationLease.owner) {\n            blockingOperationLease = operationLease\n            return\n          }\n\n          await this._runProfiledTransactionAction(\"start\", async () => {\n            await this._startTransactionAction(options)\n          })\n          this._transactionsCount++\n\n          if (this._transactionsCount === 1) {\n            this._transactionCompletionPromise = new Promise((resolve) => {\n              this._resolveTransactionCompletion = resolve\n            })\n          }\n        })\n\n        if (!blockingOperationLease) return\n\n        await blockingOperationLease.wait(options.operationOwner)\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs start transaction action.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startTransactionAction(options = {}) {\n    await this.query(\"BEGIN TRANSACTION\", options)\n  }\n\n  /**\n   * Runs commit transaction.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async commitTransaction(options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._runProfiledTransactionAction(\"commit\", async () => {\n          await this._commitTransactionAction(options)\n        })\n        this._transactionsCount--\n        this._resolveCompletedTransaction()\n      })\n    }, options.operationOwner)\n  }\n\n  /** Resolves the current outer transaction completion when it has finished. */\n  _resolveCompletedTransaction() {\n    if (this._transactionsCount !== 0) return\n\n    const resolve = this._resolveTransactionCompletion\n\n    this._resolveTransactionCompletion = undefined\n    if (resolve) resolve()\n  }\n\n  /**\n   * Runs commit transaction action.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _commitTransactionAction(options = {}) {\n    await this.query(\"COMMIT\", options)\n  }\n\n  /**\n   * Times a physical transaction action only when test profiling is active.\n   * @template T\n   * @param {\"start\" | \"commit\" | \"rollback\"} action - Transaction action.\n   * @param {() => Promise<T>} callback - Physical action callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _runProfiledTransactionAction(action, callback) {\n    const profileContext = currentTestProfileContext(this.configuration)\n\n    if (!profileContext) return await callback()\n\n    const startedAtMs = nowMs()\n    let failed = true\n\n    try {\n      const result = await callback()\n\n      failed = false\n      return result\n    } finally {\n      profileContext.profiler.recordDatabaseTransaction(profileContext, {\n        action,\n        durationMs: nowMs() - startedAtMs,\n        failed\n      })\n    }\n  }\n\n  /**\n   * Starts an optional physical-query profile attempt without retaining SQL.\n   * @param {string} sql - Original SQL used only to derive its redacted diagnostic.\n   * @returns {TestProfileQueryAttempt | undefined} - Active profile handle.\n   */\n  _startProfiledQueryAttempt(sql) {\n    const context = currentTestProfileContext(this.configuration)\n\n    if (!context) return undefined\n\n    return {\n      context,\n      diagnostic: sqlDiagnostic(sql),\n      startedAtMs: nowMs()\n    }\n  }\n\n  /**\n   * Completes an optional physical-query profile attempt.\n   * @param {TestProfileQueryAttempt | undefined} attempt - Profile handle.\n   * @param {boolean} failed - Whether the physical driver call failed.\n   * @returns {void}\n   */\n  _finishProfiledQueryAttempt(attempt, failed) {\n    if (!attempt) return\n\n    attempt.context.profiler.recordDatabaseQuery(attempt.context, {\n      durationMs: nowMs() - attempt.startedAtMs,\n      failed,\n      ...attempt.diagnostic\n    })\n  }\n\n  /**\n   * Runs every guard registered to the transaction frame.\n   * @param {TransactionCallbackFrame} callbackFrame - Frame whose guards are completing.\n   * @returns {Promise<void>} - Resolves when every guard accepts the commit.\n   */\n  async _runBeforeCommitCallbacks(callbackFrame) {\n    for (const callback of callbackFrame.beforeCommitCallbacks) {\n      await callback()\n    }\n  }\n\n  /**\n   * Merges committed callbacks into the parent transaction frame or runs them when the outermost commit completes.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _commitTransactionCallbackFrame() {\n    const committedFrame = this._transactionCallbackFrames.pop()\n\n    if (!committedFrame || committedFrame.afterCommitCallbacks.length === 0) return\n\n    const parentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]\n\n    if (parentFrame) {\n      parentFrame.afterCommitCallbacks.push(...committedFrame.afterCommitCallbacks)\n      return\n    }\n\n    for (const callback of committedFrame.afterCommitCallbacks) {\n      await callback()\n    }\n  }\n\n  /**\n   * Streams the rows of `sql` one at a time instead of buffering the whole result set, so a\n   * caller can process an arbitrarily large result with bounded memory. This base implementation\n   * falls back to a buffered {@link query} and yields its rows; drivers backed by a cursor-capable\n   * client (the MySQL driver) override it with true server-side streaming.\n   * @param {string} sql - SQL string to stream.\n   * @param {QueryOptions} [options] - Query options, as for {@link query}.\n   * @yields {Record<string, unknown>} - The result rows, one at a time.\n   */\n  async *queryStream(sql, options = {}) {\n    const rows = await this.query(sql, options)\n\n    for (const row of Array.isArray(rows) ? rows : []) {\n      yield row\n    }\n  }\n\n  /**\n   * Runs query.\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} [options] - Query options.\n   * @returns {Promise<QueryResultType>} - Resolves with the query.\n   */\n  async query(sql, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n    this._assertWritableQuery(sql)\n\n    let tries = 0\n    const maxTries = 5\n    const requestTiming = this.configuration.getCurrentRequestTiming()\n    const logQuery = options.logQuery ?? this._queryLoggingEnabled()\n    const sourceStack = logQuery ? (options.sourceStack || Error().stack) : undefined\n    const querySql = this._querySqlWithProcessListComment(sql, options)\n\n    while (tries < maxTries) {\n      tries++\n\n      try {\n        return await this._queryActualWithLogging({originalSql: sql, querySql}, {...options, logQuery, sourceStack}, requestTiming, tries)\n      } catch (error) {\n        if (!(error instanceof Error)) throw error\n\n        this._failedQueryDiagnostics.set(error, sqlDiagnostic(sql))\n\n        // A deliberately-aborted query must never be silently re-run — its\n        // connection was destroyed on purpose, so treat it as terminal.\n        if (error instanceof QueryAbortedError) throw error\n\n        const retryInfo = this.retryableDatabaseError(error)\n\n        if (options.retry !== false && tries < maxTries && retryInfo.retry) {\n          if (retryInfo.reconnect) {\n            if (this._transactionsCount > 0) {\n              throw new Error(`Cannot reconnect while a transaction is active (${this._transactionsCount}). Original error: ${error.message}`, {cause: error})\n            }\n\n            await this.reconnect()\n          }\n\n          const waitMs = typeof retryInfo.waitMs === \"number\" && Number.isFinite(retryInfo.waitMs) ? retryInfo.waitMs : 100\n\n          if (waitMs > 0) await wait(waitMs)\n          const sensitiveValues = requestTiming ? requestTiming.getLogSensitiveValues() : new Set()\n          const loggedError = this.configuration.getLogRedactor().redactString(error.stack || error.message, sensitiveValues)\n\n          this.logger.warn(`Retrying query because failed with: ${loggedError}`)\n          // Retry\n        } else {\n          throw error\n        }\n      }\n    }\n\n    throw new Error(\"'query' unexpected came here\")\n  }\n\n  /**\n   * Executes a mutation and returns the number of rows changed by that statement.\n   * @param {string} sql - Mutation SQL string.\n   * @param {QueryOptions} [options] - Query ownership options.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async affectedRows(sql, options = {}) {\n    await this._waitForOperationLease(options.operationOwner)\n    this._assertWritableQuery(sql)\n\n    return await coordinateSharedTransactionConnection(this, async () => {\n      await this.beforeQuery(sql, options)\n\n      try {\n        const profileAttempt = this._startProfiledQueryAttempt(sql)\n        let failed = true\n\n        try {\n          const affectedRows = await this._runPhysicalConnectionRequest(\n            async () => await this._affectedRowsActual(sql)\n          )\n\n          failed = false\n          return affectedRows\n        } finally {\n          this._finishProfiledQueryAttempt(profileAttempt, failed)\n        }\n      } finally {\n        await this.afterQuery(sql, options)\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs query actual with logging.\n   * @param {object} args - Options object.\n   * @param {string} args.originalSql - Original SQL string before process-list comments.\n   * @param {string} args.querySql - SQL string sent to the database.\n   * @param {QueryOptions} options - Query options.\n   * @param {import(\"../../http-server/client/request-timing.js\").default | undefined} requestTiming - Request timing.\n   * @param {number} tries - Query attempt count.\n   * @returns {Promise<QueryResultType>} - Resolves with the query.\n   */\n  async _queryActualWithLogging({originalSql, querySql}, options, requestTiming, tries) {\n    const startedAtMs = nowMs()\n    const previousActiveQuery = this._activeQuery\n    this._activeQuery = {\n      annotations: getDatabaseAnnotations(),\n      logName: options.logName || \"SQL\",\n      sqlPreview: this._debugSqlPreview(originalSql),\n      startedAtUnixMs: Date.now()\n    }\n    let result\n\n    try {\n      try {\n        const runQueryActualWithHooks = async () => await this._queryActualWithHooks(querySql, options, originalSql)\n\n        if (requestTiming && tries === 1) {\n          result = await requestTiming.measureDbQuery(runQueryActualWithHooks)\n        } else if (requestTiming) {\n          result = await requestTiming.measure(\"db\", runQueryActualWithHooks)\n        } else {\n          result = await runQueryActualWithHooks()\n        }\n      } finally {\n        this._activeQuery = previousActiveQuery\n      }\n    } catch (error) {\n      if (options.logQuery !== false) {\n        await this._logQuery({\n          elapsedMs: nowMs() - startedAtMs,\n          error: ensureError(error),\n          logName: options.logName || \"SQL\",\n          requestTiming,\n          sourceStack: options.sourceStack,\n          sql: originalSql\n        })\n      }\n\n      throw error\n    }\n\n    const elapsedMs = nowMs() - startedAtMs\n\n    if (options.logQuery !== false) {\n      await this._logQuery({\n        elapsedMs,\n        logName: options.logName || \"SQL\",\n        requestTiming,\n        sourceStack: options.sourceStack,\n        sql: originalSql\n      })\n    }\n\n    if (this._schemaCacheInvalidatingSql(originalSql)) {\n      this.clearSchemaCache()\n    }\n\n    return result\n  }\n\n  /**\n   * Runs query actual with before/after hooks.\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} options - Query options.\n   * @param {string} originalSql - SQL before process-list comments.\n   * @returns {Promise<QueryResultType>} - Resolves with the query.\n   */\n  async _queryActualWithHooks(sql, options, originalSql) {\n    return await coordinateSharedTransactionConnection(this, async () => {\n      await this.beforeQuery(sql, options)\n\n      try {\n        const profileAttempt = this._startProfiledQueryAttempt(originalSql)\n        let failed = true\n\n        try {\n          const result = await this._runPhysicalConnectionRequest(\n            async () => await this._queryActual(sql, options)\n          )\n\n          failed = false\n          return result\n        } finally {\n          this._finishProfiledQueryAttempt(profileAttempt, failed)\n        }\n      } finally {\n        await this.afterQuery(sql, options)\n      }\n    }, options.operationOwner)\n  }\n\n  /**\n   * Hook that runs immediately before a SQL query is sent to the driver.\n   * @param {string} _sql - SQL string.\n   * @param {QueryOptions} _options - Query options.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async beforeQuery(_sql, _options) {\n    // No-op by default\n  }\n\n  /**\n   * Hook that runs immediately after a SQL query has completed or failed.\n   * @param {string} _sql - SQL string.\n   * @param {QueryOptions} _options - Query options.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async afterQuery(_sql, _options) {\n    // No-op by default\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {DatabaseConnectionDebugSnapshot} - Diagnostic snapshot for this connection.\n   */\n  getDebugSnapshot() {\n    const now = Date.now()\n    const activeQuery = this._activeQuery\n\n    return {\n      activeQuery: activeQuery ? {...activeQuery, runningMs: Math.max(0, now - activeQuery.startedAtUnixMs)} : null,\n      checkoutAgeMs: this._connectionCheckedOutAtUnixMs ? Math.max(0, now - this._connectionCheckedOutAtUnixMs) : undefined,\n      checkedOutAtUnixMs: this._connectionCheckedOutAtUnixMs,\n      checkoutName: this._connectionCheckoutName,\n      driverClass: this.constructor.name,\n      idSeq: this.idSeq,\n      openTransactions: this._transactionsCount,\n      schemaCacheEntries: this._schemaCache.size\n    }\n  }\n\n  /**\n   * Returns a bounded prefix of `sql` for lightweight diagnostic scanning.\n   * @param {string} sql - SQL string.\n   * @param {number} limit - Maximum code units to inspect.\n   * @returns {string} - Prefix of `sql`.\n   */\n  _diagnosticSqlPrefix(sql, limit) {\n    return sql.length <= limit ? sql : sql.slice(0, limit)\n  }\n\n  /**\n   * Runs debug sql preview.\n   * @param {string} sql - SQL to preview.\n   * @returns {string} - Normalized truncated SQL preview for diagnostics.\n   */\n  _debugSqlPreview(sql) {\n    const prefix = this._diagnosticSqlPrefix(sql, SQL_PREVIEW_SCAN_LIMIT)\n\n    return prefix\n      .replace(/\\s+/g, \" \")\n      .trim()\n      .slice(0, 500)\n  }\n\n  /**\n   * Runs query sql with process list comment.\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} options - Query options.\n   * @returns {string} - SQL string with a leading process-list comment when annotations exist.\n   */\n  _querySqlWithProcessListComment(sql, options) {\n    if (options.processListComment === false) return sql\n\n    const parts = []\n\n    if (this._connectionCheckoutName) {\n      parts.push(`checkout=\"${this._processListCommentValue(this._connectionCheckoutName)}\"`)\n    }\n\n    const annotations = getDatabaseAnnotations()\n\n    if (annotations.length > 0) {\n      parts.push(`annotations=\"${this._processListCommentValue(annotations.join(\" > \"))}\"`)\n    }\n\n    if (parts.length === 0) return sql\n\n    return `/* velocious ${parts.join(\" \")} */ ${sql}`\n  }\n\n  /**\n   * Runs process list comment value.\n   * @param {string} value - Raw process-list comment value.\n   * @returns {string} - Sanitized process-list comment value.\n   */\n  _processListCommentValue(value) {\n    let sanitized = \"\"\n\n    for (const character of value) {\n      const codePoint = character.codePointAt(0)\n\n      sanitized += codePoint !== undefined && (codePoint < 32 || codePoint === 127) ? \" \" : character\n    }\n\n    return sanitized\n      .replace(/\\*\\//g, \"* /\")\n      .replace(/\\s+/g, \" \")\n      .trim()\n      .slice(0, 200)\n      .replace(/\"/g, \"'\")\n  }\n\n  /**\n   * Reads the next SQL token starting at `startIndex`, skipping leading trivia\n   * (BOM, whitespace, block comments, line comments). If the scan cannot finish\n   * skipping trivia before `limit`, the result is marked incomplete so callers\n   * can conservatively treat the statement as schema-invalidating.\n   * @param {string} sql - SQL string.\n   * @param {number} startIndex - Index to start scanning.\n   * @param {number} limit - Maximum absolute index to scan while skipping leading trivia.\n   * @returns {SqlTokenResult} - Token result.\n   */\n  _readSqlToken(sql, startIndex, limit) {\n    let i = startIndex\n    const len = sql.length\n\n    while (i < len && i < limit) {\n      const char = sql[i]\n\n      if (char === \"\\ufeff\" || /\\s/.test(char)) {\n        i++\n        continue\n      }\n\n      if (char === \"/\" && sql[i + 1] === \"*\") {\n        const close = sql.indexOf(\"*/\", i + 2)\n\n        if (close === -1 || close + 2 > limit) {\n          return {incomplete: true, index: i, token: undefined}\n        }\n\n        i = close + 2\n        continue\n      }\n\n      if (char === \"-\" && sql[i + 1] === \"-\") {\n        const newline = sql.indexOf(\"\\n\", i + 2)\n\n        if (newline === -1) {\n          return {incomplete: false, index: len, token: undefined}\n        }\n\n        if (newline + 1 > limit) {\n          return {incomplete: true, index: i, token: undefined}\n        }\n\n        i = newline + 1\n        continue\n      }\n\n      let token = \"\"\n\n      while (i < len) {\n        const c = sql[i]\n\n        if (/\\s/.test(c) || c === \"\\ufeff\") break\n        if (c === \"/\" && sql[i + 1] === \"*\") break\n        if (c === \"-\" && sql[i + 1] === \"-\") break\n\n        token += c\n        i++\n      }\n\n      return {incomplete: false, token: token.toLowerCase(), index: i}\n    }\n\n    if (i >= len) {\n      return {incomplete: false, index: len, token: undefined}\n    }\n\n    return {incomplete: true, index: i, token: undefined}\n  }\n\n  /**\n   * Runs schema cache invalidating sql.\n   * @param {string} sql - SQL string.\n   * @returns {boolean} - Whether the SQL should invalidate schema metadata.\n   */\n  _schemaCacheInvalidatingSql(sql) {\n    const first = this._readSqlToken(sql, 0, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n    if (first.incomplete) return true\n\n    const firstToken = first.token\n\n    if (!firstToken) return false\n    if (/^(create|alter|drop|rename)$/.test(firstToken)) return true\n\n    if (firstToken === \"comment\") {\n      const next = this._readSqlToken(sql, first.index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n      return next.incomplete || next.token === \"on\"\n    }\n\n    if (firstToken === \"exec\" || firstToken === \"execute\") {\n      const next = this._readSqlToken(sql, first.index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n      return next.incomplete || next.token === \"sp_rename\"\n    }\n\n    if (firstToken === \"if\") {\n      let index = first.index\n\n      while (true) {\n        const result = this._readSqlToken(sql, index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n        if (result.incomplete) return true\n        if (!result.token) return false\n        if (result.token === \"begin\") {\n          const ddlResult = this._readSqlToken(sql, result.index, SCHEMA_INVALIDATION_SCAN_LIMIT)\n\n          return ddlResult.incomplete || /^(create|alter|drop|rename)$/.test(ddlResult.token || \"\")\n        }\n\n        index = result.index\n      }\n    }\n\n    return false\n  }\n\n  /**\n   * Runs query logging enabled.\n   * @returns {boolean} - Whether query logging is enabled for this driver.\n   */\n  _queryLoggingEnabled() {\n    if (!this.configuration) return true\n    if (!this.configuration.getQueryLoggingEnabled()) return false\n\n    const logger = new Logger(\"SQL\", {configuration: this.configuration})\n\n    return logger.isLevelEnabled(\"info\")\n  }\n\n  /**\n   * Runs log query.\n   * @param {object} args - Options object.\n   * @param {number} args.elapsedMs - Elapsed milliseconds.\n   * @param {Error} [args.error] - Query failure, when the driver call failed.\n   * @param {string} args.logName - Query log subject.\n   * @param {import(\"../../http-server/client/request-timing.js\").default | undefined} args.requestTiming - Request timing.\n   * @param {string | undefined} args.sourceStack - Source stack.\n   * @param {string} args.sql - SQL string.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _logQuery({elapsedMs, error, logName, requestTiming, sourceStack, sql}) {\n    const logger = new Logger(logName, {configuration: this.configuration})\n    const sourceLine = this._querySourceLine(sourceStack)\n    const sensitiveValues = requestTiming ? requestTiming.getLogSensitiveValues() : new Set()\n    const redactor = this.configuration.getLogRedactor()\n    const loggedSql = redactor.redactString(sql, sensitiveValues)\n    const failure = error\n      ? ` FAILED ${error.name}: ${redactor.redactString(error.message, sensitiveValues)}`\n      : \"\"\n    const message = sourceLine\n      ? `(${formatElapsedMs(elapsedMs)})${failure}  ${loggedSql}\\n  ↳ ${sourceLine}`\n      : `(${formatElapsedMs(elapsedMs)})${failure}  ${loggedSql}`\n\n    await logger.info(message)\n  }\n\n  /**\n   * Runs query source line.\n   * @param {string | undefined} sourceStack - Source stack.\n   * @returns {string | undefined} - Source line when an application frame is available.\n   */\n  _querySourceLine(sourceStack) {\n    if (!sourceStack) return undefined\n\n    const applicationDirectory = this.configuration\n      ? this.configuration.getDirectoryIfAvailable()\n      : undefined\n\n    if (!applicationDirectory) return undefined\n\n    const error = new Error(\"Query source\")\n\n    error.stack = sourceStack\n\n    return BacktraceCleaner.getApplicationSourceLine(error, {\n      applicationDirectory,\n      frameworkSourceDirectory: this.configuration.getEnvironmentHandler().getFrameworkSourceDirectory()\n    })\n  }\n\n  /**\n   * Runs query actual.\n   * @abstract\n   * @param {string} sql - SQL string.\n   * @param {QueryOptions} [options] - Query options (carries the optional abort signal).\n   * @returns {Promise<QueryResultType>} - Resolves with the query actual.\n   */\n  _queryActual(sql, options) { // eslint-disable-line no-unused-vars\n    throw new Error(`queryActual not implemented`)\n  }\n\n  /**\n   * Executes a mutation and returns its affected row count.\n   * @abstract\n   * @param {string} sql - Mutation SQL string.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  _affectedRowsActual(sql) { // eslint-disable-line no-unused-vars\n    throw new Error(`affectedRowsActual not implemented`)\n  }\n\n  /**\n   * Runs query to sql.\n   * @abstract\n   * @param {Query} _query - Query instance.\n   * @returns {string} - SQL string.\n   */\n  queryToSql(_query) { throw new Error(\"queryToSql not implemented\") }\n\n  /**\n   * Runs retryable database error.\n   * @param {Error} _error - Error instance.\n   * @returns {RetryableDatabaseErrorResult} - Retry info.\n   */\n  retryableDatabaseError(_error) {\n    return {retry: false, reconnect: false}\n  }\n\n  /**\n   * Runs assert writable query.\n   * @param {string} sql - SQL string.\n   * @returns {void} - No return value.\n   */\n  _assertWritableQuery(sql) {\n    if (!this.isReadOnly()) return\n    if (!this._sqlLooksLikeWrite(sql)) return\n\n    throw new Error(\"Database is read-only\")\n  }\n\n  /**\n   * Runs assert not read only.\n   * @returns {void} - No return value.\n   */\n  _assertNotReadOnly() {\n    if (this.isReadOnly()) {\n      throw new Error(\"Database is read-only\")\n    }\n  }\n\n  /**\n   * Runs sql looks like write.\n   * @param {string} sql - SQL string.\n   * @returns {boolean} - SQL representation.\n   */\n  _sqlLooksLikeWrite(sql) {\n    const normalized = sql.trim().toLowerCase()\n\n    if (!normalized) return false\n\n    if (\n      normalized.startsWith(\"select\") ||\n      normalized.startsWith(\"show\") ||\n      normalized.startsWith(\"pragma\") ||\n      normalized.startsWith(\"explain\") ||\n      normalized.startsWith(\"describe\")\n    ) {\n      return false\n    }\n\n    if (normalized.startsWith(\"with\")) {\n      const withMatch = normalized.match(/^\\s*with[\\s\\S]+?\\)\\s*(select|insert|update|delete|merge|replace)\\b/)\n\n      if (withMatch) {\n        return withMatch[1] !== \"select\"\n      }\n\n      return false\n    }\n\n    const keywordMatch = normalized.match(/^\\s*(\\w+)/)\n    const keyword = keywordMatch ? keywordMatch[1] : \"\"\n\n    return [\n      \"insert\",\n      \"update\",\n      \"delete\",\n      \"create\",\n      \"alter\",\n      \"drop\",\n      \"truncate\",\n      \"merge\",\n      \"replace\"\n    ].includes(keyword)\n  }\n\n  /**\n   * Runs is read only.\n   * @returns {boolean} - Whether read only.\n   */\n  isReadOnly() {\n    return Boolean(this.getArgs().readOnly)\n  }\n\n  /**\n   * Runs rollback transaction.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async rollbackTransaction(options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        try {\n          await this._runProfiledTransactionAction(\"rollback\", async () => {\n            await this._rollbackTransactionAction(options)\n          })\n        } finally {\n          // Driver recovery may need to clear a stale physical transaction when\n          // no logical transaction is active. Never let that cleanup underflow\n          // the logical depth and turn the next root transaction into a savepoint.\n          if (this._transactionsCount > 0) this._transactionsCount--\n          this._resolveCompletedTransaction()\n\n          // A rolled-back transaction may have reverted DDL (e.g. a CREATE TABLE\n          // run lazily inside the transaction), so any cached schema metadata is\n          // now stale and must be invalidated. Without this, a later tableExists()\n          // check can report a table that the rollback already removed, so callers\n          // skip recreating it and then fail with \"no such table\".\n          this.clearSchemaCache()\n        }\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs rollback transaction action.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _rollbackTransactionAction(options = {}) {\n    await this.query(\"ROLLBACK\", options)\n  }\n\n  /**\n   * Runs generate save point name.\n   * @returns {string} - The generate save point name.\n   */\n  generateSavePointName() {\n    return `sp${new UUID(4).format().replaceAll(\"-\", \"\")}`\n  }\n\n  /**\n   * Runs start save point.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async startSavePoint(savePointName, options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._startSavePointAction(savePointName, options)\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs start save point action.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startSavePointAction(savePointName, options = {}) {\n    await this.query(`SAVEPOINT ${savePointName}`, options)\n  }\n\n  /**\n   * Runs rename column.\n   * @param {string} tableName - Table name.\n   * @param {string} oldColumnName - Previous column name.\n   * @param {string} newColumnName - New column name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async renameColumn(tableName, oldColumnName, newColumnName) {\n    this._assertNotReadOnly()\n    const tableColumn = new TableColumn(oldColumnName)\n\n    tableColumn.setNewName(newColumnName)\n\n    const tableData = new TableData(tableName)\n\n    tableData.addColumn(tableColumn)\n\n    const alterTableSQLs = await this.alterTableSQLs(tableData)\n\n    for (const alterTableSQL of alterTableSQLs) {\n      await this.query(alterTableSQL)\n    }\n  }\n\n  /**\n   * Runs release save point.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async releaseSavePoint(savePointName, options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._releaseSavePointAction(savePointName, options)\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs release save point action.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _releaseSavePointAction(savePointName, options = {}) {\n    try {\n      await this.query(`RELEASE SAVEPOINT ${savePointName}`, options)\n    } catch (error) {\n      const message = error instanceof Error ? error.message : `${error}`\n\n      // Savepoint may already be gone if the database rolled back automatically\n      if (message.toLowerCase().includes(\"savepoint\") && message.toLowerCase().includes(\"does not exist\")) {\n        this.logger.debug(`Release savepoint ignored because it no longer exists: ${savePointName}`)\n        return\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs rollback save point.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async rollbackSavePoint(savePointName, options = {}) {\n    await coordinateSharedTransactionConnection(this, async () => {\n      await this._transactionsActionsMutex.sync(async () => {\n        await this._rollbackSavePointAction(savePointName, options)\n      })\n    }, options.operationOwner)\n  }\n\n  /**\n   * Runs rollback save point action.\n   * @param {string} savePointName - Save point name.\n   * @param {Pick<QueryOptions, \"operationOwner\">} [options] - Transaction ownership.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _rollbackSavePointAction(savePointName, options = {}) {\n    await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`, options)\n  }\n\n  /**\n   * Truncates the given table snapshot. Drivers can override this to issue one batch.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} tables - Eligible tables for this cleanup attempt.\n   * @returns {Promise<void>} - Resolves when every table has been cleaned.\n   */\n  async truncateTables(tables) {\n    const truncateErrors = []\n\n    for (const table of tables) {\n      try {\n        await table.truncate({cascade: true})\n      } catch (error) {\n        truncateErrors.push(error)\n      }\n    }\n\n    if (truncateErrors.length > 0) throw truncateErrors[0]\n  }\n\n  /**\n   * Runs truncate all tables.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async truncateAllTables() {\n    this._assertNotReadOnly()\n    const tables = (await this.getTables()).filter((table) => table.getName() != \"schema_migrations\")\n\n    if (tables.length == 0) return\n\n    await this._truncateAllTables(tables)\n    await this.flushPendingWrites()\n  }\n\n  /**\n   * Owns the foreign-key boundary around every cleanup retry. Drivers that\n   * require one physical request for the full operation may override it.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} tables - Eligible tables.\n   * @returns {Promise<void>} - Resolves after cleanup succeeds.\n   */\n  async _truncateAllTables(tables) {\n    await this.withDisabledForeignKeys(async () => {\n      await this._truncateAllTablesWithRetries(tables)\n    })\n  }\n\n  /**\n   * Retries cleanup against refreshed schema snapshots. Drivers may override\n   * `_truncateAllTablesAttempt` to own a complete driver-specific attempt.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} initialTables - Initial eligible tables.\n   * @returns {Promise<void>} - Resolves after one cleanup attempt succeeds.\n   */\n  async _truncateAllTablesWithRetries(initialTables) {\n    let tables = initialTables\n\n    for (let tries = 1; tries <= 6; tries++) {\n      try {\n        await this._truncateAllTablesAttempt(tables)\n        return\n      } catch (error) {\n        console.error(error)\n\n        if (tries == 6) throw error\n\n        // A truncate failed — the schema cache may still list a table that was\n        // dropped out from under us (e.g. a db:rollback test that left the\n        // shared DB rolled back). Clear it so the next pass re-reads the live\n        // table list and no longer tries to truncate a table that is gone.\n        this.clearSchemaCache()\n        tables = (await this.getTables()).filter((table) => table.getName() != \"schema_migrations\")\n\n        if (tables.length == 0) return\n      }\n    }\n  }\n\n  /**\n   * Runs one cleanup attempt while the default owner has constraints disabled.\n   * @protected\n   * @param {Array<import(\"./base-table.js\").default>} tables - Current eligible tables.\n   * @returns {Promise<void>} - Resolves when the attempt completes.\n   */\n  async _truncateAllTablesAttempt(tables) {\n    await this.truncateTables(tables)\n  }\n\n  /**\n   * Runs update.\n   * @param {UpdateSqlArgsType} args - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async update(args) {\n    this._assertNotReadOnly()\n    const sql = this.updateSql(args)\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs update sql.\n   * @abstract\n   * @param {UpdateSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  updateSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'disableForeignKeys' not implemented\")\n  }\n\n  /**\n   * Runs upsert sql.\n   * @abstract\n   * @param {UpsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  upsertSql(args) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'upsertSql' not implemented\")\n  }\n\n  /**\n   * Runs disable foreign keys.\n   * @abstract\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  disableForeignKeys() {\n    throw new Error(\"'disableForeignKeys' not implemented\")\n  }\n\n  /**\n   * Runs enable foreign keys.\n   * @abstract\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  enableForeignKeys() {\n    throw new Error(\"'enableForeignKeys' not implemented\")\n  }\n\n  /**\n   * Runs with disabled foreign keys.\n   * @param {() => void} callback - Callback function.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the with disabled foreign keys.\n   */\n  async withDisabledForeignKeys(callback) {\n    await this.disableForeignKeys()\n\n    try {\n      return await callback()\n    } finally {\n      await this.enableForeignKeys()\n    }\n  }\n\n  /**\n   * Blocks until a named advisory lock is acquired on this connection.\n   * Advisory locks are connection-scoped and do not interact with row or\n   * table locks; they are purely cooperative between callers that use the\n   * same name and let you serialize functionality without blocking readers\n   * or writers that do not participate in the same named lock.\n   *\n   * Acquisition runs as a two-tier chain:\n   * 1. The **process-local pre-filter tier** (this class' FIFO waiter\n   *    queue) serializes same-process callers for the lock name without\n   *    issuing any driver-native lock query and without parking a\n   *    connection in a driver lock state. A queued caller never reaches\n   *    tier 2 until the in-process holder releases.\n   * 2. The **driver-native tier** (`_acquireAdvisoryLock`: MariaDB\n   *    `GET_LOCK`, PostgreSQL `pg_advisory_lock`, SQL Server\n   *    `sp_getapplock`, SQLite filesystem lock on Node) confirms the\n   *    cross-process/cross-host exclusion.\n   *\n   * The process-local tier is a pre-filter, **never the authority**: a\n   * lock name that other processes or hosts can request is only granted\n   * after the driver-native tier (or, once the STC-210 backend chain\n   * lands, the configured cross-host backend) confirms it. If the native\n   * tier denies or times out, the in-process hold is rolled back.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null` blocks forever, and an omitted value uses the database's `advisoryLockAcquireTimeoutMs` or the framework default. The bound covers the whole two-tier acquisition.\n   * @returns {Promise<boolean>} - Resolves to true when the lock has been acquired, false if the timeout elapsed.\n   */\n  async acquireAdvisoryLock(name, args = {}) {\n    const timeoutMs = this.advisoryLockAcquireTimeoutMs(args)\n    const deadlineMs = typeof timeoutMs === \"number\" && timeoutMs >= 0 ? Date.now() + timeoutMs : null\n    const localAcquisition = await this._acquireProcessLocalAdvisoryLock(name, {timeoutMs})\n\n    if (!localAcquisition.acquired) return false\n\n    if (!this.supportsDriverNativeAdvisoryLock()) {\n      // No driver-native tier exists for this driver (plain SQLite): the\n      // process-local tier is the whole implementation, and callers must\n      // not read it as a cross-process guarantee.\n      this._trackAdvisoryLock(name)\n\n      return true\n    }\n\n    // Only a caller that actually queued in the process-local tier spends\n    // part of the acquire budget; an uncontended acquisition passes the\n    // full bound on to the driver-native tier.\n    const nativeTimeoutMs = localAcquisition.waited && deadlineMs !== null\n      ? Math.max(0, deadlineMs - Date.now())\n      : timeoutMs\n\n    const startedAt = Date.now()\n\n    /** @type {boolean} */\n    let nativeAcquired\n\n    try {\n      nativeAcquired = await this._acquireAdvisoryLock(name, {timeoutMs: nativeTimeoutMs})\n    } catch (error) {\n      this._releaseProcessLocalAdvisoryLock(name)\n      throw error\n    }\n\n    const durationMs = Date.now() - startedAt\n\n    if (nativeAcquired) {\n      this._trackAdvisoryLock(name)\n\n      const slowAcquireMs = advisoryLockTelemetryThresholds(this.getArgs()).slowAcquireMs\n\n      if (slowAcquireMs !== null && durationMs > slowAcquireMs) {\n        await this._reportAdvisoryLockTelemetry({event: \"advisory-lock-slow-acquire\", lockName: name, durationMs, outcome: \"acquired\", timeoutMs})\n      }\n\n      return true\n    }\n\n    this._releaseProcessLocalAdvisoryLock(name)\n\n    // The wait exceeded its bound: attribute the lock to the holder that\n    // blocked it, captured at this moment on this tier.\n    await this._reportAdvisoryLockTelemetry({event: \"advisory-lock-acquire-timeout\", lockName: name, durationMs, outcome: \"timeout\", timeoutMs, captureHolder: true})\n\n    return false\n  }\n\n  /**\n   * Resolves the wait bound for one advisory-lock acquisition.\n   * An explicit `timeoutMs` — including an explicit `null` opt-out — always\n   * wins. Otherwise the database configuration's `advisoryLockAcquireTimeoutMs`\n   * applies, and a null there opts out too. Only when neither is configured does\n   * the framework default bound the wait.\n   * @param {{timeoutMs?: number | null}} [args] - Acquisition options from the caller.\n   * @returns {number | null} - Wait bound in milliseconds, or `null` for an indefinite wait.\n   */\n  advisoryLockAcquireTimeoutMs(args = {}) {\n    if (args.timeoutMs !== undefined) return args.timeoutMs\n\n    const configured = this.getArgs()?.advisoryLockAcquireTimeoutMs\n\n    if (configured === null) return null\n    if (typeof configured === \"number\" && configured >= 0) return configured\n\n    return DEFAULT_ADVISORY_LOCK_ACQUIRE_TIMEOUT_MS\n  }\n\n  /**\n   * Whether this driver has a driver-native advisory-lock tier behind the\n   * process-local pre-filter. MariaDB (`GET_LOCK`), PostgreSQL\n   * (`pg_advisory_lock`) and SQL Server (`sp_getapplock`) do; SQLite has\n   * no native primitive (the Node SQLite driver substitutes its\n   * filesystem lock directory, the web/native builds have nothing), so\n   * for plain SQLite the process-local tier IS the whole implementation\n   * and callers must not read it as a cross-process guarantee.\n   * @returns {boolean} - Whether the driver-native tier exists.\n   */\n  supportsDriverNativeAdvisoryLock() {\n    return true\n  }\n\n  /**\n   * Whether the driver's native tier is re-entrant within the same\n   * session. `GET_LOCK`, `pg_advisory_lock` and `sp_getapplock` grant the\n   * same session repeatedly, so the process-local tier must let a\n   * re-acquisition by its own owner pass through to the native tier.\n   * SQLite's emulation (including the Node filesystem lock) is not\n   * re-entrant, so the tier keeps treating a re-acquisition as contention\n   * exactly as the SQLite emulation always has.\n   * @returns {boolean} - Whether same-instance re-acquisition is honored.\n   */\n  supportsReentrantAdvisoryLock() {\n    return true\n  }\n\n  /**\n   * Process-local pre-filter tier: FIFO waiter queue for one lock name\n   * inside this process. This is the promoted SQLite emulation from\n   * STC-211 — it now runs in front of **every** driver's native tier so a\n   * same-process waiter never issues a driver-native lock query and never\n   * parks a pooled connection in a driver lock state while queued.\n   *\n   * A grant here means only \"you are the next caller in this process.\"\n   * It is never the authority for cross-process/cross-host exclusion; the\n   * caller must still pass the driver-native tier before the lock counts\n   * as held. A re-entrant acquisition by the owning driver instance is\n   * granted immediately, mirroring the session-scoped re-entrancy of\n   * `GET_LOCK` / `pg_advisory_lock` / `sp_getapplock`.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.\n   * @returns {Promise<{acquired: boolean, waited: boolean}>} - Whether the tier granted this caller, and whether it had to queue for it.\n   */\n  async _acquireProcessLocalAdvisoryLock(name, {timeoutMs} = {}) {\n    const state = VelociousDatabaseDriversBase._advisoryLockState\n    let waited = false\n\n    while (state.ownersByName.has(name)) {\n      if (state.ownersByName.get(name) === this && this.supportsReentrantAdvisoryLock()) break\n\n      waited = true\n\n      let remainingMs = null\n\n      if (typeof timeoutMs === \"number\" && timeoutMs >= 0) {\n        remainingMs = timeoutMs\n\n        if (remainingMs <= 0) return {acquired: false, waited}\n      }\n\n      await new Promise((resolve) => {\n        const waiters = state.waitersByName.get(name) || []\n        /**\n         * Timeout handle.\n         * @type {ReturnType<typeof setTimeout> | null} */\n        let timeoutHandle = null\n        /**\n         * Remove and resolve.\n         * @type {(() => void) | null} */\n        let removeAndResolve = null\n\n        removeAndResolve = () => {\n          if (timeoutHandle) clearTimeout(timeoutHandle)\n\n          const current = state.waitersByName.get(name) || []\n          const index = current.indexOf(/** @type {() => void} */ (removeAndResolve))\n\n          if (index >= 0) current.splice(index, 1)\n          if (current.length === 0) state.waitersByName.delete(name)\n\n          resolve(undefined)\n        }\n\n        waiters.push(removeAndResolve)\n        state.waitersByName.set(name, waiters)\n\n        if (remainingMs !== null) {\n          timeoutHandle = setTimeout(() => {\n            if (removeAndResolve) removeAndResolve()\n          }, remainingMs)\n        }\n      })\n\n      if (typeof timeoutMs === \"number\" && timeoutMs >= 0 && state.ownersByName.has(name) && !(state.ownersByName.get(name) === this && this.supportsReentrantAdvisoryLock())) {\n        return {acquired: false, waited}\n      }\n    }\n\n    state.ownersByName.set(name, this)\n\n    return {acquired: true, waited}\n  }\n\n  /**\n   * Hands the process-local tier for one lock name to the next FIFO waiter,\n   * but only when **this** driver instance currently owns it. A release by\n   * a non-owner is a no-op, matching the \"you can only release locks you\n   * own\" contract of `RELEASE_LOCK` / `pg_advisory_unlock`.\n   * @param {string} name - Lock name.\n   * @returns {boolean} - Whether this instance owned the tier and released it.\n   */\n  _releaseProcessLocalAdvisoryLock(name) {\n    const state = VelociousDatabaseDriversBase._advisoryLockState\n    const owner = state.ownersByName.get(name)\n\n    if (owner !== this) return false\n\n    state.ownersByName.delete(name)\n\n    const waiters = state.waitersByName.get(name)\n\n    if (waiters && waiters.length > 0) {\n      const nextWaiter = waiters.shift()\n\n      if (waiters.length === 0) state.waitersByName.delete(name)\n      if (nextWaiter) nextWaiter()\n    }\n\n    return true\n  }\n\n  /**\n   * Driver-specific blocking advisory-lock acquisition hook.\n   * This is the **driver-native tier** of the acquisition chain: MariaDB\n   * `GET_LOCK`, PostgreSQL `pg_advisory_lock`, SQL Server `sp_getapplock`,\n   * the Node SQLite filesystem lock. It runs only after the process-local\n   * pre-filter tier has granted this caller its turn, and its result is\n   * what actually confirms cross-process/cross-host exclusion.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [_args] - Lock timeout options.\n   * @returns {Promise<boolean>} - Whether the lock was acquired.\n   */\n  _acquireAdvisoryLock(name, _args = {}) {\n    throw new Error(`'_acquireAdvisoryLock' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Attempts to acquire a named advisory lock without blocking.\n   *\n   * Same two-tier chain as `acquireAdvisoryLock`: the process-local tier\n   * short-circuits contention between callers in this process (a queued\n   * name never reaches the driver-native hook), and the driver-native tier\n   * confirms cross-process/cross-host exclusion. A free in-process tier is\n   * NOT a grant — the native tier still has to agree.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the lock was acquired, false if it was already held.\n   */\n  async tryAcquireAdvisoryLock(name) {\n    const owner = VelociousDatabaseDriversBase._advisoryLockState.ownersByName.get(name)\n\n    if (owner !== undefined && owner !== this) return false\n\n    // Same-instance re-acquisition mirrors the re-entrant semantics of the\n    // session-scoped driver-native locks; a non-re-entrant driver (SQLite)\n    // keeps treating it as contention, exactly as the emulation always did.\n    const reentrant = owner === this\n\n    if (reentrant && !this.supportsReentrantAdvisoryLock()) return false\n\n    if (!reentrant) VelociousDatabaseDriversBase._advisoryLockState.ownersByName.set(name, this)\n\n    if (!this.supportsDriverNativeAdvisoryLock()) {\n      this._trackAdvisoryLock(name)\n\n      return true\n    }\n\n    /** @type {boolean} */\n    let acquired\n\n    try {\n      acquired = await this._tryAcquireAdvisoryLock(name)\n    } catch (error) {\n      if (!reentrant) this._releaseProcessLocalAdvisoryLock(name)\n\n      throw error\n    }\n\n    if (!acquired) {\n      if (!reentrant) this._releaseProcessLocalAdvisoryLock(name)\n\n      return false\n    }\n\n    this._trackAdvisoryLock(name)\n\n    return true\n  }\n\n  /**\n   * Driver-specific non-blocking advisory-lock acquisition hook.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Whether the lock was acquired.\n   */\n  _tryAcquireAdvisoryLock(name) { // eslint-disable-line no-unused-vars\n    throw new Error(`'_tryAcquireAdvisoryLock' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Releases a named advisory lock previously acquired on this connection.\n   * The driver-native release runs first; the process-local tier is handed\n   * to the next waiter only once this connection's counted registry no\n   * longer holds the name, so re-entrant acquisitions release one level at\n   * a time exactly like the session-scoped driver locks.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the lock was held by this session and has now been released.\n   */\n  async releaseAdvisoryLock(name) {\n    const owner = VelociousDatabaseDriversBase._advisoryLockState.ownersByName.get(name)\n\n    // Another driver instance in this process owns the tier for this name,\n    // so this connection can never be the native holder either — refuse\n    // before issuing a release statement that could disturb the owner.\n    if (owner !== undefined && owner !== this) return false\n\n    if (!this.supportsDriverNativeAdvisoryLock()) {\n      // Plain SQLite: the process-local tier IS the lock, so the first\n      // release by the owner releases it fully, exactly as the SQLite\n      // emulation always has.\n      const released = this._releaseProcessLocalAdvisoryLock(name)\n\n      if (released) {\n        this._untrackAdvisoryLock(name)\n      } else {\n        this._heldAdvisoryLocks.delete(name)\n      }\n\n      return released\n    }\n\n    const released = await this._releaseAdvisoryLock(name)\n\n    if (released) {\n      this._untrackAdvisoryLock(name)\n    } else {\n      this._heldAdvisoryLocks.delete(name)\n    }\n\n    if (!this._heldAdvisoryLocks.has(name)) {\n      const acquiredAt = this._advisoryLockAcquiredAtByName.get(name)\n\n      this._advisoryLockAcquiredAtByName.delete(name)\n\n      if (acquiredAt !== undefined) {\n        const holdDurationMs = Date.now() - acquiredAt\n        const slowHoldMs = advisoryLockTelemetryThresholds(this.getArgs()).slowHoldMs\n\n        if (slowHoldMs !== null && holdDurationMs > slowHoldMs) {\n          await this._reportAdvisoryLockTelemetry({event: \"advisory-lock-slow-hold\", lockName: name, durationMs: holdDurationMs, outcome: null, timeoutMs: null})\n        }\n      }\n\n      // Last connection-level release: hand the process-local tier to the\n      // next queued caller in this process.\n      this._releaseProcessLocalAdvisoryLock(name)\n    }\n\n    return released\n  }\n\n  /**\n   * Driver-specific advisory-lock release hook.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Whether the lock was released.\n   */\n  _releaseAdvisoryLock(name) { // eslint-disable-line no-unused-vars\n    throw new Error(`'_releaseAdvisoryLock' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Releases every advisory lock still tracked on this connection.\n   * @returns {Promise<void>} - Resolves when every tracked lock is released.\n   */\n  async releaseHeldAdvisoryLocks() {\n    /** @type {Error[]} */\n    const errors = []\n\n    for (const name of [...this._heldAdvisoryLocks.keys()]) {\n      while (this._heldAdvisoryLocks.has(name)) {\n        try {\n          await this.releaseAdvisoryLock(name)\n        } catch (error) {\n          errors.push(error instanceof Error ? error : new Error(`Failed to release advisory lock ${JSON.stringify(name)}`, {cause: error}))\n          break\n        }\n      }\n    }\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to release held advisory locks\")\n  }\n\n  /**\n   * Records one successful acquisition, including re-entrant acquisitions.\n   * @param {string} name - Lock name.\n   * @returns {void}\n   */\n  _trackAdvisoryLock(name) {\n    this._heldAdvisoryLocks.set(name, (this._heldAdvisoryLocks.get(name) || 0) + 1)\n\n    if (!this._advisoryLockAcquiredAtByName.has(name)) this._advisoryLockAcquiredAtByName.set(name, Date.now())\n  }\n\n  /**\n   * Removes one successful acquisition from the connection registry.\n   * @param {string} name - Lock name.\n   * @returns {void}\n   */\n  _untrackAdvisoryLock(name) {\n    const remainingCount = (this._heldAdvisoryLocks.get(name) || 0) - 1\n\n    if (remainingCount > 0) {\n      this._heldAdvisoryLocks.set(name, remainingCount)\n    } else {\n      this._heldAdvisoryLocks.delete(name)\n    }\n  }\n\n  /**\n   * Checks whether a named advisory lock is currently held by any session.\n   * Intended as an introspection helper; callers who need to act on the\n   * result should prefer `tryAcquireAdvisoryLock` to avoid a TOCTOU race.\n   *\n   * The process-local tier answers first (a same-process holder is a\n   * holder, full stop); otherwise the question goes to the driver-native\n   * tier's introspection (`IS_USED_LOCK` / `pg_locks` / `APPLOCK_TEST`).\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the lock is held by any session.\n   */\n  async isAdvisoryLockHeld(name) {\n    if (VelociousDatabaseDriversBase._advisoryLockState.ownersByName.has(name)) return true\n\n    if (!this.supportsDriverNativeAdvisoryLock()) return false\n\n    return await this._isAdvisoryLockHeldNative(name)\n  }\n\n  /**\n   * Driver-native advisory-lock introspection hook behind\n   * `isAdvisoryLockHeld`.\n   * @abstract\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Resolves to true if the native tier reports the lock held.\n   */\n  _isAdvisoryLockHeldNative(name) { // eslint-disable-line no-unused-vars\n    throw new Error(`'_isAdvisoryLockHeldNative' not implemented for ${this.constructor.name}`)\n  }\n\n  /**\n   * Which advisory-lock backend tier this connection serves (STC-210 chain\n   * naming). The base driver is the driver-native tier; the SQLite drivers\n   * override to `process-local` / `file`.\n   * @returns {string} - Tier name reported on telemetry payloads.\n   */\n  advisoryLockBackendTier() {\n    return \"driver-native\"\n  }\n\n  /**\n   * Stable identity of this connection as a lock holder, reported on\n   * telemetry payloads so a slow acquire/hold is attributable to the reporting\n   * connection itself.\n   * @returns {string} - Holder id.\n   */\n  advisoryLockHolderId() {\n    if (!this._advisoryLockHolderId) this._advisoryLockHolderId = `advisory-lock-holder:${new UUID(4).format()}`\n\n    return this._advisoryLockHolderId\n  }\n\n  /**\n   * Best-effort identity of the connection currently holding the named lock,\n   * captured on the tier that served the acquisition. The base driver has no\n   * portable server-side lookup; MySQL/PostgreSQL/SQL Server/Node-SQLite\n   * override with their tier's holder attribution.\n   * @param {string} name - Lock name.\n   * @returns {Promise<string | null>} - Holder connection identity, or null when the tier cannot attribute it.\n   */\n  async advisoryLockHolderConnectionId(name) { // eslint-disable-line no-unused-vars\n    return null\n  }\n\n  /**\n   * Emit one event-driven advisory-lock telemetry report (slow acquire,\n   * acquire timeout with holder attribution, slow hold). The holder lookup is\n   * best-effort: a failed lookup is recorded on the report and never affects\n   * the acquisition that already settled.\n   * @param {{event: \"advisory-lock-slow-acquire\" | \"advisory-lock-acquire-timeout\" | \"advisory-lock-slow-hold\", lockName: string, durationMs: number, outcome: \"acquired\" | \"timeout\" | null, timeoutMs: number | null, captureHolder?: boolean}} args - Report args.\n   * @returns {Promise<void>} - Resolves after the report is emitted.\n   */\n  async _reportAdvisoryLockTelemetry(args) {\n    /** @type {import(\"../advisory-lock-telemetry.js\").AdvisoryLockTelemetryReport} */\n    const report = {\n      event: args.event,\n      lockName: args.lockName,\n      backendTier: this.advisoryLockBackendTier(),\n      durationMs: args.durationMs,\n      outcome: args.outcome,\n      timeoutMs: args.timeoutMs,\n      holderId: this.advisoryLockHolderId(),\n      holderConnectionId: null,\n      holderLookupError: null\n    }\n\n    if (args.captureHolder) {\n      try {\n        report.holderConnectionId = await this.advisoryLockHolderConnectionId(args.lockName)\n      } catch (error) {\n        report.holderLookupError = error instanceof Error ? error.message : String(error)\n      }\n    }\n\n    emitAdvisoryLockTelemetryReport(this.configuration, report)\n  }\n}\n"]}