velocious 1.0.556 → 1.0.557

package/build/background-jobs/forked-runner-child.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import runJobPayload from "./job-runner.js"
+import { closeRunnerConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js"
 import setRunnerProcessTitle from "./runner-process-title.js"
 
 // Name the process so `ps`/`top`/`htop` can identify forked job runners at a
@@ -10,6 +11,23 @@ import setRunnerProcessTitle from "./runner-process-title.js"
 setRunnerProcessTitle()
 
 let finishing = false
+let shuttingDown = false
+
+/**
+ * Closes the runner's connections — releasing any advisory lock a killed-mid-job
+ * job still holds — before exiting on shutdown, instead of leaving a half-open
+ * session that keeps the lock until the DB server's `wait_timeout`. Normal
+ * completion (`finish`) already released its locks via the job's own lock scope.
+ * @param {number} exitCode - Process exit code.
+ * @returns {Promise<void>}
+ */
+async function shutdownRunner(exitCode) {
+  if (shuttingDown || finishing) return
+  shuttingDown = true
+
+  await closeRunnerConnections(currentConfigurationOrNull())
+  process.exit(exitCode)
+}
 
 /**
  * Runs is job message.
@@ -82,11 +100,11 @@ async function handleJobMessage(message) {
 }
 
 for (const signal of ["SIGTERM", "SIGINT"]) {
-  process.once(signal, () => process.exit(1))
+  process.once(signal, () => void shutdownRunner(1))
 }
 
 process.once("disconnect", () => {
-  if (!finishing) process.exit(0)
+  if (!finishing) void shutdownRunner(0)
 })
 
 process.once("message", (message) => {

package/build/background-jobs/pooled-runner-child.js

@@ -1,12 +1,30 @@
 // @ts-check
 
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js"
+import { closeRunnerConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js"
 import setRunnerProcessTitle from "./runner-process-title.js"
 
 const BASE_PROCESS_TITLE = "velocious background-jobs-runner"
 
 setRunnerProcessTitle()
 
+let shuttingDown = false
+
+/**
+ * Closes the runner's connections — releasing any advisory lock a killed-mid-pass
+ * job still holds — before exiting, instead of leaving a half-open session that
+ * keeps the lock until the DB server's `wait_timeout`.
+ * @param {number} exitCode - Process exit code.
+ * @returns {Promise<void>}
+ */
+async function shutdownRunner(exitCode) {
+  if (shuttingDown) return
+  shuttingDown = true
+
+  await closeRunnerConnections(currentConfigurationOrNull())
+  process.exit(exitCode)
+}
+
 /**
  * Ids of jobs currently running in this child. A pooled child runs up to
  * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that
@@ -111,5 +129,5 @@ function handleMessage(message) {
 }
 
 process.on("message", (message) => handleMessage(message))
-process.once("disconnect", () => process.exit(0))
-for (const signal of ["SIGTERM", "SIGINT"]) process.once(signal, () => process.exit(1))
+process.once("disconnect", () => void shutdownRunner(0))
+for (const signal of ["SIGTERM", "SIGINT"]) process.once(signal, () => void shutdownRunner(1))

package/build/background-jobs/runner-graceful-shutdown.js

@@ -0,0 +1,73 @@
+// @ts-check
+
+import timeout from "awaitery/build/timeout.js"
+
+import Configuration, {CurrentConfigurationNotSetError} from "../configuration.js"
+
+/** Bounded grace for closing framework connections on shutdown before forcing exit. */
+const SHUTDOWN_CLOSE_TIMEOUT_MS = 5000
+
+/**
+ * The subset of a configuration a runner closes on shutdown. Typed structurally so
+ * the shutdown path stays typechecked without a broad cast, and a future signature
+ * drift surfaces at the call sites (and in tests) instead of hiding behind `any`.
+ * @typedef {{disconnectBeacon: () => Promise<void>, closeDatabaseConnections: () => Promise<void>}} RunnerCloseableConfiguration
+ */
+
+/**
+ * Gracefully closes a background-job runner's framework connections (beacon +
+ * database) on shutdown, so the database server ends the session and releases any
+ * advisory lock the runner still holds *immediately* — instead of leaving a
+ * half-open session that keeps the lock (e.g. the build-planner lock) held until
+ * the server's idle `wait_timeout` (hours).
+ *
+ * A runner child otherwise exits abruptly on shutdown (`process.exit`) and relies
+ * on the OS tearing down its sockets. A named lock releases only when its owning
+ * session ends, and an abrupt exit / container teardown does not reliably deliver a
+ * clean disconnect to the server — so the lock leaks. Sending a real close here
+ * (`COM_QUIT` via `closeDatabaseConnections`) makes the server end the session and
+ * release the lock deterministically.
+ *
+ * The beacon disconnect and the database close run independently, each bounded by
+ * `closeTimeoutMs`: the database close releases the locks and must still run even if
+ * the beacon disconnect hangs (a wedged beacon socket during teardown), and neither
+ * may block the exit forever. A failed or timed-out close is thrown, not swallowed —
+ * the caller surfaces it (a lock that failed to release must be visible).
+ * @param {RunnerCloseableConfiguration | null} configuration - Configuration whose connections to close; null when none is set (nothing to close).
+ * @param {number} [closeTimeoutMs] - Max time to spend on each close before giving up.
+ * @returns {Promise<void>} - Resolves once both closes have settled; rejects if either failed.
+ */
+export async function closeRunnerConnections(configuration, closeTimeoutMs = SHUTDOWN_CLOSE_TIMEOUT_MS) {
+  if (!configuration) return
+
+  const [beaconResult, databaseResult] = await Promise.allSettled([
+    timeout({timeout: closeTimeoutMs}, () => configuration.disconnectBeacon()),
+    timeout({timeout: closeTimeoutMs}, () => configuration.closeDatabaseConnections())
+  ])
+
+  /** @type {unknown[]} */
+  const errors = []
+
+  if (beaconResult.status == "rejected") errors.push(beaconResult.reason)
+  if (databaseResult.status == "rejected") errors.push(databaseResult.reason)
+
+  if (errors.length == 1) throw errors[0]
+  if (errors.length > 1) throw new AggregateError(errors, "Failed to close background-job runner connections on shutdown")
+}
+
+/**
+ * The current configuration, or null when none has been set yet — a runner that is
+ * signalled before it runs any job holds no connections (and no locks) to close.
+ * Only that expected "not set yet" case is treated as null; any other error is a real
+ * fault and is rethrown rather than masked.
+ * @returns {Configuration | null} - The current configuration, or null when none is set.
+ */
+export function currentConfigurationOrNull() {
+  try {
+    return Configuration.current()
+  } catch (error) {
+    if (error instanceof CurrentConfigurationNotSetError) return null
+
+    throw error
+  }
+}

package/build/configuration.js

@@ -119,6 +119,15 @@ export default class VelociousConfiguration {
    * Close database connections promise.
    * @type {Promise<void> | null} */
   _closeDatabaseConnectionsPromise = null
+
+  /**
+   * Dedicated advisory-lock connections currently holding a lock. These are spawned
+   * outside the pools' tracked sets (so a hold-timeout lock survives pool checkouts),
+   * so `closeDatabaseConnections` would otherwise walk past them; tracking them here
+   * lets a shutdown close them and release the lock instead of orphaning it.
+   * @type {Set<import("./database/drivers/base.js").default>} */
+  _advisoryLockConnections = new Set()
+
   /**
    * Runs current.
    * @returns {VelociousConfiguration} - The current.
@@ -2986,6 +2995,53 @@ export default class VelociousConfiguration {
     })
   }
 
+  /**
+   * Registers a dedicated connection that currently holds an advisory lock, so a
+   * shutdown can close it and release the lock. See `_advisoryLockConnections`.
+   * @param {import("./database/drivers/base.js").default} connection - The dedicated lock connection.
+   * @returns {void}
+   */
+  registerAdvisoryLockConnection(connection) {
+    this._advisoryLockConnections.add(connection)
+  }
+
+  /**
+   * Unregisters a dedicated advisory-lock connection once its lock scope ends and the
+   * connection has been (or is about to be) closed by its owner.
+   * @param {import("./database/drivers/base.js").default} connection - The dedicated lock connection.
+   * @returns {void}
+   */
+  unregisterAdvisoryLockConnection(connection) {
+    this._advisoryLockConnections.delete(connection)
+  }
+
+  /**
+   * Closes every registered dedicated advisory-lock connection, ending its session so
+   * the DB server releases the lock. Every connection is attempted before any failure
+   * is surfaced, so one stuck close does not leave the others' locks held; a failure is
+   * then thrown (never swallowed), aggregated when more than one connection failed.
+   * @returns {Promise<void>} - Resolves once all have been closed; rejects if any failed.
+   */
+  async _closeAdvisoryLockConnections() {
+    const connections = [...this._advisoryLockConnections]
+
+    this._advisoryLockConnections.clear()
+
+    /** @type {unknown[]} */
+    const errors = []
+
+    for (const connection of connections) {
+      try {
+        await connection.close()
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+
+    if (errors.length == 1) throw errors[0]
+    if (errors.length > 1) throw new AggregateError(errors, "Failed to close dedicated advisory-lock connections")
+  }
+
   /**
    * Closes active database connections and clears global connections.
    * @returns {Promise<void>} - Resolves when complete.
@@ -3000,21 +3056,30 @@ export default class VelociousConfiguration {
     const constructors = new Set()
 
     this._closeDatabaseConnectionsPromise = (async () => {
-      for (const pool of Object.values(this.databasePools)) {
-        if (!pool) continue
-
-        await pool.closeAll()
+      try {
+        // Close dedicated advisory-lock connections first: they are spawned outside the
+        // pools' tracked sets, so `pool.closeAll()` would not reach them and a lock held
+        // by a runner torn down mid-pass would leak until the DB server's `wait_timeout`.
+        // Still close the pools even if this throws, so a stuck lock connection does not
+        // leave the rest of the connections open.
+        await this._closeAdvisoryLockConnections()
+      } finally {
+        for (const pool of Object.values(this.databasePools)) {
+          if (!pool) continue
+
+          await pool.closeAll()
+
+          const PoolClass = /** @type {typeof import("./database/pool/base.js").default} */ (pool.constructor)
+          constructors.add(PoolClass)
+        }
 
-        const PoolClass = /** @type {typeof import("./database/pool/base.js").default} */ (pool.constructor)
-        constructors.add(PoolClass)
-      }
+        for (const PoolClass of constructors) {
+          PoolClass.clearGlobalConnections(this)
+        }
 
-      for (const PoolClass of constructors) {
-        PoolClass.clearGlobalConnections(this)
+        // Allow models to be re-initialized after connections are closed.
+        this._modelsInitialized = false
       }
-
-      // Allow models to be re-initialized after connections are closed.
-      this._modelsInitialized = false
     })()
 
     try {

package/build/database/advisory-lock-runner.js

@@ -150,13 +150,22 @@ export default class AdvisoryLockRunner {
   async withDedicatedConnection(callback) {
     const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()
 
+    // The spawned driver owns its physical connection unless it borrows a shared one
+    // via `getConnection`. An owned connection lives outside the pools' tracked sets,
+    // so register it while the lock is held: a shutdown then closes it (releasing the
+    // lock) instead of orphaning a half-open session until the DB `wait_timeout`.
+    const ownsConnection = !connection.getArgs().getConnection
+
+    if (ownsConnection) this.configuration.registerAdvisoryLockConnection(connection)
+
     try {
       return await callback(connection)
     } finally {
-      if (connection.getArgs().getConnection) {
-        await connection.releaseHeldAdvisoryLocks()
-      } else {
+      if (ownsConnection) {
+        this.configuration.unregisterAdvisoryLockConnection(connection)
         await connection.close()
+      } else {
+        await connection.releaseHeldAdvisoryLocks()
       }
     }
   }

package/build/src/background-jobs/forked-runner-child.js

@@ -1,5 +1,6 @@
 // @ts-check
 import runJobPayload from "./job-runner.js";
+import { closeRunnerConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js";
 import setRunnerProcessTitle from "./runner-process-title.js";
 // Name the process so `ps`/`top`/`htop` can identify forked job runners at a
 // glance instead of a wall of generic "node" entries. Updated to the specific
@@ -7,6 +8,22 @@ import setRunnerProcessTitle from "./runner-process-title.js";
 // which jobs are running, how many of each, and which are eating resources.
 setRunnerProcessTitle();
 let finishing = false;
+let shuttingDown = false;
+/**
+ * Closes the runner's connections — releasing any advisory lock a killed-mid-job
+ * job still holds — before exiting on shutdown, instead of leaving a half-open
+ * session that keeps the lock until the DB server's `wait_timeout`. Normal
+ * completion (`finish`) already released its locks via the job's own lock scope.
+ * @param {number} exitCode - Process exit code.
+ * @returns {Promise<void>}
+ */
+async function shutdownRunner(exitCode) {
+    if (shuttingDown || finishing)
+        return;
+    shuttingDown = true;
+    await closeRunnerConnections(currentConfigurationOrNull());
+    process.exit(exitCode);
+}
 /**
  * Runs is job message.
  * @param {?} message - IPC message.
@@ -71,13 +88,13 @@ async function handleJobMessage(message) {
     }
 }
 for (const signal of ["SIGTERM", "SIGINT"]) {
-    process.once(signal, () => process.exit(1));
+    process.once(signal, () => void shutdownRunner(1));
 }
 process.once("disconnect", () => {
     if (!finishing)
-        process.exit(0);
+        void shutdownRunner(0);
 });
 process.once("message", (message) => {
     void handleJobMessage(message);
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/background-jobs/pooled-runner-child.js

@@ -1,8 +1,24 @@
 // @ts-check
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js";
+import { closeRunnerConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js";
 import setRunnerProcessTitle from "./runner-process-title.js";
 const BASE_PROCESS_TITLE = "velocious background-jobs-runner";
 setRunnerProcessTitle();
+let shuttingDown = false;
+/**
+ * Closes the runner's connections — releasing any advisory lock a killed-mid-pass
+ * job still holds — before exiting, instead of leaving a half-open session that
+ * keeps the lock until the DB server's `wait_timeout`.
+ * @param {number} exitCode - Process exit code.
+ * @returns {Promise<void>}
+ */
+async function shutdownRunner(exitCode) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    await closeRunnerConnections(currentConfigurationOrNull());
+    process.exit(exitCode);
+}
 /**
  * Ids of jobs currently running in this child. A pooled child runs up to
  * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that
@@ -102,7 +118,7 @@ function handleMessage(message) {
     void runJob(message.payload);
 }
 process.on("message", (message) => handleMessage(message));
-process.once("disconnect", () => process.exit(0));
+process.once("disconnect", () => void shutdownRunner(0));
 for (const signal of ["SIGTERM", "SIGINT"])
-    process.once(signal, () => process.exit(1));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooled-runner-child.js","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-child.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport runJobPayload, { BackgroundJobPerformedFailure } from \"./job-runner.js\"\nimport setRunnerProcessTitle from \"./runner-process-title.js\"\n\nconst BASE_PROCESS_TITLE = \"velocious background-jobs-runner\"\n\nsetRunnerProcessTitle()\n\n/**\n * Ids of jobs currently running in this child. A pooled child runs up to\n * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that\n * bound); the set dedupes a redelivered job id and lets each job settle\n * independently.\n * @type {Set<string>}\n */\nconst runningJobIds = new Set()\n\n/**\n * Sets an aggregate process title from the current in-flight count. A child runs\n * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and\n * restore around a single job) cannot represent the process — interleaved\n * completions would leave a stale label. Recomputing from `runningJobIds.size` is\n * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.\n * @returns {void}\n */\nfunction updateProcessTitle() {\n  const count = runningJobIds.size\n\n  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? \"job\" : \"jobs\"}` : BASE_PROCESS_TITLE\n}\n\n/**\n * Checks whether an IPC value is a runnable pooled job message.\n * @param {?} message - IPC message.\n * @returns {message is {type: \"job\", payload: import(\"./types.js\").BackgroundJobPayload & {id: string}}} - Whether this is a valid job message.\n */\nfunction isJobMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ?, payload?: ?}} */ (message)\n\n  return record.type === \"job\" && !!record.payload && typeof record.payload === \"object\" && typeof record.payload.id === \"string\"\n}\n\n/**\n * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.\n * @param {object} args - Outcome.\n * @param {string} args.jobId - Job id.\n * @param {boolean} args.acknowledged - Whether the terminal report was acknowledged.\n * @param {\"completed\" | \"failed\"} [args.status] - Acknowledged terminal status.\n * @param {Error} [args.error] - Reporting error when acknowledgement was not obtained.\n * @returns {Promise<void>} - Resolves after IPC accepts the message.\n */\nfunction sendOutcome({jobId, acknowledged, status, error}) {\n  return new Promise((resolve) => {\n    if (!process.send) {\n      resolve(undefined)\n      return\n    }\n\n    process.send({\n      type: \"job-outcome\",\n      jobId,\n      acknowledged,\n      status,\n      rssBytes: process.memoryUsage().rss,\n      error: error?.message\n    }, () => resolve(undefined))\n  })\n}\n\n/**\n * Runs one job concurrently with any siblings and reports its own terminal\n * outcome. A single job's unexpected failure reports that job for reclamation\n * (`acknowledged: false`) but does NOT take down the child — its concurrent\n * siblings keep running. Only a process-level fault (which escapes every\n * per-job try/catch) ends the child, which the worker sees as an exit and\n * reclaims for the whole in-flight set.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload.\n * @returns {Promise<void>} - Resolves after reporting.\n */\nasync function runJob(payload) {\n  try {\n    await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})\n    await sendOutcome({jobId: payload.id, acknowledged: true, status: \"completed\"})\n  } catch (error) {\n    if (error instanceof BackgroundJobPerformedFailure) {\n      await sendOutcome({jobId: payload.id, acknowledged: true, status: \"failed\"})\n    } else {\n      const reportError = error instanceof Error ? error : new Error(String(error))\n      console.error(\"Pooled background job runner failed before terminal acknowledgement:\", reportError)\n      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})\n    }\n  } finally {\n    runningJobIds.delete(payload.id)\n    updateProcessTitle()\n  }\n}\n\n/**\n * Handles a job message, starting it alongside any concurrent siblings.\n * @param {?} message - IPC message.\n * @returns {void}\n */\nfunction handleMessage(message) {\n  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return\n\n  runningJobIds.add(message.payload.id)\n  updateProcessTitle()\n  void runJob(message.payload)\n}\n\nprocess.on(\"message\", (message) => handleMessage(message))\nprocess.once(\"disconnect\", () => process.exit(0))\nfor (const signal of [\"SIGTERM\", \"SIGINT\"]) process.once(signal, () => process.exit(1))\n"]}
+    process.once(signal, () => void shutdownRunner(1));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooled-runner-child.js","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-child.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport runJobPayload, { BackgroundJobPerformedFailure } from \"./job-runner.js\"\nimport { closeRunnerConnections, currentConfigurationOrNull } from \"./runner-graceful-shutdown.js\"\nimport setRunnerProcessTitle from \"./runner-process-title.js\"\n\nconst BASE_PROCESS_TITLE = \"velocious background-jobs-runner\"\n\nsetRunnerProcessTitle()\n\nlet shuttingDown = false\n\n/**\n * Closes the runner's connections — releasing any advisory lock a killed-mid-pass\n * job still holds — before exiting, instead of leaving a half-open session that\n * keeps the lock until the DB server's `wait_timeout`.\n * @param {number} exitCode - Process exit code.\n * @returns {Promise<void>}\n */\nasync function shutdownRunner(exitCode) {\n  if (shuttingDown) return\n  shuttingDown = true\n\n  await closeRunnerConnections(currentConfigurationOrNull())\n  process.exit(exitCode)\n}\n\n/**\n * Ids of jobs currently running in this child. A pooled child runs up to\n * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that\n * bound); the set dedupes a redelivered job id and lets each job settle\n * independently.\n * @type {Set<string>}\n */\nconst runningJobIds = new Set()\n\n/**\n * Sets an aggregate process title from the current in-flight count. A child runs\n * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and\n * restore around a single job) cannot represent the process — interleaved\n * completions would leave a stale label. Recomputing from `runningJobIds.size` is\n * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.\n * @returns {void}\n */\nfunction updateProcessTitle() {\n  const count = runningJobIds.size\n\n  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? \"job\" : \"jobs\"}` : BASE_PROCESS_TITLE\n}\n\n/**\n * Checks whether an IPC value is a runnable pooled job message.\n * @param {?} message - IPC message.\n * @returns {message is {type: \"job\", payload: import(\"./types.js\").BackgroundJobPayload & {id: string}}} - Whether this is a valid job message.\n */\nfunction isJobMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ?, payload?: ?}} */ (message)\n\n  return record.type === \"job\" && !!record.payload && typeof record.payload === \"object\" && typeof record.payload.id === \"string\"\n}\n\n/**\n * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.\n * @param {object} args - Outcome.\n * @param {string} args.jobId - Job id.\n * @param {boolean} args.acknowledged - Whether the terminal report was acknowledged.\n * @param {\"completed\" | \"failed\"} [args.status] - Acknowledged terminal status.\n * @param {Error} [args.error] - Reporting error when acknowledgement was not obtained.\n * @returns {Promise<void>} - Resolves after IPC accepts the message.\n */\nfunction sendOutcome({jobId, acknowledged, status, error}) {\n  return new Promise((resolve) => {\n    if (!process.send) {\n      resolve(undefined)\n      return\n    }\n\n    process.send({\n      type: \"job-outcome\",\n      jobId,\n      acknowledged,\n      status,\n      rssBytes: process.memoryUsage().rss,\n      error: error?.message\n    }, () => resolve(undefined))\n  })\n}\n\n/**\n * Runs one job concurrently with any siblings and reports its own terminal\n * outcome. A single job's unexpected failure reports that job for reclamation\n * (`acknowledged: false`) but does NOT take down the child — its concurrent\n * siblings keep running. Only a process-level fault (which escapes every\n * per-job try/catch) ends the child, which the worker sees as an exit and\n * reclaims for the whole in-flight set.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload.\n * @returns {Promise<void>} - Resolves after reporting.\n */\nasync function runJob(payload) {\n  try {\n    await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})\n    await sendOutcome({jobId: payload.id, acknowledged: true, status: \"completed\"})\n  } catch (error) {\n    if (error instanceof BackgroundJobPerformedFailure) {\n      await sendOutcome({jobId: payload.id, acknowledged: true, status: \"failed\"})\n    } else {\n      const reportError = error instanceof Error ? error : new Error(String(error))\n      console.error(\"Pooled background job runner failed before terminal acknowledgement:\", reportError)\n      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})\n    }\n  } finally {\n    runningJobIds.delete(payload.id)\n    updateProcessTitle()\n  }\n}\n\n/**\n * Handles a job message, starting it alongside any concurrent siblings.\n * @param {?} message - IPC message.\n * @returns {void}\n */\nfunction handleMessage(message) {\n  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return\n\n  runningJobIds.add(message.payload.id)\n  updateProcessTitle()\n  void runJob(message.payload)\n}\n\nprocess.on(\"message\", (message) => handleMessage(message))\nprocess.once(\"disconnect\", () => void shutdownRunner(0))\nfor (const signal of [\"SIGTERM\", \"SIGINT\"]) process.once(signal, () => void shutdownRunner(1))\n"]}

