mailery 0.0.0 → 0.1.0

package/dist/index.cjs

@@ -1,8 +1,3697 @@
 'use strict';
 
-// src/index.ts
-var VERSION = "0.0.0";
+var mongodb = require('mongodb');
+var crypto2 = require('crypto');
+var sgMail = require('@sendgrid/mail');
+var zod = require('zod');
+var bullmq = require('bullmq');
+var IORedis = require('ioredis');
+var Handlebars = require('handlebars');
+var htmlToText = require('html-to-text');
+var mjml2html = require('mjml');
+var express = require('express');
+var path = require('path');
+var url = require('url');
+var fs = require('fs');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var sgMail__default = /*#__PURE__*/_interopDefault(sgMail);
+var IORedis__default = /*#__PURE__*/_interopDefault(IORedis);
+var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
+var mjml2html__default = /*#__PURE__*/_interopDefault(mjml2html);
+var express__default = /*#__PURE__*/_interopDefault(express);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server/adapters/mongo.ts
+var mongo_exports = {};
+__export(mongo_exports, {
+  MongoContactAdapter: () => exports.MongoContactAdapter
+});
+function canBeObjectId(s) {
+  return typeof s === "string" && /^[a-f0-9]{24}$/i.test(s);
+}
+exports.MongoContactAdapter = void 0;
+var init_mongo = __esm({
+  "src/server/adapters/mongo.ts"() {
+    exports.MongoContactAdapter = class {
+      col;
+      emailField;
+      idField;
+      tagsField;
+      tagsWritable;
+      tagsArrayShape;
+      toContactFn;
+      translateFilterFn;
+      batchSize;
+      constructor(opts) {
+        this.col = opts.db.collection(opts.collection);
+        this.emailField = opts.emailField ?? "email";
+        this.idField = opts.idField ?? "_id";
+        this.tagsField = opts.tagsField ?? null;
+        this.tagsWritable = !!opts.tagsWritable;
+        this.tagsArrayShape = opts.tagsArrayShape ?? "strings";
+        this.toContactFn = opts.toContact ?? this.defaultToContact.bind(this);
+        this.translateFilterFn = opts.translateFilter ?? this.defaultTranslateFilter.bind(this);
+        this.batchSize = opts.batchSize ?? 500;
+        if (this.tagsWritable && this.tagsField) {
+          this.addTags = this.addTagsImpl.bind(this);
+          this.removeTags = this.removeTagsImpl.bind(this);
+        }
+      }
+      async getById(externalId) {
+        const filter = this.idFilter(externalId);
+        const doc = await this.col.findOne(filter);
+        return doc ? this.toContactFn(doc) : null;
+      }
+      async getByEmail(email) {
+        const doc = await this.col.findOne({ [this.emailField]: email.toLowerCase() });
+        return doc ? this.toContactFn(doc) : null;
+      }
+      async getBatch(externalIds) {
+        if (externalIds.length === 0) return /* @__PURE__ */ new Map();
+        const tryObjectId = externalIds.every(canBeObjectId);
+        const ids = tryObjectId ? externalIds.map((s) => new mongodb.ObjectId(s)) : externalIds;
+        const docs = await this.col.find({ [this.idField]: { $in: ids } }).toArray();
+        const out = /* @__PURE__ */ new Map();
+        for (const doc of docs) {
+          const c = this.toContactFn(doc);
+          out.set(c.externalId, c);
+        }
+        return out;
+      }
+      async query(filter, opts) {
+        const query = this.translateFilterFn(filter);
+        const limit = Math.min(opts.limit, this.batchSize);
+        if (opts.cursor) {
+          const cursorVal = canBeObjectId(opts.cursor) ? new mongodb.ObjectId(opts.cursor) : opts.cursor;
+          query[this.idField] = { ...query[this.idField] ?? {}, $gt: cursorVal };
+        }
+        const docs = await this.col.find(query).sort({ [this.idField]: 1 }).limit(limit + 1).toArray();
+        const hasMore = docs.length > limit;
+        const slice = hasMore ? docs.slice(0, limit) : docs;
+        const contacts = slice.map((d) => this.toContactFn(d));
+        const last = slice[slice.length - 1];
+        const nextCursor = hasMore && last ? String(last[this.idField]) : void 0;
+        return { contacts, nextCursor };
+      }
+      async count(filter) {
+        const query = this.translateFilterFn(filter);
+        return await this.col.countDocuments(query);
+      }
+      addTags;
+      removeTags;
+      // -------------------------------------------------------------------------
+      // Private helpers
+      // -------------------------------------------------------------------------
+      idFilter(externalId) {
+        if (this.idField === "_id" && canBeObjectId(externalId)) {
+          return { _id: new mongodb.ObjectId(externalId) };
+        }
+        return { [this.idField]: externalId };
+      }
+      defaultToContact(doc) {
+        const tagsRaw = this.tagsField ? doc[this.tagsField] ?? [] : [];
+        const tags = this.tagsArrayShape === "objects" ? (Array.isArray(tagsRaw) ? tagsRaw : []).map((t) => String(t.name ?? t)) : (Array.isArray(tagsRaw) ? tagsRaw : []).map((t) => String(t));
+        const externalId = String(doc[this.idField] ?? "");
+        const email = String(doc[this.emailField] ?? "").toLowerCase();
+        const fields = {};
+        for (const [k, v] of Object.entries(doc)) {
+          if (k === this.idField || k === this.emailField || k === this.tagsField) continue;
+          fields[k] = v;
+        }
+        return {
+          externalId,
+          email,
+          tags,
+          fields,
+          timezone: typeof doc.timezone === "string" ? doc.timezone : void 0,
+          locale: typeof doc.locale === "string" ? doc.locale : void 0
+        };
+      }
+      defaultTranslateFilter(filter) {
+        const q = {};
+        if (filter.emailIn && filter.emailIn.length > 0) {
+          q[this.emailField] = { $in: filter.emailIn.map((e) => e.toLowerCase()) };
+        }
+        if (filter.externalIdIn && filter.externalIdIn.length > 0) {
+          const tryObjectId = filter.externalIdIn.every(canBeObjectId);
+          q[this.idField] = {
+            $in: tryObjectId ? filter.externalIdIn.map((s) => new mongodb.ObjectId(s)) : filter.externalIdIn
+          };
+        }
+        if (filter.fieldEquals) {
+          q[filter.fieldEquals.field] = filter.fieldEquals.value;
+        }
+        if (filter.fieldIn) {
+          q[filter.fieldIn.field] = { $in: filter.fieldIn.values };
+        }
+        if (filter.fieldExists) {
+          q[filter.fieldExists] = { $exists: true };
+        }
+        if (filter.createdAfter || filter.createdBefore) {
+          const r = {};
+          if (filter.createdAfter) r.$gte = filter.createdAfter;
+          if (filter.createdBefore) r.$lte = filter.createdBefore;
+          q.createdAt = r;
+        }
+        if (this.tagsField) {
+          if (filter.hasTag) {
+            q[this.tagsField] = filter.hasTag;
+          }
+          if (filter.hasTagIn && filter.hasTagIn.length > 0) {
+            q[this.tagsField] = { $in: filter.hasTagIn };
+          }
+        }
+        return q;
+      }
+      async addTagsImpl(externalId, tags) {
+        if (!this.tagsField || tags.length === 0) return;
+        const value = this.tagsArrayShape === "objects" ? tags.map((name) => ({ name })) : tags;
+        await this.col.updateOne(this.idFilter(externalId), {
+          $addToSet: { [this.tagsField]: { $each: value } }
+        });
+      }
+      async removeTagsImpl(externalId, tags) {
+        if (!this.tagsField || tags.length === 0) return;
+        const value = this.tagsArrayShape === "objects" ? { $in: tags.map((name) => ({ name })) } : { $in: tags };
+        await this.col.updateOne(this.idFilter(externalId), {
+          $pull: { [this.tagsField]: value }
+        });
+      }
+    };
+  }
+});
+
+// src/server/providers/sendgrid.ts
+var sendgrid_exports = {};
+__export(sendgrid_exports, {
+  SendGridProvider: () => exports.SendGridProvider
+});
+function normalizeSendGridEvent(e) {
+  const type = mapEventType(e.event);
+  if (!type) return null;
+  return {
+    type,
+    providerEventId: String(e.sg_event_id ?? e["smtp-id"] ?? `${e.event}-${e.timestamp}-${e.email}`),
+    providerMessageId: String(e.sg_message_id ?? e["smtp-id"] ?? ""),
+    email: String(e.email ?? "").toLowerCase(),
+    occurredAt: new Date(Number(e.timestamp) * 1e3),
+    details: {
+      bounceType: e.event === "bounce" ? e.type === "bounce" ? "hard" : "soft" : void 0,
+      bounceReason: e.reason,
+      clickedUrl: e.url,
+      userAgent: e.useragent,
+      ipAddress: e.ip
+    }
+  };
+}
+function mapEventType(sgEvent) {
+  switch (sgEvent) {
+    case "delivered":
+      return "delivered";
+    case "open":
+      return "open";
+    case "click":
+      return "click";
+    case "bounce":
+    case "dropped":
+      return "bounce";
+    case "spamreport":
+      return "spam_report";
+    case "unsubscribe":
+    case "group_unsubscribe":
+      return "unsubscribe";
+    default:
+      return null;
+  }
+}
+var SG_SIG_HEADER, SG_TS_HEADER; exports.SendGridProvider = void 0;
+var init_sendgrid = __esm({
+  "src/server/providers/sendgrid.ts"() {
+    SG_SIG_HEADER = "x-twilio-email-event-webhook-signature";
+    SG_TS_HEADER = "x-twilio-email-event-webhook-timestamp";
+    exports.SendGridProvider = class {
+      constructor(opts) {
+        this.opts = opts;
+        sgMail__default.default.setApiKey(opts.apiKey);
+        this.sendRatePerSecond = opts.sendRatePerSecond ?? 10;
+      }
+      opts;
+      name = "sendgrid";
+      sendRatePerSecond;
+      async send(args) {
+        const msg = {
+          to: args.to,
+          from: { name: args.fromName, email: args.fromEmail },
+          replyTo: args.replyTo,
+          subject: args.subject,
+          text: args.text,
+          html: args.html,
+          headers: args.headers,
+          customArgs: args.messageMeta,
+          trackingSettings: {
+            // We do our own click/open tracking — let provider stay out of it.
+            clickTracking: { enable: false, enableText: false },
+            openTracking: { enable: false }
+          },
+          mailSettings: {
+            sandboxMode: { enable: this.opts.sandbox ?? false }
+          }
+        };
+        const [response] = await sgMail__default.default.send(msg);
+        const providerId = response.headers["x-message-id"] ?? `sg-${Date.now()}`;
+        return {
+          providerId,
+          status: response.statusCode < 300 ? "accepted" : "rejected",
+          raw: response
+        };
+      }
+      async verifyWebhook(rawBody, headers) {
+        if (!this.opts.webhookVerificationKey) return false;
+        const sig = headers[SG_SIG_HEADER];
+        const ts = headers[SG_TS_HEADER];
+        if (!sig || !ts) return false;
+        const payload = Buffer.concat([Buffer.from(ts, "utf8"), rawBody]);
+        try {
+          const verifier = crypto2__default.default.createVerify("sha256");
+          verifier.update(payload);
+          return verifier.verify(this.opts.webhookVerificationKey, sig, "base64");
+        } catch {
+          return false;
+        }
+      }
+      parseWebhookEvents(payload) {
+        if (!Array.isArray(payload)) return [];
+        return payload.map((raw) => normalizeSendGridEvent(raw)).filter((e) => e !== null);
+      }
+    };
+  }
+});
+var externalIdSchema = zod.z.string().min(1).max(256);
+var emailSchema = zod.z.string().email().toLowerCase().trim();
+var slugSchema = zod.z.string().min(1).max(128).regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/, "must be kebab-case slug");
+var fireInputSchema = zod.z.object({
+  eventName: zod.z.string().min(1).max(128),
+  externalId: externalIdSchema,
+  properties: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  dedupeKey: zod.z.string().min(1).max(512).optional()
+});
+var registerEventSchema = zod.z.object({
+  name: zod.z.string().min(1).max(128),
+  dedupePolicy: zod.z.enum(["once-per-contact", "once-per-day", "every-time"])
+});
+var upsertSubscriptionSchema = zod.z.object({
+  externalId: externalIdSchema,
+  source: zod.z.string().min(1).max(256),
+  consentTimestamp: zod.z.date().optional(),
+  consentIp: zod.z.string().optional(),
+  consentUserAgent: zod.z.string().optional()
+});
+var unsubscribeScopeSchema = zod.z.enum(["all", "marketing", "transactional"]);
+var unsubscribeReasonSchema = zod.z.enum([
+  "user_request",
+  "hard_bounce",
+  "complaint",
+  "manual",
+  "gdpr_forget",
+  "list_cleaning"
+]);
+var unsubscribeInputSchema = zod.z.object({
+  email: emailSchema,
+  scope: unsubscribeScopeSchema,
+  reason: unsubscribeReasonSchema.default("user_request"),
+  source: zod.z.string().max(256).default("manual"),
+  notes: zod.z.string().max(1024).optional()
+});
+var suppressInputSchema = zod.z.object({
+  email: emailSchema,
+  scope: unsubscribeScopeSchema,
+  reason: zod.z.enum(["unsubscribed", "hard_bounce", "complaint", "manual", "list_cleaning", "gdpr_forget"]),
+  source: zod.z.string().max(256).default("manual"),
+  notes: zod.z.string().max(1024).optional(),
+  expiresAt: zod.z.date().optional()
+});
+var tagInputSchema = zod.z.object({
+  externalId: externalIdSchema,
+  tag: zod.z.string().min(1).max(128)
+});
+var sendOneOffInputSchema = zod.z.object({
+  templateSlug: slugSchema,
+  externalId: externalIdSchema,
+  vars: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  providerOverride: zod.z.string().optional(),
+  dedupeKey: zod.z.string().min(1).max(512)
+});
+var flowStepSchema = zod.z.lazy(
+  () => zod.z.discriminatedUnion("type", [
+    zod.z.object({
+      type: zod.z.literal("wait"),
+      value: zod.z.number().int().positive(),
+      unit: zod.z.enum(["minutes", "hours", "days", "weeks"])
+    }),
+    zod.z.object({
+      type: zod.z.literal("condition"),
+      test: predicateSchema,
+      ifFalse: zod.z.enum(["continue", "exit"])
+    }),
+    zod.z.object({
+      type: zod.z.literal("branch"),
+      test: predicateSchema,
+      ifTrueSteps: zod.z.array(flowStepSchema),
+      ifFalseSteps: zod.z.array(flowStepSchema)
+    }),
+    zod.z.object({
+      type: zod.z.literal("send"),
+      templateSlug: slugSchema,
+      providerOverride: zod.z.string().optional(),
+      vars: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("tag"),
+      addTags: zod.z.array(zod.z.string()).optional(),
+      removeTags: zod.z.array(zod.z.string()).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("fire_event"),
+      eventName: zod.z.string().min(1).max(128),
+      properties: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("webhook"),
+      url: zod.z.string().url(),
+      method: zod.z.enum(["POST", "PUT"]).optional(),
+      payload: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+      failureMode: zod.z.enum(["soft", "fail_run"]).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("exit"),
+      reason: zod.z.string().optional()
+    })
+  ])
+);
+var predicateSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.object({ hasTag: zod.z.string() }),
+    zod.z.object({ notHasTag: zod.z.string() }),
+    zod.z.object({ fieldEquals: zod.z.object({ field: zod.z.string(), value: zod.z.unknown() }) }),
+    zod.z.object({ fieldExists: zod.z.string() }),
+    zod.z.object({
+      hasFiredEvent: zod.z.string(),
+      sinceFlowStart: zod.z.boolean().optional(),
+      withinDays: zod.z.number().int().positive().optional()
+    }),
+    zod.z.object({
+      notHasFiredEvent: zod.z.string(),
+      withinDays: zod.z.number().int().positive().optional()
+    }),
+    zod.z.object({
+      subscriptionStatus: zod.z.enum(["subscribed", "unsubscribed", "pending_doi", "bounced", "complained"])
+    }),
+    zod.z.object({
+      hasOpened: zod.z.object({
+        templateSlug: slugSchema.optional(),
+        sinceFlowStart: zod.z.boolean().optional(),
+        withinDays: zod.z.number().int().positive().optional()
+      })
+    }),
+    zod.z.object({
+      hasClicked: zod.z.object({
+        templateSlug: slugSchema.optional(),
+        sinceFlowStart: zod.z.boolean().optional(),
+        withinDays: zod.z.number().int().positive().optional()
+      })
+    }),
+    zod.z.object({
+      hasOpenedExcludingBots: zod.z.object({
+        templateSlug: slugSchema.optional(),
+        sinceFlowStart: zod.z.boolean().optional(),
+        withinDays: zod.z.number().int().positive().optional()
+      })
+    }),
+    zod.z.object({
+      hasClickedExcludingBots: zod.z.object({
+        templateSlug: slugSchema.optional(),
+        sinceFlowStart: zod.z.boolean().optional(),
+        withinDays: zod.z.number().int().positive().optional()
+      })
+    }),
+    zod.z.object({
+      openedAtLeastN: zod.z.object({ count: zod.z.number().int().positive(), withinDays: zod.z.number().int().positive() })
+    }),
+    zod.z.object({
+      clickedAtLeastN: zod.z.object({ count: zod.z.number().int().positive(), withinDays: zod.z.number().int().positive() })
+    }),
+    zod.z.object({ all: zod.z.array(predicateSchema) }),
+    zod.z.object({ any: zod.z.array(predicateSchema) }),
+    zod.z.object({ not: predicateSchema })
+  ])
+);
+
+// src/server/config.ts
+var DEFAULTS = {
+  collectionPrefix: "mailer_",
+  requireDoubleOptIn: false,
+  unsubscribeTokenLifetimeDays: 90,
+  transactionalRespectUnsubscribe: false,
+  doiTemplateSlug: "doi-confirmation",
+  doiTokenLifetimeDays: 7,
+  broadcastConfirmationThreshold: 1e3,
+  broadcastEnqueueBatchSize: 1e3,
+  broadcastEnqueueMaxWaiting: 5e3,
+  workerless: false,
+  tickIntervalSeconds: 60,
+  sendConcurrency: 5,
+  sendRatePerSecond: 10,
+  softBouncePromotionThreshold: 3,
+  softBouncePromotionWindowDays: 30,
+  webhookRetryAttempts: 3,
+  sendRetryAttempts: 4,
+  trackOpens: true,
+  trackClicks: true,
+  storeTrackingIp: false,
+  storeRenderedBody: false
+};
+var CIRCUIT_BREAKER_DEFAULTS = {
+  hardBounceRatePctTrip: 2,
+  complaintRatePctTrip: 0.3,
+  combinedBounceRatePctTrip: 5,
+  failedToSendRatePctDegrade: 10,
+  windowMinutes: 60,
+  minSendsBeforeEval: 100
+};
+function resolveConfig(c) {
+  return {
+    ...c,
+    collectionPrefix: c.collectionPrefix ?? DEFAULTS.collectionPrefix,
+    requireDoubleOptIn: c.requireDoubleOptIn ?? DEFAULTS.requireDoubleOptIn,
+    unsubscribeTokenLifetimeDays: c.unsubscribeTokenLifetimeDays ?? DEFAULTS.unsubscribeTokenLifetimeDays,
+    transactionalRespectUnsubscribe: c.transactionalRespectUnsubscribe ?? DEFAULTS.transactionalRespectUnsubscribe,
+    doiTemplateSlug: c.doiTemplateSlug ?? DEFAULTS.doiTemplateSlug,
+    doiTokenLifetimeDays: c.doiTokenLifetimeDays ?? DEFAULTS.doiTokenLifetimeDays,
+    broadcastConfirmationThreshold: c.broadcastConfirmationThreshold ?? DEFAULTS.broadcastConfirmationThreshold,
+    broadcastEnqueueBatchSize: c.broadcastEnqueueBatchSize ?? DEFAULTS.broadcastEnqueueBatchSize,
+    broadcastEnqueueMaxWaiting: c.broadcastEnqueueMaxWaiting ?? DEFAULTS.broadcastEnqueueMaxWaiting,
+    workerless: c.workerless ?? DEFAULTS.workerless,
+    tickIntervalSeconds: c.tickIntervalSeconds ?? DEFAULTS.tickIntervalSeconds,
+    sendConcurrency: c.sendConcurrency ?? DEFAULTS.sendConcurrency,
+    sendRatePerSecond: c.sendRatePerSecond ?? DEFAULTS.sendRatePerSecond,
+    softBouncePromotionThreshold: c.softBouncePromotionThreshold ?? DEFAULTS.softBouncePromotionThreshold,
+    softBouncePromotionWindowDays: c.softBouncePromotionWindowDays ?? DEFAULTS.softBouncePromotionWindowDays,
+    webhookRetryAttempts: c.webhookRetryAttempts ?? DEFAULTS.webhookRetryAttempts,
+    sendRetryAttempts: c.sendRetryAttempts ?? DEFAULTS.sendRetryAttempts,
+    trackOpens: c.trackOpens ?? DEFAULTS.trackOpens,
+    trackClicks: c.trackClicks ?? DEFAULTS.trackClicks,
+    storeTrackingIp: c.storeTrackingIp ?? DEFAULTS.storeTrackingIp,
+    storeRenderedBody: c.storeRenderedBody ?? DEFAULTS.storeRenderedBody,
+    circuitBreaker: { ...CIRCUIT_BREAKER_DEFAULTS, ...c.circuitBreaker ?? {} }
+  };
+}
+
+// src/server/models/index.ts
+function getCollections(db, prefix = "mailer_") {
+  return {
+    subscriptions: db.collection(`${prefix}subscriptions`),
+    leads: db.collection(`${prefix}leads`),
+    events: db.collection(`${prefix}events`),
+    flows: db.collection(`${prefix}flows`),
+    flowVersions: db.collection(`${prefix}flow_versions`),
+    flowRuns: db.collection(`${prefix}flow_runs`),
+    templates: db.collection(`${prefix}templates`),
+    templateVersions: db.collection(`${prefix}template_versions`),
+    sends: db.collection(`${prefix}sends`),
+    suppressions: db.collection(`${prefix}suppressions`),
+    broadcasts: db.collection(`${prefix}broadcasts`),
+    outbox: db.collection(`${prefix}outbox`),
+    auditLog: db.collection(`${prefix}audit_log`),
+    webhookEvents: db.collection(`${prefix}webhook_events`),
+    health: db.collection(`${prefix}health`),
+    contactTags: db.collection(`${prefix}contact_tags`)
+  };
+}
+async function ensureIndexes(db, prefix = "mailer_") {
+  const c = getCollections(db, prefix);
+  await Promise.all([
+    c.subscriptions.createIndexes([
+      { key: { externalId: 1 }, unique: true },
+      { key: { status: 1, unsubscribedAt: -1 } }
+    ]),
+    c.leads.createIndexes([
+      { key: { email: 1 }, unique: true },
+      { key: { status: 1, createdAt: -1 } }
+    ]),
+    c.events.createIndexes([
+      { key: { dedupeKey: 1 }, unique: true },
+      { key: { externalId: 1, occurredAt: -1 } },
+      { key: { name: 1, occurredAt: -1 } },
+      { key: { externalId: 1, name: 1 } }
+    ]),
+    c.flows.createIndexes([
+      { key: { slug: 1 }, unique: true },
+      { key: { enabled: 1, "trigger.type": 1, "trigger.eventName": 1 } }
+    ]),
+    c.flowVersions.createIndexes([{ key: { flowId: 1, version: 1 }, unique: true }]),
+    c.flowRuns.createIndexes([
+      { key: { status: 1, nextActionAt: 1 } },
+      { key: { externalId: 1, flowId: 1 } },
+      { key: { flowId: 1, status: 1 } }
+    ]),
+    c.templates.createIndexes([
+      { key: { slug: 1 }, unique: true },
+      { key: { tags: 1 } },
+      { key: { kind: 1 } }
+    ]),
+    c.templateVersions.createIndexes([{ key: { templateId: 1, version: 1 }, unique: true }]),
+    c.sends.createIndexes([
+      { key: { dedupeKey: 1 }, unique: true },
+      { key: { externalId: 1, sentAt: -1 } },
+      { key: { templateId: 1, sentAt: -1 } },
+      { key: { flowRunId: 1 }, sparse: true },
+      { key: { broadcastId: 1 }, sparse: true },
+      { key: { providerMessageId: 1 }, sparse: true },
+      { key: { status: 1, queuedAt: 1 } }
+    ]),
+    c.suppressions.createIndexes([
+      { key: { email: 1, scope: 1 }, unique: true, partialFilterExpression: { email: { $type: "string" } } },
+      { key: { emailHash: 1 } },
+      { key: { addedAt: -1 } }
+    ]),
+    c.broadcasts.createIndexes([
+      { key: { slug: 1 }, unique: true },
+      { key: { status: 1, scheduledAt: 1 } }
+    ]),
+    c.outbox.createIndexes([
+      { key: { status: 1, enqueuedAt: 1 } },
+      { key: { "payload.dedupeKey": 1 }, unique: true }
+    ]),
+    c.auditLog.createIndexes([
+      { key: { occurredAt: -1 } },
+      { key: { "resource.collection": 1, "resource.id": 1, occurredAt: -1 } },
+      { key: { actor: 1, occurredAt: -1 } }
+    ]),
+    c.webhookEvents.createIndexes([
+      { key: { provider: 1, providerEventId: 1 }, unique: true },
+      { key: { providerMessageId: 1 } },
+      { key: { processed: 1, receivedAt: 1 } }
+    ]),
+    c.contactTags.createIndexes([
+      { key: { externalId: 1, tag: 1 }, unique: true },
+      { key: { tag: 1 } }
+    ])
+  ]);
+}
+var EventRegistry = class {
+  policies = /* @__PURE__ */ new Map();
+  register(reg) {
+    this.policies.set(reg.name, reg.dedupePolicy);
+  }
+  has(name) {
+    return this.policies.has(name);
+  }
+  policy(name) {
+    return this.policies.get(name);
+  }
+  /**
+   * Derive a dedupeKey for an event call. Returns null when no policy is
+   * registered AND no key was passed — caller should throw.
+   */
+  deriveKey(name, externalId, passedKey, now) {
+    if (passedKey) return passedKey;
+    const policy = this.policies.get(name);
+    if (!policy) return null;
+    switch (policy) {
+      case "once-per-contact":
+        return `${externalId}:${name}`;
+      case "once-per-day":
+        return `${externalId}:${name}:${isoDay(now)}`;
+      case "every-time":
+        return `${externalId}:${name}:${randomId()}`;
+    }
+  }
+};
+function isoDay(d) {
+  return d.toISOString().slice(0, 10);
+}
+function randomId() {
+  return crypto2__default.default.randomBytes(8).toString("hex");
+}
+function signUnsubscribeToken(payload, secret) {
+  const body = JSON.stringify({
+    e: payload.email.toLowerCase(),
+    s: payload.scope,
+    x: payload.expiresAt.getTime()
+  });
+  const bodyB64 = b64url(Buffer.from(body, "utf8"));
+  const hmac = crypto2__default.default.createHmac("sha256", secret).update(bodyB64).digest();
+  return `${bodyB64}.${b64url(hmac)}`;
+}
+function verifyUnsubscribeToken(token, secret, now = /* @__PURE__ */ new Date()) {
+  const parts = token.split(".");
+  if (parts.length !== 2) return null;
+  const [bodyB64, sigB64] = parts;
+  const expected = crypto2__default.default.createHmac("sha256", secret).update(bodyB64).digest();
+  let actual;
+  try {
+    actual = b64urlDecode(sigB64);
+  } catch {
+    return null;
+  }
+  if (expected.length !== actual.length) return null;
+  if (!crypto2__default.default.timingSafeEqual(expected, actual)) return null;
+  let body;
+  try {
+    body = JSON.parse(b64urlDecode(bodyB64).toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!body.e || !body.s || typeof body.x !== "number") return null;
+  if (body.x < now.getTime()) return null;
+  if (body.s !== "all" && body.s !== "marketing" && body.s !== "transactional") return null;
+  return {
+    email: body.e,
+    scope: body.s,
+    expiresAt: new Date(body.x)
+  };
+}
+function b64url(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64urlDecode(s) {
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
+  return Buffer.from(padded, "base64");
+}
+function sha256Hex(input) {
+  return crypto2__default.default.createHash("sha256").update(input).digest("hex");
+}
+function signDoiToken(payload, secret) {
+  const body = JSON.stringify({
+    i: payload.externalId,
+    x: payload.expiresAt.getTime(),
+    k: "doi"
+  });
+  const bodyB64 = b64url(Buffer.from(body, "utf8"));
+  const hmac = crypto2__default.default.createHmac("sha256", secret).update(bodyB64).digest();
+  return `${bodyB64}.${b64url(hmac)}`;
+}
+function verifyDoiToken(token, secret, now = /* @__PURE__ */ new Date()) {
+  const parts = token.split(".");
+  if (parts.length !== 2) return null;
+  const [bodyB64, sigB64] = parts;
+  const expected = crypto2__default.default.createHmac("sha256", secret).update(bodyB64).digest();
+  let actual;
+  try {
+    actual = b64urlDecode(sigB64);
+  } catch {
+    return null;
+  }
+  if (expected.length !== actual.length) return null;
+  if (!crypto2__default.default.timingSafeEqual(expected, actual)) return null;
+  let body;
+  try {
+    body = JSON.parse(b64urlDecode(bodyB64).toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!body.i || typeof body.x !== "number" || body.k !== "doi") return null;
+  if (body.x < now.getTime()) return null;
+  return { externalId: body.i, expiresAt: new Date(body.x) };
+}
+function adaptBullQueue(q) {
+  return {
+    add: (name, data, opts) => q.add(name, data, opts),
+    getWaitingCount: () => q.getWaitingCount(),
+    close: () => q.close()
+  };
+}
+function noopQueueAPI() {
+  return {
+    add: async () => void 0,
+    getWaitingCount: async () => 0,
+    close: async () => void 0
+  };
+}
+function noopQueues() {
+  return {
+    tick: noopQueueAPI(),
+    advance: noopQueueAPI(),
+    send: noopQueueAPI(),
+    webhook: noopQueueAPI()
+  };
+}
+function namespacedQueueNames(prefix) {
+  return {
+    tick: "mailer-tick",
+    advance: "mailer-advance",
+    send: "mailer-send",
+    webhook: "mailer-webhook"
+  };
+}
+function makeRedis(opts) {
+  if (isRedisLike(opts)) return opts;
+  const config = {
+    maxRetriesPerRequest: null,
+    // BullMQ requirement
+    enableReadyCheck: false
+  };
+  if (opts.url) {
+    return new IORedis__default.default(opts.url, config);
+  }
+  return new IORedis__default.default({
+    ...config,
+    host: opts.host ?? "127.0.0.1",
+    port: opts.port ?? 6379,
+    password: opts.password,
+    db: opts.db,
+    username: opts.username,
+    tls: opts.tls ? {} : void 0
+  });
+}
+function isRedisLike(x) {
+  return !!x && typeof x === "object" && typeof x.get === "function" && typeof x.set === "function";
+}
+function createQueues(redis) {
+  const names = namespacedQueueNames();
+  const qOpts = { connection: redis };
+  const bullQueues = {
+    tick: new bullmq.Queue(names.tick, qOpts),
+    advance: new bullmq.Queue(names.advance, qOpts),
+    send: new bullmq.Queue(names.send, qOpts),
+    webhook: new bullmq.Queue(names.webhook, qOpts)
+  };
+  return {
+    queues: {
+      tick: adaptBullQueue(bullQueues.tick),
+      advance: adaptBullQueue(bullQueues.advance),
+      send: adaptBullQueue(bullQueues.send),
+      webhook: adaptBullQueue(bullQueues.webhook)
+    },
+    bullQueues
+  };
+}
+async function scheduleTick(bullQueues, intervalSeconds) {
+  await bullQueues.tick.upsertJobScheduler(
+    "mailer-tick-repeat",
+    { every: intervalSeconds * 1e3 },
+    { name: "tick", data: {} }
+  );
+}
+function createWorkers(input) {
+  const names = namespacedQueueNames();
+  const base = { connection: input.redis };
+  const tick = new bullmq.Worker(names.tick, async (job) => input.handlers.tick(job.data), {
+    ...base,
+    concurrency: 1
+    // single tick driver per worker process
+  });
+  const advance = new bullmq.Worker(
+    names.advance,
+    async (job) => input.handlers.advance(job.data),
+    { ...base, concurrency: 10 }
+  );
+  const sendOpts = {
+    ...base,
+    concurrency: input.concurrency.send,
+    limiter: input.sendRateLimit ? { max: input.sendRateLimit.max, duration: input.sendRateLimit.durationMs } : void 0
+  };
+  const send = new bullmq.Worker(names.send, async (job) => input.handlers.send(job.data), sendOpts);
+  const webhook = new bullmq.Worker(
+    names.webhook,
+    async (job) => input.handlers.webhook(job.data),
+    { ...base, concurrency: 4 }
+  );
+  return { tick, advance, send, webhook };
+}
+async function closeQueues(queues) {
+  await Promise.all([queues.tick.close(), queues.advance.close(), queues.send.close(), queues.webhook.close()]);
+}
+async function closeBullQueues(b) {
+  await Promise.all([b.tick.close(), b.advance.close(), b.send.close(), b.webhook.close()]);
+}
+async function closeWorkers(workers) {
+  await Promise.all([workers.tick.close(), workers.advance.close(), workers.send.close(), workers.webhook.close()]);
+}
+
+// src/server/runner/triggers.ts
+var BATCH_SIZE = 1e3;
+async function processNewlyFiredEventTriggers(ctx) {
+  const flows = await ctx.collections.flows.find({ enabled: true, "trigger.type": "event" }).toArray();
+  for (const flow of flows) {
+    await processFlowTriggers(flow, ctx);
+  }
+}
+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();
+  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() } }
+  );
+}
+async function tryEnterFlow(flow, event, ctx) {
+  if (flow.trigger.once) {
+    const existing = await ctx.collections.flowRuns.findOne(
+      { externalId: event.externalId, flowId: flow._id },
+      { projection: { _id: 1 } }
+    );
+    if (existing) return;
+  }
+  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,
+    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()
+  });
+  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;
+    }
+    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;
+}
+async function compileTemplate(mjml) {
+  const out = await mjml2html__default.default(mjml, { validationLevel: "soft", minify: false });
+  const plainText = derivePlaintext(out.html);
+  return { html: out.html, plainText, errors: out.errors ?? [] };
+}
+async function compileMailyTemplate(content) {
+  const { render } = await import('@maily-to/render');
+  const html = await render(content);
+  const plainText = derivePlaintext(html);
+  return { html, plainText, errors: [] };
+}
+function derivePlaintext(html) {
+  return htmlToText.convert(html, {
+    wordwrap: 80,
+    selectors: [
+      { selector: "img", format: "skip" },
+      { selector: "a", options: { hideLinkHrefIfSameAsText: true } }
+    ]
+  }).trim();
+}
+async function renderTemplate(template, ctx, opts = {}) {
+  const hb = makeHandlebars(opts.helpers);
+  const subject = hb.compile(template.subject)(ctx);
+  const preheader = hb.compile(template.preheader)(ctx);
+  let html;
+  if (template.body.html) {
+    html = hb.compile(template.body.html)(ctx);
+  } else {
+    const compiled = await compileTemplate(template.body.mjml);
+    html = hb.compile(compiled.html)(ctx);
+  }
+  const plainText = template.body.plainText ? hb.compile(template.body.plainText)(ctx) : derivePlaintext(html);
+  return {
+    subject,
+    preheader,
+    html,
+    plainText,
+    fromName: template.fromName,
+    fromEmail: template.fromEmail,
+    replyTo: template.replyTo
+  };
+}
+function applyTracking(html, opts) {
+  const preserve = new Set((opts.preserveUrls ?? []).map((u) => u.trim()));
+  const links = [];
+  const seen = /* @__PURE__ */ new Map();
+  let out = html;
+  if (opts.trackClicks) {
+    out = out.replace(/<a\b([^>]*?)\bhref=(["'])([^"']+)\2([^>]*)>/gi, (full, pre, _q, url, post) => {
+      if (shouldSkipClickRewrite(url, preserve, full)) return full;
+      let linkId = seen.get(url);
+      if (!linkId) {
+        linkId = shortHash(`${opts.sendId}:${url}:${links.length}`);
+        seen.set(url, linkId);
+        links.push({ linkId, url });
+      }
+      const newHref = `${opts.publicUrl}/m/click/${opts.sendId}/${linkId}`;
+      return `<a${pre}href="${newHref}"${post}>`;
+    });
+  }
+  if (opts.trackOpens) {
+    const pixel = `<img src="${opts.publicUrl}/m/open/${opts.sendId}.png" width="1" height="1" alt="" style="display:block;border:0" />`;
+    if (/<\/body>/i.test(out)) {
+      out = out.replace(/<\/body>/i, `${pixel}</body>`);
+    } else {
+      out = out + pixel;
+    }
+  }
+  return { html: out, links };
+}
+function shouldSkipClickRewrite(url, preserve, fullTag) {
+  if (!url) return true;
+  if (url.startsWith("mailto:")) return true;
+  if (url.startsWith("tel:")) return true;
+  if (url.startsWith("#")) return true;
+  if (url.startsWith("{{") || url.startsWith("{")) return true;
+  if (preserve.has(url.trim())) return true;
+  if (/data-mailer-notrack=["']true["']/.test(fullTag)) return true;
+  return false;
+}
+function shortHash(input) {
+  return crypto2__default.default.createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+function makeHandlebars(extra) {
+  const hb = Handlebars__default.default.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/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/health.ts
+async function recordHealthCounter(ctx, counter2, by = 1) {
+  await ctx.collections.health.updateOne(
+    { _id: "singleton" },
+    {
+      $inc: { [`counters.${counter2}`]: by },
+      $setOnInsert: {
+        _id: "singleton",
+        windowStartedAt: /* @__PURE__ */ new Date(),
+        windowDurationMs: ctx.config.circuitBreaker.windowMinutes * 60 * 1e3,
+        status: "healthy",
+        trippedAt: null,
+        trippedReason: null,
+        manuallyResumedAt: null,
+        rates: { bounceRate: 0, hardBounceRate: 0, complaintRate: 0, failureRate: 0 }
+      },
+      $set: { updatedAt: /* @__PURE__ */ new Date() }
+    },
+    { upsert: true }
+  );
+}
+async function evaluateHealth(ctx) {
+  const cb = ctx.config.circuitBreaker;
+  const windowMs = cb.windowMinutes * 60 * 1e3;
+  const doc = await ctx.collections.health.findOne({ _id: "singleton" });
+  if (!doc) return;
+  const windowAge = Date.now() - new Date(doc.windowStartedAt).getTime();
+  if (windowAge > windowMs && doc.status !== "tripped") {
+    await ctx.collections.health.updateOne(
+      { _id: "singleton" },
+      {
+        $set: {
+          windowStartedAt: /* @__PURE__ */ new Date(),
+          windowDurationMs: windowMs,
+          counters: { sent: 0, delivered: 0, bounced: 0, hardBounced: 0, softBounced: 0, complained: 0, failedToSend: 0 },
+          rates: { bounceRate: 0, hardBounceRate: 0, complaintRate: 0, failureRate: 0 },
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      }
+    );
+    return;
+  }
+  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: "singleton" },
+    { $set: { rates, updatedAt: /* @__PURE__ */ new Date() } }
+  );
+  if (c.sent < cb.minSendsBeforeEval) return;
+  if (doc.status === "tripped") return;
+  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) {
+    await ctx.collections.health.updateOne(
+      { _id: "singleton" },
+      { $set: { status: "tripped", trippedAt: /* @__PURE__ */ new Date(), trippedReason, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    if (ctx.config.onCircuitBreakerTrip) {
+      try {
+        await ctx.config.onCircuitBreakerTrip({ reason: trippedReason, rates });
+      } catch {
+      }
+    }
+    return;
+  }
+  if (rates.failureRate * 100 >= cb.failedToSendRatePctDegrade) {
+    if (doc.status !== "degraded") {
+      await ctx.collections.health.updateOne(
+        { _id: "singleton" },
+        { $set: { status: "degraded", updatedAt: /* @__PURE__ */ new Date() } }
+      );
+    }
+  } else if (doc.status === "degraded") {
+    await ctx.collections.health.updateOne(
+      { _id: "singleton" },
+      { $set: { status: "healthy", updatedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
+}
+
+// src/server/runner/send.ts
+async function handleSend(run, step, contact, flow, ctx) {
+  const template = await ctx.collections.templates.findOne({ slug: step.templateSlug });
+  if (!template) {
+    await failFlowRun(run, `template not found: ${step.templateSlug}`, ctx);
+    return;
+  }
+  const dedupeKey = `flowrun:${run._id}:step${run.currentStepIndex}`;
+  const existing = await ctx.collections.sends.findOne({ dedupeKey });
+  if (existing) {
+    await advanceStep(run, ctx, {
+      action: "sent",
+      details: { dedupeKey, alreadySent: true, sendId: String(existing._id) }
+    });
+    return;
+  }
+  const providerName = pickProviderName(step.providerOverride, template, ctx);
+  const renderCtx = buildRenderContext(contact, run, step.vars ?? {}, ctx);
+  let rendered;
+  try {
+    rendered = await renderTemplate(template, renderCtx, { helpers: ctx.handlebarsHelpers });
+  } catch (err) {
+    await ctx.collections.sends.insertOne(
+      newSendDoc({
+        dedupeKey,
+        run,
+        contact,
+        template,
+        providerName,
+        renderedSubject: template.subject,
+        bodyHash: "",
+        status: "failed",
+        errorMessage: `render error: ${err?.message ?? err}`
+      })
+    );
+    await advanceStep(run, ctx, {
+      action: "send_skipped",
+      details: { reason: "render_error", message: String(err?.message ?? err) }
+    });
+    return;
+  }
+  const sendId = new mongodb.ObjectId();
+  await ctx.collections.sends.insertOne(
+    newSendDoc({
+      _id: sendId,
+      dedupeKey,
+      run,
+      contact,
+      template,
+      providerName,
+      renderedSubject: rendered.subject,
+      bodyHash: sha256(rendered.html),
+      status: "queued",
+      renderedFrom: rendered.fromName ? { name: rendered.fromName, email: rendered.fromEmail } : void 0,
+      vars: step.vars ?? {}
+    })
+  );
+  await ctx.queues.send.add(
+    "send",
+    { sendId: String(sendId) },
+    { attempts: ctx.config.sendRetryAttempts, backoff: { type: "exponential", delay: 6e4 } }
+  );
+  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 });
+  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);
+    return;
+  }
+  const supp = await isSuppressed(ctx.collections, send.emailAtSend, send.kind);
+  if (supp.suppressed) {
+    await ctx.collections.sends.updateOne(
+      { _id: send._id },
+      { $set: { status: "suppressed", errorMessage: `suppressed: ${supp.reason}` } }
+    );
+    return;
+  }
+  if (send.kind === "marketing") {
+    const health = await ctx.collections.health.findOne({ _id: "singleton" });
+    if (health?.status === "tripped") {
+      await ctx.queues.send.add("send", { sendId: String(send._id) }, { delay: 6e4 });
+      return;
+    }
+  }
+  const contact = await ctx.adapter.getById(send.externalId);
+  if (!contact) {
+    await markFailed(send._id, "contact_missing", ctx);
+    return;
+  }
+  const run = send.flowRunId ? await ctx.collections.flowRuns.findOne({ _id: send.flowRunId }) : null;
+  const renderCtx = buildRenderContext(
+    contact,
+    run,
+    send.vars ?? {},
+    ctx
+  );
+  const rendered = await renderTemplate(template, renderCtx, { helpers: ctx.handlebarsHelpers });
+  const tracking = applyTracking(rendered.html, {
+    sendId: String(send._id),
+    publicUrl: ctx.config.publicUrl,
+    trackOpens: template.trackOpens ?? ctx.config.trackOpens,
+    trackClicks: template.trackClicks ?? ctx.config.trackClicks,
+    preserveUrls: [renderCtx.unsubscribeUrl]
+  });
+  await ctx.collections.sends.updateOne(
+    { _id: send._id },
+    {
+      $set: {
+        links: tracking.links,
+        bodyHash: sha256(tracking.html),
+        status: "sending",
+        fromName: rendered.fromName,
+        fromEmail: rendered.fromEmail,
+        subject: rendered.subject
+      }
+    }
+  );
+  const provider = ctx.providers[send.provider] ?? ctx.providers[ctx.config.defaultProvider];
+  if (!provider) {
+    await markFailed(send._id, `provider_unknown: ${send.provider}`, ctx);
+    return;
+  }
+  try {
+    const result = await provider.send({
+      to: send.emailAtSend,
+      fromName: rendered.fromName,
+      fromEmail: rendered.fromEmail,
+      replyTo: rendered.replyTo ?? void 0,
+      subject: rendered.subject,
+      html: tracking.html,
+      text: rendered.plainText,
+      headers: {
+        "List-Unsubscribe": `<${renderCtx.unsubscribeUrl}>`,
+        "List-Unsubscribe-Post": "List-Unsubscribe=One-Click"
+      },
+      messageMeta: { sendId: String(send._id) }
+    });
+    await ctx.collections.sends.updateOne(
+      { _id: send._id },
+      {
+        $set: {
+          status: "sent",
+          sentAt: /* @__PURE__ */ new Date(),
+          providerMessageId: result.providerId
+        }
+      }
+    );
+    await recordHealthCounter(ctx, "sent");
+  } catch (err) {
+    await ctx.collections.sends.updateOne(
+      { _id: send._id },
+      { $set: { status: "failed", errorMessage: String(err?.message ?? err) } }
+    );
+    await recordHealthCounter(ctx, "failedToSend");
+    if (ctx.config.onSendFailure) {
+      try {
+        await ctx.config.onSendFailure({ send, error: err });
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+function pickProviderName(stepOverride, tpl, ctx) {
+  if (stepOverride) return stepOverride;
+  if (tpl.providerOverride) return tpl.providerOverride;
+  if (tpl.kind === "transactional" && ctx.config.defaultTransactionalProvider) {
+    return ctx.config.defaultTransactionalProvider;
+  }
+  return ctx.config.defaultProvider;
+}
+function buildRenderContext(contact, run, vars, ctx) {
+  const scope = "marketing";
+  const expiresAt = new Date(Date.now() + ctx.config.unsubscribeTokenLifetimeDays * 24 * 60 * 60 * 1e3);
+  const token = signUnsubscribeToken(
+    { email: contact.email, scope, expiresAt },
+    ctx.config.unsubscribeSecret
+  );
+  const unsubscribeUrl = `${ctx.config.publicUrl}/m/unsub/${token}`;
+  return {
+    contact,
+    vars,
+    unsubscribeUrl,
+    senderAddress: ctx.config.senderAddress
+  };
+}
+function newSendDoc(input) {
+  return {
+    _id: input._id,
+    dedupeKey: input.dedupeKey,
+    externalId: input.run.externalId,
+    emailAtSend: input.contact.email,
+    templateId: input.template._id,
+    templateSlug: input.template.slug,
+    flowRunId: input.run._id,
+    broadcastId: null,
+    manualSendBy: null,
+    kind: input.template.kind,
+    provider: input.providerName,
+    providerMessageId: null,
+    fromName: input.renderedFrom?.name ?? input.template.fromName,
+    fromEmail: input.renderedFrom?.email ?? input.template.fromEmail,
+    subject: input.renderedSubject,
+    bodyHash: input.bodyHash,
+    status: input.status,
+    errorMessage: input.errorMessage ?? null,
+    bounceType: null,
+    bounceReason: null,
+    links: [],
+    vars: input.vars ?? {},
+    openedAt: null,
+    openCount: 0,
+    firstClickAt: null,
+    clickCount: 0,
+    clickedLinks: [],
+    unsubscribedAt: null,
+    complainedAt: null,
+    queuedAt: /* @__PURE__ */ new Date(),
+    sentAt: null,
+    deliveredAt: null
+  };
+}
+async function markFailed(sendId, reason, ctx) {
+  await ctx.collections.sends.updateOne(
+    { _id: sendId },
+    { $set: { status: "failed", errorMessage: reason } }
+  );
+}
+function sha256(s) {
+  return crypto2__default.default.createHash("sha256").update(s).digest("hex");
+}
+
+// src/server/runner/step.ts
+async function processOneRunStep(runId, ctx) {
+  const run = await ctx.collections.flowRuns.findOne({ _id: runId });
+  if (!run || run.status !== "active") return;
+  const flow = await ctx.collections.flows.findOne({ _id: run.flowId });
+  if (!flow) {
+    await failFlowRun(run, "flow_missing", ctx);
+    return;
+  }
+  const steps = await loadStepsForRun(run, flow, ctx);
+  const step = locateStep(steps, run.currentStepIndex, run.currentBranchPath);
+  if (!step) {
+    await completeFlowRun(run, "completed", ctx);
+    return;
+  }
+  const contact = await ctx.adapter.getById(run.externalId);
+  if (!contact) {
+    await exitFlowRun(run, "contact_missing", ctx);
+    return;
+  }
+  const sub = await ctx.collections.subscriptions.findOne({ externalId: run.externalId });
+  if (sub && sub.status !== "subscribed") {
+    await exitFlowRun(run, sub.status, ctx);
+    return;
+  }
+  switch (step.type) {
+    case "wait":
+      return handleWait(run, step, ctx);
+    case "condition":
+      return handleCondition(run, step, contact, ctx);
+    case "branch":
+      return handleBranch(run, step, contact, ctx);
+    case "send":
+      return handleSend(run, step, contact, flow, ctx);
+    case "tag":
+      return handleTag(run, step, ctx);
+    case "fire_event":
+      return handleFireEvent(run, step, ctx);
+    case "webhook":
+      return handleWebhookStep(run, step, ctx);
+    case "exit":
+      return exitFlowRun(run, step.reason ?? "exit_step", ctx);
+  }
+}
+async function handleWait(run, step, ctx) {
+  const ms = unitToMs(step.value, step.unit);
+  const nextAt = new Date(Date.now() + ms);
+  const updated = await ctx.collections.flowRuns.findOneAndUpdate(
+    { _id: run._id, currentStepIndex: run.currentStepIndex },
+    {
+      $set: { nextActionAt: nextAt, attemptsForCurrentStep: 0, updatedAt: /* @__PURE__ */ new Date() },
+      $inc: { currentStepIndex: 1 },
+      $push: {
+        history: {
+          stepIndex: run.currentStepIndex,
+          action: "wait_started",
+          at: /* @__PURE__ */ new Date(),
+          details: { until: nextAt }
+        }
+      }
+    },
+    { returnDocument: "after" }
+  );
+  if (!updated) return;
+  await ctx.queues.advance.add(
+    "advance",
+    { flowRunId: String(run._id) },
+    { delay: ms, jobId: `advance:${run._id}:${run.currentStepIndex + 1}` }
+  );
+}
+async function handleCondition(run, step, contact, ctx) {
+  if (!contact) return;
+  const result = await evaluatePredicate(step.test, { contact, run, collections: ctx.collections });
+  if (result) {
+    await advanceStep(run, ctx, { action: "condition_evaluated", details: { result: true } });
+    return;
+  }
+  if (step.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) {
+  if (!contact) return;
+  const result = await evaluatePredicate(step.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 },
+    {
+      $set: {
+        currentBranchPath: newPath,
+        currentStepIndex: 0,
+        nextActionAt: /* @__PURE__ */ new Date(),
+        attemptsForCurrentStep: 0,
+        updatedAt: /* @__PURE__ */ new Date()
+      },
+      $push: {
+        history: {
+          stepIndex: run.currentStepIndex,
+          action: "branch_taken",
+          at: /* @__PURE__ */ new Date(),
+          details: { result }
+        }
+      }
+    },
+    { returnDocument: "after" }
+  );
+  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 ?? [];
+  if (ctx.adapter.addTags && adds.length > 0) {
+    await ctx.adapter.addTags(run.externalId, adds);
+  } else if (adds.length > 0) {
+    await ctx.collections.contactTags.bulkWrite(
+      adds.map((tag) => ({
+        updateOne: {
+          filter: { externalId: run.externalId, tag },
+          update: { $setOnInsert: { externalId: run.externalId, tag, appliedBy: "flow", appliedAt: /* @__PURE__ */ new Date() } },
+          upsert: true
+        }
+      }))
+    );
+  }
+  if (ctx.adapter.removeTags && removes.length > 0) {
+    await ctx.adapter.removeTags(run.externalId, removes);
+  } else if (removes.length > 0) {
+    await ctx.collections.contactTags.deleteMany({ externalId: run.externalId, tag: { $in: removes } });
+  }
+  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}`;
+  try {
+    await ctx.collections.events.insertOne({
+      externalId: run.externalId,
+      name: step.eventName,
+      properties: step.properties ?? {},
+      dedupeKey,
+      occurredAt: /* @__PURE__ */ new Date(),
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  } catch (err) {
+    if (err?.code !== 11e3) throw err;
+  }
+  await advanceStep(run, ctx, { action: "event_fired", details: { name: step.eventName } });
+}
+async function handleWebhookStep(run, step, ctx) {
+  try {
+    const res = await fetch(step.url, {
+      method: step.method ?? "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(step.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 } });
+  } catch (err) {
+    const attempts = (run.attemptsForCurrentStep ?? 0) + 1;
+    if (attempts >= ctx.config.webhookRetryAttempts) {
+      if (step.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 }
+        });
+      }
+    } else {
+      await ctx.collections.flowRuns.updateOne(
+        { _id: run._id, currentStepIndex: run.currentStepIndex },
+        { $inc: { attemptsForCurrentStep: 1 }, $set: { nextActionAt: new Date(Date.now() + 6e4) } }
+      );
+      await ctx.queues.advance.add(
+        "advance",
+        { flowRunId: String(run._id) },
+        { delay: 6e4, jobId: `advance:${run._id}:${run.currentStepIndex}:retry-${attempts}` }
+      );
+    }
+  }
+}
+async function advanceStep(run, ctx, log, opts = {}) {
+  const stepInc = opts.stepInc ?? 1;
+  const updated = await ctx.collections.flowRuns.findOneAndUpdate(
+    { _id: run._id, currentStepIndex: run.currentStepIndex },
+    {
+      $set: { nextActionAt: /* @__PURE__ */ new Date(), attemptsForCurrentStep: 0, updatedAt: /* @__PURE__ */ new Date() },
+      $inc: { currentStepIndex: stepInc },
+      $push: {
+        history: { stepIndex: run.currentStepIndex, action: log.action, at: /* @__PURE__ */ new Date(), details: log.details }
+      }
+    },
+    { returnDocument: "after" }
+  );
+  if (!updated) return;
+  await ctx.queues.advance.add("advance", { flowRunId: String(run._id) });
+}
+async function exitFlowRun(run, reason, ctx) {
+  await ctx.collections.flowRuns.updateOne(
+    { _id: run._id, status: "active" },
+    {
+      $set: { status: "exited", exitedAt: /* @__PURE__ */ new Date(), exitReason: reason, updatedAt: /* @__PURE__ */ new Date() },
+      $push: { history: { stepIndex: run.currentStepIndex, action: "exited", at: /* @__PURE__ */ new Date(), details: { reason } } }
+    }
+  );
+}
+async function completeFlowRun(run, reason, ctx) {
+  await ctx.collections.flowRuns.updateOne(
+    { _id: run._id, status: "active" },
+    {
+      $set: { status: "completed", exitedAt: /* @__PURE__ */ new Date(), exitReason: reason, updatedAt: /* @__PURE__ */ new Date() }
+    }
+  );
+}
+async function failFlowRun(run, reason, ctx) {
+  await ctx.collections.flowRuns.updateOne(
+    { _id: run._id, status: "active" },
+    {
+      $set: { status: "failed", exitedAt: /* @__PURE__ */ new Date(), exitReason: reason, updatedAt: /* @__PURE__ */ new Date() },
+      $push: { history: { stepIndex: run.currentStepIndex, action: "failed", at: /* @__PURE__ */ new Date(), details: { reason } } }
+    }
+  );
+}
+async function loadStepsForRun(run, flow, ctx) {
+  if (run.flowVersion === flow.version) return flow.steps;
+  const snapshot = await ctx.collections.flowVersions.findOne({ flowId: run.flowId, version: run.flowVersion });
+  return snapshot?.steps ?? flow.steps;
+}
+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 parent = arr[parentIndex];
+    if (!parent || parent.type !== "branch") return null;
+    arr = branchKey === "true" ? parent.ifTrueSteps : parent.ifFalseSteps;
+  }
+  return arr[currentStepIndex] ?? null;
+}
+function unitToMs(value, unit) {
+  const m = 6e4;
+  switch (unit) {
+    case "minutes":
+      return value * m;
+    case "hours":
+      return value * 60 * m;
+    case "days":
+      return value * 24 * 60 * m;
+    case "weeks":
+      return value * 7 * 24 * 60 * m;
+  }
+}
+
+// src/server/runner/sweep.ts
+var SWEEP_LIMIT = 500;
+async function sweepStrandedFlowRuns(ctx) {
+  const runs = await ctx.collections.flowRuns.find({ status: "active", nextActionAt: { $lte: /* @__PURE__ */ new Date() } }).sort({ nextActionAt: 1 }).limit(SWEEP_LIMIT).toArray();
+  for (const run of runs) {
+    try {
+      await processOneRunStep(run._id, ctx);
+    } catch (err) {
+      console.error("mailery: sweep advance failed", { runId: String(run._id), err });
+    }
+  }
+}
+async function processScheduledBroadcasts(ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const due = await ctx.collections.broadcasts.find({ status: "scheduled", scheduledAt: { $lte: now } }).toArray();
+  for (const b of due) {
+    const claimed = await ctx.collections.broadcasts.findOneAndUpdate(
+      { _id: b._id, status: "scheduled" },
+      { $set: { status: "sending", startedAt: now, updatedAt: now } },
+      { 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() } }
+      );
+    }
+  }
+}
+async function dispatchBroadcast(broadcast, ctx) {
+  const template = await ctx.collections.templates.findOne({ slug: broadcast.templateSlug });
+  if (!template) {
+    await ctx.collections.broadcasts.updateOne(
+      { _id: broadcast._id },
+      { $set: { status: "failed", updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    return;
+  }
+  const hostFilter = toAdapterFilter(broadcast.segmentDefinition);
+  const postFilters = broadcast.segmentDefinition.filters.filter((f) => isMailerSide(f));
+  let cursor = void 0;
+  let total = 0;
+  const batchSize = ctx.config.broadcastEnqueueBatchSize;
+  const maxWaiting = ctx.config.broadcastEnqueueMaxWaiting;
+  const respectTimezone = broadcast.respectRecipientTimezone === true;
+  const scheduledMs = broadcast.scheduledAt?.getTime() ?? Date.now();
+  for (; ; ) {
+    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 sleep(2e3);
+      }
+      const sendDocs = await Promise.all(
+        eligible.map(async (contact) => buildSendDoc(broadcast, template, contact, ctx, scheduledMs, respectTimezone))
+      );
+      const inserted = [];
+      for (const { doc, delayMs } of sendDocs) {
+        if (!doc) continue;
+        try {
+          await ctx.collections.sends.insertOne(doc);
+          inserted.push({ sendId: doc._id, delayMs });
+        } catch (err) {
+          if (err?.code !== 11e3) throw err;
+        }
+      }
+      if (inserted.length > 0) {
+        await Promise.all(
+          inserted.map(
+            ({ sendId, delayMs }) => ctx.queues.send.add(
+              "send",
+              { sendId: String(sendId) },
+              {
+                attempts: ctx.config.sendRetryAttempts,
+                backoff: { type: "exponential", delay: 6e4 },
+                ...delayMs > 0 ? { delay: delayMs } : {}
+              }
+            )
+          )
+        );
+      }
+      total += inserted.length;
+    }
+    if (!page.nextCursor) break;
+    cursor = page.nextCursor;
+  }
+  await ctx.collections.broadcasts.updateOne(
+    { _id: broadcast._id },
+    {
+      $set: {
+        status: "sent",
+        completedAt: /* @__PURE__ */ new Date(),
+        recipientCount: total,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    }
+  );
+}
+function toAdapterFilter(seg) {
+  const out = {};
+  for (const f of seg.filters) {
+    switch (f.kind) {
+      case "hasTag":
+        out.hasTag = f.tag;
+        break;
+      case "fieldEquals":
+        out.fieldEquals = { field: f.field, value: f.value };
+        break;
+      case "fieldIn":
+        out.fieldIn = { field: f.field, values: f.values };
+        break;
+      case "fieldExists":
+        out.fieldExists = f.field;
+        break;
+    }
+  }
+  return out;
+}
+function isMailerSide(f) {
+  return f.kind === "subscriptionStatus" || f.kind === "firedEvent" || f.kind === "notFiredEvent" || f.kind === "subscribedAfter" || f.kind === "subscribedBefore" || f.kind === "opened" || f.kind === "notOpened" || f.kind === "notHasTag" || f.kind === "any" || f.kind === "not";
+}
+async function applyPostFilters(contacts, filters, ctx) {
+  if (filters.length === 0) return contacts;
+  const externalIds = contacts.map((c) => c.externalId);
+  const cache = {};
+  for (const f of filters) {
+    if (f.kind === "subscriptionStatus") {
+      const docs = await ctx.collections.subscriptions.find({ externalId: { $in: externalIds }, status: f.equals }).project({ externalId: 1 }).toArray();
+      cache[`sub:${f.equals}`] = new Set(docs.map((d) => d.externalId));
+    }
+    if (f.kind === "firedEvent" || f.kind === "notFiredEvent") {
+      const query = { externalId: { $in: externalIds }, name: f.eventName };
+      if (f.withinDays) {
+        query.occurredAt = { $gt: new Date(Date.now() - f.withinDays * 864e5) };
+      }
+      const docs = await ctx.collections.events.find(query).project({ externalId: 1 }).toArray();
+      cache[`evt:${f.eventName}`] = new Set(docs.map((d) => d.externalId));
+    }
+  }
+  return contacts.filter((c) => filters.every((f) => filterMatches(c, f, cache)));
+}
+function filterMatches(c, f, cache) {
+  switch (f.kind) {
+    case "subscriptionStatus":
+      return cache[`sub:${f.equals}`]?.has(c.externalId) ?? false;
+    case "firedEvent":
+      return cache[`evt:${f.eventName}`]?.has(c.externalId) ?? false;
+    case "notFiredEvent":
+      return !cache[`evt:${f.eventName}`]?.has(c.externalId);
+    case "notHasTag":
+      return !c.tags.includes(f.tag);
+    case "opened":
+    case "notOpened":
+      return true;
+    case "subscribedAfter":
+    case "subscribedBefore":
+      return true;
+    // V2
+    case "any":
+      return f.filters.some((sub) => filterMatches(c, sub, cache));
+    case "not":
+      return !filterMatches(c, f.filter, cache);
+    default:
+      return true;
+  }
+}
+async function buildSendDoc(broadcast, template, contact, ctx, scheduledMs, respectTimezone) {
+  const supp = await isSuppressed(ctx.collections, contact.email, template.kind);
+  if (supp.suppressed) return { doc: null, delayMs: 0 };
+  const sendId = new mongodb.ObjectId();
+  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 doc = {
+    _id: sendId,
+    dedupeKey,
+    externalId: contact.externalId,
+    emailAtSend: contact.email,
+    templateId: template._id,
+    templateSlug: template.slug,
+    flowRunId: null,
+    broadcastId: broadcast._id,
+    manualSendBy: null,
+    kind: template.kind,
+    provider: template.providerOverride ?? ctx.config.defaultProvider,
+    providerMessageId: null,
+    fromName: template.fromName,
+    fromEmail: template.fromEmail,
+    subject: template.subject,
+    bodyHash: "",
+    status: "queued",
+    errorMessage: null,
+    bounceType: null,
+    bounceReason: null,
+    links: [],
+    vars: {},
+    openedAt: null,
+    openCount: 0,
+    firstClickAt: null,
+    clickCount: 0,
+    clickedLinks: [],
+    unsubscribedAt: null,
+    complainedAt: null,
+    queuedAt: /* @__PURE__ */ new Date(),
+    sentAt: null,
+    deliveredAt: null
+  };
+  return { doc, delayMs };
+}
+function perRecipientDelayMs(scheduledMs, timezone) {
+  try {
+    const scheduled = new Date(scheduledMs);
+    const utc = scheduled.toLocaleString("en-US", { timeZone: "UTC", hour12: false });
+    const local = scheduled.toLocaleString("en-US", { timeZone: timezone, hour12: false });
+    const parse = (s) => {
+      const m = s.match(/(\d+)\/(\d+)\/(\d+),\s*(\d+):(\d+):(\d+)/);
+      if (!m) return 0;
+      return Date.UTC(+m[3], +m[1] - 1, +m[2], +m[4], +m[5], +m[6]);
+    };
+    const utcMs = parse(utc);
+    const localMs = parse(local);
+    const offsetMs = utcMs - localMs;
+    return offsetMs;
+  } catch {
+    return 0;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/server/runner/bounce-promotion.ts
+async function promoteSoftBounces(ctx) {
+  const threshold = ctx.config.softBouncePromotionThreshold;
+  const windowDays = ctx.config.softBouncePromotionWindowDays;
+  if (threshold <= 0 || windowDays <= 0) return;
+  const cutoff = new Date(Date.now() - windowDays * 864e5);
+  const offenders = await ctx.collections.sends.aggregate([
+    { $match: { status: "bounced", bounceType: "soft", queuedAt: { $gt: cutoff } } },
+    { $group: { _id: "$emailAtSend", count: { $sum: 1 } } },
+    { $match: { count: { $gte: threshold } } },
+    { $limit: 200 }
+  ]).toArray();
+  for (const o of offenders) {
+    const email = String(o._id ?? "").toLowerCase();
+    if (!email) continue;
+    const existing = await ctx.collections.suppressions.findOne({
+      email,
+      scope: "all"
+    });
+    if (existing) continue;
+    await ctx.collections.suppressions.updateOne(
+      { email, scope: "all" },
+      {
+        $setOnInsert: {
+          email,
+          emailHash: sha256Hex(email),
+          scope: "all",
+          reason: "hard_bounce",
+          source: "soft_promotion",
+          notes: `${o.count} soft bounces in last ${windowDays} days`,
+          addedAt: /* @__PURE__ */ new Date(),
+          expiresAt: null
+        }
+      },
+      { upsert: true }
+    );
+    await ctx.collections.subscriptions.updateOne(
+      { emailAtSubscribe: email },
+      { $set: { status: "bounced", updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    await recordHealthCounter(ctx, "hardBounced");
+  }
+}
+
+// src/server/runner/tick.ts
+async function runTick(ctx) {
+  await processNewlyFiredEventTriggers(ctx).catch((err) => {
+    console.error("mailery: triggers scan failed", err);
+  });
+  await sweepStrandedFlowRuns(ctx).catch((err) => {
+    console.error("mailery: sweep failed", err);
+  });
+  await drainOutbox(ctx).catch((err) => {
+    console.error("mailery: outbox drain failed", err);
+  });
+  await processScheduledBroadcasts2(ctx).catch((err) => {
+    console.error("mailery: broadcast dispatch 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);
+  });
+}
+async function drainOutbox(ctx) {
+  const batch = await ctx.collections.outbox.find({ status: "pending" }).sort({ enqueuedAt: 1 }).limit(200).toArray();
+  for (const row of batch) {
+    try {
+      if (row.payload.type === "event") {
+        try {
+          await ctx.collections.events.insertOne({
+            externalId: row.payload.data.externalId,
+            name: row.payload.data.name,
+            properties: row.payload.data.properties ?? {},
+            dedupeKey: row.payload.dedupeKey,
+            occurredAt: row.payload.data.occurredAt ?? /* @__PURE__ */ new Date(),
+            createdAt: /* @__PURE__ */ new Date()
+          });
+        } catch (err) {
+          if (err?.code !== 11e3) throw err;
+        }
+      }
+      await ctx.collections.outbox.updateOne(
+        { _id: row._id },
+        { $set: { status: "processed", processedAt: /* @__PURE__ */ new Date() } }
+      );
+    } catch (err) {
+      await ctx.collections.outbox.updateOne(
+        { _id: row._id },
+        {
+          $set: { lastAttemptAt: /* @__PURE__ */ new Date(), lastError: String(err?.message ?? err) },
+          $inc: { attempts: 1 }
+        }
+      );
+    }
+  }
+}
+async function processScheduledBroadcasts2(ctx) {
+  await processScheduledBroadcasts(ctx);
+}
+
+// src/server/runner/webhook.ts
+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");
+      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() } }
+        );
+      }
+      await recordHealthCounter(ctx, "bounced");
+      await recordHealthCounter(ctx, bounceType === "hard" ? "hardBounced" : "softBounced");
+      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");
+      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;
+  collections;
+  adapter;
+  providers;
+  redis;
+  queues;
+  config;
+  events;
+  workers = null;
+  bullQueues;
+  runnerContext;
+  constructor(args) {
+    this.config = args.config;
+    this.db = args.db;
+    this.collections = args.collections;
+    this.adapter = args.adapter;
+    this.providers = args.providers;
+    this.redis = args.redis;
+    this.queues = args.queues;
+    this.bullQueues = args.bullQueues;
+    this.events = args.events;
+    this.runnerContext = {
+      db: this.db,
+      collections: this.collections,
+      adapter: this.adapter,
+      providers: this.providers,
+      queues: this.queues,
+      config: this.config,
+      handlebarsHelpers: this.config.handlebarsHelpers
+    };
+  }
+  /**
+   * Construct a Mailer from environment variables. Reads:
+   *
+   *   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_PUBLIC_URL                 — base for tracking/unsub URLs (required)
+   *   MAILER_UNSUBSCRIBE_SECRET         — HMAC key (required)
+   *   MAILER_SENDER_ADDRESS             — postal address for CAN-SPAM (optional)
+   *   MAILER_FROM_NAME / MAILER_FROM_EMAIL
+   *   MAILER_DEFAULT_PROVIDER           — defaults to 'sendgrid' if SENDGRID_API_KEY is set
+   *   MAILER_SENDGRID_API_KEY / MAILER_SENDGRID_WEBHOOK_KEY
+   *   MAILER_HOST_USERS_COLLECTION (default 'users')
+   *   MAILER_HOST_USERS_EMAIL_FIELD (default 'email')
+   *   MAILER_HOST_USERS_ID_FIELD (default '_id')
+   *   MAILER_HOST_USERS_TAGS_FIELD
+   *   MAILER_HOST_USERS_TAGS_WRITABLE — '1' or 'true' to enable
+   *
+   * For anything beyond this (custom toContact, custom providers, hooks),
+   * use the programmatic init.
+   */
+  static async fromEnv() {
+    const env = process.env;
+    const required = (k) => {
+      const v = env[k];
+      if (!v) throw new Error(`Mailer.fromEnv: missing env var ${k}`);
+      return v;
+    };
+    const { MongoClient } = await import('mongodb');
+    const mongoClient = await MongoClient.connect(required("MAILER_MONGODB_URI"));
+    const db = env.MAILER_MONGODB_DB ? mongoClient.db(env.MAILER_MONGODB_DB) : mongoClient.db();
+    const { MongoContactAdapter: MongoContactAdapter2 } = await Promise.resolve().then(() => (init_mongo(), mongo_exports));
+    const adapter = new MongoContactAdapter2({
+      db,
+      collection: env.MAILER_HOST_USERS_COLLECTION ?? "users",
+      emailField: env.MAILER_HOST_USERS_EMAIL_FIELD ?? "email",
+      idField: env.MAILER_HOST_USERS_ID_FIELD ?? "_id",
+      tagsField: env.MAILER_HOST_USERS_TAGS_FIELD,
+      tagsWritable: env.MAILER_HOST_USERS_TAGS_WRITABLE === "1" || env.MAILER_HOST_USERS_TAGS_WRITABLE === "true"
+    });
+    const providers = {};
+    if (env.MAILER_SENDGRID_API_KEY) {
+      const { SendGridProvider: SendGridProvider2 } = await Promise.resolve().then(() => (init_sendgrid(), sendgrid_exports));
+      providers.sendgrid = new SendGridProvider2({
+        apiKey: env.MAILER_SENDGRID_API_KEY,
+        webhookVerificationKey: env.MAILER_SENDGRID_WEBHOOK_KEY,
+        sandbox: env.NODE_ENV !== "production"
+      });
+    }
+    if (Object.keys(providers).length === 0) {
+      throw new Error("Mailer.fromEnv: no provider configured (set MAILER_SENDGRID_API_KEY, ...)");
+    }
+    const defaultProvider = env.MAILER_DEFAULT_PROVIDER ?? Object.keys(providers)[0];
+    return _Mailer.init({
+      db,
+      adapter,
+      redis: { url: required("MAILER_REDIS_URL") },
+      providers,
+      defaultProvider,
+      publicUrl: required("MAILER_PUBLIC_URL"),
+      unsubscribeSecret: required("MAILER_UNSUBSCRIBE_SECRET"),
+      senderAddress: env.MAILER_SENDER_ADDRESS,
+      fromDefaults: env.MAILER_FROM_NAME && env.MAILER_FROM_EMAIL ? { name: env.MAILER_FROM_NAME, email: env.MAILER_FROM_EMAIL } : void 0
+    });
+  }
+  static async init(input) {
+    const config = resolveConfig(input);
+    if (!config.providers[config.defaultProvider]) {
+      throw new Error(`defaultProvider "${config.defaultProvider}" not in providers map`);
+    }
+    const collections = getCollections(config.db, config.collectionPrefix);
+    await ensureIndexes(config.db, config.collectionPrefix);
+    let redis = null;
+    let queues;
+    let bullQueues = null;
+    if (config.redis === null) {
+      queues = noopQueues();
+    } else {
+      redis = makeRedis(config.redis);
+      const created = createQueues(redis);
+      queues = created.queues;
+      bullQueues = created.bullQueues;
+      if (!config.workerless) {
+        await scheduleTick(bullQueues, config.tickIntervalSeconds);
+      }
+    }
+    return new _Mailer({
+      config,
+      db: config.db,
+      collections,
+      adapter: config.adapter,
+      providers: config.providers,
+      redis,
+      queues,
+      bullQueues,
+      events: new EventRegistry()
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Event registration + firing
+  // -------------------------------------------------------------------------
+  registerEvent(reg) {
+    const parsed = registerEventSchema.parse(reg);
+    this.events.register(parsed);
+  }
+  async fire(eventName, externalId, properties = {}, dedupeKey) {
+    const input = fireInputSchema.parse({ eventName, externalId, properties, dedupeKey });
+    const key = this.events.deriveKey(input.eventName, input.externalId, input.dedupeKey, /* @__PURE__ */ new Date());
+    if (!key) {
+      throw new Error(
+        `fire("${input.eventName}") missing dedupeKey and no policy registered. Call mailer.registerEvent("${input.eventName}", { dedupePolicy }) or pass a key explicitly.`
+      );
+    }
+    try {
+      await this.collections.events.insertOne({
+        externalId: input.externalId,
+        name: input.eventName,
+        properties: input.properties ?? {},
+        dedupeKey: key,
+        occurredAt: /* @__PURE__ */ new Date(),
+        createdAt: /* @__PURE__ */ new Date()
+      });
+    } catch (err) {
+      if (err?.code !== 11e3) throw err;
+    }
+  }
+  async fireFromSession(session, eventName, externalId, properties = {}, dedupeKey) {
+    const input = fireInputSchema.parse({ eventName, externalId, properties, dedupeKey });
+    const key = this.events.deriveKey(input.eventName, input.externalId, input.dedupeKey, /* @__PURE__ */ new Date());
+    if (!key) {
+      throw new Error(`fireFromSession("${input.eventName}") missing dedupeKey and no policy registered.`);
+    }
+    try {
+      await this.collections.outbox.insertOne(
+        {
+          payload: {
+            type: "event",
+            data: {
+              externalId: input.externalId,
+              name: input.eventName,
+              properties: input.properties ?? {},
+              occurredAt: /* @__PURE__ */ new Date()
+            },
+            dedupeKey: key
+          },
+          status: "pending",
+          attempts: 0,
+          lastAttemptAt: null,
+          lastError: null,
+          enqueuedAt: /* @__PURE__ */ new Date(),
+          processedAt: null
+        },
+        { session }
+      );
+    } catch (err) {
+      if (err?.code !== 11e3) throw err;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Subscription / unsubscribe / tags / suppression
+  // -------------------------------------------------------------------------
+  async upsertSubscription(input) {
+    const parsed = upsertSubscriptionSchema.parse(input);
+    const contact = await this.adapter.getById(parsed.externalId);
+    if (!contact) throw new Error(`adapter has no contact for externalId ${parsed.externalId}`);
+    const status = this.config.requireDoubleOptIn ? "pending_doi" : "subscribed";
+    const now = /* @__PURE__ */ new Date();
+    let doiToken = null;
+    let doiTokenHash = null;
+    if (status === "pending_doi") {
+      const expiresAt = new Date(now.getTime() + this.config.doiTokenLifetimeDays * 864e5);
+      doiToken = signDoiToken({ externalId: parsed.externalId, expiresAt }, this.config.unsubscribeSecret);
+      doiTokenHash = sha256Hex(doiToken);
+    }
+    await this.collections.subscriptions.updateOne(
+      { externalId: parsed.externalId },
+      {
+        $set: {
+          status,
+          source: parsed.source,
+          emailAtSubscribe: contact.email,
+          subscribedAt: status === "subscribed" ? parsed.consentTimestamp ?? now : null,
+          updatedAt: now,
+          ...doiTokenHash ? { doiTokenHash, doiRequestedAt: now } : {}
+        },
+        $setOnInsert: {
+          externalId: parsed.externalId,
+          createdAt: now,
+          unsubscribedAt: null,
+          unsubscribeReason: null,
+          doiTokenHash: null,
+          doiRequestedAt: null,
+          doiConfirmedAt: null,
+          doiIp: parsed.consentIp ?? null,
+          doiUserAgent: parsed.consentUserAgent ?? null
+        }
+      },
+      { upsert: true }
+    );
+    if (status === "pending_doi" && doiToken) {
+      const tpl = await this.collections.templates.findOne({ slug: this.config.doiTemplateSlug });
+      if (!tpl) {
+        console.warn(`mailery: DOI required but template "${this.config.doiTemplateSlug}" not found \u2014 skipping confirmation email`);
+        return;
+      }
+      const dedupeKey = `doi:${parsed.externalId}:${now.toISOString().slice(0, 10)}`;
+      try {
+        await this.sendOneOff({
+          templateSlug: tpl.slug,
+          externalId: parsed.externalId,
+          vars: { confirmDoiUrl: `${this.config.publicUrl}/m/confirm-doi/${doiToken}` },
+          dedupeKey
+        });
+      } catch (err) {
+        console.error("mailery: DOI confirmation send failed", err);
+      }
+    }
+  }
+  async unsubscribe(email, opts) {
+    const parsed = unsubscribeInputSchema.parse({ email, ...opts });
+    const normalized = parsed.email;
+    const now = /* @__PURE__ */ new Date();
+    await this.collections.suppressions.updateOne(
+      { email: normalized, scope: parsed.scope },
+      {
+        $setOnInsert: {
+          email: normalized,
+          emailHash: sha256Hex(normalized),
+          scope: parsed.scope,
+          // mailer_suppressions canonical reason — see plans/02-data-model.md.
+          reason: "unsubscribed",
+          source: parsed.source,
+          notes: parsed.notes ?? null,
+          addedAt: now,
+          expiresAt: null
+        }
+      },
+      { upsert: true }
+    );
+    await this.collections.subscriptions.updateOne(
+      { emailAtSubscribe: normalized },
+      {
+        $set: {
+          status: "unsubscribed",
+          unsubscribedAt: now,
+          unsubscribeReason: parsed.reason,
+          updatedAt: now
+        }
+      }
+    );
+  }
+  async suppress(email, opts) {
+    const parsed = suppressInputSchema.parse({ email, ...opts });
+    await this.collections.suppressions.updateOne(
+      { email: parsed.email, scope: parsed.scope },
+      {
+        $setOnInsert: {
+          email: parsed.email,
+          emailHash: sha256Hex(parsed.email),
+          scope: parsed.scope,
+          reason: parsed.reason,
+          source: parsed.source,
+          notes: parsed.notes ?? null,
+          addedAt: /* @__PURE__ */ new Date(),
+          expiresAt: parsed.expiresAt ?? null
+        }
+      },
+      { upsert: true }
+    );
+  }
+  async tag(externalId, tag) {
+    const parsed = tagInputSchema.parse({ externalId, tag });
+    if (this.adapter.addTags) {
+      await this.adapter.addTags(parsed.externalId, [parsed.tag]);
+    } else {
+      await this.collections.contactTags.updateOne(
+        { externalId: parsed.externalId, tag: parsed.tag },
+        {
+          $setOnInsert: {
+            externalId: parsed.externalId,
+            tag: parsed.tag,
+            appliedBy: "admin",
+            appliedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { upsert: true }
+      );
+    }
+  }
+  async untag(externalId, tag) {
+    const parsed = tagInputSchema.parse({ externalId, tag });
+    if (this.adapter.removeTags) {
+      await this.adapter.removeTags(parsed.externalId, [parsed.tag]);
+    } else {
+      await this.collections.contactTags.deleteOne({ externalId: parsed.externalId, tag: parsed.tag });
+    }
+  }
+  /**
+   * GDPR right-to-erasure. Hard-deletes the contact's PII and leaves a hashed
+   * suppression row to block re-import. INVARIANT 9.
+   */
+  async forget(externalId) {
+    const sub = await this.collections.subscriptions.findOne({ externalId });
+    const email = sub?.emailAtSubscribe?.toLowerCase();
+    const collected = await Promise.all([
+      this.collections.sends.find({ externalId }).map((s) => s.emailAtSend).toArray()
+    ]);
+    const emails = /* @__PURE__ */ new Set();
+    if (email) emails.add(email);
+    for (const e of collected[0]) if (e) emails.add(e.toLowerCase());
+    await Promise.all([
+      this.collections.events.deleteMany({ externalId }),
+      this.collections.flowRuns.deleteMany({ externalId }),
+      this.collections.sends.deleteMany({ externalId }),
+      this.collections.subscriptions.deleteMany({ externalId }),
+      this.collections.contactTags.deleteMany({ externalId })
+    ]);
+    if (email) {
+      await this.collections.leads.deleteMany({ email });
+    }
+    for (const e of emails) {
+      await this.collections.suppressions.updateOne(
+        { emailHash: sha256Hex(e), scope: "all" },
+        {
+          $setOnInsert: {
+            email: null,
+            emailHash: sha256Hex(e),
+            scope: "all",
+            reason: "gdpr_forget",
+            source: "gdpr_request",
+            notes: null,
+            addedAt: /* @__PURE__ */ new Date(),
+            expiresAt: null
+          }
+        },
+        { upsert: true }
+      );
+    }
+    await this.audit({
+      actor: "system:gdpr",
+      action: "gdpr.forget",
+      resource: { collection: "mailer_subscriptions", id: sub?._id },
+      diffSummary: `forget externalId=${externalId}`
+    });
+  }
+  /** GDPR data export. JSON-serializable. */
+  async exportContactData(externalId) {
+    const subscription = await this.collections.subscriptions.findOne({ externalId });
+    const [events, flowRuns, sends, suppressions, tags] = await Promise.all([
+      this.collections.events.find({ externalId }).toArray(),
+      this.collections.flowRuns.find({ externalId }).toArray(),
+      this.collections.sends.find({ externalId }).toArray(),
+      subscription?.emailAtSubscribe ? this.collections.suppressions.find({ email: subscription.emailAtSubscribe }).toArray() : Promise.resolve([]),
+      this.collections.contactTags.find({ externalId }).toArray()
+    ]);
+    return { subscription, events, flowRuns, sends, suppressions, tags };
+  }
+  // -------------------------------------------------------------------------
+  // One-off transactional send (password reset etc.)
+  // -------------------------------------------------------------------------
+  async sendOneOff(input) {
+    const parsed = sendOneOffInputSchema.parse(input);
+    const template = await this.collections.templates.findOne({ slug: parsed.templateSlug });
+    if (!template) throw new Error(`template not found: ${parsed.templateSlug}`);
+    const contact = await this.adapter.getById(parsed.externalId);
+    if (!contact) throw new Error(`contact not found: ${parsed.externalId}`);
+    const dedupeKey = `oneoff:${parsed.dedupeKey}`;
+    const existing = await this.collections.sends.findOne({ dedupeKey });
+    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 mongodb.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(),
+      sentAt: null,
+      deliveredAt: null
+    });
+    await this.queues.send.add(
+      "send",
+      { sendId: String(sendId) },
+      { attempts: this.config.sendRetryAttempts, backoff: { type: "exponential", delay: 6e4 } }
+    );
+    return { sendId: String(sendId) };
+  }
+  // -------------------------------------------------------------------------
+  // Audit log helper
+  // -------------------------------------------------------------------------
+  async audit(entry) {
+    await this.collections.auditLog.insertOne({
+      actor: entry.actor,
+      action: entry.action,
+      resource: entry.resource,
+      before: entry.before ?? null,
+      after: entry.after ?? null,
+      diffSummary: entry.diffSummary ?? null,
+      ip: entry.ip ?? null,
+      userAgent: entry.userAgent ?? null,
+      requestId: entry.requestId ?? null,
+      occurredAt: /* @__PURE__ */ new Date()
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Workers
+  // -------------------------------------------------------------------------
+  async startWorkers() {
+    if (this.workers) return;
+    if (!this.redis) throw new Error("startWorkers requires a Redis connection (redis was null in config)");
+    const provider = this.providers[this.config.defaultProvider];
+    const sendRate = provider?.sendRatePerSecond ?? this.config.sendRatePerSecond;
+    this.workers = createWorkers({
+      redis: this.redis,
+      concurrency: { send: this.config.sendConcurrency },
+      sendRateLimit: { max: sendRate, durationMs: 1e3 },
+      handlers: {
+        tick: async () => {
+          await runTick(this.runnerContext);
+        },
+        advance: async (data) => {
+          if (!mongodb.ObjectId.isValid(data.flowRunId)) return;
+          await processOneRunStep(new mongodb.ObjectId(data.flowRunId), this.runnerContext);
+        },
+        send: async (data) => {
+          if (!mongodb.ObjectId.isValid(data.sendId)) return;
+          await dispatchSend(new mongodb.ObjectId(data.sendId), this.runnerContext);
+        },
+        webhook: async () => {
+          await this.processWebhookBacklog();
+        }
+      }
+    });
+  }
+  /** 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 });
+      }
+    }
+  }
+  async stop() {
+    if (this.workers) {
+      await closeWorkers(this.workers);
+      this.workers = null;
+    }
+    if (this.bullQueues) {
+      await closeBullQueues(this.bullQueues);
+      this.bullQueues = null;
+    } else {
+      await closeQueues(this.queues);
+    }
+    if (this.redis) {
+      await this.redis.quit().catch(() => {
+      });
+    }
+  }
+  /** Used internally by the admin router and tests; not part of the public API. */
+  getRunnerContext() {
+    return this.runnerContext;
+  }
+};
+
+// src/server/index.ts
+init_mongo();
+
+// src/server/providers/null.ts
+var counter = 0;
+var NullProvider = class {
+  name = "null";
+  sendRatePerSecond = 1e3;
+  sent = [];
+  async send(args) {
+    this.sent.push(args);
+    return {
+      providerId: `null-${Date.now()}-${++counter}`,
+      status: "accepted"
+    };
+  }
+  async verifyWebhook() {
+    return true;
+  }
+  parseWebhookEvents() {
+    return [];
+  }
+  reset() {
+    this.sent.length = 0;
+  }
+};
+
+// src/server/index.ts
+init_sendgrid();
+var __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+var __dirname$1 = path__default.default.dirname(__filename$1);
+function defaultSpaDir() {
+  return path__default.default.resolve(__dirname$1, "admin/spa");
+}
+function createAdminRouter(mailer, opts = {}) {
+  const router = express.Router();
+  const spaDir = opts.spaDir ?? defaultSpaDir();
+  const getActor = opts.getActor ?? ((req) => `human:${req.user?.email ?? "anonymous"}`);
+  router.use(
+    "/_assets",
+    express__default.default.static(spaDir, {
+      maxAge: "1y",
+      immutable: true,
+      index: false
+    })
+  );
+  router.use("/api", express__default.default.json({ limit: "1mb" }));
+  router.use("/api", (req, _res, next) => {
+    req.actor = getActor(req);
+    next();
+  });
+  router.use("/api", apiRouter(mailer));
+  router.get(/.*/, (_req, res) => {
+    res.sendFile(path__default.default.join(spaDir, "index.html"));
+  });
+  return router;
+}
+function apiRouter(mailer) {
+  const r = express.Router();
+  const c = mailer.collections;
+  r.get("/me", (req, res) => {
+    res.json({
+      actor: req.actor,
+      permissions: { canPublish: true, canSendBroadcasts: true, canManageSuppressions: true }
+    });
+  });
+  r.get(
+    "/dashboard",
+    asyncHandler(async (_req, res) => {
+      const since24h = new Date(Date.now() - 24 * 60 * 60 * 1e3);
+      const [sentTotal, deliveredCount, bouncedCount, openedCount, clickedCount] = await Promise.all([
+        c.sends.countDocuments({ queuedAt: { $gt: since24h } }),
+        c.sends.countDocuments({ queuedAt: { $gt: since24h }, status: "delivered" }),
+        c.sends.countDocuments({ queuedAt: { $gt: since24h }, status: "bounced" }),
+        c.sends.countDocuments({ queuedAt: { $gt: since24h }, openedAt: { $ne: null } }),
+        c.sends.countDocuments({ queuedAt: { $gt: since24h }, firstClickAt: { $ne: null } })
+      ]);
+      const health = await c.health.findOne({ _id: "singleton" });
+      const recentFlows = await c.flows.find({ enabled: true }).limit(5).toArray();
+      const recentSends = await c.sends.find().sort({ queuedAt: -1 }).limit(6).toArray();
+      const recentAudit = await c.auditLog.find().sort({ occurredAt: -1 }).limit(5).toArray();
+      res.json({
+        kpis: {
+          sends: { value: sentTotal, delta: null },
+          deliveredRate: {
+            value: sentTotal === 0 ? 1 : deliveredCount / sentTotal,
+            delta: null,
+            bounced: bouncedCount
+          },
+          openRate: { value: sentTotal === 0 ? 0 : openedCount / sentTotal, delta: null, exclBots: false },
+          clickRate: { value: sentTotal === 0 ? 0 : clickedCount / sentTotal, delta: null }
+        },
+        health: health ? { status: health.status, rates: health.rates } : {
+          status: "healthy",
+          rates: { hardBounceRate: 0, complaintRate: 0, combinedBounceRate: 0, failureRate: 0 }
+        },
+        queue: { inFlight: 0, delayed: 0, providerOk: true, providerName: mailer.config.defaultProvider },
+        recentFlows,
+        recentSends,
+        recentAudit
+      });
+    })
+  );
+  r.get(
+    "/flows",
+    asyncHandler(async (_req, res) => {
+      const flows = await c.flows.find().sort({ updatedAt: -1 }).toArray();
+      res.json(flows);
+    })
+  );
+  r.get(
+    "/flows/:slug",
+    asyncHandler(async (req, res) => {
+      const flow = await c.flows.findOne({ slug: req.params.slug });
+      if (!flow) return res.status(404).json({ error: "not_found" });
+      return res.json(flow);
+    })
+  );
+  r.post(
+    "/flows/:slug/pause",
+    asyncHandler(async (req, res) => {
+      const before = await c.flows.findOne({ slug: req.params.slug });
+      if (!before) return res.status(404).json({ error: "not_found" });
+      await c.flows.updateOne({ _id: before._id }, { $set: { enabled: false, updatedAt: /* @__PURE__ */ new Date() } });
+      await mailer.audit({
+        actor: req.actor,
+        action: "flow.pause",
+        resource: { collection: "mailer_flows", id: before._id, slug: before.slug }
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/flows/:slug/resume",
+    asyncHandler(async (req, res) => {
+      const before = await c.flows.findOne({ slug: req.params.slug });
+      if (!before) return res.status(404).json({ error: "not_found" });
+      await c.flows.updateOne({ _id: before._id }, { $set: { enabled: true, updatedAt: /* @__PURE__ */ new Date() } });
+      await mailer.audit({
+        actor: req.actor,
+        action: "flow.resume",
+        resource: { collection: "mailer_flows", id: before._id, slug: before.slug }
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.get(
+    "/templates",
+    asyncHandler(async (_req, res) => {
+      const templates = await c.templates.find().sort({ updatedAt: -1 }).toArray();
+      res.json(templates);
+    })
+  );
+  r.get(
+    "/templates/:slug",
+    asyncHandler(async (req, res) => {
+      const template = await c.templates.findOne({ slug: req.params.slug });
+      if (!template) return res.status(404).json({ error: "not_found" });
+      return res.json(template);
+    })
+  );
+  r.get(
+    "/broadcasts",
+    asyncHandler(async (_req, res) => {
+      const broadcasts = await c.broadcasts.find().sort({ createdAt: -1 }).toArray();
+      res.json(broadcasts);
+    })
+  );
+  r.get(
+    "/broadcasts/:slug",
+    asyncHandler(async (req, res) => {
+      const broadcast = await c.broadcasts.findOne({ slug: req.params.slug });
+      if (!broadcast) return res.status(404).json({ error: "not_found" });
+      return res.json(broadcast);
+    })
+  );
+  r.get(
+    "/contacts",
+    asyncHandler(async (req, res) => {
+      const cursor = typeof req.query.cursor === "string" ? req.query.cursor : void 0;
+      const limit = Math.min(Number(req.query.limit ?? 50), 200);
+      const { contacts, nextCursor } = await mailer.adapter.query({}, { limit, cursor });
+      res.json({ contacts, nextCursor });
+    })
+  );
+  r.get(
+    "/contacts/:externalId",
+    asyncHandler(async (req, res) => {
+      const externalId = String(req.params.externalId);
+      const [contact, subscription, recentEvents, recentSends, activeRuns] = await Promise.all([
+        mailer.adapter.getById(externalId),
+        c.subscriptions.findOne({ externalId }),
+        c.events.find({ externalId }).sort({ occurredAt: -1 }).limit(50).toArray(),
+        c.sends.find({ externalId }).sort({ queuedAt: -1 }).limit(50).toArray(),
+        c.flowRuns.find({ externalId, status: "active" }).toArray()
+      ]);
+      if (!contact) return res.status(404).json({ error: "not_found" });
+      return res.json({ contact, subscription, recentEvents, recentSends, activeRuns });
+    })
+  );
+  r.get(
+    "/sends",
+    asyncHandler(async (req, res) => {
+      const limit = Math.min(Number(req.query.limit ?? 100), 500);
+      const status = typeof req.query.status === "string" ? req.query.status : void 0;
+      const filter = {};
+      if (status) filter.status = status;
+      const sends = await c.sends.find(filter).sort({ queuedAt: -1 }).limit(limit).toArray();
+      res.json(sends);
+    })
+  );
+  r.get(
+    "/sends/:id",
+    asyncHandler(async (req, res) => {
+      const id = String(req.params.id);
+      if (!mongodb.ObjectId.isValid(id)) return res.status(400).json({ error: "bad_id" });
+      const send = await c.sends.findOne({ _id: new mongodb.ObjectId(id) });
+      if (!send) return res.status(404).json({ error: "not_found" });
+      const events = send.providerMessageId ? await c.webhookEvents.find({ providerMessageId: send.providerMessageId }).toArray() : [];
+      return res.json({ send, webhookEvents: events });
+    })
+  );
+  r.get(
+    "/suppressions",
+    asyncHandler(async (_req, res) => {
+      const rows = await c.suppressions.find().sort({ addedAt: -1 }).limit(500).toArray();
+      res.json(rows);
+    })
+  );
+  r.post(
+    "/suppressions",
+    asyncHandler(async (req, res) => {
+      const { email, scope, reason, source, notes } = req.body ?? {};
+      await mailer.suppress(email, { scope, reason, source, notes });
+      await mailer.audit({
+        actor: req.actor,
+        action: "suppression.add",
+        resource: { collection: "mailer_suppressions" },
+        diffSummary: `${email} \u2192 ${scope}/${reason}`
+      });
+      res.json({ ok: true });
+    })
+  );
+  r.get(
+    "/audit",
+    asyncHandler(async (_req, res) => {
+      const rows = await c.auditLog.find().sort({ occurredAt: -1 }).limit(200).toArray();
+      res.json(rows);
+    })
+  );
+  r.get(
+    "/health",
+    asyncHandler(async (_req, res) => {
+      const h = await c.health.findOne({ _id: "singleton" });
+      res.json(
+        h ?? {
+          _id: "singleton",
+          status: "healthy",
+          windowStartedAt: new Date(Date.now() - 60 * 60 * 1e3),
+          windowDurationMs: 60 * 60 * 1e3,
+          counters: { sent: 0, delivered: 0, bounced: 0, hardBounced: 0, softBounced: 0, complained: 0, failedToSend: 0 },
+          rates: { bounceRate: 0, hardBounceRate: 0, complaintRate: 0, failureRate: 0 }
+        }
+      );
+    })
+  );
+  r.post(
+    "/health/resume",
+    asyncHandler(async (req, res) => {
+      await c.health.updateOne(
+        { _id: "singleton" },
+        { $set: { status: "healthy", manuallyResumedAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      await mailer.audit({
+        actor: req.actor,
+        action: "health.resume",
+        resource: { collection: "mailer_health" }
+      });
+      res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/flows",
+    asyncHandler(async (req, res) => {
+      const { slug, name, description, trigger, goal, audience } = req.body ?? {};
+      if (!slug || !name || !trigger?.eventName) {
+        return res.status(400).json({ error: "validation_failed", message: "slug, name, and trigger.eventName required" });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const doc = {
+        slug,
+        name,
+        description: description ?? "",
+        trigger: { type: "event", eventName: trigger.eventName, once: trigger.once !== false },
+        enabled: false,
+        steps: [],
+        version: 0,
+        draft: {
+          steps: [],
+          notes: "Initial draft",
+          lastModifiedBy: req.actor ?? "unknown",
+          lastModifiedAt: now
+        },
+        goal: goal ?? "activation",
+        audience: audience ?? "",
+        expectedVolumePerWeek: null,
+        stats: { activeRuns: 0, completedRuns: 0, sendsTotal: 0, sendsLast7Days: 0 },
+        lastTriggerScanAt: null,
+        publishedAt: null,
+        publishedBy: null,
+        createdAt: now,
+        updatedAt: now
+      };
+      try {
+        await c.flows.insertOne(doc);
+      } catch (err) {
+        if (err?.code === 11e3) return res.status(409).json({ error: "slug_taken" });
+        throw err;
+      }
+      await mailer.audit({
+        actor: req.actor,
+        action: "flow.create",
+        resource: { collection: "mailer_flows", slug }
+      });
+      return res.json({ ok: true, slug });
+    })
+  );
+  r.patch(
+    "/flows/:slug/draft",
+    asyncHandler(async (req, res) => {
+      const flow = await c.flows.findOne({ slug: req.params.slug });
+      if (!flow) return res.status(404).json({ error: "not_found" });
+      const { steps, notes, trigger, name, description, goal, audience } = req.body ?? {};
+      const set = {
+        "draft.lastModifiedBy": req.actor,
+        "draft.lastModifiedAt": /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (Array.isArray(steps)) set["draft.steps"] = steps;
+      if (typeof notes === "string") set["draft.notes"] = notes;
+      if (trigger?.eventName) set.trigger = { type: "event", eventName: trigger.eventName, once: trigger.once !== false };
+      if (typeof name === "string") set.name = name;
+      if (typeof description === "string") set.description = description;
+      if (typeof goal === "string") set.goal = goal;
+      if (typeof audience === "string") set.audience = audience;
+      await c.flows.updateOne({ _id: flow._id }, { $set: set });
+      await mailer.audit({
+        actor: req.actor,
+        action: "flow.draft.update",
+        resource: { collection: "mailer_flows", id: flow._id, slug: flow.slug },
+        diffSummary: `Updated draft (${steps ? `${steps.length} steps` : "metadata only"})`
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/flows/:slug/publish",
+    asyncHandler(async (req, res) => {
+      const flow = await c.flows.findOne({ slug: req.params.slug });
+      if (!flow) return res.status(404).json({ error: "not_found" });
+      const draftSteps = flow.draft?.steps ?? flow.steps;
+      if (!Array.isArray(draftSteps) || draftSteps.length === 0) {
+        return res.status(400).json({ error: "empty_flow", message: "flow has no steps to publish" });
+      }
+      const nextVersion = (flow.version ?? 0) + 1;
+      const now = /* @__PURE__ */ new Date();
+      await c.flowVersions.insertOne({
+        flowId: flow._id,
+        version: nextVersion,
+        steps: draftSteps,
+        trigger: flow.trigger,
+        publishedAt: now,
+        publishedBy: req.actor
+      });
+      await c.flows.updateOne(
+        { _id: flow._id },
+        {
+          $set: {
+            steps: draftSteps,
+            version: nextVersion,
+            enabled: true,
+            draft: null,
+            publishedAt: now,
+            publishedBy: req.actor,
+            updatedAt: now
+          }
+        }
+      );
+      await mailer.audit({
+        actor: req.actor,
+        action: "flow.publish",
+        resource: { collection: "mailer_flows", id: flow._id, slug: flow.slug },
+        diffSummary: `Published v${nextVersion}`
+      });
+      return res.json({ ok: true, version: nextVersion });
+    })
+  );
+  r.delete(
+    "/flows/:slug",
+    asyncHandler(async (req, res) => {
+      const flow = await c.flows.findOne({ slug: req.params.slug });
+      if (!flow) return res.status(404).json({ error: "not_found" });
+      const everRan = await c.flowRuns.countDocuments({ flowId: flow._id }, { limit: 1 });
+      if (everRan > 0) return res.status(409).json({ error: "has_runs", message: "flow has runs \u2014 pause it instead" });
+      await c.flows.deleteOne({ _id: flow._id });
+      await mailer.audit({
+        actor: req.actor,
+        action: "flow.delete",
+        resource: { collection: "mailer_flows", id: flow._id, slug: flow.slug }
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/templates",
+    asyncHandler(async (req, res) => {
+      const { slug, name, kind, subject, preheader, fromName, fromEmail } = req.body ?? {};
+      if (!slug || !name || !kind) {
+        return res.status(400).json({ error: "validation_failed", message: "slug, name, kind required" });
+      }
+      if (kind !== "marketing" && kind !== "transactional") {
+        return res.status(400).json({ error: "validation_failed", message: "kind must be marketing or transactional" });
+      }
+      const now = /* @__PURE__ */ new Date();
+      try {
+        await c.templates.insertOne({
+          slug,
+          name,
+          description: "",
+          kind,
+          fromName: fromName ?? mailer.config.fromDefaults?.name ?? "Mailery",
+          fromEmail: fromEmail ?? mailer.config.fromDefaults?.email ?? "noreply@example.com",
+          replyTo: null,
+          providerOverride: null,
+          subject: subject ?? `Untitled \u2014 ${name}`,
+          preheader: preheader ?? "",
+          body: { mjml: "", editorJson: null, html: "", plainText: "", compiledAt: null },
+          variablesSchema: {},
+          draft: {
+            subject: subject ?? `Untitled \u2014 ${name}`,
+            preheader: preheader ?? "",
+            mjml: "",
+            editorJson: null,
+            notes: "Initial draft",
+            lastModifiedBy: req.actor,
+            lastModifiedAt: now
+          },
+          tags: [],
+          trackOpens: kind === "marketing",
+          trackClicks: kind === "marketing",
+          stats: { sent: 0, delivered: 0, opened: 0, clicked: 0, bounced: 0, complained: 0, unsubscribed: 0, lastSentAt: null },
+          publishedAt: null,
+          publishedBy: null,
+          createdAt: now,
+          updatedAt: now
+        });
+      } catch (err) {
+        if (err?.code === 11e3) return res.status(409).json({ error: "slug_taken" });
+        throw err;
+      }
+      await mailer.audit({
+        actor: req.actor,
+        action: "template.create",
+        resource: { collection: "mailer_templates", slug }
+      });
+      return res.json({ ok: true, slug });
+    })
+  );
+  r.patch(
+    "/templates/:slug/draft",
+    asyncHandler(async (req, res) => {
+      const tpl = await c.templates.findOne({ slug: req.params.slug });
+      if (!tpl) return res.status(404).json({ error: "not_found" });
+      const { subject, preheader, mjml, editorJson, notes, name, fromName, fromEmail, replyTo, kind, trackOpens, trackClicks } = req.body ?? {};
+      const set = {
+        "draft.lastModifiedBy": req.actor,
+        "draft.lastModifiedAt": /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (typeof subject === "string") set["draft.subject"] = subject;
+      if (typeof preheader === "string") set["draft.preheader"] = preheader;
+      if (typeof mjml === "string") set["draft.mjml"] = mjml;
+      if (editorJson !== void 0) set["draft.editorJson"] = editorJson;
+      if (typeof notes === "string") set["draft.notes"] = notes;
+      if (typeof name === "string") set.name = name;
+      if (typeof fromName === "string") set.fromName = fromName;
+      if (typeof fromEmail === "string") set.fromEmail = fromEmail;
+      if (typeof replyTo === "string" || replyTo === null) set.replyTo = replyTo;
+      if (kind === "marketing" || kind === "transactional") set.kind = kind;
+      if (typeof trackOpens === "boolean") set.trackOpens = trackOpens;
+      if (typeof trackClicks === "boolean") set.trackClicks = trackClicks;
+      await c.templates.updateOne({ _id: tpl._id }, { $set: set });
+      await mailer.audit({
+        actor: req.actor,
+        action: "template.draft.update",
+        resource: { collection: "mailer_templates", id: tpl._id, slug: tpl.slug }
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/templates/:slug/publish",
+    asyncHandler(async (req, res) => {
+      const tpl = await c.templates.findOne({ slug: req.params.slug });
+      if (!tpl) return res.status(404).json({ error: "not_found" });
+      const draft = tpl.draft;
+      if (!draft) return res.status(400).json({ error: "no_draft" });
+      let compiled;
+      if (draft.editorJson) {
+        compiled = await compileMailyTemplate(draft.editorJson);
+      } else if (draft.mjml) {
+        compiled = await compileTemplate(draft.mjml);
+      } else {
+        return res.status(400).json({ error: "empty_draft", message: "draft has no MJML or editorJson content" });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const nextVersion = await c.templateVersions.countDocuments({ templateId: tpl._id }) + 1;
+      await c.templateVersions.insertOne({
+        templateId: tpl._id,
+        version: nextVersion,
+        mjml: draft.mjml,
+        html: compiled.html,
+        plainText: compiled.plainText,
+        subject: draft.subject,
+        preheader: draft.preheader,
+        publishedAt: now,
+        publishedBy: req.actor
+      });
+      await c.templates.updateOne(
+        { _id: tpl._id },
+        {
+          $set: {
+            subject: draft.subject,
+            preheader: draft.preheader,
+            body: {
+              mjml: draft.mjml,
+              editorJson: draft.editorJson,
+              html: compiled.html,
+              plainText: compiled.plainText,
+              compiledAt: now
+            },
+            draft: null,
+            publishedAt: now,
+            publishedBy: req.actor,
+            updatedAt: now
+          }
+        }
+      );
+      await mailer.audit({
+        actor: req.actor,
+        action: "template.publish",
+        resource: { collection: "mailer_templates", id: tpl._id, slug: tpl.slug },
+        diffSummary: `Published v${nextVersion}`
+      });
+      return res.json({ ok: true, version: nextVersion, warnings: compiled.errors });
+    })
+  );
+  r.post(
+    "/templates/:slug/preview",
+    asyncHandler(async (req, res) => {
+      const tpl = await c.templates.findOne({ slug: req.params.slug });
+      if (!tpl) return res.status(404).json({ error: "not_found" });
+      const useDraft = req.body?.useDraft !== false;
+      let html = "";
+      let plainText = "";
+      if (useDraft && tpl.draft) {
+        const compiled = tpl.draft.editorJson ? await compileMailyTemplate(tpl.draft.editorJson) : await compileTemplate(tpl.draft.mjml || "<mjml><mj-body></mj-body></mjml>");
+        html = compiled.html;
+        plainText = compiled.plainText;
+      } else {
+        html = tpl.body.html;
+        plainText = tpl.body.plainText;
+      }
+      const sampleContact = req.body?.sampleContact ?? {
+        externalId: "preview-contact",
+        email: "preview@example.com",
+        tags: [],
+        fields: { firstName: "Alex" }
+      };
+      const renderCtx = {
+        contact: sampleContact,
+        vars: req.body?.vars ?? {},
+        unsubscribeUrl: `${mailer.config.publicUrl}/m/unsub/preview`,
+        senderAddress: mailer.config.senderAddress
+      };
+      const previewTpl = { ...tpl, body: { ...tpl.body, html, plainText } };
+      const rendered = await renderTemplate(previewTpl, renderCtx, { helpers: mailer.config.handlebarsHelpers });
+      return res.json({ subject: rendered.subject, preheader: rendered.preheader, html: rendered.html, plainText: rendered.plainText });
+    })
+  );
+  r.post(
+    "/templates/:slug/send-test",
+    asyncHandler(async (req, res) => {
+      const { to, sampleData } = req.body ?? {};
+      if (!to) return res.status(400).json({ error: "to_required" });
+      const tpl = await c.templates.findOne({ slug: req.params.slug });
+      if (!tpl) return res.status(404).json({ error: "not_found" });
+      const contact = sampleData?.contact ?? {
+        externalId: "test-recipient",
+        email: to,
+        tags: [],
+        fields: { firstName: "Test" }
+      };
+      contact.email = to;
+      const renderCtx = {
+        contact,
+        vars: sampleData?.vars ?? {},
+        unsubscribeUrl: `${mailer.config.publicUrl}/m/unsub/test`,
+        senderAddress: mailer.config.senderAddress
+      };
+      const rendered = await renderTemplate(tpl, renderCtx, { helpers: mailer.config.handlebarsHelpers });
+      const tracking = applyTracking(rendered.html, {
+        sendId: `test-${Date.now()}`,
+        publicUrl: mailer.config.publicUrl,
+        trackOpens: false,
+        trackClicks: false
+      });
+      const provider = mailer.providers[tpl.providerOverride ?? mailer.config.defaultProvider];
+      const result = await provider.send({
+        to,
+        fromName: rendered.fromName,
+        fromEmail: rendered.fromEmail,
+        subject: `[TEST] ${rendered.subject}`,
+        html: tracking.html,
+        text: rendered.plainText
+      });
+      await mailer.audit({
+        actor: req.actor,
+        action: "template.send-test",
+        resource: { collection: "mailer_templates", slug: tpl.slug },
+        diffSummary: `to=${to}`
+      });
+      return res.json({ ok: true, providerId: result.providerId });
+    })
+  );
+  r.post(
+    "/broadcasts",
+    asyncHandler(async (req, res) => {
+      const { slug, name, templateSlug, segmentDefinition } = req.body ?? {};
+      if (!slug || !name || !templateSlug) {
+        return res.status(400).json({ error: "validation_failed", message: "slug, name, templateSlug required" });
+      }
+      const now = /* @__PURE__ */ new Date();
+      try {
+        await c.broadcasts.insertOne({
+          slug,
+          name,
+          templateSlug,
+          segmentDefinition: segmentDefinition ?? { filters: [{ kind: "subscriptionStatus", equals: "subscribed" }] },
+          status: "draft",
+          scheduledAt: null,
+          startedAt: null,
+          completedAt: null,
+          confirmationRequired: true,
+          confirmedCount: null,
+          confirmedAt: null,
+          confirmedBy: null,
+          recipientCount: null,
+          stats: { sent: 0, delivered: 0, opened: 0, clicked: 0, bounced: 0, complained: 0, unsubscribed: 0 },
+          createdAt: now,
+          createdBy: req.actor,
+          updatedAt: now
+        });
+      } catch (err) {
+        if (err?.code === 11e3) return res.status(409).json({ error: "slug_taken" });
+        throw err;
+      }
+      await mailer.audit({
+        actor: req.actor,
+        action: "broadcast.create",
+        resource: { collection: "mailer_broadcasts", slug }
+      });
+      return res.json({ ok: true, slug });
+    })
+  );
+  r.patch(
+    "/broadcasts/:slug",
+    asyncHandler(async (req, res) => {
+      const b = await c.broadcasts.findOne({ slug: req.params.slug });
+      if (!b) return res.status(404).json({ error: "not_found" });
+      if (b.status !== "draft") return res.status(409).json({ error: "not_draft" });
+      const { name, templateSlug, segmentDefinition } = req.body ?? {};
+      const set = { updatedAt: /* @__PURE__ */ new Date() };
+      if (typeof name === "string") set.name = name;
+      if (typeof templateSlug === "string") set.templateSlug = templateSlug;
+      if (segmentDefinition) set.segmentDefinition = segmentDefinition;
+      await c.broadcasts.updateOne({ _id: b._id }, { $set: set });
+      return res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/broadcasts/:slug/segment/count",
+    asyncHandler(async (req, res) => {
+      const segmentDefinition = req.body?.segmentDefinition;
+      if (!segmentDefinition?.filters) return res.status(400).json({ error: "segment_required" });
+      const t0 = Date.now();
+      const hostFilter = {};
+      for (const f of segmentDefinition.filters) {
+        if (f.kind === "hasTag") hostFilter.hasTag = f.tag;
+        if (f.kind === "fieldEquals") hostFilter.fieldEquals = { field: f.field, value: f.value };
+      }
+      const stageA = await mailer.adapter.count(hostFilter);
+      return res.json({ stageA, stageB: stageA, afterSuppression: stageA, computedMs: Date.now() - t0 });
+    })
+  );
+  r.post(
+    "/broadcasts/:slug/schedule",
+    asyncHandler(async (req, res) => {
+      const b = await c.broadcasts.findOne({ slug: req.params.slug });
+      if (!b) return res.status(404).json({ error: "not_found" });
+      if (b.status !== "draft") return res.status(409).json({ error: "not_draft" });
+      const { scheduledAt, confirmedCount, respectRecipientTimezone } = req.body ?? {};
+      if (!scheduledAt) return res.status(400).json({ error: "scheduledAt_required" });
+      const scheduled = new Date(scheduledAt);
+      if (Number.isNaN(scheduled.getTime())) return res.status(400).json({ error: "bad_scheduledAt" });
+      const threshold = mailer.config.broadcastConfirmationThreshold;
+      if (typeof confirmedCount !== "number") {
+        return res.status(400).json({ error: "confirmedCount_required" });
+      }
+      const set = {
+        status: "scheduled",
+        scheduledAt: scheduled,
+        confirmedCount,
+        confirmedAt: /* @__PURE__ */ new Date(),
+        confirmedBy: req.actor,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (respectRecipientTimezone) set.respectRecipientTimezone = true;
+      await c.broadcasts.updateOne({ _id: b._id }, { $set: set });
+      await mailer.audit({
+        actor: req.actor,
+        action: "broadcast.schedule",
+        resource: { collection: "mailer_broadcasts", id: b._id, slug: b.slug },
+        diffSummary: `scheduled at ${scheduled.toISOString()} \xB7 confirmedCount=${confirmedCount} \xB7 threshold=${threshold}`
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.post(
+    "/broadcasts/:slug/cancel",
+    asyncHandler(async (req, res) => {
+      const b = await c.broadcasts.findOne({ slug: req.params.slug });
+      if (!b) return res.status(404).json({ error: "not_found" });
+      await c.broadcasts.updateOne({ _id: b._id }, { $set: { status: "cancelled", updatedAt: /* @__PURE__ */ new Date() } });
+      await mailer.audit({
+        actor: req.actor,
+        action: "broadcast.cancel",
+        resource: { collection: "mailer_broadcasts", id: b._id, slug: b.slug }
+      });
+      return res.json({ ok: true });
+    })
+  );
+  r.use((_req, res) => res.status(404).json({ error: "not_found" }));
+  return r;
+}
+function asyncHandler(fn) {
+  return (req, res, next) => {
+    fn(req, res, next).catch(next);
+  };
+}
+var PIXEL = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=",
+  "base64"
+);
+function createPublicRouter(mailer, opts = {}) {
+  const router = express.Router();
+  const pendingUnsubsPath = opts.pendingUnsubsPath ?? "/tmp/mailery-pending-unsubs.jsonl";
+  router.use(
+    "/webhooks",
+    express__default.default.json({
+      limit: "5mb",
+      verify: (req, _res, buf) => {
+        req.rawBody = buf;
+      }
+    })
+  );
+  router.use("/unsub", express__default.default.urlencoded({ extended: false }));
+  router.get("/open/:sendId.png", async (req, res) => {
+    res.setHeader("Content-Type", "image/png");
+    res.setHeader("Content-Length", String(PIXEL.length));
+    res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
+    res.status(200).end(PIXEL);
+    const id = req.params.sendId;
+    if (!mongodb.ObjectId.isValid(id)) return;
+    const sendId = new mongodb.ObjectId(id);
+    try {
+      const send = await mailer.collections.sends.findOne({ _id: sendId }, { projection: { openedAt: 1 } });
+      if (!send) return;
+      await mailer.collections.sends.updateOne(
+        { _id: sendId },
+        {
+          $set: {
+            openedAt: send.openedAt ?? /* @__PURE__ */ new Date(),
+            status: "delivered"
+          },
+          $inc: { openCount: 1 }
+        }
+      );
+    } catch (err) {
+      console.error("mailery: open pixel update failed", err);
+    }
+  });
+  router.get("/click/:sendId/:linkId", async (req, res) => {
+    const { sendId: sendIdStr, linkId } = req.params;
+    if (!mongodb.ObjectId.isValid(sendIdStr)) return res.status(400).end();
+    const sendId = new mongodb.ObjectId(sendIdStr);
+    const send = await mailer.collections.sends.findOne(
+      { _id: sendId },
+      { projection: { links: 1, firstClickAt: 1 } }
+    );
+    if (!send) return res.status(404).end();
+    const link = (send.links ?? []).find((l) => l.linkId === linkId);
+    if (!link) return res.status(404).end();
+    res.redirect(302, link.url);
+    try {
+      await mailer.collections.sends.updateOne(
+        { _id: sendId },
+        {
+          $set: { firstClickAt: send.firstClickAt ?? /* @__PURE__ */ new Date() },
+          $inc: { clickCount: 1 },
+          $push: {
+            clickedLinks: {
+              url: link.url,
+              linkId,
+              clickedAt: /* @__PURE__ */ new Date()
+            }
+          }
+        }
+      );
+    } catch (err) {
+      console.error("mailery: click recording failed", err);
+    }
+  });
+  router.get("/unsub/:token", (req, res) => {
+    const decoded = verifyUnsubscribeToken(req.params.token, mailer.config.unsubscribeSecret);
+    if (!decoded) return sendUnsubError(res, "Invalid or expired link.");
+    res.status(200).type("html").send(`<!doctype html>
+<html><head>
+  <meta charset="utf-8" />
+  <title>Unsubscribe</title>
+  <style>body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;max-width:480px;margin:48px auto;padding:0 16px;color:#1c1917;line-height:1.5}h1{font-size:20px}button{padding:10px 18px;background:#dc2626;color:#fff;border:0;border-radius:6px;font-size:14px;cursor:pointer}</style>
+</head><body>
+  <h1>Confirm unsubscribe</h1>
+  <p>Click the button below to unsubscribe <strong>${escapeHtml(decoded.email)}</strong>${decoded.scope === "all" ? " from everything" : " from marketing emails"}.</p>
+  <form method="POST" action="${escapeHtml(req.originalUrl)}">
+    <button type="submit">Unsubscribe</button>
+  </form>
+</body></html>`);
+  });
+  router.post("/unsub/:token", async (req, res) => {
+    const decoded = verifyUnsubscribeToken(req.params.token, mailer.config.unsubscribeSecret);
+    if (!decoded) {
+      res.status(200).end();
+      return;
+    }
+    res.status(200).type("html").send("<!doctype html><html><body><p>You are unsubscribed.</p></body></html>");
+    try {
+      await mailer.unsubscribe(decoded.email, {
+        scope: decoded.scope,
+        reason: "user_request",
+        source: "one-click"
+      });
+    } catch (err) {
+      try {
+        fs__default.default.appendFileSync(
+          pendingUnsubsPath,
+          JSON.stringify({ email: decoded.email, scope: decoded.scope, at: Date.now() }) + "\n"
+        );
+      } catch (diskErr) {
+        console.error("mailery: unsub disk fallback failed", { err, diskErr });
+      }
+    }
+  });
+  router.get("/confirm-doi/:token", async (req, res) => {
+    const token = req.params.token;
+    const decoded = verifyDoiToken(token, mailer.config.unsubscribeSecret);
+    if (!decoded) {
+      return res.status(400).type("html").send("<!doctype html><html><body><p>Confirmation link is invalid or expired.</p></body></html>");
+    }
+    const now = /* @__PURE__ */ new Date();
+    const result = await mailer.collections.subscriptions.updateOne(
+      { externalId: decoded.externalId, status: "pending_doi" },
+      {
+        $set: {
+          status: "subscribed",
+          subscribedAt: now,
+          doiConfirmedAt: now,
+          doiIp: req.ip ?? null,
+          doiUserAgent: req.headers["user-agent"] ?? null,
+          updatedAt: now
+        }
+      }
+    );
+    if (result.matchedCount === 0) {
+      return res.status(200).type("html").send("<!doctype html><html><body><p>Already confirmed. Thanks.</p></body></html>");
+    }
+    try {
+      await mailer.fire("subscription.confirmed", decoded.externalId, {}, `doi-confirmed:${decoded.externalId}`);
+    } catch {
+    }
+    return res.status(200).type("html").send("<!doctype html><html><body><p>Thanks \u2014 you're subscribed.</p></body></html>");
+  });
+  router.post("/webhooks/:provider", async (req, res) => {
+    const providerName = req.params.provider;
+    const provider = mailer.providers[providerName];
+    if (!provider) return res.status(404).end();
+    const rawBody = req.rawBody;
+    if (!rawBody) return res.status(400).end();
+    const headers = lowercaseHeaders(req.headers);
+    const valid = await provider.verifyWebhook(rawBody, headers);
+    if (!valid) return res.status(401).end();
+    const events = provider.parseWebhookEvents(req.body, headers);
+    res.status(200).end();
+    const rawBodyRef = req.body;
+    for (const evt of events) {
+      try {
+        await mailer.collections.webhookEvents.updateOne(
+          { provider: providerName, providerEventId: evt.providerEventId },
+          {
+            $setOnInsert: {
+              provider: providerName,
+              providerEventId: evt.providerEventId,
+              eventType: evt.type,
+              normalizedType: evt.type,
+              providerMessageId: evt.providerMessageId,
+              email: evt.email,
+              occurredAt: evt.occurredAt,
+              receivedAt: /* @__PURE__ */ new Date(),
+              processed: false,
+              raw: { normalized: evt, providerBody: rawBodyRef }
+            }
+          },
+          { upsert: true }
+        );
+      } catch (err) {
+        console.error("mailery: webhook dedupe insert failed", err);
+      }
+    }
+    if (events.length > 0) {
+      try {
+        await mailer.queues.webhook.add("webhook", { provider: providerName });
+      } catch {
+      }
+    }
+  });
+  return router;
+}
+function sendUnsubError(res, msg) {
+  return res.status(400).type("html").send(`<!doctype html><html><body><p>${escapeHtml(msg)}</p></body></html>`);
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function lowercaseHeaders(h) {
+  const out = {};
+  for (const k of Object.keys(h)) {
+    const v = h[k];
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(",") : String(v ?? "");
+  }
+  return out;
+}
+
+// src/server/index.ts
+var VERSION = "0.1.0";
+
+exports.Mailer = Mailer;
+exports.NullProvider = NullProvider;
 exports.VERSION = VERSION;
+exports.applyTracking = applyTracking;
+exports.compileTemplate = compileTemplate;
+exports.createAdminRouter = createAdminRouter;
+exports.createPublicRouter = createPublicRouter;
+exports.derivePlaintext = derivePlaintext;
+exports.ensureIndexes = ensureIndexes;
+exports.getCollections = getCollections;
+exports.renderTemplate = renderTemplate;
+exports.sha256Hex = sha256Hex;
+exports.signUnsubscribeToken = signUnsubscribeToken;
+exports.verifyUnsubscribeToken = verifyUnsubscribeToken;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map