velocious 1.0.522 → 1.0.524

package/README.md

@@ -2118,7 +2118,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 +2133,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

@@ -386,9 +386,9 @@ export default class BackgroundJobsWorker {
     inflight = this._runInlineJobAndReport(payload).finally(() => {
       this.inflightInlineJobs.delete(inflight)
 
-      if (!this.shouldStop && this.inflightInlineJobs.size === this.maxConcurrentInlineJobs - 1) {
-        this._sendReadyIfRunning()
-      }
+      // Re-announce on every completion below cap, not just the cap→cap-1 edge —
+      // see _trackProcessJob for why the knife-edge condition silently wedges.
+      if (!this.shouldStop) this._sendReadyIfRunning()
     })
 
     this.inflightInlineJobs.add(inflight)
@@ -439,9 +439,16 @@ export default class BackgroundJobsWorker {
     inflight = processJob.finally(() => {
       this.inflightProcessJobs.delete(inflight)
 
-      if (!this.shouldStop && this.inflightProcessJobs.size === this.maxConcurrentForkedJobs - 1) {
-        this._sendReadyIfRunning()
-      }
+      // Re-announce readiness on EVERY completion that leaves us below cap — not
+      // just the single cap→cap-1 edge. The main removes a worker from its ready
+      // set on each dispatch (`_drainOnce`) and only re-adds it on a fresh
+      // "ready"; gating the re-announce on one knife-edge transition means a
+      // single missed or lost signal leaves the worker out of the ready set and
+      // wedges dispatch cluster-wide. This was the silent-freeze root cause.
+      // `_sendReadyIfRunning` self-guards (it sends nothing when the worker is
+      // genuinely at capacity), so re-announcing on every freed slot is safe and
+      // idempotent on the main.
+      if (!this.shouldStop) this._sendReadyIfRunning()
     })
 
     this.inflightProcessJobs.add(inflight)

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

@@ -74,8 +74,19 @@ export default class VelociousDatabaseDriversMysql extends Base{
    * @returns {Promise<void>} - Resolves when complete.
    */
   async setConnectionCheckoutName(name) {
-    await this.query(`SET @velocious_connection_checkout_name = ${name === undefined ? "NULL" : this.quote(name)}`, {logName: "Set Connection Checkout Name", processListComment: false, sessionTimeZone: false})
+    const previousName = this._connectionCheckoutName
+
     await super.setConnectionCheckoutName(name)
+
+    if (name === undefined) {
+      if (previousName !== undefined) {
+        await this.query("SET @velocious_connection_checkout_name = NULL", {logName: "Clear Connection Checkout Name", processListComment: false, sessionTimeZone: false})
+      }
+
+      return
+    }
+
+    await this.query(`SET @velocious_connection_checkout_name = ${this.quote(name)}`, {logName: "Set Connection Checkout Name", processListComment: false, sessionTimeZone: false})
   }
 
   /**
@@ -83,7 +94,10 @@ export default class VelociousDatabaseDriversMysql extends Base{
    * @returns {Promise<void>} - Resolves when complete.
    */
   async clearConnectionCheckoutName() {
-    await this.query("SET @velocious_connection_checkout_name = NULL", {logName: "Clear Connection Checkout Name", processListComment: false, sessionTimeZone: false})
+    if (this._connectionCheckoutName !== undefined) {
+      await this.query("SET @velocious_connection_checkout_name = NULL", {logName: "Clear Connection Checkout Name", processListComment: false, sessionTimeZone: false})
+    }
+
     await super.clearConnectionCheckoutName()
   }
 

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"}

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

@@ -40,6 +40,19 @@ async function connectBeacon(configuration) {
         reportBeaconReadyError(configuration, error);
     }
 }
+/**
+ * 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.
@@ -61,6 +74,10 @@ export default async function runJobPayload(payload, { closeConnections = true }
      * Perform.
      * @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 () => {
@@ -93,6 +110,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();
@@ -103,4 +123,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":"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","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\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 * 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  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      if (payload.id) {\n        await reporter.reportWithRetry({\n          jobId: payload.id,\n          status: \"failed\",\n          error,\n          handoffId: payload.handoffId,\n          workerId: payload.workerId,\n          handedOffAtMs: payload.handedOffAtMs,\n          maxDurationMs: 30000\n        })\n      }\n\n      throw error\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    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":"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","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\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      if (payload.id) {\n        await reporter.reportWithRetry({\n          jobId: payload.id,\n          status: \"failed\",\n          error,\n          handoffId: payload.handoffId,\n          workerId: payload.workerId,\n          handedOffAtMs: payload.handedOffAtMs,\n          maxDurationMs: 30000\n        })\n      }\n\n      throw error\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"]}

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

@@ -17,6 +17,17 @@ export default class VelociousJob<TArgs extends Array<unknown> = []> {
      * @type {string | undefined}
      */
     static queue: string | 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: string | undefined;
     /**
      * Runs job name.
      * @returns {string} - Job name.

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

@@ -1 +1 @@
-{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kCAFyB,KAAK,SAAhB,KAAK,CAAC,OAAC,CAAE;IAGrB;;;;;;OAMG;IACH,cAFU,MAAM,GAAG,SAAS,CAEJ;IAExB;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,2BAHW,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,GACnD,OAAO,YAAY,EAAE,oBAAoB,CAUrD;IAED;;;;OAIG;IACH,6BAHc,OAAC,EAAA,GACF,OAAO,CAAC,MAAM,CAAC,CAW3B;IAED;;;;;;OAMG;IACH,kDAJG;QAAuB,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;;OAIG;IACH,kCAHW,KAAK,CAAC,OAAC,CAAC,GACN;QAAC,OAAO,EAAE,KAAK,CAAC,OAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,CAgBtF;IAED;;;;OAIG;IACH,kBAHW,KAAK,GACH,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kCAFyB,KAAK,SAAhB,KAAK,CAAC,OAAC,CAAE;IAGrB;;;;;;OAMG;IACH,cAFU,MAAM,GAAG,SAAS,CAEJ;IAExB;;;;;;;;;OASG;IACH,qBAFU,MAAM,GAAG,SAAS,CAEG;IAE/B;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,2BAHW,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,GACnD,OAAO,YAAY,EAAE,oBAAoB,CAUrD;IAED;;;;OAIG;IACH,6BAHc,OAAC,EAAA,GACF,OAAO,CAAC,MAAM,CAAC,CAW3B;IAED;;;;;;OAMG;IACH,kDAJG;QAAuB,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;;OAIG;IACH,kCAHW,KAAK,CAAC,OAAC,CAAC,GACN;QAAC,OAAO,EAAE,KAAK,CAAC,OAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,CAgBtF;IAED;;;;OAIG;IACH,kBAHW,KAAK,GACH,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}

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

@@ -19,6 +19,17 @@ export default class VelociousJob {
      * @type {string | undefined}
      */
     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.
@@ -94,4 +105,4 @@ export default class VelociousJob {
         throw new Error("perform not implemented");
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiam9iLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2JhY2tncm91bmQtam9icy9qb2IuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sb0JBQW9CLE1BQU0sYUFBYSxDQUFBO0FBRTlDOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sWUFBWTtJQUMvQjs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsS0FBSyxHQUFHLFNBQVMsQ0FBQTtJQUV4Qjs7O09BR0c7SUFDSCxNQUFNLENBQUMsT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQTtJQUNsQixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLE9BQU87UUFDdkIsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFDLEdBQUcsT0FBTyxFQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQTtRQUUxQyxJQUFJLE1BQU0sQ0FBQyxLQUFLLEtBQUssU0FBUyxJQUFJLE9BQU8sSUFBSSxDQUFDLEtBQUssS0FBSyxRQUFRLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDMUYsTUFBTSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFBO1FBQzNCLENBQUM7UUFFRCxPQUFPLE1BQU0sQ0FBQTtJQUNmLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsR0FBRyxJQUFJO1FBQy9CLE1BQU0sRUFBQyxPQUFPLEVBQUUsVUFBVSxFQUFDLEdBQUcsSUFBSSxDQUFDLG9CQUFvQixDQUFDLElBQUksQ0FBQyxDQUFBO1FBQzdELE1BQU0sTUFBTSxHQUFHLElBQUksb0JBQW9CLEVBQUUsQ0FBQTtRQUV6QyxPQUFPLE1BQU0sTUFBTSxDQUFDLE9BQU8sQ0FBQztZQUMxQixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRTtZQUN2QixJQUFJLEVBQUUsT0FBTztZQUNiLE9BQU8sRUFBRSxJQUFJLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQztTQUNyQyxDQUFDLENBQUE7SUFDSixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBQyx1QkFBdUIsQ0FBQyxFQUFDLElBQUksRUFBRSxPQUFPLEVBQUM7UUFDbEQsTUFBTSxNQUFNLEdBQUcsSUFBSSxvQkFBb0IsRUFBRSxDQUFBO1FBRXpDLE9BQU8sTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDO1lBQzFCLE9BQU8sRUFBRSxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ3ZCLElBQUk7WUFDSixPQUFPLEVBQUUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUM7U0FDbEMsQ0FBQyxDQUFBO0lBQ0osQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsb0JBQW9CLENBQUMsSUFBSTtRQUM5QixJQUFJLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDdEIsT0FBTyxFQUFDLE9BQU8sRUFBRSxFQUFFLEVBQUUsVUFBVSxFQUFFLEVBQUUsRUFBQyxDQUFBO1FBQ3RDLENBQUM7UUFFRCxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQTtRQUNyQyxNQUFNLFlBQVksR0FBRyxPQUFPLElBQUksT0FBTyxPQUFPLEtBQUssUUFBUSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxZQUFZLElBQUksT0FBTyxDQUFBO1FBRWpILElBQUksWUFBWSxFQUFFLENBQUM7WUFDakIsTUFBTSxFQUFDLFVBQVUsRUFBQyxHQUFHLHNFQUFzRSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUE7WUFDckcsT0FBTyxFQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLFVBQVUsRUFBRSxVQUFVLElBQUksRUFBRSxFQUFDLENBQUE7UUFDbkUsQ0FBQztRQUVELE9BQU8sRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxFQUFFLEVBQUMsQ0FBQTtJQUN4QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILEtBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxLQUFLO1FBQ3BCLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQTtJQUM1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCBCYWNrZ3JvdW5kSm9ic0NsaWVudCBmcm9tIFwiLi9jbGllbnQuanNcIlxuXG4vKipcbiAqIEJhc2UgY2xhc3MgZm9yIGJhY2tncm91bmQgam9icy5cbiAqXG4gKiBgVEFyZ3NgIGlzIHRoZSB0dXBsZSBvZiBhcmd1bWVudHMgdGhlIHN1YmNsYXNzJ3MgYHBlcmZvcm1gIGFjY2VwdHMsIHNvIGEgam9iIHRoYXRcbiAqIG5lZWRzIGFyZ3VtZW50cyBkZWNsYXJlcyB0aGVtIGFzIHJlcXVpcmVkIGFuZCB0eXBlZCDigJQgZm9yIGV4YW1wbGVcbiAqIGBjbGFzcyBSdW5CdWlsZEpvYiBleHRlbmRzIFZlbG9jaW91c0pvYjxbc3RyaW5nXT5gIHdpdGggYGFzeW5jIHBlcmZvcm0oYnVpbGRJZClgLlxuICogVGhlIGRlZmF1bHQgZW1wdHkgdHVwbGUga2VlcHMgYXJndW1lbnQtbGVzcyBqb2JzIChgZXh0ZW5kcyBWZWxvY2lvdXNKb2JgLFxuICogYGFzeW5jIHBlcmZvcm0oKWApIHdvcmtpbmcgdW5jaGFuZ2VkLlxuICogQHRlbXBsYXRlIHtBcnJheTw/Pn0gW1RBcmdzPVtdXVxuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNKb2Ige1xuICAvKipcbiAgICogUXVldWUgdGhpcyBqb2IgY2xhc3MgcnVucyBvbi4gU3ViY2xhc3NlcyBzZXQgZS5nLiBgc3RhdGljIHF1ZXVlID0gXCJidWlsZHNcImBcbiAgICogdG8gcm91dGUgb250byBhIHF1ZXVlIHdpdGggaXRzIG93biBjbHVzdGVyLXdpZGUgY29uY3VycmVuY3kgY2FwIChjb25maWd1cmVkXG4gICAqIHZpYSBgYmFja2dyb3VuZEpvYnMucXVldWVzYCkuIFRoZSBge3F1ZXVlfWAgZW5xdWV1ZSBvcHRpb24gb3ZlcnJpZGVzIGl0LlxuICAgKiBMZWZ0IHVuZGVmaW5lZCwgam9icyBydW4gb24gdGhlIGBcImRlZmF1bHRcImAgcXVldWUuXG4gICAqIEB0eXBlIHtzdHJpbmcgfCB1bmRlZmluZWR9XG4gICAqL1xuICBzdGF0aWMgcXVldWUgPSB1bmRlZmluZWRcblxuICAvKipcbiAgICogUnVucyBqb2IgbmFtZS5cbiAgICogQHJldHVybnMge3N0cmluZ30gLSBKb2IgbmFtZS5cbiAgICovXG4gIHN0YXRpYyBqb2JOYW1lKCkge1xuICAgIHJldHVybiB0aGlzLm5hbWVcbiAgfVxuXG4gIC8qKlxuICAgKiBGb2xkcyB0aGlzIGpvYiBjbGFzcydzIHN0YXRpYyBgcXVldWVgIGludG8gdGhlIGVucXVldWUgb3B0aW9ucyB1bmxlc3MgdGhlXG4gICAqIGNhbGxlciBhbHJlYWR5IHNwZWNpZmllZCBvbmUuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi90eXBlcy5qc1wiKS5CYWNrZ3JvdW5kSm9iT3B0aW9ucyB8IHVuZGVmaW5lZH0gb3B0aW9ucyAtIEpvYiBvcHRpb25zLlxuICAgKiBAcmV0dXJucyB7aW1wb3J0KFwiLi90eXBlcy5qc1wiKS5CYWNrZ3JvdW5kSm9iT3B0aW9uc30gLSBPcHRpb25zIGluY2x1ZGluZyB0aGUgcmVzb2x2ZWQgcXVldWUuXG4gICAqL1xuICBzdGF0aWMgX3dpdGhRdWV1ZShvcHRpb25zKSB7XG4gICAgY29uc3QgbWVyZ2VkID0gb3B0aW9ucyA/IHsuLi5vcHRpb25zfSA6IHt9XG5cbiAgICBpZiAobWVyZ2VkLnF1ZXVlID09PSB1bmRlZmluZWQgJiYgdHlwZW9mIHRoaXMucXVldWUgPT09IFwic3RyaW5nXCIgJiYgdGhpcy5xdWV1ZS5sZW5ndGggPiAwKSB7XG4gICAgICBtZXJnZWQucXVldWUgPSB0aGlzLnF1ZXVlXG4gICAgfVxuXG4gICAgcmV0dXJuIG1lcmdlZFxuICB9XG5cbiAgLyoqXG4gICAqIFJ1bnMgcGVyZm9ybSBsYXRlci5cbiAgICogQHBhcmFtIHsuLi4/fSBhcmdzIC0gSm9iIGFyZ3MuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHN0cmluZz59IC0gSm9iIGlkLlxuICAgKi9cbiAgc3RhdGljIGFzeW5jIHBlcmZvcm1MYXRlciguLi5hcmdzKSB7XG4gICAgY29uc3Qge2pvYkFyZ3MsIGpvYk9wdGlvbnN9ID0gdGhpcy5fc3BsaXRBcmdzQW5kT3B0aW9ucyhhcmdzKVxuICAgIGNvbnN0IGNsaWVudCA9IG5ldyBCYWNrZ3JvdW5kSm9ic0NsaWVudCgpXG5cbiAgICByZXR1cm4gYXdhaXQgY2xpZW50LmVucXVldWUoe1xuICAgICAgam9iTmFtZTogdGhpcy5qb2JOYW1lKCksXG4gICAgICBhcmdzOiBqb2JBcmdzLFxuICAgICAgb3B0aW9uczogdGhpcy5fd2l0aFF1ZXVlKGpvYk9wdGlvbnMpXG4gICAgfSlcbiAgfVxuXG4gIC8qKlxuICAgKiBSdW5zIHBlcmZvcm0gbGF0ZXIgd2l0aCBvcHRpb25zLlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMuXG4gICAqIEBwYXJhbSB7QXJyYXk8Pz59IGFyZ3MuYXJncyAtIEpvYiBhcmdzLlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vdHlwZXMuanNcIikuQmFja2dyb3VuZEpvYk9wdGlvbnN9IFthcmdzLm9wdGlvbnNdIC0gSm9iIG9wdGlvbnMuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHN0cmluZz59IC0gSm9iIGlkLlxuICAgKi9cbiAgc3RhdGljIGFzeW5jIHBlcmZvcm1MYXRlcldpdGhPcHRpb25zKHthcmdzLCBvcHRpb25zfSkge1xuICAgIGNvbnN0IGNsaWVudCA9IG5ldyBCYWNrZ3JvdW5kSm9ic0NsaWVudCgpXG5cbiAgICByZXR1cm4gYXdhaXQgY2xpZW50LmVucXVldWUoe1xuICAgICAgam9iTmFtZTogdGhpcy5qb2JOYW1lKCksXG4gICAgICBhcmdzLFxuICAgICAgb3B0aW9uczogdGhpcy5fd2l0aFF1ZXVlKG9wdGlvbnMpXG4gICAgfSlcbiAgfVxuXG4gIC8qKlxuICAgKiBSdW5zIHNwbGl0IGFyZ3MgYW5kIG9wdGlvbnMuXG4gICAqIEBwYXJhbSB7QXJyYXk8Pz59IGFyZ3MgLSBKb2IgYXJncy5cbiAgICogQHJldHVybnMge3tqb2JBcmdzOiBBcnJheTw/Piwgam9iT3B0aW9uczogaW1wb3J0KFwiLi90eXBlcy5qc1wiKS5CYWNrZ3JvdW5kSm9iT3B0aW9uc319IC0gU3BsaXQgYXJncyBhbmQgb3B0aW9ucy5cbiAgICovXG4gIHN0YXRpYyBfc3BsaXRBcmdzQW5kT3B0aW9ucyhhcmdzKSB7XG4gICAgaWYgKGFyZ3MubGVuZ3RoID09PSAwKSB7XG4gICAgICByZXR1cm4ge2pvYkFyZ3M6IFtdLCBqb2JPcHRpb25zOiB7fX1cbiAgICB9XG5cbiAgICBjb25zdCBsYXN0QXJnID0gYXJnc1thcmdzLmxlbmd0aCAtIDFdXG4gICAgY29uc3QgaXNPcHRpb25zQXJnID0gbGFzdEFyZyAmJiB0eXBlb2YgbGFzdEFyZyA9PT0gXCJvYmplY3RcIiAmJiAhQXJyYXkuaXNBcnJheShsYXN0QXJnKSAmJiBcImpvYk9wdGlvbnNcIiBpbiBsYXN0QXJnXG5cbiAgICBpZiAoaXNPcHRpb25zQXJnKSB7XG4gICAgICBjb25zdCB7am9iT3B0aW9uc30gPSAvKiogQHR5cGUge3tqb2JPcHRpb25zOiBpbXBvcnQoXCIuL3R5cGVzLmpzXCIpLkJhY2tncm91bmRKb2JPcHRpb25zfX0gKi8gKGxhc3RBcmcpXG4gICAgICByZXR1cm4ge2pvYkFyZ3M6IGFyZ3Muc2xpY2UoMCwgLTEpLCBqb2JPcHRpb25zOiBqb2JPcHRpb25zIHx8IHt9fVxuICAgIH1cblxuICAgIHJldHVybiB7am9iQXJnczogYXJncywgam9iT3B0aW9uczoge319XG4gIH1cblxuICAvKipcbiAgICogT3ZlcnJpZGUgaW4gc3ViY2xhc3Nlcy5cbiAgICogQHBhcmFtIHtUQXJnc30gX2FyZ3MgLSBKb2IgYXJncyAodGhlIHR1cGxlIHRoaXMgam9iIGNsYXNzIHdhcyBwYXJhbWV0ZXJpemVkIHdpdGgpLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gLSBSZXNvbHZlcyB3aGVuIGNvbXBsZXRlLlxuICAgKi9cbiAgYXN5bmMgcGVyZm9ybSguLi5fYXJncykge1xuICAgIHRocm93IG5ldyBFcnJvcihcInBlcmZvcm0gbm90IGltcGxlbWVudGVkXCIpXG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.js","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,oBAAoB,MAAM,aAAa,CAAA;AAE9C;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,GAAG,SAAS,CAAA;IAExB;;;;;;;;;OASG;IACH,MAAM,CAAC,YAAY,GAAG,SAAS,CAAA;IAE/B;;;OAGG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO;QACvB,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAC,GAAG,OAAO,EAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAE1C,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1F,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;QAC3B,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI;QAC/B,MAAM,EAAC,OAAO,EAAE,UAAU,EAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAA;QAC7D,MAAM,MAAM,GAAG,IAAI,oBAAoB,EAAE,CAAA;QAEzC,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;YAC1B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE;YACvB,IAAI,EAAE,OAAO;YACb,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;SACrC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC;QAClD,MAAM,MAAM,GAAG,IAAI,oBAAoB,EAAE,CAAA;QAEzC,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;YAC1B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE;YACvB,IAAI;YACJ,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;SAClC,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,IAAI;QAC9B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAC,CAAA;QACtC,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QACrC,MAAM,YAAY,GAAG,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,YAAY,IAAI,OAAO,CAAA;QAEjH,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,EAAC,UAAU,EAAC,GAAG,sEAAsE,CAAC,CAAC,OAAO,CAAC,CAAA;YACrG,OAAO,EAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,IAAI,EAAE,EAAC,CAAA;QACnE,CAAC;QAED,OAAO,EAAC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAC,CAAA;IACxC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK;QACpB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAA;IAC5C,CAAC","sourcesContent":["// @ts-check\n\nimport BackgroundJobsClient from \"./client.js\"\n\n/**\n * Base class for background jobs.\n *\n * `TArgs` is the tuple of arguments the subclass's `perform` accepts, so a job that\n * needs arguments declares them as required and typed — for example\n * `class RunBuildJob extends VelociousJob<[string]>` with `async perform(buildId)`.\n * The default empty tuple keeps argument-less jobs (`extends VelociousJob`,\n * `async perform()`) working unchanged.\n * @template {Array<?>} [TArgs=[]]\n */\nexport default class VelociousJob {\n  /**\n   * Queue this job class runs on. Subclasses set e.g. `static queue = \"builds\"`\n   * to route onto a queue with its own cluster-wide concurrency cap (configured\n   * via `backgroundJobs.queues`). The `{queue}` enqueue option overrides it.\n   * Left undefined, jobs run on the `\"default\"` queue.\n   * @type {string | undefined}\n   */\n  static queue = undefined\n\n  /**\n   * Optional process title shown for the runner while this job executes.\n   * Velocious sets `process.title` to this for the duration of the job — so\n   * `ps`/`top`/`htop` identify what a runner is doing — and restores the\n   * runner's base title when the job finishes. Left undefined, the runner falls\n   * back to `velocious job-runner: <JobName>`. Set e.g.\n   * `static processTitle = \"velocious media transcoder\"` to give a job a\n   * custom, human-readable title.\n   * @type {string | undefined}\n   */\n  static processTitle = undefined\n\n  /**\n   * Runs job name.\n   * @returns {string} - Job name.\n   */\n  static jobName() {\n    return this.name\n  }\n\n  /**\n   * Folds this job class's static `queue` into the enqueue options unless the\n   * caller already specified one.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Options including the resolved queue.\n   */\n  static _withQueue(options) {\n    const merged = options ? {...options} : {}\n\n    if (merged.queue === undefined && typeof this.queue === \"string\" && this.queue.length > 0) {\n      merged.queue = this.queue\n    }\n\n    return merged\n  }\n\n  /**\n   * Runs perform later.\n   * @param {...?} args - Job args.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLater(...args) {\n    const {jobArgs, jobOptions} = this._splitArgsAndOptions(args)\n    const client = new BackgroundJobsClient()\n\n    return await client.enqueue({\n      jobName: this.jobName(),\n      args: jobArgs,\n      options: this._withQueue(jobOptions)\n    })\n  }\n\n  /**\n   * Runs perform later with options.\n   * @param {object} args - Options.\n   * @param {Array<?>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLaterWithOptions({args, options}) {\n    const client = new BackgroundJobsClient()\n\n    return await client.enqueue({\n      jobName: this.jobName(),\n      args,\n      options: this._withQueue(options)\n    })\n  }\n\n  /**\n   * Runs split args and options.\n   * @param {Array<?>} args - Job args.\n   * @returns {{jobArgs: Array<?>, jobOptions: import(\"./types.js\").BackgroundJobOptions}} - Split args and options.\n   */\n  static _splitArgsAndOptions(args) {\n    if (args.length === 0) {\n      return {jobArgs: [], jobOptions: {}}\n    }\n\n    const lastArg = args[args.length - 1]\n    const isOptionsArg = lastArg && typeof lastArg === \"object\" && !Array.isArray(lastArg) && \"jobOptions\" in lastArg\n\n    if (isOptionsArg) {\n      const {jobOptions} = /** @type {{jobOptions: import(\"./types.js\").BackgroundJobOptions}} */ (lastArg)\n      return {jobArgs: args.slice(0, -1), jobOptions: jobOptions || {}}\n    }\n\n    return {jobArgs: args, jobOptions: {}}\n  }\n\n  /**\n   * Override in subclasses.\n   * @param {TArgs} _args - Job args (the tuple this job class was parameterized with).\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async perform(..._args) {\n    throw new Error(\"perform not implemented\")\n  }\n}\n"]}

package/build/src/background-jobs/main.d.ts

@@ -169,6 +169,21 @@ export default class BackgroundJobsMain {
         jsonSocket: JsonSocket;
         message: import("./types.js").BackgroundJobSocketMessage;
     }): import("./types.js").BackgroundJobSocketRole | null;
+    /**
+     * 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>}
+     */
+    _adoptWorkerHandoffs(jsonSocket: JsonSocket): Promise<void>;
     /**
      * Runs handle client socket message.
      * @param {object} args - Options.
@@ -264,6 +279,14 @@ export default class BackgroundJobsMain {
      * @returns {void}
      */
     _reportHandoffReleaseError(error: unknown): void;
+    /**
+     * 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: unknown): void;
     /**
      * Runs handle enqueue.
      * @param {object} args - Options.