package/build/src/background-jobs/runner-graceful-shutdown.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The subset of a configuration a runner closes on shutdown. Typed structurally so
+ * the shutdown path stays typechecked without a broad cast, and a future signature
+ * drift surfaces at the call sites (and in tests) instead of hiding behind `any`.
+ * @typedef {{disconnectBeacon: () => Promise<void>, closeDatabaseConnections: () => Promise<void>}} RunnerCloseableConfiguration
+ */
+/**
+ * Gracefully closes a background-job runner's framework connections (beacon +
+ * database) on shutdown, so the database server ends the session and releases any
+ * advisory lock the runner still holds *immediately* — instead of leaving a
+ * half-open session that keeps the lock (e.g. the build-planner lock) held until
+ * the server's idle `wait_timeout` (hours).
+ *
+ * A runner child otherwise exits abruptly on shutdown (`process.exit`) and relies
+ * on the OS tearing down its sockets. A named lock releases only when its owning
+ * session ends, and an abrupt exit / container teardown does not reliably deliver a
+ * clean disconnect to the server — so the lock leaks. Sending a real close here
+ * (`COM_QUIT` via `closeDatabaseConnections`) makes the server end the session and
+ * release the lock deterministically.
+ *
+ * The beacon disconnect and the database close run independently, each bounded by
+ * `closeTimeoutMs`: the database close releases the locks and must still run even if
+ * the beacon disconnect hangs (a wedged beacon socket during teardown), and neither
+ * may block the exit forever. A failed or timed-out close is thrown, not swallowed —
+ * the caller surfaces it (a lock that failed to release must be visible).
+ * @param {RunnerCloseableConfiguration | null} configuration - Configuration whose connections to close; null when none is set (nothing to close).
+ * @param {number} [closeTimeoutMs] - Max time to spend on each close before giving up.
+ * @returns {Promise<void>} - Resolves once both closes have settled; rejects if either failed.
+ */
+export function closeRunnerConnections(configuration: RunnerCloseableConfiguration | null, closeTimeoutMs?: number): Promise<void>;
+/**
+ * The current configuration, or null when none has been set yet — a runner that is
+ * signalled before it runs any job holds no connections (and no locks) to close.
+ * Only that expected "not set yet" case is treated as null; any other error is a real
+ * fault and is rethrown rather than masked.
+ * @returns {Configuration | null} - The current configuration, or null when none is set.
+ */
+export function currentConfigurationOrNull(): Configuration | null;
+/**
+ * The subset of a configuration a runner closes on shutdown. Typed structurally so
+ * the shutdown path stays typechecked without a broad cast, and a future signature
+ * drift surfaces at the call sites (and in tests) instead of hiding behind `any`.
+ */
+export type RunnerCloseableConfiguration = {
+    disconnectBeacon: () => Promise<void>;
+    closeDatabaseConnections: () => Promise<void>;
+};
+import Configuration from "../configuration.js";
+//# sourceMappingURL=runner-graceful-shutdown.d.ts.map

