velocious 1.0.529 → 1.0.530

package/README.md

@@ -1977,6 +1977,7 @@ export default new Configuration({
     maxConcurrentForkedJobs: 4,
     maxConcurrentInlineJobs: 4,
     pooledRunnerCount: 4,
+    pooledRunnerConcurrency: 1,
     pooledRunnerMaxJobs: 100,
     pooledRunnerMaxRssBytes: 536870912,
     pooledRunnerMaxLifetimeMs: 3600000,
@@ -2008,7 +2009,7 @@ VELOCIOUS_BACKGROUND_JOBS_JOB_TIMEOUT_MS=5400000
 
 `maxConcurrentInlineJobs` (default: `4`) caps how many `executionMode: "inline"` jobs a single `background-jobs-worker` process runs in parallel. Concurrency is at the JS event-loop level: every job in flight shares the worker's process and DB connection pool, so the cap should fit the pool, not the CPU count. Forking remains the right tool when you need memory isolation across long-running jobs or want to use more cores. The older `forked: false` option still maps to inline mode.
 
-New jobs default to `executionMode: "pooled"`: a worker runs them serially in warm, reusable Node child runners. `pooledRunnerCount` (default: `4`) bounds this independent per-worker capacity. It and `pooledRunnerMaxJobs` must be finite positive integers; the RSS and lifetime limits must be finite positive numbers. A child is recycled after an acknowledged job when it reaches `pooledRunnerMaxJobs` (default: `100`), `pooledRunnerMaxRssBytes` (default: `536870912`, or 512 MiB), or `pooledRunnerMaxLifetimeMs` (default: `3600000`, or one hour). Pooled rows remain readable by older mains during rolling upgrades and run there with legacy one-shot fork behavior. `forked: true` remains an explicit alias for `"forked"`; `forked: false` remains inline. See [execution modes and pooled runners](docs/background-jobs.md#execution-modes-and-pooled-runners).
+New jobs default to `executionMode: "pooled"`: a worker runs them in warm, reusable Node child runners. `pooledRunnerCount` (default: `4`) bounds this independent per-worker pool, and `pooledRunnerConcurrency` (default: `1`) sets how many jobs each child runs at once on its own event loop, so total pooled capacity is `pooledRunnerCount × pooledRunnerConcurrency` — raise concurrency for I/O-bound jobs to get high throughput from a bounded, isolated set of processes. `pooledRunnerCount`, `pooledRunnerConcurrency`, and `pooledRunnerMaxJobs` must be finite positive integers; the RSS and lifetime limits must be finite positive numbers. A child is recycled after an acknowledged job when it reaches `pooledRunnerMaxJobs` (default: `100`), `pooledRunnerMaxRssBytes` (default: `536870912`, or 512 MiB), or `pooledRunnerMaxLifetimeMs` (default: `3600000`, or one hour). Pooled rows remain readable by older mains during rolling upgrades and run there with legacy one-shot fork behavior. `forked: true` remains an explicit alias for `"forked"`; `forked: false` remains inline. See [execution modes and pooled runners](docs/background-jobs.md#execution-modes-and-pooled-runners).
 
 `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.
 

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

@@ -78,9 +78,10 @@ function runnerProcessTitle(JobClass, payload) {
  * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
  * @param {object} [options] - Runner options.
  * @param {boolean} [options.closeConnections] - Whether to gracefully close framework connections after the job.
+ * @param {boolean} [options.manageProcessTitle] - Whether to set the per-job process title and restore it afterwards. Off for concurrent pooled runners, where interleaved snapshot/restore of the single process-wide `process.title` would corrupt it; the pooled child owns an aggregate title instead.
  * @returns {Promise<void>} - Resolves when complete.
  */
-export default async function runJobPayload(payload, {closeConnections = true} = {}) {
+export default async function runJobPayload(payload, {closeConnections = true, manageProcessTitle = true} = {}) {
   const configuration = await configurationResolver()
   configuration.setCurrent()
   await configuration.initialize({type: "background-jobs-runner"})
@@ -98,8 +99,9 @@ export default async function runJobPayload(payload, {closeConnections = true} =
 
   // 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.
+  // Skipped for concurrent pooled runners, whose child owns an aggregate title.
   const previousTitle = process.title
-  process.title = runnerProcessTitle(JobClass, payload)
+  if (manageProcessTitle) process.title = runnerProcessTitle(JobClass, payload)
 
   try {
     try {
@@ -136,7 +138,7 @@ 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 (manageProcessTitle) process.title = previousTitle
     if (closeConnections) {
       try {
         await configuration.disconnectBeacon()

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

@@ -3,8 +3,32 @@
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js"
 import setRunnerProcessTitle from "./runner-process-title.js"
 
+const BASE_PROCESS_TITLE = "velocious background-jobs-runner"
+
 setRunnerProcessTitle()
-let running = false
+
+/**
+ * Ids of jobs currently running in this child. A pooled child runs up to
+ * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that
+ * bound); the set dedupes a redelivered job id and lets each job settle
+ * independently.
+ * @type {Set<string>}
+ */
+const runningJobIds = new Set()
+
+/**
+ * Sets an aggregate process title from the current in-flight count. A child runs
+ * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and
+ * restore around a single job) cannot represent the process — interleaved
+ * completions would leave a stale label. Recomputing from `runningJobIds.size` is
+ * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.
+ * @returns {void}
+ */
+function updateProcessTitle() {
+  const count = runningJobIds.size
+
+  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? "job" : "jobs"}` : BASE_PROCESS_TITLE
+}
 
 /**
  * Checks whether an IPC value is a runnable pooled job message.
@@ -46,33 +70,46 @@ function sendOutcome({jobId, acknowledged, status, error}) {
 }
 
 /**
- * Handles one serial job message.
- * @param {?} message - IPC message.
+ * Runs one job concurrently with any siblings and reports its own terminal
+ * outcome. A single job's unexpected failure reports that job for reclamation
+ * (`acknowledged: false`) but does NOT take down the child — its concurrent
+ * siblings keep running. Only a process-level fault (which escapes every
+ * per-job try/catch) ends the child, which the worker sees as an exit and
+ * reclaims for the whole in-flight set.
+ * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Job payload.
  * @returns {Promise<void>} - Resolves after reporting.
  */
-async function handleMessage(message) {
-  if (running || !isJobMessage(message)) return
-
-  running = true
+async function runJob(payload) {
   try {
-    await runJobPayload(message.payload, {closeConnections: false})
-    await sendOutcome({jobId: message.payload.id, acknowledged: true, status: "completed"})
+    await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})
+    await sendOutcome({jobId: payload.id, acknowledged: true, status: "completed"})
   } catch (error) {
     if (error instanceof BackgroundJobPerformedFailure) {
-      await sendOutcome({jobId: message.payload.id, acknowledged: true, status: "failed"})
+      await sendOutcome({jobId: payload.id, acknowledged: true, status: "failed"})
     } else {
       const reportError = error instanceof Error ? error : new Error(String(error))
       console.error("Pooled background job runner failed before terminal acknowledgement:", reportError)
-      await sendOutcome({jobId: message.payload.id, acknowledged: false, error: reportError})
-      process.exitCode = 1
-      if (process.disconnect) process.disconnect()
-      setImmediate(() => process.exit(1))
+      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})
     }
   } finally {
-    running = false
+    runningJobIds.delete(payload.id)
+    updateProcessTitle()
   }
 }
 
