@aglyn/plugins-outreach 1.0.0-beta.143

package/src/lib/runtime/send-job.js

@@ -0,0 +1,780 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { consentGroupForHost } from "@aglyn/aglyn/app-utils/consent-groups";
+import { CRM_COLLECTIONS } from "@aglyn/aglyn/app-utils/crm";
+import { normalizeCrmEmailTemplate } from "@aglyn/aglyn/app-utils/crm-email-templates";
+import { randomUUID } from "node:crypto";
+import { composeOutreachEmail } from "../engine/compose.js";
+import { planOutreachStepCompletion } from "../engine/enrollment-state.js";
+import { evaluateOutreachGates } from "../engine/gates.js";
+import { outreachSentToday, outreachTickAllowance, selectDueOutreachEnrollments } from "../engine/sending-capacity.js";
+import { readOutreachEnrollCandidates } from "../enrollment/enroll-people.js";
+import { readOutreachGateLookups } from "../enrollment/gate-lookups.js";
+import { mailboxRef } from "../mailboxes/mailbox-credentials.js";
+import { outreachEffectiveDailyCap, outreachLocalDay } from "../mailboxes/mailbox-settings.js";
+import { markOutreachMailboxReconnectRequired } from "../mailboxes/mailbox-transport.js";
+import { effectiveOutreachAllowedCountries } from "../model/compliance-settings.js";
+import { OUTREACH_COLLECTIONS } from "../model/outreach.types.js";
+import { readOutreachComplianceSettingsDoc } from "../storage/compliance-settings-store.js";
+import { outreachOrgCollection, readStoredOutreachEnrollment, readStoredOutreachMailbox, readStoredOutreachSequence } from "../storage/outreach-records.js";
+import { GmailTransportError, isReconnectRequired } from "../transport/gmail-errors.js";
+import { Rfc5322MessageError } from "../transport/rfc5322.js";
+import { sendComposedOutreachEmail } from "../transport/send-message.js";
+import { applyOutreachEvent } from "./enrollment-events.js";
+import { outreachSendDigest, withRecentSend } from "./mailbox-health-store.js";
+import { fileOutreachEmail, fileOutreachTask, OUTREACH_TASK_KIND_TO_RECORD } from "./timeline.js";
+import { outreachUnsubscribeMailbox } from "./unsubscribe-link.js";
+/*==========================================
+ * THE SEND JOB (AGL-2981): every fifteen minutes, on the console.
+ *
+ * ## What comes due
+ *
+ * One collection-group read finds every active enrollment whose next step
+ * is due, oldest first, bounded per run. They are grouped by workspace and
+ * mailbox, and each group is judged before anything is sent:
+ *
+ * - the workspace: Outreach switched on, entitled and released to it;
+ * - the mailbox: an enrollment whose mailbox is gone, disconnected, or whose
+ *   member left the organization is STOPPED — nothing will ever send it, and
+ *   leaving it active would show a sequence that is not running. A paused
+ *   mailbox, or one waiting to be reconnected, holds its enrollments;
+ * - the member it sends as: a lockdown of the platform, the workspace or the
+ *   member holds everything.
+ *
+ * ## How much goes
+ *
+ * The engine's per-run allowance — the day's cap and ramp, spread across
+ * the window, at most five a run — picks the enrollments (follow-ups first);
+ * a task step is due whenever its time comes and spends no allowance.
+ *
+ * ## One send, exactly once
+ *
+ * Each email is CLAIMED before it is sent: a transaction over the enrollment
+ * and its mailbox checks the enrollment is still active on the same step
+ * with no live claim, and that the mailbox's day has room under its cap,
+ * then writes the claim and reserves the day's count. Two runs racing for
+ * one enrollment write one claim; two racing for one mailbox's last slot
+ * reserve it once. The claim carries the `Message-ID` minted for the send,
+ * so a claim a run died holding is settled by finding the message in the
+ * mailbox rather than by sending it a second time. A send that fails hands
+ * its reservation back.
+ *
+ * Before it is claimed, every gate is asked again — the do-not-contact
+ * list, the suppression lists, the sales topic, the roster, the other
+ * sequences — because a person enrolled on Monday can unsubscribe by
+ * Thursday. A lookup that could not be made holds the send; a gate that
+ * refuses stops the enrollment, saying why.
+ *==========================================*/ export { OUTREACH_SEND_JOB_ID } from "../constants/runtime-jobs.js";
+/** The most due enrollments one run reads. */ export const OUTREACH_SEND_SCAN_LIMIT = 300;
+/** How long a claim holds before a later run settles it. */ export const OUTREACH_CLAIM_STALE_MS = 10 * 60000;
+const blankReport = ()=>({
+        due: 0,
+        sent: 0,
+        tasks: 0,
+        stopped: 0,
+        failed: 0,
+        held: 0,
+        recovered: 0
+    });
+/** Runs the send job once — see the module note. */ export async function runOutreachSendJob(deps, context) {
+    const firestore = deps.firestore();
+    const report = blankReport();
+    const due = await firestore.collectionGroup(OUTREACH_COLLECTIONS.enrollments).where('status', '==', 'active').where('nextDueAtMs', '<=', context.nowMs).orderBy('nextDueAtMs').limit(OUTREACH_SEND_SCAN_LIMIT).get();
+    report.due = due.size;
+    const byOrg = new Map();
+    for (const doc of due.docs){
+        var _byOrg_get, _mailboxes_get;
+        var _doc_ref_parent_parent;
+        const orgId = (_doc_ref_parent_parent = doc.ref.parent.parent) == null ? void 0 : _doc_ref_parent_parent.id;
+        const enrollment = readStoredOutreachEnrollment(doc.id, doc.data());
+        if (!orgId || !enrollment) continue;
+        const mailboxes = (_byOrg_get = byOrg.get(orgId)) != null ? _byOrg_get : new Map();
+        mailboxes.set(enrollment.mailboxId, [
+            ...(_mailboxes_get = mailboxes.get(enrollment.mailboxId)) != null ? _mailboxes_get : [],
+            enrollment
+        ]);
+        byOrg.set(orgId, mailboxes);
+    }
+    for (const [orgId, mailboxes] of byOrg){
+        const waiting = [
+            ...mailboxes.values()
+        ].reduce((sum, list)=>sum + list.length, 0);
+        if (deps.now() >= context.deadlineMs) {
+            report.held += waiting;
+            continue;
+        }
+        const orgSnapshot = await firestore.collection('orgs').doc(orgId).get();
+        const org = orgSnapshot.exists ? orgSnapshot.data() : null;
+        if (!org || await deps.orgRefusal(orgId, org)) {
+            report.held += waiting;
+            continue;
+        }
+        const settings = await readOutreachComplianceSettingsDoc(firestore, orgId);
+        for (const [mailboxId, enrollments] of mailboxes){
+            await runMailbox(deps, firestore, {
+                orgId,
+                org,
+                mailboxId,
+                enrollments,
+                settings,
+                report,
+                context
+            });
+        }
+    }
+    return report;
+}
+/** The reason an unusable mailbox stops an enrollment, or `null` for a usable one. */ async function unusableMailbox(firestore, orgId, mailbox) {
+    if (!mailbox) return 'The mailbox this sequence sends from was removed.';
+    if (mailbox.status === 'disconnected') return 'The mailbox this sequence sends from was disconnected.';
+    const member = await firestore.collection('orgs').doc(orgId).collection('members').doc(mailbox.connectedByUid).get();
+    return member.exists ? null : 'The member who connected the mailbox this sequence sends from is no longer in the organization.';
+}
+async function runMailbox(deps, firestore, input) {
+    const { orgId, org, report, context } = input;
+    const nowMs = context.nowMs;
+    const snapshot = await mailboxRef(firestore, orgId, input.mailboxId).get();
+    const mailbox = readStoredOutreachMailbox(input.mailboxId, snapshot.exists ? snapshot.data() : undefined);
+    const unusable = await unusableMailbox(firestore, orgId, mailbox);
+    if (unusable || !mailbox) {
+        for (const enrollment of input.enrollments){
+            const outcome = await applyOutreachEvent(firestore, {
+                orgId,
+                enrollmentId: enrollment.id,
+                event: {
+                    type: 'stop',
+                    atMs: nowMs,
+                    byUid: null,
+                    reason: 'gate',
+                    detail: unusable
+                },
+                nowMs
+            });
+            if (outcome.changed) report.stopped += 1;
+        }
+        return;
+    }
+    if (mailbox.status !== 'connected' || await deps.sendRefusal({
+        orgId,
+        org,
+        uid: mailbox.connectedByUid
+    })) {
+        report.held += input.enrollments.length;
+        return;
+    }
+    const run = {
+        orgId,
+        org,
+        mailbox,
+        settings: input.settings,
+        report,
+        deadlineMs: context.deadlineMs,
+        opened: null,
+        stopped: false,
+        templates: new Map()
+    };
+    const sequenceIds = [
+        ...new Set(input.enrollments.map((enrollment)=>enrollment.sequenceId))
+    ];
+    const sequenceSnapshots = await firestore.getAll(...sequenceIds.map((id)=>outreachOrgCollection(firestore, orgId, 'sequences').doc(id)));
+    const sequences = new Map();
+    sequenceSnapshots.forEach((sequenceSnapshot, index)=>{
+        const sequence = readStoredOutreachSequence(sequenceIds[index], sequenceSnapshot.exists ? sequenceSnapshot.data() : undefined);
+        if (sequence) sequences.set(sequence.id, sequence);
+    });
+    const candidates = [];
+    for (const enrollment of input.enrollments){
+        const sequence = sequences.get(enrollment.sequenceId);
+        const claim = enrollment.sendClaim;
+        if (claim && nowMs - claim.atMs < OUTREACH_CLAIM_STALE_MS) continue;
+        if (claim && sequence) {
+            if (await recoverClaim(deps, firestore, run, enrollment, sequence)) report.recovered += 1;
+            continue;
+        }
+        if (sequence) candidates.push({
+            enrollment,
+            sequence
+        });
+    }
+    const allowance = outreachTickAllowance({
+        mailbox,
+        nowMs
+    });
+    const selection = selectDueOutreachEnrollments({
+        candidates,
+        mailbox,
+        nowMs,
+        allowance: allowance.allowance
+    });
+    report.held += selection.deferred.length;
+    for (const candidate of selection.tasks){
+        if (deps.now() >= context.deadlineMs) {
+            report.held += 1;
+            continue;
+        }
+        if (await runTaskStep(deps, firestore, run, candidate)) report.tasks += 1;
+    }
+    if (!selection.emails.length) return;
+    // The people behind the emails, read once per site: the contact and its
+    // company, and every lookup the gates decide on.
+    const people = new Map();
+    const lookups = new Map();
+    const byHost = new Map();
+    for (const candidate of selection.emails){
+        var _byHost_get;
+        const enrollment = candidate.enrollment;
+        byHost.set(enrollment.hostId, [
+            ...(_byHost_get = byHost.get(enrollment.hostId)) != null ? _byHost_get : [],
+            enrollment
+        ]);
+    }
+    const siteNames = new Map();
+    for (const [hostId, enrollments] of byHost){
+        var _host_get;
+        const contactGroupId = consentGroupForHost(org, hostId).groupId;
+        const [candidatesRead, lookupsRead, host] = await Promise.all([
+            readOutreachEnrollCandidates(firestore, {
+                orgId,
+                hostId,
+                contactGroupId,
+                contactIds: enrollments.map((enrollment)=>enrollment.contactId)
+            }),
+            readOutreachGateLookups(firestore, {
+                orgId,
+                hostId,
+                people: enrollments.map((enrollment)=>({
+                        contactId: enrollment.contactId,
+                        email: enrollment.email
+                    }))
+            }),
+            firestore.collection('hosts').doc(hostId).get()
+        ]);
+        for (const person of candidatesRead)people.set(person.contactId, person);
+        for (const [contactId, answer] of lookupsRead)lookups.set(contactId, answer);
+        siteNames.set(hostId, host.exists ? String((_host_get = host.get('name')) != null ? _host_get : '') : '');
+    }
+    for (const candidate of selection.emails){
+        var _people_get, _lookups_get, _siteNames_get;
+        if (run.stopped || deps.now() >= context.deadlineMs) {
+            report.held += 1;
+            continue;
+        }
+        const enrollment = candidate.enrollment;
+        await runEmailStep(deps, firestore, run, {
+            enrollment,
+            sequence: candidate.sequence,
+            person: (_people_get = people.get(enrollment.contactId)) != null ? _people_get : null,
+            lookups: (_lookups_get = lookups.get(enrollment.contactId)) != null ? _lookups_get : null,
+            siteName: (_siteNames_get = siteNames.get(enrollment.hostId)) != null ? _siteNames_get : ''
+        });
+    }
+}
+/** Any lookup the runtime could not make: the send waits for a run that can. */ function uncheckable(lookups) {
+    return !lookups || Object.values(lookups).some((value)=>value === null);
+}
+/** The event a gate's refusal ends an enrollment with. */ function gateEvent(blocks, atMs) {
+    const optedOut = blocks.find((block)=>block.code === 'do_not_contact' || block.code === 'sales_opted_out');
+    if (optedOut) return {
+        type: 'opt_out',
+        atMs,
+        reason: 'do_not_contact',
+        detail: optedOut.reason
+    };
+    return {
+        type: 'stop',
+        atMs,
+        byUid: null,
+        reason: 'gate',
+        detail: blocks.map((block)=>block.reason).join(' ')
+    };
+}
+/** The sender line a mailbox's mail goes out with. */ const senderOf = (mailbox)=>({
+        address: mailbox.sendAs || mailbox.email,
+        name: mailbox.displayName || null
+    });
+async function openClient(deps, firestore, run) {
+    var _run, _opened;
+    const opened = (_opened = (_run = run).opened) != null ? _opened : _run.opened = await deps.openMailbox(run.mailbox.id);
+    if (opened.ok === true) return opened.client;
+    run.stopped = true;
+    if (opened.reason !== 'not-configured') {
+        await markOutreachMailboxReconnectRequired(firestore, {
+            orgId: run.orgId,
+            mailboxId: run.mailbox.id,
+            errorCode: opened.reason,
+            nowMs: deps.now()
+        });
+    }
+    return null;
+}
+/**
+ * Claims one step: the enrollment still active on the same step with no
+ * live claim, and — for an email — a slot under the mailbox's cap today,
+ * reserved in the same transaction.
+ */ async function claimStep(deps, firestore, run, enrollment, messageId) {
+    const enrollmentRef = outreachOrgCollection(firestore, run.orgId, 'enrollments').doc(enrollment.id);
+    const boxRef = mailboxRef(firestore, run.orgId, run.mailbox.id);
+    const nowMs = deps.now();
+    return firestore.runTransaction(async (transaction)=>{
+        const [current, box] = await Promise.all([
+            transaction.get(enrollmentRef),
+            transaction.get(boxRef)
+        ]);
+        const stored = readStoredOutreachEnrollment(enrollment.id, current.exists ? current.data() : undefined);
+        const claim = stored == null ? void 0 : stored.sendClaim;
+        if (!stored || stored.status !== 'active' || stored.stepIndex !== enrollment.stepIndex || stored.nextDueAtMs === null || stored.nextDueAtMs > nowMs || claim && nowMs - claim.atMs < OUTREACH_CLAIM_STALE_MS) {
+            return 'taken';
+        }
+        if (messageId) {
+            const mailbox = readStoredOutreachMailbox(run.mailbox.id, box.exists ? box.data() : undefined);
+            if (!mailbox || mailbox.status !== 'connected') return 'taken';
+            const sent = outreachSentToday(mailbox.health, nowMs, mailbox.timezone);
+            if (sent >= outreachEffectiveDailyCap(mailbox, nowMs)) return 'cap';
+            transaction.update(boxRef, {
+                'health.sentToday': sent + 1,
+                'health.sentOnDay': outreachLocalDay(nowMs, mailbox.timezone)
+            });
+        }
+        transaction.update(enrollmentRef, {
+            sendClaim: {
+                token: randomUUID(),
+                atMs: nowMs,
+                stepIndex: enrollment.stepIndex,
+                messageId
+            },
+            updatedAtMs: nowMs
+        });
+        return 'claimed';
+    });
+}
+/** Drops a claim, and hands an email's reservation back to the mailbox's day. */ async function releaseClaim(deps, firestore, run, enrollment, reserved, event = null) {
+    const nowMs = deps.now();
+    await applyOutreachEvent(firestore, {
+        orgId: run.orgId,
+        enrollmentId: enrollment.id,
+        event,
+        extra: ()=>({
+                sendClaim: null
+            }),
+        nowMs
+    });
+    if (!reserved) return;
+    const boxRef = mailboxRef(firestore, run.orgId, run.mailbox.id);
+    await firestore.runTransaction(async (transaction)=>{
+        var _mailbox_health;
+        const box = await transaction.get(boxRef);
+        const mailbox = readStoredOutreachMailbox(run.mailbox.id, box.exists ? box.data() : undefined);
+        if (!mailbox || ((_mailbox_health = mailbox.health) == null ? void 0 : _mailbox_health.sentOnDay) !== outreachLocalDay(nowMs, mailbox.timezone)) return;
+        transaction.update(boxRef, {
+            'health.sentToday': Math.max(0, (Number(mailbox.health.sentToday) || 0) - 1)
+        });
+    });
+}
+/**
+ * Records a step that ran: the engine's completion patch, the claim
+ * cleared, the step's record kept — and for an email the mailbox's send on
+ * its day, its last-sent time and its window of recent sends. Refuses
+ * (answers false) when the claim is no longer this run's.
+ */ async function completeStep(deps, firestore, run, input) {
+    const enrollmentRef = outreachOrgCollection(firestore, run.orgId, 'enrollments').doc(input.enrollment.id);
+    const boxRef = mailboxRef(firestore, run.orgId, run.mailbox.id);
+    const nowMs = deps.now();
+    return firestore.runTransaction(async (transaction)=>{
+        var _stored_stepRecords, _plan_patch;
+        const [current, box] = await Promise.all([
+            transaction.get(enrollmentRef),
+            input.sent ? transaction.get(boxRef) : Promise.resolve(null)
+        ]);
+        const stored = readStoredOutreachEnrollment(input.enrollment.id, current.exists ? current.data() : undefined);
+        if (!(stored == null ? void 0 : stored.sendClaim) || stored.sendClaim.messageId !== input.claimMessageId) return false;
+        if (stored.stepIndex !== input.enrollment.stepIndex) return false;
+        // The step RAN, whatever happened to the enrollment while it did — a
+        // member paused it, a reply stopped it — so it is recorded as run, and a
+        // resume never sends it twice.
+        const plan = planOutreachStepCompletion({
+            enrollment: _extends({}, stored, {
+                status: 'active'
+            }),
+            sequence: input.sequence,
+            mailbox: run.mailbox,
+            completedAtMs: nowMs,
+            sent: input.sent,
+            random: deps.random
+        });
+        const patch = _extends({
+            sendClaim: null,
+            stepRecords: [
+                ...(_stored_stepRecords = stored.stepRecords) != null ? _stored_stepRecords : [],
+                input.record
+            ].slice(-20),
+            updatedAtMs: nowMs
+        }, (_plan_patch = plan.patch) != null ? _plan_patch : {});
+        if (stored.status !== 'active') {
+            patch['status'] = stored.status;
+            if (stored.status !== 'paused') patch['nextDueAtMs'] = null;
+        }
+        transaction.update(enrollmentRef, patch);
+        if (input.sent && (box == null ? void 0 : box.exists)) {
+            const mailbox = readStoredOutreachMailbox(run.mailbox.id, box.data());
+            if (mailbox) {
+                var _ref;
+                var _mailbox_health_daily, _mailbox_health, _mailbox_health1;
+                const day = outreachLocalDay(nowMs, mailbox.timezone);
+                const counts = (_ref = (_mailbox_health = mailbox.health) == null ? void 0 : (_mailbox_health_daily = _mailbox_health.daily) == null ? void 0 : _mailbox_health_daily[day]) != null ? _ref : {
+                    sent: 0,
+                    bounces: 0,
+                    replies: 0
+                };
+                transaction.update(boxRef, {
+                    'health.lastSentAtMs': nowMs,
+                    'health.lastErrorAtMs': null,
+                    'health.lastErrorCode': null,
+                    [`health.daily.${day}`]: _extends({}, counts, {
+                        sent: (Number(counts.sent) || 0) + 1
+                    }),
+                    'health.recentSends': withRecentSend((_mailbox_health1 = mailbox.health) == null ? void 0 : _mailbox_health1.recentSends, {
+                        id: outreachSendDigest(input.sent.messageId),
+                        atMs: nowMs,
+                        bounced: false
+                    }),
+                    updatedAtMs: nowMs
+                });
+            }
+        }
+        return true;
+    });
+}
+/** One task step: the rep's task on the contact, then the step recorded. */ async function runTaskStep(deps, firestore, run, candidate) {
+    const enrollment = candidate.enrollment;
+    const sequence = candidate.sequence;
+    const step = sequence.steps[enrollment.stepIndex];
+    if (await claimStep(deps, firestore, run, enrollment, null) !== 'claimed') return false;
+    const nowMs = deps.now();
+    let taskId;
+    try {
+        var _OUTREACH_TASK_KIND_TO_RECORD_step_taskKind;
+        const written = await fileOutreachTask(deps, {
+            orgId: run.orgId,
+            hostId: enrollment.hostId,
+            contactId: enrollment.contactId,
+            dedupeKey: `step:${enrollment.id}:${step.id}`,
+            title: step.title,
+            notes: `From sequence step ${enrollment.stepIndex + 1}.`,
+            kind: (_OUTREACH_TASK_KIND_TO_RECORD_step_taskKind = OUTREACH_TASK_KIND_TO_RECORD[step.taskKind]) != null ? _OUTREACH_TASK_KIND_TO_RECORD_step_taskKind : 'todo',
+            dueAtMs: nowMs,
+            assigneeUid: run.mailbox.connectedByUid
+        });
+        taskId = (written == null ? void 0 : written.ok) ? written.id : null;
+        if ((written == null ? void 0 : written.ok) === false) console.warn(`[outreach] a task step's task was not filed: ${written.error}`);
+    } catch (error) {
+        // The record system failed rather than refused: the step waits for a
+        // run that can file its task.
+        console.error('[outreach] filing a task step failed; the step waits', error);
+        await releaseClaim(deps, firestore, run, enrollment, false);
+        return false;
+    }
+    return completeStep(deps, firestore, run, {
+        enrollment,
+        sequence,
+        record: {
+            stepIndex: enrollment.stepIndex,
+            stepId: step.id,
+            kind: 'task',
+            atMs: nowMs,
+            taskId
+        },
+        sent: null,
+        claimMessageId: null
+    });
+}
+/** A CRM template's body, read once per run. */ async function templateBody(firestore, run, templateId) {
+    var _run_templates_get;
+    if (!run.templates.has(templateId)) {
+        const snapshot = await firestore.collection('orgs').doc(run.orgId).collection(CRM_COLLECTIONS.emailTemplates).doc(templateId).get();
+        run.templates.set(templateId, snapshot.exists ? normalizeCrmEmailTemplate(snapshot.data()).body : null);
+    }
+    return (_run_templates_get = run.templates.get(templateId)) != null ? _run_templates_get : null;
+}
+async function runEmailStep(deps, firestore, run, input) {
+    var _ref, _composed_email_inReplyTo;
+    const { enrollment, sequence, person } = input;
+    const { report, mailbox } = run;
+    const nowMs = deps.now();
+    const stop = async (event, counter)=>{
+        const outcome = await applyOutreachEvent(firestore, {
+            orgId: run.orgId,
+            enrollmentId: enrollment.id,
+            event,
+            nowMs
+        });
+        if (outcome.changed) report[counter] += 1;
+    };
+    // Every gate again, on the person as they stand now.
+    if (!(person == null ? void 0 : person.contact)) {
+        return stop({
+            type: 'stop',
+            atMs: nowMs,
+            byUid: null,
+            reason: 'gate',
+            detail: 'This contact no longer exists in the CRM.'
+        }, 'stopped');
+    }
+    if (!person.visible) {
+        return stop({
+            type: 'stop',
+            atMs: nowMs,
+            byUid: null,
+            reason: 'gate',
+            detail: "This contact is no longer in the sequence's site's CRM."
+        }, 'stopped');
+    }
+    if (uncheckable(input.lookups)) {
+        report.held += 1;
+        return;
+    }
+    const contactGroupId = consentGroupForHost(run.org, enrollment.hostId).groupId;
+    const gate = evaluateOutreachGates({
+        email: enrollment.email,
+        contact: person.contact,
+        contactGroupId,
+        company: person.company,
+        settings: _extends({}, sequence.settings, {
+            allowedCountries: effectiveOutreachAllowedCountries(sequence.settings.allowedCountries, run.settings.allowedCountries)
+        }),
+        personalLine: enrollment.personalLine,
+        attestations: enrollment.attestations,
+        enrollmentId: enrollment.id,
+        lookups: input.lookups
+    });
+    if (!gate.allowed) return stop(gateEvent(gate.blocks, nowMs), 'stopped');
+    // The email, with its way out.
+    const listUnsubscribeUrl = deps.unsubscribeUrl({
+        orgId: run.orgId,
+        enrollmentId: enrollment.id
+    });
+    const mailto = outreachUnsubscribeMailbox(mailbox.email);
+    if (!listUnsubscribeUrl || !mailto) {
+        // No link can be minted — no secret, or no HTTPS console origin — and an
+        // email without its one-click way out does not leave.
+        console.error('[outreach] no unsubscribe link could be minted; nothing sends until one can');
+        run.stopped = true;
+        report.held += 1;
+        return;
+    }
+    const step = sequence.steps[enrollment.stepIndex];
+    const sender = senderOf(mailbox);
+    const composed = composeOutreachEmail({
+        sequence,
+        enrollment,
+        orgSettings: run.settings,
+        merge: {
+            contact: person.contact,
+            contactGroupId,
+            sender: {
+                name: mailbox.displayName,
+                email: sender.address
+            },
+            site: {
+                name: input.siteName
+            }
+        },
+        templateBody: (step == null ? void 0 : step.kind) === 'email' && step.templateId ? await templateBody(firestore, run, step.templateId) : null,
+        listUnsubscribeUrl,
+        listUnsubscribeMailto: mailto.uri
+    });
+    if (composed.error || !composed.email) {
+        var _composed_error, _composed_error1;
+        const code = (_composed_error = composed.error) == null ? void 0 : _composed_error.code;
+        if (code === 'missing_postal_address' || code === 'missing_legal_name') {
+            // The organization's footer: nothing of theirs sends until it is set.
+            run.stopped = true;
+            report.held += 1;
+            return;
+        }
+        if (code === 'invalid_recipient' || code === 'missing_thread' || code === 'not_an_email_step') {
+            var _composed_error2;
+            return stop({
+                type: 'send_failed',
+                atMs: nowMs,
+                detail: (_composed_error2 = composed.error) == null ? void 0 : _composed_error2.message
+            }, 'failed');
+        }
+        // The sequence's own words: the rep fixes the step and resumes.
+        return stop({
+            type: 'pause',
+            atMs: nowMs,
+            byUid: null,
+            detail: (_composed_error1 = composed.error) == null ? void 0 : _composed_error1.message
+        }, 'failed');
+    }
+    if (composed.unresolvedFields.length) {
+        const fields = composed.unresolvedFields.map((field)=>`{{${field}}}`).join(', ');
+        return stop({
+            type: 'pause',
+            atMs: nowMs,
+            byUid: null,
+            detail: `Paused before sending: this contact has nothing for ${fields}. Fill it in and resume.`
+        }, 'failed');
+    }
+    // Claimed, then sent, then recorded.
+    const domain = sender.address.slice(sender.address.lastIndexOf('@') + 1);
+    const local = randomUUID();
+    const messageId = `<${local}@${domain}>`;
+    const claimed = await claimStep(deps, firestore, run, enrollment, messageId);
+    if (claimed !== 'claimed') {
+        if (claimed === 'cap') run.stopped = true;
+        report.held += 1;
+        return;
+    }
+    const client = await openClient(deps, firestore, run);
+    if (!client) {
+        await releaseClaim(deps, firestore, run, enrollment, true);
+        report.held += 1;
+        return;
+    }
+    let sent;
+    try {
+        sent = await sendComposedOutreachEmail(client, composed.email, sender, {
+            messageIdLocalPart: local,
+            messageIdDomain: domain
+        });
+    } catch (error) {
+        if (error instanceof Rfc5322MessageError || error instanceof GmailTransportError && error.code === 'invalid_request') {
+            await releaseClaim(deps, firestore, run, enrollment, true, {
+                type: 'send_failed',
+                atMs: deps.now(),
+                detail: `Gmail refused the email: ${error.message}`
+            });
+            report.failed += 1;
+            return;
+        }
+        await releaseClaim(deps, firestore, run, enrollment, true);
+        report.held += 1;
+        run.stopped = true;
+        const code = error instanceof GmailTransportError ? error.code : 'unexpected';
+        if (isReconnectRequired(error)) {
+            await markOutreachMailboxReconnectRequired(firestore, {
+                orgId: run.orgId,
+                mailboxId: mailbox.id,
+                errorCode: code,
+                nowMs: deps.now()
+            });
+        } else {
+            await mailboxRef(firestore, run.orgId, mailbox.id).update({
+                'health.lastErrorAtMs': deps.now(),
+                'health.lastErrorCode': code
+            }).catch(()=>undefined);
+        }
+        console.error(`[outreach] a send from a mailbox failed (${code}); its sends wait for the next run`);
+        return;
+    }
+    const record = {
+        stepIndex: enrollment.stepIndex,
+        stepId: (_ref = step == null ? void 0 : step.id) != null ? _ref : '',
+        kind: 'email',
+        atMs: deps.now(),
+        gmailMessageId: sent.gmailMessageId,
+        gmailThreadId: sent.threadId,
+        messageId: sent.messageId,
+        subject: sent.subject
+    };
+    await completeStep(deps, firestore, run, {
+        enrollment,
+        sequence,
+        record,
+        sent: {
+            messageId: sent.messageId,
+            threadId: sent.threadId,
+            subject: sent.subject
+        },
+        claimMessageId: messageId
+    });
+    report.sent += 1;
+    await fileOutreachEmail(deps, {
+        orgId: run.orgId,
+        hostId: enrollment.hostId,
+        contactId: enrollment.contactId,
+        direction: 'outbound',
+        subject: sent.subject,
+        from: sender.address,
+        to: composed.email.to,
+        messageId: sent.messageId,
+        inReplyTo: (_composed_email_inReplyTo = composed.email.inReplyTo) != null ? _composed_email_inReplyTo : null,
+        body: composed.email.text,
+        atMs: record.atMs,
+        byUid: mailbox.connectedByUid,
+        byName: mailbox.displayName || null
+    });
+}
+/**
+ * Settles a claim a run died holding. A task step's claim is dropped and
+ * the step runs again (its task is filed once however often it is asked).
+ * An email's claim looks for the message it minted in the mailbox: found,
+ * the send happened and is recorded; not found, it did not, and the claim
+ * and its reservation are handed back for the next run.
+ */ async function recoverClaim(deps, firestore, run, enrollment, sequence) {
+    var _ref, _ref1;
+    var _message_headers_find;
+    const claim = enrollment.sendClaim;
+    if (!claim) return false;
+    if (!claim.messageId) {
+        await releaseClaim(deps, firestore, run, enrollment, false);
+        return true;
+    }
+    const client = await openClient(deps, firestore, run);
+    if (!client) return false;
+    const bare = claim.messageId.replace(/^<|>$/g, '');
+    const found = await client.listMessages({
+        q: `rfc822msgid:${bare}`,
+        maxResults: 1,
+        includeSpamTrash: true
+    });
+    const hit = found.messages[0];
+    if (!hit) {
+        await releaseClaim(deps, firestore, run, enrollment, true);
+        return true;
+    }
+    const message = await client.getMessage(hit.id, {
+        metadataHeaders: [
+            'Subject'
+        ]
+    });
+    const subject = (_ref = (_message_headers_find = message.headers.find((header)=>header.name.toLowerCase() === 'subject')) == null ? void 0 : _message_headers_find.value) != null ? _ref : '';
+    const step = sequence.steps[enrollment.stepIndex];
+    return completeStep(deps, firestore, run, {
+        enrollment,
+        sequence,
+        record: {
+            stepIndex: enrollment.stepIndex,
+            stepId: (_ref1 = step == null ? void 0 : step.id) != null ? _ref1 : '',
+            kind: 'email',
+            atMs: deps.now(),
+            gmailMessageId: hit.id,
+            gmailThreadId: hit.threadId,
+            messageId: claim.messageId,
+            subject
+        },
+        sent: {
+            messageId: claim.messageId,
+            threadId: hit.threadId,
+            subject
+        },
+        claimMessageId: claim.messageId
+    });
+}
+
+//# sourceMappingURL=send-job.js.map