velocious 1.0.177 → 1.0.179

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

@@ -0,0 +1,62 @@
+export default class BackgroundJobsMain {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.host] - Hostname.
+     * @param {number} [args.port] - Port.
+     */
+    constructor({ configuration, host, port }: {
+        configuration: import("../configuration.js").default;
+        host?: string;
+        port?: number;
+    });
+    configuration: import("../configuration.js").default;
+    host: string;
+    port: number;
+    store: BackgroundJobsStore;
+    logger: Logger;
+    /** @type {Set<JsonSocket>} */
+    workers: Set<JsonSocket>;
+    /** @type {Set<JsonSocket>} */
+    readyWorkers: Set<JsonSocket>;
+    _dispatching: boolean;
+    /**
+     * @returns {Promise<void>} - Resolves when listening.
+     */
+    start(): Promise<void>;
+    server: net.Server;
+    _dispatchTimer: NodeJS.Timeout;
+    _orphanTimer: NodeJS.Timeout;
+    /**
+     * @returns {Promise<void>} - Resolves when closed.
+     */
+    stop(): Promise<void>;
+    /**
+     * @returns {number} - Bound port.
+     */
+    getPort(): number;
+    /**
+     * @param {import("net").Socket} socket - Socket.
+     * @returns {void}
+     */
+    _handleConnection(socket: import("net").Socket): void;
+    _handleEnqueue({ jsonSocket, message }: {
+        jsonSocket: any;
+        message: any;
+    }): Promise<void>;
+    _handleJobComplete({ jsonSocket, message }: {
+        jsonSocket: any;
+        message: any;
+    }): Promise<void>;
+    _handleJobFailed({ jsonSocket, message }: {
+        jsonSocket: any;
+        message: any;
+    }): Promise<void>;
+    _dispatch(): Promise<void>;
+    _sweepOrphans(): Promise<void>;
+}
+import BackgroundJobsStore from "./store.js";
+import { Logger } from "../logger.js";
+import JsonSocket from "./json-socket.js";
+import net from "net";
+//# sourceMappingURL=main.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"AAOA;IACE;;;;;OAKG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI,GAAlB,MAAM;QACQ,IAAI,GAAlB,MAAM;KAChB,EAaA;IAXC,qDAAkC;IAElC,aAA+B;IAC/B,aAAyD;IACzD,2BAAoG;IACpG,eAA8B;IAC9B,8BAA8B;IAC9B,SADW,GAAG,CAAC,UAAU,CAAC,CACF;IACxB,8BAA8B;IAC9B,cADW,GAAG,CAAC,UAAU,CAAC,CACG;IAC7B,sBAAyB;IAG3B;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAnBC,mBAA0E;IAY1E,+BAEQ;IAER,6BAES;IAGX;;OAEG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;OAEG;IACH,WAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,0BAHW,OAAO,KAAK,EAAE,MAAM,GAClB,IAAI,CAqDhB;IAED;;;sBAcC;IAED;;;sBAYC;IAED;;;sBAcC;IAED,2BAyCC;IAED,+BAUC;CACF;gCAxO+B,YAAY;uBACvB,cAAc;uBAFZ,kBAAkB;gBADzB,KAAK"}

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

