@voyantjs/notifications 0.28.1 → 0.29.0

package/dist/service-reminders.js

@@ -1,26 +1,61 @@
 import { bookings, bookingTravelers } from "@voyantjs/bookings/schema";
 import { bookingPaymentSchedules, invoices, paymentSessions } from "@voyantjs/finance";
 import { and, asc, desc, eq, gt, or } from "drizzle-orm";
-import { notificationReminderRules, notificationReminderRuns } from "./schema.js";
+import { notificationReminderRules, notificationReminderRuns, notificationReminderStageChannels, } from "./schema.js";
 import { bookingDocumentNotificationsService, createDefaultBookingDocumentAttachment, } from "./service-booking-documents.js";
 import { sendInvoiceNotification, sendNotification } from "./service-deliveries.js";
-import { addUtcDays, buildReminderDedupeKey, listBookingNotificationItems, resolveReminderRecipient, startOfUtcDay, toDateString, toTimestamp, } from "./service-shared.js";
+import { applyQuietHours, evaluateStage, exceedsRecipientRateLimit, fetchTargetsForRule, getNotificationSettings, listActiveRulesByPriority, listChannelsForStage, listStagesForRule, loadHistory, suppressedByGroup, } from "./service-sequence.js";
+import { buildReminderDedupeKey, listBookingNotificationItems, resolveReminderRecipient, startOfUtcDay, toDateString, toTimestamp, } from "./service-shared.js";
 async function getBookingPaymentNotificationContext(db, bookingId) {
     const [[paymentSchedule], [invoice], [paymentSession]] = await Promise.all([
         db
-            .select()
+            .select({
+            id: bookingPaymentSchedules.id,
+            bookingId: bookingPaymentSchedules.bookingId,
+            scheduleType: bookingPaymentSchedules.scheduleType,
+            status: bookingPaymentSchedules.status,
+            dueDate: bookingPaymentSchedules.dueDate,
+            currency: bookingPaymentSchedules.currency,
+            amountCents: bookingPaymentSchedules.amountCents,
+            createdAt: bookingPaymentSchedules.createdAt,
+        })
             .from(bookingPaymentSchedules)
             .where(and(eq(bookingPaymentSchedules.bookingId, bookingId), or(eq(bookingPaymentSchedules.status, "pending"), eq(bookingPaymentSchedules.status, "due"))))
             .orderBy(asc(bookingPaymentSchedules.dueDate), asc(bookingPaymentSchedules.createdAt))
             .limit(1),
         db
-            .select()
+            .select({
+            id: invoices.id,
+            invoiceNumber: invoices.invoiceNumber,
+            invoiceType: invoices.invoiceType,
+            status: invoices.status,
+            currency: invoices.currency,
+            subtotalCents: invoices.subtotalCents,
+            taxCents: invoices.taxCents,
+            totalCents: invoices.totalCents,
+            paidCents: invoices.paidCents,
+            balanceDueCents: invoices.balanceDueCents,
+            issueDate: invoices.issueDate,
+            dueDate: invoices.dueDate,
+        })
             .from(invoices)
             .where(eq(invoices.bookingId, bookingId))
             .orderBy(desc(invoices.createdAt))
             .limit(1),
         db
-            .select()
+            .select({
+            id: paymentSessions.id,
+            status: paymentSessions.status,
+            provider: paymentSessions.provider,
+            currency: paymentSessions.currency,
+            amountCents: paymentSessions.amountCents,
+            redirectUrl: paymentSessions.redirectUrl,
+            returnUrl: paymentSessions.returnUrl,
+            cancelUrl: paymentSessions.cancelUrl,
+            expiresAt: paymentSessions.expiresAt,
+            paymentMethod: paymentSessions.paymentMethod,
+            externalReference: paymentSessions.externalReference,
+        })
             .from(paymentSessions)
             .where(eq(paymentSessions.bookingId, bookingId))
             .orderBy(desc(paymentSessions.createdAt))
@@ -121,9 +156,6 @@ function buildReminderQueueSummary() {
         failed: 0,
     };
 }
-function isRetryableReminderRun(run) {
-    return run?.status === "failed";
-}
 async function getReminderRuleById(db, reminderRuleId) {
     const [rule] = await db
         .select()
@@ -140,20 +172,6 @@ async function getReminderRunById(db, reminderRunId) {
         .limit(1);
     return run ?? null;
 }
-async function markReminderRunQueued(db, reminderRunId, now, recipient) {
-    const [run] = await db
-        .update(notificationReminderRuns)
-        .set({
-        status: "queued",
-        errorMessage: null,
-        recipient: recipient ?? undefined,
-        processedAt: now,
-        updatedAt: now,
-    })
-        .where(eq(notificationReminderRuns.id, reminderRunId))
-        .returning();
-    return run ?? null;
-}
 async function markReminderRunSkipped(db, reminderRunId, now, errorMessage) {
     const [run] = await db
         .update(notificationReminderRuns)
@@ -194,419 +212,33 @@ async function markReminderRunSent(db, reminderRunId, now, notificationDeliveryI
         .returning();
     return run ?? null;
 }
-async function enqueueReminderRun(db, enqueueDelivery, run, now) {
-    const queuedRun = await markReminderRunQueued(db, run.id, now, run.recipient);
-    if (!queuedRun) {
-        return null;
-    }
-    try {
-        await enqueueDelivery({ reminderRunId: queuedRun.id });
-        return queuedRun;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to enqueue reminder delivery";
-        return markReminderRunFailed(db, queuedRun.id, new Date(), message);
-    }
-}
-async function queueBookingPaymentScheduleReminder(db, enqueueDelivery, rule, schedule, now) {
-    const runDate = toDateString(startOfUtcDay(now));
-    const dedupeKey = buildReminderDedupeKey(rule.id, schedule.id, runDate);
-    const [existingRun] = await db
-        .select()
-        .from(notificationReminderRuns)
-        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
-        .limit(1);
-    if (existingRun && !isRetryableReminderRun(existingRun)) {
-        return null;
-    }
-    const [booking] = await db
-        .select()
-        .from(bookings)
-        .where(eq(bookings.id, schedule.bookingId))
-        .limit(1);
-    const reminderRun = existingRun && isRetryableReminderRun(existingRun)
-        ? existingRun
-        : ((await db
-            .insert(notificationReminderRuns)
-            .values({
-            reminderRuleId: rule.id,
-            targetType: rule.targetType,
-            targetId: schedule.id,
-            dedupeKey,
-            bookingId: schedule.bookingId,
-            personId: booking?.personId ?? null,
-            organizationId: booking?.organizationId ?? null,
-            paymentSessionId: null,
-            notificationDeliveryId: null,
-            status: "queued",
-            recipient: null,
-            scheduledFor: now,
-            processedAt: now,
-            errorMessage: null,
-            metadata: {
-                dueDate: schedule.dueDate,
-                relativeDaysFromDueDate: rule.relativeDaysFromDueDate,
-                bookingNumber: booking?.bookingNumber ?? null,
-            },
-        })
-            .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
-            .returning())[0] ?? null);
-    if (!reminderRun) {
-        return null;
-    }
-    if (!booking) {
-        return markReminderRunSkipped(db, reminderRun.id, now, "Booking not found for payment schedule");
-    }
-    const [participants] = await Promise.all([
-        db
-            .select({
-            id: bookingTravelers.id,
-            firstName: bookingTravelers.firstName,
-            lastName: bookingTravelers.lastName,
-            email: bookingTravelers.email,
-            participantType: bookingTravelers.participantType,
-            isPrimary: bookingTravelers.isPrimary,
-        })
-            .from(bookingTravelers)
-            .where(eq(bookingTravelers.bookingId, booking.id))
-            .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt),
-    ]);
-    const recipient = resolveReminderRecipient(booking, participants);
-    if (!recipient?.email) {
-        return markReminderRunSkipped(db, reminderRun.id, now, "No traveler email available for booking payment reminder");
-    }
-    return enqueueReminderRun(db, enqueueDelivery, { ...reminderRun, recipient: recipient.email }, now);
-}
-async function queueInvoiceReminder(db, enqueueDelivery, rule, invoice, now) {
-    const runDate = toDateString(startOfUtcDay(now));
-    const dedupeKey = buildReminderDedupeKey(rule.id, invoice.id, runDate);
-    const [existingRun] = await db
-        .select()
-        .from(notificationReminderRuns)
-        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
-        .limit(1);
-    if (existingRun && !isRetryableReminderRun(existingRun)) {
-        return null;
-    }
-    const [booking] = await db
-        .select()
-        .from(bookings)
-        .where(eq(bookings.id, invoice.bookingId))
-        .limit(1);
-    const reminderRun = existingRun && isRetryableReminderRun(existingRun)
-        ? existingRun
-        : ((await db
-            .insert(notificationReminderRuns)
-            .values({
-            reminderRuleId: rule.id,
-            targetType: "invoice",
-            targetId: invoice.id,
-            dedupeKey,
-            bookingId: invoice.bookingId,
-            personId: invoice.personId ?? booking?.personId ?? null,
-            organizationId: invoice.organizationId ?? booking?.organizationId ?? null,
-            paymentSessionId: null,
-            notificationDeliveryId: null,
-            status: "queued",
-            recipient: null,
-            scheduledFor: now,
-            processedAt: now,
-            errorMessage: null,
-            metadata: {
-                dueDate: invoice.dueDate,
-                relativeDaysFromDueDate: rule.relativeDaysFromDueDate,
-                bookingNumber: booking?.bookingNumber ?? null,
-                invoiceNumber: invoice.invoiceNumber,
-                invoiceType: invoice.invoiceType,
-            },
-        })
-            .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
-            .returning())[0] ?? null);
-    if (!reminderRun) {
-        return null;
-    }
-    if (!booking) {
-        return markReminderRunSkipped(db, reminderRun.id, now, "Booking not found for invoice reminder");
-    }
-    const [participants] = await Promise.all([
-        db
-            .select({
-            id: bookingTravelers.id,
-            firstName: bookingTravelers.firstName,
-            lastName: bookingTravelers.lastName,
-            email: bookingTravelers.email,
-            participantType: bookingTravelers.participantType,
-            isPrimary: bookingTravelers.isPrimary,
-        })
-            .from(bookingTravelers)
-            .where(eq(bookingTravelers.bookingId, booking.id))
-            .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt),
-    ]);
-    const recipient = resolveReminderRecipient(booking, participants);
-    if (!recipient?.email) {
-        return markReminderRunSkipped(db, reminderRun.id, now, "No traveler email available for invoice reminder");
-    }
-    return enqueueReminderRun(db, enqueueDelivery, { ...reminderRun, recipient: recipient.email }, now);
-}
-async function sendBookingPaymentScheduleReminder(db, dispatcher, rule, schedule, now) {
-    const runDate = toDateString(startOfUtcDay(now));
-    const dedupeKey = buildReminderDedupeKey(rule.id, schedule.id, runDate);
-    const [existingRun] = await db
-        .select({ id: notificationReminderRuns.id })
-        .from(notificationReminderRuns)
-        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
-        .limit(1);
-    if (existingRun) {
-        return null;
-    }
-    const [booking] = await db
-        .select()
-        .from(bookings)
-        .where(eq(bookings.id, schedule.bookingId))
-        .limit(1);
-    if (!booking) {
-        const [run] = await db
-            .insert(notificationReminderRuns)
-            .values({
-            reminderRuleId: rule.id,
-            targetType: rule.targetType,
-            targetId: schedule.id,
-            dedupeKey,
-            bookingId: schedule.bookingId,
-            personId: null,
-            organizationId: null,
-            paymentSessionId: null,
-            notificationDeliveryId: null,
-            status: "skipped",
-            recipient: null,
-            scheduledFor: now,
-            processedAt: now,
-            errorMessage: "Booking not found for payment schedule",
-            metadata: {
-                dueDate: schedule.dueDate,
-                relativeDaysFromDueDate: rule.relativeDaysFromDueDate,
-            },
-        })
-            .returning();
-        return run ?? null;
-    }
-    const [participants, items, paymentContext] = await Promise.all([
-        db
-            .select({
-            id: bookingTravelers.id,
-            firstName: bookingTravelers.firstName,
-            lastName: bookingTravelers.lastName,
-            email: bookingTravelers.email,
-            participantType: bookingTravelers.participantType,
-            isPrimary: bookingTravelers.isPrimary,
-        })
-            .from(bookingTravelers)
-            .where(eq(bookingTravelers.bookingId, booking.id))
-            .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt),
-        listBookingNotificationItems(db, booking.id),
-        getBookingPaymentNotificationContext(db, booking.id),
-    ]);
-    const recipient = resolveReminderRecipient(booking, participants);
-    const [processingRun] = await db
-        .insert(notificationReminderRuns)
-        .values({
-        reminderRuleId: rule.id,
-        targetType: rule.targetType,
-        targetId: schedule.id,
-        dedupeKey,
-        bookingId: booking.id,
-        personId: booking.personId ?? null,
-        organizationId: booking.organizationId ?? null,
-        paymentSessionId: null,
-        notificationDeliveryId: null,
-        status: "processing",
-        recipient: recipient?.email ?? null,
-        scheduledFor: now,
-        processedAt: now,
-        errorMessage: null,
-        metadata: {
-            dueDate: schedule.dueDate,
-            relativeDaysFromDueDate: rule.relativeDaysFromDueDate,
-            bookingNumber: booking.bookingNumber,
-        },
-    })
-        .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
-        .returning();
-    if (!processingRun) {
-        return null;
-    }
-    if (!recipient?.email) {
-        return markReminderRunSkipped(db, processingRun.id, now, "No traveler email available for booking payment reminder");
-    }
-    try {
-        const delivery = await sendNotification(db, dispatcher, {
-            templateId: rule.templateId ?? null,
-            templateSlug: rule.templateSlug ?? null,
-            channel: rule.channel,
-            provider: rule.provider ?? null,
-            to: recipient.email,
-            data: {
-                bookingId: booking.id,
-                bookingNumber: booking.bookingNumber,
-                dueDate: schedule.dueDate,
-                amountCents: schedule.amountCents,
-                currency: schedule.currency,
-                scheduleType: schedule.scheduleType,
-                reminderOffsetDays: rule.relativeDaysFromDueDate,
-                traveler: {
-                    firstName: recipient.firstName,
-                    lastName: recipient.lastName,
-                    email: recipient.email,
-                    participantType: recipient.participantType,
-                    isPrimary: recipient.isPrimary,
-                },
-                travelers: participants,
-                booking: {
-                    id: booking.id,
-                    bookingNumber: booking.bookingNumber,
-                    startDate: booking.startDate,
-                    endDate: booking.endDate,
-                    sellCurrency: booking.sellCurrency,
-                    sellAmountCents: booking.sellAmountCents,
-                },
-                ...serializeBookingPaymentContext(paymentContext, schedule),
-                items,
-            },
-            targetType: "booking_payment_schedule",
-            targetId: schedule.id,
-            bookingId: booking.id,
-            personId: booking.personId ?? null,
-            organizationId: booking.organizationId ?? null,
-            metadata: {
-                reminderRuleId: rule.id,
-                reminderRunId: processingRun.id,
-            },
-            scheduledFor: now.toISOString(),
-        });
-        return markReminderRunSent(db, processingRun.id, new Date(), delivery?.id ?? null);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Notification reminder failed";
-        return markReminderRunFailed(db, processingRun.id, new Date(), message);
-    }
-}
-async function sendInvoiceReminder(db, dispatcher, rule, invoice, now) {
-    const runDate = toDateString(startOfUtcDay(now));
-    const dedupeKey = buildReminderDedupeKey(rule.id, invoice.id, runDate);
-    const [existingRun] = await db
-        .select({ id: notificationReminderRuns.id })
-        .from(notificationReminderRuns)
-        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
-        .limit(1);
-    if (existingRun) {
-        return null;
-    }
-    const [booking] = await db
-        .select()
-        .from(bookings)
-        .where(eq(bookings.id, invoice.bookingId))
-        .limit(1);
-    if (!booking) {
-        const [run] = await db
-            .insert(notificationReminderRuns)
-            .values({
-            reminderRuleId: rule.id,
-            targetType: "invoice",
-            targetId: invoice.id,
-            dedupeKey,
-            bookingId: invoice.bookingId,
-            personId: invoice.personId ?? null,
-            organizationId: invoice.organizationId ?? null,
-            paymentSessionId: null,
-            notificationDeliveryId: null,
-            status: "skipped",
-            recipient: null,
-            scheduledFor: now,
-            processedAt: now,
-            errorMessage: "Booking not found for invoice reminder",
-            metadata: {
-                dueDate: invoice.dueDate,
-                relativeDaysFromDueDate: rule.relativeDaysFromDueDate,
-                invoiceNumber: invoice.invoiceNumber,
-                invoiceType: invoice.invoiceType,
-            },
-        })
-            .returning();
-        return run ?? null;
-    }
-    const [participants] = await Promise.all([
-        db
-            .select({
-            id: bookingTravelers.id,
-            firstName: bookingTravelers.firstName,
-            lastName: bookingTravelers.lastName,
-            email: bookingTravelers.email,
-            participantType: bookingTravelers.participantType,
-            isPrimary: bookingTravelers.isPrimary,
-        })
-            .from(bookingTravelers)
-            .where(eq(bookingTravelers.bookingId, booking.id))
-            .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt),
-    ]);
-    const recipient = resolveReminderRecipient(booking, participants);
-    const [processingRun] = await db
-        .insert(notificationReminderRuns)
-        .values({
-        reminderRuleId: rule.id,
-        targetType: "invoice",
-        targetId: invoice.id,
-        dedupeKey,
-        bookingId: booking.id,
-        personId: invoice.personId ?? booking.personId ?? null,
-        organizationId: invoice.organizationId ?? booking.organizationId ?? null,
-        paymentSessionId: null,
-        notificationDeliveryId: null,
-        status: "processing",
-        recipient: recipient?.email ?? null,
-        scheduledFor: now,
-        processedAt: now,
-        errorMessage: null,
-        metadata: {
-            dueDate: invoice.dueDate,
-            relativeDaysFromDueDate: rule.relativeDaysFromDueDate,
-            bookingNumber: booking.bookingNumber,
-            invoiceNumber: invoice.invoiceNumber,
-            invoiceType: invoice.invoiceType,
-        },
-    })
-        .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
-        .returning();
-    if (!processingRun) {
-        return null;
-    }
-    if (!recipient?.email) {
-        return markReminderRunSkipped(db, processingRun.id, now, "No traveler email available for invoice reminder");
-    }
-    try {
-        const delivery = await sendInvoiceNotification(db, dispatcher, invoice.id, {
-            templateId: rule.templateId ?? null,
-            templateSlug: rule.templateSlug ?? null,
-            channel: rule.channel,
-            provider: rule.provider ?? null,
-            to: recipient.email,
-            data: {
-                reminderOffsetDays: rule.relativeDaysFromDueDate,
-                reminderRunId: processingRun.id,
-            },
-            metadata: {
-                reminderRuleId: rule.id,
-                reminderRunId: processingRun.id,
-            },
-            scheduledFor: now.toISOString(),
-        });
-        return markReminderRunSent(db, processingRun.id, new Date(), delivery?.id ?? null);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Invoice reminder failed";
-        return markReminderRunFailed(db, processingRun.id, new Date(), message);
+async function resolveChannelOverride(db, run, rule) {
+    const stageChannelId = run.metadata && typeof run.metadata === "object"
+        ? run.metadata.stageChannelId
+        : undefined;
+    if (stageChannelId) {
+        const [stageChannel] = await db
+            .select()
+            .from(notificationReminderStageChannels)
+            .where(eq(notificationReminderStageChannels.id, stageChannelId))
+            .limit(1);
+        if (stageChannel) {
+            return {
+                channel: stageChannel.channel,
+                templateId: stageChannel.templateId ?? null,
+                templateSlug: stageChannel.templateSlug ?? null,
+                provider: stageChannel.provider ?? null,
+            };
+        }
     }
+    return {
+        channel: rule.channel,
+        templateId: rule.templateId ?? null,
+        templateSlug: rule.templateSlug ?? null,
+        provider: rule.provider ?? null,
+    };
 }
-async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rule, now) {
+async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rule, now, channelOverride) {
     const [schedule] = await db
         .select()
         .from(bookingPaymentSchedules)
@@ -616,7 +248,22 @@ async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rul
         return markReminderRunSkipped(db, run.id, now, "Booking payment schedule not found for reminder run");
     }
     const [booking] = await db
-        .select()
+        .select({
+        id: bookings.id,
+        bookingNumber: bookings.bookingNumber,
+        status: bookings.status,
+        personId: bookings.personId,
+        organizationId: bookings.organizationId,
+        contactFirstName: bookings.contactFirstName,
+        contactLastName: bookings.contactLastName,
+        contactEmail: bookings.contactEmail,
+        contactPhone: bookings.contactPhone,
+        contactPreferredLanguage: bookings.contactPreferredLanguage,
+        sellCurrency: bookings.sellCurrency,
+        sellAmountCents: bookings.sellAmountCents,
+        startDate: bookings.startDate,
+        endDate: bookings.endDate,
+    })
         .from(bookings)
         .where(eq(bookings.id, schedule.bookingId))
         .limit(1);
@@ -647,10 +294,10 @@ async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rul
     }
     try {
         const delivery = await sendNotification(db, dispatcher, {
-            templateId: rule.templateId ?? null,
-            templateSlug: rule.templateSlug ?? null,
-            channel: rule.channel,
-            provider: rule.provider ?? null,
+            templateId: channelOverride.templateId,
+            templateSlug: channelOverride.templateSlug,
+            channel: channelOverride.channel,
+            provider: channelOverride.provider,
             to: recipientEmail,
             data: {
                 bookingId: booking.id,
@@ -659,7 +306,6 @@ async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rul
                 amountCents: schedule.amountCents,
                 currency: schedule.currency,
                 scheduleType: schedule.scheduleType,
-                reminderOffsetDays: rule.relativeDaysFromDueDate,
                 traveler: traveler
                     ? {
                         firstName: traveler.firstName,
@@ -699,15 +345,14 @@ async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rul
         return markReminderRunFailed(db, run.id, new Date(), message);
     }
 }
-async function sendQueuedInvoiceReminder(db, dispatcher, run, rule, now) {
+async function sendQueuedInvoiceReminder(db, dispatcher, run, rule, now, channelOverride) {
     const delivery = await sendInvoiceNotification(db, dispatcher, run.targetId, {
-        templateId: rule.templateId ?? null,
-        templateSlug: rule.templateSlug ?? null,
-        channel: rule.channel,
-        provider: rule.provider ?? null,
+        templateId: channelOverride.templateId,
+        templateSlug: channelOverride.templateSlug,
+        channel: channelOverride.channel,
+        provider: channelOverride.provider,
         to: run.recipient ?? undefined,
         data: {
-            reminderOffsetDays: rule.relativeDaysFromDueDate,
             reminderRunId: run.id,
         },
         metadata: {
@@ -893,59 +538,7 @@ export async function bookingIsPaidInFullForNotification(db, bookingId) {
     return !(await hasOutstandingBookingBalance(db, bookingId));
 }
 export async function queueDueReminders(db, input = {}, enqueueDelivery) {
-    const now = toTimestamp(input.now) ?? new Date();
-    const today = startOfUtcDay(now);
-    const activeRules = await db
-        .select()
-        .from(notificationReminderRules)
-        .where(eq(notificationReminderRules.status, "active"))
-        .orderBy(notificationReminderRules.createdAt);
-    const summary = buildReminderQueueSummary();
-    for (const rule of activeRules) {
-        const matchingDueDate = toDateString(addUtcDays(today, -rule.relativeDaysFromDueDate));
-        if (rule.targetType === "booking_payment_schedule") {
-            const schedules = await db
-                .select()
-                .from(bookingPaymentSchedules)
-                .where(and(eq(bookingPaymentSchedules.dueDate, matchingDueDate), or(eq(bookingPaymentSchedules.status, "pending"), eq(bookingPaymentSchedules.status, "due"))))
-                .orderBy(bookingPaymentSchedules.createdAt);
-            for (const schedule of schedules) {
-                const run = await queueBookingPaymentScheduleReminder(db, enqueueDelivery, rule, schedule, now);
-                if (!run) {
-                    continue;
-                }
-                summary.processed += 1;
-                if (run.status === "queued")
-                    summary.queued += 1;
-                if (run.status === "skipped")
-                    summary.skipped += 1;
-                if (run.status === "failed")
-                    summary.failed += 1;
-            }
-            continue;
-        }
-        if (rule.targetType === "invoice") {
-            const dueInvoices = await db
-                .select()
-                .from(invoices)
-                .where(and(eq(invoices.dueDate, matchingDueDate), gt(invoices.balanceDueCents, 0), or(eq(invoices.invoiceType, "invoice"), eq(invoices.invoiceType, "proforma")), or(eq(invoices.status, "sent"), eq(invoices.status, "partially_paid"), eq(invoices.status, "overdue"))))
-                .orderBy(invoices.createdAt);
-            for (const invoice of dueInvoices) {
-                const run = await queueInvoiceReminder(db, enqueueDelivery, rule, invoice, now);
-                if (!run) {
-                    continue;
-                }
-                summary.processed += 1;
-                if (run.status === "queued")
-                    summary.queued += 1;
-                if (run.status === "skipped")
-                    summary.skipped += 1;
-                if (run.status === "failed")
-                    summary.failed += 1;
-            }
-        }
-    }
-    return summary;
+    return queueStageBasedDueReminders(db, enqueueDelivery, input);
 }
 export async function deliverReminderRun(db, dispatcher, input) {
     const now = new Date();
@@ -970,12 +563,13 @@ export async function deliverReminderRun(db, dispatcher, input) {
     if (!rule) {
         return markReminderRunFailed(db, run.id, new Date(), "Reminder rule not found");
     }
+    const channelOverride = await resolveChannelOverride(db, run, rule);
     try {
         if (run.targetType === "booking_payment_schedule") {
-            return await sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rule, now);
+            return await sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rule, now, channelOverride);
         }
         if (run.targetType === "invoice") {
-            return await sendQueuedInvoiceReminder(db, dispatcher, run, rule, now);
+            return await sendQueuedInvoiceReminder(db, dispatcher, run, rule, now, channelOverride);
         }
         return markReminderRunSkipped(db, run.id, now, "Unsupported reminder target type");
     }
@@ -985,57 +579,310 @@ export async function deliverReminderRun(db, dispatcher, input) {
     }
 }
 export async function runDueReminders(db, dispatcher, input = {}) {
-    const now = toTimestamp(input.now) ?? new Date();
-    const today = startOfUtcDay(now);
-    const activeRules = await db
+    return runStageBasedDueReminders(db, dispatcher, input);
+}
+function buildStageDedupeKey(ruleId, targetId, runDate, stageId, channel) {
+    return `${ruleId}:${targetId}:${runDate}:${stageId}:${channel}`;
+}
+async function fetchScheduleRow(db, scheduleId) {
+    const [row] = await db
         .select()
-        .from(notificationReminderRules)
-        .where(eq(notificationReminderRules.status, "active"))
-        .orderBy(notificationReminderRules.createdAt);
-    const summary = buildReminderSweepSummary();
-    for (const rule of activeRules) {
-        const matchingDueDate = toDateString(addUtcDays(today, -rule.relativeDaysFromDueDate));
-        if (rule.targetType === "booking_payment_schedule") {
-            const schedules = await db
-                .select()
-                .from(bookingPaymentSchedules)
-                .where(and(eq(bookingPaymentSchedules.dueDate, matchingDueDate), or(eq(bookingPaymentSchedules.status, "pending"), eq(bookingPaymentSchedules.status, "due"))))
-                .orderBy(bookingPaymentSchedules.createdAt);
-            for (const schedule of schedules) {
-                const run = await sendBookingPaymentScheduleReminder(db, dispatcher, rule, schedule, now);
-                if (!run) {
-                    continue;
-                }
-                summary.processed += 1;
-                if (run.status === "sent")
-                    summary.sent += 1;
-                if (run.status === "skipped")
-                    summary.skipped += 1;
-                if (run.status === "failed")
-                    summary.failed += 1;
+        .from(bookingPaymentSchedules)
+        .where(eq(bookingPaymentSchedules.id, scheduleId))
+        .limit(1);
+    return row ?? null;
+}
+async function fetchInvoiceRow(db, invoiceId) {
+    const [row] = await db.select().from(invoices).where(eq(invoices.id, invoiceId)).limit(1);
+    return row ?? null;
+}
+async function emitStageChannelRun(db, dispatcher, rule, stage, channelRow, target, recipient, scheduledAt, sendCountAtFire, enqueueDelivery, now) {
+    const runDate = toDateString(startOfUtcDay(scheduledAt));
+    const dedupeKey = buildStageDedupeKey(rule.id, target.id, runDate, stage.id, channelRow.channel);
+    const [existingRun] = await db
+        .select()
+        .from(notificationReminderRuns)
+        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
+        .limit(1);
+    if (existingRun && existingRun.status !== "failed") {
+        return { status: "skipped", runId: existingRun.id };
+    }
+    const baseValues = {
+        reminderRuleId: rule.id,
+        targetType: rule.targetType,
+        targetId: target.id,
+        dedupeKey,
+        bookingId: target.bookingId,
+        personId: null,
+        organizationId: null,
+        paymentSessionId: null,
+        notificationDeliveryId: null,
+        recipient: recipient?.email ?? null,
+        scheduledFor: scheduledAt,
+        processedAt: now,
+        errorMessage: null,
+        metadata: {
+            stageId: stage.id,
+            stageOrderIndex: stage.orderIndex,
+            stageChannelId: channelRow.id,
+            channel: channelRow.channel,
+            anchor: stage.anchor,
+            sendCountAtFire,
+            ruleSlug: rule.slug,
+        },
+    };
+    if (!recipient?.email) {
+        const [run] = existingRun
+            ? await db
+                .update(notificationReminderRuns)
+                .set({ ...baseValues, status: "skipped", errorMessage: "no_recipient" })
+                .where(eq(notificationReminderRuns.id, existingRun.id))
+                .returning()
+            : await db
+                .insert(notificationReminderRuns)
+                .values({ ...baseValues, status: "skipped", errorMessage: "no_recipient" })
+                .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+                .returning();
+        return { status: "skipped", runId: run?.id ?? null };
+    }
+    if (enqueueDelivery && !dispatcher) {
+        const [queuedRun] = existingRun
+            ? await db
+                .update(notificationReminderRuns)
+                .set({ ...baseValues, status: "queued" })
+                .where(eq(notificationReminderRuns.id, existingRun.id))
+                .returning()
+            : await db
+                .insert(notificationReminderRuns)
+                .values({ ...baseValues, status: "queued" })
+                .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+                .returning();
+        if (!queuedRun)
+            return { status: "skipped", runId: null };
+        try {
+            await enqueueDelivery({ reminderRunId: queuedRun.id });
+            return { status: "queued", runId: queuedRun.id };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "enqueue_failed";
+            const failed = await markReminderRunFailed(db, queuedRun.id, new Date(), message);
+            return { status: "failed", runId: failed?.id ?? null };
+        }
+    }
+    if (!dispatcher) {
+        return { status: "skipped", runId: null };
+    }
+    const [processingRun] = existingRun
+        ? await db
+            .update(notificationReminderRuns)
+            .set({ ...baseValues, status: "processing" })
+            .where(eq(notificationReminderRuns.id, existingRun.id))
+            .returning()
+        : await db
+            .insert(notificationReminderRuns)
+            .values({ ...baseValues, status: "processing" })
+            .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+            .returning();
+    if (!processingRun) {
+        return { status: "skipped", runId: null };
+    }
+    try {
+        const data = {
+            reminderRuleId: rule.id,
+            reminderRunId: processingRun.id,
+            stageId: stage.id,
+            stageOrderIndex: stage.orderIndex,
+            sendCountAtFire,
+        };
+        let delivery = null;
+        if (rule.targetType === "invoice") {
+            const invoice = await fetchInvoiceRow(db, target.id);
+            if (!invoice) {
+                return {
+                    status: "skipped",
+                    runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), "invoice_not_found"))
+                        ?.id ?? null,
+                };
+            }
+            delivery = await sendInvoiceNotification(db, dispatcher, invoice.id, {
+                templateId: channelRow.templateId ?? null,
+                templateSlug: channelRow.templateSlug ?? null,
+                channel: channelRow.channel,
+                provider: channelRow.provider ?? null,
+                to: recipient.email,
+                data,
+                metadata: { reminderRuleId: rule.id, reminderRunId: processingRun.id, stageId: stage.id },
+                scheduledFor: scheduledAt.toISOString(),
+            });
+        }
+        else if (rule.targetType === "booking_payment_schedule") {
+            const schedule = await fetchScheduleRow(db, target.id);
+            if (!schedule) {
+                return {
+                    status: "skipped",
+                    runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), "schedule_not_found"))
+                        ?.id ?? null,
+                };
             }
+            delivery = await sendNotification(db, dispatcher, {
+                templateId: channelRow.templateId ?? null,
+                templateSlug: channelRow.templateSlug ?? null,
+                channel: channelRow.channel,
+                provider: channelRow.provider ?? null,
+                to: recipient.email,
+                data: {
+                    ...data,
+                    bookingId: schedule.bookingId,
+                    dueDate: schedule.dueDate,
+                    amountCents: schedule.amountCents,
+                    currency: schedule.currency,
+                },
+                targetType: "booking_payment_schedule",
+                targetId: schedule.id,
+                bookingId: schedule.bookingId,
+                metadata: { reminderRuleId: rule.id, reminderRunId: processingRun.id, stageId: stage.id },
+                scheduledFor: scheduledAt.toISOString(),
+            });
+        }
+        else {
+            return {
+                status: "skipped",
+                runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), "unsupported_target_type"))?.id ?? null,
+            };
+        }
+        const sent = await markReminderRunSent(db, processingRun.id, new Date(), delivery?.id ?? null);
+        return { status: "sent", runId: sent?.id ?? null };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "delivery_failed";
+        const failed = await markReminderRunFailed(db, processingRun.id, new Date(), message);
+        return { status: "failed", runId: failed?.id ?? null };
+    }
+}
+async function processStageRuleTargets(db, options) {
+    const tally = { processed: 0, sent: 0, queued: 0, skipped: 0, failed: 0 };
+    for (const target of options.targets) {
+        const history = await loadHistory(db, options.rule.id, target.id);
+        const decision = evaluateStage(options.rule, options.stages, target, history, options.today);
+        if (!decision.fire)
+            continue;
+        const channels = await listChannelsForStage(db, decision.stage.id);
+        if (channels.length === 0)
+            continue;
+        const booking = target.bookingId
+            ? ((await db
+                .select({
+                id: bookings.id,
+                bookingNumber: bookings.bookingNumber,
+                personId: bookings.personId,
+                organizationId: bookings.organizationId,
+                contactFirstName: bookings.contactFirstName,
+                contactLastName: bookings.contactLastName,
+                contactEmail: bookings.contactEmail,
+                contactPhone: bookings.contactPhone,
+                contactPreferredLanguage: bookings.contactPreferredLanguage,
+            })
+                .from(bookings)
+                .where(eq(bookings.id, target.bookingId))
+                .limit(1))[0] ?? null)
+            : null;
+        const participants = booking
+            ? await db
+                .select({
+                id: bookingTravelers.id,
+                firstName: bookingTravelers.firstName,
+                lastName: bookingTravelers.lastName,
+                email: bookingTravelers.email,
+                participantType: bookingTravelers.participantType,
+                isPrimary: bookingTravelers.isPrimary,
+            })
+                .from(bookingTravelers)
+                .where(eq(bookingTravelers.bookingId, booking.id))
+                .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt)
+            : [];
+        const recipient = booking ? resolveReminderRecipient(booking, participants) : null;
+        if (await suppressedByGroup(db, recipient?.email ?? null, options.rule.suppressionGroup, options.settings, options.now)) {
+            tally.skipped += 1;
             continue;
         }
-        if (rule.targetType === "invoice") {
-            const dueInvoices = await db
-                .select()
-                .from(invoices)
-                .where(and(eq(invoices.dueDate, matchingDueDate), gt(invoices.balanceDueCents, 0), or(eq(invoices.invoiceType, "invoice"), eq(invoices.invoiceType, "proforma")), or(eq(invoices.status, "sent"), eq(invoices.status, "partially_paid"), eq(invoices.status, "overdue"))))
-                .orderBy(invoices.createdAt);
-            for (const invoice of dueInvoices) {
-                const run = await sendInvoiceReminder(db, dispatcher, rule, invoice, now);
-                if (!run) {
-                    continue;
-                }
-                summary.processed += 1;
-                if (run.status === "sent")
-                    summary.sent += 1;
-                if (run.status === "skipped")
-                    summary.skipped += 1;
-                if (run.status === "failed")
-                    summary.failed += 1;
+        const { scheduledAt } = applyQuietHours(options.now, decision.stage, options.settings);
+        for (const channelRow of channels) {
+            if (recipient?.email &&
+                (await exceedsRecipientRateLimit(db, recipient.email, channelRow.channel, options.settings, options.now))) {
+                tally.skipped += 1;
+                continue;
             }
+            const result = await emitStageChannelRun(db, options.dispatcher, options.rule, decision.stage, channelRow, target, recipient ?? null, scheduledAt, decision.sendCountAtFire, options.enqueueDelivery, options.now);
+            tally.processed += 1;
+            if (result.status === "sent")
+                tally.sent += 1;
+            if (result.status === "queued")
+                tally.queued += 1;
+            if (result.status === "skipped")
+                tally.skipped += 1;
+            if (result.status === "failed")
+                tally.failed += 1;
         }
     }
+    return tally;
+}
+export async function runStageBasedDueReminders(db, dispatcher, input = {}) {
+    const now = toTimestamp(input.now) ?? new Date();
+    const today = startOfUtcDay(now);
+    const settings = await getNotificationSettings(db);
+    const rules = await listActiveRulesByPriority(db);
+    const summary = buildReminderSweepSummary();
+    for (const rule of rules) {
+        const stages = await listStagesForRule(db, rule.id);
+        if (stages.length === 0)
+            continue;
+        const targets = await fetchTargetsForRule(db, rule, stages, today);
+        if (targets.length === 0)
+            continue;
+        const tally = await processStageRuleTargets(db, {
+            rule,
+            stages,
+            targets,
+            settings,
+            today,
+            now,
+            dispatcher,
+            enqueueDelivery: null,
+        });
+        summary.processed += tally.processed;
+        summary.sent += tally.sent;
+        summary.skipped += tally.skipped;
+        summary.failed += tally.failed;
+    }
+    return summary;
+}
+export async function queueStageBasedDueReminders(db, enqueueDelivery, input = {}) {
+    const now = toTimestamp(input.now) ?? new Date();
+    const today = startOfUtcDay(now);
+    const settings = await getNotificationSettings(db);
+    const rules = await listActiveRulesByPriority(db);
+    const summary = buildReminderQueueSummary();
+    for (const rule of rules) {
+        const stages = await listStagesForRule(db, rule.id);
+        if (stages.length === 0)
+            continue;
+        const targets = await fetchTargetsForRule(db, rule, stages, today);
+        if (targets.length === 0)
+            continue;
+        const tally = await processStageRuleTargets(db, {
+            rule,
+            stages,
+            targets,
+            settings,
+            today,
+            now,
+            dispatcher: null,
+            enqueueDelivery,
+        });
+        summary.processed += tally.processed;
+        summary.queued += tally.queued;
+        summary.skipped += tally.skipped;
+        summary.failed += tally.failed;
+    }
     return summary;
 }