ghost 6.62.0 → 6.63.0

package/core/server/services/email-service/batch-sending-service.js

@@ -213,6 +213,7 @@ class BatchSendingService {
 
     // Check if email is 'pending' only + change status to submitting in one transaction.
     // This allows us to have a lock around the email job that makes sure an email can only have one active job.
+    // Also stamps updated_at, which SendingStatusService reads as the attempt start; do not save the Email once batches submit.
     let email;
     try {
       email = await this.retryDb(
@@ -704,6 +705,7 @@ class BatchSendingService {
     const deliveryTimes = this.calculateDeliveryTimes(email, batches.length);
 
     // Loop batches and send them via the EmailProvider
+    // SendingStatusService treats a batch that fails in this run as finished work; never re-queue it within the run.
     let succeededCount = 0;
     const queue = batches.slice();
 

package/core/server/services/email-service/email-controller.js

@@ -1,6 +1,8 @@
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 
+/** @typedef {import('./sending-status-service').SendingStatusService} SendingStatusService */
+
 const messages = {
   postNotFound: 'Post not found.',
   noEmailsProvided: 'No emails provided.',
@@ -23,16 +25,18 @@ class EmailController {
   service;
   models;
   getRequiredUrlRelations;
+  sendingStatusService;
 
   /**
    *
    * @param {EmailService} service
-   * @param {{models: {Post: any, Newsletter: any, Email: any}, getRequiredUrlRelations?: () => string[]}} dependencies
+   * @param {{models: {Post: any, Newsletter: any, Email: any}, getRequiredUrlRelations?: () => string[], sendingStatusService: SendingStatusService}} dependencies
    */
-  constructor(service, { models, getRequiredUrlRelations = () => [] }) {
+  constructor(service, { models, getRequiredUrlRelations = () => [], sendingStatusService }) {
     this.service = service;
     this.models = models;
     this.getRequiredUrlRelations = getRequiredUrlRelations;
+    this.sendingStatusService = sendingStatusService;
   }
 
   async _getFrameData(frame) {
@@ -143,6 +147,18 @@ class EmailController {
 
     return await this.service.retryEmail(email);
   }
+
+  async getSendingStatus(frame) {
+    const status = await this.sendingStatusService.statusFor(frame.data.id);
+
+    if (!status) {
+      throw new errors.NotFoundError({
+        message: tpl(messages.emailNotFound),
+      });
+    }
+
+    return status;
+  }
 }
 
 module.exports = EmailController;

package/core/server/services/email-service/email-service-wrapper.js

@@ -24,6 +24,7 @@ class EmailServiceWrapper {
     const EmailRenderer = require('./email-renderer');
     const SendingService = require('./sending-service');
     const BatchSendingService = require('./batch-sending-service');
+    const { SendingStatusService } = require('./sending-status-service');
     const EmailSegmenter = require('./email-segmenter');
     const MailgunEmailProvider = require('./mailgun-email-provider');
     const { DomainWarmingService } = require('./domain-warming-service');
@@ -127,6 +128,7 @@ class EmailServiceWrapper {
       sentry,
       getRequiredUrlRelations,
     });
+    const sendingStatusService = new SendingStatusService({ knex: db.knex });
 
     if (ghostServer) {
       // Two phases: stop claiming batches immediately, drain in-flight ones later.
@@ -169,6 +171,7 @@ class EmailServiceWrapper {
         Email,
       },
       getRequiredUrlRelations,
+      sendingStatusService,
     });
   }
 }

package/core/server/services/email-service/sending-status-schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbBatchSendingRow = exports.DbEmailSendingRow = exports.StoredSendingStatus = void 0;
+const zod_1 = require("zod");
+const count_1 = require("../../lib/db-types/count");
+const date_1 = require("../../lib/db-types/date");
+exports.StoredSendingStatus = zod_1.z.enum(['pending', 'submitting', 'submitted', 'failed']);
+// Projections of tables the Bookshelf models own, not full rows, so there is no knex table
+// augmentation here: typing `emails` by these columns alone would mistype every other read.
+exports.DbEmailSendingRow = zod_1.z.object({
+    id: zod_1.z.string(),
+    status: exports.StoredSendingStatus,
+    email_count: count_1.DbCount,
+    updated_at: date_1.DbDate.nullable(),
+});
+exports.DbBatchSendingRow = zod_1.z.object({
+    status: exports.StoredSendingStatus,
+    created_at: date_1.DbDate,
+    updated_at: date_1.DbDate,
+    recipient_count: count_1.DbCount,
+});

package/core/server/services/email-service/sending-status-serializers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEmailStatusesResponse = void 0;
+const zod_1 = require("zod");
+const case_keys_1 = require("../../lib/case-keys");
+const sending_status_1 = require("./sending-status");
+const SendingPhaseResource = zod_1.z.enum(['preparing', 'submitting']);
+const SendingResource = zod_1.z.object({
+    status: zod_1.z.enum(['preparing', 'submitting', 'submitted', 'failed']),
+    progress: zod_1.z.object({
+        completed: zod_1.z.number(),
+        total: zod_1.z.number(),
+        estimated_seconds_remaining: zod_1.z.number().nullable(),
+    }),
+    failed_during: SendingPhaseResource.optional(),
+});
+const EmailStatusResource = zod_1.z.object({
+    id: zod_1.z.string(),
+    sending: SendingResource,
+});
+const EmailStatusesResponse = zod_1.z.object({ email_statuses: zod_1.z.array(EmailStatusResource) });
+exports.toEmailStatusesResponse = sending_status_1.EmailSendingStatus.transform(({ id, sending }) => ({
+    email_statuses: [
+        {
+            id,
+            sending: {
+                status: sending.status,
+                progress: (0, case_keys_1.snakeKeys)(sending.progress),
+                ...(sending.status === 'failed' ? { failed_during: sending.failedDuring } : {}),
+            },
+        },
+    ],
+})).pipe(EmailStatusesResponse);

package/core/server/services/email-service/sending-status-service.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendingStatusService = void 0;
+const case_keys_1 = require("../../lib/case-keys");
+const sending_status_schema_1 = require("./sending-status-schema");
+const sending_status_1 = require("./sending-status");
+class SendingStatusService {
+    #knex;
+    constructor({ knex }) {
+        this.#knex = knex;
+    }
+    async statusFor(emailId) {
+        const row = await this.#knex('emails')
+            .select('id', 'status', 'email_count', 'updated_at')
+            .where('id', emailId)
+            .first();
+        if (!row) {
+            return null;
+        }
+        const email = sending_status_schema_1.DbEmailSendingRow.parse(row);
+        // A submitted email answers from its own count, and batch creation reconciles email_count
+        // to the recipient rows it built, so the batch query is skipped rather than run and ignored.
+        const batches = email.status === 'submitted' ? [] : await this.#batchesFor(emailId);
+        return {
+            id: email.id,
+            sending: (0, sending_status_1.buildSendingStatus)({
+                status: email.status,
+                recipientCount: email.email_count,
+                // The sending job saves the email when it takes its status lock, so updated_at
+                // stands in for the attempt start that Ghost does not record.
+                attemptStartedAt: email.updated_at,
+            }, batches),
+        };
+    }
+    async #batchesFor(emailId) {
+        // Correlated per-batch count stays on the batch_id index; grouping recipients by email_id scans every recipient row.
+        const recipientCount = this.#knex('email_recipients as recipient')
+            .count('*')
+            .whereRaw('recipient.batch_id = batch.id');
+        const rows = await this.#knex('email_batches as batch')
+            .select('batch.status', 'batch.created_at', 'batch.updated_at')
+            .select(recipientCount.as('recipient_count'))
+            .where('batch.email_id', emailId);
+        return rows.map((batchRow) => (0, case_keys_1.camelKeys)(sending_status_schema_1.DbBatchSendingRow.parse(batchRow)));
+    }
+}
+exports.SendingStatusService = SendingStatusService;

package/core/server/services/email-service/sending-status.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailSendingStatus = exports.SendingStatus = exports.SendingProgress = exports.SendingPhase = void 0;
+exports.buildSendingStatus = buildSendingStatus;
+const zod_1 = require("zod");
+const ETA_COMPLETION_WINDOW = 20;
+const ETA_MIN_INTERVALS = 2;
+exports.SendingPhase = zod_1.z.enum(['preparing', 'submitting']);
+exports.SendingProgress = zod_1.z.object({
+    completed: zod_1.z.number().int().nonnegative(),
+    total: zod_1.z.number().int().nonnegative(),
+    estimatedSecondsRemaining: zod_1.z.number().int().nonnegative().nullable(),
+});
+exports.SendingStatus = zod_1.z.discriminatedUnion('status', [
+    zod_1.z.object({ status: exports.SendingPhase, progress: exports.SendingProgress }),
+    zod_1.z.object({ status: zod_1.z.literal('submitted'), progress: exports.SendingProgress }),
+    zod_1.z.object({ status: zod_1.z.literal('failed'), progress: exports.SendingProgress, failedDuring: exports.SendingPhase }),
+]);
+exports.EmailSendingStatus = zod_1.z.object({
+    id: zod_1.z.string(),
+    sending: exports.SendingStatus,
+});
+function buildSendingStatus(email, batches) {
+    // Submitted is terminal: every batch was accepted, so the email's own recipient count is the
+    // answer and the batch aggregation below, which describes a send still in progress, does not apply.
+    if (email.status === 'submitted') {
+        return {
+            status: 'submitted',
+            progress: {
+                completed: email.recipientCount,
+                total: email.recipientCount,
+                estimatedSecondsRemaining: 0,
+            },
+        };
+    }
+    const phase = batches.some((batch) => batch.status !== 'pending')
+        ? 'submitting'
+        : 'preparing';
+    const attemptStartedAt = email.attemptStartedAt?.getTime() ?? null;
+    const preparedCount = sumRecipients(batches);
+    const completedBatches = phase === 'preparing' ? batches : batches.filter((batch) => batch.status === 'submitted');
+    const completed = sumRecipients(completedBatches);
+    const total = phase === 'preparing' ? Math.max(email.recipientCount, preparedCount) : preparedCount;
+    if (email.status === 'failed') {
+        return {
+            status: 'failed',
+            progress: { completed, total, estimatedSecondsRemaining: null },
+            failedDuring: phase,
+        };
+    }
+    const failedThisAttempt = batches.filter((batch) => failedDuringAttempt(batch, attemptStartedAt));
+    const remaining = total - completed - sumRecipients(failedThisAttempt);
+    const samples = completedBatches.map((batch) => ({
+        recipientCount: batch.recipientCount,
+        timestamp: (phase === 'preparing' ? batch.createdAt : batch.updatedAt).getTime(),
+    }));
+    return {
+        status: phase,
+        progress: {
+            completed,
+            total,
+            estimatedSecondsRemaining: estimateSecondsRemaining({
+                remaining,
+                samples,
+                attemptStartedAt,
+            }),
+        },
+    };
+}
+function sumRecipients(batches) {
+    return batches.reduce((sum, batch) => sum + batch.recipientCount, 0);
+}
+// A batch that fails is only retried together with its email, so within an attempt it is finished work.
+function failedDuringAttempt(batch, attemptStartedAt) {
+    return (batch.status === 'failed' &&
+        attemptStartedAt !== null &&
+        batch.updatedAt.getTime() >= attemptStartedAt);
+}
+function estimateSecondsRemaining({ remaining, samples, attemptStartedAt, }) {
+    if (remaining <= 0) {
+        return 0;
+    }
+    const sorted = samples
+        .filter((sample) => sample.recipientCount > 0 &&
+        (attemptStartedAt === null || sample.timestamp >= attemptStartedAt))
+        .sort((a, b) => a.timestamp - b.timestamp);
+    // Coalesce completions sharing a timestamp so database timestamp precision does
+    // not turn their recipients into zero-duration samples or make row order matter.
+    const completions = [];
+    for (const sample of sorted) {
+        const previous = completions.at(-1);
+        if (previous?.timestamp === sample.timestamp) {
+            previous.recipientCount += sample.recipientCount;
+        }
+        else {
+            completions.push({ ...sample });
+        }
+    }
+    // Limit usable timestamps, not rows: fast sends may finish many batches per timestamp.
+    const window = completions.slice(-ETA_COMPLETION_WINDOW);
+    // Three distinct timestamps provide two measured intervals for an initial rate.
+    if (window.length < ETA_MIN_INTERVALS + 1) {
+        return null;
+    }
+    // Measure combined throughput across the window, including overlapping workers.
+    // The first completion is only the baseline: its recipients were processed
+    // before the measured time span.
+    const seconds = (window[window.length - 1].timestamp - window[0].timestamp) / 1000;
+    const recipients = window.slice(1).reduce((sum, sample) => sum + sample.recipientCount, 0);
+    return Math.ceil((remaining * seconds) / recipients);
+}

package/core/server/services/email-suppression-list/email-suppression-list.js

@@ -54,38 +54,6 @@ class EmailSuppressionData {
   }
 }
 
-/**
- * @abstract
- * @implements {IEmailSuppressionList}
- */
-class AbstractEmailSuppressionList {
-  /**
-   * @param {string} email
-   * @returns {Promise<boolean>}
-   */
-  // eslint-disable-next-line
-  async removeEmail(email) {
-    return Promise.reject();
-  }
-
-  /**
-   * @param {string} email
-   * @returns {Promise<EmailSuppressionData>}
-   */
-  // eslint-disable-next-line
-  async getSuppressionData(email) {
-    return Promise.reject();
-  }
-
-  /**
-   * @param {string[]} emails
-   * @returns {Promise<EmailSuppressionData[]>}
-   */
-  async getBulkSuppressionData(emails) {
-    return Promise.all(emails.map((email) => this.getSuppressionData(email)));
-  }
-}
-
 class EmailSuppressedEvent {
   /**
    * @readonly
@@ -120,7 +88,6 @@ class EmailSuppressedEvent {
 }
 
 module.exports = {
-  AbstractEmailSuppressionList,
   EmailSuppressionData,
   EmailSuppressedEvent,
 };

package/core/server/services/email-suppression-list/mailgun-email-suppression-list.js

@@ -1,13 +1,10 @@
-const {
-  AbstractEmailSuppressionList,
-  EmailSuppressionData,
-  EmailSuppressedEvent,
-} = require('./email-suppression-list');
+const { EmailSuppressionData, EmailSuppressedEvent } = require('./email-suppression-list');
 const { SpamComplaintEvent } = require('../email-service/events/spam-complaint-event');
 const { EmailBouncedEvent } = require('../email-service/events/email-bounced-event');
 const DomainEvents = require('@tryghost/domain-events');
 const logging = require('@tryghost/logging');
 const models = require('../../models');
+/** @import {IEmailSuppressionList} from './email-suppression-list' */
 
 /**
  * @typedef {object} IMailgunAPIClient
@@ -16,14 +13,16 @@ const models = require('../../models');
  * @prop {(email: string) => Promise<any>} removeUnsubscribe
  */
 
-class MailgunEmailSuppressionList extends AbstractEmailSuppressionList {
+/**
+ * @implements {IEmailSuppressionList}
+ */
+class MailgunEmailSuppressionList {
   /**
    * @param {object} deps
    * @param {import('bookshelf').Model} deps.Suppression
    * @param {IMailgunAPIClient} deps.apiClient
    */
   constructor(deps) {
-    super();
     this.Suppression = deps.Suppression;
     this.apiClient = deps.apiClient;
   }

package/core/server/services/gifts/README.md

@@ -6,8 +6,8 @@ transactions, or Stripe objects.
 
 ## Interface
 
-- `startCheckout(input)` owns the `giftSubCustomization` flag, duration
-  catalogue, Portal plan gate, tier/cadence validation, authoritative price,
+- `startCheckout(input)` owns the duration catalogue, Portal plan gate,
+  tier/cadence validation, authoritative price,
   token, success parameters, metadata, customer, and one-time payment.
 - `preparePaidContinuation(input)` validates an active gift and returns the
   stable tier/cadence/trial decision consumed by the normal subscription

package/core/server/services/gifts/constants.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GIFT_DELIVERY_EMAIL_TAG = exports.GIFT_DELIVERY_STALE_AFTER_MS = exports.GIFT_REMINDER_FLOOR_DAYS = exports.GIFT_REMINDER_LEAD_DAYS = exports.GIFT_SEND_HOUR = exports.GIFT_MAX_SCHEDULE_DAYS = exports.GIFT_EXPIRY_DAYS = void 0;
 exports.GIFT_EXPIRY_DAYS = 365;
 // How far ahead a delivery may be scheduled. Portal's picker carries its own
-// copy (GIFT_MAX_SCHEDULE_DAYS in beta-gift-page.tsx) since Portal ships
+// copy (GIFT_MAX_SCHEDULE_DAYS in gift-page.tsx) since Portal ships
 // separately — change them together.
 exports.GIFT_MAX_SCHEDULE_DAYS = 365;
 // Site-local hour a scheduled delivery is sent at. Portal never derives

package/core/server/services/gifts/gift-service.js

@@ -95,40 +95,22 @@ class GiftService {
         this.deps = deps;
     }
     async startCheckout(input) {
-        const customizationEnabled = this.deps.labsService.isSet('giftSubCustomization');
-        const populatedDeliveryFields = [
-            input.recipientEmail,
-            input.recipientName,
-            input.buyerName,
-            input.personalMessage,
-            input.deliveryDate,
-        ].some((value) => value !== undefined && value !== null && value !== '');
-        if (!customizationEnabled && (input.deliveryMethod === 'email' || populatedDeliveryFields)) {
-            throw new errors_1.default.BadRequestError({
-                message: 'Bad Request.',
-                context: 'Gift email delivery is not available',
-            });
-        }
         const parsedBuyerEmail = CheckoutBuyerEmailSchema.safeParse(input.buyer.email);
-        if (customizationEnabled && !parsedBuyerEmail.success) {
+        if (!parsedBuyerEmail.success) {
             throw new errors_1.default.BadRequestError({
                 message: 'Bad Request.',
                 context: `Invalid gift buyer email: ${parsedBuyerEmail.error.issues[0].message}`,
             });
         }
         const buyerEmail = parsedBuyerEmail.success ? parsedBuyerEmail.data : input.buyer.email;
-        const parsedDelivery = GiftCheckoutDeliverySchema.safeParse(customizationEnabled
-            ? {
-                deliveryMethod: input.deliveryMethod ?? 'link',
-                recipientEmail: input.recipientEmail,
-                recipientName: input.recipientName,
-                buyerName: input.buyerName,
-                personalMessage: input.personalMessage,
-                deliveryDate: input.deliveryDate,
-            }
-            : {
-                deliveryMethod: 'link',
-            });
+        const parsedDelivery = GiftCheckoutDeliverySchema.safeParse({
+            deliveryMethod: input.deliveryMethod ?? 'link',
+            recipientEmail: input.recipientEmail,
+            recipientName: input.recipientName,
+            buyerName: input.buyerName,
+            personalMessage: input.personalMessage,
+            deliveryDate: input.deliveryDate,
+        });
         if (!parsedDelivery.success) {
             const issue = parsedDelivery.error.issues[0];
             throw new errors_1.default.BadRequestError({
@@ -150,22 +132,7 @@ class GiftService {
                 context: 'Expected offerId or tierId, received none',
             });
         }
-        let resolvedDuration = null;
-        let cadence;
-        if (customizationEnabled) {
-            resolvedDuration = (0, gift_checkout_offer_1.resolveGiftDuration)(input);
-            cadence = resolvedDuration.cadence;
-        }
-        else {
-            if (input.cadence !== 'month' && input.cadence !== 'year') {
-                const receivedCadence = input.cadence ? `"${input.cadence}"` : input.cadence;
-                throw new errors_1.default.BadRequestError({
-                    message: 'Bad Request.',
-                    context: `Expected cadence to be "month" or "year", received ${receivedCadence}`,
-                });
-            }
-            cadence = input.cadence;
-        }
+        const resolvedDuration = (0, gift_checkout_offer_1.resolveGiftDuration)(input);
         let tier;
         try {
             tier = await this.deps.tiersService.api.read(input.tierId);
@@ -185,20 +152,15 @@ class GiftService {
                 message: 'This tier is archived.',
             });
         }
-        let duration = 1;
-        let totalMonths;
-        let amount = tier.getPrice(cadence);
-        if (resolvedDuration) {
-            const plan = (0, gift_checkout_offer_1.validateGiftCheckoutOffer)({
-                tier,
-                portalPlans: this.deps.settingsCache.get('portal_plans'),
-                offer: resolvedDuration,
-            });
-            cadence = plan.cadence;
-            duration = plan.duration;
-            totalMonths = plan.totalMonths;
-            amount = plan.amount;
-        }
+        const plan = (0, gift_checkout_offer_1.validateGiftCheckoutOffer)({
+            tier,
+            portalPlans: this.deps.settingsCache.get('portal_plans'),
+            offer: resolvedDuration,
+        });
+        const cadence = plan.cadence;
+        const duration = plan.duration;
+        const totalMonths = plan.totalMonths;
+        const amount = plan.amount;
         const tierId = typeof tier.id === 'string' ? tier.id : tier.id.toHexString();
         const token = this.generateToken();
         const successUrl = new URL(input.successUrl);

package/core/server/services/gifts/index.js

@@ -34,7 +34,6 @@ function init(options) {
     const MailgunClient = require('../lib/mailgun-client');
     const config = require('../../../shared/config');
     const settingsCache = require('../../../shared/settings-cache');
-    const labsService = require('../../../shared/labs');
     const urlUtils = require('../../../shared/url-utils').default;
     const settingsHelpers = require('../settings-helpers');
     const emailAddressParser = require('../email-address/email-address-parser');
@@ -110,7 +109,6 @@ function init(options) {
         },
         giftReminderScheduler,
         checkoutAdapter,
-        labsService,
         settingsCache,
     });
     exports.service = giftService;

package/core/server/services/jobs-service/index.js

@@ -10,6 +10,14 @@ const errors_1 = __importDefault(require("@tryghost/errors"));
 const jobs_service_1 = require("./jobs-service");
 let instance;
 function init() {
+    // The instance lives for the whole process: the didInit-guarded mentions
+    // service captures it in MentionController and MentionSendingService, so
+    // an in-process restart (test harness) must revive the same object rather
+    // than strand those references on a stopped queue.
+    if (instance) {
+        instance.clearHandlers();
+        return instance;
+    }
     const adapterManager = require('../adapter-manager').default;
     const logging = require('@tryghost/logging');
     const sentry = require('../../../shared/sentry');

package/core/server/services/jobs-service/jobs-service.js

@@ -11,12 +11,14 @@ class JobsService {
     #logging;
     #sentry;
     #registry = new Map();
+    #queueByType = new Map();
+    #queues = new Map();
     constructor({ backend, logging, sentry }) {
         this.#backend = backend;
         this.#logging = logging;
         this.#sentry = sentry;
     }
-    handle(JobClass, handler) {
+    handle(JobClass, handler, options) {
         const type = JobClass.type;
         if (typeof type !== 'string' || type.length === 0) {
             throw new errors_1.default.IncorrectUsageError({
@@ -28,14 +30,52 @@ class JobsService {
                 message: `A handler for job type "${type}" is already registered.`,
             });
         }
+        this.#declareQueue(type, options);
         this.#registry.set(type, (payload) => handler(new JobClass(JSON.parse(payload))));
     }
+    #declareQueue(type, options) {
+        if (!options) {
+            return;
+        }
+        const { queue, concurrency } = options;
+        if (typeof queue !== 'string' || queue.length === 0) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Invalid queue for job type "${type}": ${JSON.stringify(queue)}. Expected a non-empty string.`,
+            });
+        }
+        // "default" is the backend's shared lane for types that declare no queue;
+        // declaring it would silently re-size that lane for every unrouted type.
+        if (queue === 'default') {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Queue name "default" is reserved for the shared lane; job type "${type}" must omit options to use it.`,
+            });
+        }
+        if (!Number.isInteger(concurrency) || concurrency < 1) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Invalid concurrency for job type "${type}": ${JSON.stringify(concurrency)}. Expected a positive integer.`,
+            });
+        }
+        const existing = this.#queues.get(queue);
+        if (existing && existing.concurrency !== concurrency) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Conflicting concurrency for queue "${queue}": ${existing.concurrency} is already declared, job type "${type}" declares ${concurrency}.`,
+            });
+        }
+        this.#queues.set(queue, { concurrency });
+        this.#queueByType.set(type, queue);
+    }
+    #routingFor(type) {
+        const queue = this.#queueByType.get(type);
+        return queue === undefined ? undefined : { queue };
+    }
     async dispatch(job) {
-        await this.#backend.enqueue(this.#buildEnvelope(job));
+        const envelope = this.#buildEnvelope(job);
+        await this.#backend.enqueue(envelope, this.#routingFor(envelope.type));
     }
     async scheduleRecurring(job, schedule) {
         this.#assertValidCron(schedule.cron);
-        await this.#backend.scheduleRecurring(this.#buildEnvelope(job), schedule);
+        const envelope = this.#buildEnvelope(job);
+        await this.#backend.scheduleRecurring(envelope, schedule, this.#routingFor(envelope.type));
     }
     // later.parse.cron does not strictly validate: it silently coerces a
     // malformed expression into a bogus schedule (garbage -> every minute,
@@ -55,11 +95,20 @@ class JobsService {
     async start() {
         await this.#backend.start({
             processor: (envelope) => this.#process(envelope),
+            queues: Object.fromEntries(this.#queues),
         });
     }
     async shutdown(options) {
         await this.#backend.shutdown(options);
     }
+    // An in-process restart (test harness) re-runs handler registration on the
+    // same instance, so all registration state resets - handlers and queue
+    // declarations alike. The duplicate-type guard still holds within a boot.
+    clearHandlers() {
+        this.#registry.clear();
+        this.#queueByType.clear();
+        this.#queues.clear();
+    }
     #buildEnvelope(job) {
         return { type: this.#typeOf(job), payload: JSON.stringify(job) };
     }

package/core/server/services/jobs-service/register-job-handlers.js

@@ -45,8 +45,16 @@ const content_csv_import_job_1 = __importDefault(require("../content-import/jobs
 const contentImport = __importStar(require("../content-import"));
 const update_check_job_1 = __importDefault(require("../update-check/jobs/update-check-job"));
 const process_webmention_job_1 = __importDefault(require("../mentions/process-webmention-job"));
+const send_webmentions_job_1 = __importDefault(require("../mentions/send-webmentions-job"));
 const updateCheck = require('../update-check');
-function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInliner, mentionsController, }) {
+// Webmention processing fetches external pages and is triggered by
+// unauthenticated requests, so webmention jobs run in their own lane where a
+// flood cannot occupy the shared workers. The concurrency matches the old
+// dedicated mentions job queue. Every webmention job type must register with
+// this shared declaration so none can declare the queue with a different
+// concurrency.
+const WEBMENTIONS_QUEUE = { queue: 'webmentions', concurrency: 3 };
+function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInliner, mentionsController, mentionsSendingService, }) {
     jobsService.handle(clean_tokens_job_1.default, async () => {
         await memberJobs.cleanTokens();
     });
@@ -67,5 +75,8 @@ function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInline
     });
     jobsService.handle(process_webmention_job_1.default, async (job) => {
         await mentionsController.processWebmention(job);
-    });
+    }, WEBMENTIONS_QUEUE);
+    jobsService.handle(send_webmentions_job_1.default, async (job) => {
+        await mentionsSendingService.sendWebmentions(job);
+    }, WEBMENTIONS_QUEUE);
 }