mailery 0.7.0 → 0.8.1

package/dist/testing.js

@@ -491,22 +491,22 @@ function __awaiter(thisArg, _arguments, P, generator) {
   return new (P || (P = Promise))(function(resolve, reject) {
     function fulfilled(value) {
       try {
-        step(generator.next(value));
+        step2(generator.next(value));
       } catch (e) {
         reject(e);
       }
     }
     function rejected(value) {
       try {
-        step(generator["throw"](value));
+        step2(generator["throw"](value));
       } catch (e) {
         reject(e);
       }
     }
-    function step(result) {
+    function step2(result) {
       result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
+    step2((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 }
 function __generator(thisArg, body) {
@@ -519,10 +519,10 @@ function __generator(thisArg, body) {
   }), g;
   function verb(n) {
     return function(v) {
-      return step([n, v]);
+      return step2([n, v]);
     };
   }
-  function step(op) {
+  function step2(op) {
     if (f) throw new TypeError("Generator is already executing.");
     while (g && (g = 0, op[0] && (_ = 0)), _) try {
       if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
@@ -656,12 +656,12 @@ function __asyncGenerator(thisArg, _arguments, generator) {
   }
   function resume(n, v) {
     try {
-      step(g[n](v));
+      step2(g[n](v));
     } catch (e) {
       settle(q[0][3], e);
     }
   }
-  function step(r) {
+  function step2(r) {
     r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
   }
   function fulfill(value) {
@@ -7079,9 +7079,9 @@ var require_pack = __commonJS({
         this.push(headers.encode(newHeader));
       }
       _doDrain() {
-        const drain = this._drain;
+        const drain2 = this._drain;
         this._drain = noop;
-        drain();
+        drain2();
       }
       _predestroy() {
         const err = getStreamError(this);
@@ -14434,6 +14434,7 @@ async function ensureIndexes(db, prefix = "mailer_") {
       { key: { dedupeKey: 1 }, unique: true },
       { key: { externalId: 1, occurredAt: -1 } },
       { key: { name: 1, occurredAt: -1 } },
+      { key: { name: 1, createdAt: 1 } },
       { key: { externalId: 1, name: 1 } }
     ]),
     c.flows.createIndexes([
@@ -14444,7 +14445,12 @@ async function ensureIndexes(db, prefix = "mailer_") {
     c.flowRuns.createIndexes([
       { key: { status: 1, nextActionAt: 1 } },
       { key: { externalId: 1, flowId: 1 } },
-      { key: { flowId: 1, status: 1 } }
+      { key: { flowId: 1, status: 1 } },
+      {
+        key: { flowId: 1, triggerDedupeKey: 1 },
+        unique: true,
+        partialFilterExpression: { triggerDedupeKey: { $type: "string" } }
+      }
     ]),
     c.templates.createIndexes([
       { key: { slug: 1 }, unique: true },
@@ -14632,7 +14638,13 @@ var BullDriver = class _BullDriver {
   constructor(bull, redis) {
     this.bull = bull;
     this.redis = redis;
-    const opts = { connection: redis };
+    const opts = {
+      connection: redis,
+      defaultJobOptions: {
+        removeOnComplete: { age: 24 * 3600, count: 1e3 },
+        removeOnFail: { age: 7 * 24 * 3600 }
+      }
+    };
     this.bullQueues = {
       tick: new bull.Queue(QUEUE_NAMES.tick, opts),
       advance: new bull.Queue(QUEUE_NAMES.advance, opts),
@@ -14650,7 +14662,11 @@ var BullDriver = class _BullDriver {
     await this.bullQueues.tick.upsertJobScheduler(
       "mailer-tick-repeat",
       { every: intervalSeconds * 1e3 },
-      { name: "tick", data: {} }
+      {
+        name: "tick",
+        data: {},
+        opts: { removeOnComplete: { count: 20 }, removeOnFail: { count: 50 } }
+      }
     );
   }
   async startWorkers(opts) {
@@ -14760,9 +14776,10 @@ var AgendaDriver = class _AgendaDriver {
         "mailery: queue driver 'agenda' requires the 'agenda' and '@agendajs/mongo-backend' peer dependencies. Run `npm install agenda @agendajs/mongo-backend bottleneck`."
       );
     }
+    const collectionName = opts.collectionName ?? "_mailerJobs";
     const backend = new backendMod.MongoBackend({
       mongo: opts.db,
-      collection: opts.collectionName ?? "_mailerJobs"
+      collection: collectionName
     });
     const agenda = new agendaMod.Agenda({
       backend,
@@ -14771,13 +14788,15 @@ var AgendaDriver = class _AgendaDriver {
       maxConcurrency: 50,
       defaultConcurrency: 5
     });
-    return new _AgendaDriver(agenda, agendaMod, opts.db);
+    return new _AgendaDriver(agenda, agendaMod, opts.db, collectionName);
   }
   db;
-  constructor(agenda, agendaMod, db) {
+  collName;
+  constructor(agenda, agendaMod, db, collectionName) {
     this.agenda = agenda;
     this.agendaMod = agendaMod;
     this.db = db;
+    this.collName = collectionName;
     this.queues = {
       tick: this.makeQueueAPI(QUEUE_NAMES2.tick),
       advance: this.makeQueueAPI(QUEUE_NAMES2.advance),
@@ -14810,10 +14829,7 @@ var AgendaDriver = class _AgendaDriver {
   }
   /** Direct access to the Mongo collection Agenda persists jobs into. */
   jobsCollection() {
-    return this.db.collection(this.collectionName());
-  }
-  collectionName() {
-    return "_mailerJobs";
+    return this.db.collection(this.collName);
   }
   async findPending(name, jobId) {
     return this.jobsCollection().findOne({
@@ -14823,12 +14839,6 @@ var AgendaDriver = class _AgendaDriver {
     });
   }
   async scheduleRepeatingTick(intervalSeconds) {
-    if (!this.started) {
-      this.agenda.define(QUEUE_NAMES2.tick, async () => {
-      }, { concurrency: 1 });
-      await this.agenda.start();
-      this.started = true;
-    }
     await this.agenda.every(`${intervalSeconds} seconds`, QUEUE_NAMES2.tick);
   }
   async startWorkers(opts) {
@@ -14931,6 +14941,7 @@ async function createQueueDriver(config, fallbackDb) {
 
 // src/server/runner/triggers.ts
 var BATCH_SIZE = 1e3;
+var SCAN_OVERLAP_MS = 3e4;
 async function processNewlyFiredEventTriggers(ctx) {
   const flows = await ctx.collections.flows.find({ enabled: true, "trigger.type": "event" }).toArray();
   for (const flow of flows) {
@@ -14941,16 +14952,19 @@ async function processFlowTriggers(flow, ctx) {
   const eventName = flow.trigger.eventName;
   if (!eventName) return;
   const since = flow.lastTriggerScanAt ?? flow.createdAt;
-  const events = await ctx.collections.events.find({ name: eventName, occurredAt: { $gt: since } }).sort({ occurredAt: 1 }).limit(BATCH_SIZE).toArray();
+  const scanFrom = new Date(since.getTime() - SCAN_OVERLAP_MS);
+  const events = await ctx.collections.events.find({ name: eventName, createdAt: { $gt: scanFrom } }).sort({ createdAt: 1 }).limit(BATCH_SIZE).toArray();
   if (events.length === 0) return;
   for (const event of events) {
     await tryEnterFlow(flow, event, ctx);
   }
-  const newestOccurredAt = events[events.length - 1].occurredAt;
-  await ctx.collections.flows.updateOne(
-    { _id: flow._id },
-    { $set: { lastTriggerScanAt: newestOccurredAt, updatedAt: /* @__PURE__ */ new Date() } }
-  );
+  const newestCreatedAt = events[events.length - 1].createdAt;
+  if (newestCreatedAt.getTime() > since.getTime()) {
+    await ctx.collections.flows.updateOne(
+      { _id: flow._id },
+      { $set: { lastTriggerScanAt: newestCreatedAt, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
 }
 async function tryEnterFlow(flow, event, ctx) {
   if (flow.trigger.once) {
@@ -14962,28 +14976,364 @@ async function tryEnterFlow(flow, event, ctx) {
   }
   const sub = await ctx.collections.subscriptions.findOne({ externalId: event.externalId });
   if (!sub || sub.status !== "subscribed") return;
-  const result = await ctx.collections.flowRuns.insertOne({
-    externalId: event.externalId,
-    flowId: flow._id,
-    flowSlug: flow.slug,
-    flowVersion: flow.version,
-    emailAtEntry: sub.emailAtSubscribe,
-    triggerEvent: { name: event.name, properties: event.properties ?? {}, occurredAt: event.occurredAt },
-    enteredAt: /* @__PURE__ */ new Date(),
-    status: "active",
-    currentStepIndex: 0,
-    currentBranchPath: [],
-    nextActionAt: /* @__PURE__ */ new Date(),
-    attemptsForCurrentStep: 0,
-    history: [{ stepIndex: -1, action: "entered", at: /* @__PURE__ */ new Date(), details: { eventDedupeKey: event.dedupeKey } }],
-    exitedAt: null,
-    exitReason: null,
-    createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: /* @__PURE__ */ new Date()
-  });
+  let result;
+  try {
+    result = await ctx.collections.flowRuns.insertOne({
+      externalId: event.externalId,
+      flowId: flow._id,
+      flowSlug: flow.slug,
+      flowVersion: flow.version,
+      emailAtEntry: sub.emailAtSubscribe,
+      triggerEvent: { name: event.name, properties: event.properties ?? {}, occurredAt: event.occurredAt },
+      triggerDedupeKey: event.dedupeKey,
+      enteredAt: /* @__PURE__ */ new Date(),
+      status: "active",
+      currentStepIndex: 0,
+      currentBranchPath: [],
+      nextActionAt: /* @__PURE__ */ new Date(),
+      attemptsForCurrentStep: 0,
+      history: [{ stepIndex: -1, action: "entered", at: /* @__PURE__ */ new Date(), details: { eventDedupeKey: event.dedupeKey } }],
+      exitedAt: null,
+      exitReason: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+  } catch (err) {
+    if (err?.code !== 11e3) throw err;
+    return;
+  }
   await ctx.queues.advance.add("advance", { flowRunId: String(result.insertedId) });
 }
 
+// src/server/templates/sender-domain.ts
+function extractDomain(email) {
+  if (typeof email !== "string") return null;
+  const at = email.lastIndexOf("@");
+  if (at <= 0 || at === email.length - 1) return null;
+  return email.slice(at + 1).toLowerCase().trim();
+}
+
+// src/server/runner/health.ts
+var ZERO_COUNTERS = {
+  sent: 0,
+  delivered: 0,
+  bounced: 0,
+  hardBounced: 0,
+  softBounced: 0,
+  complained: 0,
+  failedToSend: 0
+};
+var ZERO_RATES = {
+  bounceRate: 0,
+  hardBounceRate: 0,
+  complaintRate: 0,
+  failureRate: 0
+};
+async function recordHealthCounter(ctx, counter2, dims, by = 1) {
+  const windowMs = ctx.config.circuitBreaker.windowMinutes * 60 * 1e3;
+  const writes = [];
+  writes.push(upsertCounter(ctx, HEALTH_AGG_ID, null, null, counter2, by, windowMs));
+  if (dims) {
+    const domain = dims.fromEmail ? extractDomain(dims.fromEmail) : null;
+    if (domain) {
+      const id = healthBucketId(domain, dims.kind);
+      writes.push(upsertCounter(ctx, id, domain, dims.kind, counter2, by, windowMs));
+    }
+  }
+  await Promise.all(writes);
+}
+async function upsertCounter(ctx, _id, senderDomain, kind, counter2, by, windowMs) {
+  await ctx.collections.health.updateOne(
+    { _id },
+    {
+      $inc: { [`counters.${counter2}`]: by },
+      $setOnInsert: {
+        _id,
+        senderDomain,
+        kind,
+        windowStartedAt: /* @__PURE__ */ new Date(),
+        windowDurationMs: windowMs,
+        status: "healthy",
+        trippedAt: null,
+        trippedReason: null,
+        manuallyResumedAt: null,
+        rates: { ...ZERO_RATES }
+      },
+      $set: { updatedAt: /* @__PURE__ */ new Date() }
+    },
+    { upsert: true }
+  );
+}
+async function evaluateHealth(ctx) {
+  const cb = ctx.config.circuitBreaker;
+  const windowMs = cb.windowMinutes * 60 * 1e3;
+  const docs = await ctx.collections.health.find({}).toArray();
+  if (docs.length === 0) return;
+  const hasAgg = docs.some((d) => d._id === HEALTH_AGG_ID);
+  if (!hasAgg) {
+    await upsertCounter(ctx, HEALTH_AGG_ID, null, null, "sent", 0, windowMs);
+  }
+  for (const doc of docs) {
+    const isAgg = doc._id === HEALTH_AGG_ID;
+    const windowAge = Date.now() - new Date(doc.windowStartedAt).getTime();
+    if (windowAge > windowMs && doc.status !== "tripped") {
+      await ctx.collections.health.updateOne(
+        { _id: doc._id },
+        {
+          $set: {
+            windowStartedAt: /* @__PURE__ */ new Date(),
+            windowDurationMs: windowMs,
+            counters: { ...ZERO_COUNTERS },
+            rates: { ...ZERO_RATES },
+            status: "healthy",
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      continue;
+    }
+    const c = doc.counters;
+    const total = c.sent || 1;
+    const rates = {
+      bounceRate: c.bounced / total,
+      hardBounceRate: c.hardBounced / total,
+      complaintRate: c.complained / total,
+      failureRate: c.failedToSend / total
+    };
+    await ctx.collections.health.updateOne(
+      { _id: doc._id },
+      { $set: { rates, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    if (isAgg) continue;
+    if (c.sent < cb.minSendsBeforeEval) continue;
+    if (doc.status === "tripped") continue;
+    let trippedReason = null;
+    if (rates.hardBounceRate * 100 >= cb.hardBounceRatePctTrip) {
+      trippedReason = `hard bounce rate ${(rates.hardBounceRate * 100).toFixed(2)}% >= ${cb.hardBounceRatePctTrip}%`;
+    } else if (rates.complaintRate * 100 >= cb.complaintRatePctTrip) {
+      trippedReason = `complaint rate ${(rates.complaintRate * 100).toFixed(2)}% >= ${cb.complaintRatePctTrip}%`;
+    } else if (rates.bounceRate * 100 >= cb.combinedBounceRatePctTrip) {
+      trippedReason = `combined bounce rate ${(rates.bounceRate * 100).toFixed(2)}% >= ${cb.combinedBounceRatePctTrip}%`;
+    }
+    if (trippedReason) {
+      const result = await ctx.collections.health.updateOne(
+        { _id: doc._id, status: { $in: ["healthy", "degraded"] } },
+        { $set: { status: "tripped", trippedAt: /* @__PURE__ */ new Date(), trippedReason, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      if (result.modifiedCount > 0) {
+        if (ctx.audit) {
+          try {
+            await ctx.audit({
+              actor: "system:circuit-breaker",
+              action: "health.trip",
+              resource: {
+                collection: "mailer_health",
+                id: String(doc._id),
+                slug: `${doc.senderDomain ?? "_unknown"}|${doc.kind}`
+              },
+              diffSummary: trippedReason
+            });
+          } catch {
+          }
+        }
+        if (ctx.config.onCircuitBreakerTrip) {
+          try {
+            await ctx.config.onCircuitBreakerTrip({
+              reason: `[${doc.senderDomain ?? "_unknown"} / ${doc.kind}] ${trippedReason}`,
+              rates
+            });
+          } catch {
+          }
+        }
+      }
+      continue;
+    }
+    if (rates.failureRate * 100 >= cb.failedToSendRatePctDegrade) {
+      if (doc.status !== "degraded") {
+        await ctx.collections.health.updateOne(
+          { _id: doc._id },
+          { $set: { status: "degraded", updatedAt: /* @__PURE__ */ new Date() } }
+        );
+      }
+    } else if (doc.status === "degraded") {
+      await ctx.collections.health.updateOne(
+        { _id: doc._id },
+        { $set: { status: "healthy", updatedAt: /* @__PURE__ */ new Date() } }
+      );
+    }
+  }
+}
+async function getBucketStatus(ctx, fromEmail, kind) {
+  const domain = fromEmail ? extractDomain(fromEmail) : null;
+  const id = healthBucketId(domain, kind);
+  return ctx.collections.health.findOne({ _id: id });
+}
+
+// src/server/runner/webhook.ts
+function dimsFromSend(send) {
+  if (!send) return null;
+  return { fromEmail: send.fromEmail, kind: send.kind };
+}
+async function processWebhookBacklog(ctx, opts = {}) {
+  const filter = { processed: false };
+  if (opts.olderThanMs) {
+    filter.receivedAt = { $lt: new Date(Date.now() - opts.olderThanMs) };
+  }
+  const batch = await ctx.collections.webhookEvents.find(filter).limit(500).toArray();
+  for (const evt of batch) {
+    const claimed = await ctx.collections.webhookEvents.findOneAndUpdate(
+      { _id: evt._id, processed: false },
+      { $set: { processed: true } }
+    );
+    if (!claimed) continue;
+    try {
+      const normalized = evt.raw?.normalized;
+      const details = normalized?.details ?? {};
+      await applyWebhookEvent(
+        {
+          type: evt.normalizedType,
+          providerEventId: evt.providerEventId,
+          providerMessageId: evt.providerMessageId,
+          email: evt.email,
+          occurredAt: evt.occurredAt,
+          details
+        },
+        ctx
+      );
+    } catch (err) {
+      console.error("mailery: webhook apply failed", { id: String(evt._id), err });
+    }
+  }
+}
+async function applyWebhookEvent(event, ctx) {
+  const send = await ctx.collections.sends.findOne(
+    event.providerMessageId ? { $or: [{ providerMessageId: event.providerMessageId }, { emailAtSend: event.email }] } : { emailAtSend: event.email },
+    { sort: { queuedAt: -1 } }
+  );
+  switch (event.type) {
+    case "delivered":
+      if (send) {
+        await ctx.collections.sends.updateOne(
+          { _id: send._id },
+          { $set: { status: "delivered", deliveredAt: event.occurredAt } }
+        );
+      }
+      await recordHealthCounter(ctx, "delivered", dimsFromSend(send));
+      break;
+    case "open":
+      if (send) {
+        await ctx.collections.sends.updateOne(
+          { _id: send._id },
+          {
+            $set: {
+              openedAt: send.openedAt ?? event.occurredAt,
+              status: send.status === "sent" ? "delivered" : send.status
+            },
+            $inc: { openCount: 1 }
+          }
+        );
+      }
+      break;
+    case "click":
+      if (send) {
+        await ctx.collections.sends.updateOne(
+          { _id: send._id },
+          {
+            $set: { firstClickAt: send.firstClickAt ?? event.occurredAt },
+            $inc: { clickCount: 1 },
+            $push: {
+              clickedLinks: {
+                url: event.details.clickedUrl ?? "",
+                linkId: "",
+                clickedAt: event.occurredAt
+              }
+            }
+          }
+        );
+      }
+      break;
+    case "bounce": {
+      const bounceType = event.details.bounceType ?? "hard";
+      if (send) {
+        await ctx.collections.sends.updateOne(
+          { _id: send._id },
+          {
+            $set: {
+              status: "bounced",
+              bounceType,
+              bounceReason: event.details.bounceReason ?? null
+            }
+          }
+        );
+      }
+      if (bounceType === "hard") {
+        await suppressOnce(ctx, event.email, "hard_bounce", "all");
+        await ctx.collections.subscriptions.updateOne(
+          { emailAtSubscribe: event.email },
+          { $set: { status: "bounced", updatedAt: /* @__PURE__ */ new Date() } }
+        );
+      }
+      {
+        const dims = dimsFromSend(send);
+        await recordHealthCounter(ctx, "bounced", dims);
+        await recordHealthCounter(ctx, bounceType === "hard" ? "hardBounced" : "softBounced", dims);
+      }
+      break;
+    }
+    case "complaint":
+    case "spam_report":
+      if (send) {
+        await ctx.collections.sends.updateOne(
+          { _id: send._id },
+          { $set: { complainedAt: event.occurredAt, status: "complained" } }
+        );
+      }
+      await suppressOnce(ctx, event.email, "complaint", "all");
+      await ctx.collections.subscriptions.updateOne(
+        { emailAtSubscribe: event.email },
+        { $set: { status: "complained", updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      await recordHealthCounter(ctx, "complained", dimsFromSend(send));
+      break;
+    case "unsubscribe":
+      if (send) {
+        await ctx.collections.sends.updateOne({ _id: send._id }, { $set: { unsubscribedAt: event.occurredAt } });
+      }
+      await suppressOnce(ctx, event.email, "unsubscribed", "marketing");
+      await ctx.collections.subscriptions.updateOne(
+        { emailAtSubscribe: event.email },
+        {
+          $set: {
+            status: "unsubscribed",
+            unsubscribedAt: event.occurredAt,
+            unsubscribeReason: "user_request",
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      break;
+  }
+}
+async function suppressOnce(ctx, email, reason, scope) {
+  const normalized = email.toLowerCase();
+  await ctx.collections.suppressions.updateOne(
+    { email: normalized, scope },
+    {
+      $setOnInsert: {
+        email: normalized,
+        emailHash: sha256Hex(normalized),
+        scope,
+        reason,
+        source: "provider_webhook",
+        notes: null,
+        addedAt: /* @__PURE__ */ new Date(),
+        expiresAt: null
+      }
+    },
+    { upsert: true }
+  );
+}
+
 // src/server/runner/predicate.ts
 var BOT_UA_RE = /Mimecast|SafeLinks|proofpoint|HeadlessChrome|Googlebot|bingbot/i;
 async function evaluatePredicate(predicate, ctx) {
@@ -15207,7 +15557,8 @@ function applyTracking(html, opts) {
   const seen = /* @__PURE__ */ new Map();
   let out = html;
   if (opts.trackClicks) {
-    out = out.replace(/<a\b([^>]*?)\bhref=(["'])([^"']+)\2([^>]*)>/gi, (full, pre, _q, url, post) => {
+    out = out.replace(/<a\b([^>]*?)\bhref=(["'])([^"']+)\2([^>]*)>/gi, (full, pre, _q, rawUrl, post) => {
+      const url = decodeHtmlEntities(rawUrl);
       if (shouldSkipClickRewrite(url, preserve, full)) return full;
       let linkId = seen.get(url);
       if (!linkId) {
@@ -15239,6 +15590,29 @@ function shouldSkipClickRewrite(url, preserve, fullTag) {
   if (/data-mailer-notrack=["']true["']/.test(fullTag)) return true;
   return false;
 }
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+function decodeHtmlEntities(input) {
+  return input.replace(/&(#x[0-9a-f]+|#\d+|[a-z][a-z0-9]*);/gi, (match, body) => {
+    if (body[0] === "#") {
+      const code = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+      if (!Number.isFinite(code) || code < 0 || code > 1114111) return match;
+      try {
+        return String.fromCodePoint(code);
+      } catch {
+        return match;
+      }
+    }
+    const named = NAMED_ENTITIES[body.toLowerCase()];
+    return named ?? match;
+  });
+}
 function shortHash(input) {
   return crypto2.createHash("sha256").update(input).digest("hex").slice(0, 12);
 }
@@ -15307,175 +15681,11 @@ async function isSuppressed(collections, email, kind) {
   return { suppressed: false };
 }
 
-// src/server/templates/sender-domain.ts
-function extractDomain(email) {
-  if (typeof email !== "string") return null;
-  const at = email.lastIndexOf("@");
-  if (at <= 0 || at === email.length - 1) return null;
-  return email.slice(at + 1).toLowerCase().trim();
-}
-
-// src/server/runner/health.ts
-var ZERO_COUNTERS = {
-  sent: 0,
-  delivered: 0,
-  bounced: 0,
-  hardBounced: 0,
-  softBounced: 0,
-  complained: 0,
-  failedToSend: 0
-};
-var ZERO_RATES = {
-  bounceRate: 0,
-  hardBounceRate: 0,
-  complaintRate: 0,
-  failureRate: 0
-};
-async function recordHealthCounter(ctx, counter2, dims, by = 1) {
-  const windowMs = ctx.config.circuitBreaker.windowMinutes * 60 * 1e3;
-  const writes = [];
-  writes.push(upsertCounter(ctx, HEALTH_AGG_ID, null, null, counter2, by, windowMs));
-  if (dims) {
-    const domain = dims.fromEmail ? extractDomain(dims.fromEmail) : null;
-    if (domain) {
-      const id = healthBucketId(domain, dims.kind);
-      writes.push(upsertCounter(ctx, id, domain, dims.kind, counter2, by, windowMs));
-    }
-  }
-  await Promise.all(writes);
-}
-async function upsertCounter(ctx, _id, senderDomain, kind, counter2, by, windowMs) {
-  await ctx.collections.health.updateOne(
-    { _id },
-    {
-      $inc: { [`counters.${counter2}`]: by },
-      $setOnInsert: {
-        _id,
-        senderDomain,
-        kind,
-        windowStartedAt: /* @__PURE__ */ new Date(),
-        windowDurationMs: windowMs,
-        status: "healthy",
-        trippedAt: null,
-        trippedReason: null,
-        manuallyResumedAt: null,
-        rates: { ...ZERO_RATES }
-      },
-      $set: { updatedAt: /* @__PURE__ */ new Date() }
-    },
-    { upsert: true }
-  );
-}
-async function evaluateHealth(ctx) {
-  const cb = ctx.config.circuitBreaker;
-  const windowMs = cb.windowMinutes * 60 * 1e3;
-  const docs = await ctx.collections.health.find({}).toArray();
-  if (docs.length === 0) return;
-  const hasAgg = docs.some((d) => d._id === HEALTH_AGG_ID);
-  if (!hasAgg) {
-    await upsertCounter(ctx, HEALTH_AGG_ID, null, null, "sent", 0, windowMs);
-  }
-  for (const doc of docs) {
-    const isAgg = doc._id === HEALTH_AGG_ID;
-    const windowAge = Date.now() - new Date(doc.windowStartedAt).getTime();
-    if (windowAge > windowMs && doc.status !== "tripped") {
-      await ctx.collections.health.updateOne(
-        { _id: doc._id },
-        {
-          $set: {
-            windowStartedAt: /* @__PURE__ */ new Date(),
-            windowDurationMs: windowMs,
-            counters: { ...ZERO_COUNTERS },
-            rates: { ...ZERO_RATES },
-            status: "healthy",
-            updatedAt: /* @__PURE__ */ new Date()
-          }
-        }
-      );
-      continue;
-    }
-    const c = doc.counters;
-    const total = c.sent || 1;
-    const rates = {
-      bounceRate: c.bounced / total,
-      hardBounceRate: c.hardBounced / total,
-      complaintRate: c.complained / total,
-      failureRate: c.failedToSend / total
-    };
-    await ctx.collections.health.updateOne(
-      { _id: doc._id },
-      { $set: { rates, updatedAt: /* @__PURE__ */ new Date() } }
-    );
-    if (isAgg) continue;
-    if (c.sent < cb.minSendsBeforeEval) continue;
-    if (doc.status === "tripped") continue;
-    let trippedReason = null;
-    if (rates.hardBounceRate * 100 >= cb.hardBounceRatePctTrip) {
-      trippedReason = `hard bounce rate ${(rates.hardBounceRate * 100).toFixed(2)}% >= ${cb.hardBounceRatePctTrip}%`;
-    } else if (rates.complaintRate * 100 >= cb.complaintRatePctTrip) {
-      trippedReason = `complaint rate ${(rates.complaintRate * 100).toFixed(2)}% >= ${cb.complaintRatePctTrip}%`;
-    } else if (rates.bounceRate * 100 >= cb.combinedBounceRatePctTrip) {
-      trippedReason = `combined bounce rate ${(rates.bounceRate * 100).toFixed(2)}% >= ${cb.combinedBounceRatePctTrip}%`;
-    }
-    if (trippedReason) {
-      const result = await ctx.collections.health.updateOne(
-        { _id: doc._id, status: { $in: ["healthy", "degraded"] } },
-        { $set: { status: "tripped", trippedAt: /* @__PURE__ */ new Date(), trippedReason, updatedAt: /* @__PURE__ */ new Date() } }
-      );
-      if (result.modifiedCount > 0) {
-        if (ctx.audit) {
-          try {
-            await ctx.audit({
-              actor: "system:circuit-breaker",
-              action: "health.trip",
-              resource: {
-                collection: "mailer_health",
-                id: String(doc._id),
-                slug: `${doc.senderDomain ?? "_unknown"}|${doc.kind}`
-              },
-              diffSummary: trippedReason
-            });
-          } catch {
-          }
-        }
-        if (ctx.config.onCircuitBreakerTrip) {
-          try {
-            await ctx.config.onCircuitBreakerTrip({
-              reason: `[${doc.senderDomain ?? "_unknown"} / ${doc.kind}] ${trippedReason}`,
-              rates
-            });
-          } catch {
-          }
-        }
-      }
-      continue;
-    }
-    if (rates.failureRate * 100 >= cb.failedToSendRatePctDegrade) {
-      if (doc.status !== "degraded") {
-        await ctx.collections.health.updateOne(
-          { _id: doc._id },
-          { $set: { status: "degraded", updatedAt: /* @__PURE__ */ new Date() } }
-        );
-      }
-    } else if (doc.status === "degraded") {
-      await ctx.collections.health.updateOne(
-        { _id: doc._id },
-        { $set: { status: "healthy", updatedAt: /* @__PURE__ */ new Date() } }
-      );
-    }
-  }
-}
-async function getBucketStatus(ctx, fromEmail, kind) {
-  const domain = fromEmail ? extractDomain(fromEmail) : null;
-  const id = healthBucketId(domain, kind);
-  return ctx.collections.health.findOne({ _id: id });
-}
-
 // src/server/runner/send.ts
-async function handleSend(run, step, contact, flow, ctx) {
-  const template = await ctx.collections.templates.findOne({ slug: step.templateSlug });
+async function handleSend(run, step2, contact, flow, ctx) {
+  const template = await ctx.collections.templates.findOne({ slug: step2.templateSlug });
   if (!template) {
-    await failFlowRun(run, `template not found: ${step.templateSlug}`, ctx);
+    await failFlowRun(run, `template not found: ${step2.templateSlug}`, ctx);
     return;
   }
   const dedupeKey = `flowrun:${run._id}:step${run.currentStepIndex}`;
@@ -15487,8 +15697,8 @@ async function handleSend(run, step, contact, flow, ctx) {
     });
     return;
   }
-  const providerName = pickProviderName(step.providerOverride, template, ctx);
-  const renderCtx = buildRenderContext(contact, run, step.vars ?? {}, ctx);
+  const providerName = pickProviderName(step2.providerOverride, template, ctx);
+  const renderCtx = buildRenderContext(contact, run, step2.vars ?? {}, ctx);
   let rendered;
   try {
     rendered = await renderTemplate(template, renderCtx, { helpers: ctx.handlebarsHelpers });
@@ -15525,7 +15735,7 @@ async function handleSend(run, step, contact, flow, ctx) {
       bodyHash: sha256(rendered.html),
       status: "queued",
       renderedFrom: rendered.fromName ? { name: rendered.fromName, email: rendered.fromEmail } : void 0,
-      vars: step.vars ?? {}
+      vars: step2.vars ?? {}
     })
   );
   await ctx.queues.send.add(
@@ -15536,9 +15746,11 @@ async function handleSend(run, step, contact, flow, ctx) {
   await advanceStep(run, ctx, { action: "sent", details: { dedupeKey, sendId: String(sendId) } });
 }
 async function dispatchSend(sendId, ctx) {
-  const send = await ctx.collections.sends.findOne({ _id: sendId });
+  const send = await ctx.collections.sends.findOneAndUpdate(
+    { _id: sendId, status: { $in: ["queued", "failed"] } },
+    { $set: { status: "sending", updatedAt: /* @__PURE__ */ new Date() } }
+  );
   if (!send) return;
-  if (send.status !== "queued" && send.status !== "failed") return;
   const template = await ctx.collections.templates.findOne({ _id: send.templateId });
   if (!template) {
     await markFailed(send._id, "template_missing", ctx);
@@ -15555,6 +15767,10 @@ async function dispatchSend(sendId, ctx) {
   if (send.kind === "marketing") {
     const bucket = await getBucketStatus(ctx, send.fromEmail, send.kind);
     if (bucket?.status === "tripped") {
+      await ctx.collections.sends.updateOne(
+        { _id: send._id },
+        { $set: { status: "queued", updatedAt: /* @__PURE__ */ new Date() } }
+      );
       await ctx.queues.send.add("send", { sendId: String(send._id) }, { delay: 6e4 });
       return;
     }
@@ -15614,6 +15830,10 @@ async function dispatchSend(sendId, ctx) {
     await markFailed(send._id, `provider_unknown: ${send.provider}`, ctx);
     return;
   }
+  const headers = send.kind === "marketing" ? {
+    "List-Unsubscribe": `<${renderCtx.unsubscribeUrl}>`,
+    "List-Unsubscribe-Post": "List-Unsubscribe=One-Click"
+  } : {};
   try {
     const result = await provider.send({
       to: send.emailAtSend,
@@ -15623,10 +15843,7 @@ async function dispatchSend(sendId, ctx) {
       subject: rendered.subject,
       html: tracking.html,
       text: rendered.plainText,
-      headers: {
-        "List-Unsubscribe": `<${renderCtx.unsubscribeUrl}>`,
-        "List-Unsubscribe-Post": "List-Unsubscribe=One-Click"
-      },
+      headers,
       messageMeta: { sendId: String(send._id) }
     });
     await ctx.collections.sends.updateOne(
@@ -15738,8 +15955,8 @@ async function processOneRunStep(runId, ctx) {
     return;
   }
   const steps = await loadStepsForRun(run, flow, ctx);
-  const step = locateStep(steps, run.currentStepIndex, run.currentBranchPath);
-  if (!step) {
+  const step2 = locateStep(steps, run.currentStepIndex, run.currentBranchPath);
+  if (!step2) {
     await completeFlowRun(run, "completed", ctx);
     return;
   }
@@ -15753,34 +15970,34 @@ async function processOneRunStep(runId, ctx) {
     await exitFlowRun(run, sub.status, ctx);
     return;
   }
-  switch (step.type) {
+  switch (step2.type) {
     case "wait":
-      return handleWait(run, step, ctx);
+      return handleWait(run, step2, ctx);
     case "condition":
-      return handleCondition(run, step, contact, ctx);
+      return handleCondition(run, step2, contact, ctx);
     case "branch":
-      return handleBranch(run, step, contact, ctx);
+      return handleBranch(run, step2, contact, ctx);
     case "send": {
-      if (step.delivery) {
-        const deliverAt = computeDeliveryTime(/* @__PURE__ */ new Date(), step.delivery, contact.timezone);
+      if (step2.delivery) {
+        const deliverAt = computeDeliveryTime(/* @__PURE__ */ new Date(), step2.delivery, contact.timezone);
         if (deliverAt.getTime() > Date.now() + 3e4) {
           return deferSendForWindow(run, deliverAt, ctx);
         }
       }
-      return handleSend(run, step, contact, flow, ctx);
+      return handleSend(run, step2, contact, flow, ctx);
     }
     case "tag":
-      return handleTag(run, step, ctx);
+      return handleTag(run, step2, ctx);
     case "fire_event":
-      return handleFireEvent(run, step, ctx);
+      return handleFireEvent(run, step2, ctx);
     case "webhook":
-      return handleWebhookStep(run, step, ctx);
+      return handleWebhookStep(run, step2, ctx);
     case "exit":
-      return exitFlowRun(run, step.reason ?? "exit_step", ctx);
+      return exitFlowRun(run, step2.reason ?? "exit_step", ctx);
   }
 }
-async function handleWait(run, step, ctx) {
-  const ms = unitToMs(step.value, step.unit);
+async function handleWait(run, step2, ctx) {
+  const ms = unitToMs(step2.value, step2.unit);
   const nextAt = new Date(Date.now() + ms);
   const updated = await ctx.collections.flowRuns.findOneAndUpdate(
     { _id: run._id, currentStepIndex: run.currentStepIndex },
@@ -15802,25 +16019,25 @@ async function handleWait(run, step, ctx) {
   await ctx.queues.advance.add(
     "advance",
     { flowRunId: String(run._id) },
-    { delay: ms, jobId: `advance:${run._id}:${run.currentStepIndex + 1}` }
+    { delay: ms, jobId: `advance:${run._id}:${branchKey(run)}:${run.currentStepIndex + 1}` }
   );
 }
-async function handleCondition(run, step, contact, ctx) {
+async function handleCondition(run, step2, contact, ctx) {
   if (!contact) return;
-  const result = await evaluatePredicate(step.test, { contact, run, collections: ctx.collections });
+  const result = await evaluatePredicate(step2.test, { contact, run, collections: ctx.collections });
   if (result) {
     await advanceStep(run, ctx, { action: "condition_evaluated", details: { result: true } });
     return;
   }
-  if (step.ifFalse === "continue") {
+  if (step2.ifFalse === "continue") {
     await advanceStep(run, ctx, { action: "condition_evaluated", details: { result: false, skipped: 1 } }, { stepInc: 2 });
     return;
   }
   await exitFlowRun(run, "condition_false", ctx);
 }
-async function handleBranch(run, step, contact, ctx) {
+async function handleBranch(run, step2, contact, ctx) {
   if (!contact) return;
-  const result = await evaluatePredicate(step.test, { contact, run, collections: ctx.collections });
+  const result = await evaluatePredicate(step2.test, { contact, run, collections: ctx.collections });
   const newPath = [...run.currentBranchPath, run.currentStepIndex, result ? "true" : "false", 0];
   const updated = await ctx.collections.flowRuns.findOneAndUpdate(
     { _id: run._id, currentStepIndex: run.currentStepIndex },
@@ -15846,9 +16063,9 @@ async function handleBranch(run, step, contact, ctx) {
   if (!updated) return;
   await ctx.queues.advance.add("advance", { flowRunId: String(run._id) });
 }
-async function handleTag(run, step, ctx) {
-  const adds = step.addTags ?? [];
-  const removes = step.removeTags ?? [];
+async function handleTag(run, step2, ctx) {
+  const adds = step2.addTags ?? [];
+  const removes = step2.removeTags ?? [];
   if (ctx.adapter.addTags && adds.length > 0) {
     await ctx.adapter.addTags(run.externalId, adds);
   } else if (adds.length > 0) {
@@ -15869,13 +16086,13 @@ async function handleTag(run, step, ctx) {
   }
   await advanceStep(run, ctx, { action: "tagged", details: { addTags: adds, removeTags: removes } });
 }
-async function handleFireEvent(run, step, ctx) {
-  const dedupeKey = `flowrun:${run._id}:step${run.currentStepIndex}:${step.eventName}`;
+async function handleFireEvent(run, step2, ctx) {
+  const dedupeKey = `flowrun:${run._id}:step${run.currentStepIndex}:${step2.eventName}`;
   try {
     await ctx.collections.events.insertOne({
       externalId: run.externalId,
-      name: step.eventName,
-      properties: step.properties ?? {},
+      name: step2.eventName,
+      properties: step2.properties ?? {},
       dedupeKey,
       occurredAt: /* @__PURE__ */ new Date(),
       createdAt: /* @__PURE__ */ new Date()
@@ -15883,27 +16100,27 @@ async function handleFireEvent(run, step, ctx) {
   } catch (err) {
     if (err?.code !== 11e3) throw err;
   }
-  await advanceStep(run, ctx, { action: "event_fired", details: { name: step.eventName } });
+  await advanceStep(run, ctx, { action: "event_fired", details: { name: step2.eventName } });
 }
-async function handleWebhookStep(run, step, ctx) {
+async function handleWebhookStep(run, step2, ctx) {
   try {
-    const res = await fetch(step.url, {
-      method: step.method ?? "POST",
+    const res = await fetch(step2.url, {
+      method: step2.method ?? "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(step.payload ?? { externalId: run.externalId, flowRunId: String(run._id) }),
+      body: JSON.stringify(step2.payload ?? { externalId: run.externalId, flowRunId: String(run._id) }),
       signal: AbortSignal.timeout(1e4)
     });
     if (!res.ok) throw new Error(`webhook step returned ${res.status}`);
-    await advanceStep(run, ctx, { action: "webhook_called", details: { url: step.url, status: res.status } });
+    await advanceStep(run, ctx, { action: "webhook_called", details: { url: step2.url, status: res.status } });
   } catch (err) {
     const attempts = (run.attemptsForCurrentStep ?? 0) + 1;
     if (attempts >= ctx.config.webhookRetryAttempts) {
-      if (step.failureMode === "fail_run") {
+      if (step2.failureMode === "fail_run") {
         await failFlowRun(run, `webhook failed: ${err?.message}`, ctx);
       } else {
         await advanceStep(run, ctx, {
           action: "webhook_called",
-          details: { url: step.url, error: err?.message, exhausted: true }
+          details: { url: step2.url, error: err?.message, exhausted: true }
         });
       }
     } else {
@@ -15914,7 +16131,7 @@ async function handleWebhookStep(run, step, ctx) {
       await ctx.queues.advance.add(
         "advance",
         { flowRunId: String(run._id) },
-        { delay: 6e4, jobId: `advance:${run._id}:${run.currentStepIndex}:retry-${attempts}` }
+        { delay: 6e4, jobId: `advance:${run._id}:${branchKey(run)}:${run.currentStepIndex}:retry-${attempts}` }
       );
     }
   }
@@ -15943,7 +16160,7 @@ async function deferSendForWindow(run, deliverAt, ctx) {
     { flowRunId: String(run._id) },
     {
       delay: Math.max(0, deliverAt.getTime() - Date.now()),
-      jobId: `advance:${run._id}:${run.currentStepIndex}:window:${deliverAt.getTime()}`
+      jobId: `advance:${run._id}:${branchKey(run)}:${run.currentStepIndex}:window:${deliverAt.getTime()}`
     }
   );
 }
@@ -15998,13 +16215,16 @@ function locateStep(steps, currentStepIndex, branchPath) {
   let arr = steps;
   for (let i = 0; i < branchPath.length; i += 3) {
     const parentIndex = branchPath[i];
-    const branchKey = branchPath[i + 1];
+    const branchKey2 = branchPath[i + 1];
     const parent = arr[parentIndex];
     if (!parent || parent.type !== "branch") return null;
-    arr = branchKey === "true" ? parent.ifTrueSteps : parent.ifFalseSteps;
+    arr = branchKey2 === "true" ? parent.ifTrueSteps : parent.ifFalseSteps;
   }
   return arr[currentStepIndex] ?? null;
 }
+function branchKey(run) {
+  return run.currentBranchPath.join("_");
+}
 function unitToMs(value, unit) {
   const m = 6e4;
   switch (unit) {
@@ -16031,6 +16251,7 @@ async function sweepStrandedFlowRuns(ctx) {
     }
   }
 }
+var STALLED_BROADCAST_THRESHOLD_MS = 10 * 60 * 1e3;
 async function processScheduledBroadcasts(ctx) {
   const now = /* @__PURE__ */ new Date();
   const due = await ctx.collections.broadcasts.find({ status: "scheduled", scheduledAt: { $lte: now } }).toArray();
@@ -16041,15 +16262,49 @@ async function processScheduledBroadcasts(ctx) {
       { returnDocument: "after" }
     );
     if (!claimed) continue;
-    try {
-      await dispatchBroadcast(claimed, ctx);
-    } catch (err) {
-      console.error("mailery: broadcast dispatch failed", { id: String(b._id), err });
-      await ctx.collections.broadcasts.updateOne(
-        { _id: b._id },
-        { $set: { status: "failed", updatedAt: /* @__PURE__ */ new Date() } }
-      );
+    await startBroadcastDispatch(claimed, ctx);
+  }
+}
+async function startBroadcastDispatch(broadcast, ctx) {
+  if (ctx.config.queue.driver === "noop") {
+    await runBroadcastDispatch(broadcast, ctx);
+    return;
+  }
+  await ctx.queues.advance.add(
+    "advance",
+    { broadcastId: String(broadcast._id) },
+    {
+      attempts: 3,
+      backoff: { type: "exponential", delay: 6e4 },
+      jobId: `broadcast-dispatch:${broadcast._id}`
     }
+  );
+}
+async function dispatchBroadcastById(broadcastId, ctx) {
+  const broadcast = await ctx.collections.broadcasts.findOne({ _id: broadcastId, status: "sending" });
+  if (!broadcast) return;
+  await runBroadcastDispatch(broadcast, ctx);
+}
+async function resumeStalledBroadcasts(ctx) {
+  const cutoff = new Date(Date.now() - STALLED_BROADCAST_THRESHOLD_MS);
+  const stalled = await ctx.collections.broadcasts.find({ status: "sending", updatedAt: { $lt: cutoff } }).toArray();
+  for (const b of stalled) {
+    await ctx.collections.broadcasts.updateOne(
+      { _id: b._id },
+      { $set: { updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    await startBroadcastDispatch(b, ctx);
+  }
+}
+async function runBroadcastDispatch(broadcast, ctx) {
+  try {
+    await dispatchBroadcast(broadcast, ctx);
+  } catch (err) {
+    console.error("mailery: broadcast dispatch failed", { id: String(broadcast._id), err });
+    await ctx.collections.broadcasts.updateOne(
+      { _id: broadcast._id },
+      { $set: { status: "failed", updatedAt: /* @__PURE__ */ new Date() } }
+    );
   }
 }
 async function dispatchBroadcast(broadcast, ctx) {
@@ -16070,11 +16325,19 @@ async function dispatchBroadcast(broadcast, ctx) {
   const respectTimezone = broadcast.respectRecipientTimezone === true;
   const scheduledMs = broadcast.scheduledAt?.getTime() ?? Date.now();
   for (; ; ) {
+    await ctx.collections.broadcasts.updateOne(
+      { _id: broadcast._id },
+      { $set: { updatedAt: /* @__PURE__ */ new Date() } }
+    );
     const page = await ctx.adapter.query(hostFilter, { limit: batchSize, cursor });
     if (page.contacts.length === 0) break;
     const eligible = await applyPostFilters(page.contacts, postFilters, ctx);
     if (eligible.length > 0) {
       while (await ctx.queues.send.getWaitingCount() > maxWaiting) {
+        await ctx.collections.broadcasts.updateOne(
+          { _id: broadcast._id },
+          { $set: { updatedAt: /* @__PURE__ */ new Date() } }
+        );
         await sleep(2e3);
       }
       const sendDocs = await Promise.all(
@@ -16197,7 +16460,8 @@ async function buildSendDoc(broadcast, template, contact, ctx, scheduledMs, resp
   const dedupeKey = `broadcast:${broadcast._id}:${contact.externalId}`;
   let delayMs = Math.max(0, scheduledMs - Date.now());
   if (respectTimezone && contact.timezone) {
-    delayMs = Math.max(0, perRecipientDelayMs(scheduledMs, contact.timezone));
+    const offsetMs = perRecipientOffsetMs(scheduledMs, contact.timezone);
+    delayMs = Math.max(0, scheduledMs + offsetMs - Date.now());
   }
   const doc = {
     _id: sendId,
@@ -16236,7 +16500,8 @@ async function buildSendDoc(broadcast, template, contact, ctx, scheduledMs, resp
   };
   return { doc, delayMs };
 }
-function perRecipientDelayMs(scheduledMs, timezone) {
+function perRecipientOffsetMs(scheduledMs, timezone) {
+  const DAY_MS = 24 * 60 * 60 * 1e3;
   try {
     const scheduled = new Date(scheduledMs);
     const utc = scheduled.toLocaleString("en-US", { timeZone: "UTC", hour12: false });
@@ -16249,7 +16514,7 @@ function perRecipientDelayMs(scheduledMs, timezone) {
     const utcMs = parse(utc);
     const localMs = parse(local);
     const offsetMs = utcMs - localMs;
-    return offsetMs;
+    return (offsetMs % DAY_MS + DAY_MS) % DAY_MS;
   } catch {
     return 0;
   }
@@ -16924,6 +17189,7 @@ async function pruneDmarcFailures(ctx, opts = {}) {
 
 // src/server/runner/tick.ts
 var STRANDED_SEND_THRESHOLD_MS = 5 * 60 * 1e3;
+var STRANDED_WEBHOOK_THRESHOLD_MS = 5 * 60 * 1e3;
 async function runTick(ctx) {
   try {
     await ctx.collections.health.updateOne(
@@ -16964,12 +17230,18 @@ async function runTick(ctx) {
   await processScheduledBroadcasts2(ctx).catch((err) => {
     console.error("mailery: broadcast dispatch failed", err);
   });
+  await resumeStalledBroadcasts(ctx).catch((err) => {
+    console.error("mailery: stalled-broadcast resume failed", err);
+  });
   await evaluateHealth(ctx).catch((err) => {
     console.error("mailery: health evaluation failed", err);
   });
   await promoteSoftBounces(ctx).catch((err) => {
     console.error("mailery: soft-bounce promotion failed", err);
   });
+  await processWebhookBacklog(ctx, { olderThanMs: STRANDED_WEBHOOK_THRESHOLD_MS }).catch((err) => {
+    console.error("mailery: stranded-webhook drain failed", err);
+  });
   await Promise.all([
     runDnsblChecks(ctx).catch((err) => {
       console.error("mailery: dnsbl checks failed", err);
@@ -17040,140 +17312,6 @@ async function processScheduledBroadcasts2(ctx) {
   await processScheduledBroadcasts(ctx);
 }
 
-// src/server/runner/webhook.ts
-function dimsFromSend(send) {
-  if (!send) return null;
-  return { fromEmail: send.fromEmail, kind: send.kind };
-}
-async function applyWebhookEvent(event, ctx) {
-  const send = await ctx.collections.sends.findOne(
-    event.providerMessageId ? { $or: [{ providerMessageId: event.providerMessageId }, { emailAtSend: event.email }] } : { emailAtSend: event.email },
-    { sort: { queuedAt: -1 } }
-  );
-  switch (event.type) {
-    case "delivered":
-      if (send) {
-        await ctx.collections.sends.updateOne(
-          { _id: send._id },
-          { $set: { status: "delivered", deliveredAt: event.occurredAt } }
-        );
-      }
-      await recordHealthCounter(ctx, "delivered", dimsFromSend(send));
-      break;
-    case "open":
-      if (send) {
-        await ctx.collections.sends.updateOne(
-          { _id: send._id },
-          {
-            $set: {
-              openedAt: send.openedAt ?? event.occurredAt,
-              status: send.status === "sent" ? "delivered" : send.status
-            },
-            $inc: { openCount: 1 }
-          }
-        );
-      }
-      break;
-    case "click":
-      if (send) {
-        await ctx.collections.sends.updateOne(
-          { _id: send._id },
-          {
-            $set: { firstClickAt: send.firstClickAt ?? event.occurredAt },
-            $inc: { clickCount: 1 },
-            $push: {
-              clickedLinks: {
-                url: event.details.clickedUrl ?? "",
-                linkId: "",
-                clickedAt: event.occurredAt
-              }
-            }
-          }
-        );
-      }
-      break;
-    case "bounce": {
-      const bounceType = event.details.bounceType ?? "hard";
-      if (send) {
-        await ctx.collections.sends.updateOne(
-          { _id: send._id },
-          {
-            $set: {
-              status: "bounced",
-              bounceType,
-              bounceReason: event.details.bounceReason ?? null
-            }
-          }
-        );
-      }
-      if (bounceType === "hard") {
-        await suppressOnce(ctx, event.email, "hard_bounce", "all");
-        await ctx.collections.subscriptions.updateOne(
-          { emailAtSubscribe: event.email },
-          { $set: { status: "bounced", updatedAt: /* @__PURE__ */ new Date() } }
-        );
-      }
-      {
-        const dims = dimsFromSend(send);
-        await recordHealthCounter(ctx, "bounced", dims);
-        await recordHealthCounter(ctx, bounceType === "hard" ? "hardBounced" : "softBounced", dims);
-      }
-      break;
-    }
-    case "complaint":
-    case "spam_report":
-      if (send) {
-        await ctx.collections.sends.updateOne(
-          { _id: send._id },
-          { $set: { complainedAt: event.occurredAt, status: "complained" } }
-        );
-      }
-      await suppressOnce(ctx, event.email, "complaint", "all");
-      await ctx.collections.subscriptions.updateOne(
-        { emailAtSubscribe: event.email },
-        { $set: { status: "complained", updatedAt: /* @__PURE__ */ new Date() } }
-      );
-      await recordHealthCounter(ctx, "complained", dimsFromSend(send));
-      break;
-    case "unsubscribe":
-      if (send) {
-        await ctx.collections.sends.updateOne({ _id: send._id }, { $set: { unsubscribedAt: event.occurredAt } });
-      }
-      await suppressOnce(ctx, event.email, "unsubscribed", "marketing");
-      await ctx.collections.subscriptions.updateOne(
-        { emailAtSubscribe: event.email },
-        {
-          $set: {
-            status: "unsubscribed",
-            unsubscribedAt: event.occurredAt,
-            unsubscribeReason: "user_request",
-            updatedAt: /* @__PURE__ */ new Date()
-          }
-        }
-      );
-      break;
-  }
-}
-async function suppressOnce(ctx, email, reason, scope) {
-  const normalized = email.toLowerCase();
-  await ctx.collections.suppressions.updateOne(
-    { email: normalized, scope },
-    {
-      $setOnInsert: {
-        email: normalized,
-        emailHash: sha256Hex(normalized),
-        scope,
-        reason,
-        source: "provider_webhook",
-        notes: null,
-        addedAt: /* @__PURE__ */ new Date(),
-        expiresAt: null
-      }
-    },
-    { upsert: true }
-  );
-}
-
 // src/server/mailer.ts
 var Mailer = class _Mailer {
   db;
@@ -17638,41 +17776,48 @@ var Mailer = class _Mailer {
     if (existing) return { sendId: String(existing._id) };
     const providerName = parsed.providerOverride ?? template.providerOverride ?? (template.kind === "transactional" ? this.config.defaultTransactionalProvider : null) ?? this.config.defaultProvider;
     const sendId = new ObjectId();
-    await this.collections.sends.insertOne({
-      _id: sendId,
-      dedupeKey,
-      externalId: parsed.externalId,
-      emailAtSend: contact.email,
-      templateId: template._id,
-      templateSlug: template.slug,
-      flowRunId: null,
-      broadcastId: null,
-      manualSendBy: "sendOneOff",
-      kind: template.kind,
-      provider: providerName,
-      providerMessageId: null,
-      fromName: template.fromName,
-      fromEmail: template.fromEmail,
-      subject: template.subject,
-      bodyHash: "",
-      status: "queued",
-      errorMessage: null,
-      bounceType: null,
-      bounceReason: null,
-      links: [],
-      vars: parsed.vars ?? {},
-      openedAt: null,
-      openCount: 0,
-      firstClickAt: null,
-      clickCount: 0,
-      clickedLinks: [],
-      unsubscribedAt: null,
-      complainedAt: null,
-      queuedAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      sentAt: null,
-      deliveredAt: null
-    });
+    try {
+      await this.collections.sends.insertOne({
+        _id: sendId,
+        dedupeKey,
+        externalId: parsed.externalId,
+        emailAtSend: contact.email,
+        templateId: template._id,
+        templateSlug: template.slug,
+        flowRunId: null,
+        broadcastId: null,
+        manualSendBy: "sendOneOff",
+        kind: template.kind,
+        provider: providerName,
+        providerMessageId: null,
+        fromName: template.fromName,
+        fromEmail: template.fromEmail,
+        subject: template.subject,
+        bodyHash: "",
+        status: "queued",
+        errorMessage: null,
+        bounceType: null,
+        bounceReason: null,
+        links: [],
+        vars: parsed.vars ?? {},
+        openedAt: null,
+        openCount: 0,
+        firstClickAt: null,
+        clickCount: 0,
+        clickedLinks: [],
+        unsubscribedAt: null,
+        complainedAt: null,
+        queuedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        sentAt: null,
+        deliveredAt: null
+      });
+    } catch (err) {
+      if (err?.code !== 11e3) throw err;
+      const winner = await this.collections.sends.findOne({ dedupeKey });
+      if (winner) return { sendId: String(winner._id) };
+      throw err;
+    }
     await this.queues.send.add(
       "send",
       { sendId: String(sendId) },
@@ -17716,7 +17861,12 @@ var Mailer = class _Mailer {
           await runTick(this.runnerContext);
         },
         advance: async (data) => {
-          if (!ObjectId.isValid(data.flowRunId)) return;
+          if (data.broadcastId) {
+            if (!ObjectId.isValid(data.broadcastId)) return;
+            await dispatchBroadcastById(new ObjectId(data.broadcastId), this.runnerContext);
+            return;
+          }
+          if (!data.flowRunId || !ObjectId.isValid(data.flowRunId)) return;
           await processOneRunStep(new ObjectId(data.flowRunId), this.runnerContext);
         },
         send: async (data) => {
@@ -17732,27 +17882,7 @@ var Mailer = class _Mailer {
   }
   /** Process unprocessed webhook events in mailer_webhook_events. */
   async processWebhookBacklog() {
-    const batch = await this.collections.webhookEvents.find({ processed: false }).limit(500).toArray();
-    for (const evt of batch) {
-      try {
-        const normalized = evt.raw?.normalized;
-        const details = normalized?.details ?? {};
-        await applyWebhookEvent(
-          {
-            type: evt.normalizedType,
-            providerEventId: evt.providerEventId,
-            providerMessageId: evt.providerMessageId,
-            email: evt.email,
-            occurredAt: evt.occurredAt,
-            details
-          },
-          this.runnerContext
-        );
-        await this.collections.webhookEvents.updateOne({ _id: evt._id }, { $set: { processed: true } });
-      } catch (err) {
-        console.error("mailery: webhook apply failed", { id: String(evt._id), err });
-      }
-    }
+    await processWebhookBacklog(this.runnerContext);
   }
   async stop() {
     await this.queueDriver.close();
@@ -17839,6 +17969,207 @@ function matches(c, f) {
   return true;
 }
 
+// src/testing/recording-provider.ts
+var RecordingProvider = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  /** Every `SendArgs` handed to the provider, in call order. */
+  sent = [];
+  /** Same calls, with outcome attached. */
+  records = [];
+  get name() {
+    return this.inner.name;
+  }
+  get sendRatePerSecond() {
+    return this.inner.sendRatePerSecond;
+  }
+  async send(args) {
+    this.sent.push(args);
+    const record = { args, result: null, error: null, durationMs: 0, at: /* @__PURE__ */ new Date() };
+    this.records.push(record);
+    const startedAt = Date.now();
+    try {
+      const result = await this.inner.send(args);
+      record.result = result;
+      return result;
+    } catch (err) {
+      record.error = err instanceof Error ? err : new Error(String(err));
+      throw err;
+    } finally {
+      record.durationMs = Date.now() - startedAt;
+    }
+  }
+  async verifyWebhook(rawBody, headers) {
+    return this.inner.verifyWebhook(rawBody, headers);
+  }
+  parseWebhookEvents(payload, headers) {
+    return this.inner.parseWebhookEvents(payload, headers);
+  }
+  /** Last recorded send, or undefined. Sugar for the common single-send assertion. */
+  get last() {
+    return this.sent[this.sent.length - 1];
+  }
+  /** All sends addressed to `email` (case-insensitive). */
+  toRecipient(email) {
+    const lower = email.toLowerCase();
+    return this.sent.filter((s) => s.to.toLowerCase() === lower);
+  }
+  reset() {
+    this.sent.length = 0;
+    this.records.length = 0;
+  }
+};
+
+// src/testing/builders.ts
+var BACKDATE_MS = 6e4;
+async function buildTemplate(spec) {
+  const now = /* @__PURE__ */ new Date();
+  const createdAt = spec.createdAt ?? new Date(now.getTime() - BACKDATE_MS);
+  let mjml = "";
+  let html;
+  if (spec.html) {
+    html = spec.html;
+  } else {
+    mjml = spec.mjml ?? wrapMjml(spec.text ?? "Hello {{contact.fields.firstName}}");
+    const compiled = await compileTemplate(mjml);
+    html = compiled.html;
+  }
+  const plainText = spec.plainText ?? derivePlaintext(html);
+  return {
+    slug: spec.slug,
+    name: spec.name ?? spec.slug,
+    description: spec.description ?? "",
+    kind: spec.kind ?? "marketing",
+    fromName: spec.fromName ?? "Test",
+    fromEmail: spec.fromEmail ?? "hello@example.com",
+    replyTo: spec.replyTo ?? null,
+    providerOverride: spec.providerOverride ?? null,
+    subject: spec.subject ?? "Test subject",
+    preheader: spec.preheader ?? "",
+    body: { mjml, editorJson: null, html, plainText, compiledAt: createdAt },
+    variablesSchema: spec.variablesSchema ?? {},
+    draft: null,
+    tags: spec.tags ?? [],
+    trackOpens: spec.trackOpens ?? false,
+    trackClicks: spec.trackClicks ?? false,
+    stats: {
+      sent: 0,
+      delivered: 0,
+      opened: 0,
+      clicked: 0,
+      bounced: 0,
+      complained: 0,
+      unsubscribed: 0,
+      lastSentAt: null
+    },
+    publishedAt: spec.published === false ? null : createdAt,
+    publishedBy: spec.published === false ? null : "test",
+    createdAt,
+    updatedAt: createdAt
+  };
+}
+function wrapMjml(body) {
+  return `<mjml><mj-body><mj-section><mj-column><mj-text>${body}</mj-text></mj-column></mj-section></mj-body></mjml>`;
+}
+function buildFlow(spec) {
+  const now = /* @__PURE__ */ new Date();
+  const createdAt = spec.createdAt ?? new Date(now.getTime() - BACKDATE_MS);
+  const trigger = spec.trigger ?? {
+    type: "event",
+    eventName: spec.eventName ?? `${spec.slug}:trigger`,
+    once: spec.once ?? true
+  };
+  return {
+    slug: spec.slug,
+    name: spec.name ?? spec.slug,
+    description: spec.description ?? "",
+    trigger,
+    enabled: spec.enabled ?? true,
+    steps: spec.steps,
+    version: spec.version ?? 1,
+    draft: null,
+    goal: spec.goal ?? "activation",
+    audience: spec.audience ?? "test",
+    expectedVolumePerWeek: null,
+    stats: { activeRuns: 0, completedRuns: 0, sendsTotal: 0, sendsLast7Days: 0 },
+    lastTriggerScanAt: null,
+    publishedAt: createdAt,
+    publishedBy: "test",
+    createdAt,
+    updatedAt: createdAt
+  };
+}
+var step = {
+  send(templateSlug, opts = {}) {
+    return { type: "send", templateSlug, ...opts };
+  },
+  sendAt(templateSlug, delivery) {
+    return { type: "send", templateSlug, delivery };
+  },
+  wait(value, unit = "minutes") {
+    return { type: "wait", value, unit };
+  },
+  tag(addTags, removeTags) {
+    return { type: "tag", addTags, removeTags };
+  },
+  exit(reason) {
+    return { type: "exit", reason };
+  },
+  fireEvent(eventName, properties) {
+    return { type: "fire_event", eventName, properties };
+  }
+};
+
+// src/testing/drive.ts
+async function drain(ctx, opts = {}) {
+  const maxRounds = opts.maxRounds ?? 100;
+  const shouldDispatch = opts.dispatch !== false;
+  const attempted = /* @__PURE__ */ new Set();
+  const errors = [];
+  let dispatched = 0;
+  let rounds = 0;
+  while (rounds < maxRounds) {
+    rounds++;
+    await processNewlyFiredEventTriggers(ctx);
+    await sweepStrandedFlowRuns(ctx);
+    let didWork = false;
+    if (shouldDispatch) {
+      const queued = await ctx.collections.sends.find({ status: "queued" }, { projection: { _id: 1 } }).toArray();
+      for (const row of queued) {
+        const id = String(row._id);
+        if (attempted.has(id)) continue;
+        attempted.add(id);
+        didWork = true;
+        dispatched++;
+        try {
+          await dispatchSend(row._id, ctx);
+        } catch (err) {
+          errors.push(err instanceof Error ? err : new Error(String(err)));
+          if (opts.throwOnSendError) throw err;
+        }
+      }
+    }
+    const due = await ctx.collections.flowRuns.countDocuments({
+      status: "active",
+      nextActionAt: { $lte: /* @__PURE__ */ new Date() }
+    });
+    if (!didWork && due === 0) {
+      return { rounds, dispatched, errors, settled: true };
+    }
+  }
+  return { rounds, dispatched, errors, settled: false };
+}
+async function dispatchQueued(ctx) {
+  const queued = await ctx.collections.sends.find({ status: "queued" }, { projection: { _id: 1 } }).toArray();
+  for (const row of queued) {
+    await dispatchSend(row._id, ctx).catch(() => {
+    });
+  }
+  return queued.length;
+}
+
 // src/testing/index.ts
 async function createTestMailer(opts = {}) {
   const { MongoMemoryServer } = await Promise.resolve().then(() => __toESM(require_mongodb_memory_server()));
@@ -17848,13 +18179,13 @@ async function createTestMailer(opts = {}) {
   const db = client.db("mailery-test");
   const memoryAdapter = opts.adapter ? null : new MemoryContactAdapter(opts.seedContacts ?? []);
   const adapter = opts.adapter ?? memoryAdapter;
-  const provider = opts.provider ?? new NullProvider();
+  const provider = new RecordingProvider(await resolveProvider(opts.provider ?? "null"));
   const mailer = await Mailer.init({
     db,
     adapter,
-    queue: { driver: "noop" },
-    providers: { null: provider },
-    defaultProvider: "null",
+    queue: opts.queue ?? { driver: "noop" },
+    providers: { [provider.name]: provider },
+    defaultProvider: provider.name,
     publicUrl: "http://localhost:3000",
     unsubscribeSecret: "test-unsub-secret-32-bytes-or-more-please",
     senderAddress: "1 Test St, Brooklyn NY 11201",
@@ -17862,17 +18193,72 @@ async function createTestMailer(opts = {}) {
     workerless: true,
     ...opts.config ?? {}
   });
-  const stop = async () => {
-    await mailer.stop().catch(() => {
-    });
-    await client.close().catch(() => {
-    });
-    await mongo.stop().catch(() => {
-    });
+  if (opts.startWorkers) await mailer.startWorkers();
+  const ctx = mailer.getRunnerContext();
+  const harness = {
+    mailer,
+    db,
+    provider,
+    adapter,
+    memoryAdapter,
+    ctx,
+    async seedContact(contact, seedOpts = {}) {
+      if (!memoryAdapter) {
+        throw new Error("seedContact requires the built-in MemoryContactAdapter \u2014 you passed a custom `adapter`.");
+      }
+      memoryAdapter.upsert(contact);
+      if (seedOpts.subscribe !== false) {
+        await mailer.upsertSubscription({
+          externalId: contact.externalId,
+          source: seedOpts.source ?? "test"
+        });
+      }
+      return contact;
+    },
+    async seedTemplate(spec) {
+      const doc = await buildTemplate(spec);
+      const res = await ctx.collections.templates.insertOne(doc);
+      doc._id = res.insertedId;
+      return doc;
+    },
+    async seedFlow(spec) {
+      const doc = buildFlow(spec);
+      const res = await ctx.collections.flows.insertOne(doc);
+      doc._id = res.insertedId;
+      return doc;
+    },
+    drain(drainOpts) {
+      return drain(ctx, drainOpts);
+    },
+    stop: async () => {
+      await mailer.stop().catch(() => {
+      });
+      await client.close().catch(() => {
+      });
+      await mongo.stop().catch(() => {
+      });
+    }
   };
-  return { mailer, db, provider, adapter, memoryAdapter, stop };
+  return harness;
+}
+async function resolveProvider(spec) {
+  if (typeof spec !== "string") return spec;
+  if (spec === "null") return new NullProvider();
+  const apiKey = process.env.SENDGRID_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "createTestMailer({ provider: 'sendgrid' }) requires SENDGRID_API_KEY. Live tests should gate on it before constructing the harness."
+    );
+  }
+  const { SendGridProvider: SendGridProvider2 } = await Promise.resolve().then(() => (init_sendgrid(), sendgrid_exports));
+  return new SendGridProvider2({
+    apiKey,
+    // Sandbox unless explicitly told to deliver: SendGrid still authenticates
+    // and validates the payload, it just never puts anything in an inbox.
+    sandbox: process.env.MAILERY_LIVE_E2E !== "deliver"
+  });
 }
 
-export { MemoryContactAdapter, NullProvider, createTestMailer };
+export { MemoryContactAdapter, NullProvider, RecordingProvider, buildFlow, buildTemplate, createTestMailer, dispatchQueued, drain, step, wrapMjml };
 //# sourceMappingURL=testing.js.map
 //# sourceMappingURL=testing.js.map