velocious 1.0.431 → 1.0.433

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

@@ -1,683 +1,629 @@
 // @ts-check
-
-import net from "net"
-import {fork, spawn} from "node:child_process"
-import JsonSocket from "./json-socket.js"
-import BackgroundJobRegistry from "./job-registry.js"
-import configurationResolver from "../configuration-resolver.js"
-import BackgroundJobsStatusReporter from "./status-reporter.js"
-import {randomUUID} from "crypto"
-import {fileURLToPath} from "node:url"
-
+import net from "net";
+import { fork, spawn } from "node:child_process";
+import JsonSocket from "./json-socket.js";
+import BackgroundJobRegistry from "./job-registry.js";
+import configurationResolver from "../configuration-resolver.js";
+import BackgroundJobsStatusReporter from "./status-reporter.js";
+import { randomUUID } from "crypto";
+import { fileURLToPath } from "node:url";
 /** Grace period after SIGTERM before a lingering process runner is SIGKILLed. */
-const FORKED_CHILD_SIGKILL_GRACE_MS = 5000
-const FORKED_RUNNER_ENTRY_PATH = fileURLToPath(new URL("./forked-runner-child.js", import.meta.url))
+const FORKED_CHILD_SIGKILL_GRACE_MS = 5000;
+const FORKED_RUNNER_ENTRY_PATH = fileURLToPath(new URL("./forked-runner-child.js", import.meta.url));
 /**
  * Execution modes.
   @type {import("./types.js").BackgroundJobExecutionMode[]} */
-const EXECUTION_MODES = ["inline", "forked", "spawned"]
-
+const EXECUTION_MODES = ["inline", "forked", "spawned"];
 export default class BackgroundJobsWorker {
-  /**
-   * Runs constructor.
-   * @param {object} [args] - Options.
-   * @param {import("../configuration.js").default} [args.configuration] - Configuration.
-   * @param {string} [args.host] - Hostname.
-   * @param {number} [args.port] - Port.
-   * @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.forkedChildSigkillGraceMs] - Override the grace period between SIGTERM and SIGKILL when reaping lingering process runners on stop.
-   */
-  constructor({configuration, host, port, maxConcurrentForkedJobs, maxConcurrentInlineJobs, forkedChildSigkillGraceMs} = {}) {
     /**
-     * Narrows the runtime value to the documented type.
-      @type {Promise<import("../configuration.js").default>} */
-    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()
-    /**
-     * Narrows the runtime value to the documented type.
-      @type {import("../configuration.js").default | undefined} */
-    this.configuration = undefined
-    this.host = host
-    this.port = port
-    /**
-     * Constructor override for the inline-job concurrency cap. When unset
-     * the cap is read from `configuration.getBackgroundJobsConfig()` in
-     * `start()` (default: 4).
-     * @type {number | undefined}
+     * Runs constructor.
+     * @param {object} [args] - Options.
+     * @param {import("../configuration.js").default} [args.configuration] - Configuration.
+     * @param {string} [args.host] - Hostname.
+     * @param {number} [args.port] - Port.
+     * @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.forkedChildSigkillGraceMs] - Override the grace period between SIGTERM and SIGKILL when reaping lingering process runners on stop.
      */
-    this.maxConcurrentInlineJobsOverride = typeof maxConcurrentInlineJobs === "number" && maxConcurrentInlineJobs >= 1
-      ? maxConcurrentInlineJobs
-      : undefined
+    constructor({ configuration, host, port, maxConcurrentForkedJobs, maxConcurrentInlineJobs, forkedChildSigkillGraceMs } = {}) {
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Promise<import("../configuration.js").default>} */
+        this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver();
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {import("../configuration.js").default | undefined} */
+        this.configuration = undefined;
+        this.host = host;
+        this.port = port;
+        /**
+         * Constructor override for the inline-job concurrency cap. When unset
+         * the cap is read from `configuration.getBackgroundJobsConfig()` in
+         * `start()` (default: 4).
+         * @type {number | undefined}
+         */
+        this.maxConcurrentInlineJobsOverride = typeof maxConcurrentInlineJobs === "number" && maxConcurrentInlineJobs >= 1
+            ? maxConcurrentInlineJobs
+            : undefined;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {number | undefined} */
+        this.maxConcurrentForkedJobsOverride = typeof maxConcurrentForkedJobs === "number" && maxConcurrentForkedJobs >= 1
+            ? maxConcurrentForkedJobs
+            : undefined;
+        /**
+         * Resolved cap for inline-job concurrency. Set in `start()`; defaults to
+         * 4 if no configuration value is available.
+         * @type {number}
+         */
+        this.maxConcurrentInlineJobs = this.maxConcurrentInlineJobsOverride || 4;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {number} */
+        this.maxConcurrentForkedJobs = this.maxConcurrentForkedJobsOverride || 4;
+        /**
+         * Grace period between SIGTERM and SIGKILL when reaping process runners that
+         * outlast a bounded shutdown drain.
+         * @type {number}
+         */
+        this.forkedChildSigkillGraceMs = typeof forkedChildSigkillGraceMs === "number" && forkedChildSigkillGraceMs >= 0
+            ? forkedChildSigkillGraceMs
+            : FORKED_CHILD_SIGKILL_GRACE_MS;
+        this.shouldStop = false;
+        this.workerId = randomUUID();
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {JsonSocket | undefined} */
+        this.jsonSocket = undefined;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {BackgroundJobsStatusReporter | undefined} */
+        this.statusReporter = undefined;
+        /**
+         * Up to `this.maxConcurrentInlineJobs` of these run in parallel. They
+         * share the worker's process and DB connection pool, so concurrency is
+         * about overlapping I/O waits — use forking for memory isolation across
+         * long-running jobs and for using more cores.
+         * @type {Set<Promise<void>>}
+         */
+        this.inflightInlineJobs = new Set();
+        /**
+         * In-flight process runner exit promises. Tracked so process-job handoff
+         * stays bounded while running and so a graceful `stop()` can drain them.
+         * @type {Set<Promise<void>>}
+         */
+        this.inflightProcessJobs = new Set();
+        /**
+         * Live process runner child processes, kept so a graceful `stop()` can
+         * terminate any that outlast the shutdown drain instead of orphaning them
+         * across a deploy (where they would keep running against deleted release
+         * code and holding database connections).
+         * @type {Set<import("node:child_process").ChildProcess>}
+         */
+        this.inflightProcessChildren = new Set();
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {number | undefined} */
-    this.maxConcurrentForkedJobsOverride = typeof maxConcurrentForkedJobs === "number" && maxConcurrentForkedJobs >= 1
-      ? maxConcurrentForkedJobs
-      : undefined
+     * Runs start.
+     * @returns {Promise<void>} - Resolves when connected.
+     */
+    async start() {
+        this.configuration = await this.configurationPromise;
+        this.configuration.setCurrent();
+        await this.configuration.initialize({ type: "background-jobs-worker" });
+        await this.configuration.connectBeacon({ peerType: "background-jobs-worker" });
+        // Constructor overrides win; otherwise pick up the configured caps.
+        if (typeof this.maxConcurrentInlineJobsOverride !== "number") {
+            const config = this.configuration.getBackgroundJobsConfig();
+            this.maxConcurrentInlineJobs = config.maxConcurrentInlineJobs || this.maxConcurrentInlineJobs;
+        }
+        if (typeof this.maxConcurrentForkedJobsOverride !== "number") {
+            const config = this.configuration.getBackgroundJobsConfig();
+            this.maxConcurrentForkedJobs = config.maxConcurrentForkedJobs || this.maxConcurrentForkedJobs;
+        }
+        this.statusReporter = new BackgroundJobsStatusReporter({
+            configuration: this.configuration,
+            host: this.host,
+            port: this.port
+        });
+        await this._connect();
+    }
     /**
-     * Resolved cap for inline-job concurrency. Set in `start()`; defaults to
-     * 4 if no configuration value is available.
-     * @type {number}
+     * Gracefully stops the worker: announces draining to the main process so
+     * no new jobs are dispatched, waits for in-flight inline jobs and process
+     * runners to finish (so their results can be reported), then closes the
+     * socket and disconnects from the beacon.
+     *
+     * Process runners are child processes. When a `timeoutMs` is given (e.g. a
+     * deploy draining the old release) any runner still alive after the drain
+     * window is terminated (SIGTERM, then SIGKILL) rather than left to orphan
+     * across the deploy. With no `timeoutMs` the drain waits for runners to
+     * finish on their own.
+     * @param {object} [args] - Options.
+     * @param {number} [args.timeoutMs] - Max wait for in-flight jobs (per phase) in ms.
+     * @returns {Promise<void>} - Resolves when stopped.
      */
-    this.maxConcurrentInlineJobs = this.maxConcurrentInlineJobsOverride || 4
+    async stop({ timeoutMs } = {}) {
+        if (this.shouldStop)
+            return;
+        this.shouldStop = true;
+        // Announce drain so main stops dispatching but keeps the connection
+        // open until we close it ourselves below.
+        if (this.jsonSocket) {
+            try {
+                this.jsonSocket.send({ type: "draining" });
+            }
+            catch {
+                // Socket may already be closing; nothing to do.
+            }
+        }
+        await this._drainInflight(this.inflightInlineJobs, timeoutMs);
+        await this._drainInflight(this.inflightProcessJobs, timeoutMs);
+        await this._terminateProcessChildren();
+        if (this.jsonSocket)
+            this.jsonSocket.close();
+        if (this.configuration) {
+            try {
+                await this.configuration.disconnectBeacon();
+            }
+            finally {
+                await this.configuration.closeDatabaseConnections();
+            }
+        }
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {number} */
-    this.maxConcurrentForkedJobs = this.maxConcurrentForkedJobsOverride || 4
+     * Waits for a set of in-flight job promises to settle, optionally bounded by
+     * `timeoutMs`.
+     * @param {Set<Promise<void>>} inflight - In-flight job promises.
+     * @param {number} [timeoutMs] - Max wait in ms; unbounded when omitted.
+     * @returns {Promise<void>} - Resolves when settled or the timeout elapses.
+     */
+    async _drainInflight(inflight, timeoutMs) {
+        if (inflight.size === 0)
+            return;
+        const drain = Promise.allSettled([...inflight]);
+        if (typeof timeoutMs === "number" && timeoutMs >= 0) {
+            let timer;
+            const timeout = new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); });
+            await Promise.race([drain, timeout]);
+            clearTimeout(timer);
+        }
+        else {
+            await drain;
+        }
+    }
     /**
-     * Grace period between SIGTERM and SIGKILL when reaping process runners that
-     * outlast a bounded shutdown drain.
-     * @type {number}
+     * Terminates any process runner children still alive after the drain window so
+     * they don't outlive the worker as orphans. SIGTERM lets the runner close its
+     * connections cleanly; survivors are SIGKILLed after a short grace.
+     * @returns {Promise<void>} - Resolves once survivors have been signalled.
      */
