@aglyn/plugins-outreach 1.0.0-beta.274 → 1.0.0-beta.277

package/src/lib/routes/reply-routes.js

@@ -0,0 +1,644 @@
+/**
+ * @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 { _ as _extends } from "@swc/helpers/_/_extends";
+import { randomUUID } from "node:crypto";
+import { composeOutreachManualReply, mergeOutreachInboundMessages, outreachEnrollmentHasInbound, outreachInboundMessagesOf, outreachMailboxAddress, outreachManualReplyRefusal, outreachMessageToAnswer, outreachReplySubject } from "../engine/manual-reply.js";
+import { outreachThreadMessageFromGmail } from "../engine/thread-message.js";
+import { mailboxRef } from "../mailboxes/mailbox-credentials.js";
+import { outreachLocalDay } from "../mailboxes/mailbox-settings.js";
+import { markOutreachMailboxReconnectRequired } from "../mailboxes/mailbox-transport.js";
+import { OUTREACH_COLLECTIONS } from "../model/outreach.types.js";
+import { newOutreachLinkId, outreachStoredLink } from "../runtime/click-link.js";
+import { fileOutreachEmail } from "../runtime/timeline.js";
+import { outreachUnsubscribeMailbox } from "../runtime/unsubscribe-link.js";
+import { lookupOutreachDoNotContact, lookupOutreachDoNotContactDomains } from "../storage/do-not-contact-store.js";
+import { outreachEnrollmentLink, outreachOrgCollection, readStoredOutreachEnrollment, readStoredOutreachMailbox, readStoredOutreachSequence } from "../storage/outreach-records.js";
+import { GmailTransportError, googleFailureAnswer, isReconnectRequired } from "../transport/gmail-errors.js";
+import { Rfc5322MessageError } from "../transport/rfc5322.js";
+import { sendOutreachReply } from "../transport/send-message.js";
+import { outreachRouteGate } from "./route-gate.js";
+import { outreachMethodNotAllowed, outreachOk, outreachRefusal, readOutreachDocumentId, readOutreachJsonBody } from "./route-http.js";
+/**
+ * ANSWERING A PERSON WHO WROTE BACK (AGL-4020): `outreach/enrollments/thread`
+ * and `outreach/enrollments/reply`.
+ *
+ * A person who answered a sequence email is answered by a member, from the
+ * enrollment's own mailbox, in the same thread — never from the platform's
+ * mail service, which carries no prospecting, and never as a new thread.
+ * The engine writes the answer (`engine/manual-reply.ts`); these routes read
+ * what it answers, check what still refuses, and send it.
+ *
+ * ## What the person wrote
+ *
+ * The sync keeps every message of theirs on the enrollment. A reply synced
+ * before they were kept is on the enrollment only as an id, so when the
+ * enrollment says someone wrote back and keeps nothing they wrote, the
+ * `thread` route reads the enrollment's threads in the mailbox — and, when
+ * they answered in a thread of their own, the messages from their address
+ * since they were enrolled — and keeps what it finds. That read is made only
+ * for a member who may send from the mailbox: nobody reads another member's
+ * mail through these routes.
+ *
+ * ## The answer is no step of the sequence
+ *
+ * It is kept as a `manual_reply` step record and filed on the person's CRM
+ * record. It never restarts the sequence or moves its step; it never counts
+ * against the mailbox's daily cap, joins the sends a bounce rate is judged
+ * over, or bumps the sequence's figures. The mailbox counts it apart, on
+ * `health.daily.<day>.manualReplies`, so it can never pause the mailbox.
+ * Its `Message-ID` joins the enrollment's when it went into the current
+ * thread, so a later step of an enrollment still running answers it, and
+ * the enrollment's `lastSentAtMs` moves, which keeps the thread watched for
+ * what the person writes next.
+ *
+ * ## Its links, on a sequence that tracks them
+ *
+ * The links in the member's words go out as the short links a step's do
+ * (AGL-4022), on the mailbox domain's link host: minted with the answer's
+ * reply key, stored before the send, and kept on the `manual_reply` record.
+ * A click on one is the person's — on their enrollment and their record —
+ * and never the sequence's. A link that cannot be stored goes out as
+ * written: an answer whose links work beats one held for a counter.
+ *
+ * ## Once
+ *
+ * The composer mints a key per answer, which becomes its `Message-ID`. The
+ * answer is claimed in a transaction before it is sent: a retry of the same
+ * answer that already went is answered with its record, and a second answer
+ * while one is in flight is refused. A send that fails hands the claim back.
+ */ /** Answers one mailbox may send in an hour: a conversation, not a campaign. */ export const OUTREACH_MANUAL_REPLIES_PER_HOUR = 30;
+/** How long a claim on an answer holds before another answer may go. */ const REPLY_CLAIM_STALE_MS = 2 * 60000;
+/** The most of an enrollment's threads one read opens, newest first. */ const THREADS_READ_MAX = 5;
+/** The most messages from the person's address one read opens, outside those threads. */ const OWN_THREAD_MESSAGES_MAX = 10;
+/** A reply key as the composer mints one: a UUID, or anything as plain. */ const REPLY_KEY = /^[A-Za-z0-9][A-Za-z0-9-]{7,63}$/;
+/** The enrollment, its sequence's click setting, and the mailbox an answer goes from: its own, else its sequence's. */ async function loadEnrollment(firestore, orgId, enrollmentId) {
+    const snapshot = await outreachOrgCollection(firestore, orgId, 'enrollments').doc(enrollmentId).get();
+    const enrollment = readStoredOutreachEnrollment(enrollmentId, snapshot.exists ? snapshot.data() : undefined);
+    if (!enrollment) return null;
+    const stored = enrollment.sequenceId ? await outreachOrgCollection(firestore, orgId, 'sequences').doc(enrollment.sequenceId).get() : null;
+    const sequence = stored ? readStoredOutreachSequence(stored.id, stored.exists ? stored.data() : undefined) : null;
+    const tracksLinks = (sequence == null ? void 0 : sequence.settings.trackClicks) === true;
+    const mailboxId = enrollment.mailboxId || (sequence == null ? void 0 : sequence.mailboxId) || '';
+    if (!mailboxId) return {
+        enrollment,
+        mailbox: null,
+        tracksLinks
+    };
+    const box = await mailboxRef(firestore, orgId, mailboxId).get();
+    return {
+        enrollment,
+        mailbox: readStoredOutreachMailbox(mailboxId, box.exists ? box.data() : undefined),
+        tracksLinks
+    };
+}
+/** The member is the mailbox's own, or an organization owner or admin. */ const mayUseMailbox = (caller, mailbox)=>Boolean(mailbox) && ((mailbox == null ? void 0 : mailbox.connectedByUid) === caller.uid || caller.isOrgAdmin);
+/** The mailbox's own addresses: the account's, and every alias it sends as. */ const selfAddressesOf = (mailbox)=>{
+    var _mailbox_sendAsOptions;
+    return [
+        mailbox.email,
+        mailbox.sendAs,
+        ...((_mailbox_sendAsOptions = mailbox.sendAsOptions) != null ? _mailbox_sendAsOptions : []).map((option)=>option.email)
+    ].filter(Boolean);
+};
+/**
+ * What the person wrote, read from the mailbox: the enrollment's threads,
+ * newest first, and — when none holds a message of theirs — the messages
+ * from their address since they were enrolled.
+ */ async function readMailboxInbound(client, enrollment, mailbox) {
+    var _ref, _enrollment_gmailThreadIds;
+    var _outreachUnsubscribeMailbox;
+    const context = {
+        selfAddresses: selfAddressesOf(mailbox),
+        unsubscribeAddress: (_ref = (_outreachUnsubscribeMailbox = outreachUnsubscribeMailbox(mailbox.email)) == null ? void 0 : _outreachUnsubscribeMailbox.address) != null ? _ref : null,
+        threadSubject: enrollment.threadSubject
+    };
+    const threads = [
+        ...new Set([
+            ...(_enrollment_gmailThreadIds = enrollment.gmailThreadIds) != null ? _enrollment_gmailThreadIds : [],
+            enrollment.gmailThreadId
+        ].filter((id)=>Boolean(id)))
+    ].reverse().slice(0, THREADS_READ_MAX);
+    const messages = [];
+    for (const threadId of threads){
+        const thread = await client.getFullThread(threadId);
+        messages.push(...thread.messages.map(outreachThreadMessageFromGmail));
+    }
+    let found = outreachInboundMessagesOf(messages, context);
+    if (!found.length && enrollment.email) {
+        const listed = await client.searchMessages({
+            afterMs: enrollment.createdAtMs || 0,
+            from: [
+                enrollment.email
+            ]
+        }, {
+            maxResults: OWN_THREAD_MESSAGES_MAX
+        });
+        const own = [];
+        for (const stub of listed.messages.slice(0, OWN_THREAD_MESSAGES_MAX)){
+            own.push(outreachThreadMessageFromGmail(await client.getFullMessage(stub.id)));
+        }
+        found = outreachInboundMessagesOf(own, context);
+    }
+    return found;
+}
+/** Keeps what the mailbox held on the enrollment; answers the enrollment as stored. */ async function keepInbound(firestore, orgId, enrollment, found, nowMs) {
+    const ref = outreachOrgCollection(firestore, orgId, 'enrollments').doc(enrollment.id);
+    return firestore.runTransaction(async (transaction)=>{
+        const snapshot = await transaction.get(ref);
+        const current = readStoredOutreachEnrollment(enrollment.id, snapshot.exists ? snapshot.data() : undefined);
+        if (!current) return enrollment;
+        const inboundMessages = mergeOutreachInboundMessages(current.inboundMessages, found);
+        transaction.update(ref, {
+            inboundMessages,
+            updatedAtMs: nowMs
+        });
+        return _extends({}, current, {
+            inboundMessages,
+            updatedAtMs: nowMs
+        });
+    });
+}
+/**
+ * The enrollment with what the person wrote: as kept, or — when it says
+ * they wrote back and keeps nothing — read from the mailbox and kept.
+ */ async function withInbound(deps, replyDeps, caller, loaded) {
+    var _enrollment_inboundMessages;
+    const { enrollment, mailbox } = loaded;
+    const unread = !((_enrollment_inboundMessages = enrollment.inboundMessages) == null ? void 0 : _enrollment_inboundMessages.length) && outreachEnrollmentHasInbound(enrollment) && mailbox !== null && (mailbox.status === 'connected' || mailbox.status === 'paused') && mayUseMailbox(caller, mailbox);
+    if (!unread || !mailbox) return {
+        ok: true,
+        enrollment,
+        readMailbox: false
+    };
+    const firestore = deps.firestore();
+    const nowMs = deps.now();
+    const opened = await replyDeps.openMailbox(mailbox.id);
+    if (opened.ok === false) {
+        if (opened.reason === 'not-configured') return {
+            ok: true,
+            enrollment,
+            readMailbox: false
+        };
+        await markOutreachMailboxReconnectRequired(firestore, {
+            orgId: caller.orgId,
+            mailboxId: mailbox.id,
+            errorCode: opened.reason,
+            nowMs
+        });
+        mailbox.status = 'reconnect_required';
+        return {
+            ok: true,
+            enrollment,
+            readMailbox: false
+        };
+    }
+    let found;
+    try {
+        found = await readMailboxInbound(opened.client, enrollment, mailbox);
+    } catch (error) {
+        if (isReconnectRequired(error)) {
+            await markOutreachMailboxReconnectRequired(firestore, {
+                orgId: caller.orgId,
+                mailboxId: mailbox.id,
+                errorCode: error instanceof GmailTransportError ? error.code : 'invalid_grant',
+                nowMs
+            });
+            mailbox.status = 'reconnect_required';
+            return {
+                ok: true,
+                enrollment,
+                readMailbox: false
+            };
+        }
+        if (!(error instanceof GmailTransportError)) throw error;
+        const answer = googleFailureAnswer(error, 'reply thread read');
+        return {
+            ok: false,
+            response: outreachRefusal(answer.status, answer.reason, answer.error)
+        };
+    }
+    if (!found.length) return {
+        ok: true,
+        enrollment,
+        readMailbox: true
+    };
+    return {
+        ok: true,
+        enrollment: await keepInbound(firestore, caller.orgId, enrollment, found, nowMs),
+        readMailbox: true
+    };
+}
+/** Every gate an answer still passes — see `outreachManualReplyRefusal`. */ async function refusalFor(firestore, caller, enrollment, mailbox, to) {
+    const recipients = [
+        ...new Set([
+            enrollment.email,
+            to
+        ].filter((address)=>Boolean(address)))
+    ];
+    const [addresses, domains] = await Promise.all([
+        lookupOutreachDoNotContact(firestore, caller.orgId, recipients),
+        lookupOutreachDoNotContactDomains(firestore, caller.orgId, recipients)
+    ]);
+    const fold = (answers)=>{
+        const values = recipients.map((address)=>{
+            var _answers_get;
+            return (_answers_get = answers.get(address)) != null ? _answers_get : null;
+        });
+        if (values.includes(true)) return true;
+        return values.includes(null) ? null : false;
+    };
+    return outreachManualReplyRefusal({
+        enrollment,
+        doNotContact: fold(addresses),
+        doNotContactDomain: fold(domains),
+        mailbox,
+        mayUseMailbox: mayUseMailbox(caller, mailbox)
+    });
+}
+/** Where an answer to the newest message would go, from what, under what subject. */ function draftFor(enrollment, mailbox, tracksLinks) {
+    var _answering_replyTo, _mailbox_provider;
+    const answering = outreachMessageToAnswer(enrollment.inboundMessages);
+    if (!answering || !mailbox) return null;
+    return {
+        answerId: answering.id,
+        tracksLinks,
+        to: (_answering_replyTo = answering.replyTo) != null ? _answering_replyTo : answering.from,
+        subject: outreachReplySubject(answering, enrollment.threadSubject),
+        // A mailbox connected before Microsoft ones existed names no provider: it is Google's.
+        from: {
+            address: outreachMailboxAddress(mailbox),
+            name: mailbox.displayName || '',
+            provider: (_mailbox_provider = mailbox.provider) != null ? _mailbox_provider : 'google'
+        }
+    };
+}
+const REFUSAL_STATUS = {
+    'opted-out': 409,
+    bounced: 409,
+    'do-not-contact': 409,
+    unchecked: 503,
+    'mailbox-unavailable': 409,
+    permission: 403
+};
+/** `outreach/enrollments/thread` — see the module note. */ export function createOutreachEnrollmentThreadRoute(deps, replyDeps) {
+    return async (request)=>{
+        var _enrollment_inboundMessages;
+        if (request.method !== 'POST') return outreachMethodNotAllowed('POST');
+        const body = await readOutreachJsonBody(request);
+        const caller = await outreachRouteGate(request, body['orgId'], deps.gate);
+        if (caller instanceof Response) return caller;
+        const enrollmentId = readOutreachDocumentId(body['enrollmentId']);
+        if (!enrollmentId) return outreachRefusal(400, 'invalid-request', 'Name the enrollment.');
+        const firestore = deps.firestore();
+        const loaded = await loadEnrollment(firestore, caller.orgId, enrollmentId);
+        if (!loaded) return outreachRefusal(404, 'enrollment-not-found', 'That enrollment no longer exists.');
+        const read = await withInbound(deps, replyDeps, caller, loaded);
+        if (read.ok === false) return read.response;
+        const { enrollment, readMailbox } = read;
+        const draft = draftFor(enrollment, loaded.mailbox, loaded.tracksLinks);
+        const refusal = draft ? await refusalFor(firestore, caller, enrollment, loaded.mailbox, draft.to) : null;
+        return outreachOk({
+            ok: true,
+            enrollment,
+            inboundMessages: (_enrollment_inboundMessages = enrollment.inboundMessages) != null ? _enrollment_inboundMessages : [],
+            draft,
+            refusal,
+            readMailbox
+        });
+    };
+}
+/** `outreach/enrollments/reply` — see the module note. */ export function createOutreachEnrollmentReplyRoute(deps, replyDeps) {
+    return async (request)=>{
+        if (request.method !== 'POST') return outreachMethodNotAllowed('POST');
+        const body = await readOutreachJsonBody(request);
+        const caller = await outreachRouteGate(request, body['orgId'], deps.gate);
+        if (caller instanceof Response) return caller;
+        const enrollmentId = readOutreachDocumentId(body['enrollmentId']);
+        if (!enrollmentId) return outreachRefusal(400, 'invalid-request', 'Name the enrollment.');
+        const named = typeof body['replyKey'] === 'string' ? body['replyKey'].trim() : '';
+        if (named && !REPLY_KEY.test(named)) return outreachRefusal(400, 'invalid-request', 'That reply key is not one the composer mints.');
+        const replyKey = named || randomUUID();
+        const answerId = typeof body['answerId'] === 'string' ? body['answerId'].trim() : null;
+        const firestore = deps.firestore();
+        const loaded = await loadEnrollment(firestore, caller.orgId, enrollmentId);
+        if (!loaded) return outreachRefusal(404, 'enrollment-not-found', 'That enrollment no longer exists.');
+        const read = await withInbound(deps, replyDeps, caller, loaded);
+        if (read.ok === false) return read.response;
+        const { mailbox } = loaded;
+        const answering = outreachMessageToAnswer(read.enrollment.inboundMessages, answerId);
+        if (!answering) {
+            return outreachRefusal(409, 'nothing-to-answer', answerId ? 'That message of theirs is not one this enrollment kept.' : 'Nothing they wrote could be read, so there is nothing to answer here yet.');
+        }
+        const composed = composeOutreachManualReply({
+            enrollment: read.enrollment,
+            answering,
+            body: body['body'],
+            timeZone: mailbox == null ? void 0 : mailbox.timezone
+        });
+        if (composed.error || !composed.reply) {
+            var _ref;
+            var _composed_error;
+            return outreachRefusal(400, 'invalid-request', (_ref = (_composed_error = composed.error) == null ? void 0 : _composed_error.message) != null ? _ref : 'The answer could not be written.');
+        }
+        const reply = composed.reply;
+        const refused = await refusalFor(firestore, caller, read.enrollment, mailbox, reply.to);
+        if (refused || !mailbox) {
+            const refusal = refused != null ? refused : {
+                code: 'mailbox-unavailable',
+                message: 'The mailbox is no longer connected.'
+            };
+            return outreachRefusal(REFUSAL_STATUS[refusal.code], refusal.code === 'permission' ? 'permission' : 'reply-refused', refusal.message);
+        }
+        const limited = await replyDeps.consumeRateLimit(`outreach-manual-reply:${mailbox.id}`, {
+            limit: OUTREACH_MANUAL_REPLIES_PER_HOUR,
+            windowMs: 60 * 60000
+        });
+        if (!limited.allowed) {
+            return outreachRefusal(429, 'rate-limited', `A mailbox can send ${OUTREACH_MANUAL_REPLIES_PER_HOUR} answers an hour. Try again later.`);
+        }
+        const sender = {
+            address: outreachMailboxAddress(mailbox),
+            name: mailbox.displayName || null
+        };
+        const domain = sender.address.slice(sender.address.lastIndexOf('@') + 1);
+        const messageId = `<${replyKey}@${domain}>`;
+        const ref = outreachOrgCollection(firestore, caller.orgId, 'enrollments').doc(enrollmentId);
+        // Claimed before it is sent: a retry of this answer, or a second one in flight.
+        const claim = await firestore.runTransaction(async (transaction)=>{
+            var _current_stepRecords;
+            const snapshot = await transaction.get(ref);
+            const current = readStoredOutreachEnrollment(enrollmentId, snapshot.exists ? snapshot.data() : undefined);
+            if (!current) return {
+                kind: 'gone'
+            };
+            const sent = ((_current_stepRecords = current.stepRecords) != null ? _current_stepRecords : []).find((record)=>record.kind === 'manual_reply' && (record.replyKey === replyKey || record.messageId === messageId));
+            if (sent) return {
+                kind: 'sent',
+                enrollment: current,
+                record: sent
+            };
+            const held = current.replyClaim;
+            if (held && deps.now() - held.atMs < REPLY_CLAIM_STALE_MS) return {
+                kind: 'busy'
+            };
+            transaction.update(ref, {
+                replyClaim: {
+                    messageId,
+                    byUid: caller.uid,
+                    atMs: deps.now()
+                }
+            });
+            return {
+                kind: 'claimed'
+            };
+        });
+        if (claim.kind === 'gone') return outreachRefusal(404, 'enrollment-not-found', 'That enrollment no longer exists.');
+        if (claim.kind === 'busy') {
+            return outreachRefusal(409, 'reply-in-flight', 'An answer to them is already being sent. Wait a moment and look again.');
+        }
+        if (claim.kind === 'sent') {
+            var _claim_record_to, _claim_record_subject;
+            return outreachOk({
+                ok: true,
+                enrollment: claim.enrollment,
+                record: claim.record,
+                sentTo: (_claim_record_to = claim.record.to) != null ? _claim_record_to : reply.to,
+                subject: (_claim_record_subject = claim.record.subject) != null ? _claim_record_subject : reply.subject,
+                alreadySent: true
+            });
+        }
+        const release = ()=>ref.update({
+                replyClaim: null
+            }).catch((error)=>{
+                console.error('[outreach] an answer’s claim could not be handed back', error);
+            });
+        const nowMs = deps.now();
+        const sending = await withTrackedLinks(firestore, replyDeps, {
+            orgId: caller.orgId,
+            loaded,
+            answering,
+            body: body['body'],
+            replyKey,
+            senderAddress: sender.address,
+            untracked: reply,
+            nowMs
+        });
+        const opened = await replyDeps.openMailbox(mailbox.id);
+        if (opened.ok === false) {
+            await release();
+            if (opened.reason === 'not-configured') {
+                return outreachRefusal(503, 'mailbox-unavailable', 'Mailboxes are not set up on this deployment.');
+            }
+            await markOutreachMailboxReconnectRequired(firestore, {
+                orgId: caller.orgId,
+                mailboxId: mailbox.id,
+                errorCode: opened.reason,
+                nowMs
+            });
+            return outreachRefusal(409, 'mailbox-unavailable', `${sender.address} needs to be connected again. Reconnect it on the Mailboxes page to answer from it.`);
+        }
+        let sent;
+        try {
+            sent = await sendOutreachReply(opened.client, sending, sender, {
+                messageIdLocalPart: replyKey,
+                messageIdDomain: domain
+            });
+        } catch (error) {
+            await release();
+            if (error instanceof Rfc5322MessageError) {
+                return outreachRefusal(400, 'invalid-request', `The answer could not be written: ${error.message}`);
+            }
+            if (error instanceof GmailTransportError && error.reconnectRequired) {
+                await markOutreachMailboxReconnectRequired(firestore, {
+                    orgId: caller.orgId,
+                    mailboxId: mailbox.id,
+                    errorCode: error.code,
+                    nowMs
+                });
+                return outreachRefusal(409, 'mailbox-unavailable', `The mail provider refused ${sender.address}’s access. Reconnect it on the Mailboxes page to answer from it.`);
+            }
+            const answer = googleFailureAnswer(error, 'manual reply send');
+            return outreachRefusal(answer.status, answer.reason, answer.error);
+        }
+        const atMs = deps.now();
+        const record = _extends({
+            stepIndex: read.enrollment.stepIndex,
+            stepId: '',
+            kind: 'manual_reply',
+            atMs,
+            byUid: caller.uid,
+            from: sender.address,
+            to: reply.to,
+            body: sending.body,
+            replyKey,
+            gmailMessageId: sent.gmailMessageId,
+            gmailThreadId: sent.threadId,
+            messageId: sent.messageId,
+            subject: sent.subject
+        }, reply.inReplyTo ? {
+            inReplyTo: reply.inReplyTo
+        } : {}, sending.trackedLinks.length ? {
+            links: sending.trackedLinks
+        } : {});
+        const enrollment = await firestore.runTransaction(async (transaction)=>{
+            var _current_stepRecords;
+            const snapshot = await transaction.get(ref);
+            const current = readStoredOutreachEnrollment(enrollmentId, snapshot.exists ? snapshot.data() : undefined);
+            if (!current) return null;
+            const patch = {
+                stepRecords: [
+                    ...(_current_stepRecords = current.stepRecords) != null ? _current_stepRecords : [],
+                    record
+                ].slice(-20),
+                replyClaim: null,
+                // The thread is watched for what they write next, and the
+                // enrollments table reads this as the last thing that happened.
+                lastSentAtMs: atMs,
+                updatedAtMs: atMs
+            };
+            if (sent.threadId && !current.gmailThreadIds.includes(sent.threadId)) {
+                patch['gmailThreadIds'] = [
+                    ...current.gmailThreadIds,
+                    sent.threadId
+                ];
+            }
+            // Into the current thread: a later step answers this answer.
+            if (sent.threadId && sent.threadId === current.gmailThreadId && !current.messageIds.includes(sent.messageId)) {
+                patch['messageIds'] = [
+                    ...current.messageIds,
+                    sent.messageId
+                ];
+            }
+            transaction.update(ref, patch);
+            return _extends({}, current, patch);
+        });
+        await countManualReply(firestore, caller.orgId, mailbox, atMs);
+        await fileOutreachEmail(deps, {
+            orgId: caller.orgId,
+            hostId: read.enrollment.hostId,
+            link: outreachEnrollmentLink(read.enrollment),
+            direction: 'outbound',
+            subject: sent.subject,
+            from: sender.address,
+            to: reply.to,
+            messageId: sent.messageId,
+            inReplyTo: reply.inReplyTo,
+            body: sending.body,
+            atMs,
+            byUid: caller.uid,
+            byName: mailbox.connectedByUid === caller.uid ? mailbox.displayName || null : null
+        });
+        return outreachOk({
+            ok: true,
+            enrollment: enrollment != null ? enrollment : read.enrollment,
+            record,
+            sentTo: reply.to,
+            subject: sent.subject,
+            alreadySent: false
+        });
+    };
+}
+/**
+ * The answer as it goes out (AGL-4022): on a sequence that tracks link
+ * clicks, written again with its links minted as short links on the mailbox
+ * domain's link host, each stored before the send and named by the answer's
+ * reply key; otherwise — or when the links cannot be stored — exactly as
+ * the member wrote it.
+ */ async function withTrackedLinks(firestore, replyDeps, input) {
+    var _loaded_mailbox;
+    const { loaded, nowMs } = input;
+    if (!loaded.tracksLinks) return input.untracked;
+    let origin = null;
+    if (replyDeps.clickLinkOrigin) {
+        origin = await replyDeps.clickLinkOrigin({
+            orgId: input.orgId,
+            senderAddress: input.senderAddress
+        }).catch((error)=>{
+            console.warn('[outreach] the click-tracking host could not be read; an answer’s links use the app address', error);
+            return null;
+        });
+    }
+    const minted = [];
+    const tracked = composeOutreachManualReply({
+        enrollment: loaded.enrollment,
+        answering: input.answering,
+        body: input.body,
+        timeZone: (_loaded_mailbox = loaded.mailbox) == null ? void 0 : _loaded_mailbox.timezone,
+        rewriteLink: (link)=>{
+            const doc = outreachStoredLink({
+                orgId: input.orgId,
+                enrollmentId: loaded.enrollment.id,
+                stepIndex: loaded.enrollment.stepIndex,
+                linkIndex: link.index,
+                url: link.url,
+                answerKey: input.replyKey
+            }, nowMs);
+            const id = newOutreachLinkId();
+            const url = doc ? replyDeps.clickLinkUrl(id, origin) : null;
+            if (!doc || !url) return null;
+            minted.push({
+                id,
+                doc
+            });
+            return url;
+        }
+    }).reply;
+    if (!tracked || !minted.length) return input.untracked;
+    try {
+        const batch = firestore.batch();
+        for (const link of minted)batch.create(firestore.collection(OUTREACH_COLLECTIONS.links).doc(link.id), link.doc);
+        await batch.commit();
+        return tracked;
+    } catch (error) {
+        // A link that resolves nowhere is worse than one as written.
+        console.error('[outreach] an answer’s short links could not be stored; it carries its links as written', error);
+        return input.untracked;
+    }
+}
+/**
+ * One more answer on the mailbox's local day, in
+ * `health.daily.<day>.manualReplies` beside the day's sends and never in
+ * them. Bookkeeping beside the act: the answer has left, so a failure is
+ * logged.
+ */ async function countManualReply(firestore, orgId, mailbox, nowMs) {
+    const ref = mailboxRef(firestore, orgId, mailbox.id);
+    try {
+        await firestore.runTransaction(async (transaction)=>{
+            var _ref;
+            var _stored_health_daily, _stored_health;
+            const snapshot = await transaction.get(ref);
+            const stored = readStoredOutreachMailbox(mailbox.id, snapshot.exists ? snapshot.data() : undefined);
+            if (!stored) return;
+            const day = outreachLocalDay(nowMs, stored.timezone);
+            const counts = (_ref = (_stored_health = stored.health) == null ? void 0 : (_stored_health_daily = _stored_health.daily) == null ? void 0 : _stored_health_daily[day]) != null ? _ref : {
+                sent: 0,
+                bounces: 0,
+                replies: 0
+            };
+            const manualReplies = Math.max(0, Number(counts.manualReplies) || 0) + 1;
+            transaction.update(ref, {
+                [`health.daily.${day}`]: _extends({}, counts, {
+                    manualReplies
+                }),
+                updatedAtMs: nowMs
+            });
+        });
+    } catch (error) {
+        console.warn('[outreach] an answer could not be counted on its mailbox', error);
+    }
+}
+
+//# sourceMappingURL=reply-routes.js.map