velocious 1.0.713 → 1.0.714

package/README.md

@@ -39,7 +39,7 @@
 * Explicit database-free in-process HTTP applications with optional request and buffered-response byte limits (see [docs/http-server.md](docs/http-server.md#database-free-applications))
 * Client-disconnect hooks for buffered (`request.onClientDisconnect` / `request.clientDisconnected`) alongside the streaming `response.onStreamClose` so long-running handlers can settle in-flight work when the socket goes away (see [docs/http-server.md](docs/http-server.md#client-disconnect-for-buffered-requests))
 * Default-on buffered HTTP response compression with Brotli/gzip content negotiation, global and per-response opt-outs, and HEAD-correct representation headers (see [docs/http-server.md](docs/http-server.md#response-compression))
-* Background jobs with Node SQL/TCP workers plus a Browser/Expo local SQLite store and in-process dispatcher, including failure events, authorized database-scoped dashboard counts, bounded drain-stall detection/recovery for the main dispatcher (`drainStoreOperationTimeoutMs`, reported as `background-jobs-drain-stall`), and an opt-in release-scoped main/worker generation protocol with acknowledged activation, asynchronous retirement, and retired-main recovery. Production compliance additionally requires downstream supervisor retention/activation ordering and release pins (see [docs/background-jobs.md](docs/background-jobs.md), [docs/local-background-jobs.md](docs/local-background-jobs.md), and [docs/background-jobs-dashboard.md](docs/background-jobs-dashboard.md))
+* Background jobs with Node SQL/TCP workers plus a Browser/Expo local SQLite store and in-process dispatcher, including per-job-class wall-clock timeouts (`static timeoutMs`), failure events, authorized database-scoped dashboard counts, bounded drain-stall detection/recovery for the main dispatcher (`drainStoreOperationTimeoutMs`, reported as `background-jobs-drain-stall`), and an opt-in release-scoped main/worker generation protocol with acknowledged activation, asynchronous retirement, and retired-main recovery. Production compliance additionally requires downstream supervisor retention/activation ordering and release pins (see [docs/background-jobs.md](docs/background-jobs.md), [docs/local-background-jobs.md](docs/local-background-jobs.md), and [docs/background-jobs-dashboard.md](docs/background-jobs-dashboard.md))
 * Durable one-off background-job scheduling with exact epoch timestamps plus stable replacement, cancellation, normalized readback, and duplicate-free wake across Node SQL/TCP and Browser/Expo local SQLite adapters (see [docs/scheduled-background-job-enqueue.md](docs/scheduled-background-job-enqueue.md))
 * Rails-style request and database query logging with structured credential redaction (see [docs/logging.md](docs/logging.md))
 * EJS-backed mailers with delivery, queueing, and payload rendering support (see [docs/mailers.md](docs/mailers.md))

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

@@ -55,6 +55,17 @@ export default class VelociousJob {
    */
   static processTitle = undefined
 
+  /**
+   * Wall-clock bound this job class runs under, in ms. Set e.g.
+   * `static timeoutMs = 60 * 60 * 1000` on a job whose work legitimately takes
+   * hours so its type carries its own bound instead of relying on one global
+   * `backgroundJobs.jobTimeoutMs` tuned for the slowest job in the system. The
+   * `{timeoutMs}` enqueue option overrides it. A non-positive value disables the
+   * bound for this class. Left undefined, the worker-level value applies.
+   * @type {number | undefined}
+   */
+  static timeoutMs = undefined
+
   /**
    * Stops this performance and reschedules the same logical job row. This is
    * normal control flow: it does not count as a failure or consume a retry.
@@ -93,6 +104,25 @@ export default class VelociousJob {
     return merged
   }
 
+  /**
+   * Folds this job class's static `timeoutMs` into the enqueue options unless the
+   * caller already specified one, so a job type carries its own wall-clock bound
+   * instead of every job sharing one worker-level value. A class that declares
+   * nothing leaves the option absent, and the worker falls back to its own
+   * default — the prior behavior.
+   * @param {import("./types.js").BackgroundJobOptions | undefined} options - Job options.
+   * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved timeout.
+   */
+  static _withTimeout(options) {
+    const merged = options ? {...options} : {}
+
+    if (merged.timeoutMs === undefined && typeof this.timeoutMs === "number") {
+      merged.timeoutMs = this.timeoutMs
+    }
+
+    return merged
+  }
+
   /**
    * Resolves class-derived enqueue options on a hydrated job instance. Explicit
    * per-enqueue options take precedence over the instance concurrency key.
@@ -102,7 +132,7 @@ export default class VelociousJob {
    * @returns {import("./types.js").BackgroundJobOptions} - Resolved job options.
    */
   static _withJobContext({jobArgs, jobOptions}) {
-    const options = this._withQueue(jobOptions)
+    const options = this._withTimeout(this._withQueue(jobOptions))
 
     if (options.concurrencyKey !== undefined) return options
 

package/build/background-jobs/types.js

@@ -175,7 +175,7 @@
  * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.
  * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.
  * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.
- * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
+ * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides a job class's `static timeoutMs` and the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
  */
 /**
  * @typedef {object} BackgroundJobPayload

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

@@ -39,6 +39,16 @@ export default class VelociousJob<TArgs extends Array<ReturnType<typeof JSON.par
      * @type {string | undefined}
      */
     static processTitle: string | undefined;
+    /**
+     * Wall-clock bound this job class runs under, in ms. Set e.g.
+     * `static timeoutMs = 60 * 60 * 1000` on a job whose work legitimately takes
+     * hours so its type carries its own bound instead of relying on one global
+     * `backgroundJobs.jobTimeoutMs` tuned for the slowest job in the system. The
+     * `{timeoutMs}` enqueue option overrides it. A non-positive value disables the
+     * bound for this class. Left undefined, the worker-level value applies.
+     * @type {number | undefined}
+     */
+    static timeoutMs: number | undefined;
     /**
      * Stops this performance and reschedules the same logical job row. This is
      * normal control flow: it does not count as a failure or consume a retry.
@@ -58,6 +68,16 @@ export default class VelociousJob<TArgs extends Array<ReturnType<typeof JSON.par
      * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved queue.
      */
     static _withQueue(options: import("./types.js").BackgroundJobOptions | undefined): import("./types.js").BackgroundJobOptions;
+    /**
+     * Folds this job class's static `timeoutMs` into the enqueue options unless the
+     * caller already specified one, so a job type carries its own wall-clock bound
+     * instead of every job sharing one worker-level value. A class that declares
+     * nothing leaves the option absent, and the worker falls back to its own
+     * default — the prior behavior.
+     * @param {import("./types.js").BackgroundJobOptions | undefined} options - Job options.
+     * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved timeout.
+     */
+    static _withTimeout(options: import("./types.js").BackgroundJobOptions | undefined): import("./types.js").BackgroundJobOptions;
     /**
      * Resolves class-derived enqueue options on a hydrated job instance. Explicit
      * per-enqueue options take precedence over the instance concurrency key.

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

@@ -1 +1 @@
-{"version":3,"file":"platform-job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/platform-job.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"platform-job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/platform-job.js"],"names":[],"mappings":"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"}

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

@@ -43,6 +43,16 @@ export default class VelociousJob {
      * @type {string | undefined}
      */
     static processTitle = undefined;
+    /**
+     * Wall-clock bound this job class runs under, in ms. Set e.g.
+     * `static timeoutMs = 60 * 60 * 1000` on a job whose work legitimately takes
+     * hours so its type carries its own bound instead of relying on one global
+     * `backgroundJobs.jobTimeoutMs` tuned for the slowest job in the system. The
+     * `{timeoutMs}` enqueue option overrides it. A non-positive value disables the
+     * bound for this class. Left undefined, the worker-level value applies.
+     * @type {number | undefined}
+     */
+    static timeoutMs = undefined;
     /**
      * Stops this performance and reschedules the same logical job row. This is
      * normal control flow: it does not count as a failure or consume a retry.
@@ -75,6 +85,22 @@ export default class VelociousJob {
         }
         return merged;
     }
+    /**
+     * Folds this job class's static `timeoutMs` into the enqueue options unless the
+     * caller already specified one, so a job type carries its own wall-clock bound
+     * instead of every job sharing one worker-level value. A class that declares
+     * nothing leaves the option absent, and the worker falls back to its own
+     * default — the prior behavior.
+     * @param {import("./types.js").BackgroundJobOptions | undefined} options - Job options.
+     * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved timeout.
+     */
+    static _withTimeout(options) {
+        const merged = options ? { ...options } : {};
+        if (merged.timeoutMs === undefined && typeof this.timeoutMs === "number") {
+            merged.timeoutMs = this.timeoutMs;
+        }
+        return merged;
+    }
     /**
      * Resolves class-derived enqueue options on a hydrated job instance. Explicit
      * per-enqueue options take precedence over the instance concurrency key.
@@ -84,7 +110,7 @@ export default class VelociousJob {
      * @returns {import("./types.js").BackgroundJobOptions} - Resolved job options.
      */
     static _withJobContext({ jobArgs, jobOptions }) {
-        const options = this._withQueue(jobOptions);
+        const options = this._withTimeout(this._withQueue(jobOptions));
         if (options.concurrencyKey !== undefined)
             return options;
         const jobInstance = new this();
@@ -207,4 +233,4 @@ export default class VelociousJob {
         throw new Error("perform not implemented");
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-job.js","sourceRoot":"","sources":["../../../src/background-jobs/platform-job.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,6BAA6B,MAAM,wBAAwB,CAAA;AAClE,OAAO,EACL,4BAA4B,EAC5B,oBAAoB,EACpB,yBAAyB,EACzB,6BAA6B,EAC7B,0BAA0B,EAC3B,MAAM,cAAc,CAAA;AAErB;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B;QACE,oEAAoE;QACpE,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAA;IACxC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,mBAAmB,GAAG,SAAS,CAAA;IAEtC;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,GAAG,SAAS,CAAA;IAExB;;;;;;;;;OASG;IACH,MAAM,CAAC,YAAY,GAAG,SAAS,CAAA;IAE/B;;;;;OAKG;IACH,YAAY,CAAC,OAAO;QAClB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,SAAS,CAAC,uEAAuE,CAAC,CAAA;QAC9F,CAAC;QAED,MAAM,IAAI,6BAA6B,CAAC,OAAO,CAAC,CAAA;IAClD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO;QACvB,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAC,GAAG,OAAO,EAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAE1C,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1F,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;QAC3B,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAAC,EAAC,OAAO,EAAE,UAAU,EAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAA;QAE3C,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS;YAAE,OAAO,OAAO,CAAA;QAExD,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAA;QAC9B,WAAW,CAAC,wBAAwB,CAAC;YACnC,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE;YACvB,OAAO;SACR,CAAC,CAAA;QACF,MAAM,cAAc,GAAG,WAAW,CAAC,cAAc,EAAE,CAAA;QAEnD,IAAI,cAAc,KAAK,SAAS;YAAE,OAAO,CAAC,cAAc,GAAG,cAAc,CAAA;QAEzE,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;;OAKG;IACH,wBAAwB,CAAC,OAAO;QAC9B,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAA;IACtC,CAAC;IAED;;;OAGG;IACH,oBAAoB;QAClB,IAAI,CAAC,IAAI,CAAC,qBAAqB;YAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;QAE1F,OAAO,IAAI,CAAC,qBAAqB,CAAA;IACnC,CAAC;IAED;;;;;OAKG;IACH,cAAc;QACZ,OAAO,SAAS,CAAA;IAClB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI;QAC/B,MAAM,EAAC,OAAO,EAAE,UAAU,EAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAA;QAC7D,OAAO,MAAM,oBAAoB,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAC,CAAC,CAAA;IAC1E,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC;QAClD,OAAO,MAAM,oBAAoB,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;IACzF,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC;QACxD,OAAO,MAAM,6BAA6B,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;IAC/G,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW;QACtC,OAAO,MAAM,4BAA4B,CAAC,WAAW,CAAC,CAAA;IACxD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW,EAAE,OAAO,GAAG,EAAE;QACpD,OAAO,MAAM,yBAAyB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IAC9D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,WAAW;QACpC,OAAO,MAAM,0BAA0B,CAAC,WAAW,CAAC,CAAA;IACtD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,IAAI;QAC9B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAC,CAAA;QACtC,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QACrC,MAAM,YAAY,GAAG,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,YAAY,IAAI,OAAO,CAAA;QAEjH,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,EAAC,UAAU,EAAC,GAAG,sEAAsE,CAAC,CAAC,OAAO,CAAC,CAAA;YACrG,OAAO,EAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,IAAI,EAAE,EAAC,CAAA;QACnE,CAAC;QAED,OAAO,EAAC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAC,CAAA;IACxC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK;QACpB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAA;IAC5C,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport BackgroundJobRescheduleSignal from \"./reschedule-signal.js\"\nimport {\n  cancelScheduledBackgroundJob,\n  enqueueBackgroundJob,\n  getScheduledBackgroundJob,\n  replaceScheduledBackgroundJob,\n  wakeScheduledBackgroundJob\n} from \"./runtime.js\"\n\n/**\n * Base class for background jobs.\n *\n * `TArgs` is the tuple of arguments the subclass's `perform` accepts, so a job that\n * needs arguments declares them as required and typed — for example\n * `class RunBuildJob extends VelociousJob<[string]>` with `async perform(buildId)`.\n * The default empty tuple keeps argument-less jobs (`extends VelociousJob`,\n * `async perform()`) working unchanged.\n * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]\n */\nexport default class VelociousJob {\n  constructor() {\n    /** @type {import(\"./types.js\").BackgroundJobContext | undefined} */\n    this._backgroundJobContext = undefined\n  }\n\n  /**\n   * Database identifiers checked out while this job performs. Set an explicit\n   * list to avoid holding unrelated configured database connections, or `[]`\n   * when the job establishes any connections it needs itself. Left undefined,\n   * jobs retain the existing behavior of checking out every active database.\n   * @type {string[] | undefined}\n   */\n  static databaseIdentifiers = undefined\n\n  /**\n   * Queue this job class runs on. Subclasses set e.g. `static queue = \"builds\"`\n   * to route onto a queue with its own cluster-wide concurrency cap (configured\n   * via `backgroundJobs.queues`). The `{queue}` enqueue option overrides it.\n   * Left undefined, jobs run on the `\"default\"` queue.\n   * @type {string | undefined}\n   */\n  static queue = undefined\n\n  /**\n   * Optional process title shown for the runner while this job executes.\n   * Velocious sets `process.title` to this for the duration of the job — so\n   * `ps`/`top`/`htop` identify what a runner is doing — and restores the\n   * runner's base title when the job finishes. Left undefined, the runner falls\n   * back to `velocious job-runner: <JobName>`. Set e.g.\n   * `static processTitle = \"velocious media transcoder\"` to give a job a\n   * custom, human-readable title.\n   * @type {string | undefined}\n   */\n  static processTitle = undefined\n\n  /**\n   * Stops this performance and reschedules the same logical job row. This is\n   * normal control flow: it does not count as a failure or consume a retry.\n   * @param {number} delayMs - Non-negative safe-integer delay in milliseconds.\n   * @returns {never} - This method never returns.\n   */\n  rescheduleIn(delayMs) {\n    if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n      throw new TypeError(\"background job reschedule delayMs must be a non-negative safe integer\")\n    }\n\n    throw new BackgroundJobRescheduleSignal(delayMs)\n  }\n\n  /**\n   * Runs job name.\n   * @returns {string} - Job name.\n   */\n  static jobName() {\n    return this.name\n  }\n\n  /**\n   * Folds this job class's static `queue` into the enqueue options unless the\n   * caller already specified one.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Options including the resolved queue.\n   */\n  static _withQueue(options) {\n    const merged = options ? {...options} : {}\n\n    if (merged.queue === undefined && typeof this.queue === \"string\" && this.queue.length > 0) {\n      merged.queue = this.queue\n    }\n\n    return merged\n  }\n\n  /**\n   * Resolves class-derived enqueue options on a hydrated job instance. Explicit\n   * per-enqueue options take precedence over the instance concurrency key.\n   * @param {object} args - Job context.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} args.jobOptions - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Resolved job options.\n   */\n  static _withJobContext({jobArgs, jobOptions}) {\n    const options = this._withQueue(jobOptions)\n\n    if (options.concurrencyKey !== undefined) return options\n\n    const jobInstance = new this()\n    jobInstance._setBackgroundJobContext({\n      args: jobArgs,\n      jobClass: this,\n      jobName: this.jobName(),\n      options\n    })\n    const concurrencyKey = jobInstance.concurrencyKey()\n\n    if (concurrencyKey !== undefined) options.concurrencyKey = concurrencyKey\n\n    return options\n  }\n\n  /**\n   * Sets the complete context available to this hydrated job instance.\n   * Framework enqueue/runner boundaries own this method.\n   * @param {import(\"./types.js\").BackgroundJobContext} context - Job context.\n   * @returns {void}\n   */\n  _setBackgroundJobContext(context) {\n    this._backgroundJobContext = context\n  }\n\n  /**\n   * Returns this hydrated job's complete enqueue or runner context.\n   * @returns {import(\"./types.js\").BackgroundJobContext} - Job context.\n   */\n  backgroundJobContext() {\n    if (!this._backgroundJobContext) throw new Error(\"Background job context is not hydrated\")\n\n    return this._backgroundJobContext\n  }\n\n  /**\n   * Override to derive a durable concurrency key from `backgroundJobContext()`.\n   * Pair the derived key with `maxConcurrency` in enqueue options. An explicit\n   * per-enqueue `concurrencyKey` takes precedence and skips this method.\n   * @returns {string | undefined} - Derived concurrency key, or undefined for none.\n   */\n  concurrencyKey() {\n    return undefined\n  }\n\n  /**\n   * Runs perform later.\n   * @param {...ReturnType<typeof JSON.parse>} args - Job args.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLater(...args) {\n    const {jobArgs, jobOptions} = this._splitArgsAndOptions(args)\n    return await enqueueBackgroundJob({JobClass: this, jobArgs, jobOptions})\n  }\n\n  /**\n   * Runs perform later with options.\n   * @param {object} args - Options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLaterWithOptions({args, options}) {\n    return await enqueueBackgroundJob({JobClass: this, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Atomically replaces this job class's queued owner for a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  static async replaceScheduled({scheduleKey, args, options}) {\n    return await replaceScheduledBackgroundJob({JobClass: this, scheduleKey, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  static async cancelScheduled(scheduleKey) {\n    return await cancelScheduledBackgroundJob(scheduleKey)\n  }\n\n  /**\n   * Reads current ownership and optional terminal history for a stable key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.\n   */\n  static async getScheduledJob(scheduleKey, options = {}) {\n    return await getScheduledBackgroundJob(scheduleKey, options)\n  }\n\n  /**\n   * Expedites a future queued owner without creating another job.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobWakeResult>} - Wake result.\n   */\n  static async wakeScheduled(scheduleKey) {\n    return await wakeScheduledBackgroundJob(scheduleKey)\n  }\n\n  /**\n   * Runs split args and options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args - Job args.\n   * @returns {{jobArgs: Array<ReturnType<typeof JSON.parse>>, jobOptions: import(\"./types.js\").BackgroundJobOptions}} - Split args and options.\n   */\n  static _splitArgsAndOptions(args) {\n    if (args.length === 0) {\n      return {jobArgs: [], jobOptions: {}}\n    }\n\n    const lastArg = args[args.length - 1]\n    const isOptionsArg = lastArg && typeof lastArg === \"object\" && !Array.isArray(lastArg) && \"jobOptions\" in lastArg\n\n    if (isOptionsArg) {\n      const {jobOptions} = /** @type {{jobOptions: import(\"./types.js\").BackgroundJobOptions}} */ (lastArg)\n      return {jobArgs: args.slice(0, -1), jobOptions: jobOptions || {}}\n    }\n\n    return {jobArgs: args, jobOptions: {}}\n  }\n\n  /**\n   * Override in subclasses.\n   * @param {TArgs} _args - Job args (the tuple this job class was parameterized with).\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async perform(..._args) {\n    throw new Error(\"perform not implemented\")\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-job.js","sourceRoot":"","sources":["../../../src/background-jobs/platform-job.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BackgroundJobRescheduleSignal from \"./reschedule-signal.js\"\nimport {\n  cancelScheduledBackgroundJob,\n  enqueueBackgroundJob,\n  getScheduledBackgroundJob,\n  replaceScheduledBackgroundJob,\n  wakeScheduledBackgroundJob\n} from \"./runtime.js\"\n\n/**\n * Base class for background jobs.\n *\n * `TArgs` is the tuple of arguments the subclass's `perform` accepts, so a job that\n * needs arguments declares them as required and typed — for example\n * `class RunBuildJob extends VelociousJob<[string]>` with `async perform(buildId)`.\n * The default empty tuple keeps argument-less jobs (`extends VelociousJob`,\n * `async perform()`) working unchanged.\n * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]\n */\nexport default class VelociousJob {\n  constructor() {\n    /** @type {import(\"./types.js\").BackgroundJobContext | undefined} */\n    this._backgroundJobContext = undefined\n  }\n\n  /**\n   * Database identifiers checked out while this job performs. Set an explicit\n   * list to avoid holding unrelated configured database connections, or `[]`\n   * when the job establishes any connections it needs itself. Left undefined,\n   * jobs retain the existing behavior of checking out every active database.\n   * @type {string[] | undefined}\n   */\n  static databaseIdentifiers = undefined\n\n  /**\n   * Queue this job class runs on. Subclasses set e.g. `static queue = \"builds\"`\n   * to route onto a queue with its own cluster-wide concurrency cap (configured\n   * via `backgroundJobs.queues`). The `{queue}` enqueue option overrides it.\n   * Left undefined, jobs run on the `\"default\"` queue.\n   * @type {string | undefined}\n   */\n  static queue = undefined\n\n  /**\n   * Optional process title shown for the runner while this job executes.\n   * Velocious sets `process.title` to this for the duration of the job — so\n   * `ps`/`top`/`htop` identify what a runner is doing — and restores the\n   * runner's base title when the job finishes. Left undefined, the runner falls\n   * back to `velocious job-runner: <JobName>`. Set e.g.\n   * `static processTitle = \"velocious media transcoder\"` to give a job a\n   * custom, human-readable title.\n   * @type {string | undefined}\n   */\n  static processTitle = undefined\n\n  /**\n   * Wall-clock bound this job class runs under, in ms. Set e.g.\n   * `static timeoutMs = 60 * 60 * 1000` on a job whose work legitimately takes\n   * hours so its type carries its own bound instead of relying on one global\n   * `backgroundJobs.jobTimeoutMs` tuned for the slowest job in the system. The\n   * `{timeoutMs}` enqueue option overrides it. A non-positive value disables the\n   * bound for this class. Left undefined, the worker-level value applies.\n   * @type {number | undefined}\n   */\n  static timeoutMs = undefined\n\n  /**\n   * Stops this performance and reschedules the same logical job row. This is\n   * normal control flow: it does not count as a failure or consume a retry.\n   * @param {number} delayMs - Non-negative safe-integer delay in milliseconds.\n   * @returns {never} - This method never returns.\n   */\n  rescheduleIn(delayMs) {\n    if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n      throw new TypeError(\"background job reschedule delayMs must be a non-negative safe integer\")\n    }\n\n    throw new BackgroundJobRescheduleSignal(delayMs)\n  }\n\n  /**\n   * Runs job name.\n   * @returns {string} - Job name.\n   */\n  static jobName() {\n    return this.name\n  }\n\n  /**\n   * Folds this job class's static `queue` into the enqueue options unless the\n   * caller already specified one.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Options including the resolved queue.\n   */\n  static _withQueue(options) {\n    const merged = options ? {...options} : {}\n\n    if (merged.queue === undefined && typeof this.queue === \"string\" && this.queue.length > 0) {\n      merged.queue = this.queue\n    }\n\n    return merged\n  }\n\n  /**\n   * Folds this job class's static `timeoutMs` into the enqueue options unless the\n   * caller already specified one, so a job type carries its own wall-clock bound\n   * instead of every job sharing one worker-level value. A class that declares\n   * nothing leaves the option absent, and the worker falls back to its own\n   * default — the prior behavior.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Options including the resolved timeout.\n   */\n  static _withTimeout(options) {\n    const merged = options ? {...options} : {}\n\n    if (merged.timeoutMs === undefined && typeof this.timeoutMs === \"number\") {\n      merged.timeoutMs = this.timeoutMs\n    }\n\n    return merged\n  }\n\n  /**\n   * Resolves class-derived enqueue options on a hydrated job instance. Explicit\n   * per-enqueue options take precedence over the instance concurrency key.\n   * @param {object} args - Job context.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} args.jobOptions - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Resolved job options.\n   */\n  static _withJobContext({jobArgs, jobOptions}) {\n    const options = this._withTimeout(this._withQueue(jobOptions))\n\n    if (options.concurrencyKey !== undefined) return options\n\n    const jobInstance = new this()\n    jobInstance._setBackgroundJobContext({\n      args: jobArgs,\n      jobClass: this,\n      jobName: this.jobName(),\n      options\n    })\n    const concurrencyKey = jobInstance.concurrencyKey()\n\n    if (concurrencyKey !== undefined) options.concurrencyKey = concurrencyKey\n\n    return options\n  }\n\n  /**\n   * Sets the complete context available to this hydrated job instance.\n   * Framework enqueue/runner boundaries own this method.\n   * @param {import(\"./types.js\").BackgroundJobContext} context - Job context.\n   * @returns {void}\n   */\n  _setBackgroundJobContext(context) {\n    this._backgroundJobContext = context\n  }\n\n  /**\n   * Returns this hydrated job's complete enqueue or runner context.\n   * @returns {import(\"./types.js\").BackgroundJobContext} - Job context.\n   */\n  backgroundJobContext() {\n    if (!this._backgroundJobContext) throw new Error(\"Background job context is not hydrated\")\n\n    return this._backgroundJobContext\n  }\n\n  /**\n   * Override to derive a durable concurrency key from `backgroundJobContext()`.\n   * Pair the derived key with `maxConcurrency` in enqueue options. An explicit\n   * per-enqueue `concurrencyKey` takes precedence and skips this method.\n   * @returns {string | undefined} - Derived concurrency key, or undefined for none.\n   */\n  concurrencyKey() {\n    return undefined\n  }\n\n  /**\n   * Runs perform later.\n   * @param {...ReturnType<typeof JSON.parse>} args - Job args.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLater(...args) {\n    const {jobArgs, jobOptions} = this._splitArgsAndOptions(args)\n    return await enqueueBackgroundJob({JobClass: this, jobArgs, jobOptions})\n  }\n\n  /**\n   * Runs perform later with options.\n   * @param {object} args - Options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLaterWithOptions({args, options}) {\n    return await enqueueBackgroundJob({JobClass: this, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Atomically replaces this job class's queued owner for a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  static async replaceScheduled({scheduleKey, args, options}) {\n    return await replaceScheduledBackgroundJob({JobClass: this, scheduleKey, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  static async cancelScheduled(scheduleKey) {\n    return await cancelScheduledBackgroundJob(scheduleKey)\n  }\n\n  /**\n   * Reads current ownership and optional terminal history for a stable key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.\n   */\n  static async getScheduledJob(scheduleKey, options = {}) {\n    return await getScheduledBackgroundJob(scheduleKey, options)\n  }\n\n  /**\n   * Expedites a future queued owner without creating another job.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobWakeResult>} - Wake result.\n   */\n  static async wakeScheduled(scheduleKey) {\n    return await wakeScheduledBackgroundJob(scheduleKey)\n  }\n\n  /**\n   * Runs split args and options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args - Job args.\n   * @returns {{jobArgs: Array<ReturnType<typeof JSON.parse>>, jobOptions: import(\"./types.js\").BackgroundJobOptions}} - Split args and options.\n   */\n  static _splitArgsAndOptions(args) {\n    if (args.length === 0) {\n      return {jobArgs: [], jobOptions: {}}\n    }\n\n    const lastArg = args[args.length - 1]\n    const isOptionsArg = lastArg && typeof lastArg === \"object\" && !Array.isArray(lastArg) && \"jobOptions\" in lastArg\n\n    if (isOptionsArg) {\n      const {jobOptions} = /** @type {{jobOptions: import(\"./types.js\").BackgroundJobOptions}} */ (lastArg)\n      return {jobArgs: args.slice(0, -1), jobOptions: jobOptions || {}}\n    }\n\n    return {jobArgs: args, jobOptions: {}}\n  }\n\n  /**\n   * Override in subclasses.\n   * @param {TArgs} _args - Job args (the tuple this job class was parameterized with).\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async perform(..._args) {\n    throw new Error(\"perform not implemented\")\n  }\n}\n"]}

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

@@ -464,7 +464,7 @@ export type BackgroundJobOptions = {
      */
     scheduledAtMs?: number;
     /**
-     * - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
+     * - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides a job class's `static timeoutMs` and the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
      */
     timeoutMs?: number;
 };
@@ -1047,7 +1047,7 @@ export type BackgroundJobSocketMessage = BackgroundJobHelloMessage | BackgroundJ
  * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.
  * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.
  * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.
- * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
+ * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides a job class's `static timeoutMs` and the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
  */
 /**
  * @typedef {object} BackgroundJobPayload

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

@@ -174,7 +174,7 @@
  * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.
  * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.
  * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.
- * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
+ * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides a job class's `static timeoutMs` and the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
  */
 /**
  * @typedef {object} BackgroundJobPayload
@@ -303,4 +303,4 @@
  * @typedef {BackgroundJobHelloMessage | BackgroundJobGenerationAcceptedMessage | BackgroundJobGenerationRejectedMessage | BackgroundJobReadyMessage | BackgroundJobDrainingMessage | BackgroundJobHeartbeatMessage | BackgroundJobEnqueueMessage | BackgroundJobEnqueuedMessage | BackgroundJobEnqueueErrorMessage | BackgroundJobReplaceScheduledMessage | BackgroundJobScheduleReplacedMessage | BackgroundJobReplaceScheduledErrorMessage | BackgroundJobCancelScheduledMessage | BackgroundJobScheduleCancelledMessage | BackgroundJobCancelScheduledErrorMessage | BackgroundJobGetScheduledMessage | BackgroundJobScheduledMessage | BackgroundJobGetScheduledErrorMessage | BackgroundJobWakeScheduledMessage | BackgroundJobScheduleWokenMessage | BackgroundJobWakeScheduledErrorMessage | BackgroundJobJobMessage | BackgroundJobAcceptedMessage | BackgroundJobCompleteMessage | BackgroundJobFailedMessage | BackgroundJobRescheduleMessage | BackgroundJobUpdatedMessage | BackgroundJobUpdateErrorMessage} BackgroundJobSocketMessage
  */
 export const nothing = {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/background-jobs/types.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;GAEG;AACH,yFAAyF;AACzF,iIAAiI;AACjI,6NAA6N;AAC7N,mEAAmE;AACnE,+FAA+F;AAC/F,6FAA6F;AAC7F,mGAAmG;AACnG,gFAAgF;AAChF,uPAAuP;AACvP;;;GAGG;AACH,wFAAwF;AACxF;;;;;;;;GAQG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;;;;;;;;;GAUG;AACH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;GAYG;AACH;;;GAGG;AACH;;;;;;;GAOG;AACH;;;;;GAKG;AACH;;;;;;GAMG;AACH;;;;;GAKG;AACH;;;;;;;;;;;GAWG;AACH;;;;;;;;;GASG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;GAEG;AACH;;;;;GAKG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;GAIG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;;;;;;;;GAWG;AACH;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;GAEG;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAA","sourcesContent":["// @ts-check\n\n/**\n * @typedef {\"inline\" | \"forked\" | \"pooled\" | \"spawned\"} BackgroundJobExecutionMode\n */\n/** @typedef {\"candidate\" | \"active\" | \"retired\"} BackgroundJobsGenerationInitialState */\n/** @typedef {\"starting\" | \"candidate\" | \"active\" | \"retiring\" | \"retired\" | \"stopped\"} BackgroundJobsGenerationLifecycleState */\n/** @typedef {\"missing-generation\" | \"unexpected-generation\" | \"malformed-generation\" | \"generation-mismatch\" | \"worker-admission-retired\" | \"worker-has-no-recoverable-handoffs\"} BackgroundJobsGenerationRejectionReason */\n/** @typedef {\"queued\" | \"handed_off\"} BackgroundJobActiveStatus */\n/** @typedef {\"cancelled\" | \"completed\" | \"failed\" | \"orphaned\"} BackgroundJobTerminalStatus */\n/** @typedef {BackgroundJobActiveStatus | BackgroundJobTerminalStatus} BackgroundJobStatus */\n/** @typedef {\"exit\" | \"process-error\" | \"ipc-send\" | \"child-silence\"} PooledRunnerFailureOrigin */\n/** @typedef {\"starting\" | \"running\" | \"retiring\"} PooledRunnerLifecycleState */\n/** @typedef {\"parent_retire_drained\" | \"job_timeout\" | \"worker_stop\" | \"child_silence\" | \"signal_sigterm\" | \"signal_sigint\" | \"signal_sigkill\" | \"signal_other\" | \"ipc_disconnect\" | \"process_error\" | \"unexpected_exit\"} PooledChildShutdownReason */\n/**\n * @deprecated Use PooledChildShutdownReason for exact shutdown provenance.\n * @typedef {\"unexpected\" | \"job-timeout\" | \"worker-shutdown-timeout\"} PooledRunnerTerminationReason\n */\n/** @typedef {\"running\" | \"retiring\" | \"stopping\"} BackgroundJobsWorkerLifecycleState */\n/**\n * Exact durable handoff ownership carried by an executing job when it produces\n * follow-up work.\n * @typedef {object} BackgroundJobProducerProof\n * @property {string} jobId - Producing job id.\n * @property {string} handoffId - Producing handoff lease id.\n * @property {string} workerId - Worker identity persisted with the handoff.\n * @property {number} handedOffAtMs - Durable handoff timestamp.\n */\n/**\n * @typedef {object} PooledRunnerActiveJob\n * @property {string | null} handoffId - Durable handoff lease id.\n * @property {number | null} handedOffAtMs - Durable handoff timestamp.\n * @property {string} jobId - Durable background job id.\n * @property {string} jobName - Registered job class name.\n * @property {string} workerId - Worker identity persisted with the handoff.\n */\n/**\n * One process-failure snapshot shared by every job lost with a pooled child.\n * @typedef {object} PooledRunnerFailure\n * @property {PooledRunnerActiveJob[]} activeJobs - Jobs that were in flight when the child failed, ordered by job id.\n * @property {string | null} childInstanceId - Stable pooled-child identity when its startup or shutdown observation arrived.\n * @property {number | null} exitCode - Child exit code, or null for signal/process errors.\n * @property {string | null} generationId - Release generation identity, or null in legacy mode.\n * @property {string[]} inflightJobIds - Bounded job ids in flight when failure handling started.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {boolean | null} oomKilled - False when the observed exit rules OOM out; null when an unexpected SIGKILL cannot be distinguished from an OOM kill without supervisor/kernel evidence.\n * @property {PooledRunnerFailureOrigin} origin - Worker observation that initiated failure handling.\n * @property {number} runnerAgeMs - Child age when failure handling started.\n * @property {number} runnerCreatedAtMs - Child creation timestamp.\n * @property {boolean} runnerDetached - Whether the runner owned a detached process group.\n * @property {number} runnerJobsRun - Previously acknowledged jobs handled by the child.\n * @property {PooledRunnerLifecycleState} runnerLifecycle - Child lifecycle immediately before recovery.\n * @property {number | null} runnerPid - Child process id when available.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Child termination signal when available.\n * @property {number | null} shutdownObservedAtMs - Time the child or parent observed shutdown beginning.\n * @property {number | null} shutdownRequestedAtMs - Exact parent request timestamp, or null for external/unrequested shutdown.\n * @property {PooledChildShutdownReason} shutdownReason - Exact recorded parent request or observed child shutdown cause.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} shutdownSignal - Parent-requested or child-observed shutdown signal when available.\n * @property {PooledRunnerTerminationReason} terminationReason - Deprecated compatibility category; use shutdownReason for exact provenance.\n * @property {string | null} timeoutJobId - Job whose timeout initiated child termination, or null.\n * @property {string} workerId - Stable generation-qualified worker id.\n * @property {BackgroundJobsWorkerLifecycleState} workerLifecycle - Parent worker lifecycle immediately before recovery.\n * @property {number} workerPid - Parent worker process id.\n */\n/**\n * Best-effort observation sent before a pooled child closes its resources.\n * @typedef {object} PooledChildShutdownObservation\n * @property {string} childInstanceId - Stable pooled-child identity.\n * @property {string[]} inflightJobIds - Bounded in-flight durable job ids.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {PooledChildShutdownReason} reason - Shutdown reason observed by the child.\n * @property {number} shutdownObservedAtMs - Child observation timestamp.\n * @property {number | null} shutdownRequestedAtMs - Parent request timestamp when supplied over IPC.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Requested or observed signal when available.\n */\n/**\n * Bounded pooled-child memory observation sent over the child IPC channel.\n * The pooled child's stdio is ignored by the worker fork, so this observation\n * (sent periodically while jobs run, plus on demand) is how a memory problem\n * in a running child names itself. `heapStatistics` and `memoryUsage`\n * distinguish V8-heap growth from external/array-buffer (native resource)\n * growth; `activeJobIds` ties the sample to the work that was in flight.\n * @typedef {object} PooledChildMemoryObservation\n * @property {string[]} activeJobIds - In-flight job ids, bounded.\n * @property {number} activeJobIdsTruncatedCount - In-flight job ids omitted by the bound.\n * @property {string} childInstanceId - Stable identity reported by the child.\n * @property {number} childPid - Child process id.\n * @property {number} childUptimeMs - Child process uptime in ms.\n * @property {ReturnType<typeof import(\"node:v8\").getHeapStatistics>} heapStatistics - V8 heap-stat breakdown at the sample.\n * @property {number} jobCount - In-flight job count.\n * @property {ReturnType<typeof import(\"node:process\").memoryUsage>} memoryUsage - Process memory breakdown at the sample.\n * @property {number} observedAtMs - Epoch ms the child sampled.\n * @property {number} peakRssBytes - Child-reported peak RSS (kernel `VmHWM` high-water mark) in bytes, monotonic for the child's life.\n * @property {number} rssBytes - Resident set size in bytes at the sample.\n * @property {\"pooled-child-memory\"} type - Discriminator.\n * @property {number} uptimeMs - Process uptime in ms.\n */\n/**\n * @typedef {object} LocalBackgroundJobsClock\n * @property {() => number} now - Current epoch milliseconds.\n * @property {(callback: () => void, delayMs: number) => ReturnType<typeof setTimeout> | number} setTimeout - Arms a timer.\n * @property {(timerId: ReturnType<typeof setTimeout> | number) => void} clearTimeout - Clears a timer.\n */\n/**\n * @typedef {object} ResolvedBackgroundJobConcurrency\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} maxConcurrency - Positive cap.\n * @property {boolean} queueDerived - Whether queue configuration owns the cap.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyRepair\n * @property {number} activeCount - Exact handed-off job count persisted by the repair.\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} previousActiveCount - Persisted count replaced by the repair.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyReconciliation\n * @property {number} candidateCount - Snapshot mismatches rechecked under their counter locks.\n * @property {number} checkedCount - Active or nonzero durable counters compared in the initial snapshot.\n * @property {number} repairedCount - Counters whose persisted values were changed.\n * @property {BackgroundJobConcurrencyRepair[]} repairs - Bounded deterministic sample of applied repairs.\n * @property {number} repairsTruncatedCount - Applied repairs omitted from the sample.\n */\n/**\n * @typedef {object} PreparedLocalBackgroundJob\n * @property {string} argsDigest - Fixed-width digest of the serialized arguments.\n * @property {string} argsJson - Serialized arguments.\n * @property {ResolvedBackgroundJobConcurrency | null} concurrency - Resolved concurrency.\n * @property {number} createdAtMs - Creation timestamp.\n * @property {\"inline\"} executionMode - Local in-process execution mode.\n * @property {string} jobId - Durable id.\n * @property {string} jobName - Registered name.\n * @property {number} maxRetries - Retry cap.\n * @property {string} queue - Queue name.\n * @property {number} scheduledAtMs - Eligibility timestamp.\n */\n/**\n * @typedef {object} BackgroundJobsHealth\n * @property {boolean} ready - Whether the adapter can accept and process work.\n */\n/**\n * @typedef {object} BackgroundJobsProducer\n * @property {(args: {jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}) => Promise<string>} enqueue - Enqueues a job.\n * @property {(args: {scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}) => Promise<BackgroundJobReplacementResult>} replaceScheduled - Replaces a stable schedule.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobCancellationResult>} cancelScheduled - Cancels a stable schedule.\n * @property {(args: {scheduleKey: string, includeLatestTerminal?: boolean}) => Promise<BackgroundJobScheduledLookupResult>} getScheduledJob - Reads stable schedule ownership and history.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobWakeResult>} wakeScheduled - Expedites a stable schedule owner.\n */\n/**\n * @typedef {object} BackgroundJobHandoff\n * @property {string} handoffId - Unique handoff lease id.\n * @property {number} handedOffAtMs - Time handed to a worker in ms.\n * @property {BackgroundJobRow} [job] - Exact committed job snapshot when the adapter changes dispatch data during the claim.\n */\n/**\n * @typedef {object} BackgroundJobHandoffSnapshot\n * @property {string} jobId - Job holding the lease.\n * @property {string} handoffId - Exact durable lease id.\n * @property {string} workerId - Stable worker id that received the lease.\n * @property {number} handedOffAtMs - Time handed to the worker in ms.\n */\n/**\n * @typedef {object} BackgroundJobHandoffRequest\n * @property {string} jobId - Job to claim.\n * @property {string} [handoffId] - Exact caller-selected lease id. Adapters must persist and return this id when supplied; built-in adapters generate one when omitted for legacy direct callers.\n * @property {string} [workerId] - Worker claiming the job.\n */\n/**\n * @typedef {object} BackgroundJobOptions\n * @property {BackgroundJobExecutionMode} [executionMode] - How the job should run. Node defaults to `\"pooled\"` (a warm, reused local runner process). Browser/Expo local dispatch defaults to and only accepts `\"inline\"`. `\"forked\"` runs a Node job in a fresh `child_process.fork()` child, and `\"spawned\"` in a detached CLI runner.\n * @property {number} [maxRetries] - Max retries for a failed job before it is marked failed.\n * @property {string} [queue] - Queue name. Defaults to `\"default\"`. When the queue has a configured cap in `backgroundJobs.queues`, that cap is enforced cluster-wide.\n * @property {string} [concurrencyKey] - Opaque non-empty key used to share a concurrency cap. Overrides any queue-derived cap.\n * @property {number} [maxConcurrency] - Positive integer cap; must be paired with `concurrencyKey`.\n * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.\n * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.\n * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.\n * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.\n */\n/**\n * @typedef {object} BackgroundJobPayload\n * @property {string} [id] - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} [args] - Serialized job arguments.\n * @property {string} [handoffId] - Unique handoff lease id.\n * @property {string} [workerId] - Worker id handling the job.\n * @property {number} [handedOffAtMs] - Time handed to a worker in ms.\n * @property {BackgroundJobOptions} [options] - Runtime options.\n */\n/**\n * @typedef {object} BackgroundJobContext\n * @property {typeof import(\"./platform-job.js\").default} jobClass - Concrete job class.\n * @property {string} jobName - Registered job name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobOptions} options - Resolved enqueue/runtime options.\n * @property {BackgroundJobPayload} [payload] - Complete persisted runner payload when the job is performing.\n */\n/**\n * @typedef {object} BackgroundJobRow\n * @property {string} id - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobExecutionMode} executionMode - How the job should run.\n * @property {string} queue - Queue name (defaults to `\"default\"`).\n * @property {string | null} scheduleKey - Stable logical schedule key retained for history.\n * @property {number | null} scheduleOrder - Transaction-assigned monotonic ownership order for this schedule key; Node preserves its high-water mark across terminal-history pruning. Null for legacy/non-scheduled rows.\n * @property {BackgroundJobStatus} status - Current job status.\n * @property {number | null} attempts - Failure attempts count.\n * @property {number | null} maxRetries - Max retry attempts.\n * @property {number | null} scheduledAtMs - Next scheduled time in ms.\n * @property {number | null} createdAtMs - Creation time in ms.\n * @property {number | null} handedOffAtMs - Time handed to worker in ms.\n * @property {string | null} handoffId - Unique latest handoff lease id.\n * @property {number | null} completedAtMs - Completion time in ms.\n * @property {number | null} failedAtMs - Failure time in ms.\n * @property {number | null} orphanedAtMs - Orphaned time in ms.\n * @property {string | null} workerId - Worker id handling the job.\n * @property {string | null} lastError - Last failure message.\n * @property {string | null} concurrencyKey - Durable concurrency key.\n * @property {number | null} maxConcurrency - Durable per-key cap.\n * @property {number | null} timeoutMs - Per-job wall-clock timeout override, or null when omitted.\n * @property {number | null} childReceivedAtMs - Epoch ms when the executing pooled child's event loop processed the job message, or null when no runner accepted it yet.\n * @property {number | null} childStartedAtMs - Epoch ms when the job's perform started in the pooled child, or null when it never started.\n * @property {string | null} childInstanceId - Stable identity of the pooled child process that accepted the job, or null.\n * @property {number | null} childPid - OS pid of the pooled child process that accepted the job, or null.\n * @property {string | null} runnerHostname - Hostname reported by the pooled child process that accepted the job, or null.\n */\n/**\n * @typedef {\"queued\" | \"handed_off\" | null} BackgroundJobReplacementPreviousStatus\n */\n/**\n * @typedef {object} BackgroundJobReplacementResult\n * @property {string} jobId - Newly queued job id.\n * @property {string | null} previousJobId - Previous active owner's job id.\n * @property {BackgroundJobReplacementPreviousStatus} previousStatus - Previous owner's observed state.\n */\n/**\n * @typedef {\"cancelled\" | \"handed_off\" | \"not_found\"} BackgroundJobCancellationOutcome\n */\n/**\n * @typedef {object} BackgroundJobCancellationResult\n * @property {string | null} jobId - Detached owner's job id, when one was active.\n * @property {BackgroundJobCancellationOutcome} outcome - Truthful best-effort outcome.\n */\n/**\n * @typedef {object} BackgroundJobScheduledLookupResult\n * @property {BackgroundJobRow | null} currentJob - Current queued or handed-off owner.\n * @property {BackgroundJobRow | null} latestTerminalJob - Latest terminal history when requested.\n */\n/**\n * @typedef {\"woken\" | \"already_due\" | \"handed_off\" | \"not_found\"} BackgroundJobWakeOutcome\n */\n/**\n * @typedef {object} BackgroundJobWakeResult\n * @property {string | null} jobId - Current owner's durable job id, when found.\n * @property {BackgroundJobWakeOutcome} outcome - Exact wake outcome.\n */\n/**\n * @typedef {object} BackgroundJobFailureEvent\n * @property {BackgroundJobRow} job - Updated job row after failure handling.\n * @property {ReturnType<typeof JSON.parse>} error - Failure error.\n * @property {number | null} attempts - Updated failure attempts count.\n * @property {boolean} terminal - Whether this failure ended the job.\n * @property {boolean} willRetry - Whether the job was returned to the queue.\n * @property {string | undefined} handoffId - Handoff lease id from the worker report.\n * @property {number | undefined} handedOffAtMs - Handoff timestamp from the worker report.\n * @property {string | undefined} workerId - Worker id from the worker report.\n * @property {PooledRunnerFailure | undefined} runnerFailure - Shared pooled-child process failure provenance.\n */\n/**\n * @typedef {\"worker\" | \"client\" | \"reporter\"} BackgroundJobSocketRole\n */\n/**\n * @typedef {{type: \"hello\", role: BackgroundJobSocketRole, generationId?: string, supportsHandoffIdReporting?: boolean, supportsHeartbeat?: boolean, supportsPooled?: boolean, workerId?: string}} BackgroundJobHelloMessage\n * @typedef {{type: \"generation-accepted\", generationId: string, lifecycleState: BackgroundJobsGenerationLifecycleState}} BackgroundJobGenerationAcceptedMessage\n * @typedef {{type: \"generation-rejected\", reason: BackgroundJobsGenerationRejectionReason}} BackgroundJobGenerationRejectedMessage\n * @typedef {{type: \"ready\", acceptsForked?: boolean, acceptsInline?: boolean, acceptsPooled?: boolean, acceptsSpawned?: boolean, availablePooledSlots?: number}} BackgroundJobReadyMessage\n * @typedef {{type: \"draining\"}} BackgroundJobDrainingMessage\n * @typedef {{type: \"heartbeat\", workerId?: string}} BackgroundJobHeartbeatMessage\n * @typedef {{type: \"enqueue\", jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}} BackgroundJobEnqueueMessage\n * @typedef {{type: \"enqueued\", jobId: string}} BackgroundJobEnqueuedMessage\n * @typedef {{type: \"enqueue-error\", error?: string}} BackgroundJobEnqueueErrorMessage\n * @typedef {{type: \"replace-scheduled\", scheduleKey: string, jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}} BackgroundJobReplaceScheduledMessage\n * @typedef {{type: \"schedule-replaced\", jobId: string, previousJobId: string | null, previousStatus: BackgroundJobReplacementPreviousStatus}} BackgroundJobScheduleReplacedMessage\n * @typedef {{type: \"replace-scheduled-error\", error?: string}} BackgroundJobReplaceScheduledErrorMessage\n * @typedef {{type: \"cancel-scheduled\", scheduleKey: string}} BackgroundJobCancelScheduledMessage\n * @typedef {{type: \"schedule-cancelled\", jobId: string | null, outcome: BackgroundJobCancellationOutcome}} BackgroundJobScheduleCancelledMessage\n * @typedef {{type: \"cancel-scheduled-error\", error?: string}} BackgroundJobCancelScheduledErrorMessage\n * @typedef {{type: \"get-scheduled-job\", scheduleKey: string, includeLatestTerminal?: boolean}} BackgroundJobGetScheduledMessage\n * @typedef {{type: \"scheduled-job\", currentJob: BackgroundJobRow | null, latestTerminalJob: BackgroundJobRow | null}} BackgroundJobScheduledMessage\n * @typedef {{type: \"get-scheduled-job-error\", error?: string}} BackgroundJobGetScheduledErrorMessage\n * @typedef {{type: \"wake-scheduled\", scheduleKey: string}} BackgroundJobWakeScheduledMessage\n * @typedef {{type: \"schedule-woken\", jobId: string | null, outcome: BackgroundJobWakeOutcome}} BackgroundJobScheduleWokenMessage\n * @typedef {{type: \"wake-scheduled-error\", error?: string}} BackgroundJobWakeScheduledErrorMessage\n * @typedef {{type: \"job\", payload: BackgroundJobPayload}} BackgroundJobJobMessage\n * @typedef {{type: \"job-accepted\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number, runnerHostname?: string}} BackgroundJobAcceptedMessage\n * @typedef {{type: \"job-complete\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobCompleteMessage\n * @typedef {{type: \"job-failed\", jobId: string, error?: ReturnType<typeof JSON.parse>, handoffId?: string, workerId?: string, handedOffAtMs?: number, runnerFailure?: PooledRunnerFailure}} BackgroundJobFailedMessage\n * @typedef {{type: \"job-reschedule\", jobId: string, delayMs: number, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobRescheduleMessage\n * @typedef {{type: \"job-updated\", jobId: string}} BackgroundJobUpdatedMessage\n * @typedef {{type: \"job-update-error\", jobId: string, error?: string}} BackgroundJobUpdateErrorMessage\n */\n/**\n * @typedef {BackgroundJobHelloMessage | BackgroundJobGenerationAcceptedMessage | BackgroundJobGenerationRejectedMessage | BackgroundJobReadyMessage | BackgroundJobDrainingMessage | BackgroundJobHeartbeatMessage | BackgroundJobEnqueueMessage | BackgroundJobEnqueuedMessage | BackgroundJobEnqueueErrorMessage | BackgroundJobReplaceScheduledMessage | BackgroundJobScheduleReplacedMessage | BackgroundJobReplaceScheduledErrorMessage | BackgroundJobCancelScheduledMessage | BackgroundJobScheduleCancelledMessage | BackgroundJobCancelScheduledErrorMessage | BackgroundJobGetScheduledMessage | BackgroundJobScheduledMessage | BackgroundJobGetScheduledErrorMessage | BackgroundJobWakeScheduledMessage | BackgroundJobScheduleWokenMessage | BackgroundJobWakeScheduledErrorMessage | BackgroundJobJobMessage | BackgroundJobAcceptedMessage | BackgroundJobCompleteMessage | BackgroundJobFailedMessage | BackgroundJobRescheduleMessage | BackgroundJobUpdatedMessage | BackgroundJobUpdateErrorMessage} BackgroundJobSocketMessage\n */\n\nexport const nothing = {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/background-jobs/types.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;GAEG;AACH,yFAAyF;AACzF,iIAAiI;AACjI,6NAA6N;AAC7N,mEAAmE;AACnE,+FAA+F;AAC/F,6FAA6F;AAC7F,mGAAmG;AACnG,gFAAgF;AAChF,uPAAuP;AACvP;;;GAGG;AACH,wFAAwF;AACxF;;;;;;;;GAQG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;;;;;;;;;GAUG;AACH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;GAYG;AACH;;;GAGG;AACH;;;;;;;GAOG;AACH;;;;;GAKG;AACH;;;;;;GAMG;AACH;;;;;GAKG;AACH;;;;;;;;;;;GAWG;AACH;;;;;;;;;GASG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;GAEG;AACH;;;;;GAKG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;GAIG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;;;;;;;;GAWG;AACH;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;GAEG;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAA","sourcesContent":["// @ts-check\n\n/**\n * @typedef {\"inline\" | \"forked\" | \"pooled\" | \"spawned\"} BackgroundJobExecutionMode\n */\n/** @typedef {\"candidate\" | \"active\" | \"retired\"} BackgroundJobsGenerationInitialState */\n/** @typedef {\"starting\" | \"candidate\" | \"active\" | \"retiring\" | \"retired\" | \"stopped\"} BackgroundJobsGenerationLifecycleState */\n/** @typedef {\"missing-generation\" | \"unexpected-generation\" | \"malformed-generation\" | \"generation-mismatch\" | \"worker-admission-retired\" | \"worker-has-no-recoverable-handoffs\"} BackgroundJobsGenerationRejectionReason */\n/** @typedef {\"queued\" | \"handed_off\"} BackgroundJobActiveStatus */\n/** @typedef {\"cancelled\" | \"completed\" | \"failed\" | \"orphaned\"} BackgroundJobTerminalStatus */\n/** @typedef {BackgroundJobActiveStatus | BackgroundJobTerminalStatus} BackgroundJobStatus */\n/** @typedef {\"exit\" | \"process-error\" | \"ipc-send\" | \"child-silence\"} PooledRunnerFailureOrigin */\n/** @typedef {\"starting\" | \"running\" | \"retiring\"} PooledRunnerLifecycleState */\n/** @typedef {\"parent_retire_drained\" | \"job_timeout\" | \"worker_stop\" | \"child_silence\" | \"signal_sigterm\" | \"signal_sigint\" | \"signal_sigkill\" | \"signal_other\" | \"ipc_disconnect\" | \"process_error\" | \"unexpected_exit\"} PooledChildShutdownReason */\n/**\n * @deprecated Use PooledChildShutdownReason for exact shutdown provenance.\n * @typedef {\"unexpected\" | \"job-timeout\" | \"worker-shutdown-timeout\"} PooledRunnerTerminationReason\n */\n/** @typedef {\"running\" | \"retiring\" | \"stopping\"} BackgroundJobsWorkerLifecycleState */\n/**\n * Exact durable handoff ownership carried by an executing job when it produces\n * follow-up work.\n * @typedef {object} BackgroundJobProducerProof\n * @property {string} jobId - Producing job id.\n * @property {string} handoffId - Producing handoff lease id.\n * @property {string} workerId - Worker identity persisted with the handoff.\n * @property {number} handedOffAtMs - Durable handoff timestamp.\n */\n/**\n * @typedef {object} PooledRunnerActiveJob\n * @property {string | null} handoffId - Durable handoff lease id.\n * @property {number | null} handedOffAtMs - Durable handoff timestamp.\n * @property {string} jobId - Durable background job id.\n * @property {string} jobName - Registered job class name.\n * @property {string} workerId - Worker identity persisted with the handoff.\n */\n/**\n * One process-failure snapshot shared by every job lost with a pooled child.\n * @typedef {object} PooledRunnerFailure\n * @property {PooledRunnerActiveJob[]} activeJobs - Jobs that were in flight when the child failed, ordered by job id.\n * @property {string | null} childInstanceId - Stable pooled-child identity when its startup or shutdown observation arrived.\n * @property {number | null} exitCode - Child exit code, or null for signal/process errors.\n * @property {string | null} generationId - Release generation identity, or null in legacy mode.\n * @property {string[]} inflightJobIds - Bounded job ids in flight when failure handling started.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {boolean | null} oomKilled - False when the observed exit rules OOM out; null when an unexpected SIGKILL cannot be distinguished from an OOM kill without supervisor/kernel evidence.\n * @property {PooledRunnerFailureOrigin} origin - Worker observation that initiated failure handling.\n * @property {number} runnerAgeMs - Child age when failure handling started.\n * @property {number} runnerCreatedAtMs - Child creation timestamp.\n * @property {boolean} runnerDetached - Whether the runner owned a detached process group.\n * @property {number} runnerJobsRun - Previously acknowledged jobs handled by the child.\n * @property {PooledRunnerLifecycleState} runnerLifecycle - Child lifecycle immediately before recovery.\n * @property {number | null} runnerPid - Child process id when available.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Child termination signal when available.\n * @property {number | null} shutdownObservedAtMs - Time the child or parent observed shutdown beginning.\n * @property {number | null} shutdownRequestedAtMs - Exact parent request timestamp, or null for external/unrequested shutdown.\n * @property {PooledChildShutdownReason} shutdownReason - Exact recorded parent request or observed child shutdown cause.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} shutdownSignal - Parent-requested or child-observed shutdown signal when available.\n * @property {PooledRunnerTerminationReason} terminationReason - Deprecated compatibility category; use shutdownReason for exact provenance.\n * @property {string | null} timeoutJobId - Job whose timeout initiated child termination, or null.\n * @property {string} workerId - Stable generation-qualified worker id.\n * @property {BackgroundJobsWorkerLifecycleState} workerLifecycle - Parent worker lifecycle immediately before recovery.\n * @property {number} workerPid - Parent worker process id.\n */\n/**\n * Best-effort observation sent before a pooled child closes its resources.\n * @typedef {object} PooledChildShutdownObservation\n * @property {string} childInstanceId - Stable pooled-child identity.\n * @property {string[]} inflightJobIds - Bounded in-flight durable job ids.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {PooledChildShutdownReason} reason - Shutdown reason observed by the child.\n * @property {number} shutdownObservedAtMs - Child observation timestamp.\n * @property {number | null} shutdownRequestedAtMs - Parent request timestamp when supplied over IPC.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Requested or observed signal when available.\n */\n/**\n * Bounded pooled-child memory observation sent over the child IPC channel.\n * The pooled child's stdio is ignored by the worker fork, so this observation\n * (sent periodically while jobs run, plus on demand) is how a memory problem\n * in a running child names itself. `heapStatistics` and `memoryUsage`\n * distinguish V8-heap growth from external/array-buffer (native resource)\n * growth; `activeJobIds` ties the sample to the work that was in flight.\n * @typedef {object} PooledChildMemoryObservation\n * @property {string[]} activeJobIds - In-flight job ids, bounded.\n * @property {number} activeJobIdsTruncatedCount - In-flight job ids omitted by the bound.\n * @property {string} childInstanceId - Stable identity reported by the child.\n * @property {number} childPid - Child process id.\n * @property {number} childUptimeMs - Child process uptime in ms.\n * @property {ReturnType<typeof import(\"node:v8\").getHeapStatistics>} heapStatistics - V8 heap-stat breakdown at the sample.\n * @property {number} jobCount - In-flight job count.\n * @property {ReturnType<typeof import(\"node:process\").memoryUsage>} memoryUsage - Process memory breakdown at the sample.\n * @property {number} observedAtMs - Epoch ms the child sampled.\n * @property {number} peakRssBytes - Child-reported peak RSS (kernel `VmHWM` high-water mark) in bytes, monotonic for the child's life.\n * @property {number} rssBytes - Resident set size in bytes at the sample.\n * @property {\"pooled-child-memory\"} type - Discriminator.\n * @property {number} uptimeMs - Process uptime in ms.\n */\n/**\n * @typedef {object} LocalBackgroundJobsClock\n * @property {() => number} now - Current epoch milliseconds.\n * @property {(callback: () => void, delayMs: number) => ReturnType<typeof setTimeout> | number} setTimeout - Arms a timer.\n * @property {(timerId: ReturnType<typeof setTimeout> | number) => void} clearTimeout - Clears a timer.\n */\n/**\n * @typedef {object} ResolvedBackgroundJobConcurrency\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} maxConcurrency - Positive cap.\n * @property {boolean} queueDerived - Whether queue configuration owns the cap.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyRepair\n * @property {number} activeCount - Exact handed-off job count persisted by the repair.\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} previousActiveCount - Persisted count replaced by the repair.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyReconciliation\n * @property {number} candidateCount - Snapshot mismatches rechecked under their counter locks.\n * @property {number} checkedCount - Active or nonzero durable counters compared in the initial snapshot.\n * @property {number} repairedCount - Counters whose persisted values were changed.\n * @property {BackgroundJobConcurrencyRepair[]} repairs - Bounded deterministic sample of applied repairs.\n * @property {number} repairsTruncatedCount - Applied repairs omitted from the sample.\n */\n/**\n * @typedef {object} PreparedLocalBackgroundJob\n * @property {string} argsDigest - Fixed-width digest of the serialized arguments.\n * @property {string} argsJson - Serialized arguments.\n * @property {ResolvedBackgroundJobConcurrency | null} concurrency - Resolved concurrency.\n * @property {number} createdAtMs - Creation timestamp.\n * @property {\"inline\"} executionMode - Local in-process execution mode.\n * @property {string} jobId - Durable id.\n * @property {string} jobName - Registered name.\n * @property {number} maxRetries - Retry cap.\n * @property {string} queue - Queue name.\n * @property {number} scheduledAtMs - Eligibility timestamp.\n */\n/**\n * @typedef {object} BackgroundJobsHealth\n * @property {boolean} ready - Whether the adapter can accept and process work.\n */\n/**\n * @typedef {object} BackgroundJobsProducer\n * @property {(args: {jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}) => Promise<string>} enqueue - Enqueues a job.\n * @property {(args: {scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}) => Promise<BackgroundJobReplacementResult>} replaceScheduled - Replaces a stable schedule.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobCancellationResult>} cancelScheduled - Cancels a stable schedule.\n * @property {(args: {scheduleKey: string, includeLatestTerminal?: boolean}) => Promise<BackgroundJobScheduledLookupResult>} getScheduledJob - Reads stable schedule ownership and history.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobWakeResult>} wakeScheduled - Expedites a stable schedule owner.\n */\n/**\n * @typedef {object} BackgroundJobHandoff\n * @property {string} handoffId - Unique handoff lease id.\n * @property {number} handedOffAtMs - Time handed to a worker in ms.\n * @property {BackgroundJobRow} [job] - Exact committed job snapshot when the adapter changes dispatch data during the claim.\n */\n/**\n * @typedef {object} BackgroundJobHandoffSnapshot\n * @property {string} jobId - Job holding the lease.\n * @property {string} handoffId - Exact durable lease id.\n * @property {string} workerId - Stable worker id that received the lease.\n * @property {number} handedOffAtMs - Time handed to the worker in ms.\n */\n/**\n * @typedef {object} BackgroundJobHandoffRequest\n * @property {string} jobId - Job to claim.\n * @property {string} [handoffId] - Exact caller-selected lease id. Adapters must persist and return this id when supplied; built-in adapters generate one when omitted for legacy direct callers.\n * @property {string} [workerId] - Worker claiming the job.\n */\n/**\n * @typedef {object} BackgroundJobOptions\n * @property {BackgroundJobExecutionMode} [executionMode] - How the job should run. Node defaults to `\"pooled\"` (a warm, reused local runner process). Browser/Expo local dispatch defaults to and only accepts `\"inline\"`. `\"forked\"` runs a Node job in a fresh `child_process.fork()` child, and `\"spawned\"` in a detached CLI runner.\n * @property {number} [maxRetries] - Max retries for a failed job before it is marked failed.\n * @property {string} [queue] - Queue name. Defaults to `\"default\"`. When the queue has a configured cap in `backgroundJobs.queues`, that cap is enforced cluster-wide.\n * @property {string} [concurrencyKey] - Opaque non-empty key used to share a concurrency cap. Overrides any queue-derived cap.\n * @property {number} [maxConcurrency] - Positive integer cap; must be paired with `concurrencyKey`.\n * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.\n * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.\n * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.\n * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides a job class's `static timeoutMs` and the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.\n */\n/**\n * @typedef {object} BackgroundJobPayload\n * @property {string} [id] - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} [args] - Serialized job arguments.\n * @property {string} [handoffId] - Unique handoff lease id.\n * @property {string} [workerId] - Worker id handling the job.\n * @property {number} [handedOffAtMs] - Time handed to a worker in ms.\n * @property {BackgroundJobOptions} [options] - Runtime options.\n */\n/**\n * @typedef {object} BackgroundJobContext\n * @property {typeof import(\"./platform-job.js\").default} jobClass - Concrete job class.\n * @property {string} jobName - Registered job name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobOptions} options - Resolved enqueue/runtime options.\n * @property {BackgroundJobPayload} [payload] - Complete persisted runner payload when the job is performing.\n */\n/**\n * @typedef {object} BackgroundJobRow\n * @property {string} id - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobExecutionMode} executionMode - How the job should run.\n * @property {string} queue - Queue name (defaults to `\"default\"`).\n * @property {string | null} scheduleKey - Stable logical schedule key retained for history.\n * @property {number | null} scheduleOrder - Transaction-assigned monotonic ownership order for this schedule key; Node preserves its high-water mark across terminal-history pruning. Null for legacy/non-scheduled rows.\n * @property {BackgroundJobStatus} status - Current job status.\n * @property {number | null} attempts - Failure attempts count.\n * @property {number | null} maxRetries - Max retry attempts.\n * @property {number | null} scheduledAtMs - Next scheduled time in ms.\n * @property {number | null} createdAtMs - Creation time in ms.\n * @property {number | null} handedOffAtMs - Time handed to worker in ms.\n * @property {string | null} handoffId - Unique latest handoff lease id.\n * @property {number | null} completedAtMs - Completion time in ms.\n * @property {number | null} failedAtMs - Failure time in ms.\n * @property {number | null} orphanedAtMs - Orphaned time in ms.\n * @property {string | null} workerId - Worker id handling the job.\n * @property {string | null} lastError - Last failure message.\n * @property {string | null} concurrencyKey - Durable concurrency key.\n * @property {number | null} maxConcurrency - Durable per-key cap.\n * @property {number | null} timeoutMs - Per-job wall-clock timeout override, or null when omitted.\n * @property {number | null} childReceivedAtMs - Epoch ms when the executing pooled child's event loop processed the job message, or null when no runner accepted it yet.\n * @property {number | null} childStartedAtMs - Epoch ms when the job's perform started in the pooled child, or null when it never started.\n * @property {string | null} childInstanceId - Stable identity of the pooled child process that accepted the job, or null.\n * @property {number | null} childPid - OS pid of the pooled child process that accepted the job, or null.\n * @property {string | null} runnerHostname - Hostname reported by the pooled child process that accepted the job, or null.\n */\n/**\n * @typedef {\"queued\" | \"handed_off\" | null} BackgroundJobReplacementPreviousStatus\n */\n/**\n * @typedef {object} BackgroundJobReplacementResult\n * @property {string} jobId - Newly queued job id.\n * @property {string | null} previousJobId - Previous active owner's job id.\n * @property {BackgroundJobReplacementPreviousStatus} previousStatus - Previous owner's observed state.\n */\n/**\n * @typedef {\"cancelled\" | \"handed_off\" | \"not_found\"} BackgroundJobCancellationOutcome\n */\n/**\n * @typedef {object} BackgroundJobCancellationResult\n * @property {string | null} jobId - Detached owner's job id, when one was active.\n * @property {BackgroundJobCancellationOutcome} outcome - Truthful best-effort outcome.\n */\n/**\n * @typedef {object} BackgroundJobScheduledLookupResult\n * @property {BackgroundJobRow | null} currentJob - Current queued or handed-off owner.\n * @property {BackgroundJobRow | null} latestTerminalJob - Latest terminal history when requested.\n */\n/**\n * @typedef {\"woken\" | \"already_due\" | \"handed_off\" | \"not_found\"} BackgroundJobWakeOutcome\n */\n/**\n * @typedef {object} BackgroundJobWakeResult\n * @property {string | null} jobId - Current owner's durable job id, when found.\n * @property {BackgroundJobWakeOutcome} outcome - Exact wake outcome.\n */\n/**\n * @typedef {object} BackgroundJobFailureEvent\n * @property {BackgroundJobRow} job - Updated job row after failure handling.\n * @property {ReturnType<typeof JSON.parse>} error - Failure error.\n * @property {number | null} attempts - Updated failure attempts count.\n * @property {boolean} terminal - Whether this failure ended the job.\n * @property {boolean} willRetry - Whether the job was returned to the queue.\n * @property {string | undefined} handoffId - Handoff lease id from the worker report.\n * @property {number | undefined} handedOffAtMs - Handoff timestamp from the worker report.\n * @property {string | undefined} workerId - Worker id from the worker report.\n * @property {PooledRunnerFailure | undefined} runnerFailure - Shared pooled-child process failure provenance.\n */\n/**\n * @typedef {\"worker\" | \"client\" | \"reporter\"} BackgroundJobSocketRole\n */\n/**\n * @typedef {{type: \"hello\", role: BackgroundJobSocketRole, generationId?: string, supportsHandoffIdReporting?: boolean, supportsHeartbeat?: boolean, supportsPooled?: boolean, workerId?: string}} BackgroundJobHelloMessage\n * @typedef {{type: \"generation-accepted\", generationId: string, lifecycleState: BackgroundJobsGenerationLifecycleState}} BackgroundJobGenerationAcceptedMessage\n * @typedef {{type: \"generation-rejected\", reason: BackgroundJobsGenerationRejectionReason}} BackgroundJobGenerationRejectedMessage\n * @typedef {{type: \"ready\", acceptsForked?: boolean, acceptsInline?: boolean, acceptsPooled?: boolean, acceptsSpawned?: boolean, availablePooledSlots?: number}} BackgroundJobReadyMessage\n * @typedef {{type: \"draining\"}} BackgroundJobDrainingMessage\n * @typedef {{type: \"heartbeat\", workerId?: string}} BackgroundJobHeartbeatMessage\n * @typedef {{type: \"enqueue\", jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}} BackgroundJobEnqueueMessage\n * @typedef {{type: \"enqueued\", jobId: string}} BackgroundJobEnqueuedMessage\n * @typedef {{type: \"enqueue-error\", error?: string}} BackgroundJobEnqueueErrorMessage\n * @typedef {{type: \"replace-scheduled\", scheduleKey: string, jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}} BackgroundJobReplaceScheduledMessage\n * @typedef {{type: \"schedule-replaced\", jobId: string, previousJobId: string | null, previousStatus: BackgroundJobReplacementPreviousStatus}} BackgroundJobScheduleReplacedMessage\n * @typedef {{type: \"replace-scheduled-error\", error?: string}} BackgroundJobReplaceScheduledErrorMessage\n * @typedef {{type: \"cancel-scheduled\", scheduleKey: string}} BackgroundJobCancelScheduledMessage\n * @typedef {{type: \"schedule-cancelled\", jobId: string | null, outcome: BackgroundJobCancellationOutcome}} BackgroundJobScheduleCancelledMessage\n * @typedef {{type: \"cancel-scheduled-error\", error?: string}} BackgroundJobCancelScheduledErrorMessage\n * @typedef {{type: \"get-scheduled-job\", scheduleKey: string, includeLatestTerminal?: boolean}} BackgroundJobGetScheduledMessage\n * @typedef {{type: \"scheduled-job\", currentJob: BackgroundJobRow | null, latestTerminalJob: BackgroundJobRow | null}} BackgroundJobScheduledMessage\n * @typedef {{type: \"get-scheduled-job-error\", error?: string}} BackgroundJobGetScheduledErrorMessage\n * @typedef {{type: \"wake-scheduled\", scheduleKey: string}} BackgroundJobWakeScheduledMessage\n * @typedef {{type: \"schedule-woken\", jobId: string | null, outcome: BackgroundJobWakeOutcome}} BackgroundJobScheduleWokenMessage\n * @typedef {{type: \"wake-scheduled-error\", error?: string}} BackgroundJobWakeScheduledErrorMessage\n * @typedef {{type: \"job\", payload: BackgroundJobPayload}} BackgroundJobJobMessage\n * @typedef {{type: \"job-accepted\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number, runnerHostname?: string}} BackgroundJobAcceptedMessage\n * @typedef {{type: \"job-complete\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobCompleteMessage\n * @typedef {{type: \"job-failed\", jobId: string, error?: ReturnType<typeof JSON.parse>, handoffId?: string, workerId?: string, handedOffAtMs?: number, runnerFailure?: PooledRunnerFailure}} BackgroundJobFailedMessage\n * @typedef {{type: \"job-reschedule\", jobId: string, delayMs: number, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobRescheduleMessage\n * @typedef {{type: \"job-updated\", jobId: string}} BackgroundJobUpdatedMessage\n * @typedef {{type: \"job-update-error\", jobId: string, error?: string}} BackgroundJobUpdateErrorMessage\n */\n/**\n * @typedef {BackgroundJobHelloMessage | BackgroundJobGenerationAcceptedMessage | BackgroundJobGenerationRejectedMessage | BackgroundJobReadyMessage | BackgroundJobDrainingMessage | BackgroundJobHeartbeatMessage | BackgroundJobEnqueueMessage | BackgroundJobEnqueuedMessage | BackgroundJobEnqueueErrorMessage | BackgroundJobReplaceScheduledMessage | BackgroundJobScheduleReplacedMessage | BackgroundJobReplaceScheduledErrorMessage | BackgroundJobCancelScheduledMessage | BackgroundJobScheduleCancelledMessage | BackgroundJobCancelScheduledErrorMessage | BackgroundJobGetScheduledMessage | BackgroundJobScheduledMessage | BackgroundJobGetScheduledErrorMessage | BackgroundJobWakeScheduledMessage | BackgroundJobScheduleWokenMessage | BackgroundJobWakeScheduledErrorMessage | BackgroundJobJobMessage | BackgroundJobAcceptedMessage | BackgroundJobCompleteMessage | BackgroundJobFailedMessage | BackgroundJobRescheduleMessage | BackgroundJobUpdatedMessage | BackgroundJobUpdateErrorMessage} BackgroundJobSocketMessage\n */\n\nexport const nothing = {}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.713",
+  "version": "1.0.714",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

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

@@ -55,6 +55,17 @@ export default class VelociousJob {
    */
   static processTitle = undefined
 
+  /**
+   * Wall-clock bound this job class runs under, in ms. Set e.g.
+   * `static timeoutMs = 60 * 60 * 1000` on a job whose work legitimately takes
+   * hours so its type carries its own bound instead of relying on one global
+   * `backgroundJobs.jobTimeoutMs` tuned for the slowest job in the system. The
+   * `{timeoutMs}` enqueue option overrides it. A non-positive value disables the
+   * bound for this class. Left undefined, the worker-level value applies.
+   * @type {number | undefined}
+   */
+  static timeoutMs = undefined
+
   /**
    * Stops this performance and reschedules the same logical job row. This is
    * normal control flow: it does not count as a failure or consume a retry.
@@ -93,6 +104,25 @@ export default class VelociousJob {
     return merged
   }
 
+  /**
+   * Folds this job class's static `timeoutMs` into the enqueue options unless the
+   * caller already specified one, so a job type carries its own wall-clock bound
+   * instead of every job sharing one worker-level value. A class that declares
+   * nothing leaves the option absent, and the worker falls back to its own
+   * default — the prior behavior.
+   * @param {import("./types.js").BackgroundJobOptions | undefined} options - Job options.
+   * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved timeout.
+   */
+  static _withTimeout(options) {
+    const merged = options ? {...options} : {}
+
+    if (merged.timeoutMs === undefined && typeof this.timeoutMs === "number") {
+      merged.timeoutMs = this.timeoutMs
+    }
+
+    return merged
+  }
+
   /**
    * Resolves class-derived enqueue options on a hydrated job instance. Explicit
    * per-enqueue options take precedence over the instance concurrency key.
@@ -102,7 +132,7 @@ export default class VelociousJob {
    * @returns {import("./types.js").BackgroundJobOptions} - Resolved job options.
    */
   static _withJobContext({jobArgs, jobOptions}) {
-    const options = this._withQueue(jobOptions)
+    const options = this._withTimeout(this._withQueue(jobOptions))
 
     if (options.concurrencyKey !== undefined) return options
 

package/src/background-jobs/types.js

@@ -175,7 +175,7 @@
  * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.
  * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.
  * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.
- * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
+ * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides a job class's `static timeoutMs` and the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.
  */
 /**
  * @typedef {object} BackgroundJobPayload