velocious 1.0.666 → 1.0.668

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

@@ -1,10 +1,74 @@
 // @ts-check
 import timeout, { TimeoutError } from "awaitery/build/timeout.js";
 import configurationResolver from "../configuration-resolver.js";
+import isPlainObject from "../utils/plain-object.js";
 import BackgroundJobEnqueueAcknowledgementTimeoutError from "./enqueue-acknowledgement-timeout-error.js";
 import BackgroundJobsSocketRequest from "./socket-request.js";
 import { DEFAULT_GENERATION_HANDSHAKE_TIMEOUT_MS, validateGenerationHandshakeTimeoutMs } from "./generation-handshake-timeout-error.js";
+import { BACKGROUND_JOB_ACTIVE_STATUSES, BACKGROUND_JOB_EXECUTION_MODES, BACKGROUND_JOB_STATUSES, BACKGROUND_JOB_TERMINAL_STATUSES } from "./job-semantics.js";
 const DEFAULT_ENQUEUE_TIMEOUT_MS = 5000;
+const BACKGROUND_JOB_WAKE_OUTCOMES = ["woken", "already_due", "handed_off", "not_found"];
+const BACKGROUND_JOB_NULLABLE_NUMBER_FIELDS = [
+    "attempts",
+    "childPid",
+    "childReceivedAtMs",
+    "childStartedAtMs",
+    "completedAtMs",
+    "createdAtMs",
+    "failedAtMs",
+    "handedOffAtMs",
+    "maxConcurrency",
+    "maxRetries",
+    "orphanedAtMs",
+    "scheduleOrder",
+    "scheduledAtMs",
+    "timeoutMs"
+];
+const BACKGROUND_JOB_NULLABLE_STRING_FIELDS = ["childInstanceId", "concurrencyKey", "handoffId", "lastError", "scheduleKey", "workerId"];
+/**
+ * Checks a required nullable number from a normalized wire row.
+ * @param {ReturnType<typeof JSON.parse>} value - Field value.
+ * @returns {boolean} - Whether the field is null or a finite number.
+ */
+function isNullableBackgroundJobNumber(value) {
+    return value === null || (typeof value === "number" && Number.isFinite(value));
+}
+/**
+ * Checks a required nullable string from a normalized wire row.
+ * @param {ReturnType<typeof JSON.parse>} value - Field value.
+ * @returns {boolean} - Whether the field is null or a string.
+ */
+function isNullableBackgroundJobString(value) {
+    return value === null || typeof value === "string";
+}
+/**
+ * Checks that a transport job uses the normalized public camel-case shape.
+ * @param {ReturnType<typeof JSON.parse>} value - Transport value.
+ * @returns {value is import("./types.js").BackgroundJobRow} - Whether normalized.
+ */
+function isNormalizedBackgroundJob(value) {
+    if (!isPlainObject(value))
+        return false;
+    const job = value;
+    return typeof job.id === "string"
+        && typeof job.jobName === "string"
+        && Array.isArray(job.args)
+        && BACKGROUND_JOB_EXECUTION_MODES.some((executionMode) => executionMode === job.executionMode)
+        && typeof job.queue === "string"
+        && BACKGROUND_JOB_STATUSES.some((status) => status === job.status)
+        && BACKGROUND_JOB_NULLABLE_NUMBER_FIELDS.every((field) => isNullableBackgroundJobNumber(job[field]))
+        && BACKGROUND_JOB_NULLABLE_STRING_FIELDS.every((field) => isNullableBackgroundJobString(job[field]));
+}
+/**
+ * Describes an unexpected protocol response without echoing its payload.
+ * @param {string} operation - Public operation name.
+ * @param {import("./types.js").BackgroundJobSocketMessage} message - Response.
+ * @returns {Error} - Protocol error.
+ */
+function unexpectedResponseError(operation, message) {
+    const responseType = message && typeof message.type === "string" ? message.type : "missing type";
+    return new Error(`Unexpected ${operation} response: ${responseType}`);
+}
 export default class BackgroundJobsClient {
     /**
      * Runs constructor.
@@ -219,5 +283,69 @@ export default class BackgroundJobsClient {
             }
         });
     }
+    /**
+     * Reads current stable ownership and optional terminal history.
+     * @param {{scheduleKey: string, includeLatestTerminal?: boolean}} args - Lookup request.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.
+     */
+    async getScheduledJob({ scheduleKey, includeLatestTerminal }) {
+        const request = await this._request();
+        return await request.run({
+            onConnect: (jsonSocket) => {
+                jsonSocket.send({ type: "get-scheduled-job", scheduleKey, includeLatestTerminal });
+            },
+            onMessage: ({ message, resolve, reject }) => {
+                if (message?.type === "scheduled-job") {
+                    const { currentJob, latestTerminalJob } = message;
+                    const currentJobValid = currentJob === null
+                        || (isNormalizedBackgroundJob(currentJob) && BACKGROUND_JOB_ACTIVE_STATUSES.some((status) => status === currentJob.status));
+                    const latestTerminalJobValid = latestTerminalJob === null
+                        || (isNormalizedBackgroundJob(latestTerminalJob) && BACKGROUND_JOB_TERMINAL_STATUSES.some((status) => status === latestTerminalJob.status));
+                    if (!currentJobValid || !latestTerminalJobValid) {
+                        reject(new Error("Invalid getScheduledJob response: expected normalized public job values"));
+                        return;
+                    }
+                    resolve({ currentJob, latestTerminalJob });
+                    return;
+                }
+                if (message?.type === "get-scheduled-job-error") {
+                    reject(new Error(message.error || "Failed to read scheduled job"));
+                    return;
+                }
+                reject(unexpectedResponseError("getScheduledJob", message));
+            }
+        });
+    }
+    /**
+     * Expedites a future queued stable owner without changing job identity.
+     * @param {{scheduleKey: string}} args - Wake request.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Wake result.
+     */
+    async wakeScheduled({ scheduleKey }) {
+        const request = await this._request();
+        return await request.run({
+            onConnect: (jsonSocket) => {
+                jsonSocket.send({ type: "wake-scheduled", scheduleKey });
+            },
+            onMessage: ({ message, resolve, reject }) => {
+                if (message?.type === "schedule-woken") {
+                    const outcome = message.outcome;
+                    const knownOutcome = BACKGROUND_JOB_WAKE_OUTCOMES.includes(outcome);
+                    const validJobId = outcome === "not_found" ? message.jobId === null : typeof message.jobId === "string" && message.jobId.length > 0;
+                    if (!knownOutcome || !validJobId) {
+                        reject(new Error("Invalid wakeScheduled response"));
+                        return;
+                    }
+                    resolve({ jobId: message.jobId, outcome });
+                    return;
+                }
+                if (message?.type === "wake-scheduled-error") {
+                    reject(new Error(message.error || "Failed to wake scheduled job"));
+                    return;
+                }
+                reject(unexpectedResponseError("wakeScheduled", message));
+            }
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport timeout, {TimeoutError} from \"awaitery/build/timeout.js\"\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobEnqueueAcknowledgementTimeoutError from \"./enqueue-acknowledgement-timeout-error.js\"\nimport BackgroundJobsSocketRequest from \"./socket-request.js\"\nimport { DEFAULT_GENERATION_HANDSHAKE_TIMEOUT_MS, validateGenerationHandshakeTimeoutMs } from \"./generation-handshake-timeout-error.js\"\n\nconst DEFAULT_ENQUEUE_TIMEOUT_MS = 5000\n\nexport default class BackgroundJobsClient {\n  /**\n   * Runs constructor.\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration.\n   * @param {number} [args.enqueueTimeoutMs] - Maximum time to wait for an enqueue acknowledgement in milliseconds (default: 5000).\n   * @param {number} [args.generationHandshakeTimeoutMs] - Maximum time to wait for generation acknowledgement (default: 4000).\n   * @param {string} [args.generationId] - Explicit release generation identity.\n   */\n  constructor({configuration, enqueueTimeoutMs = DEFAULT_ENQUEUE_TIMEOUT_MS, generationHandshakeTimeoutMs = DEFAULT_GENERATION_HANDSHAKE_TIMEOUT_MS, generationId} = {}) {\n    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()\n    this.enqueueTimeoutMs = enqueueTimeoutMs\n    this.generationHandshakeTimeoutMs = validateGenerationHandshakeTimeoutMs(generationHandshakeTimeoutMs)\n    this.explicitGenerationId = generationId\n  }\n\n  /**\n   * Builds a one-shot client socket request from the resolved configuration.\n   * @returns {Promise<BackgroundJobsSocketRequest>} - Socket request.\n   */\n  async _request() {\n    const configuration = await this.configurationPromise\n    const {host, port} = configuration.getBackgroundJobsConfig()\n    const {generationId} = configuration.resolveBackgroundJobsGenerationConfig({\n      generationId: this.explicitGenerationId,\n      sourceName: \"BackgroundJobsClient\"\n    })\n\n    return new BackgroundJobsSocketRequest({host, port, role: \"client\", generationHandshakeTimeoutMs: this.generationHandshakeTimeoutMs, generationId})\n  }\n\n  /**\n   * Runs enqueue.\n   * @param {object} args - Options.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @param {string} [args.producerInvocationId] - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} [args.producerProof] - Exact internal producer handoff.\n   * @returns {Promise<string>} - Job id.\n   */\n  async enqueue({jobName, args, options, producerInvocationId, producerProof}) {\n    const message = {\n      type: /** @type {const} */ (\"enqueue\"),\n      jobName,\n      args,\n      options,\n      ...(producerInvocationId ? {producerInvocationId} : {}),\n      ...(producerProof ? {producerProof} : {})\n    }\n    /**\n     * Creates safe observations for one attempt without retaining request data.\n     * @param {object} args - Attempt identity.\n     * @param {\"initial\" | \"owned_replay\"} args.attemptKind - Initial attempt or owned replay.\n     * @param {number} args.attemptNumber - One-based attempt number.\n     * @returns {import(\"./enqueue-acknowledgement-timeout-error.js\").BackgroundJobEnqueueAttempt} - Mutable attempt observations.\n     */\n    const newAttemptObservation = ({attemptKind, attemptNumber}) => ({\n      acknowledgementWaitElapsedMs: 0,\n      attemptElapsedMs: 0,\n      attemptKind,\n      attemptNumber,\n      explicitlyRejected: false,\n      generationFenced: false,\n      requestSent: false\n    })\n    /**\n     * Sends one enqueue attempt. An owned caller may replay this exact message\n     * once when transport acknowledgement remains ambiguous after send.\n     * @param {import(\"./enqueue-acknowledgement-timeout-error.js\").BackgroundJobEnqueueAttempt} attemptObservation - Mutable attempt observations.\n     * @param {Readonly<Array<import(\"./enqueue-acknowledgement-timeout-error.js\").BackgroundJobEnqueueAttempt>>} previousAttempts - Earlier timed-out attempts.\n     * @returns {Promise<string>} - Job id.\n     */\n    const enqueueAttempt = async (attemptObservation, previousAttempts) => {\n      const attemptStartedAtMs = Date.now()\n      const request = await this._request()\n      const requestAbortController = new AbortController()\n      const timeoutErrorMessage = `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`\n      /** @type {number | undefined} */\n      let requestSentAtMs\n      /**\n       * Resolves the pre-send phase when the mutation has entered the socket.\n       * @type {() => void}\n       */\n      let markRequestSent = () => {}\n      const requestSent = new Promise((resolve) => {\n        markRequestSent = () => resolve(undefined)\n      })\n      /**\n       * Applies the configured deadline independently to one request phase.\n       * @template T\n       * @param {() => Promise<T>} callback - Phase work.\n       * @returns {Promise<T>} - Phase result.\n       */\n      const withEnqueueTimeout = async (callback) => await timeout({\n        errorMessage: timeoutErrorMessage,\n        timeout: this.enqueueTimeoutMs\n      }, async ({control}) => {\n        const abortRequest = () => requestAbortController.abort(control.signal.reason)\n\n        control.signal.addEventListener(\"abort\", abortRequest)\n        try {\n          return await callback()\n        } finally {\n          control.signal.removeEventListener(\"abort\", abortRequest)\n        }\n      })\n      const requestPromise = request.run({\n        signal: requestAbortController.signal,\n        onConnect: (jsonSocket) => {\n          jsonSocket.send(message)\n          attemptObservation.generationFenced = Boolean(request.generationId)\n          attemptObservation.requestSent = true\n          requestSentAtMs = Date.now()\n          markRequestSent()\n        },\n        onMessage: ({message, resolve, reject}) => {\n          if (message?.type === \"enqueued\") {\n            resolve(message.jobId)\n            return\n          }\n\n          if (message?.type === \"enqueue-error\") {\n            attemptObservation.explicitlyRejected = true\n            reject(new Error(message.error || \"Failed to enqueue job\"))\n          }\n        }\n      })\n\n      await withEnqueueTimeout(async () => await Promise.race([requestSent, requestPromise]))\n\n      try {\n        return await withEnqueueTimeout(async () => await requestPromise)\n      } catch (error) {\n        if (!(error instanceof TimeoutError)) throw error\n        if (requestSentAtMs === undefined) throw new Error(\"Background job enqueue acknowledgement wait started before the request was sent\", {cause: error})\n\n        const timedOutAtMs = Date.now()\n        // The fired timer proves its logical deadline even when the adjustable wall clock reports a shorter interval.\n        const acknowledgementWaitElapsedMs = Math.max(this.enqueueTimeoutMs, timedOutAtMs - requestSentAtMs)\n\n        attemptObservation.acknowledgementWaitElapsedMs = acknowledgementWaitElapsedMs\n        attemptObservation.attemptElapsedMs = Math.max(acknowledgementWaitElapsedMs, timedOutAtMs - attemptStartedAtMs)\n\n        throw new BackgroundJobEnqueueAcknowledgementTimeoutError({\n          acknowledgementTimeoutMs: this.enqueueTimeoutMs,\n          attemptHistory: [...previousAttempts, attemptObservation],\n          cause: error,\n          generationId: request.generationId,\n          jobName,\n          producerInvocationId,\n          producerProofPresent: Boolean(producerProof)\n        })\n      }\n    }\n\n    const initialAttempt = newAttemptObservation({attemptKind: \"initial\", attemptNumber: 1})\n\n    try {\n      return await enqueueAttempt(initialAttempt, [])\n    } catch (error) {\n      if (!producerInvocationId || !producerProof || !initialAttempt.generationFenced || !initialAttempt.requestSent || initialAttempt.explicitlyRejected) throw error\n\n      const previousAttempts = error instanceof BackgroundJobEnqueueAcknowledgementTimeoutError ? error.attemptHistory : []\n      const replayAttempt = newAttemptObservation({attemptKind: \"owned_replay\", attemptNumber: 2})\n\n      return await enqueueAttempt(replayAttempt, previousAttempts)\n    }\n  }\n\n  /**\n   * Atomically replaces the queued owner of a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {string} args.jobName - Job name.\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  async replaceScheduled({scheduleKey, jobName, args, options}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"replace-scheduled\", scheduleKey, jobName, args, options})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-replaced\") {\n          resolve({\n            jobId: message.jobId,\n            previousJobId: message.previousJobId,\n            previousStatus: message.previousStatus\n          })\n          return\n        }\n\n        if (message?.type === \"replace-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to replace scheduled job\"))\n        }\n      }\n    })\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  async cancelScheduled({scheduleKey}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"cancel-scheduled\", scheduleKey})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-cancelled\") {\n          resolve({jobId: message.jobId, outcome: message.outcome})\n          return\n        }\n\n        if (message?.type === \"cancel-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to cancel scheduled job\"))\n        }\n      }\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport timeout, { TimeoutError } from \"awaitery/build/timeout.js\"\nimport configurationResolver from \"../configuration-resolver.js\"\nimport isPlainObject from \"../utils/plain-object.js\"\nimport BackgroundJobEnqueueAcknowledgementTimeoutError from \"./enqueue-acknowledgement-timeout-error.js\"\nimport BackgroundJobsSocketRequest from \"./socket-request.js\"\nimport { DEFAULT_GENERATION_HANDSHAKE_TIMEOUT_MS, validateGenerationHandshakeTimeoutMs } from \"./generation-handshake-timeout-error.js\"\nimport { BACKGROUND_JOB_ACTIVE_STATUSES, BACKGROUND_JOB_EXECUTION_MODES, BACKGROUND_JOB_STATUSES, BACKGROUND_JOB_TERMINAL_STATUSES } from \"./job-semantics.js\"\n\nconst DEFAULT_ENQUEUE_TIMEOUT_MS = 5000\nconst BACKGROUND_JOB_WAKE_OUTCOMES = [\"woken\", \"already_due\", \"handed_off\", \"not_found\"]\nconst BACKGROUND_JOB_NULLABLE_NUMBER_FIELDS = [\n  \"attempts\",\n  \"childPid\",\n  \"childReceivedAtMs\",\n  \"childStartedAtMs\",\n  \"completedAtMs\",\n  \"createdAtMs\",\n  \"failedAtMs\",\n  \"handedOffAtMs\",\n  \"maxConcurrency\",\n  \"maxRetries\",\n  \"orphanedAtMs\",\n  \"scheduleOrder\",\n  \"scheduledAtMs\",\n  \"timeoutMs\"\n]\nconst BACKGROUND_JOB_NULLABLE_STRING_FIELDS = [\"childInstanceId\", \"concurrencyKey\", \"handoffId\", \"lastError\", \"scheduleKey\", \"workerId\"]\n\n/**\n * Checks a required nullable number from a normalized wire row.\n * @param {ReturnType<typeof JSON.parse>} value - Field value.\n * @returns {boolean} - Whether the field is null or a finite number.\n */\nfunction isNullableBackgroundJobNumber(value) {\n  return value === null || (typeof value === \"number\" && Number.isFinite(value))\n}\n\n/**\n * Checks a required nullable string from a normalized wire row.\n * @param {ReturnType<typeof JSON.parse>} value - Field value.\n * @returns {boolean} - Whether the field is null or a string.\n */\nfunction isNullableBackgroundJobString(value) {\n  return value === null || typeof value === \"string\"\n}\n\n/**\n * Checks that a transport job uses the normalized public camel-case shape.\n * @param {ReturnType<typeof JSON.parse>} value - Transport value.\n * @returns {value is import(\"./types.js\").BackgroundJobRow} - Whether normalized.\n */\nfunction isNormalizedBackgroundJob(value) {\n  if (!isPlainObject(value)) return false\n\n  const job = value\n\n  return typeof job.id === \"string\"\n    && typeof job.jobName === \"string\"\n    && Array.isArray(job.args)\n    && BACKGROUND_JOB_EXECUTION_MODES.some((executionMode) => executionMode === job.executionMode)\n    && typeof job.queue === \"string\"\n    && BACKGROUND_JOB_STATUSES.some((status) => status === job.status)\n    && BACKGROUND_JOB_NULLABLE_NUMBER_FIELDS.every((field) => isNullableBackgroundJobNumber(job[field]))\n    && BACKGROUND_JOB_NULLABLE_STRING_FIELDS.every((field) => isNullableBackgroundJobString(job[field]))\n}\n\n/**\n * Describes an unexpected protocol response without echoing its payload.\n * @param {string} operation - Public operation name.\n * @param {import(\"./types.js\").BackgroundJobSocketMessage} message - Response.\n * @returns {Error} - Protocol error.\n */\nfunction unexpectedResponseError(operation, message) {\n  const responseType = message && typeof message.type === \"string\" ? message.type : \"missing type\"\n\n  return new Error(`Unexpected ${operation} response: ${responseType}`)\n}\n\nexport default class BackgroundJobsClient {\n  /**\n   * Runs constructor.\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration.\n   * @param {number} [args.enqueueTimeoutMs] - Maximum time to wait for an enqueue acknowledgement in milliseconds (default: 5000).\n   * @param {number} [args.generationHandshakeTimeoutMs] - Maximum time to wait for generation acknowledgement (default: 4000).\n   * @param {string} [args.generationId] - Explicit release generation identity.\n   */\n  constructor({configuration, enqueueTimeoutMs = DEFAULT_ENQUEUE_TIMEOUT_MS, generationHandshakeTimeoutMs = DEFAULT_GENERATION_HANDSHAKE_TIMEOUT_MS, generationId} = {}) {\n    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()\n    this.enqueueTimeoutMs = enqueueTimeoutMs\n    this.generationHandshakeTimeoutMs = validateGenerationHandshakeTimeoutMs(generationHandshakeTimeoutMs)\n    this.explicitGenerationId = generationId\n  }\n\n  /**\n   * Builds a one-shot client socket request from the resolved configuration.\n   * @returns {Promise<BackgroundJobsSocketRequest>} - Socket request.\n   */\n  async _request() {\n    const configuration = await this.configurationPromise\n    const {host, port} = configuration.getBackgroundJobsConfig()\n    const {generationId} = configuration.resolveBackgroundJobsGenerationConfig({\n      generationId: this.explicitGenerationId,\n      sourceName: \"BackgroundJobsClient\"\n    })\n\n    return new BackgroundJobsSocketRequest({host, port, role: \"client\", generationHandshakeTimeoutMs: this.generationHandshakeTimeoutMs, generationId})\n  }\n\n  /**\n   * Runs enqueue.\n   * @param {object} args - Options.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @param {string} [args.producerInvocationId] - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} [args.producerProof] - Exact internal producer handoff.\n   * @returns {Promise<string>} - Job id.\n   */\n  async enqueue({jobName, args, options, producerInvocationId, producerProof}) {\n    const message = {\n      type: /** @type {const} */ (\"enqueue\"),\n      jobName,\n      args,\n      options,\n      ...(producerInvocationId ? {producerInvocationId} : {}),\n      ...(producerProof ? {producerProof} : {})\n    }\n    /**\n     * Creates safe observations for one attempt without retaining request data.\n     * @param {object} args - Attempt identity.\n     * @param {\"initial\" | \"owned_replay\"} args.attemptKind - Initial attempt or owned replay.\n     * @param {number} args.attemptNumber - One-based attempt number.\n     * @returns {import(\"./enqueue-acknowledgement-timeout-error.js\").BackgroundJobEnqueueAttempt} - Mutable attempt observations.\n     */\n    const newAttemptObservation = ({attemptKind, attemptNumber}) => ({\n      acknowledgementWaitElapsedMs: 0,\n      attemptElapsedMs: 0,\n      attemptKind,\n      attemptNumber,\n      explicitlyRejected: false,\n      generationFenced: false,\n      requestSent: false\n    })\n    /**\n     * Sends one enqueue attempt. An owned caller may replay this exact message\n     * once when transport acknowledgement remains ambiguous after send.\n     * @param {import(\"./enqueue-acknowledgement-timeout-error.js\").BackgroundJobEnqueueAttempt} attemptObservation - Mutable attempt observations.\n     * @param {Readonly<Array<import(\"./enqueue-acknowledgement-timeout-error.js\").BackgroundJobEnqueueAttempt>>} previousAttempts - Earlier timed-out attempts.\n     * @returns {Promise<string>} - Job id.\n     */\n    const enqueueAttempt = async (attemptObservation, previousAttempts) => {\n      const attemptStartedAtMs = Date.now()\n      const request = await this._request()\n      const requestAbortController = new AbortController()\n      const timeoutErrorMessage = `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`\n      /** @type {number | undefined} */\n      let requestSentAtMs\n      /**\n       * Resolves the pre-send phase when the mutation has entered the socket.\n       * @type {() => void}\n       */\n      let markRequestSent = () => {}\n      const requestSent = new Promise((resolve) => {\n        markRequestSent = () => resolve(undefined)\n      })\n      /**\n       * Applies the configured deadline independently to one request phase.\n       * @template T\n       * @param {() => Promise<T>} callback - Phase work.\n       * @returns {Promise<T>} - Phase result.\n       */\n      const withEnqueueTimeout = async (callback) => await timeout({\n        errorMessage: timeoutErrorMessage,\n        timeout: this.enqueueTimeoutMs\n      }, async ({control}) => {\n        const abortRequest = () => requestAbortController.abort(control.signal.reason)\n\n        control.signal.addEventListener(\"abort\", abortRequest)\n        try {\n          return await callback()\n        } finally {\n          control.signal.removeEventListener(\"abort\", abortRequest)\n        }\n      })\n      const requestPromise = request.run({\n        signal: requestAbortController.signal,\n        onConnect: (jsonSocket) => {\n          jsonSocket.send(message)\n          attemptObservation.generationFenced = Boolean(request.generationId)\n          attemptObservation.requestSent = true\n          requestSentAtMs = Date.now()\n          markRequestSent()\n        },\n        onMessage: ({message, resolve, reject}) => {\n          if (message?.type === \"enqueued\") {\n            resolve(message.jobId)\n            return\n          }\n\n          if (message?.type === \"enqueue-error\") {\n            attemptObservation.explicitlyRejected = true\n            reject(new Error(message.error || \"Failed to enqueue job\"))\n          }\n        }\n      })\n\n      await withEnqueueTimeout(async () => await Promise.race([requestSent, requestPromise]))\n\n      try {\n        return await withEnqueueTimeout(async () => await requestPromise)\n      } catch (error) {\n        if (!(error instanceof TimeoutError)) throw error\n        if (requestSentAtMs === undefined) throw new Error(\"Background job enqueue acknowledgement wait started before the request was sent\", {cause: error})\n\n        const timedOutAtMs = Date.now()\n        // The fired timer proves its logical deadline even when the adjustable wall clock reports a shorter interval.\n        const acknowledgementWaitElapsedMs = Math.max(this.enqueueTimeoutMs, timedOutAtMs - requestSentAtMs)\n\n        attemptObservation.acknowledgementWaitElapsedMs = acknowledgementWaitElapsedMs\n        attemptObservation.attemptElapsedMs = Math.max(acknowledgementWaitElapsedMs, timedOutAtMs - attemptStartedAtMs)\n\n        throw new BackgroundJobEnqueueAcknowledgementTimeoutError({\n          acknowledgementTimeoutMs: this.enqueueTimeoutMs,\n          attemptHistory: [...previousAttempts, attemptObservation],\n          cause: error,\n          generationId: request.generationId,\n          jobName,\n          producerInvocationId,\n          producerProofPresent: Boolean(producerProof)\n        })\n      }\n    }\n\n    const initialAttempt = newAttemptObservation({attemptKind: \"initial\", attemptNumber: 1})\n\n    try {\n      return await enqueueAttempt(initialAttempt, [])\n    } catch (error) {\n      if (!producerInvocationId || !producerProof || !initialAttempt.generationFenced || !initialAttempt.requestSent || initialAttempt.explicitlyRejected) throw error\n\n      const previousAttempts = error instanceof BackgroundJobEnqueueAcknowledgementTimeoutError ? error.attemptHistory : []\n      const replayAttempt = newAttemptObservation({attemptKind: \"owned_replay\", attemptNumber: 2})\n\n      return await enqueueAttempt(replayAttempt, previousAttempts)\n    }\n  }\n\n  /**\n   * Atomically replaces the queued owner of a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {string} args.jobName - Job name.\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  async replaceScheduled({scheduleKey, jobName, args, options}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"replace-scheduled\", scheduleKey, jobName, args, options})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-replaced\") {\n          resolve({\n            jobId: message.jobId,\n            previousJobId: message.previousJobId,\n            previousStatus: message.previousStatus\n          })\n          return\n        }\n\n        if (message?.type === \"replace-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to replace scheduled job\"))\n        }\n      }\n    })\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  async cancelScheduled({scheduleKey}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"cancel-scheduled\", scheduleKey})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-cancelled\") {\n          resolve({jobId: message.jobId, outcome: message.outcome})\n          return\n        }\n\n        if (message?.type === \"cancel-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to cancel scheduled job\"))\n        }\n      }\n    })\n  }\n\n  /**\n   * Reads current stable ownership and optional terminal history.\n   * @param {{scheduleKey: string, includeLatestTerminal?: boolean}} args - Lookup request.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.\n   */\n  async getScheduledJob({scheduleKey, includeLatestTerminal}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"get-scheduled-job\", scheduleKey, includeLatestTerminal})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"scheduled-job\") {\n          const {currentJob, latestTerminalJob} = message\n          const currentJobValid = currentJob === null\n            || (isNormalizedBackgroundJob(currentJob) && BACKGROUND_JOB_ACTIVE_STATUSES.some((status) => status === currentJob.status))\n          const latestTerminalJobValid = latestTerminalJob === null\n            || (isNormalizedBackgroundJob(latestTerminalJob) && BACKGROUND_JOB_TERMINAL_STATUSES.some((status) => status === latestTerminalJob.status))\n\n          if (!currentJobValid || !latestTerminalJobValid) {\n            reject(new Error(\"Invalid getScheduledJob response: expected normalized public job values\"))\n            return\n          }\n\n          resolve({currentJob, latestTerminalJob})\n          return\n        }\n\n        if (message?.type === \"get-scheduled-job-error\") {\n          reject(new Error(message.error || \"Failed to read scheduled job\"))\n          return\n        }\n\n        reject(unexpectedResponseError(\"getScheduledJob\", message))\n      }\n    })\n  }\n\n  /**\n   * Expedites a future queued stable owner without changing job identity.\n   * @param {{scheduleKey: string}} args - Wake request.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobWakeResult>} - Wake result.\n   */\n  async wakeScheduled({scheduleKey}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"wake-scheduled\", scheduleKey})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-woken\") {\n          const outcome = message.outcome\n          const knownOutcome = BACKGROUND_JOB_WAKE_OUTCOMES.includes(outcome)\n          const validJobId = outcome === \"not_found\" ? message.jobId === null : typeof message.jobId === \"string\" && message.jobId.length > 0\n\n          if (!knownOutcome || !validJobId) {\n            reject(new Error(\"Invalid wakeScheduled response\"))\n            return\n          }\n\n          resolve({jobId: message.jobId, outcome})\n          return\n        }\n\n        if (message?.type === \"wake-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to wake scheduled job\"))\n          return\n        }\n\n        reject(unexpectedResponseError(\"wakeScheduled\", message))\n      }\n    })\n  }\n}\n"]}

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

@@ -4,6 +4,24 @@ export declare const DEFAULT_BACKGROUND_JOB_QUEUE = "default";
 export declare const QUEUE_CONCURRENCY_KEY_PREFIX = "queue:";
 /** @type {import("./types.js").BackgroundJobExecutionMode[]} */
 export declare const BACKGROUND_JOB_EXECUTION_MODES: import("./types.js").BackgroundJobExecutionMode[];
+/** @type {import("./types.js").BackgroundJobActiveStatus[]} */
+export declare const BACKGROUND_JOB_ACTIVE_STATUSES: import("./types.js").BackgroundJobActiveStatus[];
+/** @type {import("./types.js").BackgroundJobTerminalStatus[]} */
+export declare const BACKGROUND_JOB_TERMINAL_STATUSES: import("./types.js").BackgroundJobTerminalStatus[];
+/** @type {import("./types.js").BackgroundJobStatus[]} */
+export declare const BACKGROUND_JOB_STATUSES: import("./types.js").BackgroundJobStatus[];
+/**
+ * Normalizes persisted or transported job status vocabulary.
+ * @param {string} value - Candidate status.
+ * @returns {import("./types.js").BackgroundJobStatus} - Known status.
+ */
+export declare function normalizeBackgroundJobStatus(value: string): import("./types.js").BackgroundJobStatus;
+/**
+ * Validates a stable logical schedule key at every persistence boundary.
+ * @param {string} scheduleKey - Stable schedule key.
+ * @returns {string} - Validated key.
+ */
+export declare function normalizeBackgroundJobScheduleKey(scheduleKey: string): string;
 /**
  * Normalizes a job queue.
  * @param {import("./types.js").BackgroundJobOptions} [options] - Job options.

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

@@ -1 +1 @@
-{"version":3,"file":"job-semantics.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-semantics.js"],"names":[],"mappings":"AAIA,eAAO,MAAM,qCAAqC,WAAW,CAAA;AAC7D,eAAO,MAAM,kCAAkC,KAAK,CAAA;AACpD,eAAO,MAAM,4BAA4B,YAAY,CAAA;AACrD,eAAO,MAAM,4BAA4B,WAAW,CAAA;AACpD,gEAAgE;AAChE,eAAO,MAAM,8BAA8B,EADhC,OAAO,YAAY,EAAE,0BAA0B,EAC6B,CAAA;AAEvF;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,AAHhD,CACA,EADQ,OAAO,YAAY,EAAE,oBAGmB,GAFtC,MAAM,CAQlB;AAED;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,GALhD,IAAI,CAAC,OAAO,YAAY,EAAE,oBAAoB,EAAE,eAAe,CAAC,GAAG;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAKrC,EAAE,oBAAoB,AAJnF,CACA,EADQ,OAAO,YAAY,EAAE,0BAI8F,EAAE,uBAAuB,AAHpJ,CACA,EADQ,OAAO,YAAY,EAAE,0BAA0B,EAG8H,GAF3K,OAAO,YAAY,EAAE,0BAA0B,CAsB3D;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAHhD,MAAM,GAAG,IAAI,GAAG,SAGgC,GAF9C,MAAM,CAQlB;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,aAAa,EAJtD,MAAM,GAAG,SAI6C,EAAE,oBAAoB,EAH5E,MAG4E,GAF1E,MAAM,CAOlB;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAJzC,MAIyC,EAAE,KAAK,EAHhD,MAGgD,GAF9C,MAAM,CAclB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAH5B,MAG4B,GAF1B,MAAM,CAQlB;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,EAAC,OAAY,EAAE,KAAK,EAAE,MAAM,EAAC,EAL5E;IAAwD,OAAO,EAAvD,OAAO,YAAY,EAAE,oBAAoB,CACjD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAA0E,MAAM,EAAxE,MAAM,CAAC,MAAM,EAAE;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CACnE;CAE4E,GAFlE,OAAO,YAAY,EAAE,gCAAgC,GAAG,IAAI,CA0BxE"}
+{"version":3,"file":"job-semantics.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-semantics.js"],"names":[],"mappings":"AAIA,eAAO,MAAM,qCAAqC,WAAW,CAAA;AAC7D,eAAO,MAAM,kCAAkC,KAAK,CAAA;AACpD,eAAO,MAAM,4BAA4B,YAAY,CAAA;AACrD,eAAO,MAAM,4BAA4B,WAAW,CAAA;AACpD,gEAAgE;AAChE,eAAO,MAAM,8BAA8B,EADhC,OAAO,YAAY,EAAE,0BAA0B,EAC6B,CAAA;AACvF,+DAA+D;AAC/D,eAAO,MAAM,8BAA8B,EADhC,OAAO,YAAY,EAAE,yBAAyB,EACa,CAAA;AACtE,iEAAiE;AACjE,eAAO,MAAM,gCAAgC,EADlC,OAAO,YAAY,EAAE,2BAA2B,EACqC,CAAA;AAChG,yDAAyD;AACzD,eAAO,MAAM,uBAAuB,EADzB,OAAO,YAAY,EAAE,mBAAmB,EAC4D,CAAA;AAE/G;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAHvC,MAGuC,GAFrC,OAAO,YAAY,EAAE,mBAAmB,CAQpD;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,WAAW,EAHlD,MAGkD,GAFhD,MAAM,CAMlB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,AAHhD,CACA,EADQ,OAAO,YAAY,EAAE,oBAGmB,GAFtC,MAAM,CAQlB;AAED;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,GALhD,IAAI,CAAC,OAAO,YAAY,EAAE,oBAAoB,EAAE,eAAe,CAAC,GAAG;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAKrC,EAAE,oBAAoB,AAJnF,CACA,EADQ,OAAO,YAAY,EAAE,0BAI8F,EAAE,uBAAuB,AAHpJ,CACA,EADQ,OAAO,YAAY,EAAE,0BAA0B,EAG8H,GAF3K,OAAO,YAAY,EAAE,0BAA0B,CAsB3D;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAHhD,MAAM,GAAG,IAAI,GAAG,SAGgC,GAF9C,MAAM,CAQlB;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,aAAa,EAJtD,MAAM,GAAG,SAI6C,EAAE,oBAAoB,EAH5E,MAG4E,GAF1E,MAAM,CAOlB;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAJzC,MAIyC,EAAE,KAAK,EAHhD,MAGgD,GAF9C,MAAM,CAclB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAH5B,MAG4B,GAF1B,MAAM,CAQlB;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,EAAC,OAAY,EAAE,KAAK,EAAE,MAAM,EAAC,EAL5E;IAAwD,OAAO,EAAvD,OAAO,YAAY,EAAE,oBAAoB,CACjD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAA0E,MAAM,EAAxE,MAAM,CAAC,MAAM,EAAE;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CACnE;CAE4E,GAFlE,OAAO,YAAY,EAAE,gCAAgC,GAAG,IAAI,CA0BxE"}

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

@@ -6,6 +6,33 @@ export const DEFAULT_BACKGROUND_JOB_QUEUE = "default";
 export const QUEUE_CONCURRENCY_KEY_PREFIX = "queue:";
 /** @type {import("./types.js").BackgroundJobExecutionMode[]} */
 export const BACKGROUND_JOB_EXECUTION_MODES = ["inline", "forked", "pooled", "spawned"];
+/** @type {import("./types.js").BackgroundJobActiveStatus[]} */
+export const BACKGROUND_JOB_ACTIVE_STATUSES = ["queued", "handed_off"];
+/** @type {import("./types.js").BackgroundJobTerminalStatus[]} */
+export const BACKGROUND_JOB_TERMINAL_STATUSES = ["cancelled", "completed", "failed", "orphaned"];
+/** @type {import("./types.js").BackgroundJobStatus[]} */
+export const BACKGROUND_JOB_STATUSES = [...BACKGROUND_JOB_ACTIVE_STATUSES, ...BACKGROUND_JOB_TERMINAL_STATUSES];
+/**
+ * Normalizes persisted or transported job status vocabulary.
+ * @param {string} value - Candidate status.
+ * @returns {import("./types.js").BackgroundJobStatus} - Known status.
+ */
+export function normalizeBackgroundJobStatus(value) {
+    const status = BACKGROUND_JOB_STATUSES.find((candidate) => candidate === value);
+    if (status)
+        return status;
+    throw new Error(`Unknown background job status: ${value}`);
+}
+/**
+ * Validates a stable logical schedule key at every persistence boundary.
+ * @param {string} scheduleKey - Stable schedule key.
+ * @returns {string} - Validated key.
+ */
+export function normalizeBackgroundJobScheduleKey(scheduleKey) {
+    if (typeof scheduleKey === "string" && scheduleKey.length > 0 && scheduleKey.length <= 255)
+        return scheduleKey;
+    throw VelociousError.safe("background job scheduleKey must be a non-empty string of at most 255 characters");
+}
 /**
  * Normalizes a job queue.
  * @param {import("./types.js").BackgroundJobOptions} [options] - Job options.
@@ -122,4 +149,4 @@ export function normalizeBackgroundJobConcurrency({ options = {}, queue, queues
         queueDerived: true
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-semantics.js","sourceRoot":"","sources":["../../../src/background-jobs/job-semantics.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nexport const DEFAULT_BACKGROUND_JOB_EXECUTION_MODE = \"pooled\"\nexport const DEFAULT_BACKGROUND_JOB_MAX_RETRIES = 10\nexport const DEFAULT_BACKGROUND_JOB_QUEUE = \"default\"\nexport const QUEUE_CONCURRENCY_KEY_PREFIX = \"queue:\"\n/** @type {import(\"./types.js\").BackgroundJobExecutionMode[]} */\nexport const BACKGROUND_JOB_EXECUTION_MODES = [\"inline\", \"forked\", \"pooled\", \"spawned\"]\n\n/**\n * Normalizes a job queue.\n * @param {import(\"./types.js\").BackgroundJobOptions} [options] - Job options.\n * @returns {string} - Queue name.\n */\nexport function normalizeBackgroundJobQueue(options) {\n  const queue = options?.queue\n\n  if (typeof queue === \"string\" && queue.trim().length > 0) return queue.trim()\n\n  return DEFAULT_BACKGROUND_JOB_QUEUE\n}\n\n/**\n * Normalizes an explicit execution mode while retaining the Node default.\n * @param {Omit<import(\"./types.js\").BackgroundJobOptions, \"executionMode\"> & {executionMode?: string}} options - Job options.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode} [defaultExecutionMode] - Default mode.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode[]} [supportedExecutionModes] - Modes accepted by the caller.\n * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Execution mode.\n */\nexport function normalizeBackgroundJobExecutionMode(options = {}, defaultExecutionMode = DEFAULT_BACKGROUND_JOB_EXECUTION_MODE, supportedExecutionModes = BACKGROUND_JOB_EXECUTION_MODES) {\n  if (\"forked\" in options) {\n    throw new Error(\"The background job `forked` option was removed; pass `executionMode` (\\\"inline\\\", \\\"forked\\\", \\\"pooled\\\", or \\\"spawned\\\") instead\")\n  }\n\n  const requestedExecutionMode = options.executionMode || defaultExecutionMode\n  /** @type {import(\"./types.js\").BackgroundJobExecutionMode | undefined} */\n  let executionMode\n\n  for (const candidate of BACKGROUND_JOB_EXECUTION_MODES) {\n    if (candidate === requestedExecutionMode) executionMode = candidate\n  }\n\n  if (!executionMode) throw new Error(`Invalid background job executionMode: ${requestedExecutionMode}`)\n\n  if (!supportedExecutionModes.includes(executionMode)) {\n    throw new Error(`Background job executionMode \"${executionMode}\" is not supported by the local background-jobs adapter`)\n  }\n\n  return executionMode\n}\n\n/**\n * Validates and normalizes a retry cap.\n * @param {number | null | undefined} maxRetries - Requested retry cap.\n * @returns {number} - Retry cap.\n */\nexport function normalizeBackgroundJobMaxRetries(maxRetries) {\n  if (typeof maxRetries === \"number\" && Number.isFinite(maxRetries) && maxRetries >= 0) {\n    return Math.floor(maxRetries)\n  }\n\n  return DEFAULT_BACKGROUND_JOB_MAX_RETRIES\n}\n\n/**\n * Validates an enqueue eligibility timestamp.\n * @param {number | undefined} scheduledAtMs - Requested timestamp.\n * @param {number} defaultScheduledAtMs - Default timestamp.\n * @returns {number} - Eligibility timestamp.\n */\nexport function normalizeBackgroundJobScheduledAtMs(scheduledAtMs, defaultScheduledAtMs) {\n  if (scheduledAtMs === undefined) return defaultScheduledAtMs\n  if (Number.isSafeInteger(scheduledAtMs) && scheduledAtMs >= 0) return scheduledAtMs\n\n  throw VelociousError.safe(\"background job scheduledAtMs must be a non-negative safe integer\")\n}\n\n/**\n * Validates a reschedule delay and resolves it at persistence time.\n * @param {number} delayMs - Requested delay.\n * @param {number} nowMs - Persistence timestamp.\n * @returns {number} - New eligibility timestamp.\n */\nexport function rescheduledBackgroundJobAtMs(delayMs, nowMs) {\n  if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n    throw VelociousError.safe(\"background job reschedule delayMs must be a non-negative safe integer\")\n  }\n\n  const scheduledAtMs = nowMs + delayMs\n\n  if (!Number.isSafeInteger(scheduledAtMs)) {\n    throw VelociousError.safe(\"background job reschedule scheduledAtMs must be a safe integer\")\n  }\n\n  return scheduledAtMs\n}\n\n/**\n * Returns the shared failure backoff.\n * @param {number} retryCount - One-based failed attempt count.\n * @returns {number} - Backoff in milliseconds.\n */\nexport function retryDelayMs(retryCount) {\n  const scheduleSeconds = [10, 60, 600, 3600]\n\n  if (retryCount <= scheduleSeconds.length) return scheduleSeconds[retryCount - 1] * 1000\n\n  return (retryCount - 3) * 60 * 60 * 1000\n}\n\n/**\n * Resolves explicit or queue-derived concurrency.\n * @param {object} args - Resolution arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n * @param {string} args.queue - Normalized queue.\n * @param {Record<string, {maxConcurrent?: number, priority?: number}>} args.queues - Queue configuration.\n * @returns {import(\"./types.js\").ResolvedBackgroundJobConcurrency | null} - Concurrency contract.\n */\nexport function normalizeBackgroundJobConcurrency({options = {}, queue, queues}) {\n  const key = options.concurrencyKey\n  const cap = options.maxConcurrency\n\n  if (key !== undefined || cap !== undefined) {\n    if (typeof key !== \"string\" || key.length === 0 || !Number.isInteger(cap) || Number(cap) <= 0) {\n      throw new Error(\"background job concurrencyKey and maxConcurrency must be paired; concurrencyKey must be non-empty and maxConcurrency must be a positive integer\")\n    }\n    if (key.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) {\n      throw new Error(`background job concurrencyKey must not start with the reserved \"${QUEUE_CONCURRENCY_KEY_PREFIX}\" prefix, which is reserved for queue-derived concurrency caps`)\n    }\n\n    return {concurrencyKey: key, maxConcurrency: Number(cap), queueDerived: false}\n  }\n\n  const queueCap = queues[queue]?.maxConcurrent\n\n  if (!Number.isInteger(queueCap) || Number(queueCap) <= 0) return null\n\n  return {\n    concurrencyKey: `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`,\n    maxConcurrency: Number(queueCap),\n    queueDerived: true\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-semantics.js","sourceRoot":"","sources":["../../../src/background-jobs/job-semantics.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nexport const DEFAULT_BACKGROUND_JOB_EXECUTION_MODE = \"pooled\"\nexport const DEFAULT_BACKGROUND_JOB_MAX_RETRIES = 10\nexport const DEFAULT_BACKGROUND_JOB_QUEUE = \"default\"\nexport const QUEUE_CONCURRENCY_KEY_PREFIX = \"queue:\"\n/** @type {import(\"./types.js\").BackgroundJobExecutionMode[]} */\nexport const BACKGROUND_JOB_EXECUTION_MODES = [\"inline\", \"forked\", \"pooled\", \"spawned\"]\n/** @type {import(\"./types.js\").BackgroundJobActiveStatus[]} */\nexport const BACKGROUND_JOB_ACTIVE_STATUSES = [\"queued\", \"handed_off\"]\n/** @type {import(\"./types.js\").BackgroundJobTerminalStatus[]} */\nexport const BACKGROUND_JOB_TERMINAL_STATUSES = [\"cancelled\", \"completed\", \"failed\", \"orphaned\"]\n/** @type {import(\"./types.js\").BackgroundJobStatus[]} */\nexport const BACKGROUND_JOB_STATUSES = [...BACKGROUND_JOB_ACTIVE_STATUSES, ...BACKGROUND_JOB_TERMINAL_STATUSES]\n\n/**\n * Normalizes persisted or transported job status vocabulary.\n * @param {string} value - Candidate status.\n * @returns {import(\"./types.js\").BackgroundJobStatus} - Known status.\n */\nexport function normalizeBackgroundJobStatus(value) {\n  const status = BACKGROUND_JOB_STATUSES.find((candidate) => candidate === value)\n\n  if (status) return status\n\n  throw new Error(`Unknown background job status: ${value}`)\n}\n\n/**\n * Validates a stable logical schedule key at every persistence boundary.\n * @param {string} scheduleKey - Stable schedule key.\n * @returns {string} - Validated key.\n */\nexport function normalizeBackgroundJobScheduleKey(scheduleKey) {\n  if (typeof scheduleKey === \"string\" && scheduleKey.length > 0 && scheduleKey.length <= 255) return scheduleKey\n\n  throw VelociousError.safe(\"background job scheduleKey must be a non-empty string of at most 255 characters\")\n}\n\n/**\n * Normalizes a job queue.\n * @param {import(\"./types.js\").BackgroundJobOptions} [options] - Job options.\n * @returns {string} - Queue name.\n */\nexport function normalizeBackgroundJobQueue(options) {\n  const queue = options?.queue\n\n  if (typeof queue === \"string\" && queue.trim().length > 0) return queue.trim()\n\n  return DEFAULT_BACKGROUND_JOB_QUEUE\n}\n\n/**\n * Normalizes an explicit execution mode while retaining the Node default.\n * @param {Omit<import(\"./types.js\").BackgroundJobOptions, \"executionMode\"> & {executionMode?: string}} options - Job options.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode} [defaultExecutionMode] - Default mode.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode[]} [supportedExecutionModes] - Modes accepted by the caller.\n * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Execution mode.\n */\nexport function normalizeBackgroundJobExecutionMode(options = {}, defaultExecutionMode = DEFAULT_BACKGROUND_JOB_EXECUTION_MODE, supportedExecutionModes = BACKGROUND_JOB_EXECUTION_MODES) {\n  if (\"forked\" in options) {\n    throw new Error(\"The background job `forked` option was removed; pass `executionMode` (\\\"inline\\\", \\\"forked\\\", \\\"pooled\\\", or \\\"spawned\\\") instead\")\n  }\n\n  const requestedExecutionMode = options.executionMode || defaultExecutionMode\n  /** @type {import(\"./types.js\").BackgroundJobExecutionMode | undefined} */\n  let executionMode\n\n  for (const candidate of BACKGROUND_JOB_EXECUTION_MODES) {\n    if (candidate === requestedExecutionMode) executionMode = candidate\n  }\n\n  if (!executionMode) throw new Error(`Invalid background job executionMode: ${requestedExecutionMode}`)\n\n  if (!supportedExecutionModes.includes(executionMode)) {\n    throw new Error(`Background job executionMode \"${executionMode}\" is not supported by the local background-jobs adapter`)\n  }\n\n  return executionMode\n}\n\n/**\n * Validates and normalizes a retry cap.\n * @param {number | null | undefined} maxRetries - Requested retry cap.\n * @returns {number} - Retry cap.\n */\nexport function normalizeBackgroundJobMaxRetries(maxRetries) {\n  if (typeof maxRetries === \"number\" && Number.isFinite(maxRetries) && maxRetries >= 0) {\n    return Math.floor(maxRetries)\n  }\n\n  return DEFAULT_BACKGROUND_JOB_MAX_RETRIES\n}\n\n/**\n * Validates an enqueue eligibility timestamp.\n * @param {number | undefined} scheduledAtMs - Requested timestamp.\n * @param {number} defaultScheduledAtMs - Default timestamp.\n * @returns {number} - Eligibility timestamp.\n */\nexport function normalizeBackgroundJobScheduledAtMs(scheduledAtMs, defaultScheduledAtMs) {\n  if (scheduledAtMs === undefined) return defaultScheduledAtMs\n  if (Number.isSafeInteger(scheduledAtMs) && scheduledAtMs >= 0) return scheduledAtMs\n\n  throw VelociousError.safe(\"background job scheduledAtMs must be a non-negative safe integer\")\n}\n\n/**\n * Validates a reschedule delay and resolves it at persistence time.\n * @param {number} delayMs - Requested delay.\n * @param {number} nowMs - Persistence timestamp.\n * @returns {number} - New eligibility timestamp.\n */\nexport function rescheduledBackgroundJobAtMs(delayMs, nowMs) {\n  if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n    throw VelociousError.safe(\"background job reschedule delayMs must be a non-negative safe integer\")\n  }\n\n  const scheduledAtMs = nowMs + delayMs\n\n  if (!Number.isSafeInteger(scheduledAtMs)) {\n    throw VelociousError.safe(\"background job reschedule scheduledAtMs must be a safe integer\")\n  }\n\n  return scheduledAtMs\n}\n\n/**\n * Returns the shared failure backoff.\n * @param {number} retryCount - One-based failed attempt count.\n * @returns {number} - Backoff in milliseconds.\n */\nexport function retryDelayMs(retryCount) {\n  const scheduleSeconds = [10, 60, 600, 3600]\n\n  if (retryCount <= scheduleSeconds.length) return scheduleSeconds[retryCount - 1] * 1000\n\n  return (retryCount - 3) * 60 * 60 * 1000\n}\n\n/**\n * Resolves explicit or queue-derived concurrency.\n * @param {object} args - Resolution arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n * @param {string} args.queue - Normalized queue.\n * @param {Record<string, {maxConcurrent?: number, priority?: number}>} args.queues - Queue configuration.\n * @returns {import(\"./types.js\").ResolvedBackgroundJobConcurrency | null} - Concurrency contract.\n */\nexport function normalizeBackgroundJobConcurrency({options = {}, queue, queues}) {\n  const key = options.concurrencyKey\n  const cap = options.maxConcurrency\n\n  if (key !== undefined || cap !== undefined) {\n    if (typeof key !== \"string\" || key.length === 0 || !Number.isInteger(cap) || Number(cap) <= 0) {\n      throw new Error(\"background job concurrencyKey and maxConcurrency must be paired; concurrencyKey must be non-empty and maxConcurrency must be a positive integer\")\n    }\n    if (key.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) {\n      throw new Error(`background job concurrencyKey must not start with the reserved \"${QUEUE_CONCURRENCY_KEY_PREFIX}\" prefix, which is reserved for queue-derived concurrency caps`)\n    }\n\n    return {concurrencyKey: key, maxConcurrency: Number(cap), queueDerived: false}\n  }\n\n  const queueCap = queues[queue]?.maxConcurrent\n\n  if (!Number.isInteger(queueCap) || Number(queueCap) <= 0) return null\n\n  return {\n    concurrencyKey: `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`,\n    maxConcurrency: Number(queueCap),\n    queueDerived: true\n  }\n}\n"]}

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

@@ -43,5 +43,20 @@ export default class VelociousJob<TArgs extends Array<ReturnType<typeof JSON.par
      * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
      */
     static cancelScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
+    /**
+     * Reads current ownership and optional terminal history for a stable key.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.
+     */
+    static getScheduledJob(scheduleKey: string, options?: {
+        includeLatestTerminal?: boolean;
+    }): Promise<import("./types.js").BackgroundJobScheduledLookupResult>;
+    /**
+     * Expedites a future queued owner without creating another job.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Wake result.
+     */
+    static wakeScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobWakeResult>;
 }
 //# sourceMappingURL=job.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAMA,OAAO,oBAAoB,MAAM,mBAAmB,CAAA;AAOpD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY,CAHoB,KAAK,SAA5C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAS,EAAG,CAG5B,SAAQ,oBAAoB,CAF3B,KAAK,CAEsB;IAC5D;;;;OAIG;IACH,OAAa,YAAY,CAAC,GAAG,IAAI,EAHnB,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAGV,GAFpB,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;OAMG;IACH,OAAa,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,EAJjD;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEiD,GAFvC,OAAO,CAAC,MAAM,CAAC,CAc3B;IAED;;;;;;;OAOG;IACH,OAAa,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC,EALvD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEuD,GAF7C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAMxE;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,WAAW,EAH7B,MAG6B,GAF3B,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAMzE;CACF"}
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAMA,OAAO,oBAAoB,MAAM,mBAAmB,CAAA;AASpD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY,CAHoB,KAAK,SAA5C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAS,EAAG,CAG5B,SAAQ,oBAAoB,CAF3B,KAAK,CAEsB;IAC5D;;;;OAIG;IACH,OAAa,YAAY,CAAC,GAAG,IAAI,EAHnB,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAGV,GAFpB,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;OAMG;IACH,OAAa,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,EAJjD;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEiD,GAFvC,OAAO,CAAC,MAAM,CAAC,CAc3B;IAED;;;;;;;OAOG;IACH,OAAa,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC,EALvD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEuD,GAF7C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAMxE;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,WAAW,EAH7B,MAG6B,GAF3B,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAMzE;IAED;;;;;OAKG;IACH,OAAa,eAAe,CAAC,WAAW,EAJ7B,MAI6B,EAAE,OAAO,AAH9C,CACA,EADQ;QAAC,qBAAqB,CAAC,EAAE,OAAO,CAAA;KAGW,GAFzC,OAAO,CAAC,OAAO,YAAY,EAAE,kCAAkC,CAAC,CAM5E;IAED;;;;OAIG;IACH,OAAa,aAAa,CAAC,WAAW,EAH3B,MAG2B,GAFzB,OAAO,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAMjE;CACF"}

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

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import configurationResolver from "../configuration-resolver.js";
 import { currentBackgroundJobProducerProof } from "./execution-context.js";
 import PlatformVelociousJob from "./platform-job.js";
-import { cancelScheduledBackgroundJobForConfiguration, enqueueBackgroundJobForConfiguration, replaceScheduledBackgroundJobForConfiguration } from "./runtime.js";
+import { cancelScheduledBackgroundJobForConfiguration, enqueueBackgroundJobForConfiguration, getScheduledBackgroundJobForConfiguration, replaceScheduledBackgroundJobForConfiguration, wakeScheduledBackgroundJobForConfiguration } from "./runtime.js";
 /**
  * Node background-job entry. It preserves lazy configuration discovery for
  * fresh producer processes while the explicit platform entry stays free of
@@ -70,5 +70,24 @@ export default class VelociousJob extends PlatformVelociousJob {
         const configuration = await configurationResolver();
         return await cancelScheduledBackgroundJobForConfiguration({ configuration, scheduleKey });
     }
+    /**
+     * Reads current ownership and optional terminal history for a stable key.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.
+     */
+    static async getScheduledJob(scheduleKey, options = {}) {
+        const configuration = await configurationResolver();
+        return await getScheduledBackgroundJobForConfiguration({ configuration, scheduleKey, ...options });
+    }
+    /**
+     * Expedites a future queued owner without creating another job.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Wake result.
+     */
+    static async wakeScheduled(scheduleKey) {
+        const configuration = await configurationResolver();
+        return await wakeScheduledBackgroundJobForConfiguration({ configuration, scheduleKey });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.js","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC,OAAO,qBAAqB,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAA;AAC1E,OAAO,oBAAoB,MAAM,mBAAmB,CAAA;AACpD,OAAO,EACL,4CAA4C,EAC5C,oCAAoC,EACpC,yCAAyC,EACzC,6CAA6C,EAC7C,0CAA0C,EAC3C,MAAM,cAAc,CAAA;AAErB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,oBAAoB;IAC5D;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI;QAC/B,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QACnD,MAAM,EAAC,OAAO,EAAE,UAAU,EAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAA;QAC7D,MAAM,aAAa,GAAG,iCAAiC,EAAE,CAAA;QAEzD,OAAO,MAAM,oCAAoC,CAAC;YAChD,aAAa;YACb,QAAQ,EAAE,IAAI;YACd,OAAO;YACP,UAAU;YACV,aAAa;YACb,oBAAoB,EAAE,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,SAAS;SAC/D,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC;QAClD,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QACnD,MAAM,aAAa,GAAG,iCAAiC,EAAE,CAAA;QAEzD,OAAO,MAAM,oCAAoC,CAAC;YAChD,aAAa;YACb,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,IAAI;YACb,UAAU,EAAE,OAAO;YACnB,aAAa;YACb,oBAAoB,EAAE,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,SAAS;SAC/D,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC;QACxD,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,6CAA6C,CAAC,EAAC,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;IAC9I,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW;QACtC,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,4CAA4C,CAAC,EAAC,aAAa,EAAE,WAAW,EAAC,CAAC,CAAA;IACzF,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW,EAAE,OAAO,GAAG,EAAE;QACpD,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,yCAAyC,CAAC,EAAC,aAAa,EAAE,WAAW,EAAE,GAAG,OAAO,EAAC,CAAC,CAAA;IAClG,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,WAAW;QACpC,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,0CAA0C,CAAC,EAAC,aAAa,EAAE,WAAW,EAAC,CAAC,CAAA;IACvF,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport { randomUUID } from \"node:crypto\"\n\nimport configurationResolver from \"../configuration-resolver.js\"\nimport { currentBackgroundJobProducerProof } from \"./execution-context.js\"\nimport PlatformVelociousJob from \"./platform-job.js\"\nimport {\n  cancelScheduledBackgroundJobForConfiguration,\n  enqueueBackgroundJobForConfiguration,\n  getScheduledBackgroundJobForConfiguration,\n  replaceScheduledBackgroundJobForConfiguration,\n  wakeScheduledBackgroundJobForConfiguration\n} from \"./runtime.js\"\n\n/**\n * Node background-job entry. It preserves lazy configuration discovery for\n * fresh producer processes while the explicit platform entry stays free of\n * Node-only configuration resolution.\n * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]\n * @augments {PlatformVelociousJob<TArgs>}\n */\nexport default class VelociousJob extends PlatformVelociousJob {\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 configuration = await configurationResolver()\n    const {jobArgs, jobOptions} = this._splitArgsAndOptions(args)\n    const producerProof = currentBackgroundJobProducerProof()\n\n    return await enqueueBackgroundJobForConfiguration({\n      configuration,\n      JobClass: this,\n      jobArgs,\n      jobOptions,\n      producerProof,\n      producerInvocationId: producerProof ? randomUUID() : undefined\n    })\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    const configuration = await configurationResolver()\n    const producerProof = currentBackgroundJobProducerProof()\n\n    return await enqueueBackgroundJobForConfiguration({\n      configuration,\n      JobClass: this,\n      jobArgs: args,\n      jobOptions: options,\n      producerProof,\n      producerInvocationId: producerProof ? randomUUID() : undefined\n    })\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    const configuration = await configurationResolver()\n\n    return await replaceScheduledBackgroundJobForConfiguration({configuration, 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    const configuration = await configurationResolver()\n\n    return await cancelScheduledBackgroundJobForConfiguration({configuration, 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    const configuration = await configurationResolver()\n\n    return await getScheduledBackgroundJobForConfiguration({configuration, 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    const configuration = await configurationResolver()\n\n    return await wakeScheduledBackgroundJobForConfiguration({configuration, scheduleKey})\n  }\n}\n"]}

