velocious 1.0.665 → 1.0.667

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

@@ -1,9 +1,74 @@
 // @ts-check
-import timeout from "awaitery/build/timeout.js";
+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.
@@ -51,17 +116,36 @@ export default class BackgroundJobsClient {
             ...(producerInvocationId ? { producerInvocationId } : {}),
             ...(producerProof ? { producerProof } : {})
         };
-        const acknowledgement = { explicitlyRejected: false, generationFenced: false, requestSent: false };
+        /**
+         * Creates safe observations for one attempt without retaining request data.
+         * @param {object} args - Attempt identity.
+         * @param {"initial" | "owned_replay"} args.attemptKind - Initial attempt or owned replay.
+         * @param {number} args.attemptNumber - One-based attempt number.
+         * @returns {import("./enqueue-acknowledgement-timeout-error.js").BackgroundJobEnqueueAttempt} - Mutable attempt observations.
+         */
+        const newAttemptObservation = ({ attemptKind, attemptNumber }) => ({
+            acknowledgementWaitElapsedMs: 0,
+            attemptElapsedMs: 0,
+            attemptKind,
+            attemptNumber,
+            explicitlyRejected: false,
+            generationFenced: false,
+            requestSent: false
+        });
         /**
          * Sends one enqueue attempt. An owned caller may replay this exact message
          * once when transport acknowledgement remains ambiguous after send.
-         * @param {{explicitlyRejected: boolean, generationFenced: boolean, requestSent: boolean} | undefined} attemptAcknowledgement - First-attempt observations.
+         * @param {import("./enqueue-acknowledgement-timeout-error.js").BackgroundJobEnqueueAttempt} attemptObservation - Mutable attempt observations.
+         * @param {Readonly<Array<import("./enqueue-acknowledgement-timeout-error.js").BackgroundJobEnqueueAttempt>>} previousAttempts - Earlier timed-out attempts.
          * @returns {Promise<string>} - Job id.
          */
