velocious 1.0.698 → 1.0.700

package/src/database/drivers/base.js

@@ -293,6 +293,31 @@ function formatElapsedMs(elapsedMs) {
 }
 
 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} */
@@ -2940,18 +2965,66 @@ 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
@@ -2959,13 +3032,17 @@ export default class VelociousDatabaseDriversBase {
       if (slowAcquireMs !== null && durationMs > slowAcquireMs) {
         await this._reportAdvisoryLockTelemetry({event: "advisory-lock-slow-acquire", lockName: name, durationMs, outcome: "acquired", timeoutMs})
       }
-    } 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 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
   }
 
   /**
@@ -2988,8 +3065,146 @@ export default class VelociousDatabaseDriversBase {
     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.
@@ -3001,15 +3216,55 @@ 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)
+    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 (acquired) this._trackAdvisoryLock(name)
+    if (reentrant && !this.supportsReentrantAdvisoryLock()) return false
 
-    return acquired
+    if (!reentrant) VelociousDatabaseDriversBase._advisoryLockState.ownersByName.set(name, this)
+
+    if (!this.supportsDriverNativeAdvisoryLock()) {
+      this._trackAdvisoryLock(name)
+
+      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
   }
 
   /**
@@ -3024,10 +3279,36 @@ 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) {
@@ -3049,6 +3330,10 @@ 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
@@ -3117,12 +3402,30 @@ 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) { // eslint-disable-line no-unused-vars
-    throw new Error(`'isAdvisoryLockHeld' not implemented for ${this.constructor.name}`)
+  _isAdvisoryLockHeldNative(name) { // eslint-disable-line no-unused-vars
+    throw new Error(`'_isAdvisoryLockHeldNative' not implemented for ${this.constructor.name}`)
   }
 
   /**

package/src/database/drivers/mssql/index.js

@@ -939,7 +939,7 @@ export default class VelociousDatabaseDriversMssql extends Base{
    * @param {string} name - Lock name.
    * @returns {Promise<boolean>} - True if any session currently holds the lock.
    */