package/build/src/background-jobs/runner-graceful-shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-graceful-shutdown.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/runner-graceful-shutdown.js"],"names":[],"mappings":"AASA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,sDAJW,4BAA4B,GAAG,IAAI,mBACnC,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAkBzB;AAED;;;;;;GAMG;AACH,8CAFa,aAAa,GAAG,IAAI,CAUhC;;;;;;2CA3DY;IAAC,gBAAgB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,wBAAwB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAC;0BATtC,qBAAqB"}

package/build/src/background-jobs/runner-graceful-shutdown.js

@@ -0,0 +1,70 @@
+// @ts-check
+import timeout from "awaitery/build/timeout.js";
+import Configuration, { CurrentConfigurationNotSetError } from "../configuration.js";
+/** Bounded grace for closing framework connections on shutdown before forcing exit. */
+const SHUTDOWN_CLOSE_TIMEOUT_MS = 5000;
+/**
+ * The subset of a configuration a runner closes on shutdown. Typed structurally so
+ * the shutdown path stays typechecked without a broad cast, and a future signature
+ * drift surfaces at the call sites (and in tests) instead of hiding behind `any`.
+ * @typedef {{disconnectBeacon: () => Promise<void>, closeDatabaseConnections: () => Promise<void>}} RunnerCloseableConfiguration
+ */
+/**
+ * Gracefully closes a background-job runner's framework connections (beacon +
+ * database) on shutdown, so the database server ends the session and releases any
+ * advisory lock the runner still holds *immediately* — instead of leaving a
+ * half-open session that keeps the lock (e.g. the build-planner lock) held until
+ * the server's idle `wait_timeout` (hours).
+ *
+ * A runner child otherwise exits abruptly on shutdown (`process.exit`) and relies
+ * on the OS tearing down its sockets. A named lock releases only when its owning
+ * session ends, and an abrupt exit / container teardown does not reliably deliver a
+ * clean disconnect to the server — so the lock leaks. Sending a real close here
+ * (`COM_QUIT` via `closeDatabaseConnections`) makes the server end the session and
+ * release the lock deterministically.
+ *
+ * The beacon disconnect and the database close run independently, each bounded by
+ * `closeTimeoutMs`: the database close releases the locks and must still run even if
+ * the beacon disconnect hangs (a wedged beacon socket during teardown), and neither
+ * may block the exit forever. A failed or timed-out close is thrown, not swallowed —
+ * the caller surfaces it (a lock that failed to release must be visible).
+ * @param {RunnerCloseableConfiguration | null} configuration - Configuration whose connections to close; null when none is set (nothing to close).
+ * @param {number} [closeTimeoutMs] - Max time to spend on each close before giving up.
+ * @returns {Promise<void>} - Resolves once both closes have settled; rejects if either failed.
+ */
+export async function closeRunnerConnections(configuration, closeTimeoutMs = SHUTDOWN_CLOSE_TIMEOUT_MS) {
+    if (!configuration)
+        return;
+    const [beaconResult, databaseResult] = await Promise.allSettled([
+        timeout({ timeout: closeTimeoutMs }, () => configuration.disconnectBeacon()),
+        timeout({ timeout: closeTimeoutMs }, () => configuration.closeDatabaseConnections())
+    ]);
+    /** @type {unknown[]} */
+    const errors = [];
+    if (beaconResult.status == "rejected")
+        errors.push(beaconResult.reason);
+    if (databaseResult.status == "rejected")
+        errors.push(databaseResult.reason);
+    if (errors.length == 1)
+        throw errors[0];
+    if (errors.length > 1)
+        throw new AggregateError(errors, "Failed to close background-job runner connections on shutdown");
+}
+/**
+ * The current configuration, or null when none has been set yet — a runner that is
+ * signalled before it runs any job holds no connections (and no locks) to close.
+ * Only that expected "not set yet" case is treated as null; any other error is a real
+ * fault and is rethrown rather than masked.
+ * @returns {Configuration | null} - The current configuration, or null when none is set.
+ */
+export function currentConfigurationOrNull() {
+    try {
+        return Configuration.current();
+    }
+    catch (error) {
+        if (error instanceof CurrentConfigurationNotSetError)
+            return null;
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/configuration.d.ts

@@ -14,6 +14,13 @@ export default class VelociousConfiguration {
      * Close database connections promise.
      * @type {Promise<void> | null} */
     _closeDatabaseConnectionsPromise: Promise<void> | null;
+    /**
+     * Dedicated advisory-lock connections currently holding a lock. These are spawned
+     * outside the pools' tracked sets (so a hold-timeout lock survives pool checkouts),
+     * so `closeDatabaseConnections` would otherwise walk past them; tracking them here
+     * lets a shutdown close them and release the lock instead of orphaning it.
+     * @type {Set<import("./database/drivers/base.js").default>} */
+    _advisoryLockConnections: Set<import("./database/drivers/base.js").default>;
     _abilityResolver: import("./configuration-types.js").AbilityResolverType | undefined;
     _abilityResources: typeof import("./authorization/base-resource.js").default[];
     _autoload: boolean;
@@ -1310,6 +1317,28 @@ export default class VelociousConfiguration {
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     ensureConnections<T>(optionsOrCallback: WithConnectionsOptionsType | WithConnectionsCallbackType<T>, callback?: WithConnectionsCallbackType<T>): Promise<T>;
+    /**
+     * Registers a dedicated connection that currently holds an advisory lock, so a
+     * shutdown can close it and release the lock. See `_advisoryLockConnections`.
+     * @param {import("./database/drivers/base.js").default} connection - The dedicated lock connection.
+     * @returns {void}
+     */
+    registerAdvisoryLockConnection(connection: import("./database/drivers/base.js").default): void;
+    /**
+     * Unregisters a dedicated advisory-lock connection once its lock scope ends and the
+     * connection has been (or is about to be) closed by its owner.
+     * @param {import("./database/drivers/base.js").default} connection - The dedicated lock connection.
+     * @returns {void}
+     */
+    unregisterAdvisoryLockConnection(connection: import("./database/drivers/base.js").default): void;
+    /**
+     * Closes every registered dedicated advisory-lock connection, ending its session so
+     * the DB server releases the lock. Every connection is attempted before any failure
+     * is surfaced, so one stuck close does not leave the others' locks held; a failure is
+     * then thrown (never swallowed), aggregated when more than one connection failed.
+     * @returns {Promise<void>} - Resolves once all have been closed; rejects if any failed.
+     */
+    _closeAdvisoryLockConnections(): Promise<void>;
     /**
      * Closes active database connections and clears global connections.
      * @returns {Promise<void>} - Resolves when complete.