webspresso 0.0.104 → 0.0.106

package/core/queue/adapters/sqs.js

@@ -0,0 +1,419 @@
+/**
+ * AWS SQS Queue Adapter for Webspresso
+ * Zero-dependency: Uses standard Node.js https/crypto with standard AWS SigV4 request signing.
+ * Supports official @aws-sdk/client-sqs client, duck-typed client, or direct zero-dependency REST calls.
+ * Supports worker polling loop and AWS Lambda event.Records push batch processing.
+ *
+ * @module core/queue/adapters/sqs
+ */
+
+'use strict';
+
+const https = require('https');
+const { Job } = require('../job');
+const { signAwsV4Request } = require('../../secrets/providers/aws');
+
+/**
+ * Execute HTTPS request to SQS endpoint
+ * @param {string} urlStr
+ * @param {Object} options
+ * @returns {Promise<{ statusCode: number, data: string, json: any }>}
+ */
+function makeSqsRequest(urlStr, options = {}) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(urlStr);
+
+    const req = https.request(parsedUrl, {
+      method: options.method || 'POST',
+      headers: options.headers || {},
+      timeout: options.timeout || 15000,
+    }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        let json = null;
+        try {
+          json = JSON.parse(body);
+        } catch (_) {}
+        resolve({
+          statusCode: res.statusCode || 200,
+          data: body,
+          json,
+        });
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`[SqsQueueAdapter] Request to ${urlStr} timed out`));
+    });
+
+    if (options.body) {
+      req.write(typeof options.body === 'string' ? options.body : JSON.stringify(options.body));
+    }
+    req.end();
+  });
+}
+
+class SqsQueueAdapter {
+  /**
+   * @param {Object} options
+   * @param {string} options.queueUrl - Full URL to AWS SQS queue
+   * @param {string} [options.region] - AWS region (e.g. us-east-1)
+   * @param {string} [options.accessKeyId]
+   * @param {string} [options.secretAccessKey]
+   * @param {string} [options.sessionToken]
+   * @param {number} [options.waitTimeSeconds=5] - SQS Long polling wait time (0-20s)
+   * @param {number} [options.visibilityTimeout=30] - Visibility timeout in seconds
+   * @param {Object} [options.sqsClient] - Optional @aws-sdk/client-sqs client
+   */
+  constructor(options = {}) {
+    if (!options.queueUrl && !options.sqsClient) {
+      throw new Error('[SqsQueueAdapter] Requires queueUrl or an initialized sqsClient');
+    }
+
+    this.queueUrl = options.queueUrl || '';
+    this.region = options.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || this._extractRegion(this.queueUrl) || 'us-east-1';
+    this.accessKeyId = options.accessKeyId || process.env.AWS_ACCESS_KEY_ID || '';
+    this.secretAccessKey = options.secretAccessKey || process.env.AWS_SECRET_ACCESS_KEY || '';
+    this.sessionToken = options.sessionToken || process.env.AWS_SESSION_TOKEN || '';
+    this.waitTimeSeconds = Math.max(0, Math.min(20, options.waitTimeSeconds ?? 5));
+    this.visibilityTimeout = Math.max(1, options.visibilityTimeout ?? 30);
+    this.client = options.sqsClient || null;
+    this.httpTransport = options.httpTransport || makeSqsRequest;
+
+    /** @type {Map<string|number, string>} Map jobId -> receiptHandle */
+    this.receiptHandles = new Map();
+  }
+
+  _extractRegion(urlStr) {
+    if (!urlStr) return null;
+    const match = urlStr.match(/sqs\.([a-z0-9-]+)\.amazonaws\.com/i);
+    return match ? match[1] : null;
+  }
+
+  /**
+   * Send SQS request using SDK client or native signed HTTP POST
+   * @private
+   */
+  async _call(action, payload = {}) {
+    if (this.client) {
+      if (typeof this.client[action] === 'function') {
+        return this.client[action]({ QueueUrl: this.queueUrl, ...payload });
+      }
+      if (typeof this.client.send === 'function') {
+        return this.client.send({ name: action, input: { QueueUrl: this.queueUrl, ...payload } });
+      }
+    }
+
+    // Zero-dependency native signed POST using AWS SQS JSON 1.0 protocol
+    const parsedUrl = new URL(this.queueUrl);
+    const body = JSON.stringify({
+      QueueUrl: this.queueUrl,
+      ...payload,
+    });
+
+    const targetHeader = `AmazonSQS.${action}`;
+    const baseHeaders = {
+      'content-type': 'application/x-amz-json-1.0',
+      'x-amz-target': targetHeader,
+    };
+
+    const signedHeaders = signAwsV4Request({
+      method: 'POST',
+      host: parsedUrl.host,
+      path: parsedUrl.pathname,
+      headers: baseHeaders,
+      body,
+      service: 'sqs',
+      region: this.region,
+      accessKeyId: this.accessKeyId,
+      secretAccessKey: this.secretAccessKey,
+      sessionToken: this.sessionToken,
+    });
+
+    const response = await this.httpTransport(this.queueUrl, {
+      method: 'POST',
+      headers: signedHeaders,
+      body,
+    });
+
+    if (response.statusCode >= 300) {
+      const errMsg = response.json?.message || response.json?.Message || response.data || `HTTP ${response.statusCode}`;
+      throw new Error(`[SqsQueueAdapter] SQS.${action} failed (${response.statusCode}): ${errMsg}`);
+    }
+
+    return response.json || {};
+  }
+
+  /**
+   * Enqueue job to SQS
+   * @param {Job} job
+   * @returns {Promise<Job>}
+   */
+  async enqueue(job) {
+    const jobInstance = job instanceof Job ? job : new Job(job);
+
+    const messagePayload = {
+      id: jobInstance.id,
+      name: jobInstance.name,
+      data: jobInstance.data,
+      attempts: jobInstance.attempts,
+      maxAttempts: jobInstance.maxAttempts,
+      priority: jobInstance.priority,
+      runAt: jobInstance.runAt ? jobInstance.runAt.toISOString() : null,
+      createdAt: jobInstance.createdAt ? jobInstance.createdAt.toISOString() : new Date().toISOString(),
+    };
+
+    let delaySeconds = 0;
+    if (jobInstance.runAt) {
+      const delayMs = jobInstance.runAt.getTime() - Date.now();
+      if (delayMs > 0) {
+        delaySeconds = Math.min(900, Math.floor(delayMs / 1000));
+      }
+    }
+
+    const res = await this._call('SendMessage', {
+      MessageBody: JSON.stringify(messagePayload),
+      DelaySeconds: delaySeconds,
+      MessageAttributes: {
+        JobName: {
+          DataType: 'String',
+          StringValue: jobInstance.name,
+        },
+      },
+    });
+
+    if (res.MessageId) {
+      jobInstance._sqsMessageId = res.MessageId;
+    }
+
+    return jobInstance;
+  }
+
+  /**
+   * Dequeue single job from SQS
+   * @param {string[]} [jobNames]
+   * @returns {Promise<Job|null>}
+   */
+  async dequeue(jobNames = []) {
+    const res = await this._call('ReceiveMessage', {
+      MaxNumberOfMessages: 1,
+      WaitTimeSeconds: this.waitTimeSeconds,
+      VisibilityTimeout: this.visibilityTimeout,
+      AttributeNames: ['All'],
+      MessageAttributeNames: ['All'],
+    });
+
+    const messages = res.Messages || res.messages || [];
+    if (!messages || messages.length === 0) {
+      return null;
+    }
+
+    const msg = messages[0];
+    const receiptHandle = msg.ReceiptHandle || msg.receiptHandle;
+
+    let payload = {};
+    try {
+      payload = JSON.parse(msg.Body || msg.body || '{}');
+    } catch (_) {
+      payload = { name: 'raw', data: msg.Body };
+    }
+
+    const job = new Job({
+      id: payload.id || msg.MessageId || msg.messageId,
+      name: payload.name || 'default',
+      data: payload.data || {},
+      status: 'running',
+      attempts: (payload.attempts || 0) + 1,
+      maxAttempts: payload.maxAttempts ?? 3,
+      priority: payload.priority ?? 10,
+      runAt: payload.runAt ? new Date(payload.runAt) : new Date(),
+    });
+
+    job._receiptHandle = receiptHandle;
+    this.receiptHandles.set(job.id, receiptHandle);
+
+    // If job does not match expected handlers, return visibility immediately
+    if (jobNames.length > 0 && !jobNames.includes(job.name)) {
+      await this.retry(job.id, 0);
+      return null;
+    }
+
+    return job;
+  }
+
+  /**
+   * Mark job as completed and delete from SQS
+   * @param {string|number} jobId
+   * @param {any} [result]
+   * @returns {Promise<Job|null>}
+   */
+  async complete(jobId, result = null) {
+    const handle = this.receiptHandles.get(jobId);
+    if (handle) {
+      try {
+        await this._call('DeleteMessage', { ReceiptHandle: handle });
+      } finally {
+        this.receiptHandles.delete(jobId);
+      }
+    }
+
+    return new Job({
+      id: jobId,
+      status: 'completed',
+      result,
+      updatedAt: new Date(),
+    });
+  }
+
+  /**
+   * Mark job as permanently failed
+   * @param {string|number} jobId
+   * @param {any} [error]
+   * @returns {Promise<Job|null>}
+   */
+  async fail(jobId, error = null) {
+    const handle = this.receiptHandles.get(jobId);
+    if (handle) {
+      try {
+        await this._call('DeleteMessage', { ReceiptHandle: handle });
+      } finally {
+        this.receiptHandles.delete(jobId);
+      }
+    }
+
+    return new Job({
+      id: jobId,
+      status: 'failed',
+      error,
+      updatedAt: new Date(),
+    });
+  }
+
+  /**
+   * Change visibility timeout to reschedule job for retry
+   * @param {string|number} jobId
+   * @param {number} delayMs
+   * @param {any} [error]
+   * @returns {Promise<Job|null>}
+   */
+  async retry(jobId, delayMs, error = null) {
+    const handle = this.receiptHandles.get(jobId);
+    if (handle) {
+      const visibilitySeconds = Math.min(43200, Math.max(0, Math.ceil(delayMs / 1000)));
+      try {
+        await this._call('ChangeMessageVisibility', {
+          ReceiptHandle: handle,
+          VisibilityTimeout: visibilitySeconds,
+        });
+      } finally {
+        this.receiptHandles.delete(jobId);
+      }
+    }
+
+    return new Job({
+      id: jobId,
+      status: 'pending',
+      error,
+      updatedAt: new Date(),
+    });
+  }
+
+  /**
+   * Get queue statistics from SQS
+   * @returns {Promise<{ pending: number, running: number, delayed: number, total: number }>}
+   */
+  async getStats() {
+    try {
+      const res = await this._call('GetQueueAttributes', {
+        AttributeNames: [
+          'ApproximateNumberOfMessages',
+          'ApproximateNumberOfMessagesNotVisible',
+          'ApproximateNumberOfMessagesDelayed',
+        ],
+      });
+
+      const attrs = res.Attributes || res.attributes || {};
+      const pending = parseInt(attrs.ApproximateNumberOfMessages || '0', 10);
+      const running = parseInt(attrs.ApproximateNumberOfMessagesNotVisible || '0', 10);
+      const delayed = parseInt(attrs.ApproximateNumberOfMessagesDelayed || '0', 10);
+
+      return {
+        pending,
+        running,
+        delayed,
+        total: pending + running + delayed,
+      };
+    } catch (_) {
+      return { pending: 0, running: 0, delayed: 0, total: 0 };
+    }
+  }
+
+  /**
+   * Process an AWS Lambda SQS event batch (`event.Records`)
+   * @param {Array<Object>} records - SQS event records
+   * @param {import('../manager').QueueManager} queueManager
+   * @returns {Promise<{ processed: number, failed: number }>}
+   */
+  async processBatch(records, queueManager) {
+    if (!Array.isArray(records)) {
+      return { processed: 0, failed: 0 };
+    }
+
+    let processed = 0;
+    let failed = 0;
+
+    for (const record of records) {
+      let payload = {};
+      try {
+        payload = JSON.parse(record.body || '{}');
+      } catch (_) {
+        payload = { name: 'raw', data: record.body };
+      }
+
+      const jobName = payload.name;
+      const handlerDef = queueManager?.handlers?.get(jobName);
+
+      if (!handlerDef || typeof handlerDef.handler !== 'function') {
+        continue;
+      }
+
+      const job = new Job({
+        id: payload.id || record.messageId,
+        name: jobName,
+        data: payload.data || {},
+        priority: payload.priority || 10,
+        runAt: payload.runAt ? new Date(payload.runAt) : new Date(),
+      });
+
+      try {
+        job.status = 'running';
+        job.startedAt = new Date();
+        queueManager.emit('job:start', job);
+
+        const result = await handlerDef.handler(job, { queue: queueManager, record });
+        job.status = 'completed';
+        job.result = result;
+        job.completedAt = new Date();
+        queueManager.emit('job:completed', job, result);
+        processed++;
+      } catch (err) {
+        job.status = 'failed';
+        job.error = err;
+        queueManager.emit('job:failed', job, err);
+        failed++;
+        throw err; // In Lambda SQS batches, throwing lets SQS retry or trigger DLQ
+      }
+    }
+
+    return { processed, failed };
+  }
+}
+
+module.exports = {
+  SqsQueueAdapter,
+  makeSqsRequest,
+};