-  async isAdvisoryLockHeld(name) {
+  async _isAdvisoryLockHeldNative(name) {
     const rows = await this.query(
       `SELECT ` +
         `APPLOCK_MODE('public', ${this.quote(name)}, 'Session') AS velocious_advisory_self_mode, ` +

package/src/database/drivers/mysql/index.js

@@ -882,6 +882,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return Number(result) === 1
   }
 
+  /**
   /**
    * Attributes the current holder of the named lock to its physical session
    * connection id via `IS_USED_LOCK(name)`, captured at the telemetry event
@@ -897,11 +898,12 @@ export default class VelociousDatabaseDriversMysql extends Base{
   }
 
   /**
-   * Runs is advisory lock held.
+   * Driver-native view for the base driver's `isAdvisoryLockHeld`, which
+   * answers from the process-local tier first.
    * @param {string} name - Lock name.
    * @returns {Promise<boolean>} - True if any session currently holds the lock.
    */
-  async isAdvisoryLockHeld(name) {
+  async _isAdvisoryLockHeldNative(name) {
     const rows = await this.query(`SELECT IS_USED_LOCK(${this.quote(name)}) AS velocious_advisory_lock_holder`)
     const holder = rows?.[0]?.velocious_advisory_lock_holder
 

package/src/database/drivers/pgsql/index.js

@@ -505,6 +505,7 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     return result === true || result === "t" || result === 1 || result === "1"
   }
 
+  /**
   /**
    * Attributes the current holder of the named advisory lock to its backend
    * process id from `pg_locks`, captured at the telemetry event moment
@@ -523,11 +524,12 @@ export default class VelociousDatabaseDriversPgsql extends Base{
   }
 
   /**
-   * Runs is advisory lock held.
+   * Driver-native view for the base driver's `isAdvisoryLockHeld`, which
+   * answers from the process-local tier first.
    * @param {string} name - Lock name.
    * @returns {Promise<boolean>} - True if any session currently holds the lock.
    */
-  async isAdvisoryLockHeld(name) {
+  async _isAdvisoryLockHeldNative(name) {
     const key = this.advisoryLockKey(name)
     const rows = await this.query(
       `SELECT EXISTS (SELECT 1 FROM pg_locks WHERE locktype = 'advisory' AND ((classid::bigint << 32) | (objid::bigint & 4294967295)) = ${key}) AS velocious_advisory_lock_held`

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

@@ -19,21 +19,6 @@ import Upsert from "./sql/upsert.js"
 import Update from "./sql/update.js"
 
 export default class VelociousDatabaseDriversSqliteBase extends Base {
-  /**
-   * Process-wide state for the SQLite advisory lock emulation. Shared across
-   * every SQLite driver instance (native, web, sql.js) because there is no
-   * concept of "connection" to distinguish them at the SQLite level.
-   *
-   * `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, VelociousDatabaseDriversSqliteBase>, waitersByName: Map<string, Array<() => void>>}}
-   */
-  static _advisoryLockState = {
-    ownersByName: new Map(),
-    waitersByName: new Map()
-  }
-
   /**
    * Version major.
    * @type {number | undefined} */
@@ -404,125 +389,24 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   /**
-   * Blocks until an in-process advisory lock with the given name is
-   * acquired. SQLite has no built-in advisory lock primitive, so this is
-   * implemented as a process-local waiter queue. Typical SQLite deployments
-   * run inside a single Node process, which is exactly the scope this
-   * emulation covers; multi-process SQLite setups should not rely on this
-   * for cross-process mutual exclusion.
-   *
-   * The owning driver instance is recorded so that `releaseAdvisoryLock`
-   * can refuse to release a lock that was acquired by someone else.
-   * @param {string} name - Lock name.
-   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
-   * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.
-   */
-  async _acquireAdvisoryLock(name, {timeoutMs} = {}) {
-    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState
-
-    while (state.ownersByName.has(name)) {
-      let remainingMs = null
-
-      if (typeof timeoutMs === "number" && timeoutMs >= 0) {
-        remainingMs = timeoutMs
-
-        if (remainingMs <= 0) return false
-      }
-
-      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)) {
-        return false
-      }
-    }
-
-    state.ownersByName.set(name, this)
-
-    return true
-  }
-
-  /**
-   * Runs try acquire advisory lock.
-   * @param {string} name - Lock name.
-   * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.
+   * SQLite has no native advisory-lock primitive, so the shared
+   * process-local pre-filter tier in the base driver is the whole
+   * implementation for the web/sql.js and Expo native builds. The Node
+   * driver layers its filesystem lock on top as the driver-native tier.
+   * @returns {boolean} - Always false for plain SQLite.
    */
-  async _tryAcquireAdvisoryLock(name) {
-    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState
-
-    if (state.ownersByName.has(name)) return false
-
-    state.ownersByName.set(name, this)
-
-    return true
-  }
-
-  /**
-   * Releases the lock only if **this** driver instance owns it. Calling
-   * release for a lock owned by another driver instance is a no-op that
-   * returns `false`, matching the "you can only release locks you own"
-   * contract of MySQL's `RELEASE_LOCK` and PostgreSQL's
-   * `pg_advisory_unlock`.
-   * @param {string} name - Lock name.
-   * @returns {Promise<boolean>} - True if the lock was held by this driver and has now been released.
-   */
-  async _releaseAdvisoryLock(name) {
-    const state = VelociousDatabaseDriversSqliteBase._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
+  supportsDriverNativeAdvisoryLock() {
+    return false
   }
 
   /**
-   * Runs is advisory lock held.
-   * @param {string} name - Lock name.
-   * @returns {Promise<boolean>} - True if any driver instance currently holds the lock.
+   * The SQLite emulation is not re-entrant: a re-acquisition by the same
+   * driver instance is contention, not a grant, exactly as the in-process
+   * queue always behaved.
+   * @returns {boolean} - Always false for SQLite.
    */
-  async isAdvisoryLockHeld(name) {
-    return VelociousDatabaseDriversSqliteBase._advisoryLockState.ownersByName.has(name)
+  supportsReentrantAdvisoryLock() {
+    return false
   }
 
   /**