-    this.forkedChildSigkillGraceMs = typeof forkedChildSigkillGraceMs === "number" && forkedChildSigkillGraceMs >= 0
-      ? forkedChildSigkillGraceMs
-      : FORKED_CHILD_SIGKILL_GRACE_MS
-    this.shouldStop = false
-    this.workerId = randomUUID()
+    async _terminateProcessChildren() {
+        if (this.inflightProcessChildren.size === 0)
+            return;
+        for (const child of this.inflightProcessChildren) {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                // Child already exited; nothing to do.
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, this.forkedChildSigkillGraceMs));
+        for (const child of this.inflightProcessChildren) {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Child already exited; nothing to do.
+            }
+        }
+    }
+    async _connect() {
+        const configuration = this.configuration;
+        if (!configuration)
+            throw new Error("Background jobs worker configuration not initialized");
+        const config = configuration.getBackgroundJobsConfig();
+        const host = this.host || config.host;
+        const port = typeof this.port === "number" ? this.port : config.port;
+        const socket = net.createConnection({ host, port });
+        const jsonSocket = new JsonSocket(socket);
+        this.jsonSocket = jsonSocket;
+        /**
+         * Handles a background job socket message.
+         * @param {import("./types.js").BackgroundJobSocketMessage} message - Socket message.
+         */
+        jsonSocket.on("message", async (message) => {
+            if (message?.type === "job") {
+                await this._handleJob(message.payload);
+            }
+        });
+        jsonSocket.on("error", (error) => {
+            console.error("Background jobs worker socket error:", error);
+        });
+        jsonSocket.on("close", () => {
+            if (this.shouldStop)
+                return;
+            setTimeout(() => { void this._connect(); }, 1000);
+        });
+        socket.on("connect", () => {
+            jsonSocket.send({ type: "hello", role: "worker", workerId: this.workerId });
+            this._sendReadyIfRunning();
+        });
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {JsonSocket | undefined} */
-    this.jsonSocket = undefined
+     * Runs handle job.
+     * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
+     * @returns {Promise<void>} - Resolves when done.
+     */
+    async _handleJob(payload) {
+        if (!payload.id)
+            throw new Error("Background job payload missing id");
+        /**
+         * Identified payload.
+          @type {import("./types.js").BackgroundJobPayload & {id: string}} */
+        const identifiedPayload = /**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {?} */ (payload);
+        const executionMode = this._executionModeForPayload(identifiedPayload);
+        if (executionMode !== "inline") {
+            this._trackProcessJob(this._startProcessJob({ executionMode, payload: identifiedPayload }));
+            return;
+        }
+        this._handleInlineJob(identifiedPayload);
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {BackgroundJobsStatusReporter | undefined} */
-    this.statusReporter = undefined
+     * Runs start process job.
+     * @param {object} args - Options.
+     * @param {import("./types.js").BackgroundJobExecutionMode} args.executionMode - Execution mode.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
+     * @returns {Promise<void>} - Resolves when the process job exits.
+     */
+    _startProcessJob({ executionMode, payload }) {
+        if (executionMode === "forked")
+            return this._forkJob(payload);
+        return this._spawnJob(payload);
+    }
     /**
-     * Up to `this.maxConcurrentInlineJobs` of these run in parallel. They
-     * share the worker's process and DB connection pool, so concurrency is
-     * about overlapping I/O waits — use forking for memory isolation across
-     * long-running jobs and for using more cores.
-     * @type {Set<Promise<void>>}
+     * Runs handle inline job.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Payload.
+     * @returns {void}
      */
-    this.inflightInlineJobs = new Set()
+    _handleInlineJob(payload) {
+        // Inline jobs share the worker's process and DB pool, but each one
+        // is its own async chain — there's no semantic reason to serialize
+        // them. We kick off the job, register it with `inflightInlineJobs`
+        // for shutdown drain, and signal capacity to main:
+        // - If we still have a free slot we ask for the next job right
+        //   away, so a slow job (e.g. a docker alive check that waits 15s
+        //   on a gone server) no longer starves every other inline job.
+        // - When the job finishes, if the worker had been at the cap, we
+        //   ask for the next job to refill the slot.
+        // The bookkeeping in `finally()` ratchets capacity back up
+        // regardless of success or failure.
+        /**
+         * Defines inflight.
+          @type {Promise<void>} */
+        let inflight;
+        inflight = this._runInlineJobAndReport(payload).finally(() => {
+            this.inflightInlineJobs.delete(inflight);
+            if (!this.shouldStop && this.inflightInlineJobs.size === this.maxConcurrentInlineJobs - 1) {
+                this._sendReadyIfRunning();
+            }
+        });
+        this.inflightInlineJobs.add(inflight);
+        if (this.inflightInlineJobs.size < this.maxConcurrentInlineJobs) {
+            this._sendReadyIfRunning();
+        }
+    }
     /**
-     * In-flight process runner exit promises. Tracked so process-job handoff
-     * stays bounded while running and so a graceful `stop()` can drain them.
-     * @type {Set<Promise<void>>}
+     * Runs execution mode for payload.
+     * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
+     * @returns {import("./types.js").BackgroundJobExecutionMode} - Execution mode.
      */
-    this.inflightProcessJobs = new Set()
+    _executionModeForPayload(payload) {
+        const options = payload.options || {};
+        const executionMode = options.executionMode;
+        if (executionMode)
+            return this._normalizeExecutionMode(executionMode);
+        return options.forked === false ? "inline" : "forked";
+    }
     /**
-     * Live process runner child processes, kept so a graceful `stop()` can
-     * terminate any that outlast the shutdown drain instead of orphaning them
-     * across a deploy (where they would keep running against deleted release
-     * code and holding database connections).
-     * @type {Set<import("node:child_process").ChildProcess>}
+     * Runs normalize execution mode.
+     * @param {string} executionMode - Execution mode.
+     * @returns {import("./types.js").BackgroundJobExecutionMode} - Normalized execution mode.
      */
-    this.inflightProcessChildren = new Set()
-  }
-
-  /**
-   * Runs start.
-   * @returns {Promise<void>} - Resolves when connected.
-   */
-  async start() {
-    this.configuration = await this.configurationPromise
-    this.configuration.setCurrent()
-    await this.configuration.initialize({type: "background-jobs-worker"})
-    await this.configuration.connectBeacon({peerType: "background-jobs-worker"})
-
-    // Constructor overrides win; otherwise pick up the configured caps.
-    if (typeof this.maxConcurrentInlineJobsOverride !== "number") {
-      const config = this.configuration.getBackgroundJobsConfig()
-
-      this.maxConcurrentInlineJobs = config.maxConcurrentInlineJobs || this.maxConcurrentInlineJobs
+    _normalizeExecutionMode(executionMode) {
+        for (const mode of EXECUTION_MODES) {
+            if (mode === executionMode)
+                return mode;
+        }
+        throw new Error(`Invalid background job executionMode: ${executionMode}`);
     }
-    if (typeof this.maxConcurrentForkedJobsOverride !== "number") {
-      const config = this.configuration.getBackgroundJobsConfig()
-
-      this.maxConcurrentForkedJobs = config.maxConcurrentForkedJobs || this.maxConcurrentForkedJobs
+    /**
+     * Runs track process job.
+     * @param {Promise<void>} processJob - Process job promise.
+     * @returns {void}
+     */
+    _trackProcessJob(processJob) {
+        /**
+         * Defines inflight.
+          @type {Promise<void>} */
+        let inflight;
+        inflight = processJob.finally(() => {
+            this.inflightProcessJobs.delete(inflight);
+            if (!this.shouldStop && this.inflightProcessJobs.size === this.maxConcurrentForkedJobs - 1) {
+                this._sendReadyIfRunning();
+            }
+        });
+        this.inflightProcessJobs.add(inflight);
+        this._sendReadyIfRunning();
     }
-
-    this.statusReporter = new BackgroundJobsStatusReporter({
-      configuration: this.configuration,
-      host: this.host,
-      port: this.port
-    })
-    await this._connect()
-  }
-
-  /**
-   * Gracefully stops the worker: announces draining to the main process so
-   * no new jobs are dispatched, waits for in-flight inline jobs and process
-   * runners to finish (so their results can be reported), then closes the
-   * socket and disconnects from the beacon.
-   *
-   * Process runners are child processes. When a `timeoutMs` is given (e.g. a
-   * deploy draining the old release) any runner still alive after the drain
-   * window is terminated (SIGTERM, then SIGKILL) rather than left to orphan
-   * across the deploy. With no `timeoutMs` the drain waits for runners to
-   * finish on their own.
-   * @param {object} [args] - Options.
-   * @param {number} [args.timeoutMs] - Max wait for in-flight jobs (per phase) in ms.
-   * @returns {Promise<void>} - Resolves when stopped.
-   */
-  async stop({timeoutMs} = {}) {
-    if (this.shouldStop) return
-    this.shouldStop = true
-
-    // Announce drain so main stops dispatching but keeps the connection
-    // open until we close it ourselves below.
-    if (this.jsonSocket) {
-      try {
-        this.jsonSocket.send({type: "draining"})
-      } catch {
-        // Socket may already be closing; nothing to do.
-      }
+    /**
+     * Runs run inline job and report.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Payload with required id.
+     * @returns {Promise<void>} - Resolves when complete (success or failure reported).
+     */
+    async _runInlineJobAndReport(payload) {
+        try {
+            await this._runJobInline(payload);
+            await this._reportJobResult({
+                jobId: payload.id,
+                status: "completed",
+                handedOffAtMs: payload.handedOffAtMs,
+                workerId: payload.workerId || this.workerId
+            });
+        }
+        catch (error) {
+            await this._reportJobResult({
+                jobId: payload.id,
+                status: "failed",
+                error,
+                handedOffAtMs: payload.handedOffAtMs,
+                workerId: payload.workerId || this.workerId
+            });
+        }
     }
-
-    await this._drainInflight(this.inflightInlineJobs, timeoutMs)
-    await this._drainInflight(this.inflightProcessJobs, timeoutMs)
-    await this._terminateProcessChildren()
-
-    if (this.jsonSocket) this.jsonSocket.close()
-    if (this.configuration) {
-      try {
-        await this.configuration.disconnectBeacon()
-      } finally {
-        await this.configuration.closeDatabaseConnections()
-      }
+    /**
+     * Tells main we're ready for the next job — but only if we haven't been
+     * asked to drain. Once we've sent `draining` we don't want to take more
+     * work.
+     * @returns {void}
+     */
+    _sendReadyIfRunning() {
+        if (this.shouldStop)
+            return;
+        if (!this.jsonSocket)
+            return;
+        const readyMessage = this._readyMessage();
+        if (!readyMessage)
+            return;
+        this.jsonSocket.send(readyMessage);
     }
-  }
-
-  /**
-   * Waits for a set of in-flight job promises to settle, optionally bounded by
-   * `timeoutMs`.
-   * @param {Set<Promise<void>>} inflight - In-flight job promises.
-   * @param {number} [timeoutMs] - Max wait in ms; unbounded when omitted.
-   * @returns {Promise<void>} - Resolves when settled or the timeout elapses.
-   */
-  async _drainInflight(inflight, timeoutMs) {
-    if (inflight.size === 0) return
-
-    const drain = Promise.allSettled([...inflight])
-
-    if (typeof timeoutMs === "number" && timeoutMs >= 0) {
-      let timer
-      const timeout = new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs) })
-
-      await Promise.race([drain, timeout])
-      clearTimeout(timer)
-    } else {
-      await drain
+    /**
+     * Runs ready message.
+     * @returns {import("./types.js").BackgroundJobSocketMessage | null} - Ready message or null when the worker has no capacity.
+     */
+    _readyMessage() {
+        const acceptsProcessJob = this.inflightProcessJobs.size < this.maxConcurrentForkedJobs;
+        const acceptsInline = this.inflightInlineJobs.size < this.maxConcurrentInlineJobs;
+        if (!acceptsProcessJob && !acceptsInline)
+            return null;
+        return {
+            type: "ready",
+            acceptsForked: acceptsProcessJob,
+            acceptsInline,
+            acceptsSpawned: acceptsProcessJob
+        };
     }
-  }
-
-  /**
-   * Terminates any process runner children still alive after the drain window so
-   * they don't outlive the worker as orphans. SIGTERM lets the runner close its
-   * connections cleanly; survivors are SIGKILLed after a short grace.
-   * @returns {Promise<void>} - Resolves once survivors have been signalled.
-   */
-  async _terminateProcessChildren() {
-    if (this.inflightProcessChildren.size === 0) return
-
-    for (const child of this.inflightProcessChildren) {
-      try {
-        child.kill("SIGTERM")
-      } catch {
-        // Child already exited; nothing to do.
-      }
+    /**
+     * Runs run job inline.
+     * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
+     * @returns {Promise<void>} - Resolves when done.
+     */
+    async _runJobInline(payload) {
+        const configuration = this.configuration;
+        if (!configuration)
+            throw new Error("Background jobs worker configuration not initialized");
+        const registry = new BackgroundJobRegistry({ configuration });
+        await registry.load();
+        const JobClass = registry.getJobByName(payload.jobName);
+        const jobInstance = new JobClass();
+        /**
+         * Perform.
+          @type {(...args: Array<?>) => Promise<void>} */
+        const perform = jobInstance.perform;
+        await configuration.withConnections({ name: `Background job worker inline: ${payload.jobName}` }, async () => {
+            await perform.apply(jobInstance, payload.args || []);
+        });
     }
-
-    await new Promise((resolve) => setTimeout(resolve, this.forkedChildSigkillGraceMs))
-
-    for (const child of this.inflightProcessChildren) {
-      try {
-        child.kill("SIGKILL")
-      } catch {
-        // Child already exited; nothing to do.
-      }
+    /**
+     * Runs fork job.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Payload.
+     * @returns {Promise<void>} - Resolves when the forked runner exits or fork fails.
+     */
+    _forkJob(payload) {
+        const child = this._createForkedChild();
+        this.inflightProcessChildren.add(child);
+        const finished = this._waitForForkedChild({ child, payload });
+        this._sendForkedPayload({ child, payload });
+        return finished;
     }
-  }
-
-  async _connect() {
-    const configuration = this.configuration
-    if (!configuration) throw new Error("Background jobs worker configuration not initialized")
-
-    const config = configuration.getBackgroundJobsConfig()
-    const host = this.host || config.host
-    const port = typeof this.port === "number" ? this.port : config.port
-    const socket = net.createConnection({host, port})
-    const jsonSocket = new JsonSocket(socket)
-    this.jsonSocket = jsonSocket
-
     /**
-     * Handles a background job socket message.
-     * @param {import("./types.js").BackgroundJobSocketMessage} message - Socket message.
+     * Runs create forked child.
+     * @returns {import("node:child_process").ChildProcess} - Forked child process.
      */
-    jsonSocket.on("message", async (message) => {
-      if (message?.type === "job") {
-        await this._handleJob(message.payload)
-      }
-    })
-
-    jsonSocket.on("error", (error) => {
-      console.error("Background jobs worker socket error:", error)
-    })
-
-    jsonSocket.on("close", () => {
-      if (this.shouldStop) return
-      setTimeout(() => { void this._connect() }, 1000)
-    })
-
-    socket.on("connect", () => {
-      jsonSocket.send({type: "hello", role: "worker", workerId: this.workerId})
-      this._sendReadyIfRunning()
-    })
-  }
-
-  /**
-   * Runs handle job.
-   * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
-   * @returns {Promise<void>} - Resolves when done.
-   */
-  async _handleJob(payload) {
-    if (!payload.id) throw new Error("Background job payload missing id")
+    _createForkedChild() {
+        const configuration = this.configuration;
+        if (!configuration)
+            throw new Error("Background jobs worker configuration not initialized");
+        const directory = configuration.getDirectory();
+        const backgroundJobsConfig = configuration.getBackgroundJobsConfig();
+        return fork(FORKED_RUNNER_ENTRY_PATH, [], {
+            cwd: directory,
+            execArgv: [],
+            stdio: ["ignore", "ignore", "ignore", "ipc"],
+            env: Object.assign({}, process.env, {
+                VELOCIOUS_ENV: configuration.getEnvironment(),
+                VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
+                VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`
+            })
+        });
+    }
     /**
-     * Identified payload.
-      @type {import("./types.js").BackgroundJobPayload & {id: string}} */
-    const identifiedPayload = /**
-                               * Narrows the runtime value to the documented type.
-                                @type {?} */ (payload)
-
-    const executionMode = this._executionModeForPayload(identifiedPayload)
-
-    if (executionMode !== "inline") {
-      this._trackProcessJob(this._startProcessJob({executionMode, payload: identifiedPayload}))
-      return
+     * Runs wait for forked child.
+     * @param {object} args - Options.
+     * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
+     * @returns {Promise<void>} - Resolves when the child exits.
+     */
+    _waitForForkedChild({ child, payload }) {
+        return new Promise((resolve) => {
+            child.once("exit", (code, signal) => {
+                void this._handleForkedChildExit({ child, code, signal, payload, resolve });
+            });
+            child.once("error", (error) => {
+                void this._handleForkedChildError({ child, error, payload, resolve });
+            });
+        });
     }
-
-    this._handleInlineJob(identifiedPayload)
-  }
-
-  /**
-   * Runs start process job.
-   * @param {object} args - Options.
-   * @param {import("./types.js").BackgroundJobExecutionMode} args.executionMode - Execution mode.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
-   * @returns {Promise<void>} - Resolves when the process job exits.
-   */
-  _startProcessJob({executionMode, payload}) {
-    if (executionMode === "forked") return this._forkJob(payload)
-
-    return this._spawnJob(payload)
-  }
-
-  /**
-   * Runs handle inline job.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Payload.
-   * @returns {void}
-   */
-  _handleInlineJob(payload) {
-    // Inline jobs share the worker's process and DB pool, but each one
-    // is its own async chain — there's no semantic reason to serialize
-    // them. We kick off the job, register it with `inflightInlineJobs`
-    // for shutdown drain, and signal capacity to main:
-    // - If we still have a free slot we ask for the next job right
-    //   away, so a slow job (e.g. a docker alive check that waits 15s
-    //   on a gone server) no longer starves every other inline job.
-    // - When the job finishes, if the worker had been at the cap, we
-    //   ask for the next job to refill the slot.
-    // The bookkeeping in `finally()` ratchets capacity back up
-    // regardless of success or failure.
     /**
-     * Defines inflight.
-      @type {Promise<void>} */
-    let inflight
-
-    inflight = this._runInlineJobAndReport(payload).finally(() => {
-      this.inflightInlineJobs.delete(inflight)
-
-      if (!this.shouldStop && this.inflightInlineJobs.size === this.maxConcurrentInlineJobs - 1) {
-        this._sendReadyIfRunning()
-      }
-    })
-
-    this.inflightInlineJobs.add(inflight)
-
-    if (this.inflightInlineJobs.size < this.maxConcurrentInlineJobs) {
-      this._sendReadyIfRunning()
+     * Runs handle forked child exit.
+     * @param {object} args - Options.
+     * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
+     * @param {number | null} args.code - Exit code.
+     * @param {NodeJS.Signals | null} args.signal - Exit signal.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
+     * @param {(value: void) => void} args.resolve - Promise resolver.
+     * @returns {Promise<void>} - Resolves after failure is reported.
+     */
+    async _handleForkedChildExit({ child, code, signal, payload, resolve }) {
+        this.inflightProcessChildren.delete(child);
+        if (this._forkedChildExitedCleanly({ code, signal })) {
+            resolve(undefined);
+            return;
+        }
+        await this._reportForkedChildFailure({
+            payload,
+            error: new Error(`Forked background job runner exited before reporting: code=${code} signal=${signal || "none"}`)
+        });
+        resolve(undefined);
     }
-  }
-
-  /**
-   * Runs execution mode for payload.
-   * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
-   * @returns {import("./types.js").BackgroundJobExecutionMode} - Execution mode.
-   */
-  _executionModeForPayload(payload) {
-    const options = payload.options || {}
-    const executionMode = options.executionMode
-
-    if (executionMode) return this._normalizeExecutionMode(executionMode)
-
-    return options.forked === false ? "inline" : "forked"
-  }
-
-  /**
-   * Runs normalize execution mode.
-   * @param {string} executionMode - Execution mode.
-   * @returns {import("./types.js").BackgroundJobExecutionMode} - Normalized execution mode.
-   */
-  _normalizeExecutionMode(executionMode) {
-    for (const mode of EXECUTION_MODES) {
-      if (mode === executionMode) return mode
+    /**
+     * Runs forked child exited cleanly.
+     * @param {object} args - Options.
+     * @param {number | null} args.code - Exit code.
+     * @param {NodeJS.Signals | null} args.signal - Exit signal.
+     * @returns {boolean} - Whether the child exited cleanly.
+     */
+    _forkedChildExitedCleanly({ code, signal }) {
+        return code === 0 && !signal;
     }
-
-    throw new Error(`Invalid background job executionMode: ${executionMode}`)
-  }
-
-  /**
-   * Runs track process job.
-   * @param {Promise<void>} processJob - Process job promise.
-   * @returns {void}
-   */
-  _trackProcessJob(processJob) {
     /**
-     * Defines inflight.
-      @type {Promise<void>} */
-    let inflight
-
-    inflight = processJob.finally(() => {
-      this.inflightProcessJobs.delete(inflight)
-
-      if (!this.shouldStop && this.inflightProcessJobs.size === this.maxConcurrentForkedJobs - 1) {
-        this._sendReadyIfRunning()
-      }
-    })
-
-    this.inflightProcessJobs.add(inflight)
-    this._sendReadyIfRunning()
-  }
-
-  /**
-   * Runs run inline job and report.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Payload with required id.
-   * @returns {Promise<void>} - Resolves when complete (success or failure reported).
-   */
-  async _runInlineJobAndReport(payload) {
-    try {
-      await this._runJobInline(payload)
-      await this._reportJobResult({
-        jobId: payload.id,
-        status: "completed",
-        handedOffAtMs: payload.handedOffAtMs,
-        workerId: payload.workerId || this.workerId
-      })
-    } catch (error) {
-      await this._reportJobResult({
-        jobId: payload.id,
-        status: "failed",
-        error,
-        handedOffAtMs: payload.handedOffAtMs,
-        workerId: payload.workerId || this.workerId
-      })
+     * Runs handle forked child error.
+     * @param {object} args - Options.
+     * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
+     * @param {Error} args.error - Child process error.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
+     * @param {(value: void) => void} args.resolve - Promise resolver.
+     * @returns {Promise<void>} - Resolves after failure is reported.
+     */
+    async _handleForkedChildError({ child, error, payload, resolve }) {
+        this.inflightProcessChildren.delete(child);
+        console.error("Background jobs forked runner error:", error);
+        await this._reportForkedChildFailure({ payload, error });
+        resolve(undefined);
     }
-  }
-
-  /**
-   * Tells main we're ready for the next job — but only if we haven't been
-   * asked to drain. Once we've sent `draining` we don't want to take more
-   * work.
-   * @returns {void}
-   */
-  _sendReadyIfRunning() {
-    if (this.shouldStop) return
-    if (!this.jsonSocket) return
-
-    const readyMessage = this._readyMessage()
-
-    if (!readyMessage) return
-    this.jsonSocket.send(readyMessage)
-  }
-
-  /**
-   * Runs ready message.
-   * @returns {import("./types.js").BackgroundJobSocketMessage | null} - Ready message or null when the worker has no capacity.
-   */
-  _readyMessage() {
-    const acceptsProcessJob = this.inflightProcessJobs.size < this.maxConcurrentForkedJobs
-    const acceptsInline = this.inflightInlineJobs.size < this.maxConcurrentInlineJobs
-
-    if (!acceptsProcessJob && !acceptsInline) return null
-
-    return {
-      type: "ready",
-      acceptsForked: acceptsProcessJob,
-      acceptsInline,
-      acceptsSpawned: acceptsProcessJob
+    /**
+     * Runs send forked payload.
+     * @param {object} args - Options.
+     * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
+     * @returns {void}
+     */
+    _sendForkedPayload({ child, payload }) {
+        try {
+            child.send({ type: "job", payload });
+        }
+        catch (error) {
+            child.kill("SIGTERM");
+            void this._reportForkedChildFailure({ payload, error });
+        }
     }
-  }
-
-  /**
-   * Runs run job inline.
-   * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
-   * @returns {Promise<void>} - Resolves when done.
-   */
-  async _runJobInline(payload) {
-    const configuration = this.configuration
-    if (!configuration) throw new Error("Background jobs worker configuration not initialized")
-
-    const registry = new BackgroundJobRegistry({configuration})
-    await registry.load()
-    const JobClass = registry.getJobByName(payload.jobName)
-    const jobInstance = new JobClass()
     /**
-     * Perform.
-      @type {(...args: Array<?>) => Promise<void>} */
-    const perform = jobInstance.perform
-
-    await configuration.withConnections({name: `Background job worker inline: ${payload.jobName}`}, async () => {
-      await perform.apply(jobInstance, payload.args || [])
-    })
-  }
-
-  /**
-   * Runs fork job.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Payload.
-   * @returns {Promise<void>} - Resolves when the forked runner exits or fork fails.
-   */
-  _forkJob(payload) {
-    const child = this._createForkedChild()
-
-    this.inflightProcessChildren.add(child)
-
-    const finished = this._waitForForkedChild({child, payload})
-
-    this._sendForkedPayload({child, payload})
-
-    return finished
-  }
-
-  /**
-   * Runs create forked child.
-   * @returns {import("node:child_process").ChildProcess} - Forked child process.
-   */
-  _createForkedChild() {
-    const configuration = this.configuration
-    if (!configuration) throw new Error("Background jobs worker configuration not initialized")
-
-    const directory = configuration.getDirectory()
-    const backgroundJobsConfig = configuration.getBackgroundJobsConfig()
-
-    return fork(FORKED_RUNNER_ENTRY_PATH, [], {
-      cwd: directory,
-      execArgv: [],
-      stdio: ["ignore", "ignore", "ignore", "ipc"],
-      env: Object.assign({}, process.env, {
-        VELOCIOUS_ENV: configuration.getEnvironment(),
-        VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
-        VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`
-      })
-    })
-  }
-
-  /**
-   * Runs wait for forked child.
-   * @param {object} args - Options.
-   * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
-   * @returns {Promise<void>} - Resolves when the child exits.
-   */
-  _waitForForkedChild({child, payload}) {
-    return new Promise((resolve) => {
-      child.once("exit", (code, signal) => {
-        void this._handleForkedChildExit({child, code, signal, payload, resolve})
-      })
-      child.once("error", (error) => {
-        void this._handleForkedChildError({child, error, payload, resolve})
-      })
-    })
-  }
-
-  /**
-   * Runs handle forked child exit.
-   * @param {object} args - Options.
-   * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
-   * @param {number | null} args.code - Exit code.
-   * @param {NodeJS.Signals | null} args.signal - Exit signal.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
-   * @param {(value: void) => void} args.resolve - Promise resolver.
-   * @returns {Promise<void>} - Resolves after failure is reported.
-   */
-  async _handleForkedChildExit({child, code, signal, payload, resolve}) {
-    this.inflightProcessChildren.delete(child)
-
-    if (this._forkedChildExitedCleanly({code, signal})) {
-      resolve(undefined)
-      return
+     * Runs report forked child failure.
+     * @param {object} args - Options.
+     * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
+     * @param {?} args.error - Error.
+     * @returns {Promise<void>} - Resolves after failure is reported.
+     */
+    async _reportForkedChildFailure({ payload, error }) {
+        await this._reportJobResult({
+            jobId: payload.id,
+            status: "failed",
+            error,
+            handedOffAtMs: payload.handedOffAtMs,
+            workerId: payload.workerId || this.workerId
+        });
     }
-
-    await this._reportForkedChildFailure({
-      payload,
-      error: new Error(`Forked background job runner exited before reporting: code=${code} signal=${signal || "none"}`)
-    })
-
-    resolve(undefined)
-  }
-
-  /**
-   * Runs forked child exited cleanly.
-   * @param {object} args - Options.
-   * @param {number | null} args.code - Exit code.
-   * @param {NodeJS.Signals | null} args.signal - Exit signal.
-   * @returns {boolean} - Whether the child exited cleanly.
-   */
-  _forkedChildExitedCleanly({code, signal}) {
-    return code === 0 && !signal
-  }
-
-  /**
-   * Runs handle forked child error.
-   * @param {object} args - Options.
-   * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
-   * @param {Error} args.error - Child process error.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
-   * @param {(value: void) => void} args.resolve - Promise resolver.
-   * @returns {Promise<void>} - Resolves after failure is reported.
-   */
-  async _handleForkedChildError({child, error, payload, resolve}) {
-    this.inflightProcessChildren.delete(child)
-    console.error("Background jobs forked runner error:", error)
-    await this._reportForkedChildFailure({payload, error})
-    resolve(undefined)
-  }
-
-  /**
-   * Runs send forked payload.
-   * @param {object} args - Options.
-   * @param {import("node:child_process").ChildProcess} args.child - Forked child process.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
-   * @returns {void}
-   */
-  _sendForkedPayload({child, payload}) {
-    try {
-      child.send({type: "job", payload})
-    } catch (error) {
-      child.kill("SIGTERM")
-      void this._reportForkedChildFailure({payload, error})
+    /**
+     * Runs spawn job.
+     * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
+     * @returns {Promise<void>} - Resolves when the spawned runner exits or spawn fails.
+     */
+    _spawnJob(payload) {
+        const configuration = this.configuration;
+        if (!configuration)
+            throw new Error("Background jobs worker configuration not initialized");
+        const directory = configuration.getDirectory();
+        const argvCommand = process.argv[1];
+        const command = argvCommand ? argvCommand : `${directory}/bin/velocious.js`;
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64");
+        const backgroundJobsConfig = configuration.getBackgroundJobsConfig();
+        const child = spawn(process.execPath, [command, "background-jobs-runner"], {
+            cwd: directory,
+            detached: true,
+            stdio: "ignore",
+            env: Object.assign({}, process.env, {
+                VELOCIOUS_ENV: configuration.getEnvironment(),
+                VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
+                VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,
+                VELOCIOUS_JOB_PAYLOAD: encodedPayload
+            })
+        });
+        this.inflightProcessChildren.add(child);
+        const finished = new Promise((resolve) => {
+            child.once("exit", () => {
+                this.inflightProcessChildren.delete(child);
+                resolve(undefined);
+            });
+            child.once("error", (error) => {
+                this.inflightProcessChildren.delete(child);
+                console.error("Background jobs spawned runner error:", error);
+                resolve(undefined);
+            });
+        });
+        child.unref();
+        return finished;
     }
-  }
-
-  /**
-   * Runs report forked child failure.
-   * @param {object} args - Options.
-   * @param {import("./types.js").BackgroundJobPayload & {id: string}} args.payload - Payload.
-   * @param {?} args.error - Error.
-   * @returns {Promise<void>} - Resolves after failure is reported.
-   */
-  async _reportForkedChildFailure({payload, error}) {
-    await this._reportJobResult({
-      jobId: payload.id,
-      status: "failed",
-      error,
-      handedOffAtMs: payload.handedOffAtMs,
-      workerId: payload.workerId || this.workerId
-    })
-  }
-
-  /**
-   * Runs spawn job.
-   * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
-   * @returns {Promise<void>} - Resolves when the spawned runner exits or spawn fails.
-   */
-  _spawnJob(payload) {
-    const configuration = this.configuration
-    if (!configuration) throw new Error("Background jobs worker configuration not initialized")
-
-    const directory = configuration.getDirectory()
-    const argvCommand = process.argv[1]
-    const command = argvCommand ? argvCommand : `${directory}/bin/velocious.js`
-    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64")
-    const backgroundJobsConfig = configuration.getBackgroundJobsConfig()
-    const child = spawn(process.execPath, [command, "background-jobs-runner"], {
-      cwd: directory,
-      detached: true,
-      stdio: "ignore",
-      env: Object.assign({}, process.env, {
-        VELOCIOUS_ENV: configuration.getEnvironment(),
-        VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
-        VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,
-        VELOCIOUS_JOB_PAYLOAD: encodedPayload
-      })
-    })
-
-    this.inflightProcessChildren.add(child)
-
-    const finished = new Promise((resolve) => {
-      child.once("exit", () => {
-        this.inflightProcessChildren.delete(child)
-        resolve(undefined)
-      })
-      child.once("error", (error) => {
-        this.inflightProcessChildren.delete(child)
-        console.error("Background jobs spawned runner error:", error)
-        resolve(undefined)
-      })
-    })
-
-    child.unref()
-
-    return finished
-  }
-
-  /**
-   * Runs report job result.
-   * @param {object} args - Options.
-   * @param {string} args.jobId - Job id.
-   * @param {"completed" | "failed"} args.status - Status.
-   * @param {?} [args.error] - Error.
-   * @param {number} [args.handedOffAtMs] - Handed off timestamp.
-   * @param {string} [args.workerId] - Worker id.
-   * @returns {Promise<void>} - Resolves when reported.
-   */
-  async _reportJobResult({jobId, status, error, handedOffAtMs, workerId}) {
-    if (!this.statusReporter) return
-
-    try {
-      await this.statusReporter.reportWithRetry({jobId, status, error, handedOffAtMs, workerId})
-    } catch (reportError) {
-      console.error("Background job status reporting failed:", reportError)
+    /**
+     * Runs report job result.
+     * @param {object} args - Options.
+     * @param {string} args.jobId - Job id.
+     * @param {"completed" | "failed"} args.status - Status.
+     * @param {?} [args.error] - Error.
+     * @param {number} [args.handedOffAtMs] - Handed off timestamp.
+     * @param {string} [args.workerId] - Worker id.
+     * @returns {Promise<void>} - Resolves when reported.
+     */
+    async _reportJobResult({ jobId, status, error, handedOffAtMs, workerId }) {
+        if (!this.statusReporter)
+            return;
+        try {
+            await this.statusReporter.reportWithRetry({ jobId, status, error, handedOffAtMs, workerId });
+        }
+        catch (reportError) {
+            console.error("Background job status reporting failed:", reportError);
+        }
     }
-  }
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../../src/background-jobs/worker.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport {fork, spawn} from \"node:child_process\"\nimport JsonSocket from \"./json-socket.js\"\nimport BackgroundJobRegistry from \"./job-registry.js\"\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobsStatusReporter from \"./status-reporter.js\"\nimport {randomUUID} from \"crypto\"\nimport {fileURLToPath} from \"node:url\"\n\n/** Grace period after SIGTERM before a lingering process runner is SIGKILLed. */\nconst FORKED_CHILD_SIGKILL_GRACE_MS = 5000\nconst FORKED_RUNNER_ENTRY_PATH = fileURLToPath(new URL(\"./forked-runner-child.js\", import.meta.url))\n/**\n * Execution modes.\n  @type {import(\"./types.js\").BackgroundJobExecutionMode[]} */\nconst EXECUTION_MODES = [\"inline\", \"forked\", \"spawned\"]\n\nexport default class BackgroundJobsWorker {\n  /**\n   * Runs constructor.\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration.\n   * @param {string} [args.host] - Hostname.\n   * @param {number} [args.port] - Port.\n   * @param {number} [args.maxConcurrentForkedJobs] - Override the process runner concurrency cap from `configuration.getBackgroundJobsConfig()`.\n   * @param {number} [args.maxConcurrentInlineJobs] - Override the inline-job concurrency cap from `configuration.getBackgroundJobsConfig()`.\n   * @param {number} [args.forkedChildSigkillGraceMs] - Override the grace period between SIGTERM and SIGKILL when reaping lingering process runners on stop.\n   */\n  constructor({configuration, host, port, maxConcurrentForkedJobs, maxConcurrentInlineJobs, forkedChildSigkillGraceMs} = {}) {\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {Promise<import(\"../configuration.js\").default>} */\n    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {import(\"../configuration.js\").default | undefined} */\n    this.configuration = undefined\n    this.host = host\n    this.port = port\n    /**\n     * Constructor override for the inline-job concurrency cap. When unset\n     * the cap is read from `configuration.getBackgroundJobsConfig()` in\n     * `start()` (default: 4).\n     * @type {number | undefined}\n     */\n    this.maxConcurrentInlineJobsOverride = typeof maxConcurrentInlineJobs === \"number\" && maxConcurrentInlineJobs >= 1\n      ? maxConcurrentInlineJobs\n      : undefined\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {number | undefined} */\n    this.maxConcurrentForkedJobsOverride = typeof maxConcurrentForkedJobs === \"number\" && maxConcurrentForkedJobs >= 1\n      ? maxConcurrentForkedJobs\n      : undefined\n    /**\n     * Resolved cap for inline-job concurrency. Set in `start()`; defaults to\n     * 4 if no configuration value is available.\n     * @type {number}\n     */\n    this.maxConcurrentInlineJobs = this.maxConcurrentInlineJobsOverride || 4\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {number} */\n    this.maxConcurrentForkedJobs = this.maxConcurrentForkedJobsOverride || 4\n    /**\n     * Grace period between SIGTERM and SIGKILL when reaping process runners that\n     * outlast a bounded shutdown drain.\n     * @type {number}\n     */\n    this.forkedChildSigkillGraceMs = typeof forkedChildSigkillGraceMs === \"number\" && forkedChildSigkillGraceMs >= 0\n      ? forkedChildSigkillGraceMs\n      : FORKED_CHILD_SIGKILL_GRACE_MS\n    this.shouldStop = false\n    this.workerId = randomUUID()\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {JsonSocket | undefined} */\n    this.jsonSocket = undefined\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {BackgroundJobsStatusReporter | undefined} */\n    this.statusReporter = undefined\n    /**\n     * Up to `this.maxConcurrentInlineJobs` of these run in parallel. They\n     * share the worker's process and DB connection pool, so concurrency is\n     * about overlapping I/O waits — use forking for memory isolation across\n     * long-running jobs and for using more cores.\n     * @type {Set<Promise<void>>}\n     */\n    this.inflightInlineJobs = new Set()\n    /**\n     * In-flight process runner exit promises. Tracked so process-job handoff\n     * stays bounded while running and so a graceful `stop()` can drain them.\n     * @type {Set<Promise<void>>}\n     */\n    this.inflightProcessJobs = new Set()\n    /**\n     * Live process runner child processes, kept so a graceful `stop()` can\n     * terminate any that outlast the shutdown drain instead of orphaning them\n     * across a deploy (where they would keep running against deleted release\n     * code and holding database connections).\n     * @type {Set<import(\"node:child_process\").ChildProcess>}\n     */\n    this.inflightProcessChildren = new Set()\n  }\n\n  /**\n   * Runs start.\n   * @returns {Promise<void>} - Resolves when connected.\n   */\n  async start() {\n    this.configuration = await this.configurationPromise\n    this.configuration.setCurrent()\n    await this.configuration.initialize({type: \"background-jobs-worker\"})\n    await this.configuration.connectBeacon({peerType: \"background-jobs-worker\"})\n\n    // Constructor overrides win; otherwise pick up the configured caps.\n    if (typeof this.maxConcurrentInlineJobsOverride !== \"number\") {\n      const config = this.configuration.getBackgroundJobsConfig()\n\n      this.maxConcurrentInlineJobs = config.maxConcurrentInlineJobs || this.maxConcurrentInlineJobs\n    }\n    if (typeof this.maxConcurrentForkedJobsOverride !== \"number\") {\n      const config = this.configuration.getBackgroundJobsConfig()\n\n      this.maxConcurrentForkedJobs = config.maxConcurrentForkedJobs || this.maxConcurrentForkedJobs\n    }\n\n    this.statusReporter = new BackgroundJobsStatusReporter({\n      configuration: this.configuration,\n      host: this.host,\n      port: this.port\n    })\n    await this._connect()\n  }\n\n  /**\n   * Gracefully stops the worker: announces draining to the main process so\n   * no new jobs are dispatched, waits for in-flight inline jobs and process\n   * runners to finish (so their results can be reported), then closes the\n   * socket and disconnects from the beacon.\n   *\n   * Process runners are child processes. When a `timeoutMs` is given (e.g. a\n   * deploy draining the old release) any runner still alive after the drain\n   * window is terminated (SIGTERM, then SIGKILL) rather than left to orphan\n   * across the deploy. With no `timeoutMs` the drain waits for runners to\n   * finish on their own.\n   * @param {object} [args] - Options.\n   * @param {number} [args.timeoutMs] - Max wait for in-flight jobs (per phase) in ms.\n   * @returns {Promise<void>} - Resolves when stopped.\n   */\n  async stop({timeoutMs} = {}) {\n    if (this.shouldStop) return\n    this.shouldStop = true\n\n    // Announce drain so main stops dispatching but keeps the connection\n    // open until we close it ourselves below.\n    if (this.jsonSocket) {\n      try {\n        this.jsonSocket.send({type: \"draining\"})\n      } catch {\n        // Socket may already be closing; nothing to do.\n      }\n    }\n\n    await this._drainInflight(this.inflightInlineJobs, timeoutMs)\n    await this._drainInflight(this.inflightProcessJobs, timeoutMs)\n    await this._terminateProcessChildren()\n\n    if (this.jsonSocket) this.jsonSocket.close()\n    if (this.configuration) {\n      try {\n        await this.configuration.disconnectBeacon()\n      } finally {\n        await this.configuration.closeDatabaseConnections()\n      }\n    }\n  }\n\n  /**\n   * Waits for a set of in-flight job promises to settle, optionally bounded by\n   * `timeoutMs`.\n   * @param {Set<Promise<void>>} inflight - In-flight job promises.\n   * @param {number} [timeoutMs] - Max wait in ms; unbounded when omitted.\n   * @returns {Promise<void>} - Resolves when settled or the timeout elapses.\n   */\n  async _drainInflight(inflight, timeoutMs) {\n    if (inflight.size === 0) return\n\n    const drain = Promise.allSettled([...inflight])\n\n    if (typeof timeoutMs === \"number\" && timeoutMs >= 0) {\n      let timer\n      const timeout = new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs) })\n\n      await Promise.race([drain, timeout])\n      clearTimeout(timer)\n    } else {\n      await drain\n    }\n  }\n\n  /**\n   * Terminates any process runner children still alive after the drain window so\n   * they don't outlive the worker as orphans. SIGTERM lets the runner close its\n   * connections cleanly; survivors are SIGKILLed after a short grace.\n   * @returns {Promise<void>} - Resolves once survivors have been signalled.\n   */\n  async _terminateProcessChildren() {\n    if (this.inflightProcessChildren.size === 0) return\n\n    for (const child of this.inflightProcessChildren) {\n      try {\n        child.kill(\"SIGTERM\")\n      } catch {\n        // Child already exited; nothing to do.\n      }\n    }\n\n    await new Promise((resolve) => setTimeout(resolve, this.forkedChildSigkillGraceMs))\n\n    for (const child of this.inflightProcessChildren) {\n      try {\n        child.kill(\"SIGKILL\")\n      } catch {\n        // Child already exited; nothing to do.\n      }\n    }\n  }\n\n  async _connect() {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const config = configuration.getBackgroundJobsConfig()\n    const host = this.host || config.host\n    const port = typeof this.port === \"number\" ? this.port : config.port\n    const socket = net.createConnection({host, port})\n    const jsonSocket = new JsonSocket(socket)\n    this.jsonSocket = jsonSocket\n\n    /**\n     * Handles a background job socket message.\n     * @param {import(\"./types.js\").BackgroundJobSocketMessage} message - Socket message.\n     */\n    jsonSocket.on(\"message\", async (message) => {\n      if (message?.type === \"job\") {\n        await this._handleJob(message.payload)\n      }\n    })\n\n    jsonSocket.on(\"error\", (error) => {\n      console.error(\"Background jobs worker socket error:\", error)\n    })\n\n    jsonSocket.on(\"close\", () => {\n      if (this.shouldStop) return\n      setTimeout(() => { void this._connect() }, 1000)\n    })\n\n    socket.on(\"connect\", () => {\n      jsonSocket.send({type: \"hello\", role: \"worker\", workerId: this.workerId})\n      this._sendReadyIfRunning()\n    })\n  }\n\n  /**\n   * Runs handle job.\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when done.\n   */\n  async _handleJob(payload) {\n    if (!payload.id) throw new Error(\"Background job payload missing id\")\n    /**\n     * Identified payload.\n      @type {import(\"./types.js\").BackgroundJobPayload & {id: string}} */\n    const identifiedPayload = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {?} */ (payload)\n\n    const executionMode = this._executionModeForPayload(identifiedPayload)\n\n    if (executionMode !== \"inline\") {\n      this._trackProcessJob(this._startProcessJob({executionMode, payload: identifiedPayload}))\n      return\n    }\n\n    this._handleInlineJob(identifiedPayload)\n  }\n\n  /**\n   * Runs start process job.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode} args.executionMode - Execution mode.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} args.payload - Payload.\n   * @returns {Promise<void>} - Resolves when the process job exits.\n   */\n  _startProcessJob({executionMode, payload}) {\n    if (executionMode === \"forked\") return this._forkJob(payload)\n\n    return this._spawnJob(payload)\n  }\n\n  /**\n   * Runs handle inline job.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Payload.\n   * @returns {void}\n   */\n  _handleInlineJob(payload) {\n    // Inline jobs share the worker's process and DB pool, but each one\n    // is its own async chain — there's no semantic reason to serialize\n    // them. We kick off the job, register it with `inflightInlineJobs`\n    // for shutdown drain, and signal capacity to main:\n    // - If we still have a free slot we ask for the next job right\n    //   away, so a slow job (e.g. a docker alive check that waits 15s\n    //   on a gone server) no longer starves every other inline job.\n    // - When the job finishes, if the worker had been at the cap, we\n    //   ask for the next job to refill the slot.\n    // The bookkeeping in `finally()` ratchets capacity back up\n    // regardless of success or failure.\n    /**\n     * Defines inflight.\n      @type {Promise<void>} */\n    let inflight\n\n    inflight = this._runInlineJobAndReport(payload).finally(() => {\n      this.inflightInlineJobs.delete(inflight)\n\n      if (!this.shouldStop && this.inflightInlineJobs.size === this.maxConcurrentInlineJobs - 1) {\n        this._sendReadyIfRunning()\n      }\n    })\n\n    this.inflightInlineJobs.add(inflight)\n\n    if (this.inflightInlineJobs.size < this.maxConcurrentInlineJobs) {\n      this._sendReadyIfRunning()\n    }\n  }\n\n  /**\n   * Runs execution mode for payload.\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Execution mode.\n   */\n  _executionModeForPayload(payload) {\n    const options = payload.options || {}\n    const executionMode = options.executionMode\n\n    if (executionMode) return this._normalizeExecutionMode(executionMode)\n\n    return options.forked === false ? \"inline\" : \"forked\"\n  }\n\n  /**\n   * Runs normalize execution mode.\n   * @param {string} executionMode - Execution mode.\n   * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Normalized execution mode.\n   */\n  _normalizeExecutionMode(executionMode) {\n    for (const mode of EXECUTION_MODES) {\n      if (mode === executionMode) return mode\n    }\n\n    throw new Error(`Invalid background job executionMode: ${executionMode}`)\n  }\n\n  /**\n   * Runs track process job.\n   * @param {Promise<void>} processJob - Process job promise.\n   * @returns {void}\n   */\n  _trackProcessJob(processJob) {\n    /**\n     * Defines inflight.\n      @type {Promise<void>} */\n    let inflight\n\n    inflight = processJob.finally(() => {\n      this.inflightProcessJobs.delete(inflight)\n\n      if (!this.shouldStop && this.inflightProcessJobs.size === this.maxConcurrentForkedJobs - 1) {\n        this._sendReadyIfRunning()\n      }\n    })\n\n    this.inflightProcessJobs.add(inflight)\n    this._sendReadyIfRunning()\n  }\n\n  /**\n   * Runs run inline job and report.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Payload with required id.\n   * @returns {Promise<void>} - Resolves when complete (success or failure reported).\n   */\n  async _runInlineJobAndReport(payload) {\n    try {\n      await this._runJobInline(payload)\n      await this._reportJobResult({\n        jobId: payload.id,\n        status: \"completed\",\n        handedOffAtMs: payload.handedOffAtMs,\n        workerId: payload.workerId || this.workerId\n      })\n    } catch (error) {\n      await this._reportJobResult({\n        jobId: payload.id,\n        status: \"failed\",\n        error,\n        handedOffAtMs: payload.handedOffAtMs,\n        workerId: payload.workerId || this.workerId\n      })\n    }\n  }\n\n  /**\n   * Tells main we're ready for the next job — but only if we haven't been\n   * asked to drain. Once we've sent `draining` we don't want to take more\n   * work.\n   * @returns {void}\n   */\n  _sendReadyIfRunning() {\n    if (this.shouldStop) return\n    if (!this.jsonSocket) return\n\n    const readyMessage = this._readyMessage()\n\n    if (!readyMessage) return\n    this.jsonSocket.send(readyMessage)\n  }\n\n  /**\n   * Runs ready message.\n   * @returns {import(\"./types.js\").BackgroundJobSocketMessage | null} - Ready message or null when the worker has no capacity.\n   */\n  _readyMessage() {\n    const acceptsProcessJob = this.inflightProcessJobs.size < this.maxConcurrentForkedJobs\n    const acceptsInline = this.inflightInlineJobs.size < this.maxConcurrentInlineJobs\n\n    if (!acceptsProcessJob && !acceptsInline) return null\n\n    return {\n      type: \"ready\",\n      acceptsForked: acceptsProcessJob,\n      acceptsInline,\n      acceptsSpawned: acceptsProcessJob\n    }\n  }\n\n  /**\n   * Runs run job inline.\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when done.\n   */\n  async _runJobInline(payload) {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\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    await configuration.withConnections({name: `Background job worker inline: ${payload.jobName}`}, async () => {\n      await perform.apply(jobInstance, payload.args || [])\n    })\n  }\n\n  /**\n   * Runs fork job.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Payload.\n   * @returns {Promise<void>} - Resolves when the forked runner exits or fork fails.\n   */\n  _forkJob(payload) {\n    const child = this._createForkedChild()\n\n    this.inflightProcessChildren.add(child)\n\n    const finished = this._waitForForkedChild({child, payload})\n\n    this._sendForkedPayload({child, payload})\n\n    return finished\n  }\n\n  /**\n   * Runs create forked child.\n   * @returns {import(\"node:child_process\").ChildProcess} - Forked child process.\n   */\n  _createForkedChild() {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const directory = configuration.getDirectory()\n    const backgroundJobsConfig = configuration.getBackgroundJobsConfig()\n\n    return fork(FORKED_RUNNER_ENTRY_PATH, [], {\n      cwd: directory,\n      execArgv: [],\n      stdio: [\"ignore\", \"ignore\", \"ignore\", \"ipc\"],\n      env: Object.assign({}, process.env, {\n        VELOCIOUS_ENV: configuration.getEnvironment(),\n        VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,\n        VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`\n      })\n    })\n  }\n\n  /**\n   * Runs wait for forked child.\n   * @param {object} args - Options.\n   * @param {import(\"node:child_process\").ChildProcess} args.child - Forked child process.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} args.payload - Payload.\n   * @returns {Promise<void>} - Resolves when the child exits.\n   */\n  _waitForForkedChild({child, payload}) {\n    return new Promise((resolve) => {\n      child.once(\"exit\", (code, signal) => {\n        void this._handleForkedChildExit({child, code, signal, payload, resolve})\n      })\n      child.once(\"error\", (error) => {\n        void this._handleForkedChildError({child, error, payload, resolve})\n      })\n    })\n  }\n\n  /**\n   * Runs handle forked child exit.\n   * @param {object} args - Options.\n   * @param {import(\"node:child_process\").ChildProcess} args.child - Forked child process.\n   * @param {number | null} args.code - Exit code.\n   * @param {NodeJS.Signals | null} args.signal - Exit signal.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} args.payload - Payload.\n   * @param {(value: void) => void} args.resolve - Promise resolver.\n   * @returns {Promise<void>} - Resolves after failure is reported.\n   */\n  async _handleForkedChildExit({child, code, signal, payload, resolve}) {\n    this.inflightProcessChildren.delete(child)\n\n    if (this._forkedChildExitedCleanly({code, signal})) {\n      resolve(undefined)\n      return\n    }\n\n    await this._reportForkedChildFailure({\n      payload,\n      error: new Error(`Forked background job runner exited before reporting: code=${code} signal=${signal || \"none\"}`)\n    })\n\n    resolve(undefined)\n  }\n\n  /**\n   * Runs forked child exited cleanly.\n   * @param {object} args - Options.\n   * @param {number | null} args.code - Exit code.\n   * @param {NodeJS.Signals | null} args.signal - Exit signal.\n   * @returns {boolean} - Whether the child exited cleanly.\n   */\n  _forkedChildExitedCleanly({code, signal}) {\n    return code === 0 && !signal\n  }\n\n  /**\n   * Runs handle forked child error.\n   * @param {object} args - Options.\n   * @param {import(\"node:child_process\").ChildProcess} args.child - Forked child process.\n   * @param {Error} args.error - Child process error.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} args.payload - Payload.\n   * @param {(value: void) => void} args.resolve - Promise resolver.\n   * @returns {Promise<void>} - Resolves after failure is reported.\n   */\n  async _handleForkedChildError({child, error, payload, resolve}) {\n    this.inflightProcessChildren.delete(child)\n    console.error(\"Background jobs forked runner error:\", error)\n    await this._reportForkedChildFailure({payload, error})\n    resolve(undefined)\n  }\n\n  /**\n   * Runs send forked payload.\n   * @param {object} args - Options.\n   * @param {import(\"node:child_process\").ChildProcess} args.child - Forked child process.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} args.payload - Payload.\n   * @returns {void}\n   */\n  _sendForkedPayload({child, payload}) {\n    try {\n      child.send({type: \"job\", payload})\n    } catch (error) {\n      child.kill(\"SIGTERM\")\n      void this._reportForkedChildFailure({payload, error})\n    }\n  }\n\n  /**\n   * Runs report forked child failure.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} args.payload - Payload.\n   * @param {?} args.error - Error.\n   * @returns {Promise<void>} - Resolves after failure is reported.\n   */\n  async _reportForkedChildFailure({payload, error}) {\n    await this._reportJobResult({\n      jobId: payload.id,\n      status: \"failed\",\n      error,\n      handedOffAtMs: payload.handedOffAtMs,\n      workerId: payload.workerId || this.workerId\n    })\n  }\n\n  /**\n   * Runs spawn job.\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when the spawned runner exits or spawn fails.\n   */\n  _spawnJob(payload) {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const directory = configuration.getDirectory()\n    const argvCommand = process.argv[1]\n    const command = argvCommand ? argvCommand : `${directory}/bin/velocious.js`\n    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(\"base64\")\n    const backgroundJobsConfig = configuration.getBackgroundJobsConfig()\n    const child = spawn(process.execPath, [command, \"background-jobs-runner\"], {\n      cwd: directory,\n      detached: true,\n      stdio: \"ignore\",\n      env: Object.assign({}, process.env, {\n        VELOCIOUS_ENV: configuration.getEnvironment(),\n        VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,\n        VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,\n        VELOCIOUS_JOB_PAYLOAD: encodedPayload\n      })\n    })\n\n    this.inflightProcessChildren.add(child)\n\n    const finished = new Promise((resolve) => {\n      child.once(\"exit\", () => {\n        this.inflightProcessChildren.delete(child)\n        resolve(undefined)\n      })\n      child.once(\"error\", (error) => {\n        this.inflightProcessChildren.delete(child)\n        console.error(\"Background jobs spawned runner error:\", error)\n        resolve(undefined)\n      })\n    })\n\n    child.unref()\n\n    return finished\n  }\n\n  /**\n   * Runs report job result.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {\"completed\" | \"failed\"} args.status - Status.\n   * @param {?} [args.error] - Error.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @param {string} [args.workerId] - Worker id.\n   * @returns {Promise<void>} - Resolves when reported.\n   */\n  async _reportJobResult({jobId, status, error, handedOffAtMs, workerId}) {\n    if (!this.statusReporter) return\n\n    try {\n      await this.statusReporter.reportWithRetry({jobId, status, error, handedOffAtMs, workerId})\n    } catch (reportError) {\n      console.error(\"Background job status reporting failed:\", reportError)\n    }\n  }\n}\n"]}