velocious 1.0.523 → 1.0.525

package/README.md

@@ -1975,7 +1975,8 @@ export default new Configuration({
     databaseIdentifier: "default",
     maxConcurrentForkedJobs: 4,
     maxConcurrentInlineJobs: 4,
-    dispatchStrategy: "beacon"
+    dispatchStrategy: "beacon",
+    jobTimeoutMs: null
   }
 })
 ```
@@ -1991,6 +1992,7 @@ VELOCIOUS_BACKGROUND_JOBS_MAX_CONCURRENT_INLINE_JOBS=4
 VELOCIOUS_BACKGROUND_JOBS_DISPATCH_STRATEGY=beacon
 VELOCIOUS_BACKGROUND_JOBS_POLL_INTERVAL_MS=1000
 VELOCIOUS_BACKGROUND_JOBS_WORKER_SHUTDOWN_TIMEOUT_MS=indefinite
+VELOCIOUS_BACKGROUND_JOBS_JOB_TIMEOUT_MS=5400000
 ```
 
 `VELOCIOUS_BACKGROUND_JOBS_WORKER_SHUTDOWN_TIMEOUT_MS` (default: `indefinite`) bounds how long a `background-jobs-worker` waits for in-flight jobs on `SIGTERM`/`SIGINT` before terminating any forked or spawned child runners still running, so they are not orphaned across a deploy. The default waits for jobs to finish and never interrupts a running job; set a positive number of milliseconds for a finite cap (keep it shorter than your process supervisor's graceful-stop window so the worker reaps its own runners first). See [docs/background-jobs.md](docs/background-jobs.md#worker-shutdown-and-process-job-draining).
@@ -1999,6 +2001,8 @@ VELOCIOUS_BACKGROUND_JOBS_WORKER_SHUTDOWN_TIMEOUT_MS=indefinite
 
 `maxConcurrentForkedJobs` (default: `4`) caps how many out-of-process `executionMode: "forked"` or `executionMode: "spawned"` jobs one worker may keep in flight. Forked jobs use `child_process.fork()` with an attached IPC channel. After the main process acknowledges their durable status report, forked and spawned one-shot runners exit without waiting for graceful Beacon/database teardown; the OS closes their process-owned resources. A missing or rejected status acknowledgement makes the runner exit as failed instead of reporting clean success. Spawned jobs use the legacy `background-jobs-runner` CLI process via `child_process.spawn()` and are only for callers that intentionally want that spawned behavior.
 
+`jobTimeoutMs` (or `VELOCIOUS_BACKGROUND_JOBS_JOB_TIMEOUT_MS`, milliseconds; default: disabled) is a wall-clock backstop for a single `"forked"` runner. A forked job still running after the timeout is terminated (`SIGTERM`, then `SIGKILL` after the reaping grace) and reported `failed`, so a genuinely-hung runner can't pin a worker — and its whole-app boot and DB connections — indefinitely (notably a retired-release worker draining after a deploy). It's a coarse safety net, not per-job tuning: it applies to every forked runner, so set it well above the longest legitimate forked job. Omit it, or set `null`/`<= 0`, to disable. `"inline"` jobs are not covered — they share the worker's process and can't be killed without killing the worker. See [docs/background-jobs.md](docs/background-jobs.md#forked-job-timeout-hung-runner-backstop).
+
 ### Dispatch strategy
 
 `dispatchStrategy` controls how `background-jobs-main` detects new work.
@@ -2118,7 +2122,7 @@ Each job must define exactly one of `every` or `cron`. Cron times are evaluated
 
 ## Persistence and retries
 
-Jobs are persisted in the configured database (`backgroundJobs.databaseIdentifier`) in an internal `background_jobs` table. When a worker picks a job, the job is marked as handed off with a unique lease id and the worker reports completion or failure back to the main process. If that worker socket disconnects unexpectedly, only the leases handed to that exact socket are immediately returned to the queue; late reports are fenced by lease id so they cannot mutate a newer attempt. This recovery is at-least-once and may repeat application side effects if the disconnected attempt had already started them. Gracefully draining workers keep their leases while they finish. For rolling upgrades, upgrade workers before the main process: a lease-aware main keeps legacy workers connected for old reports but dispatches new jobs only to workers advertising lease-reporting support. See [docs/background-jobs.md](docs/background-jobs.md#worker-disconnect-recovery).
+Jobs are persisted in the configured database (`backgroundJobs.databaseIdentifier`) in an internal `background_jobs` table. When a worker picks a job, the job is marked as handed off with a unique lease id and the worker reports completion or failure back to the main process. If that worker socket disconnects unexpectedly, only the leases handed to that exact socket are immediately returned to the queue; late reports are fenced by lease id so they cannot mutate a newer attempt. This recovery is at-least-once and may repeat application side effects if the disconnected attempt had already started them. Gracefully draining workers keep their leases while they finish. When the **main** itself restarts (every deploy), a reconnecting worker's still-active handoffs are adopted into its new socket on `hello` so a later disconnect releases them instead of leaving them stuck until the orphan sweep; the main never time-reclaims a disconnected worker's jobs, so a gracefully-draining old-release worker is not double-run. For rolling upgrades, upgrade workers before the main process: a lease-aware main keeps legacy workers connected for old reports but dispatches new jobs only to workers advertising lease-reporting support. See [docs/background-jobs.md](docs/background-jobs.md#worker-disconnect-recovery).
 
 Failed jobs are re-queued with backoff and retried up to 10 times by default (10s, 1m, 10m, 1h, then +1h per retry). You can override the retry limit per job:
 
@@ -2133,6 +2137,8 @@ If a handed-off job does not report back within 2 hours, it is marked orphaned a
 
 Workers also send periodic heartbeats (and use TCP keepalive) so the main can drop a wedged or half-open worker that never fires a socket `close` and release its leases, and job slots are freed independently of durable, background result reporting so a transient outage can't wedge a worker or lose a completion. See [docs/background-jobs.md](docs/background-jobs.md#worker-liveness).
 
+Every background-jobs process sets a descriptive `process.title` (`velocious background-jobs-main`/`-worker`/`server`/`beacon`), and each forked/spawned job runner is named after the job it runs (`velocious job-runner: <JobName>`, or a job class's `static processTitle`), so `ps`/`top` show which jobs are consuming resources. See [docs/background-jobs.md](docs/background-jobs.md#process-titles).
+
 ## Queues
 
 Give a job a queue with `static queue = "..."` (or a `{queue}` job option; the option wins) and cap how many of that queue's jobs run in flight across the whole cluster under `backgroundJobs.queues`:

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

@@ -2,6 +2,12 @@
 
 import runJobPayload from "./job-runner.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
+// job name once one arrives (see runJobMessage), so operators can see exactly
+// which jobs are running, how many of each, and which are eating resources.
+process.title = "velocious background-jobs-runner"
+
 let finishing = false
 
 /**
@@ -51,6 +57,9 @@ async function runJobMessage(message) {
     throw new Error("Forked background job runner received invalid payload")
   }
 
+  // The per-job process title (and its restore) is set inside runJobPayload,
+  // which reads the job class's `static processTitle`. This process boots with
+  // the base "velocious background-jobs-runner" title set at module load above.
   await runJobPayload(message.payload, {closeConnections: false})
 }
 

package/build/background-jobs/job-runner.js

@@ -47,6 +47,21 @@ async function connectBeacon(configuration) {
   }
 }
 
+/**
+ * Resolves the process title to show while a job runs: the job class's declared
+ * `static processTitle`, else a `velocious job-runner: <JobName>` fallback.
+ * @param {typeof import("./job.js").default} JobClass - Resolved job class.
+ * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
+ * @returns {string} - Process title.
+ */
+function runnerProcessTitle(JobClass, payload) {
+  const declared = JobClass.processTitle
+
+  if (typeof declared === "string" && declared.length > 0) return declared
+
+  return `velocious job-runner: ${payload.jobName}`
+}
+
 /**
  * Runs run job payload.
  * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
@@ -70,6 +85,11 @@ export default async function runJobPayload(payload, {closeConnections = true} =
    * @type {(...args: Array<?>) => Promise<void>} */
   const perform = jobInstance.perform
 
+  // Name the process after the job it is running so `ps`/`top` show what each
+  // runner is doing; restored in the `finally` below when the job finishes.
+  const previousTitle = process.title
+  process.title = runnerProcessTitle(JobClass, payload)
+
   try {
     try {
       await configuration.withConnections({name: `Background job runner: ${payload.jobName}`}, async () => {
@@ -102,6 +122,9 @@ export default async function runJobPayload(payload, {closeConnections = true} =
       })
     }
   } finally {
+    // Restore the runner's base title so a lingering/idle runner (or a reused
+    // one) doesn't misreport a finished job as still running.
+    process.title = previousTitle
     if (closeConnections) {
       try {
         await configuration.disconnectBeacon()

package/build/background-jobs/job.js

@@ -22,6 +22,18 @@ export default class VelociousJob {
    */
   static queue = undefined
 
+  /**
+   * Optional process title shown for the runner while this job executes.
+   * Velocious sets `process.title` to this for the duration of the job — so
+   * `ps`/`top`/`htop` identify what a runner is doing — and restores the
+   * runner's base title when the job finishes. Left undefined, the runner falls
+   * back to `velocious job-runner: <JobName>`. Set e.g.
+   * `static processTitle = "velocious media transcoder"` to give a job a
+   * custom, human-readable title.
+   * @type {string | undefined}
+   */
+  static processTitle = undefined
+
   /**
    * Runs job name.
    * @returns {string} - Job name.

package/build/background-jobs/main.js

@@ -422,11 +422,47 @@ export default class BackgroundJobsMain {
       jsonSocket.lastSeenAt = Date.now()
       this.workers.add(jsonSocket)
       this.workerHandoffs.set(jsonSocket, new Map())
+      void this._adoptWorkerHandoffs(jsonSocket)
     }
 
     return message.role
   }
 
+  /**
+   * Adopts a reconnecting worker's still-active `handed_off` jobs into its new
+   * socket's handoff map. A fresh main (e.g. after a deploy restart) holds no
+   * in-memory leases, so a worker that reconnects with its stable id would
+   * otherwise have its pre-restart jobs tracked nowhere — if it then died, those
+   * leases (and their concurrency reservations) would sit stuck until the
+   * hours-long orphan sweep. Adopting them means `_handleWorkerSocketClosed`
+   * releases them on the worker's next disconnect, while a still-running worker
+   * (including one gracefully draining) keeps executing them untouched. No
+   * time-based reclaim is used, so a draining worker whose jobs outlive the old
+   * main is never wrongly requeued into a duplicate attempt.
+   * @param {JsonSocket} jsonSocket - The reconnected worker socket.
+   * @returns {Promise<void>}
+   */
+  async _adoptWorkerHandoffs(jsonSocket) {
+    const workerId = jsonSocket.workerId
+
+    if (typeof workerId !== "string" || workerId.length === 0) return
+
+    try {
+      const handoffs = await this.store.handedOffJobsForWorker({workerId})
+      const map = this.workerHandoffs.get(jsonSocket)
+
+      // The socket may have closed while the query was in flight; its map is then
+      // gone and the jobs are left for the orphan sweep rather than resurrected.
+      if (!map || !this.workers.has(jsonSocket)) return
+
+      for (const {jobId, handoffId} of handoffs) {
+        map.set(jobId, handoffId)
+      }
+    } catch (error) {
+      this._reportHandoffAdoptError(error)
+    }
+  }
+
   /**
    * Runs handle client socket message.
    * @param {object} args - Options.
@@ -611,6 +647,23 @@ export default class BackgroundJobsMain {
     errorEvents.emit("all-error", {...payload, errorType: "framework-error"})
   }
 
+  /**
+   * Reports an unexpected worker-handoff adoption failure on framework error
+   * channels. A failed adoption is not fatal (the worker's jobs remain and are
+   * reclaimed by the orphan sweep), but must surface rather than be swallowed.
+   * @param {?} error - Adoption failure.
+   * @returns {void}
+   */
+  _reportHandoffAdoptError(error) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error))
+    const payload = {context: {stage: "background-job-handoff-adopt"}, error: normalizedError}
+    const errorEvents = this.configuration.getErrorEvents()
+
+    this.logger.error(() => ["Failed to adopt reconnected worker handoffs:", normalizedError])
+    errorEvents.emit("framework-error", payload)
+    errorEvents.emit("all-error", {...payload, errorType: "framework-error"})
+  }
+
   /**
    * Runs handle enqueue.
    * @param {object} args - Options.

package/build/background-jobs/store.js

@@ -487,6 +487,38 @@ export default class BackgroundJobsStore {
     }))
   }
 
+  /**
+   * Returns the active `handed_off` jobs (jobId + handoffId) held under a worker
+   * id. Used on worker reconnect: after a main restart a worker reconnects with
+   * its stable id, and the fresh main adopts these leases so they are tracked —
+   * and released if the reconnected worker later disconnects — instead of
+   * sitting stuck until the age-based orphan sweep. This never reclaims, so a
+   * gracefully-draining worker that keeps running its in-flight jobs is left
+   * untouched. Rows with a null handoff id (legacy) are skipped; the orphan
+   * sweep reclaims those via its `handed_off_at_ms` fence.
+   * @param {object} args - Options.
+   * @param {string} args.workerId - Worker id.
+   * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active handoffs.
+   */
+  async handedOffJobsForWorker({workerId}) {
+    await this.ensureReady()
+
+    const rows = await this._withDb(async (db) =>
+      await db.newQuery().from(JOBS_TABLE).where({status: "handed_off", worker_id: workerId}).results()
+    )
+
+    /** @type {Array<{jobId: string, handoffId: string}>} */
+    const handoffs = []
+
+    for (const row of rows) {
+      const job = this._normalizeJobRow(row)
+
+      if (job.handoffId) handoffs.push({jobId: job.id, handoffId: job.handoffId})
+    }
+
+    return handoffs
+  }
+
   /**
    * Runs mark failed.
    * @param {object} args - Options.

package/build/background-jobs/worker.js

@@ -11,6 +11,13 @@ import {fileURLToPath} from "node:url"
 
 /** Grace period after SIGTERM before a lingering process runner is SIGKILLed. */
 const FORKED_CHILD_SIGKILL_GRACE_MS = 5000
+/**
+ * Largest delay Node's `setTimeout` accepts without overflowing to a 1ms delay
+ * (a 32-bit signed int of ms, ~24.8 days). A `jobTimeoutMs` above this — or a
+ * non-finite one like `Infinity` — is clamped/disabled rather than coerced to
+ * ~1ms, which would otherwise terminate every forked job almost immediately.
+ */
+const MAX_FORKED_JOB_TIMEOUT_MS = 2_147_483_647
 const FORKED_RUNNER_ENTRY_PATH = fileURLToPath(new URL("./forked-runner-child.js", import.meta.url))
 /** How often the worker sends a liveness heartbeat to the main. */
 const HEARTBEAT_INTERVAL_MS = 15000
@@ -21,6 +28,15 @@ const SOCKET_KEEPALIVE_MS = 10000
  * @type {import("./types.js").BackgroundJobExecutionMode[]} */
 const EXECUTION_MODES = ["inline", "forked", "spawned"]
 
+/**
+ * Per-forked-child timeout bookkeeping.
+ * @typedef {object} ForkedJobTimeoutState
+ * @property {boolean} timedOut - Whether the timeout fired and the child was terminated.
+ * @property {number | null} timeoutMs - The armed timeout in ms, or null when disabled.
+ * @property {ReturnType<typeof setTimeout> | null} timer - The pending timeout timer, cleared on exit.
+ * @property {ReturnType<typeof setTimeout> | null} sigkillTimer - The pending SIGKILL grace timer, cleared on exit.
+ */
+
 export default class BackgroundJobsWorker {
   /**
    * Runs constructor.
@@ -32,8 +48,9 @@ export default class BackgroundJobsWorker {
    * @param {number} [args.maxConcurrentInlineJobs] - Override the inline-job concurrency cap from `configuration.getBackgroundJobsConfig()`.
    * @param {number} [args.forkedChildSigkillGraceMs] - Override the grace period between SIGTERM and SIGKILL when reaping lingering process runners on stop.
    * @param {number} [args.heartbeatIntervalMs] - Override the liveness heartbeat interval (default 15000ms).
+   * @param {number} [args.jobTimeoutMs] - Override the forked-job wall-clock timeout from `configuration.getBackgroundJobsConfig()`. `0` disables it.
    */
-  constructor({configuration, host, port, maxConcurrentForkedJobs, maxConcurrentInlineJobs, forkedChildSigkillGraceMs, heartbeatIntervalMs} = {}) {
+  constructor({configuration, host, port, maxConcurrentForkedJobs, maxConcurrentInlineJobs, forkedChildSigkillGraceMs, heartbeatIntervalMs, jobTimeoutMs} = {}) {
     /**
      * Narrows the runtime value to the documented type.
      * @type {Promise<import("../configuration.js").default>} */
@@ -77,6 +94,13 @@ export default class BackgroundJobsWorker {
     this.forkedChildSigkillGraceMs = typeof forkedChildSigkillGraceMs === "number" && forkedChildSigkillGraceMs >= 0
       ? forkedChildSigkillGraceMs
       : FORKED_CHILD_SIGKILL_GRACE_MS
+    /**
+     * Constructor override for the forked-job wall-clock timeout. When unset the
+     * timeout is read from `configuration.getBackgroundJobsConfig().jobTimeoutMs`
+     * at fork time (default: disabled).
+     * @type {number | undefined}
+     */
+    this.jobTimeoutMsOverride = typeof jobTimeoutMs === "number" ? jobTimeoutMs : undefined
     this.shouldStop = false
     this.workerId = randomUUID()
     this.heartbeatIntervalMs = typeof heartbeatIntervalMs === "number" && heartbeatIntervalMs >= 1
@@ -590,16 +614,109 @@ export default class BackgroundJobsWorker {
    * @returns {Promise<void>} - Resolves when the child exits.
    */
   _waitForForkedChild({child, payload}) {
+    const timeoutState = this._armForkedJobTimeout({child})
+
     return new Promise((resolve) => {
       child.once("exit", (code, signal) => {
-        this._handleForkedChildExit({child, code, signal, payload, resolve})
+        this._clearForkedJobTimeout(timeoutState)
+        this._handleForkedChildExit({child, code, signal, payload, resolve, timeoutState})
       })
       child.once("error", (error) => {
+        this._clearForkedJobTimeout(timeoutState)
         this._handleForkedChildError({child, error, payload, resolve})
       })
     })
   }
 
+  /**
+   * Arms a wall-clock backstop for a forked job runner. A forked job still
+   * running after `jobTimeoutMs` is terminated (SIGTERM, then SIGKILL after the
+   * grace) so a single genuinely-hung runner can't pin a draining worker — and
+   * its full-app boot and database connections — indefinitely. Returns a state
+   * object the exit/error handlers use to cancel the timer and to report a
+   * timeout-specific failure. When no timeout is configured the timer is null
+   * and behavior is unchanged.
+   * @param {object} args - Options.
+   * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
+   * @returns {ForkedJobTimeoutState} - Timeout state.
+   */
+  _armForkedJobTimeout({child}) {
+    const timeoutMs = this._resolveForkedJobTimeoutMs()
+    /** @type {ForkedJobTimeoutState} */
+    const state = {timedOut: false, timeoutMs, timer: null, sigkillTimer: null}
+
+    if (!(typeof timeoutMs === "number" && timeoutMs > 0)) return state
+
+    state.timer = setTimeout(() => this._onForkedJobTimeout({child, state}), timeoutMs)
+
+    return state
+  }
+
+  /**
+   * Resolves the effective forked-job timeout in ms, or null when disabled. The
+   * constructor override wins; otherwise the value comes from the background-jobs
+   * configuration. A non-positive value disables the backstop.
+   * @returns {number | null} - Timeout in ms, or null when disabled.
+   */
+  _resolveForkedJobTimeoutMs() {
+    const raw = typeof this.jobTimeoutMsOverride === "number"
+      ? this.jobTimeoutMsOverride
+      : (this.configuration ? this.configuration.getBackgroundJobsConfig().jobTimeoutMs : null)
+
+    // A non-finite (e.g. Infinity) or non-positive value disables the backstop;
+    // a finite value beyond Node's timer range is clamped to the max rather than
+    // silently coerced to ~1ms (which would kill every forked job immediately).
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return null
+
+    return Math.min(raw, MAX_FORKED_JOB_TIMEOUT_MS)
+  }
+
+  /**
+   * Fired when a forked runner overruns its timeout. Sends SIGTERM for a clean
+   * shutdown, then SIGKILL after the grace for a runner that ignores it. The
+   * resulting non-clean exit flows through `_handleForkedChildExit`, which frees
+   * the slot and reports the job failed.
+   * @param {object} args - Options.
+   * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
+   * @param {ForkedJobTimeoutState} args.state - Timeout state.
+   * @returns {void}
+   */
+  _onForkedJobTimeout({child, state}) {
+    state.timedOut = true
+
+    try {
+      child.kill("SIGTERM")
+    } catch {
+      // Child already exited; nothing to do.
+    }
+
+    state.sigkillTimer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL")
+      } catch {
+        // Child already exited; nothing to do.
+      }
+    }, this.forkedChildSigkillGraceMs)
+  }
+
+  /**
+   * Cancels any pending timeout/SIGKILL timers for a forked runner that has
+   * exited (or errored) so they never fire against a gone or reused child.
+   * @param {ForkedJobTimeoutState} state - Timeout state.
+   * @returns {void}
+   */
+  _clearForkedJobTimeout(state) {
+    if (state.timer) {
+      clearTimeout(state.timer)
+      state.timer = null
+    }
+
+    if (state.sigkillTimer) {
+      clearTimeout(state.sigkillTimer)
+      state.sigkillTimer = null
+    }
+  }
+
   /**
    * Runs handle forked child exit.
    * @param {object} args - Options.
@@ -608,9 +725,10 @@ export default class BackgroundJobsWorker {
    * @param {keyof typeof import("node:os").constants.signals | null} args.signal - Exit signal.
    * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
    * @param {(value: void) => void} args.resolve - Promise resolver.
+   * @param {ForkedJobTimeoutState} [args.timeoutState] - Timeout state, when the runner had a wall-clock backstop.
    * @returns {void}
    */
-  _handleForkedChildExit({child, code, signal, payload, resolve}) {
+  _handleForkedChildExit({child, code, signal, payload, resolve, timeoutState}) {
     this.inflightProcessChildren.delete(child)
 
     // Free the worker slot as soon as the child is gone — never gate it on the
@@ -620,10 +738,11 @@ export default class BackgroundJobsWorker {
 
     if (this._forkedChildExitedCleanly({code, signal})) return
 
-    this._reportForkedChildFailure({
-      payload,
-      error: new Error(`Forked background job runner exited before reporting: code=${code} signal=${signal || "none"}`)
-    })
+    const error = timeoutState?.timedOut
+      ? new Error(`Forked background job runner timed out after ${timeoutState.timeoutMs}ms and was terminated: code=${code} signal=${signal || "none"}`)
+      : new Error(`Forked background job runner exited before reporting: code=${code} signal=${signal || "none"}`)
+
+    this._reportForkedChildFailure({payload, error})
   }
 
   /**

package/build/configuration-types.js

@@ -192,6 +192,15 @@
  *   to restore the legacy fixed-interval poll.
  * @property {number} [pollIntervalMs] - Poll interval in milliseconds. Only used
  *   when `dispatchStrategy === "polling"`. Default: `1000`.
+ * @property {number | null} [jobTimeoutMs] - Wall-clock backstop, in ms, for a
+ *   `"forked"` job runner. A forked job still running after this is terminated
+ *   (SIGTERM, then SIGKILL after the reaping grace) and reported failed, so a
+ *   single genuinely-hung runner can't pin a draining worker — and its full-app
+ *   boot and DB connections — indefinitely (e.g. across a deploy where a retired
+ *   worker drains in-flight jobs). This is a coarse safety net, not per-job
+ *   tuning: set it well above the longest legitimate forked job (build runners,
+ *   long imports) so only genuinely-stuck runners are killed. Omit, `null`, or
+ *   `<= 0` to disable (default), which preserves the prior unbounded behavior.
  * @property {BackgroundJobsRetentionConfiguration} [retention] - Retention/pruning
  *   of terminal job rows. Without pruning the jobs table grows unbounded
  *   (completed rows accumulate forever), which bloats storage and indexes and

package/build/configuration.js

@@ -1270,10 +1270,12 @@ export default class VelociousConfiguration {
     const envMaxConcurrentRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_MAX_CONCURRENT_INLINE_JOBS
     const envDispatchStrategy = process.env.VELOCIOUS_BACKGROUND_JOBS_DISPATCH_STRATEGY
     const envPollIntervalRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_POLL_INTERVAL_MS
+    const envJobTimeoutRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_JOB_TIMEOUT_MS
     const envPort = envPortRaw ? Number(envPortRaw) : undefined
     const envMaxConcurrentForked = envMaxConcurrentForkedRaw ? Number(envMaxConcurrentForkedRaw) : undefined
     const envMaxConcurrent = envMaxConcurrentRaw ? Number(envMaxConcurrentRaw) : undefined
     const envPollInterval = envPollIntervalRaw ? Number(envPollIntervalRaw) : undefined
+    const envJobTimeout = envJobTimeoutRaw ? Number(envJobTimeoutRaw) : undefined
     const configured = this._backgroundJobs || {}
     const host = configured.host || envHost || "127.0.0.1"
     const port = typeof configured.port === "number"
@@ -1292,6 +1294,12 @@ export default class VelociousConfiguration {
       ? configured.pollIntervalMs
       : (typeof envPollInterval === "number" && Number.isFinite(envPollInterval) && envPollInterval >= 1 ? envPollInterval : 1000)
     const queues = configured.queues && typeof configured.queues === "object" ? configured.queues : {}
+    // An explicit config value wins over the env var — including `null`/`0`,
+    // which disable the backstop even when the environment sets a default.
+    // Only fall through to the env var when config omits `jobTimeoutMs` entirely.
+    const jobTimeoutMs = "jobTimeoutMs" in configured
+      ? (typeof configured.jobTimeoutMs === "number" && configured.jobTimeoutMs > 0 ? configured.jobTimeoutMs : null)
+      : (typeof envJobTimeout === "number" && Number.isFinite(envJobTimeout) && envJobTimeout > 0 ? envJobTimeout : null)
     const configuredRetention = configured.retention && typeof configured.retention === "object" ? configured.retention : {}
     const retention = {
       completedTtlMs: typeof configuredRetention.completedTtlMs === "number" || configuredRetention.completedTtlMs === null
@@ -1308,7 +1316,7 @@ export default class VelociousConfiguration {
         : 60 * 60 * 1000
     }
 
-    return {host, port, databaseIdentifier, maxConcurrentForkedJobs, maxConcurrentInlineJobs, dispatchStrategy, pollIntervalMs, queues, retention}
+    return {host, port, databaseIdentifier, maxConcurrentForkedJobs, maxConcurrentInlineJobs, dispatchStrategy, pollIntervalMs, queues, jobTimeoutMs, retention}
   }
 
   /**

package/build/environment-handlers/node/cli/commands/background-jobs-main.js

@@ -3,6 +3,9 @@ import BackgroundJobsMain from "../../../../background-jobs/main.js"
 
 export default class BackgroundJobsMainCommand extends BaseCommand {
   async execute() {
+    // Identify this process in `ps`/`top` instead of a generic "node" entry.
+    process.title = "velocious background-jobs-main"
+
     const main = new BackgroundJobsMain({configuration: this.getConfiguration()})
     await main.start()
 

package/build/environment-handlers/node/cli/commands/background-jobs-runner.js

@@ -16,6 +16,10 @@ export default class BackgroundJobsRunnerCommand extends BaseCommand {
       process.once(signal, () => process.exit(0))
     }
 
+    // Base title; runJobPayload sets the per-job title (from the job class's
+    // `static processTitle`) for the duration of the job and restores this after.
+    process.title = "velocious background-jobs-runner"
+
     const decoded = Buffer.from(payload, "base64").toString("utf8")
     const jobPayload = JSON.parse(decoded)
 

package/build/environment-handlers/node/cli/commands/background-jobs-worker.js

@@ -27,6 +27,9 @@ function resolveShutdownTimeoutMs() {
 
 export default class BackgroundJobsWorkerCommand extends BaseCommand {
   async execute() {
+    // Identify this process in `ps`/`top` instead of a generic "node" entry.
+    process.title = "velocious background-jobs-worker"
+
     const worker = new BackgroundJobsWorker({configuration: this.getConfiguration()})
     await worker.start()
 

package/build/environment-handlers/node/cli/commands/beacon.js

@@ -3,6 +3,9 @@ import BeaconServer from "../../../../beacon/server.js"
 
 export default class BeaconCommand extends BaseCommand {
   async execute() {
+    // Identify this process in `ps`/`top` instead of a generic "node" entry.
+    process.title = "velocious beacon"
+
     const beacon = new BeaconServer({configuration: this.getConfiguration()})
     await beacon.start()
 

package/build/environment-handlers/node/cli/commands/server.js

@@ -133,6 +133,9 @@ export default class VelociousCliCommandsServer extends BaseCommand{
    * @returns {Promise<void>} - Starts the HTTP server and waits until it stops.
    */
   async execute() {
+    // Identify this process in `ps`/`top` instead of a generic "node" entry.
+    process.title = "velocious server"
+
     const parsedProcessArgs = this.args?.parsedProcessArgs || {}
     const configuration = this.getConfiguration()
     const httpServer = httpServerConfigFromParsedArgs(parsedProcessArgs, configuration.httpServer)

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

@@ -1,5 +1,10 @@
 // @ts-check
 import runJobPayload from "./job-runner.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
+// job name once one arrives (see runJobMessage), so operators can see exactly
+// which jobs are running, how many of each, and which are eating resources.
+process.title = "velocious background-jobs-runner";
 let finishing = false;
 /**
  * Runs is job message.
@@ -42,6 +47,9 @@ async function runJobMessage(message) {
     if (!isJobMessage(message)) {
         throw new Error("Forked background job runner received invalid payload");
     }
+    // The per-job process title (and its restore) is set inside runJobPayload,
+    // which reads the job class's `static processTitle`. This process boots with
+    // the base "velocious background-jobs-runner" title set at module load above.
     await runJobPayload(message.payload, { closeConnections: false });
 }
 /**
@@ -71,4 +79,4 @@ process.once("disconnect", () => {
 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/job-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AAiDA;;;;;;GAMG;AACH,+CALW,OAAO,YAAY,EAAE,oBAAoB,yBAEjD;IAA0B,gBAAgB;CAC1C,GAAU,OAAO,CAAC,IAAI,CAAC,CA0DzB"}
+{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AAgEA;;;;;;GAMG;AACH,+CALW,OAAO,YAAY,EAAE,oBAAoB,yBAEjD;IAA0B,gBAAgB;CAC1C,GAAU,OAAO,CAAC,IAAI,CAAC,CAkEzB"}