@@ -0,0 +1,216 @@
+// @ts-check
+import net from "net";
+import JsonSocket from "./json-socket.js";
+import BackgroundJobsStore from "./store.js";
+import { Logger } from "../logger.js";
+export default class BackgroundJobsMain {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.host] - Hostname.
+     * @param {number} [args.port] - Port.
+     */
+    constructor({ configuration, host, port }) {
+        this.configuration = configuration;
+        const config = configuration.getBackgroundJobsConfig();
+        this.host = host || config.host;
+        this.port = typeof port === "number" ? port : config.port;
+        this.store = new BackgroundJobsStore({ configuration, databaseIdentifier: config.databaseIdentifier });
+        this.logger = new Logger(this);
+        /** @type {Set<JsonSocket>} */
+        this.workers = new Set();
+        /** @type {Set<JsonSocket>} */
+        this.readyWorkers = new Set();
+        this._dispatching = false;
+    }
+    /**
+     * @returns {Promise<void>} - Resolves when listening.
+     */
+    async start() {
+        this.configuration.setCurrent();
+        await this.configuration.initialize({ type: "background-jobs-main" });
+        await this.store.ensureReady();
+        this.server = net.createServer((socket) => this._handleConnection(socket));
+        await new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(this.port, this.host, () => resolve(undefined));
+        });
+        const address = this.server.address();
+        if (address && typeof address === "object") {
+            this.port = address.port;
+        }
+        this._dispatchTimer = setInterval(() => {
+            void this._dispatch();
+        }, 1000);
+        this._orphanTimer = setInterval(() => {
+            void this._sweepOrphans();
+        }, 60000);
+    }
+    /**
+     * @returns {Promise<void>} - Resolves when closed.
+     */
+    async stop() {
+        for (const worker of this.workers) {
+            worker.close();
+        }
+        if (this._dispatchTimer)
+            clearInterval(this._dispatchTimer);
+        if (this._orphanTimer)
+            clearInterval(this._orphanTimer);
+        if (!this.server)
+            return;
+        await new Promise((resolve) => this.server.close(() => resolve(undefined)));
+    }
+    /**
+     * @returns {number} - Bound port.
+     */
+    getPort() {
+        return this.port;
+    }
+    /**
+     * @param {import("net").Socket} socket - Socket.
+     * @returns {void}
+     */
+    _handleConnection(socket) {
+        const jsonSocket = new JsonSocket(socket);
+        let role = null;
+        const cleanup = () => {
+            if (role === "worker") {
+                this.workers.delete(jsonSocket);
+                this.readyWorkers.delete(jsonSocket);
+            }
+        };
+        jsonSocket.on("close", cleanup);
+        jsonSocket.on("error", (error) => {
+            this.logger.warn(() => ["Background jobs connection error:", error]);
+            cleanup();
+        });
+        jsonSocket.on("message", (message) => {
+            if (!role && message?.type === "hello") {
+                role = message.role;
+                if (role === "worker") {
+                    jsonSocket.workerId = message.workerId;
+                    this.workers.add(jsonSocket);
+                    this.readyWorkers.add(jsonSocket);
+                    this._dispatch();
+                }
+                return;
+            }
+            if (role === "client" && message?.type === "enqueue") {
+                this._handleEnqueue({ jsonSocket, message });
+                return;
+            }
+            if (role === "worker" && message?.type === "ready") {
+                this.readyWorkers.add(jsonSocket);
+                this._dispatch();
+                return;
+            }
+            if ((role === "worker" || role === "reporter") && message?.type === "job-complete") {
+                this._handleJobComplete({ jsonSocket, message });
+                return;
+            }
+            if ((role === "worker" || role === "reporter") && message?.type === "job-failed") {
+                this._handleJobFailed({ jsonSocket, message });
+            }
+        });
+    }
+    async _handleEnqueue({ jsonSocket, message }) {
+        try {
+            const jobId = await this.store.enqueue({
+                jobName: message.jobName,
+                args: message.args || [],
+                options: message.options || {}
+            });
+            jsonSocket.send({ type: "enqueued", jobId });
+            await this._dispatch();
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to enqueue background job:", error]);
+            jsonSocket.send({ type: "enqueue-error", error: "Failed to enqueue job" });
+        }
+    }
+    async _handleJobComplete({ jsonSocket, message }) {
+        try {
+            await this.store.markCompleted({
+                jobId: message.jobId,
+                workerId: message.workerId,
+                handedOffAtMs: message.handedOffAtMs
+            });
+            jsonSocket.send({ type: "job-updated", jobId: message.jobId });
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to update job completion:", error]);
+            jsonSocket.send({ type: "job-update-error", jobId: message.jobId, error: "Failed to update job" });
+        }
+    }
+    async _handleJobFailed({ jsonSocket, message }) {
+        try {
+            await this.store.markFailed({
+                jobId: message.jobId,
+                error: message.error,
+                workerId: message.workerId,
+                handedOffAtMs: message.handedOffAtMs
+            });
+            jsonSocket.send({ type: "job-updated", jobId: message.jobId });
+            await this._dispatch();
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to update job failure:", error]);
+            jsonSocket.send({ type: "job-update-error", jobId: message.jobId, error: "Failed to update job" });
+        }
+    }
+    async _dispatch() {
+        if (this._dispatching)
+            return;
+        if (this.readyWorkers.size === 0)
+            return;
+        this._dispatching = true;
+        try {
+            while (this.readyWorkers.size > 0) {
+                const job = await this.store.nextAvailableJob();
+                if (!job)
+                    return;
+                const [worker] = this.readyWorkers;
+                if (!worker)
+                    return;
+                this.readyWorkers.delete(worker);
+                const handedOffAtMs = await this.store.markHandedOff({ jobId: job.id, workerId: worker.workerId });
+                try {
+                    worker.send({
+                        type: "job",
+                        payload: {
+                            id: job.id,
+                            jobName: job.jobName,
+                            args: job.args,
+                            workerId: worker.workerId,
+                            handedOffAtMs,
+                            options: {
+                                forked: job.forked
+                            }
+                        }
+                    });
+                }
+                catch (error) {
+                    this.logger.warn(() => ["Failed to send job to worker, re-queueing:", error]);
+                    await this.store.markReturnedToQueue({ jobId: job.id });
+                    this.readyWorkers.add(worker);
+                }
+            }
+        }
+        finally {
+            this._dispatching = false;
+        }
+    }
+    async _sweepOrphans() {
+        try {
+            const count = await this.store.markOrphanedJobs();
+            if (count > 0) {
+                this.logger.warn(() => ["Marked orphaned background jobs", count]);
+            }
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to mark orphaned jobs:", error]);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport JsonSocket from \"./json-socket.js\"\nimport BackgroundJobsStore from \"./store.js\"\nimport {Logger} from \"../logger.js\"\n\nexport default class BackgroundJobsMain {\n  /**\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   */\n  constructor({configuration, host, port}) {\n    this.configuration = configuration\n    const config = configuration.getBackgroundJobsConfig()\n    this.host = host || config.host\n    this.port = typeof port === \"number\" ? port : config.port\n    this.store = new BackgroundJobsStore({configuration, databaseIdentifier: config.databaseIdentifier})\n    this.logger = new Logger(this)\n    /** @type {Set<JsonSocket>} */\n    this.workers = new Set()\n    /** @type {Set<JsonSocket>} */\n    this.readyWorkers = new Set()\n    this._dispatching = false\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when listening.\n   */\n  async start() {\n    this.configuration.setCurrent()\n    await this.configuration.initialize({type: \"background-jobs-main\"})\n    await this.store.ensureReady()\n    this.server = net.createServer((socket) => this._handleConnection(socket))\n\n    await new Promise((resolve, reject) => {\n      this.server.once(\"error\", reject)\n      this.server.listen(this.port, this.host, () => resolve(undefined))\n    })\n\n    const address = this.server.address()\n    if (address && typeof address === \"object\") {\n      this.port = address.port\n    }\n\n    this._dispatchTimer = setInterval(() => {\n      void this._dispatch()\n    }, 1000)\n\n    this._orphanTimer = setInterval(() => {\n      void this._sweepOrphans()\n    }, 60000)\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when closed.\n   */\n  async stop() {\n    for (const worker of this.workers) {\n      worker.close()\n    }\n\n    if (this._dispatchTimer) clearInterval(this._dispatchTimer)\n    if (this._orphanTimer) clearInterval(this._orphanTimer)\n\n    if (!this.server) return\n\n    await new Promise((resolve) => this.server.close(() => resolve(undefined)))\n  }\n\n  /**\n   * @returns {number} - Bound port.\n   */\n  getPort() {\n    return this.port\n  }\n\n  /**\n   * @param {import(\"net\").Socket} socket - Socket.\n   * @returns {void}\n   */\n  _handleConnection(socket) {\n    const jsonSocket = new JsonSocket(socket)\n    let role = null\n\n    const cleanup = () => {\n      if (role === \"worker\") {\n        this.workers.delete(jsonSocket)\n        this.readyWorkers.delete(jsonSocket)\n      }\n    }\n\n    jsonSocket.on(\"close\", cleanup)\n    jsonSocket.on(\"error\", (error) => {\n      this.logger.warn(() => [\"Background jobs connection error:\", error])\n      cleanup()\n    })\n\n    jsonSocket.on(\"message\", (message) => {\n      if (!role && message?.type === \"hello\") {\n        role = message.role\n\n        if (role === \"worker\") {\n          jsonSocket.workerId = message.workerId\n          this.workers.add(jsonSocket)\n          this.readyWorkers.add(jsonSocket)\n          this._dispatch()\n        }\n\n        return\n      }\n\n      if (role === \"client\" && message?.type === \"enqueue\") {\n        this._handleEnqueue({jsonSocket, message})\n        return\n      }\n\n      if (role === \"worker\" && message?.type === \"ready\") {\n        this.readyWorkers.add(jsonSocket)\n        this._dispatch()\n        return\n      }\n\n      if ((role === \"worker\" || role === \"reporter\") && message?.type === \"job-complete\") {\n        this._handleJobComplete({jsonSocket, message})\n        return\n      }\n\n      if ((role === \"worker\" || role === \"reporter\") && message?.type === \"job-failed\") {\n        this._handleJobFailed({jsonSocket, message})\n      }\n    })\n  }\n\n  async _handleEnqueue({jsonSocket, message}) {\n    try {\n      const jobId = await this.store.enqueue({\n        jobName: message.jobName,\n        args: message.args || [],\n        options: message.options || {}\n      })\n\n      jsonSocket.send({type: \"enqueued\", jobId})\n      await this._dispatch()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to enqueue background job:\", error])\n      jsonSocket.send({type: \"enqueue-error\", error: \"Failed to enqueue job\"})\n    }\n  }\n\n  async _handleJobComplete({jsonSocket, message}) {\n    try {\n      await this.store.markCompleted({\n        jobId: message.jobId,\n        workerId: message.workerId,\n        handedOffAtMs: message.handedOffAtMs\n      })\n      jsonSocket.send({type: \"job-updated\", jobId: message.jobId})\n    } catch (error) {\n      this.logger.error(() => [\"Failed to update job completion:\", error])\n      jsonSocket.send({type: \"job-update-error\", jobId: message.jobId, error: \"Failed to update job\"})\n    }\n  }\n\n  async _handleJobFailed({jsonSocket, message}) {\n    try {\n      await this.store.markFailed({\n        jobId: message.jobId,\n        error: message.error,\n        workerId: message.workerId,\n        handedOffAtMs: message.handedOffAtMs\n      })\n      jsonSocket.send({type: \"job-updated\", jobId: message.jobId})\n      await this._dispatch()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to update job failure:\", error])\n      jsonSocket.send({type: \"job-update-error\", jobId: message.jobId, error: \"Failed to update job\"})\n    }\n  }\n\n  async _dispatch() {\n    if (this._dispatching) return\n    if (this.readyWorkers.size === 0) return\n\n    this._dispatching = true\n\n    try {\n      while (this.readyWorkers.size > 0) {\n        const job = await this.store.nextAvailableJob()\n        if (!job) return\n\n        const [worker] = this.readyWorkers\n        if (!worker) return\n\n        this.readyWorkers.delete(worker)\n\n        const handedOffAtMs = await this.store.markHandedOff({jobId: job.id, workerId: worker.workerId})\n\n        try {\n          worker.send({\n            type: \"job\",\n            payload: {\n              id: job.id,\n              jobName: job.jobName,\n              args: job.args,\n              workerId: worker.workerId,\n              handedOffAtMs,\n              options: {\n                forked: job.forked\n              }\n            }\n          })\n        } catch (error) {\n          this.logger.warn(() => [\"Failed to send job to worker, re-queueing:\", error])\n          await this.store.markReturnedToQueue({jobId: job.id})\n          this.readyWorkers.add(worker)\n        }\n      }\n    } finally {\n      this._dispatching = false\n    }\n  }\n\n  async _sweepOrphans() {\n    try {\n      const count = await this.store.markOrphanedJobs()\n\n      if (count > 0) {\n        this.logger.warn(() => [\"Marked orphaned background jobs\", count])\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Failed to mark orphaned jobs:\", error])\n    }\n  }\n}\n"]}

