velocious 1.0.660 → 1.0.661

package/README.md

@@ -2450,7 +2450,13 @@ deduplication. Each call has its own internal replay identity, so two identical
 calls create distinct jobs unless the caller explicitly requests queued
 deduplication or durable idempotency. The retired main commits and wakes the
 queue but never dispatches the follow-up; the active generation owns that work.
-Ordinary retired enqueue, replace, and cancel requests remain rejected.
+If the first sent request loses its acknowledgement after the main accepts the
+generation fence, whether through connection loss or deadline expiry, the Node
+client makes one recovery attempt with the exact same producer proof and
+invocation identity. Legacy/default connections never replay automatically, even
+if execution context supplied producer metadata. Pre-send generation failures
+and explicit enqueue rejections are not retried. Ordinary retired enqueue,
+replace, and cancel requests remain rejected.
 
 Velocious provides the opt-in generation protocol; production still requires a
 supervisor that preserves old generation units and release pins, and a deploy
@@ -2722,7 +2728,7 @@ Set `deduplicateWhileQueued: true` to coalesce an enqueue onto the earliest iden
 
 Use `options: {idempotencyKey}` when producer replay must converge on the original durable job across every state and even after terminal-job pruning. Ownership is scoped to the resolved job class name, resolved queue, and key; reusing that scope with changed canonical arguments or behavior-affecting options fails. This is distinct from queued-only deduplication, and ownership rows are intentionally retained until a future explicit reconciliation/deletion policy. See [durable idempotent enqueue](docs/background-jobs.md#durable-idempotent-enqueue).
 
-The Node producer rejects and destroys its one-shot socket when the main closes before acknowledging or when an enqueue acknowledgement stalls for 5 seconds. Because the main may already have committed the job, this is an ambiguous outcome: replay with the same durable `idempotencyKey` to recover the original job id without creating a duplicate. Direct `BackgroundJobsClient` users can set a different bounded `enqueueTimeoutMs` constructor option. See [durable idempotent enqueue](docs/background-jobs.md#durable-idempotent-enqueue).
+The Node producer rejects and destroys its one-shot socket when the main closes before acknowledging or when an enqueue acknowledgement stalls for 5 seconds. Because the main may already have committed the job, this is an ambiguous outcome. A call made by an executing generation-owned job automatically makes one recovery attempt with its exact internal producer proof and per-call invocation identity, but never after a pre-send generation failure or explicit enqueue rejection. Ordinary enqueues are not retried automatically: replay one with the same durable `idempotencyKey` to recover the original job id without creating a duplicate. Direct `BackgroundJobsClient` users can set a different bounded `enqueueTimeoutMs` constructor option. See [durable idempotent enqueue](docs/background-jobs.md#durable-idempotent-enqueue).
 
 Select a non-default runtime explicitly with `options: {executionMode: "inline" | "forked" | "spawned"}`.
 

package/build/background-jobs/client.js

@@ -49,34 +49,57 @@ export default class BackgroundJobsClient {
    * @returns {Promise<string>} - Job id.
    */
   async enqueue({jobName, args, options, producerInvocationId, producerProof}) {
-    const request = await this._request()
+    const message = {
+      type: /** @type {const} */ ("enqueue"),
+      jobName,
+      args,
+      options,
+      ...(producerInvocationId ? {producerInvocationId} : {}),
+      ...(producerProof ? {producerProof} : {})
+    }
+    const acknowledgement = {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.
+     * @returns {Promise<string>} - Job id.
+     */
+    const enqueueAttempt = async (attemptAcknowledgement) => {
+      const request = await this._request()
 
-    return await timeout({
-      errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
-      timeout: this.enqueueTimeoutMs
-    }, async ({control}) => await request.run({
-      signal: control.signal,
-      onConnect: (jsonSocket) => {
-        jsonSocket.send({
-          type: "enqueue",
-          jobName,
-          args,
-          options,
-          ...(producerInvocationId ? {producerInvocationId} : {}),
-          ...(producerProof ? {producerProof} : {})
-        })
-      },
-      onMessage: ({message, resolve, reject}) => {
-        if (message?.type === "enqueued") {
-          resolve(message.jobId)
-          return
-        }
+      return await timeout({
+        errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
+        timeout: this.enqueueTimeoutMs
+      }, async ({control}) => await request.run({
+        signal: control.signal,
+        onConnect: (jsonSocket) => {
+          jsonSocket.send(message)
+          if (attemptAcknowledgement) {
+            attemptAcknowledgement.generationFenced = Boolean(request.generationId)
+            attemptAcknowledgement.requestSent = true
+          }
+        },
+        onMessage: ({message, resolve, reject}) => {
+          if (message?.type === "enqueued") {
+            resolve(message.jobId)
+            return
+          }
 
-        if (message?.type === "enqueue-error") {
-          reject(new Error(message.error || "Failed to enqueue job"))
+          if (message?.type === "enqueue-error") {
+            if (attemptAcknowledgement) attemptAcknowledgement.explicitlyRejected = true
+            reject(new Error(message.error || "Failed to enqueue job"))
+          }
         }
-      }
-    }))
+      }))
+    }
+
+    try {
+      return await enqueueAttempt(acknowledgement)
+    } catch (error) {
+      if (!producerInvocationId || !producerProof || !acknowledgement.generationFenced || !acknowledgement.requestSent || acknowledgement.explicitlyRejected) throw error
+    }
+
+    return await enqueueAttempt(undefined)
   }
 
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"AAIA,OAAO,2BAA2B,MAAM,qBAAqB,CAAA;AAK7D,MAAM,CAAC,OAAO,OAAO,oBAAoB;IAUhC,oBAAoB;IACpB,gBAAgB;IAChB,4BAA4B;IAC5B,oBAAoB;IAZ3B;;;;;;;OAOG;IACH,YAAY,EAAC,aAAa,EAAE,gBAA6C,EAAE,4BAAsE,EAAE,YAAY,EAAC,AAN7J,CAKF,EAJE;QAAqD,aAAa,AAAlE,CACA,EADQ,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,gBAAgB,AAAtC,CACA,EADQ,MAAM,CACd;QAAsB,4BAA4B,AAAlD,CACA,EADQ,MAAM,CACd;QAAsB,YAAY,AAAlC,CACF,EADU,MAAM,CAChB;KACoK,EAKpK;IAED;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,2BAA2B,CAAC,CAWhD;IAED;;;;;;;;;OASG;IACG,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAC,EAPxE;QAAqB,OAAO,EAApB,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;QAAsB,oBAAoB,AAA1C,CACA,EADQ,MAAM,CACd;QAA+D,aAAa,AAA5E,CACA,EADQ,OAAO,YAAY,EAAE,0BAA0B,CACvD;KAEwE,GAF9D,OAAO,CAAC,MAAM,CAAC,CA+B3B;IAED;;;;;;;;OAQG;IACG,gBAAgB,CAAC,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,EANzD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAqB,OAAO,EAApB,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;KAEyD,GAF/C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAwBxE;IAED;;;;;OAKG;IACG,eAAe,CAAC,EAAC,WAAW,EAAC,EAHhC;QAAqB,WAAW,EAAxB,MAAM,CACd;KAEgC,GAFtB,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAoBzE;CACF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"AAIA,OAAO,2BAA2B,MAAM,qBAAqB,CAAA;AAK7D,MAAM,CAAC,OAAO,OAAO,oBAAoB;IAUhC,oBAAoB;IACpB,gBAAgB;IAChB,4BAA4B;IAC5B,oBAAoB;IAZ3B;;;;;;;OAOG;IACH,YAAY,EAAC,aAAa,EAAE,gBAA6C,EAAE,4BAAsE,EAAE,YAAY,EAAC,AAN7J,CAKF,EAJE;QAAqD,aAAa,AAAlE,CACA,EADQ,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,gBAAgB,AAAtC,CACA,EADQ,MAAM,CACd;QAAsB,4BAA4B,AAAlD,CACA,EADQ,MAAM,CACd;QAAsB,YAAY,AAAlC,CACF,EADU,MAAM,CAChB;KACoK,EAKpK;IAED;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,2BAA2B,CAAC,CAWhD;IAED;;;;;;;;;OASG;IACG,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAC,EAPxE;QAAqB,OAAO,EAApB,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;QAAsB,oBAAoB,AAA1C,CACA,EADQ,MAAM,CACd;QAA+D,aAAa,AAA5E,CACA,EADQ,OAAO,YAAY,EAAE,0BAA0B,CACvD;KAEwE,GAF9D,OAAO,CAAC,MAAM,CAAC,CAsD3B;IAED;;;;;;;;OAQG;IACG,gBAAgB,CAAC,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,EANzD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAqB,OAAO,EAApB,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;KAEyD,GAF/C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAwBxE;IAED;;;;;OAKG;IACG,eAAe,CAAC,EAAC,WAAW,EAAC,EAHhC;QAAqB,WAAW,EAAxB,MAAM,CACd;KAEgC,GAFtB,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAoBzE;CACF"}

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

@@ -43,32 +43,56 @@ export default class BackgroundJobsClient {
      * @returns {Promise<string>} - Job id.
      */
     async enqueue({ jobName, args, options, producerInvocationId, producerProof }) {
-        const request = await this._request();
-        return await timeout({
-            errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
-            timeout: this.enqueueTimeoutMs
-        }, async ({ control }) => await request.run({
-            signal: control.signal,
-            onConnect: (jsonSocket) => {
-                jsonSocket.send({
-                    type: "enqueue",
-                    jobName,
-                    args,
-                    options,
-                    ...(producerInvocationId ? { producerInvocationId } : {}),
-                    ...(producerProof ? { producerProof } : {})
-                });
-            },
-            onMessage: ({ message, resolve, reject }) => {
-                if (message?.type === "enqueued") {
-                    resolve(message.jobId);
-                    return;
-                }
-                if (message?.type === "enqueue-error") {
-                    reject(new Error(message.error || "Failed to enqueue job"));
+        const message = {
+            type: /** @type {const} */ ("enqueue"),
+            jobName,
+            args,
+            options,
+            ...(producerInvocationId ? { producerInvocationId } : {}),
+            ...(producerProof ? { producerProof } : {})
+        };
+        const acknowledgement = { 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.
+         * @returns {Promise<string>} - Job id.
+         */
+        const enqueueAttempt = async (attemptAcknowledgement) => {
+            const request = await this._request();
+            return await timeout({
+                errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
+                timeout: this.enqueueTimeoutMs
+            }, async ({ control }) => await request.run({
+                signal: control.signal,
+                onConnect: (jsonSocket) => {
+                    jsonSocket.send(message);
+                    if (attemptAcknowledgement) {
+                        attemptAcknowledgement.generationFenced = Boolean(request.generationId);
+                        attemptAcknowledgement.requestSent = true;
+                    }
+                },
+                onMessage: ({ message, resolve, reject }) => {
+                    if (message?.type === "enqueued") {
+                        resolve(message.jobId);
+                        return;
+                    }
+                    if (message?.type === "enqueue-error") {
+                        if (attemptAcknowledgement)
+                            attemptAcknowledgement.explicitlyRejected = true;
+                        reject(new Error(message.error || "Failed to enqueue job"));
+                    }
                 }
-            }
-        }));
+            }));
+        };
+        try {
+            return await enqueueAttempt(acknowledgement);
+        }
+        catch (error) {
+            if (!producerInvocationId || !producerProof || !acknowledgement.generationFenced || !acknowledgement.requestSent || acknowledgement.explicitlyRejected)
+                throw error;
+        }
+        return await enqueueAttempt(undefined);
     }
     /**
      * Atomically replaces the queued owner of a stable schedule key.
@@ -124,4 +148,4 @@ export default class BackgroundJobsClient {
         });
     }
 }
-//# 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 request = await this._request()\n\n    return await timeout({\n      errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,\n      timeout: this.enqueueTimeoutMs\n    }, async ({control}) => await request.run({\n      signal: control.signal,\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({\n          type: \"enqueue\",\n          jobName,\n          args,\n          options,\n          ...(producerInvocationId ? {producerInvocationId} : {}),\n          ...(producerProof ? {producerProof} : {})\n        })\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          reject(new Error(message.error || \"Failed to enqueue job\"))\n        }\n      }\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 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\n      return await timeout({\n        errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,\n        timeout: this.enqueueTimeoutMs\n      }, async ({control}) => await request.run({\n        signal: control.signal,\n        onConnect: (jsonSocket) => {\n          jsonSocket.send(message)\n          if (attemptAcknowledgement) {\n            attemptAcknowledgement.generationFenced = Boolean(request.generationId)\n            attemptAcknowledgement.requestSent = true\n          }\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\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"]}

package/package.json

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

package/src/background-jobs/client.js

@@ -49,34 +49,57 @@ export default class BackgroundJobsClient {
    * @returns {Promise<string>} - Job id.
    */
   async enqueue({jobName, args, options, producerInvocationId, producerProof}) {
-    const request = await this._request()
+    const message = {
+      type: /** @type {const} */ ("enqueue"),
+      jobName,
+      args,
+      options,
+      ...(producerInvocationId ? {producerInvocationId} : {}),
+      ...(producerProof ? {producerProof} : {})
+    }
+    const acknowledgement = {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.
+     * @returns {Promise<string>} - Job id.
+     */
+    const enqueueAttempt = async (attemptAcknowledgement) => {
+      const request = await this._request()
 
-    return await timeout({
-      errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
-      timeout: this.enqueueTimeoutMs
-    }, async ({control}) => await request.run({
-      signal: control.signal,
-      onConnect: (jsonSocket) => {
-        jsonSocket.send({
-          type: "enqueue",
-          jobName,
-          args,
-          options,
-          ...(producerInvocationId ? {producerInvocationId} : {}),
-          ...(producerProof ? {producerProof} : {})
-        })
-      },
-      onMessage: ({message, resolve, reject}) => {
-        if (message?.type === "enqueued") {
-          resolve(message.jobId)
-          return
-        }
+      return await timeout({
+        errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
+        timeout: this.enqueueTimeoutMs
+      }, async ({control}) => await request.run({
+        signal: control.signal,
+        onConnect: (jsonSocket) => {
+          jsonSocket.send(message)
+          if (attemptAcknowledgement) {
+            attemptAcknowledgement.generationFenced = Boolean(request.generationId)
+            attemptAcknowledgement.requestSent = true
+          }
+        },
+        onMessage: ({message, resolve, reject}) => {
+          if (message?.type === "enqueued") {
+            resolve(message.jobId)
+            return
+          }
 
-        if (message?.type === "enqueue-error") {
-          reject(new Error(message.error || "Failed to enqueue job"))
+          if (message?.type === "enqueue-error") {
+            if (attemptAcknowledgement) attemptAcknowledgement.explicitlyRejected = true
+            reject(new Error(message.error || "Failed to enqueue job"))
+          }
         }
-      }
-    }))
+      }))
+    }
+
+    try {
+      return await enqueueAttempt(acknowledgement)
+    } catch (error) {
+      if (!producerInvocationId || !producerProof || !acknowledgement.generationFenced || !acknowledgement.requestSent || acknowledgement.explicitlyRejected) throw error
+    }
+
+    return await enqueueAttempt(undefined)
   }
 
   /**