-        const enqueueAttempt = async (attemptAcknowledgement) => {
+        const enqueueAttempt = async (attemptObservation, previousAttempts) => {
+            const attemptStartedAtMs = Date.now();
             const request = await this._request();
             const requestAbortController = new AbortController();
             const timeoutErrorMessage = `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`;
+            /** @type {number | undefined} */
+            let requestSentAtMs;
             /**
              * Resolves the pre-send phase when the mutation has entered the socket.
              * @type {() => void}
@@ -93,10 +177,9 @@ export default class BackgroundJobsClient {
                 signal: requestAbortController.signal,
                 onConnect: (jsonSocket) => {
                     jsonSocket.send(message);
-                    if (attemptAcknowledgement) {
-                        attemptAcknowledgement.generationFenced = Boolean(request.generationId);
-                        attemptAcknowledgement.requestSent = true;
-                    }
+                    attemptObservation.generationFenced = Boolean(request.generationId);
+                    attemptObservation.requestSent = true;
+                    requestSentAtMs = Date.now();
                     markRequestSent();
                 },
                 onMessage: ({ message, resolve, reject }) => {
@@ -105,23 +188,47 @@ export default class BackgroundJobsClient {
                         return;
                     }
                     if (message?.type === "enqueue-error") {
-                        if (attemptAcknowledgement)
-                            attemptAcknowledgement.explicitlyRejected = true;
+                        attemptObservation.explicitlyRejected = true;
                         reject(new Error(message.error || "Failed to enqueue job"));
                     }
                 }
             });
             await withEnqueueTimeout(async () => await Promise.race([requestSent, requestPromise]));
-            return await withEnqueueTimeout(async () => await requestPromise);
+            try {
+                return await withEnqueueTimeout(async () => await requestPromise);
+            }
+            catch (error) {
+                if (!(error instanceof TimeoutError))
+                    throw error;
+                if (requestSentAtMs === undefined)
+                    throw new Error("Background job enqueue acknowledgement wait started before the request was sent", { cause: error });
+                const timedOutAtMs = Date.now();
+                // The fired timer proves its logical deadline even when the adjustable wall clock reports a shorter interval.
+                const acknowledgementWaitElapsedMs = Math.max(this.enqueueTimeoutMs, timedOutAtMs - requestSentAtMs);
+                attemptObservation.acknowledgementWaitElapsedMs = acknowledgementWaitElapsedMs;
+                attemptObservation.attemptElapsedMs = Math.max(acknowledgementWaitElapsedMs, timedOutAtMs - attemptStartedAtMs);
+                throw new BackgroundJobEnqueueAcknowledgementTimeoutError({
+                    acknowledgementTimeoutMs: this.enqueueTimeoutMs,
+                    attemptHistory: [...previousAttempts, attemptObservation],
+                    cause: error,
+                    generationId: request.generationId,
+                    jobName,
+                    producerInvocationId,
+                    producerProofPresent: Boolean(producerProof)
+                });
+            }
         };
+        const initialAttempt = newAttemptObservation({ attemptKind: "initial", attemptNumber: 1 });
         try {
-            return await enqueueAttempt(acknowledgement);
+            return await enqueueAttempt(initialAttempt, []);
         }
         catch (error) {
-            if (!producerInvocationId || !producerProof || !acknowledgement.generationFenced || !acknowledgement.requestSent || acknowledgement.explicitlyRejected)
+            if (!producerInvocationId || !producerProof || !initialAttempt.generationFenced || !initialAttempt.requestSent || initialAttempt.explicitlyRejected)
                 throw error;
+            const previousAttempts = error instanceof BackgroundJobEnqueueAcknowledgementTimeoutError ? error.attemptHistory : [];
+            const replayAttempt = newAttemptObservation({ attemptKind: "owned_replay", attemptNumber: 2 });
+            return await enqueueAttempt(replayAttempt, previousAttempts);
         }
-        return await enqueueAttempt(undefined);
     }
     /**
      * Atomically replaces the queued owner of a stable schedule key.
@@ -176,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 from \"awaitery/build/timeout.js\"\nimport configurationResolver from \"../configuration-resolver.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    const acknowledgement = {explicitlyRejected: false, generationFenced: false, requestSent: false}\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 {{explicitlyRejected: boolean, generationFenced: boolean, requestSent: boolean} | undefined} attemptAcknowledgement - First-attempt observations.\n     * @returns {Promise<string>} - Job id.\n     */\n    const enqueueAttempt = async (attemptAcknowledgement) => {\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      /**\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          if (attemptAcknowledgement) {\n            attemptAcknowledgement.generationFenced = Boolean(request.generationId)\n            attemptAcknowledgement.requestSent = true\n          }\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            if (attemptAcknowledgement) attemptAcknowledgement.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      return await withEnqueueTimeout(async () => await requestPromise)\n    }\n\n    try {\n      return await enqueueAttempt(acknowledgement)\n    } catch (error) {\n      if (!producerInvocationId || !producerProof || !acknowledgement.generationFenced || !acknowledgement.requestSent || acknowledgement.explicitlyRejected) throw error\n    }\n\n    return await enqueueAttempt(undefined)\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/enqueue-acknowledgement-timeout-error.d.ts

@@ -0,0 +1,81 @@
+import { TimeoutError } from "awaitery/build/timeout.js";
+export type BackgroundJobEnqueueAttempt = {
+    /**
+     * - Time spent waiting for the acknowledgement after send.
+     */
+    acknowledgementWaitElapsedMs: number;
+    /**
+     * - Total attempt time including connection and generation fencing.
+     */
+    attemptElapsedMs: number;
+    /**
+     * - Initial attempt or the one eligible owned replay.
+     */
+    attemptKind: "initial" | "owned_replay";
+    /**
+     * - One-based attempt number.
+     */
+    attemptNumber: number;
+    /**
+     * - Whether the main explicitly rejected the enqueue.
+     */
+    explicitlyRejected: boolean;
+    /**
+     * - Whether the configured generation accepted the connection before send.
+     */
+    generationFenced: boolean;
+    /**
+     * - Whether the enqueue request entered the socket.
+     */
+    requestSent: boolean;
+};
+/**
+ * @typedef {object} BackgroundJobEnqueueAttempt
+ * @property {number} acknowledgementWaitElapsedMs - Time spent waiting for the acknowledgement after send.
+ * @property {number} attemptElapsedMs - Total attempt time including connection and generation fencing.
+ * @property {"initial" | "owned_replay"} attemptKind - Initial attempt or the one eligible owned replay.
+ * @property {number} attemptNumber - One-based attempt number.
+ * @property {boolean} explicitlyRejected - Whether the main explicitly rejected the enqueue.
+ * @property {boolean} generationFenced - Whether the configured generation accepted the connection before send.
+ * @property {boolean} requestSent - Whether the enqueue request entered the socket.
+ */
+/** Safe typed failure for an ambiguous post-send enqueue acknowledgement timeout. */
+export default class BackgroundJobEnqueueAcknowledgementTimeoutError extends TimeoutError {
+    /** @type {"BACKGROUND_JOB_ENQUEUE_ACKNOWLEDGEMENT_TIMEOUT"} */
+    code: "BACKGROUND_JOB_ENQUEUE_ACKNOWLEDGEMENT_TIMEOUT";
+    acknowledgementTimeoutMs: number;
+    attemptHistory: readonly Readonly<{
+        acknowledgementWaitElapsedMs: number;
+        attemptElapsedMs: number;
+        attemptKind: "initial" | "owned_replay";
+        attemptNumber: number;
+        explicitlyRejected: boolean;
+        generationFenced: boolean;
+        requestSent: boolean;
+    }>[];
+    generationId: string | undefined;
+    jobName: string;
+    producerInvocationId: string | undefined;
+    producerProofPresent: boolean;
+    /**
+     * Builds an enqueue acknowledgement timeout error without request payload or connection details.
+     * @param {object} args - Safe timeout context.
+     * @param {number} args.acknowledgementTimeoutMs - Configured post-send acknowledgement deadline.
+     * @param {Array<BackgroundJobEnqueueAttempt>} args.attemptHistory - Safe observations for timed-out attempts.
+     * @param {TimeoutError} [args.cause] - Original Awaitery timeout.
+     * @param {string} [args.generationId] - Accepted release generation identity.
+     * @param {string} args.jobName - Resolved job class name.
+     * @param {string} [args.producerInvocationId] - Owned enqueue invocation identity.
+     * @param {boolean} args.producerProofPresent - Whether the request carried an internal producer proof.
+     */
+    constructor({ acknowledgementTimeoutMs, attemptHistory, cause, generationId, jobName, producerInvocationId, producerProofPresent }: {
+        acknowledgementTimeoutMs: number;
+        attemptHistory: Array<BackgroundJobEnqueueAttempt>;
+        cause?: TimeoutError;
+        generationId?: string;
+        jobName: string;
+        producerInvocationId?: string;
+        producerProofPresent: boolean;
+    });
+}
+//# sourceMappingURL=enqueue-acknowledgement-timeout-error.d.ts.map

package/build/src/background-jobs/enqueue-acknowledgement-timeout-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enqueue-acknowledgement-timeout-error.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/enqueue-acknowledgement-timeout-error.js"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAA;AAGnD,YAAkB,2BAA2B,GAC7C;;;;IAAmB,4BAA4B,EAApC,MAAM,CACjB;;;;IAAmB,gBAAgB,EAAxB,MAAM,CACjB;;;;IAAuC,WAAW,EAAvC,SAAS,GAAG,cAAc,CACrC;;;;IAAmB,aAAa,EAArB,MAAM,CACjB;;;;IAAoB,kBAAkB,EAA3B,OAAO,CAClB;;;;IAAoB,gBAAgB,EAAzB,OAAO,CAClB;;;;IAAoB,WAAW,EAApB,OAAO,CACpB;CAAA,CAAA;AATD;;;;;;;;;GASG;AAEH,qFAAqF;AACrF,MAAM,CAAC,OAAO,OAAO,+CAAgD,SAAQ,YAAY;IAgBrF,+DAA+D;IAC1D,IAAI,EADE,gDAAgD;IAEtD,wBAAwB;IACxB,cAAc;;;;;;;;;IASd,YAAY;IACZ,OAAO;IACP,oBAAoB;IACpB,oBAAoB;IA9B3B;;;;;;;;;;OAUG;IACH,YAAY,EAAC,wBAAwB,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAC,EAR7H;QAAqB,wBAAwB,EAArC,MAAM,CACd;QAAiD,cAAc,EAAvD,KAAK,CAAC,2BAA2B,CAAC,CAC1C;QAA4B,KAAK,AAAjC,CACA,EADQ,YAAY,CACpB;QAAsB,YAAY,AAAlC,CACA,EADQ,MAAM,CACd;QAAqB,OAAO,EAApB,MAAM,CACd;QAAsB,oBAAoB,AAA1C,CACA,EADQ,MAAM,CACd;QAAsB,oBAAoB,EAAlC,OAAO,CACjB;KAC+H,EAoB/H;CACF"}

package/build/src/background-jobs/enqueue-acknowledgement-timeout-error.js

@@ -0,0 +1,47 @@
+// @ts-check
+import { TimeoutError } from "awaitery/build/timeout.js";
+/**
+ * @typedef {object} BackgroundJobEnqueueAttempt
+ * @property {number} acknowledgementWaitElapsedMs - Time spent waiting for the acknowledgement after send.
+ * @property {number} attemptElapsedMs - Total attempt time including connection and generation fencing.
+ * @property {"initial" | "owned_replay"} attemptKind - Initial attempt or the one eligible owned replay.
+ * @property {number} attemptNumber - One-based attempt number.
+ * @property {boolean} explicitlyRejected - Whether the main explicitly rejected the enqueue.
+ * @property {boolean} generationFenced - Whether the configured generation accepted the connection before send.
+ * @property {boolean} requestSent - Whether the enqueue request entered the socket.
+ */
+/** Safe typed failure for an ambiguous post-send enqueue acknowledgement timeout. */
+export default class BackgroundJobEnqueueAcknowledgementTimeoutError extends TimeoutError {
+    /**
+     * Builds an enqueue acknowledgement timeout error without request payload or connection details.
+     * @param {object} args - Safe timeout context.
+     * @param {number} args.acknowledgementTimeoutMs - Configured post-send acknowledgement deadline.
+     * @param {Array<BackgroundJobEnqueueAttempt>} args.attemptHistory - Safe observations for timed-out attempts.
+     * @param {TimeoutError} [args.cause] - Original Awaitery timeout.
+     * @param {string} [args.generationId] - Accepted release generation identity.
+     * @param {string} args.jobName - Resolved job class name.
+     * @param {string} [args.producerInvocationId] - Owned enqueue invocation identity.
+     * @param {boolean} args.producerProofPresent - Whether the request carried an internal producer proof.
+     */
+    constructor({ acknowledgementTimeoutMs, attemptHistory, cause, generationId, jobName, producerInvocationId, producerProofPresent }) {
+        super(`Background job enqueue acknowledgement timed out after ${acknowledgementTimeoutMs}ms`, cause ? { cause } : undefined);
+        this.name = "BackgroundJobEnqueueAcknowledgementTimeoutError";
+        /** @type {"BACKGROUND_JOB_ENQUEUE_ACKNOWLEDGEMENT_TIMEOUT"} */
+        this.code = "BACKGROUND_JOB_ENQUEUE_ACKNOWLEDGEMENT_TIMEOUT";
+        this.acknowledgementTimeoutMs = acknowledgementTimeoutMs;
+        this.attemptHistory = Object.freeze(attemptHistory.map((attempt) => Object.freeze({
+            acknowledgementWaitElapsedMs: attempt.acknowledgementWaitElapsedMs,
+            attemptElapsedMs: attempt.attemptElapsedMs,
+            attemptKind: attempt.attemptKind,
+            attemptNumber: attempt.attemptNumber,
+            explicitlyRejected: attempt.explicitlyRejected,
+            generationFenced: attempt.generationFenced,
+            requestSent: attempt.requestSent
+        })));
+        this.generationId = generationId;
+        this.jobName = jobName;
+        this.producerInvocationId = producerInvocationId;
+        this.producerProofPresent = producerProofPresent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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"}