package/build/src/background-jobs/status-reporter.d.ts

@@ -0,0 +1,54 @@
+export default class BackgroundJobsStatusReporter {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.host] - Host.
+     * @param {number} [args.port] - Port.
+     */
+    constructor({ configuration, host, port }: {
+        configuration: import("../configuration.js").default;
+        host?: string;
+        port?: number;
+    });
+    configuration: import("../configuration.js").default;
+    host: string;
+    port: number;
+    logger: Logger;
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.jobId - Job id.
+     * @param {"completed" | "failed"} args.status - Status.
+     * @param {unknown} [args.error] - Error.
+     * @param {number} [args.handedOffAtMs] - Handed off timestamp.
+     * @param {string} [args.workerId] - Worker id.
+     * @returns {Promise<void>} - Resolves when reported.
+     */
+    report({ jobId, status, error, handedOffAtMs, workerId }: {
+        jobId: string;
+        status: "completed" | "failed";
+        error?: unknown;
+        handedOffAtMs?: number;
+        workerId?: string;
+    }): Promise<void>;
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.jobId - Job id.
+     * @param {"completed" | "failed"} args.status - Status.
+     * @param {unknown} [args.error] - Error.
+     * @param {number} [args.handedOffAtMs] - Handed off timestamp.
+     * @param {string} [args.workerId] - Worker id.
+     * @param {number} [args.maxDurationMs] - Max duration for retries.
+     * @returns {Promise<void>} - Resolves when reported.
+     */
+    reportWithRetry({ jobId, status, error, handedOffAtMs, workerId, maxDurationMs }: {
+        jobId: string;
+        status: "completed" | "failed";
+        error?: unknown;
+        handedOffAtMs?: number;
+        workerId?: string;
+        maxDurationMs?: number;
+    }): Promise<void>;
+    _normalizeError(error: any): string;
+}
+import { Logger } from "../logger.js";
+//# sourceMappingURL=status-reporter.d.ts.map

