velocious 1.0.712 → 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":"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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   * 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":"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;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,GAAG,SAAS,CAAA;IAE5B;;;;;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;;;;;;;;OAQG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO;QACzB,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAC,GAAG,OAAO,EAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAE1C,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACzE,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAA;QACnC,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,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAA;QAE9D,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   * 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/build/src/sync/sync-model-change-feed-service.d.ts

@@ -36,9 +36,10 @@ export default class SyncModelChangeFeedService {
     });
     /**
      * Builds a stable change-feed page. The additive `total` is the scope's pending
-     * change count from the request cursor to the snapshot bound (a COUNT, not a
-     * materialized read), so a client can render a "synced of total" progress bar;
-     * older clients ignore it.
+     * change count from the request cursor to the snapshot bound, so a client can
+     * render a "synced of total" progress bar; older clients ignore it. The count
+     * query only runs when the page read cannot answer it: a sequence cursor whose
+     * page is short of the limit has already materialized the whole remaining set.
      * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
      */
     changes(): Promise<{

package/build/src/sync/sync-model-change-feed-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-model-change-feed-service.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"sync-model-change-feed-service.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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"}

package/build/src/sync/sync-model-change-feed-service.js

@@ -30,9 +30,10 @@ export default class SyncModelChangeFeedService {
     }
     /**
      * Builds a stable change-feed page. The additive `total` is the scope's pending
-     * change count from the request cursor to the snapshot bound (a COUNT, not a
-     * materialized read), so a client can render a "synced of total" progress bar;
-     * older clients ignore it.
+     * change count from the request cursor to the snapshot bound, so a client can
+     * render a "synced of total" progress bar; older clients ignore it. The count
+     * query only runs when the page read cannot answer it: a sequence cursor whose
+     * page is short of the limit has already materialized the whole remaining set.
      * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
      */
     async changes() {
@@ -40,10 +41,20 @@ export default class SyncModelChangeFeedService {
         const upToCursor = await this.resolveUpToCursor();
         if (!upToCursor)
             return { status: "success", nextCursor: null, syncs: [], total: 0, upToCursor: null };
-        const total = await this.totalPendingChanges({ upToCursor });
-        const query = this.pageQuery({ limit, upToCursor });
-        const records = await query.toArray();
+        const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, "afterServerSequence");
+        // A cursor at or past the scope's snapshot bound cannot have pending rows.
+        // Answering here skips both the page read and the count, which would otherwise
+        // run against an empty sequence range on every caught-up poll. A multi-scope
+        // client sends its global cursor to each scope, so a scope whose own sequences
+        // are behind that cursor lands here on nearly every request.
+        if (afterServerSequence !== null && afterServerSequence >= upToCursor.serverSequence) {
+            return { status: "success", nextCursor: upToCursor, syncs: [], total: 0, upToCursor };
+        }
+        const records = await this.pageQuery({ limit, upToCursor }).toArray();
         const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor;
+        const total = afterServerSequence !== null && records.length < limit
+            ? records.length
+            : await this.totalPendingChanges({ upToCursor });
         return {
             status: "success",
             nextCursor,
@@ -246,4 +257,4 @@ export default class SyncModelChangeFeedService {
         return date.toISOString();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-model-change-feed-service.js","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nimport {declaredSyncScopeAttributes} from \"./sync-scope-attributes.js\"\nimport {decodeReplayPersistedData} from \"./sync-replay-persisted-data.js\"\n\n/**\n * Generic cursor-paginated change feed over an app-owned sync/change model.\n *\n * Apps provide the model and optional scoping/serialization hooks. Velocious owns\n * cursor parsing, snapshot high-water resolution, stable ordering, page limits,\n * and response shape for `/velocious/sync/changes` style endpoints.\n */\nexport default class SyncModelChangeFeedService {\n  /**\n   * Creates a generic sync-model change-feed service.\n   * @param {object} args - Service arguments.\n   * @param {typeof import(\"../database/record/index.js\").default} args.modelClass - Sync/change model class.\n   * @param {Record<string, unknown>} args.params - Request params.\n   * @param {number} [args.defaultLimit] - Default page size.\n   * @param {number} [args.maxLimit] - Maximum page size.\n   * @param {(record: ReturnType<typeof JSON.parse>) => Record<string, unknown>} [args.serializeRecord] - Record serializer.\n   * @param {(args: {query: import(\"../database/query/model-class-query.js\").default}) => void} [args.scopeQuery] - Applies app-owned visibility scope.\n   */\n  constructor({defaultLimit = 1000, maxLimit = 1000, modelClass, params, scopeQuery, serializeRecord}) {\n    this.defaultLimit = defaultLimit\n    this.maxLimit = maxLimit\n    this.modelClass = modelClass\n    this.params = params\n    this.scopeQuery = scopeQuery || null\n    this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record))\n  }\n\n  /**\n   * Builds a stable change-feed page. The additive `total` is the scope's pending\n   * change count from the request cursor to the snapshot bound (a COUNT, not a\n   * materialized read), so a client can render a \"synced of total\" progress bar;\n   * older clients ignore it.\n   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.\n   */\n  async changes() {\n    const limit = this.normalizedLimit(this.params.limit)\n    const upToCursor = await this.resolveUpToCursor()\n\n    if (!upToCursor) return {status: \"success\", nextCursor: null, syncs: [], total: 0, upToCursor: null}\n\n    const total = await this.totalPendingChanges({upToCursor})\n    const query = this.pageQuery({limit, upToCursor})\n    const records = await query.toArray()\n    const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor\n\n    return {\n      status: \"success\",\n      nextCursor,\n      syncs: records.map((record) => this.serializeRecord(record)),\n      total,\n      upToCursor\n    }\n  }\n\n  /**\n   * Normalizes the requested page limit.\n   * @param {unknown} value - Raw limit param.\n   * @returns {number} Normalized page limit.\n   */\n  normalizedLimit(value) {\n    if (value === undefined || value === null || value === \"\") return this.defaultLimit\n\n    const limit = Number(value)\n\n    if (!Number.isSafeInteger(limit) || limit <= 0) {\n      throw VelociousError.safe(\"Sync changes limit must be a positive integer.\", {code: \"sync-invalid-changes-limit\"})\n    }\n\n    return Math.min(limit, this.maxLimit)\n  }\n\n  /**\n   * Parses an optional positive integer cursor field.\n   * @param {unknown} value - Raw integer param.\n   * @param {string} name - Param name for error messages.\n   * @returns {number | null} Positive integer value, or null when omitted.\n   */\n  optionalPositiveIntegerParam(value, name) {\n    if (value === undefined || value === null || value === \"\") return null\n\n    const integer = Number(value)\n\n    if (!Number.isSafeInteger(integer) || integer <= 0) {\n      throw VelociousError.safe(`${name} must be a positive integer.`, {code: \"sync-invalid-changes-cursor\"})\n    }\n\n    return integer\n  }\n\n  /**\n   * Resolves the high-water cursor that bounds the current feed page.\n   * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.\n   */\n  async resolveUpToCursor() {\n    const upToServerSequence = this.optionalPositiveIntegerParam(this.params.upToServerSequence, \"upToServerSequence\")\n\n    if (upToServerSequence !== null && typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      return {id: this.params.upToId, serverSequence: upToServerSequence, updatedAt: this.params.upToUpdatedAt}\n    }\n\n    if (typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      const upToRecord = await this.modelClass.findBy({id: this.params.upToId})\n\n      if (upToRecord) return this.cursorForRecord(upToRecord)\n    }\n\n    const query = this.scopedQuery()\n    const table = query.driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = query.driver.quoteColumn(\"server_sequence\")\n    const latestRecords = await query\n      .order(`${table}.${serverSequenceColumn} DESC`)\n      .limit(1)\n      .toArray()\n\n    if (latestRecords.length === 0) return null\n\n    return this.cursorForRecord(latestRecords[0])\n  }\n\n  /**\n   * Builds the ordered and cursor-filtered page query.\n   * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Page query.\n   */\n  pageQuery({limit, upToCursor}) {\n    const query = this.cursorFilteredQuery({upToCursor})\n    const driver = query.driver\n    const serverSequenceColumn = `${driver.quoteTable(this.modelClass.tableName())}.${driver.quoteColumn(\"server_sequence\")}`\n\n    return query\n      .order(`${serverSequenceColumn} ASC`)\n      .limit(limit)\n  }\n\n  /**\n   * Counts the scope's pending change rows from the request cursor to the snapshot\n   * bound without materializing them, so the client can render a stable \"of Y\"\n   * progress denominator.\n   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Count args.\n   * @returns {Promise<number>} Pending change count from the request cursor.\n   */\n  async totalPendingChanges({upToCursor}) {\n    return await this.cursorFilteredQuery({upToCursor}).count()\n  }\n\n  /**\n   * Builds a scoped query with the snapshot upper bound and after-cursor filters\n   * applied, but without ordering or a page limit. Shared by the page read and the\n   * total-count so both count the same set of rows.\n   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Filter args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Cursor-filtered query.\n   */\n  cursorFilteredQuery({upToCursor}) {\n    const query = this.scopedQuery()\n    const driver = query.driver\n    const table = driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = `${table}.${driver.quoteColumn(\"server_sequence\")}`\n    const updatedAtColumn = `${table}.${driver.quoteColumn(\"updated_at\")}`\n    const idColumn = `${table}.${driver.quoteColumn(\"id\")}`\n\n    query.where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)\n\n    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, \"afterServerSequence\")\n\n    if (afterServerSequence !== null) {\n      query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`)\n    } else if (typeof this.params.afterUpdatedAt === \"string\" && this.params.afterUpdatedAt !== \"\") {\n      const isPagingExistingSnapshot = typeof this.params.upToUpdatedAt === \"string\" && this.params.upToUpdatedAt !== \"\" && typeof this.params.upToId === \"string\" && this.params.upToId !== \"\"\n\n      if (isPagingExistingSnapshot && typeof this.params.afterId === \"string\" && this.params.afterId !== \"\") {\n        query.where(`(${updatedAtColumn} > ${driver.quote(this.params.afterUpdatedAt)} OR (${updatedAtColumn} = ${driver.quote(this.params.afterUpdatedAt)} AND ${idColumn} > ${driver.quote(this.params.afterId)}))`)\n      } else {\n        query.where(`${updatedAtColumn} >= ${driver.quote(this.params.afterUpdatedAt)}`)\n      }\n    }\n\n    return query\n  }\n\n  /**\n   * Builds a base query with app-owned scope applied.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Scoped base query.\n   */\n  scopedQuery() {\n    const query = this.modelClass.where({})\n\n    if (this.scopeQuery) this.scopeQuery({query})\n\n    return query\n  }\n\n  /**\n   * Serializes a record into a transport cursor.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.\n   */\n  cursorForRecord(record) {\n    return {id: String(this.recordValue(record, \"id\")), serverSequence: Number(this.recordValue(record, \"serverSequence\")), updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))}\n  }\n\n  /**\n   * Serializes a record using the standard sync envelope shape plus the sync\n   * model's declared scope-partition attributes (`static syncScopeAttributes`),\n   * each emitted under its own attribute name. Models declaring no scope\n   * attributes keep the deprecated 1.0.503 wire and emit `eventId`. Keys are\n   * sorted so a declared `[\"eventId\"]` partition stays byte-identical with the\n   * 1.0.503 wire.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @returns {Record<string, unknown>} Default serialized row.\n   */\n  defaultSerializeRecord(record) {\n    const scopeAttributes = declaredSyncScopeAttributes(this.modelClass)\n    /** @type {Record<string, unknown>} */\n    const serialized = {\n      data: this.recordData(record),\n      id: this.recordValue(record, \"id\"),\n      resourceId: this.recordValue(record, \"resourceId\"),\n      resourceType: this.recordValue(record, \"resourceType\"),\n      serverSequence: this.recordValue(record, \"serverSequence\"),\n      syncType: this.recordValue(record, \"syncType\"),\n      updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))\n    }\n\n    for (const scopeAttribute of scopeAttributes || [\"eventId\"]) {\n      serialized[scopeAttribute] = this.recordValue(record, scopeAttribute)\n    }\n\n    return Object.fromEntries(Object.entries(serialized).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)))\n  }\n\n  /**\n   * Reads and parses the record data payload.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @returns {unknown} Parsed data value.\n   */\n  recordData(record) {\n    const data = this.recordValue(record, \"data\")\n\n    if (data === \"\" || data === null || data === undefined) return null\n    return decodeReplayPersistedData(data).payload\n  }\n\n  /**\n   * Reads a value from either a record accessor method or plain property.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @param {string} name - Camel-cased value/method name.\n   * @returns {unknown} Record value.\n   */\n  recordValue(record, name) {\n    if (!record || typeof record !== \"object\") {\n      throw new Error(\"Sync changes row must be an object.\")\n    }\n\n    const recordObject = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (record)\n    const method = recordObject[name]\n    const value = typeof method === \"function\" ? method.call(record) : method\n\n    if (value === undefined) {\n      throw new Error(`Sync changes row is missing ${name}.`)\n    }\n\n    return value\n  }\n\n  /**\n   * Converts a date-like value to an ISO string.\n   * @param {Date | string | null | undefined | unknown} value - Date value.\n   * @returns {string} ISO date.\n   */\n  isoDate(value) {\n    const date = value instanceof Date ? value : new Date(typeof value === \"string\" || typeof value === \"number\" ? value : 0)\n\n    if (Number.isNaN(date.getTime())) {\n      throw VelociousError.safe(\"Sync changes row has an invalid updated_at value.\", {code: \"sync-invalid-changes-row\"})\n    }\n\n    return date.toISOString()\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-model-change-feed-service.js","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nimport {declaredSyncScopeAttributes} from \"./sync-scope-attributes.js\"\nimport {decodeReplayPersistedData} from \"./sync-replay-persisted-data.js\"\n\n/**\n * Generic cursor-paginated change feed over an app-owned sync/change model.\n *\n * Apps provide the model and optional scoping/serialization hooks. Velocious owns\n * cursor parsing, snapshot high-water resolution, stable ordering, page limits,\n * and response shape for `/velocious/sync/changes` style endpoints.\n */\nexport default class SyncModelChangeFeedService {\n  /**\n   * Creates a generic sync-model change-feed service.\n   * @param {object} args - Service arguments.\n   * @param {typeof import(\"../database/record/index.js\").default} args.modelClass - Sync/change model class.\n   * @param {Record<string, unknown>} args.params - Request params.\n   * @param {number} [args.defaultLimit] - Default page size.\n   * @param {number} [args.maxLimit] - Maximum page size.\n   * @param {(record: ReturnType<typeof JSON.parse>) => Record<string, unknown>} [args.serializeRecord] - Record serializer.\n   * @param {(args: {query: import(\"../database/query/model-class-query.js\").default}) => void} [args.scopeQuery] - Applies app-owned visibility scope.\n   */\n  constructor({defaultLimit = 1000, maxLimit = 1000, modelClass, params, scopeQuery, serializeRecord}) {\n    this.defaultLimit = defaultLimit\n    this.maxLimit = maxLimit\n    this.modelClass = modelClass\n    this.params = params\n    this.scopeQuery = scopeQuery || null\n    this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record))\n  }\n\n  /**\n   * Builds a stable change-feed page. The additive `total` is the scope's pending\n   * change count from the request cursor to the snapshot bound, so a client can\n   * render a \"synced of total\" progress bar; older clients ignore it. The count\n   * query only runs when the page read cannot answer it: a sequence cursor whose\n   * page is short of the limit has already materialized the whole remaining set.\n   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.\n   */\n  async changes() {\n    const limit = this.normalizedLimit(this.params.limit)\n    const upToCursor = await this.resolveUpToCursor()\n\n    if (!upToCursor) return {status: \"success\", nextCursor: null, syncs: [], total: 0, upToCursor: null}\n\n    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, \"afterServerSequence\")\n\n    // A cursor at or past the scope's snapshot bound cannot have pending rows.\n    // Answering here skips both the page read and the count, which would otherwise\n    // run against an empty sequence range on every caught-up poll. A multi-scope\n    // client sends its global cursor to each scope, so a scope whose own sequences\n    // are behind that cursor lands here on nearly every request.\n    if (afterServerSequence !== null && afterServerSequence >= upToCursor.serverSequence) {\n      return {status: \"success\", nextCursor: upToCursor, syncs: [], total: 0, upToCursor}\n    }\n\n    const records = await this.pageQuery({limit, upToCursor}).toArray()\n    const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor\n    const total = afterServerSequence !== null && records.length < limit\n      ? records.length\n      : await this.totalPendingChanges({upToCursor})\n\n    return {\n      status: \"success\",\n      nextCursor,\n      syncs: records.map((record) => this.serializeRecord(record)),\n      total,\n      upToCursor\n    }\n  }\n\n  /**\n   * Normalizes the requested page limit.\n   * @param {unknown} value - Raw limit param.\n   * @returns {number} Normalized page limit.\n   */\n  normalizedLimit(value) {\n    if (value === undefined || value === null || value === \"\") return this.defaultLimit\n\n    const limit = Number(value)\n\n    if (!Number.isSafeInteger(limit) || limit <= 0) {\n      throw VelociousError.safe(\"Sync changes limit must be a positive integer.\", {code: \"sync-invalid-changes-limit\"})\n    }\n\n    return Math.min(limit, this.maxLimit)\n  }\n\n  /**\n   * Parses an optional positive integer cursor field.\n   * @param {unknown} value - Raw integer param.\n   * @param {string} name - Param name for error messages.\n   * @returns {number | null} Positive integer value, or null when omitted.\n   */\n  optionalPositiveIntegerParam(value, name) {\n    if (value === undefined || value === null || value === \"\") return null\n\n    const integer = Number(value)\n\n    if (!Number.isSafeInteger(integer) || integer <= 0) {\n      throw VelociousError.safe(`${name} must be a positive integer.`, {code: \"sync-invalid-changes-cursor\"})\n    }\n\n    return integer\n  }\n\n  /**\n   * Resolves the high-water cursor that bounds the current feed page.\n   * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.\n   */\n  async resolveUpToCursor() {\n    const upToServerSequence = this.optionalPositiveIntegerParam(this.params.upToServerSequence, \"upToServerSequence\")\n\n    if (upToServerSequence !== null && typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      return {id: this.params.upToId, serverSequence: upToServerSequence, updatedAt: this.params.upToUpdatedAt}\n    }\n\n    if (typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      const upToRecord = await this.modelClass.findBy({id: this.params.upToId})\n\n      if (upToRecord) return this.cursorForRecord(upToRecord)\n    }\n\n    const query = this.scopedQuery()\n    const table = query.driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = query.driver.quoteColumn(\"server_sequence\")\n    const latestRecords = await query\n      .order(`${table}.${serverSequenceColumn} DESC`)\n      .limit(1)\n      .toArray()\n\n    if (latestRecords.length === 0) return null\n\n    return this.cursorForRecord(latestRecords[0])\n  }\n\n  /**\n   * Builds the ordered and cursor-filtered page query.\n   * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Page query.\n   */\n  pageQuery({limit, upToCursor}) {\n    const query = this.cursorFilteredQuery({upToCursor})\n    const driver = query.driver\n    const serverSequenceColumn = `${driver.quoteTable(this.modelClass.tableName())}.${driver.quoteColumn(\"server_sequence\")}`\n\n    return query\n      .order(`${serverSequenceColumn} ASC`)\n      .limit(limit)\n  }\n\n  /**\n   * Counts the scope's pending change rows from the request cursor to the snapshot\n   * bound without materializing them, so the client can render a stable \"of Y\"\n   * progress denominator.\n   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Count args.\n   * @returns {Promise<number>} Pending change count from the request cursor.\n   */\n  async totalPendingChanges({upToCursor}) {\n    return await this.cursorFilteredQuery({upToCursor}).count()\n  }\n\n  /**\n   * Builds a scoped query with the snapshot upper bound and after-cursor filters\n   * applied, but without ordering or a page limit. Shared by the page read and the\n   * total-count so both count the same set of rows.\n   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Filter args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Cursor-filtered query.\n   */\n  cursorFilteredQuery({upToCursor}) {\n    const query = this.scopedQuery()\n    const driver = query.driver\n    const table = driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = `${table}.${driver.quoteColumn(\"server_sequence\")}`\n    const updatedAtColumn = `${table}.${driver.quoteColumn(\"updated_at\")}`\n    const idColumn = `${table}.${driver.quoteColumn(\"id\")}`\n\n    query.where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)\n\n    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, \"afterServerSequence\")\n\n    if (afterServerSequence !== null) {\n      query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`)\n    } else if (typeof this.params.afterUpdatedAt === \"string\" && this.params.afterUpdatedAt !== \"\") {\n      const isPagingExistingSnapshot = typeof this.params.upToUpdatedAt === \"string\" && this.params.upToUpdatedAt !== \"\" && typeof this.params.upToId === \"string\" && this.params.upToId !== \"\"\n\n      if (isPagingExistingSnapshot && typeof this.params.afterId === \"string\" && this.params.afterId !== \"\") {\n        query.where(`(${updatedAtColumn} > ${driver.quote(this.params.afterUpdatedAt)} OR (${updatedAtColumn} = ${driver.quote(this.params.afterUpdatedAt)} AND ${idColumn} > ${driver.quote(this.params.afterId)}))`)\n      } else {\n        query.where(`${updatedAtColumn} >= ${driver.quote(this.params.afterUpdatedAt)}`)\n      }\n    }\n\n    return query\n  }\n\n  /**\n   * Builds a base query with app-owned scope applied.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Scoped base query.\n   */\n  scopedQuery() {\n    const query = this.modelClass.where({})\n\n    if (this.scopeQuery) this.scopeQuery({query})\n\n    return query\n  }\n\n  /**\n   * Serializes a record into a transport cursor.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.\n   */\n  cursorForRecord(record) {\n    return {id: String(this.recordValue(record, \"id\")), serverSequence: Number(this.recordValue(record, \"serverSequence\")), updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))}\n  }\n\n  /**\n   * Serializes a record using the standard sync envelope shape plus the sync\n   * model's declared scope-partition attributes (`static syncScopeAttributes`),\n   * each emitted under its own attribute name. Models declaring no scope\n   * attributes keep the deprecated 1.0.503 wire and emit `eventId`. Keys are\n   * sorted so a declared `[\"eventId\"]` partition stays byte-identical with the\n   * 1.0.503 wire.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @returns {Record<string, unknown>} Default serialized row.\n   */\n  defaultSerializeRecord(record) {\n    const scopeAttributes = declaredSyncScopeAttributes(this.modelClass)\n    /** @type {Record<string, unknown>} */\n    const serialized = {\n      data: this.recordData(record),\n      id: this.recordValue(record, \"id\"),\n      resourceId: this.recordValue(record, \"resourceId\"),\n      resourceType: this.recordValue(record, \"resourceType\"),\n      serverSequence: this.recordValue(record, \"serverSequence\"),\n      syncType: this.recordValue(record, \"syncType\"),\n      updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))\n    }\n\n    for (const scopeAttribute of scopeAttributes || [\"eventId\"]) {\n      serialized[scopeAttribute] = this.recordValue(record, scopeAttribute)\n    }\n\n    return Object.fromEntries(Object.entries(serialized).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)))\n  }\n\n  /**\n   * Reads and parses the record data payload.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @returns {unknown} Parsed data value.\n   */\n  recordData(record) {\n    const data = this.recordValue(record, \"data\")\n\n    if (data === \"\" || data === null || data === undefined) return null\n    return decodeReplayPersistedData(data).payload\n  }\n\n  /**\n   * Reads a value from either a record accessor method or plain property.\n   * @param {ReturnType<typeof JSON.parse>} record - Sync/change record.\n   * @param {string} name - Camel-cased value/method name.\n   * @returns {unknown} Record value.\n   */\n  recordValue(record, name) {\n    if (!record || typeof record !== \"object\") {\n      throw new Error(\"Sync changes row must be an object.\")\n    }\n\n    const recordObject = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (record)\n    const method = recordObject[name]\n    const value = typeof method === \"function\" ? method.call(record) : method\n\n    if (value === undefined) {\n      throw new Error(`Sync changes row is missing ${name}.`)\n    }\n\n    return value\n  }\n\n  /**\n   * Converts a date-like value to an ISO string.\n   * @param {Date | string | null | undefined | unknown} value - Date value.\n   * @returns {string} ISO date.\n   */\n  isoDate(value) {\n    const date = value instanceof Date ? value : new Date(typeof value === \"string\" || typeof value === \"number\" ? value : 0)\n\n    if (Number.isNaN(date.getTime())) {\n      throw VelociousError.safe(\"Sync changes row has an invalid updated_at value.\", {code: \"sync-invalid-changes-row\"})\n    }\n\n    return date.toISOString()\n  }\n}\n"]}

package/build/sync/sync-model-change-feed-service.js

@@ -34,9 +34,10 @@ export default class SyncModelChangeFeedService {
 
   /**
    * Builds a stable change-feed page. The additive `total` is the scope's pending
-   * change count from the request cursor to the snapshot bound (a COUNT, not a
-   * materialized read), so a client can render a "synced of total" progress bar;
-   * older clients ignore it.
+   * change count from the request cursor to the snapshot bound, so a client can
+   * render a "synced of total" progress bar; older clients ignore it. The count
+   * query only runs when the page read cannot answer it: a sequence cursor whose
+   * page is short of the limit has already materialized the whole remaining set.
    * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
    */
   async changes() {
@@ -45,10 +46,22 @@ export default class SyncModelChangeFeedService {
 
     if (!upToCursor) return {status: "success", nextCursor: null, syncs: [], total: 0, upToCursor: null}
 
-    const total = await this.totalPendingChanges({upToCursor})
-    const query = this.pageQuery({limit, upToCursor})
-    const records = await query.toArray()
+    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, "afterServerSequence")
+
+    // A cursor at or past the scope's snapshot bound cannot have pending rows.
+    // Answering here skips both the page read and the count, which would otherwise
+    // run against an empty sequence range on every caught-up poll. A multi-scope
+    // client sends its global cursor to each scope, so a scope whose own sequences
+    // are behind that cursor lands here on nearly every request.
+    if (afterServerSequence !== null && afterServerSequence >= upToCursor.serverSequence) {
+      return {status: "success", nextCursor: upToCursor, syncs: [], total: 0, upToCursor}
+    }
+
+    const records = await this.pageQuery({limit, upToCursor}).toArray()
     const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor
+    const total = afterServerSequence !== null && records.length < limit
+      ? records.length
+      : await this.totalPendingChanges({upToCursor})
 
     return {
       status: "success",

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.712",
+  "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

package/src/sync/sync-model-change-feed-service.js

@@ -34,9 +34,10 @@ export default class SyncModelChangeFeedService {
 
   /**
    * Builds a stable change-feed page. The additive `total` is the scope's pending
-   * change count from the request cursor to the snapshot bound (a COUNT, not a
-   * materialized read), so a client can render a "synced of total" progress bar;
-   * older clients ignore it.
+   * change count from the request cursor to the snapshot bound, so a client can
+   * render a "synced of total" progress bar; older clients ignore it. The count
+   * query only runs when the page read cannot answer it: a sequence cursor whose
+   * page is short of the limit has already materialized the whole remaining set.
    * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
    */
   async changes() {
@@ -45,10 +46,22 @@ export default class SyncModelChangeFeedService {
 
     if (!upToCursor) return {status: "success", nextCursor: null, syncs: [], total: 0, upToCursor: null}
 
-    const total = await this.totalPendingChanges({upToCursor})
-    const query = this.pageQuery({limit, upToCursor})
-    const records = await query.toArray()
+    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, "afterServerSequence")
+
+    // A cursor at or past the scope's snapshot bound cannot have pending rows.
+    // Answering here skips both the page read and the count, which would otherwise
+    // run against an empty sequence range on every caught-up poll. A multi-scope
+    // client sends its global cursor to each scope, so a scope whose own sequences
+    // are behind that cursor lands here on nearly every request.
+    if (afterServerSequence !== null && afterServerSequence >= upToCursor.serverSequence) {
+      return {status: "success", nextCursor: upToCursor, syncs: [], total: 0, upToCursor}
+    }
+
+    const records = await this.pageQuery({limit, upToCursor}).toArray()
     const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor
+    const total = afterServerSequence !== null && records.length < limit
+      ? records.length
+      : await this.totalPendingChanges({upToCursor})
 
     return {
       status: "success",