package/core/queue/adapters/wait-until.js

@@ -0,0 +1,77 @@
+/**
+ * WaitUntil (Edge/Serverless) Queue Adapter
+ * Designed for environments exposing an execution context (e.g. Cloudflare Workers ctx.waitUntil,
+ * Vercel Edge waitUntil) where jobs run non-blocking in the background without persistent polling daemons.
+ * @module core/queue/adapters/wait-until
+ */
+
+'use strict';
+
+const { MemoryQueueAdapter } = require('./memory');
+const { Job } = require('../job');
+
+class WaitUntilQueueAdapter extends MemoryQueueAdapter {
+  /**
+   * @param {Object} [options]
+   * @param {Function} [options.waitUntil] - Optional global waitUntil handler
+   * @param {number} [options.maxRetainedJobs=1000] - In-memory retention limit to prevent memory leaks in isolates
+   */
+  constructor(options = {}) {
+    super();
+    this.waitUntilHandler = typeof options.waitUntil === 'function' ? options.waitUntil : null;
+    this.maxRetainedJobs = options.maxRetainedJobs || 1000;
+  }
+
+  /**
+   * Set or update the active waitUntil handler (e.g. from per-request execution context)
+   * @param {Function} fn
+   */
+  setWaitUntil(fn) {
+    if (typeof fn === 'function') {
+      this.waitUntilHandler = fn;
+    }
+  }
+
+  /**
+   * Enqueue a job and schedule it for immediate execution via waitUntil if available
+   * @param {Job} job
+   * @returns {Promise<Job>}
+   */
+  async enqueue(job) {
+    const jobInstance = await super.enqueue(job);
+
+    // Evict oldest completed/failed jobs if limit reached to protect isolate memory
+    if (this.jobs.size > this.maxRetainedJobs) {
+      let evicted = 0;
+      for (const [id, j] of this.jobs.entries()) {
+        if (j.status === 'completed' || j.status === 'failed') {
+          this.jobs.delete(id);
+          evicted++;
+          if (evicted >= 50) break;
+        }
+      }
+    }
+
+    return jobInstance;
+  }
+
+  /**
+   * Schedule a promise to complete in the background via waitUntil if available,
+   * or fall back to unhandled Promise execution.
+   * @param {Promise<any>} promise
+   */
+  scheduleBackground(promise) {
+    if (this.waitUntilHandler) {
+      try {
+        this.waitUntilHandler(promise);
+        return;
+      } catch (_) {
+        // Fall back to unhandled background promise
+      }
+    }
+    // Standard Node/V8 unhandled background promise fallback
+    promise.catch(() => {});
+  }
+}
+
+module.exports = { WaitUntilQueueAdapter };