-process.on("message", (message) => { void handleMessage(message) })
+/**
+ * Handles a job message, starting it alongside any concurrent siblings.
+ * @param {?} message - IPC message.
+ * @returns {void}
+ */
+function handleMessage(message) {
+  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return
+
+  runningJobIds.add(message.payload.id)
+  updateProcessTitle()
+  void runJob(message.payload)
+}
+
+process.on("message", (message) => handleMessage(message))
 process.once("disconnect", () => process.exit(0))
 for (const signal of ["SIGTERM", "SIGINT"]) process.once(signal, () => process.exit(1))

package/build/background-jobs/worker.js

@@ -66,6 +66,7 @@ export default class BackgroundJobsWorker {
    * @param {number} [args.maxConcurrentForkedJobs] - Override the process runner concurrency cap from `configuration.getBackgroundJobsConfig()`.
    * @param {number} [args.maxConcurrentInlineJobs] - Override the inline-job concurrency cap from `configuration.getBackgroundJobsConfig()`.
    * @param {number} [args.pooledRunnerCount] - Override the pooled runner count.
+   * @param {number} [args.pooledRunnerConcurrency] - Override the per-runner concurrency.
    * @param {number} [args.pooledRunnerMaxJobs] - Override the per-runner recycle job count.
    * @param {number} [args.pooledRunnerMaxRssBytes] - Override the per-runner recycle RSS limit.
    * @param {number} [args.pooledRunnerMaxLifetimeMs] - Override the per-runner recycle lifetime.
@@ -73,7 +74,7 @@ export default class BackgroundJobsWorker {
    * @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, pooledRunnerCount, pooledRunnerMaxJobs, pooledRunnerMaxRssBytes, pooledRunnerMaxLifetimeMs, forkedChildSigkillGraceMs, heartbeatIntervalMs, jobTimeoutMs} = {}) {
+  constructor({configuration, host, port, maxConcurrentForkedJobs, maxConcurrentInlineJobs, pooledRunnerCount, pooledRunnerConcurrency, pooledRunnerMaxJobs, pooledRunnerMaxRssBytes, pooledRunnerMaxLifetimeMs, forkedChildSigkillGraceMs, heartbeatIntervalMs, jobTimeoutMs} = {}) {
     /**
      * Narrows the runtime value to the documented type.
      * @type {Promise<import("../configuration.js").default>} */
@@ -110,10 +111,12 @@ export default class BackgroundJobsWorker {
      * @type {number} */
     this.maxConcurrentForkedJobs = this.maxConcurrentForkedJobsOverride || 4
     this.pooledRunnerCountOverride = positiveInteger(pooledRunnerCount)
+    this.pooledRunnerConcurrencyOverride = positiveInteger(pooledRunnerConcurrency)
     this.pooledRunnerMaxJobsOverride = positiveInteger(pooledRunnerMaxJobs)
     this.pooledRunnerMaxRssBytesOverride = positiveNumber(pooledRunnerMaxRssBytes)
     this.pooledRunnerMaxLifetimeMsOverride = positiveNumber(pooledRunnerMaxLifetimeMs)
     this.pooledRunnerCount = this.pooledRunnerCountOverride || 4
+    this.pooledRunnerConcurrency = this.pooledRunnerConcurrencyOverride || 1
     this.pooledRunnerMaxJobs = this.pooledRunnerMaxJobsOverride || 100
     this.pooledRunnerMaxRssBytes = this.pooledRunnerMaxRssBytesOverride || 512 * 1024 * 1024
     this.pooledRunnerMaxLifetimeMs = this.pooledRunnerMaxLifetimeMsOverride || 60 * 60 * 1000
@@ -183,7 +186,7 @@ export default class BackgroundJobsWorker {
     this.inflightPooledJobs = new Set()
     /** @type {Set<import("node:child_process").ChildProcess>} */
     this.pooledChildren = new Set()
-    /** @type {Map<import("node:child_process").ChildProcess, {createdAtMs: number, jobsRun: number, payload?: import("./types.js").BackgroundJobPayload & {id: string}, resolve?: (value: void) => void, settling?: boolean}>} */
+    /** @type {Map<import("node:child_process").ChildProcess, {createdAtMs: number, jobsRun: number, inflight: Map<string, {payload: import("./types.js").BackgroundJobPayload & {id: string}, resolve?: (value: void) => void}>, retiring: boolean, settling?: boolean}>} */
     this.pooledChildStates = new Map()
   }
 
@@ -210,6 +213,7 @@ export default class BackgroundJobsWorker {
     }
     const poolConfig = this.configuration.getBackgroundJobsConfig()
     if (typeof this.pooledRunnerCountOverride !== "number") this.pooledRunnerCount = poolConfig.pooledRunnerCount
+    if (typeof this.pooledRunnerConcurrencyOverride !== "number") this.pooledRunnerConcurrency = poolConfig.pooledRunnerConcurrency
     if (typeof this.pooledRunnerMaxJobsOverride !== "number") this.pooledRunnerMaxJobs = poolConfig.pooledRunnerMaxJobs
     if (typeof this.pooledRunnerMaxRssBytesOverride !== "number") this.pooledRunnerMaxRssBytes = poolConfig.pooledRunnerMaxRssBytes
     if (typeof this.pooledRunnerMaxLifetimeMsOverride !== "number") this.pooledRunnerMaxLifetimeMs = poolConfig.pooledRunnerMaxLifetimeMs
@@ -582,7 +586,7 @@ export default class BackgroundJobsWorker {
   _readyMessage() {
     const acceptsProcessJob = this.inflightProcessJobs.size < this.maxConcurrentForkedJobs
     const acceptsInline = this.inflightInlineJobs.size < this.maxConcurrentInlineJobs
-    const acceptsPooled = this.inflightPooledJobs.size < this.pooledRunnerCount
+    const acceptsPooled = this._availablePooledSlots() > 0
 
     if (!acceptsProcessJob && !acceptsInline && !acceptsPooled) return null
 
@@ -612,23 +616,54 @@ export default class BackgroundJobsWorker {
   }
 
   /**
-   * Runs a payload in an idle pooled child.
+   * Free pooled slots across the pool: open slots in non-retiring children plus
+   * the slots we could add by spawning more children up to `pooledRunnerCount`.
+   * Retiring children (draining before replacement) never contribute capacity.
+   * @returns {number} - Number of pooled jobs the worker can accept right now.
+   */
+  _availablePooledSlots() {
+    let openInExisting = 0
+    let nonRetiringChildren = 0
+
+    for (const child of this.pooledChildren) {
+      const state = this.pooledChildStates.get(child)
+      if (!state || state.retiring) continue
+      nonRetiringChildren += 1
+      openInExisting += this.pooledRunnerConcurrency - state.inflight.size
+    }
+
+    const spawnableChildren = Math.max(0, this.pooledRunnerCount - nonRetiringChildren)
+
+    return openInExisting + spawnableChildren * this.pooledRunnerConcurrency
+  }
+
+  /**
+   * Runs a payload on a pooled child with a free concurrency slot, spawning a
+   * new child when every non-retiring child is full and the pool is below
+   * `pooledRunnerCount`. Each child runs up to `pooledRunnerConcurrency` jobs at
+   * once on its own event loop.
    * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Job payload.
    * @returns {Promise<void>} - Resolves after the durable report.
    */
   _runPooledJob(payload) {
-    let child = [...this.pooledChildren].find((candidate) => !this.pooledChildStates.get(candidate)?.payload)
+    let child
+    for (const candidate of this.pooledChildren) {
+      const state = this.pooledChildStates.get(candidate)
+      if (state && !state.retiring && state.inflight.size < this.pooledRunnerConcurrency) {
+        child = candidate
+        break
+      }
+    }
     if (!child) child = this._createPooledChild()
     const state = this.pooledChildStates.get(child)
     if (!state) throw new Error("Pooled runner state missing")
 
     return new Promise((resolve) => {
-      state.payload = payload
-      state.resolve = resolve
+      state.inflight.set(payload.id, {payload, resolve})
       try {
         child.send({type: "job", payload})
       } catch (error) {
-        this._handlePooledChildFailure({child, error})
+        void this._handlePooledChildFailure({child, error})
       }
     })
   }
@@ -647,7 +682,7 @@ export default class BackgroundJobsWorker {
     })
     this.pooledChildren.add(child)
     this.inflightProcessChildren.add(child)
-    this.pooledChildStates.set(child, {createdAtMs: Date.now(), jobsRun: 0})
+    this.pooledChildStates.set(child, {createdAtMs: Date.now(), jobsRun: 0, inflight: new Map(), retiring: false})
     child.on("message", (message) => this._handlePooledChildMessage({child, message}))
     child.once("exit", (code, signal) => this._handlePooledChildFailure({child, error: new Error(`Pooled background job runner exited: code=${code} signal=${signal || "none"}`)}))
     child.once("error", (error) => this._handlePooledChildFailure({child, error}))
@@ -655,7 +690,8 @@ export default class BackgroundJobsWorker {
   }
 
   /**
-   * Handles a pooled child's durable-report acknowledgement.
+   * Handles a pooled child's per-job durable-report acknowledgement. A child
+   * runs jobs concurrently and reports one `job-outcome` per job id.
    * @param {object} args - Message details.
    * @param {import("node:child_process").ChildProcess} args.child - Pooled child.
    * @param {?} args.message - IPC message.
@@ -665,23 +701,70 @@ export default class BackgroundJobsWorker {
     if (!message || typeof message !== "object") return
     const record = /** @type {{type?: ?, jobId?: ?, acknowledged?: ?, rssBytes?: ?, error?: ?}} */ (message)
     const state = this.pooledChildStates.get(child)
-    if (record.type !== "job-outcome" || !state?.payload || record.jobId !== state.payload.id || state.settling) return
-    if (record.acknowledged !== true) {
-      void this._handlePooledChildFailure({child, error: new Error(typeof record.error === "string" ? record.error : "Pooled runner terminal report was not acknowledged")})
-      return
-    }
-    const resolve = state.resolve
-    state.payload = undefined
-    state.resolve = undefined
+    if (record.type !== "job-outcome" || !state || state.settling || typeof record.jobId !== "string") return
+    const entry = state.inflight.get(record.jobId)
+    if (!entry) return
+
+    state.inflight.delete(record.jobId)
     state.jobsRun += 1
-    if (resolve) resolve(undefined)
+    const resolve = entry.resolve
+
+    if (record.acknowledged === true) {
+      if (resolve) resolve(undefined)
+    } else {
+      // The child stayed alive but could not confirm this one job's terminal
+      // report; reclaim just this job — its concurrent siblings are unaffected.
+      void this._reportJobResult({
+        jobId: entry.payload.id,
+        status: "failed",
+        error: new Error(typeof record.error === "string" ? record.error : "Pooled runner terminal report was not acknowledged"),
+        handoffId: entry.payload.handoffId,
+        handedOffAtMs: entry.payload.handedOffAtMs,
+        workerId: entry.payload.workerId || this.workerId
+      }).finally(() => { if (resolve) resolve(undefined) })
+    }
+
     const rssBytes = typeof record.rssBytes === "number" ? record.rssBytes : Number.POSITIVE_INFINITY
     const runnerAgeMs = Date.now() - state.createdAtMs
-    if (state.jobsRun >= this.pooledRunnerMaxJobs || rssBytes >= this.pooledRunnerMaxRssBytes || runnerAgeMs >= this.pooledRunnerMaxLifetimeMs || this.shouldStop) this._retirePooledChild(child)
+    if (!state.retiring && (state.jobsRun >= this.pooledRunnerMaxJobs || rssBytes >= this.pooledRunnerMaxRssBytes || runnerAgeMs >= this.pooledRunnerMaxLifetimeMs || this.shouldStop)) {
+      this._beginRetirePooledChild(child)
+    }
+    this._terminateIfDrained(child)
+  }
+
+  /**
+   * Marks a pooled child for retirement and eagerly spawns a single replacement
+   * (1-for-1) so its capacity is restored immediately without waiting for it to
+   * finish draining. The retiring child stops receiving new jobs and is
+   * terminated only once its in-flight set drains, so a long-running job (e.g. a
+   * build) is never cut off.
+   * @param {import("node:child_process").ChildProcess} child - Child to retire.
+   * @returns {void}
+   */
+  _beginRetirePooledChild(child) {
+    const state = this.pooledChildStates.get(child)
+    if (!state || state.retiring) return
+
+    state.retiring = true
+    // Best-effort pre-warm: skip when stopping (no new work) or before the
+    // worker is initialized (no configuration to fork a child from).
+    if (!this.shouldStop && this.configuration) this._createPooledChild()
+  }
+
+  /**
+   * Terminates a retiring pooled child once it has no in-flight jobs left.
+   * @param {import("node:child_process").ChildProcess} child - Child to check.
+   * @returns {void}
+   */
+  _terminateIfDrained(child) {
+    const state = this.pooledChildStates.get(child)
+    if (!state || !state.retiring || state.inflight.size > 0) return
+
+    this._retirePooledChild(child)
   }
 
   /**
-   * Retires an idle pooled child.
+   * Retires a drained pooled child (removes it from tracking, then SIGTERMs it).
    * @param {import("node:child_process").ChildProcess} child - Child process to retire.
    * @returns {void}
    */
@@ -693,7 +776,11 @@ export default class BackgroundJobsWorker {
   }
 
   /**
-   * Removes and reports an unhealthy pooled child.
+   * Removes an exited/unhealthy pooled child and reports every job that was
+   * in-flight on it as failed — a process-level crash's blast radius is the
+   * child's whole in-flight set. Capacity is refilled lazily on the next
+   * dispatch (a spawnable slot is still advertised), avoiding a tight respawn
+   * loop when a child crashes on startup.
    * @param {object} args - Failure details.
    * @param {import("node:child_process").ChildProcess} args.child - Pooled child.
    * @param {?} args.error - Failure.
@@ -705,21 +792,22 @@ export default class BackgroundJobsWorker {
     if (state) state.settling = true
     this.pooledChildren.delete(child)
     this.inflightProcessChildren.delete(child)
-    if (!state?.payload) {
-      this.pooledChildStates.delete(child)
-      return
-    }
-    const payload = state.payload
-    await this._reportJobResult({
-      jobId: payload.id,
-      status: "failed",
-      error,
-      handoffId: payload.handoffId,
-      handedOffAtMs: payload.handedOffAtMs,
-      workerId: payload.workerId || this.workerId
-    })
+
+    const entries = state ? [...state.inflight.values()] : []
+    if (state) state.inflight.clear()
     this.pooledChildStates.delete(child)
-    if (state.resolve) state.resolve(undefined)
+
+    await Promise.allSettled(entries.map(async (entry) => {
+      await this._reportJobResult({
+        jobId: entry.payload.id,
+        status: "failed",
+        error,
+        handoffId: entry.payload.handoffId,
+        handedOffAtMs: entry.payload.handedOffAtMs,
+        workerId: entry.payload.workerId || this.workerId
+      })
+      if (entry.resolve) entry.resolve(undefined)
+    }))
   }
 
   /**

package/build/configuration-types.js

@@ -165,6 +165,7 @@
  *   for workload-shaped limits use per-queue caps (`queues`) instead, which are
  *   enforced cluster-wide and are immune to duplicate worker processes.
  * @property {number} [pooledRunnerCount] - Number of warm, reusable child runners owned by each worker. Pooled capacity is separate from inline and forked/spawned capacity. Default: `4`.
+ * @property {number} [pooledRunnerConcurrency] - Number of jobs each pooled child runs concurrently on its own event loop. Total per-worker pooled capacity is `pooledRunnerCount × pooledRunnerConcurrency`. `1` (default) keeps each child serial; raise it for I/O-bound jobs so a bounded set of isolated processes handles high concurrency (like the inline lane) without one process per concurrent job. Default: `1`.
  * @property {number} [pooledRunnerMaxJobs] - Number of sequential jobs a pooled child runs before it is replaced, bounding process-level resource accumulation. Default: `100`.
  * @property {number} [pooledRunnerMaxRssBytes] - RSS bytes after an acknowledged job at which a pooled child is replaced. Default: `536870912` (512 MiB).
  * @property {number} [pooledRunnerMaxLifetimeMs] - Age after an acknowledged job at which a pooled child is replaced. Default: `3600000` (one hour).

package/build/configuration.js

@@ -192,6 +192,12 @@ export default class VelociousConfiguration {
     }
 
     this._isInitialized = false
+    /**
+     * In-progress `initialize()` promise, memoized so concurrent callers await
+     * the same bootstrap. Reset to undefined if initialization fails.
+     * @type {Promise<void> | undefined}
+     */
+    this._initializePromise = undefined
     this.httpServer = httpServer || {}
     /**
      * Stores the http server instance value.
@@ -1269,6 +1275,7 @@ export default class VelociousConfiguration {
     const envMaxConcurrentForkedRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_MAX_CONCURRENT_FORKED_JOBS
     const envMaxConcurrentRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_MAX_CONCURRENT_INLINE_JOBS
     const envPooledRunnerCountRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_POOLED_RUNNER_COUNT
+    const envPooledRunnerConcurrencyRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_POOLED_RUNNER_CONCURRENCY
     const envPooledRunnerMaxJobsRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_POOLED_RUNNER_MAX_JOBS
     const envPooledRunnerMaxRssBytesRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_POOLED_RUNNER_MAX_RSS_BYTES
     const envPooledRunnerMaxLifetimeMsRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_POOLED_RUNNER_MAX_LIFETIME_MS
@@ -1279,6 +1286,7 @@ export default class VelociousConfiguration {
     const envMaxConcurrentForked = envMaxConcurrentForkedRaw ? Number(envMaxConcurrentForkedRaw) : undefined
     const envMaxConcurrent = envMaxConcurrentRaw ? Number(envMaxConcurrentRaw) : undefined
     const envPooledRunnerCount = envPooledRunnerCountRaw ? Number(envPooledRunnerCountRaw) : undefined
+    const envPooledRunnerConcurrency = envPooledRunnerConcurrencyRaw ? Number(envPooledRunnerConcurrencyRaw) : undefined
     const envPooledRunnerMaxJobs = envPooledRunnerMaxJobsRaw ? Number(envPooledRunnerMaxJobsRaw) : undefined
     const envPooledRunnerMaxRssBytes = envPooledRunnerMaxRssBytesRaw ? Number(envPooledRunnerMaxRssBytesRaw) : undefined
     const envPooledRunnerMaxLifetimeMs = envPooledRunnerMaxLifetimeMsRaw ? Number(envPooledRunnerMaxLifetimeMsRaw) : undefined
@@ -1299,6 +1307,9 @@ export default class VelociousConfiguration {
     const pooledRunnerCount = typeof configured.pooledRunnerCount === "number" && Number.isFinite(configured.pooledRunnerCount) && Number.isInteger(configured.pooledRunnerCount) && configured.pooledRunnerCount >= 1
       ? configured.pooledRunnerCount
       : (!("pooledRunnerCount" in configured) && typeof envPooledRunnerCount === "number" && Number.isFinite(envPooledRunnerCount) && Number.isInteger(envPooledRunnerCount) && envPooledRunnerCount >= 1 ? envPooledRunnerCount : 4)
+    const pooledRunnerConcurrency = typeof configured.pooledRunnerConcurrency === "number" && Number.isFinite(configured.pooledRunnerConcurrency) && Number.isInteger(configured.pooledRunnerConcurrency) && configured.pooledRunnerConcurrency >= 1
+      ? configured.pooledRunnerConcurrency
+      : (!("pooledRunnerConcurrency" in configured) && typeof envPooledRunnerConcurrency === "number" && Number.isFinite(envPooledRunnerConcurrency) && Number.isInteger(envPooledRunnerConcurrency) && envPooledRunnerConcurrency >= 1 ? envPooledRunnerConcurrency : 1)
     const pooledRunnerMaxJobs = typeof configured.pooledRunnerMaxJobs === "number" && Number.isFinite(configured.pooledRunnerMaxJobs) && Number.isInteger(configured.pooledRunnerMaxJobs) && configured.pooledRunnerMaxJobs >= 1
       ? configured.pooledRunnerMaxJobs
       : (!("pooledRunnerMaxJobs" in configured) && typeof envPooledRunnerMaxJobs === "number" && Number.isFinite(envPooledRunnerMaxJobs) && Number.isInteger(envPooledRunnerMaxJobs) && envPooledRunnerMaxJobs >= 1 ? envPooledRunnerMaxJobs : 100)
@@ -1336,7 +1347,7 @@ export default class VelociousConfiguration {
         : 60 * 60 * 1000
     }
 
-    return {host, port, databaseIdentifier, maxConcurrentForkedJobs, maxConcurrentInlineJobs, pooledRunnerCount, pooledRunnerMaxJobs, pooledRunnerMaxRssBytes, pooledRunnerMaxLifetimeMs, dispatchStrategy, pollIntervalMs, queues, jobTimeoutMs, retention}
+    return {host, port, databaseIdentifier, maxConcurrentForkedJobs, maxConcurrentInlineJobs, pooledRunnerCount, pooledRunnerConcurrency, pooledRunnerMaxJobs, pooledRunnerMaxRssBytes, pooledRunnerMaxLifetimeMs, dispatchStrategy, pollIntervalMs, queues, jobTimeoutMs, retention}
   }
 
   /**
@@ -1934,9 +1945,16 @@ export default class VelociousConfiguration {
    * @returns {Promise<void>} - Resolves when complete.
    */
   async initialize({type} = {type: "undefined"}) {
-    if (!this.isInitialized()) {
-      this._isInitialized = true
-
+    if (this._isInitialized) return
+    // Memoize the in-progress initialization so concurrent callers await the same
+    // bootstrap instead of racing. `_isInitialized` was previously set to `true`
+    // up front, so a second caller (e.g. a pooled runner with
+    // `pooledRunnerConcurrency > 1` starting several jobs on a cold child) could
+    // skip initialization and load models / perform a job while the first call
+    // was still awaiting model discovery and initializers. Mirrors connectBeacon.
+    if (this._initializePromise) return await this._initializePromise
+
+    this._initializePromise = (async () => {
       await this.initializeModels({type})
       await this.getEnvironmentHandler().autoDiscoverResources(this)
       this._mergeDiscoveredAbilityResources()
@@ -1957,6 +1975,17 @@ export default class VelociousConfiguration {
           }
         }
       }
+
+      this._isInitialized = true
+    })()
+
+    try {
+      await this._initializePromise
+    } catch (error) {
+      // Let a later call retry a failed initialization instead of every future
+      // caller awaiting the same cached rejection.
+      this._initializePromise = undefined
+      throw error
     }
   }
 

package/build/src/background-jobs/job-runner.d.ts

@@ -3,10 +3,12 @@
  * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
  * @param {object} [options] - Runner options.
  * @param {boolean} [options.closeConnections] - Whether to gracefully close framework connections after the job.
+ * @param {boolean} [options.manageProcessTitle] - Whether to set the per-job process title and restore it afterwards. Off for concurrent pooled runners, where interleaved snapshot/restore of the single process-wide `process.title` would corrupt it; the pooled child owns an aggregate title instead.
  * @returns {Promise<void>} - Resolves when complete.
  */
-export default function runJobPayload(payload: import("./types.js").BackgroundJobPayload, { closeConnections }?: {
+export default function runJobPayload(payload: import("./types.js").BackgroundJobPayload, { closeConnections, manageProcessTitle }?: {
     closeConnections?: boolean | undefined;
+    manageProcessTitle?: boolean | undefined;
 }): Promise<void>;
 export class BackgroundJobPerformedFailure extends Error {
     /**

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":"AA2EA;;;;;;GAMG;AACH,+CALW,OAAO,YAAY,EAAE,oBAAoB,yBAEjD;IAA0B,gBAAgB;CAC1C,GAAU,OAAO,CAAC,IAAI,CAAC,CAmEzB;AA3ID;IACE;;;OAGG;IACH,mBAFW,KAAK,EAKf;CACF"}
+{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AA2EA;;;;;;;GAOG;AACH,+CANW,OAAO,YAAY,EAAE,oBAAoB,6CAEjD;IAA0B,gBAAgB;IAChB,kBAAkB;CAC5C,GAAU,OAAO,CAAC,IAAI,CAAC,CAoEzB;AA7ID;IACE;;;OAGG;IACH,mBAFW,KAAK,EAKf;CACF"}

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

@@ -68,9 +68,10 @@ function runnerProcessTitle(JobClass, payload) {
  * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
  * @param {object} [options] - Runner options.
  * @param {boolean} [options.closeConnections] - Whether to gracefully close framework connections after the job.
+ * @param {boolean} [options.manageProcessTitle] - Whether to set the per-job process title and restore it afterwards. Off for concurrent pooled runners, where interleaved snapshot/restore of the single process-wide `process.title` would corrupt it; the pooled child owns an aggregate title instead.
  * @returns {Promise<void>} - Resolves when complete.
  */
-export default async function runJobPayload(payload, { closeConnections = true } = {}) {
+export default async function runJobPayload(payload, { closeConnections = true, manageProcessTitle = true } = {}) {
     const configuration = await configurationResolver();
     configuration.setCurrent();
     await configuration.initialize({ type: "background-jobs-runner" });
@@ -86,8 +87,10 @@ export default async function runJobPayload(payload, { closeConnections = true }
     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.
+    // Skipped for concurrent pooled runners, whose child owns an aggregate title.
     const previousTitle = process.title;
-    process.title = runnerProcessTitle(JobClass, payload);
+    if (manageProcessTitle)
+        process.title = runnerProcessTitle(JobClass, payload);
     try {
         try {
             await configuration.withConnections({ name: `Background job runner: ${payload.jobName}` }, async () => {
@@ -123,7 +126,8 @@ 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 (manageProcessTitle)
+            process.title = previousTitle;
         if (closeConnections) {
             try {
                 await configuration.disconnectBeacon();
@@ -134,4 +138,4 @@ export default async function runJobPayload(payload, { closeConnections = true }
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-runner.js","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,qBAAqB,MAAM,8BAA8B,CAAA;AAChE,OAAO,qBAAqB,MAAM,mBAAmB,CAAA;AACrD,OAAO,4BAA4B,MAAM,sBAAsB,CAAA;AAE/D,MAAM,uBAAuB,GAAG,IAAI,CAAA;AAEpC,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IACtD;;;OAGG;IACH,YAAY,KAAK;QACf,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,EAAC,KAAK,EAAC,CAAC,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAA;IAC7C,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,aAAa,EAAE,KAAK;IAClD,MAAM,WAAW,GAAG,aAAa,CAAC,cAAc,EAAE,CAAA;IAClD,MAAM,eAAe,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IACjF,MAAM,OAAO,GAAG;QACd,OAAO,EAAE,EAAC,QAAQ,EAAE,wBAAwB,EAAE,KAAK,EAAE,cAAc,EAAC;QACpE,KAAK,EAAE,eAAe;KACvB,CAAA;IACD,MAAM,WAAW,GAAG,WAAW,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,CAAC;WAC/D,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAE/C,WAAW,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAA;IAC5C,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,EAAC,GAAG,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAC,CAAC,CAAA;IAEzE,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,CAAC,KAAK,CAAC,kDAAkD,eAAe,CAAC,OAAO,EAAE,CAAC,CAAA;IAC5F,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,aAAa,CAAC,aAAa;IACxC,MAAM,YAAY,GAAG,MAAM,aAAa,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAE,wBAAwB,EAAC,CAAC,CAAA;IAE5F,IAAI,CAAC,YAAY;QAAE,OAAM;IAEzB,IAAI,CAAC;QACH,MAAM,YAAY,CAAC,YAAY,CAAC,EAAC,SAAS,EAAE,uBAAuB,EAAC,CAAC,CAAA;IACvE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,sBAAsB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;IAC9C,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,QAAQ,EAAE,OAAO;IAC3C,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAA;IAEtC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAA;IAExE,OAAO,yBAAyB,OAAO,CAAC,OAAO,EAAE,CAAA;AACnD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,CAAC,OAAO,EAAE,EAAC,gBAAgB,GAAG,IAAI,EAAC,GAAG,EAAE;IACjF,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;IACnD,aAAa,CAAC,UAAU,EAAE,CAAA;IAC1B,MAAM,aAAa,CAAC,UAAU,CAAC,EAAC,IAAI,EAAE,wBAAwB,EAAC,CAAC,CAAA;IAChE,MAAM,aAAa,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,QAAQ,GAAG,IAAI,4BAA4B,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;IAElE,MAAM,QAAQ,GAAG,IAAI,qBAAqB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;IAC3D,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;IACrB,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IACvD,MAAM,WAAW,GAAG,IAAI,QAAQ,EAAE,CAAA;IAClC;;sDAEkD;IAClD,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAA;IAEnC,4EAA4E;IAC5E,0EAA0E;IAC1E,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,CAAA;IACnC,OAAO,CAAC,KAAK,GAAG,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;IAErD,IAAI,CAAC;QACH,IAAI,CAAC;YACH,MAAM,aAAa,CAAC,eAAe,CAAC,EAAC,IAAI,EAAE,0BAA0B,OAAO,CAAC,OAAO,EAAE,EAAC,EAAE,KAAK,IAAI,EAAE;gBAClG,MAAM,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;YACtD,CAAC,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,cAAc,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAChF,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;gBACf,MAAM,QAAQ,CAAC,eAAe,CAAC;oBAC7B,KAAK,EAAE,OAAO,CAAC,EAAE;oBACjB,MAAM,EAAE,QAAQ;oBAChB,KAAK,EAAE,cAAc;oBACrB,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,aAAa,EAAE,OAAO,CAAC,aAAa;oBACpC,aAAa,EAAE,KAAK;iBACrB,CAAC,CAAA;YACJ,CAAC;YAED,MAAM,IAAI,6BAA6B,CAAC,cAAc,CAAC,CAAA;QACzD,CAAC;QAED,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;YACf,MAAM,QAAQ,CAAC,eAAe,CAAC;gBAC7B,KAAK,EAAE,OAAO,CAAC,EAAE;gBACjB,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,aAAa,EAAE,KAAK;aACrB,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;YAAS,CAAC;QACT,0EAA0E;QAC1E,0DAA0D;QAC1D,OAAO,CAAC,KAAK,GAAG,aAAa,CAAA;QAC7B,IAAI,gBAAgB,EAAE,CAAC;YACrB,IAAI,CAAC;gBACH,MAAM,aAAa,CAAC,gBAAgB,EAAE,CAAA;YACxC,CAAC;oBAAS,CAAC;gBACT,MAAM,aAAa,CAAC,wBAAwB,EAAE,CAAA;YAChD,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["// @ts-check\n\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobRegistry from \"./job-registry.js\"\nimport BackgroundJobsStatusReporter from \"./status-reporter.js\"\n\nconst BEACON_READY_TIMEOUT_MS = 5000\n\nexport class BackgroundJobPerformedFailure extends Error {\n  /**\n   * Creates a performed-job failure after its terminal report is acknowledged.\n   * @param {Error} cause - A job perform error whose failed terminal report was acknowledged.\n   */\n  constructor(cause) {\n    super(cause.message, {cause})\n    this.name = \"BackgroundJobPerformedFailure\"\n  }\n}\n\n/**\n * Runs report beacon ready error.\n * @param {import(\"../configuration.js\").default} configuration - Configuration.\n * @param {?} error - Beacon readiness error.\n * @returns {void}\n */\nfunction reportBeaconReadyError(configuration, error) {\n  const errorEvents = configuration.getErrorEvents()\n  const normalizedError = error instanceof Error ? error : new Error(String(error))\n  const payload = {\n    context: {peerType: \"background-jobs-runner\", stage: \"beacon-ready\"},\n    error: normalizedError\n  }\n  const hasListener = errorEvents.listenerCount(\"framework-error\") > 0\n    || errorEvents.listenerCount(\"all-error\") > 0\n\n  errorEvents.emit(\"framework-error\", payload)\n  errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n\n  if (!hasListener) {\n    console.error(`[velocious framework-error stage=beacon-ready] ${normalizedError.message}`)\n  }\n}\n\n/**\n * Runs connect beacon.\n * @param {import(\"../configuration.js\").default} configuration - Configuration.\n * @returns {Promise<void>}\n */\nasync function connectBeacon(configuration) {\n  const beaconClient = await configuration.connectBeacon({peerType: \"background-jobs-runner\"})\n\n  if (!beaconClient) return\n\n  try {\n    await beaconClient.waitForReady({timeoutMs: BEACON_READY_TIMEOUT_MS})\n  } catch (error) {\n    reportBeaconReadyError(configuration, error)\n  }\n}\n\n/**\n * Resolves the process title to show while a job runs: the job class's declared\n * `static processTitle`, else a `velocious job-runner: <JobName>` fallback.\n * @param {typeof import(\"./job.js\").default} JobClass - Resolved job class.\n * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n * @returns {string} - Process title.\n */\nfunction runnerProcessTitle(JobClass, payload) {\n  const declared = JobClass.processTitle\n\n  if (typeof declared === \"string\" && declared.length > 0) return declared\n\n  return `velocious job-runner: ${payload.jobName}`\n}\n\n/**\n * Runs run job payload.\n * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n * @param {object} [options] - Runner options.\n * @param {boolean} [options.closeConnections] - Whether to gracefully close framework connections after the job.\n * @returns {Promise<void>} - Resolves when complete.\n */\nexport default async function runJobPayload(payload, {closeConnections = true} = {}) {\n  const configuration = await configurationResolver()\n  configuration.setCurrent()\n  await configuration.initialize({type: \"background-jobs-runner\"})\n  await connectBeacon(configuration)\n  const reporter = new BackgroundJobsStatusReporter({configuration})\n\n  const registry = new BackgroundJobRegistry({configuration})\n  await registry.load()\n  const JobClass = registry.getJobByName(payload.jobName)\n  const jobInstance = new JobClass()\n  /**\n   * Perform.\n   * @type {(...args: Array<?>) => Promise<void>} */\n  const perform = jobInstance.perform\n\n  // Name the process after the job it is running so `ps`/`top` show what each\n  // runner is doing; restored in the `finally` below when the job finishes.\n  const previousTitle = process.title\n  process.title = runnerProcessTitle(JobClass, payload)\n\n  try {\n    try {\n      await configuration.withConnections({name: `Background job runner: ${payload.jobName}`}, async () => {\n        await perform.apply(jobInstance, payload.args || [])\n      })\n    } catch (error) {\n      const performedError = error instanceof Error ? error : new Error(String(error))\n      if (payload.id) {\n        await reporter.reportWithRetry({\n          jobId: payload.id,\n          status: \"failed\",\n          error: performedError,\n          handoffId: payload.handoffId,\n          workerId: payload.workerId,\n          handedOffAtMs: payload.handedOffAtMs,\n          maxDurationMs: 30000\n        })\n      }\n\n      throw new BackgroundJobPerformedFailure(performedError)\n    }\n\n    if (payload.id) {\n      await reporter.reportWithRetry({\n        jobId: payload.id,\n        status: \"completed\",\n        handoffId: payload.handoffId,\n        workerId: payload.workerId,\n        handedOffAtMs: payload.handedOffAtMs,\n        maxDurationMs: 30000\n      })\n    }\n  } finally {\n    // Restore the runner's base title so a lingering/idle runner (or a reused\n    // one) doesn't misreport a finished job as still running.\n    process.title = previousTitle\n    if (closeConnections) {\n      try {\n        await configuration.disconnectBeacon()\n      } finally {\n        await configuration.closeDatabaseConnections()\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-runner.js","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,qBAAqB,MAAM,8BAA8B,CAAA;AAChE,OAAO,qBAAqB,MAAM,mBAAmB,CAAA;AACrD,OAAO,4BAA4B,MAAM,sBAAsB,CAAA;AAE/D,MAAM,uBAAuB,GAAG,IAAI,CAAA;AAEpC,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IACtD;;;OAGG;IACH,YAAY,KAAK;QACf,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,EAAC,KAAK,EAAC,CAAC,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAA;IAC7C,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,aAAa,EAAE,KAAK;IAClD,MAAM,WAAW,GAAG,aAAa,CAAC,cAAc,EAAE,CAAA;IAClD,MAAM,eAAe,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IACjF,MAAM,OAAO,GAAG;QACd,OAAO,EAAE,EAAC,QAAQ,EAAE,wBAAwB,EAAE,KAAK,EAAE,cAAc,EAAC;QACpE,KAAK,EAAE,eAAe;KACvB,CAAA;IACD,MAAM,WAAW,GAAG,WAAW,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,CAAC;WAC/D,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAE/C,WAAW,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAA;IAC5C,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,EAAC,GAAG,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAC,CAAC,CAAA;IAEzE,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,CAAC,KAAK,CAAC,kDAAkD,eAAe,CAAC,OAAO,EAAE,CAAC,CAAA;IAC5F,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,aAAa,CAAC,aAAa;IACxC,MAAM,YAAY,GAAG,MAAM,aAAa,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAE,wBAAwB,EAAC,CAAC,CAAA;IAE5F,IAAI,CAAC,YAAY;QAAE,OAAM;IAEzB,IAAI,CAAC;QACH,MAAM,YAAY,CAAC,YAAY,CAAC,EAAC,SAAS,EAAE,uBAAuB,EAAC,CAAC,CAAA;IACvE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,sBAAsB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;IAC9C,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,QAAQ,EAAE,OAAO;IAC3C,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAA;IAEtC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAA;IAExE,OAAO,yBAAyB,OAAO,CAAC,OAAO,EAAE,CAAA;AACnD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,CAAC,OAAO,EAAE,EAAC,gBAAgB,GAAG,IAAI,EAAE,kBAAkB,GAAG,IAAI,EAAC,GAAG,EAAE;IAC5G,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;IACnD,aAAa,CAAC,UAAU,EAAE,CAAA;IAC1B,MAAM,aAAa,CAAC,UAAU,CAAC,EAAC,IAAI,EAAE,wBAAwB,EAAC,CAAC,CAAA;IAChE,MAAM,aAAa,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,QAAQ,GAAG,IAAI,4BAA4B,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;IAElE,MAAM,QAAQ,GAAG,IAAI,qBAAqB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;IAC3D,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;IACrB,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IACvD,MAAM,WAAW,GAAG,IAAI,QAAQ,EAAE,CAAA;IAClC;;sDAEkD;IAClD,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAA;IAEnC,4EAA4E;IAC5E,0EAA0E;IAC1E,8EAA8E;IAC9E,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,CAAA;IACnC,IAAI,kBAAkB;QAAE,OAAO,CAAC,KAAK,GAAG,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;IAE7E,IAAI,CAAC;QACH,IAAI,CAAC;YACH,MAAM,aAAa,CAAC,eAAe,CAAC,EAAC,IAAI,EAAE,0BAA0B,OAAO,CAAC,OAAO,EAAE,EAAC,EAAE,KAAK,IAAI,EAAE;gBAClG,MAAM,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;YACtD,CAAC,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,cAAc,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAChF,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;gBACf,MAAM,QAAQ,CAAC,eAAe,CAAC;oBAC7B,KAAK,EAAE,OAAO,CAAC,EAAE;oBACjB,MAAM,EAAE,QAAQ;oBAChB,KAAK,EAAE,cAAc;oBACrB,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,aAAa,EAAE,OAAO,CAAC,aAAa;oBACpC,aAAa,EAAE,KAAK;iBACrB,CAAC,CAAA;YACJ,CAAC;YAED,MAAM,IAAI,6BAA6B,CAAC,cAAc,CAAC,CAAA;QACzD,CAAC;QAED,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;YACf,MAAM,QAAQ,CAAC,eAAe,CAAC;gBAC7B,KAAK,EAAE,OAAO,CAAC,EAAE;gBACjB,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,aAAa,EAAE,KAAK;aACrB,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;YAAS,CAAC;QACT,0EAA0E;QAC1E,0DAA0D;QAC1D,IAAI,kBAAkB;YAAE,OAAO,CAAC,KAAK,GAAG,aAAa,CAAA;QACrD,IAAI,gBAAgB,EAAE,CAAC;YACrB,IAAI,CAAC;gBACH,MAAM,aAAa,CAAC,gBAAgB,EAAE,CAAA;YACxC,CAAC;oBAAS,CAAC;gBACT,MAAM,aAAa,CAAC,wBAAwB,EAAE,CAAA;YAChD,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["// @ts-check\n\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobRegistry from \"./job-registry.js\"\nimport BackgroundJobsStatusReporter from \"./status-reporter.js\"\n\nconst BEACON_READY_TIMEOUT_MS = 5000\n\nexport class BackgroundJobPerformedFailure extends Error {\n  /**\n   * Creates a performed-job failure after its terminal report is acknowledged.\n   * @param {Error} cause - A job perform error whose failed terminal report was acknowledged.\n   */\n  constructor(cause) {\n    super(cause.message, {cause})\n    this.name = \"BackgroundJobPerformedFailure\"\n  }\n}\n\n/**\n * Runs report beacon ready error.\n * @param {import(\"../configuration.js\").default} configuration - Configuration.\n * @param {?} error - Beacon readiness error.\n * @returns {void}\n */\nfunction reportBeaconReadyError(configuration, error) {\n  const errorEvents = configuration.getErrorEvents()\n  const normalizedError = error instanceof Error ? error : new Error(String(error))\n  const payload = {\n    context: {peerType: \"background-jobs-runner\", stage: \"beacon-ready\"},\n    error: normalizedError\n  }\n  const hasListener = errorEvents.listenerCount(\"framework-error\") > 0\n    || errorEvents.listenerCount(\"all-error\") > 0\n\n  errorEvents.emit(\"framework-error\", payload)\n  errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n\n  if (!hasListener) {\n    console.error(`[velocious framework-error stage=beacon-ready] ${normalizedError.message}`)\n  }\n}\n\n/**\n * Runs connect beacon.\n * @param {import(\"../configuration.js\").default} configuration - Configuration.\n * @returns {Promise<void>}\n */\nasync function connectBeacon(configuration) {\n  const beaconClient = await configuration.connectBeacon({peerType: \"background-jobs-runner\"})\n\n  if (!beaconClient) return\n\n  try {\n    await beaconClient.waitForReady({timeoutMs: BEACON_READY_TIMEOUT_MS})\n  } catch (error) {\n    reportBeaconReadyError(configuration, error)\n  }\n}\n\n/**\n * Resolves the process title to show while a job runs: the job class's declared\n * `static processTitle`, else a `velocious job-runner: <JobName>` fallback.\n * @param {typeof import(\"./job.js\").default} JobClass - Resolved job class.\n * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n * @returns {string} - Process title.\n */\nfunction runnerProcessTitle(JobClass, payload) {\n  const declared = JobClass.processTitle\n\n  if (typeof declared === \"string\" && declared.length > 0) return declared\n\n  return `velocious job-runner: ${payload.jobName}`\n}\n\n/**\n * Runs run job payload.\n * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n * @param {object} [options] - Runner options.\n * @param {boolean} [options.closeConnections] - Whether to gracefully close framework connections after the job.\n * @param {boolean} [options.manageProcessTitle] - Whether to set the per-job process title and restore it afterwards. Off for concurrent pooled runners, where interleaved snapshot/restore of the single process-wide `process.title` would corrupt it; the pooled child owns an aggregate title instead.\n * @returns {Promise<void>} - Resolves when complete.\n */\nexport default async function runJobPayload(payload, {closeConnections = true, manageProcessTitle = true} = {}) {\n  const configuration = await configurationResolver()\n  configuration.setCurrent()\n  await configuration.initialize({type: \"background-jobs-runner\"})\n  await connectBeacon(configuration)\n  const reporter = new BackgroundJobsStatusReporter({configuration})\n\n  const registry = new BackgroundJobRegistry({configuration})\n  await registry.load()\n  const JobClass = registry.getJobByName(payload.jobName)\n  const jobInstance = new JobClass()\n  /**\n   * Perform.\n   * @type {(...args: Array<?>) => Promise<void>} */\n  const perform = jobInstance.perform\n\n  // Name the process after the job it is running so `ps`/`top` show what each\n  // runner is doing; restored in the `finally` below when the job finishes.\n  // Skipped for concurrent pooled runners, whose child owns an aggregate title.\n  const previousTitle = process.title\n  if (manageProcessTitle) process.title = runnerProcessTitle(JobClass, payload)\n\n  try {\n    try {\n      await configuration.withConnections({name: `Background job runner: ${payload.jobName}`}, async () => {\n        await perform.apply(jobInstance, payload.args || [])\n      })\n    } catch (error) {\n      const performedError = error instanceof Error ? error : new Error(String(error))\n      if (payload.id) {\n        await reporter.reportWithRetry({\n          jobId: payload.id,\n          status: \"failed\",\n          error: performedError,\n          handoffId: payload.handoffId,\n          workerId: payload.workerId,\n          handedOffAtMs: payload.handedOffAtMs,\n          maxDurationMs: 30000\n        })\n      }\n\n      throw new BackgroundJobPerformedFailure(performedError)\n    }\n\n    if (payload.id) {\n      await reporter.reportWithRetry({\n        jobId: payload.id,\n        status: \"completed\",\n        handoffId: payload.handoffId,\n        workerId: payload.workerId,\n        handedOffAtMs: payload.handedOffAtMs,\n        maxDurationMs: 30000\n      })\n    }\n  } finally {\n    // Restore the runner's base title so a lingering/idle runner (or a reused\n    // one) doesn't misreport a finished job as still running.\n    if (manageProcessTitle) process.title = previousTitle\n    if (closeConnections) {\n      try {\n        await configuration.disconnectBeacon()\n      } finally {\n        await configuration.closeDatabaseConnections()\n      }\n    }\n  }\n}\n"]}