package/build/src/background-jobs/status-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-reporter.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/status-reporter.js"],"names":[],"mappings":"AAQA;IACE;;;;;OAKG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI,GAAlB,MAAM;QACQ,IAAI,GAAlB,MAAM;KAChB,EAMA;IAJC,qDAAkC;IAClC,aAAgB;IAChB,aAAgB;IAChB,eAA8B;IAGhC;;;;;;;;OAQG;IACH,0DAPG;QAAqB,KAAK,EAAlB,MAAM;QACuB,MAAM,EAAnC,WAAW,GAAG,QAAQ;QACP,KAAK,GAApB,OAAO;QACO,aAAa,GAA3B,MAAM;QACQ,QAAQ,GAAtB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAgDzB;IAED;;;;;;;;;OASG;IACH,kFARG;QAAqB,KAAK,EAAlB,MAAM;QACuB,MAAM,EAAnC,WAAW,GAAG,QAAQ;QACP,KAAK,GAApB,OAAO;QACO,aAAa,GAA3B,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACQ,aAAa,GAA3B,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED,oCASC;CACF;uBArHoB,cAAc"}

package/build/src/background-jobs/status-reporter.js

@@ -0,0 +1,113 @@
+// @ts-check
+import net from "net";
+import timeout from "awaitery/build/timeout.js";
+import wait from "awaitery/build/wait.js";
+import JsonSocket from "./json-socket.js";
+import { Logger } from "../logger.js";
+export default class BackgroundJobsStatusReporter {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.host] - Host.
+     * @param {number} [args.port] - Port.
+     */
+    constructor({ configuration, host, port }) {
+        this.configuration = configuration;
+        this.host = host;
+        this.port = port;
+        this.logger = new Logger(this);
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.jobId - Job id.
+     * @param {"completed" | "failed"} args.status - Status.
+     * @param {unknown} [args.error] - Error.
+     * @param {number} [args.handedOffAtMs] - Handed off timestamp.
+     * @param {string} [args.workerId] - Worker id.
+     * @returns {Promise<void>} - Resolves when reported.
+     */
+    async report({ jobId, status, error, handedOffAtMs, workerId }) {
+        const config = this.configuration.getBackgroundJobsConfig();
+        const host = this.host || config.host;
+        const port = typeof this.port === "number" ? this.port : config.port;
+        await timeout({ timeout: 5000 }, async () => {
+            await new Promise((resolve, reject) => {
+                const socket = net.createConnection({ host, port });
+                const jsonSocket = new JsonSocket(socket);
+                const cleanup = () => {
+                    jsonSocket.removeAllListeners();
+                };
+                jsonSocket.on("error", (err) => {
+                    cleanup();
+                    reject(err);
+                });
+                jsonSocket.on("message", (message) => {
+                    if (message?.type === "job-updated" && message.jobId === jobId) {
+                        cleanup();
+                        jsonSocket.close();
+                        resolve(undefined);
+                        return;
+                    }
+                    if (message?.type === "job-update-error" && message.jobId === jobId) {
+                        cleanup();
+                        jsonSocket.close();
+                        reject(new Error(message.error || "Job update failed"));
+                    }
+                });
+                socket.on("connect", () => {
+                    jsonSocket.send({ type: "hello", role: "reporter" });
+                    jsonSocket.send({
+                        type: status === "completed" ? "job-complete" : "job-failed",
+                        jobId,
+                        workerId,
+                        handedOffAtMs,
+                        error: error ? this._normalizeError(error) : undefined
+                    });
+                });
+            });
+        });
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.jobId - Job id.
+     * @param {"completed" | "failed"} args.status - Status.
+     * @param {unknown} [args.error] - Error.
+     * @param {number} [args.handedOffAtMs] - Handed off timestamp.
+     * @param {string} [args.workerId] - Worker id.
+     * @param {number} [args.maxDurationMs] - Max duration for retries.
+     * @returns {Promise<void>} - Resolves when reported.
+     */
+    async reportWithRetry({ jobId, status, error, handedOffAtMs, workerId, maxDurationMs }) {
+        let attempt = 0;
+        const startTime = Date.now();
+        while (true) {
+            try {
+                await this.report({ jobId, status, error, handedOffAtMs, workerId });
+                return;
+            }
+            catch (err) {
+                attempt += 1;
+                const delaySeconds = Math.min(30, 0.5 * attempt);
+                this.logger.debug(() => ["Background job status report failed, retrying", err]);
+                if (maxDurationMs && Date.now() - startTime >= maxDurationMs) {
+                    this.logger.warn(() => ["Background job status report timed out, giving up", err]);
+                    return;
+                }
+                await wait(delaySeconds);
+            }
+        }
+    }
+    _normalizeError(error) {
+        if (error instanceof Error)
+            return error.stack || error.message;
+        if (typeof error === "string")
+            return error;
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status-reporter.js","sourceRoot":"","sources":["../../../src/background-jobs/status-reporter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport wait from \"awaitery/build/wait.js\"\nimport JsonSocket from \"./json-socket.js\"\nimport {Logger} from \"../logger.js\"\n\nexport default class BackgroundJobsStatusReporter {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.host] - Host.\n   * @param {number} [args.port] - Port.\n   */\n  constructor({configuration, host, port}) {\n    this.configuration = configuration\n    this.host = host\n    this.port = port\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {\"completed\" | \"failed\"} args.status - Status.\n   * @param {unknown} [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 report({jobId, status, error, handedOffAtMs, workerId}) {\n    const config = this.configuration.getBackgroundJobsConfig()\n    const host = this.host || config.host\n    const port = typeof this.port === \"number\" ? this.port : config.port\n\n    await timeout({timeout: 5000}, async () => {\n      await new Promise((resolve, reject) => {\n        const socket = net.createConnection({host, port})\n        const jsonSocket = new JsonSocket(socket)\n\n        const cleanup = () => {\n          jsonSocket.removeAllListeners()\n        }\n\n        jsonSocket.on(\"error\", (err) => {\n          cleanup()\n          reject(err)\n        })\n\n        jsonSocket.on(\"message\", (message) => {\n          if (message?.type === \"job-updated\" && message.jobId === jobId) {\n            cleanup()\n            jsonSocket.close()\n            resolve(undefined)\n            return\n          }\n\n          if (message?.type === \"job-update-error\" && message.jobId === jobId) {\n            cleanup()\n            jsonSocket.close()\n            reject(new Error(message.error || \"Job update failed\"))\n          }\n        })\n\n        socket.on(\"connect\", () => {\n          jsonSocket.send({type: \"hello\", role: \"reporter\"})\n          jsonSocket.send({\n            type: status === \"completed\" ? \"job-complete\" : \"job-failed\",\n            jobId,\n            workerId,\n            handedOffAtMs,\n            error: error ? this._normalizeError(error) : undefined\n          })\n        })\n      })\n    })\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {\"completed\" | \"failed\"} args.status - Status.\n   * @param {unknown} [args.error] - Error.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.maxDurationMs] - Max duration for retries.\n   * @returns {Promise<void>} - Resolves when reported.\n   */\n  async reportWithRetry({jobId, status, error, handedOffAtMs, workerId, maxDurationMs}) {\n    let attempt = 0\n    const startTime = Date.now()\n\n    while (true) {\n      try {\n        await this.report({jobId, status, error, handedOffAtMs, workerId})\n        return\n      } catch (err) {\n        attempt += 1\n        const delaySeconds = Math.min(30, 0.5 * attempt)\n\n        this.logger.debug(() => [\"Background job status report failed, retrying\", err])\n\n        if (maxDurationMs && Date.now() - startTime >= maxDurationMs) {\n          this.logger.warn(() => [\"Background job status report timed out, giving up\", err])\n          return\n        }\n\n        await wait(delaySeconds)\n      }\n    }\n  }\n\n  _normalizeError(error) {\n    if (error instanceof Error) return error.stack || error.message\n    if (typeof error === \"string\") return error\n\n    try {\n      return JSON.stringify(error)\n    } catch {\n      return String(error)\n    }\n  }\n}\n"]}