mailery 0.8.0 → 0.9.0

package/dist/testing.js

@@ -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 },
@@ -14617,7 +14623,7 @@ var BullDriver = class _BullDriver {
   bullQueues;
   workers = null;
   bull;
-  static async create(redisConfig) {
+  static async create(redisConfig, prefix) {
     let bull;
     try {
       bull = await import('bullmq');
@@ -14626,13 +14632,27 @@ var BullDriver = class _BullDriver {
         "mailery: queue driver 'bull' requires the 'bullmq' peer dependency. Run `npm install bullmq ioredis`."
       );
     }
+    if (prefix?.includes(":")) {
+      throw new Error(
+        `mailery: queue prefix "${prefix}" must not contain ':' \u2014 BullMQ uses it as the Redis key separator.`
+      );
+    }
     const redis = isRedisLike(redisConfig) ? redisConfig : connect(redisConfig);
-    return new _BullDriver(bull, redis);
+    return new _BullDriver(bull, redis, prefix);
   }
-  constructor(bull, redis) {
+  prefix;
+  constructor(bull, redis, prefix) {
     this.bull = bull;
     this.redis = redis;
-    const opts = { connection: redis };
+    this.prefix = prefix;
+    const opts = {
+      connection: redis,
+      prefix,
+      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,12 +14670,16 @@ 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) {
     if (this.workers) return;
-    const base = { connection: this.redis };
+    const base = { connection: this.redis, prefix: this.prefix };
     const { Worker } = this.bull;
     const tick = new Worker(
       QUEUE_NAMES.tick,
@@ -14760,9 +14784,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 +14796,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 +14837,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 +14847,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) {
@@ -14913,7 +14931,7 @@ var NoopDriver = class {
 async function createQueueDriver(config, fallbackDb) {
   switch (config.driver) {
     case "bull":
-      return BullDriver.create(config.redis);
+      return BullDriver.create(config.redis, config.prefix);
     case "agenda":
       return AgendaDriver.create({
         db: config.db ?? fallbackDb,
@@ -14931,6 +14949,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 +14960,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,117 +14984,453 @@ 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/runner/predicate.ts
-var BOT_UA_RE = /Mimecast|SafeLinks|proofpoint|HeadlessChrome|Googlebot|bingbot/i;
-async function evaluatePredicate(predicate, ctx) {
-  const p = predicate;
-  if ("hasTag" in p) return ctx.contact.tags.includes(p.hasTag);
-  if ("notHasTag" in p) return !ctx.contact.tags.includes(p.notHasTag);
-  if ("fieldEquals" in p) {
-    return ctx.contact.fields[p.fieldEquals.field] === p.fieldEquals.value;
-  }
-  if ("fieldExists" in p) {
-    return ctx.contact.fields[p.fieldExists] !== void 0;
-  }
-  if ("subscriptionStatus" in p) {
-    const sub = await ctx.collections.subscriptions.findOne({ externalId: ctx.contact.externalId });
-    return sub?.status === p.subscriptionStatus;
-  }
-  if ("hasFiredEvent" in p) {
-    return hasEvent(ctx, p.hasFiredEvent, { sinceFlowStart: p.sinceFlowStart, withinDays: p.withinDays });
-  }
-  if ("notHasFiredEvent" in p) {
-    return !await hasEvent(ctx, p.notHasFiredEvent, { withinDays: p.withinDays });
-  }
-  if ("hasOpened" in p) return await openOrClickCount(ctx, "opened", p.hasOpened, false) > 0;
-  if ("hasClicked" in p) return await openOrClickCount(ctx, "clicked", p.hasClicked, false) > 0;
-  if ("hasOpenedExcludingBots" in p) return await openOrClickCount(ctx, "opened", p.hasOpenedExcludingBots, true) > 0;
-  if ("hasClickedExcludingBots" in p) return await openOrClickCount(ctx, "clicked", p.hasClickedExcludingBots, true) > 0;
-  if ("openedAtLeastN" in p) return await openOrClickCount(ctx, "opened", p.openedAtLeastN, true) >= p.openedAtLeastN.count;
-  if ("clickedAtLeastN" in p) return await openOrClickCount(ctx, "clicked", p.clickedAtLeastN, true) >= p.clickedAtLeastN.count;
-  if ("all" in p) {
-    for (const sub of p.all) {
-      if (!await evaluatePredicate(sub, ctx)) return false;
-    }
-    return true;
-  }
-  if ("any" in p) {
-    for (const sub of p.any) {
-      if (await evaluatePredicate(sub, ctx)) return true;
+// 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));
     }
-    return false;
   }
-  if ("not" in p) {
-    return !await evaluatePredicate(p.not, ctx);
-  }
-  return false;
+  await Promise.all(writes);
 }
-async function hasEvent(ctx, name, opts) {
-  const filter = { externalId: ctx.contact.externalId, name };
-  const lower = effectiveLowerBound(ctx, opts);
-  if (lower) filter.occurredAt = { $gt: lower };
-  const found = await ctx.collections.events.findOne(filter, { projection: { _id: 1 } });
-  return !!found;
+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 openOrClickCount(ctx, kind, opts, excludeBots) {
-  const filter = { externalId: ctx.contact.externalId };
-  if (opts.templateSlug) filter.templateSlug = opts.templateSlug;
-  if (kind === "opened") filter.openedAt = { $ne: null };
-  if (kind === "clicked") filter.firstClickAt = { $ne: null };
-  const lower = effectiveLowerBound(ctx, opts);
-  if (lower) filter[kind === "opened" ? "openedAt" : "firstClickAt"] = { $gt: lower };
-  if (!excludeBots) {
-    return await ctx.collections.sends.countDocuments(filter);
+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);
   }
-  const docs = await ctx.collections.sends.find(filter).limit(1e3).toArray();
-  let n = 0;
-  for (const s of docs) {
-    if (kind === "opened") {
-      n++;
+  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 hasHumanClick = s.clickedLinks?.some((c) => !c.userAgent || !BOT_UA_RE.test(c.userAgent));
-    if (hasHumanClick) n++;
+    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() } }
+      );
+    }
   }
-  return n;
 }
-function effectiveLowerBound(ctx, opts) {
-  const now = ctx.now ?? /* @__PURE__ */ new Date();
-  if (opts.sinceFlowStart) return ctx.run.enteredAt;
-  if (opts.withinDays && opts.withinDays > 0) {
-    return new Date(now.getTime() - opts.withinDays * 24 * 60 * 60 * 1e3);
-  }
-  return null;
+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/delivery-window.ts
-var TIME_OF_DAY_GRACE_MS = 60 * 6e4;
-function computeDeliveryTime(now, window2, contactTimezone) {
-  const tz = pickTimezone(window2, contactTimezone);
-  let candidate = now;
-  if (window2.timeOfDay) {
+// 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) {
+  const p = predicate;
+  if ("hasTag" in p) return ctx.contact.tags.includes(p.hasTag);
+  if ("notHasTag" in p) return !ctx.contact.tags.includes(p.notHasTag);
+  if ("fieldEquals" in p) {
+    return ctx.contact.fields[p.fieldEquals.field] === p.fieldEquals.value;
+  }
+  if ("fieldExists" in p) {
+    return ctx.contact.fields[p.fieldExists] !== void 0;
+  }
+  if ("subscriptionStatus" in p) {
+    const sub = await ctx.collections.subscriptions.findOne({ externalId: ctx.contact.externalId });
+    return sub?.status === p.subscriptionStatus;
+  }
+  if ("hasFiredEvent" in p) {
+    return hasEvent(ctx, p.hasFiredEvent, { sinceFlowStart: p.sinceFlowStart, withinDays: p.withinDays });
+  }
+  if ("notHasFiredEvent" in p) {
+    return !await hasEvent(ctx, p.notHasFiredEvent, { withinDays: p.withinDays });
+  }
+  if ("hasOpened" in p) return await openOrClickCount(ctx, "opened", p.hasOpened, false) > 0;
+  if ("hasClicked" in p) return await openOrClickCount(ctx, "clicked", p.hasClicked, false) > 0;
+  if ("hasOpenedExcludingBots" in p) return await openOrClickCount(ctx, "opened", p.hasOpenedExcludingBots, true) > 0;
+  if ("hasClickedExcludingBots" in p) return await openOrClickCount(ctx, "clicked", p.hasClickedExcludingBots, true) > 0;
+  if ("openedAtLeastN" in p) return await openOrClickCount(ctx, "opened", p.openedAtLeastN, true) >= p.openedAtLeastN.count;
+  if ("clickedAtLeastN" in p) return await openOrClickCount(ctx, "clicked", p.clickedAtLeastN, true) >= p.clickedAtLeastN.count;
+  if ("all" in p) {
+    for (const sub of p.all) {
+      if (!await evaluatePredicate(sub, ctx)) return false;
+    }
+    return true;
+  }
+  if ("any" in p) {
+    for (const sub of p.any) {
+      if (await evaluatePredicate(sub, ctx)) return true;
+    }
+    return false;
+  }
+  if ("not" in p) {
+    return !await evaluatePredicate(p.not, ctx);
+  }
+  return false;
+}
+async function hasEvent(ctx, name, opts) {
+  const filter = { externalId: ctx.contact.externalId, name };
+  const lower = effectiveLowerBound(ctx, opts);
+  if (lower) filter.occurredAt = { $gt: lower };
+  const found = await ctx.collections.events.findOne(filter, { projection: { _id: 1 } });
+  return !!found;
+}
+async function openOrClickCount(ctx, kind, opts, excludeBots) {
+  const filter = { externalId: ctx.contact.externalId };
+  if (opts.templateSlug) filter.templateSlug = opts.templateSlug;
+  if (kind === "opened") filter.openedAt = { $ne: null };
+  if (kind === "clicked") filter.firstClickAt = { $ne: null };
+  const lower = effectiveLowerBound(ctx, opts);
+  if (lower) filter[kind === "opened" ? "openedAt" : "firstClickAt"] = { $gt: lower };
+  if (!excludeBots) {
+    return await ctx.collections.sends.countDocuments(filter);
+  }
+  const docs = await ctx.collections.sends.find(filter).limit(1e3).toArray();
+  let n = 0;
+  for (const s of docs) {
+    if (kind === "opened") {
+      n++;
+      continue;
+    }
+    const hasHumanClick = s.clickedLinks?.some((c) => !c.userAgent || !BOT_UA_RE.test(c.userAgent));
+    if (hasHumanClick) n++;
+  }
+  return n;
+}
+function effectiveLowerBound(ctx, opts) {
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  if (opts.sinceFlowStart) return ctx.run.enteredAt;
+  if (opts.withinDays && opts.withinDays > 0) {
+    return new Date(now.getTime() - opts.withinDays * 24 * 60 * 60 * 1e3);
+  }
+  return null;
+}
+
+// src/server/runner/delivery-window.ts
+var TIME_OF_DAY_GRACE_MS = 60 * 6e4;
+function computeDeliveryTime(now, window2, contactTimezone) {
+  const tz = pickTimezone(window2, contactTimezone);
+  let candidate = now;
+  if (window2.timeOfDay) {
     const [hh, mm] = window2.timeOfDay.split(":").map(Number);
     const local = localParts(candidate, tz);
     const todaySlot = utcFromLocal(local.y, local.mo, local.d, hh, mm, tz);
@@ -15207,7 +15565,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,236 +15598,95 @@ function shouldSkipClickRewrite(url, preserve, fullTag) {
   if (/data-mailer-notrack=["']true["']/.test(fullTag)) return true;
   return false;
 }
-function shortHash(input) {
-  return crypto2.createHash("sha256").update(input).digest("hex").slice(0, 12);
-}
-function makeHandlebars(extra) {
-  const hb = Handlebars.create();
-  hb.registerHelper("eq", (a, b) => a === b);
-  hb.registerHelper("ne", (a, b) => a !== b);
-  hb.registerHelper("gt", (a, b) => a > b);
-  hb.registerHelper("lt", (a, b) => a < b);
-  hb.registerHelper("gte", (a, b) => a >= b);
-  hb.registerHelper("lte", (a, b) => a <= b);
-  hb.registerHelper("and", (...args) => args.slice(0, -1).every(Boolean));
-  hb.registerHelper("or", (...args) => args.slice(0, -1).some(Boolean));
-  hb.registerHelper("not", (a) => !a);
-  hb.registerHelper("formatDate", (value, fmt) => {
-    if (!value) return "";
-    const d = value instanceof Date ? value : new Date(String(value));
-    if (Number.isNaN(d.getTime())) return "";
-    if (fmt === "long") return d.toLocaleDateString("en-US", { dateStyle: "long" });
-    if (fmt === "short") return d.toLocaleDateString("en-US", { dateStyle: "short" });
-    return d.toISOString().slice(0, 10);
-  });
-  hb.registerHelper("formatNumber", (n) => {
-    const v = Number(n);
-    return Number.isFinite(v) ? v.toLocaleString("en-US") : "";
-  });
-  hb.registerHelper("formatCurrency", (cents, currency = "usd") => {
-    const v = Number(cents);
-    if (!Number.isFinite(v)) return "";
-    return new Intl.NumberFormat("en-US", { style: "currency", currency }).format(v / 100);
-  });
-  hb.registerHelper(
-    "pluralize",
-    (n, one, many) => Number(n) === 1 ? one : many
-  );
-  if (extra) {
-    for (const [name, fn] of Object.entries(extra)) {
-      hb.registerHelper(name, fn);
-    }
-  }
-  return hb;
-}
-
-// src/server/runner/send.ts
-init_vars();
-
-// src/server/runner/suppression.ts
-var SCOPES_BY_KIND = {
-  marketing: ["all", "marketing"],
-  transactional: ["all", "transactional"]
-};
-async function isSuppressed(collections, email, kind) {
-  const normalized = email.toLowerCase();
-  const allowed = SCOPES_BY_KIND[kind];
-  const byEmail = await collections.suppressions.findOne({
-    email: normalized,
-    scope: { $in: allowed },
-    $or: [{ expiresAt: null }, { expiresAt: { $gt: /* @__PURE__ */ new Date() } }]
-  });
-  if (byEmail) return { suppressed: true, scope: byEmail.scope, reason: byEmail.reason };
-  const hashed = await collections.suppressions.findOne({
-    emailHash: sha256Hex(normalized),
-    scope: { $in: allowed }
-  });
-  if (hashed) return { suppressed: true, scope: hashed.scope, reason: hashed.reason };
-  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
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
 };
-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 {
-          }
-        }
+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;
       }
-      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() } }
-      );
+    const named = NAMED_ENTITIES[body.toLowerCase()];
+    return named ?? match;
+  });
+}
+function shortHash(input) {
+  return crypto2.createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+function makeHandlebars(extra) {
+  const hb = Handlebars.create();
+  hb.registerHelper("eq", (a, b) => a === b);
+  hb.registerHelper("ne", (a, b) => a !== b);
+  hb.registerHelper("gt", (a, b) => a > b);
+  hb.registerHelper("lt", (a, b) => a < b);
+  hb.registerHelper("gte", (a, b) => a >= b);
+  hb.registerHelper("lte", (a, b) => a <= b);
+  hb.registerHelper("and", (...args) => args.slice(0, -1).every(Boolean));
+  hb.registerHelper("or", (...args) => args.slice(0, -1).some(Boolean));
+  hb.registerHelper("not", (a) => !a);
+  hb.registerHelper("formatDate", (value, fmt) => {
+    if (!value) return "";
+    const d = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(d.getTime())) return "";
+    if (fmt === "long") return d.toLocaleDateString("en-US", { dateStyle: "long" });
+    if (fmt === "short") return d.toLocaleDateString("en-US", { dateStyle: "short" });
+    return d.toISOString().slice(0, 10);
+  });
+  hb.registerHelper("formatNumber", (n) => {
+    const v = Number(n);
+    return Number.isFinite(v) ? v.toLocaleString("en-US") : "";
+  });
+  hb.registerHelper("formatCurrency", (cents, currency = "usd") => {
+    const v = Number(cents);
+    if (!Number.isFinite(v)) return "";
+    return new Intl.NumberFormat("en-US", { style: "currency", currency }).format(v / 100);
+  });
+  hb.registerHelper(
+    "pluralize",
+    (n, one, many) => Number(n) === 1 ? one : many
+  );
+  if (extra) {
+    for (const [name, fn] of Object.entries(extra)) {
+      hb.registerHelper(name, fn);
     }
   }
+  return hb;
 }
-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
+init_vars();
+
+// src/server/runner/suppression.ts
+var SCOPES_BY_KIND = {
+  marketing: ["all", "marketing"],
+  transactional: ["all", "transactional"]
+};
+async function isSuppressed(collections, email, kind) {
+  const normalized = email.toLowerCase();
+  const allowed = SCOPES_BY_KIND[kind];
+  const byEmail = await collections.suppressions.findOne({
+    email: normalized,
+    scope: { $in: allowed },
+    $or: [{ expiresAt: null }, { expiresAt: { $gt: /* @__PURE__ */ new Date() } }]
+  });
+  if (byEmail) return { suppressed: true, scope: byEmail.scope, reason: byEmail.reason };
+  const hashed = await collections.suppressions.findOne({
+    emailHash: sha256Hex(normalized),
+    scope: { $in: allowed }
+  });
+  if (hashed) return { suppressed: true, scope: hashed.scope, reason: hashed.reason };
+  return { suppressed: false };
 }
 
 // src/server/runner/send.ts
@@ -15536,9 +15754,11 @@ async function handleSend(run, step2, 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 +15775,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;
     }
@@ -15803,7 +16027,7 @@ async function handleWait(run, step2, 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, step2, contact, ctx) {
@@ -15915,7 +16139,7 @@ async function handleWebhookStep(run, step2, 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}` }
       );
     }
   }
@@ -15944,7 +16168,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()}`
     }
   );
 }
@@ -15999,13 +16223,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) {
@@ -16032,6 +16259,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();
@@ -16042,15 +16270,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) {
@@ -16071,11 +16333,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(
@@ -16198,7 +16468,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,
@@ -16237,7 +16508,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 });
@@ -16250,7 +16522,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;
   }
@@ -16925,6 +17197,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(
@@ -16965,12 +17238,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);
@@ -17041,140 +17320,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;
@@ -17214,6 +17359,7 @@ var Mailer = class _Mailer {
    *   MAILER_MONGODB_URI                — Mongo connection string (required)
    *   MAILER_MONGODB_DB                 — database name (optional; defaults to the URI default)
    *   MAILER_REDIS_URL                  — Redis connection URL (required)
+   *   MAILER_QUEUE_PREFIX               — Redis key prefix to namespace this instance (optional)
    *   MAILER_PUBLIC_URL                 — base for tracking/unsub URLs (required)
    *   MAILER_UNSUBSCRIBE_SECRET         — HMAC key (required)
    *   MAILER_SENDER_ADDRESS             — postal address for CAN-SPAM (optional)
@@ -17262,7 +17408,11 @@ var Mailer = class _Mailer {
     }
     const defaultProvider = env.MAILER_DEFAULT_PROVIDER ?? Object.keys(providers)[0];
     const driverEnv = env.MAILER_QUEUE_DRIVER ?? "bull";
-    const queue = driverEnv === "agenda" ? { driver: "agenda" } : driverEnv === "noop" ? { driver: "noop" } : { driver: "bull", redis: { url: required("MAILER_REDIS_URL") } };
+    const queue = driverEnv === "agenda" ? { driver: "agenda" } : driverEnv === "noop" ? { driver: "noop" } : {
+      driver: "bull",
+      redis: { url: required("MAILER_REDIS_URL") },
+      prefix: env.MAILER_QUEUE_PREFIX
+    };
     return _Mailer.init({
       db,
       adapter,
@@ -17639,41 +17789,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) },
@@ -17717,7 +17874,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) => {
@@ -17733,27 +17895,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();