package/core/queue/index.js

@@ -10,6 +10,10 @@ const { QueueManager, createQueueManager } = require('./manager');
 const { MemoryQueueAdapter } = require('./adapters/memory');
 const { DatabaseQueueAdapter } = require('./adapters/database');
 const { RedisQueueAdapter } = require('./adapters/redis');
+const { WaitUntilQueueAdapter } = require('./adapters/wait-until');
+const { CloudflareQueueAdapter } = require('./adapters/cloudflare');
+const { SqsQueueAdapter } = require('./adapters/sqs');
+const { PubSubQueueAdapter } = require('./adapters/pubsub');
 const { CronExpression, isValidCron, parseCron, resolveCronAlias } = require('./cron');
 const { TaskScheduler } = require('./scheduler');
 
@@ -20,6 +24,10 @@ module.exports = {
   MemoryQueueAdapter,
   DatabaseQueueAdapter,
   RedisQueueAdapter,
+  WaitUntilQueueAdapter,
+  CloudflareQueueAdapter,
+  SqsQueueAdapter,
+  PubSubQueueAdapter,
   CronExpression,
   isValidCron,
   parseCron,

package/core/queue/manager.js

@@ -12,6 +12,8 @@ const { Job } = require('./job');
 const { MemoryQueueAdapter } = require('./adapters/memory');
 const { CronExpression, CRON_ALIASES } = require('./cron');
 const { TaskScheduler } = require('./scheduler');
+const { walkDirectoryDetailed } = require('../utils/fs');
+const { parseDurationMs } = require('../utils/time');
 
 class QueueManager extends EventEmitter {
   /**
@@ -31,6 +33,10 @@ class QueueManager extends EventEmitter {
     this.maxPollInterval = Math.max(this.pollInterval, options.maxPollInterval || (this.pollInterval * 5));
     this._currentPollInterval = this.pollInterval;
     this.jobsDir = options.jobsDir || null;
+    this.timeouts = options.timeouts || null;
+    this.defaultTimeout = options.timeout !== undefined
+      ? parseDurationMs(options.timeout, 30000)
+      : (options.timeouts?.queue ? parseDurationMs(options.timeouts.queue, 30000) : 30000);
 
     /** @type {Map<string, { handler: Function, options: Object }>} */
     this.handlers = new Map();
@@ -117,7 +123,7 @@ class QueueManager extends EventEmitter {
       handler,
       options: {
         attempts: 3,
-        timeout: 30000,
+        timeout: options.timeout !== undefined ? parseDurationMs(options.timeout, this.defaultTimeout) : this.defaultTimeout,
         priority: 10,
         ...options,
       },
@@ -126,6 +132,17 @@ class QueueManager extends EventEmitter {
     return this;
   }
 
+  /**
+   * Alias for define
+   * @param {string} name
+   * @param {Function} handler
+   * @param {Object} [options]
+   * @returns {JobQueueManager}
+   */
+  register(name, handler, options = {}) {
+    return this.define(name, handler, options);
+  }
+
   /**
    * Check if a job handler is defined
    * @param {string} name
@@ -152,6 +169,8 @@ class QueueManager extends EventEmitter {
         runAt = new Date(Date.now() + options.delay);
       } else if (options.delay instanceof Date) {
         runAt = options.delay;
+      } else if (typeof options.delay === 'string') {
+        runAt = new Date(Date.now() + parseDurationMs(options.delay, 0));
       }
     }
 
@@ -161,7 +180,7 @@ class QueueManager extends EventEmitter {
       runAt,
       priority: options.priority !== undefined ? options.priority : defaults.priority,
       maxAttempts: options.attempts !== undefined ? options.attempts : defaults.attempts,
-      timeout: options.timeout !== undefined ? options.timeout : defaults.timeout,
+      timeout: options.timeout !== undefined ? parseDurationMs(options.timeout, defaults.timeout) : defaults.timeout,
       backoff: options.backoff !== undefined ? options.backoff : defaults.backoff,
       onProgress: (j, percent, msg) => {
         this.emit('job:progress', j, percent, msg);
@@ -450,45 +469,44 @@ class QueueManager extends EventEmitter {
   loadJobsFromDirectory(dirPath) {
     if (!fs.existsSync(dirPath)) return;
 
-    const readRecursive = (curDir, basePrefix = '') => {
-      const entries = fs.readdirSync(curDir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(curDir, entry.name);
-        if (entry.isDirectory()) {
-          readRecursive(fullPath, basePrefix ? `${basePrefix}.${entry.name}` : entry.name);
-        } else if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.cjs'))) {
-          const isCronFile = entry.name.endsWith('.cron.js') || entry.name.endsWith('.cron.cjs');
-          const nameWithoutExt = isCronFile
-            ? entry.name.replace(/\.cron\.(c)?js$/, '')
-            : entry.name.replace(/\.(c)?js$/, '');
-          const jobName = basePrefix ? `${basePrefix}.${nameWithoutExt}` : nameWithoutExt;
-
-          try {
-            const mod = require(fullPath);
-            const handler = typeof mod === 'function' ? mod : (mod.handler || mod.default);
-            const options = mod.options || {};
-
-            if (typeof handler === 'function') {
-              this.define(jobName, handler, options);
-
-              const cronExpr = mod.cron || mod.schedule || (isCronFile ? (mod.expression || (CRON_ALIASES[`@${nameWithoutExt}`] ? `@${nameWithoutExt}` : null)) : null);
-              if (cronExpr) {
-                this.schedule(
-                  cronExpr,
-                  jobName,
-                  mod.data || {},
-                  { ...options, ...(mod.scheduleOptions || {}) }
-                );
-              }
-            }
-          } catch (err) {
-            console.error(`[QueueManager] Failed to load job from ${fullPath}:`, err.message);
+    const files = walkDirectoryDetailed(dirPath, {
+      extensions: ['.js', '.cjs'],
+      ignorePrefixes: ['.', '_'],
+      ignoreTests: true,
+    });
+
+    for (const item of files) {
+      const relNormalized = item.relativePath.split(/[\/\\]/).join('.');
+      const isCronFile = item.name.endsWith('.cron.js') || item.name.endsWith('.cron.cjs');
+      const baseNameWithoutExt = isCronFile
+        ? item.name.replace(/\.cron\.(c)?js$/, '')
+        : item.name.replace(/\.(c)?js$/, '');
+      const jobName = isCronFile
+        ? relNormalized.replace(/\.cron\.(c)?js$/, '')
+        : relNormalized.replace(/\.(c)?js$/, '');
+
+      try {
+        const mod = require(item.absolutePath);
+        const handler = typeof mod === 'function' ? mod : (mod.handler || mod.default);
+        const options = mod.options || {};
+
+        if (typeof handler === 'function') {
+          this.define(jobName, handler, options);
+
+          const cronExpr = mod.cron || mod.schedule || (isCronFile ? (mod.expression || (CRON_ALIASES[`@${baseNameWithoutExt}`] ? `@${baseNameWithoutExt}` : null)) : null);
+          if (cronExpr) {
+            this.schedule(
+              cronExpr,
+              jobName,
+              mod.data || {},
+              { ...options, ...(mod.scheduleOptions || {}) }
+            );
           }
         }
+      } catch (err) {
+        console.error(`[QueueManager] Failed to load job from ${item.absolutePath}:`, err.message);
       }
-    };
-
-    readRecursive(dirPath);
+    }
   }
 
   /**
@@ -592,13 +610,16 @@ class QueueManager extends EventEmitter {
     this.emit('job:started', job);
 
     const { handler } = registered;
-    const timeoutMs = job.timeout || 30000;
+    const timeoutMs = job.timeout || this.defaultTimeout || 30000;
 
     let timeoutTimer = null;
     const timeoutPromise = new Promise((_, reject) => {
       timeoutTimer = setTimeout(() => {
         reject(new Error(`Job '${job.name}' (${job.id}) exceeded timeout of ${timeoutMs}ms`));
       }, timeoutMs);
+      if (timeoutTimer && typeof timeoutTimer.unref === 'function') {
+        timeoutTimer.unref();
+      }
     });
 
     try {
@@ -606,12 +627,16 @@ class QueueManager extends EventEmitter {
         handler(job, { queue: this }),
         timeoutPromise,
       ]);
-      clearTimeout(timeoutTimer);
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+      }
 
       const completedJob = await this.adapter.complete(job.id, result);
       this.emit('job:completed', completedJob || job, result);
     } catch (err) {
-      clearTimeout(timeoutTimer);
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+      }
 
       if (job.attempts < job.maxAttempts) {
         const delayMs = job.getNextRetryDelay();