package/build/src/background-jobs/local-adapter.d.ts

@@ -52,22 +52,37 @@ export default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {
         options?: import("./types.js").BackgroundJobOptions;
     }): Promise<string>;
     /**
-     * Rejects stable-key cancellation, which is outside the local adapter contract.
-     * @param {string} _scheduleKey - Unsupported stable key.
-     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Never resolves.
+     * Cancels or detaches the current owner of a stable schedule key.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
      */
-    cancelScheduled(_scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
+    cancelScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
     /**
-     * Rejects stable-key replacement, which is outside the local adapter contract.
-     * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import("./types.js").BackgroundJobOptions}} _args - Unsupported request.
-     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Never resolves.
+     * Replaces the current owner of a stable schedule key.
+     * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import("./types.js").BackgroundJobOptions}} args - Replacement request.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
      */
-    replaceScheduled(_args: {
+    replaceScheduled(args: {
         scheduleKey: string;
         jobName: string;
         args: Array<ReturnType<typeof JSON.parse>>;
         options?: import("./types.js").BackgroundJobOptions;
     }): Promise<import("./types.js").BackgroundJobReplacementResult>;
+    /**
+     * Reads stable ownership and optional terminal history.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized local jobs.
+     */
+    getScheduledJob(scheduleKey: string, options?: {
+        includeLatestTerminal?: boolean;
+    }): Promise<import("./types.js").BackgroundJobScheduledLookupResult>;
+    /**
+     * Makes a future queued stable owner due without replacing it.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Exact wake result.
+     */
+    wakeScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobWakeResult>;
     /**
      * Finds the next eligible local job.
      * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Next eligible job.

package/build/src/background-jobs/local-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-adapter.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/local-adapter.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"local-adapter.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/local-adapter.js"],"names":[],"mappings":"AAEA,OAAO,qBAAqB,MAAM,cAAc,CAAA;AAChD,OAAO,6BAA6B,MAAM,uBAAuB,CAAA;AACjE,OAAO,0BAA0B,MAAM,yBAAyB,CAAA;AAChE,OAAO,wBAAoD,MAAM,kBAAkB,CAAA;AAEnF,wEAAwE;AACxE,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,qBAAqB;IAUpE,KAAK;IACL,aAAa;IACb,QAAQ;IACR,KAAK;IAML,UAAU;IAlBjB;;;;;;OAMG;IACH,YAAY,EAAC,aAAa,EAAE,KAAkC,EAAE,kBAAkB,EAAC,EAJhF;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAA6D,KAAK,AAAlE,CACA,EADQ,OAAO,YAAY,EAAE,wBAAwB,CACrD;QAAsB,kBAAkB,AAAxC,CACF,EADU,MAAM,CAChB;KACkF,EAYlF;IAED;;;OAGG;IACG,WAAW,IAFJ,OAAO,CAAC,IAAI,CAAC,CAE2B;IAErD;;;OAGG;IACG,KAAK,IAFE,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;OAGG;IACG,MAAM,IAFC,OAAO,CAAC,OAAO,YAAY,EAAE,oBAAoB,CAAC,CAEH;IAE5D;;;OAGG;IACG,yBAAyB,IAFlB,OAAO,CAAC,IAAI,CAAC,CAEwD;IAElF;;;;OAIG;IACG,OAAO,CAAC,IAAI,EAHP;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAG1G,GAFL,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;OAIG;IACG,eAAe,CAAC,WAAW,EAHtB,MAGsB,GAFpB,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAKzE;IAED;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAHhB;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAGtH,GAFd,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAMxE;IAED;;;;;OAKG;IACG,eAAe,CAAC,WAAW,EAJtB,MAIsB,EAAE,OAAO,AAHvC,CACA,EADQ;QAAC,qBAAqB,CAAC,EAAE,OAAO,CAAA;KAGD,GAF7B,OAAO,CAAC,OAAO,YAAY,EAAE,kCAAkC,CAAC,CAK5E;IAED;;;;OAIG;IACG,aAAa,CAAC,WAAW,EAHpB,MAGoB,GAFlB,OAAO,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAKjE;IAED;;;OAGG;IACG,gBAAgB,IAFT,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC,CAEK;IAEvE;;;OAGG;IACG,gBAAgB,IAFT,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC,CAEK;IAEvE;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAHP,MAGO,GAFL,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC,CAEL;IAE7D;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,EAAE,CAAC,CAEN;IAEvD;;;;OAIG;IACG,aAAa,CAAC,IAAI,EAHb,OAAO,YAAY,EAAE,2BAGR,GAFX,OAAO,CAAC,OAAO,YAAY,EAAE,oBAAoB,GAAG,IAAI,CAAC,CAEG;IAEzE;;;;OAIG;IACG,sBAAsB,CAAC,IAAI,EAHtB;QAAC,QAAQ,EAAE,MAAM,CAAA;KAGK,GAFpB,OAAO,CAAC,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAE4B;IAE3F;;;;OAIG;IACG,mBAAmB,CAAC,IAAI,EAHnB;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAGd,GAFjB,OAAO,CAAC,IAAI,CAAC,CAEoD;IAE9E;;;;OAIG;IACG,aAAa,CAAC,IAAI,EAHb;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAGrB,GAFX,OAAO,CAAC,OAAO,CAAC,CAE4C;IAEzE;;;;OAIG;IACG,iBAAiB,CAAC,IAAI,EAHjB;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAG3G,GAFf,OAAO,CAAC,OAAO,CAAC,CAEoD;IAEjF;;;;OAIG;IACG,eAAe,CAAC,IAAI,EAHf;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAGpC,GAFb,OAAO,CAAC,OAAO,CAAC,CAEgD;IAE7E;;;;OAIG;IACG,UAAU,CAAC,IAAI,EAHV;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAG9D,GAFR,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC,CAEC;IAEnE;;;OAGG;IACH,IAAI,IAFS,IAAI,CAEgB;IAEjC;;;OAGG;IACG,WAAW,IAFJ,OAAO,CAAC,IAAI,CAAC,CAEiC;CAC5D"}