@astralibx/email-account-manager 2.0.0

package/dist/index.js

@@ -0,0 +1,3044 @@
+'use strict';
+
+var zod = require('zod');
+var core = require('@astralibx/core');
+var mongoose = require('mongoose');
+var crypto = require('crypto');
+var bullmq = require('bullmq');
+var nodemailer = require('nodemailer');
+var https = require('https');
+var express = require('express');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var nodemailer__default = /*#__PURE__*/_interopDefault(nodemailer);
+var https__default = /*#__PURE__*/_interopDefault(https);
+
+// src/validation/config.schema.ts
+var AlxAccountError = class extends core.AlxError {
+  constructor(message, code) {
+    super(message, code);
+    this.code = code;
+    this.name = "AlxAccountError";
+  }
+};
+var ConfigValidationError = class extends AlxAccountError {
+  constructor(message, field) {
+    super(message, "CONFIG_VALIDATION");
+    this.field = field;
+    this.name = "ConfigValidationError";
+  }
+};
+var AccountDisabledError = class extends AlxAccountError {
+  constructor(accountId, reason) {
+    super(`Account ${accountId} is disabled: ${reason}`, "ACCOUNT_DISABLED");
+    this.accountId = accountId;
+    this.reason = reason;
+    this.name = "AccountDisabledError";
+  }
+};
+var NoAvailableAccountError = class extends AlxAccountError {
+  constructor() {
+    super("No available accounts with remaining capacity", "NO_AVAILABLE_ACCOUNT");
+    this.name = "NoAvailableAccountError";
+  }
+};
+var SmtpConnectionError = class extends AlxAccountError {
+  constructor(accountId, originalError) {
+    super(`SMTP connection failed for account ${accountId}: ${originalError.message}`, "SMTP_CONNECTION");
+    this.accountId = accountId;
+    this.originalError = originalError;
+    this.name = "SmtpConnectionError";
+  }
+};
+var InvalidTokenError = class extends AlxAccountError {
+  constructor(tokenType) {
+    super(`Invalid or expired ${tokenType} token`, "INVALID_TOKEN");
+    this.tokenType = tokenType;
+    this.name = "InvalidTokenError";
+  }
+};
+var QuotaExceededError = class extends AlxAccountError {
+  constructor(accountId, dailyMax, currentSent) {
+    super(
+      `Account ${accountId} exceeded daily quota: ${currentSent}/${dailyMax}`,
+      "QUOTA_EXCEEDED"
+    );
+    this.accountId = accountId;
+    this.dailyMax = dailyMax;
+    this.currentSent = currentSent;
+    this.name = "QuotaExceededError";
+  }
+};
+var SnsSignatureError = class extends AlxAccountError {
+  constructor() {
+    super("SNS message signature verification failed", "SNS_SIGNATURE_INVALID");
+    this.name = "SnsSignatureError";
+  }
+};
+var AccountNotFoundError = class extends AlxAccountError {
+  constructor(accountId) {
+    super(`Account not found: ${accountId}`, "ACCOUNT_NOT_FOUND");
+    this.accountId = accountId;
+    this.name = "AccountNotFoundError";
+  }
+};
+var DraftNotFoundError = class extends AlxAccountError {
+  constructor(draftId) {
+    super(`Draft not found: ${draftId}`, "DRAFT_NOT_FOUND");
+    this.draftId = draftId;
+    this.name = "DraftNotFoundError";
+  }
+};
+
+// src/validation/config.schema.ts
+var warmupPhaseSchema = zod.z.object({
+  days: zod.z.tuple([zod.z.number().int().min(0), zod.z.number().int().min(0)]),
+  dailyLimit: zod.z.number().int().positive(),
+  delayMinMs: zod.z.number().int().min(0),
+  delayMaxMs: zod.z.number().int().min(0)
+});
+var configSchema = zod.z.object({
+  db: core.baseDbSchema,
+  redis: core.baseRedisSchema,
+  logger: core.loggerSchema.optional(),
+  options: zod.z.object({
+    warmup: zod.z.object({
+      defaultSchedule: zod.z.array(warmupPhaseSchema).min(1)
+    }).optional(),
+    healthDefaults: zod.z.object({
+      minScore: zod.z.number().min(0).max(100).optional(),
+      maxBounceRate: zod.z.number().min(0).max(100).optional(),
+      maxConsecutiveErrors: zod.z.number().int().positive().optional()
+    }).optional(),
+    ses: zod.z.object({
+      enabled: zod.z.boolean(),
+      validateSignature: zod.z.boolean().optional(),
+      allowedTopicArns: zod.z.array(zod.z.string()).optional()
+    }).optional(),
+    unsubscribe: zod.z.object({
+      builtin: zod.z.object({
+        enabled: zod.z.boolean(),
+        secret: zod.z.string().min(1),
+        baseUrl: zod.z.string().url(),
+        tokenExpiryDays: zod.z.number().int().positive().optional()
+      }).optional(),
+      generateUrl: zod.z.function().optional()
+    }).optional(),
+    queues: zod.z.object({
+      sendQueueName: zod.z.string().optional(),
+      approvalQueueName: zod.z.string().optional()
+    }).optional()
+  }).optional(),
+  hooks: zod.z.object({
+    onAccountDisabled: zod.z.function().optional(),
+    onWarmupComplete: zod.z.function().optional(),
+    onHealthDegraded: zod.z.function().optional(),
+    onSend: zod.z.function().optional(),
+    onSendError: zod.z.function().optional(),
+    onBounce: zod.z.function().optional(),
+    onUnsubscribe: zod.z.function().optional(),
+    onDelivery: zod.z.function().optional(),
+    onComplaint: zod.z.function().optional(),
+    onOpen: zod.z.function().optional(),
+    onClick: zod.z.function().optional(),
+    onDraftCreated: zod.z.function().optional(),
+    onDraftApproved: zod.z.function().optional(),
+    onDraftRejected: zod.z.function().optional()
+  }).optional()
+});
+function validateConfig(raw) {
+  const result = configSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigValidationError(
+      `Invalid EmailAccountManagerConfig:
+${issues}`,
+      result.error.issues[0]?.path.join(".") ?? ""
+    );
+  }
+}
+
+// src/constants/index.ts
+var ACCOUNT_PROVIDER = {
+  Gmail: "gmail",
+  Ses: "ses"
+};
+var ACCOUNT_STATUS = {
+  Active: "active",
+  Disabled: "disabled",
+  QuotaExceeded: "quota_exceeded",
+  Error: "error",
+  Warmup: "warmup"
+};
+var IDENTIFIER_STATUS = {
+  Active: "active",
+  Bounced: "bounced",
+  Unsubscribed: "unsubscribed",
+  Blocked: "blocked",
+  Invalid: "invalid"
+};
+var BOUNCE_TYPE = {
+  Hard: "hard",
+  Soft: "soft",
+  InboxFull: "inbox_full",
+  InvalidEmail: "invalid_email"
+};
+var DRAFT_STATUS = {
+  Pending: "pending",
+  Approved: "approved",
+  Rejected: "rejected",
+  Queued: "queued",
+  Sent: "sent",
+  Failed: "failed"
+};
+var EMAIL_EVENT_TYPE = {
+  Sent: "sent",
+  Failed: "failed",
+  Delivered: "delivered",
+  Bounced: "bounced",
+  Complained: "complained",
+  Opened: "opened",
+  Clicked: "clicked",
+  Unsubscribed: "unsubscribed"
+};
+var SES_BOUNCE_TYPE = {
+  Permanent: "Permanent",
+  Transient: "Transient",
+  Undetermined: "Undetermined"
+};
+var SES_COMPLAINT_TYPE = {
+  Abuse: "abuse",
+  AuthFailure: "auth-failure",
+  Fraud: "fraud",
+  NotSpam: "not-spam",
+  Other: "other",
+  Virus: "virus"
+};
+var SNS_MESSAGE_TYPE = {
+  Notification: "Notification",
+  SubscriptionConfirmation: "SubscriptionConfirmation",
+  UnsubscribeConfirmation: "UnsubscribeConfirmation"
+};
+var SES_NOTIFICATION_TYPE = {
+  Bounce: "Bounce",
+  Complaint: "Complaint",
+  Delivery: "Delivery",
+  Send: "Send",
+  Open: "Open",
+  Click: "Click"
+};
+
+// src/schemas/email-account.schema.ts
+function createEmailAccountSchema(options) {
+  const schema = new mongoose.Schema(
+    {
+      email: { type: String, required: true, unique: true, lowercase: true },
+      senderName: { type: String, required: true },
+      provider: { type: String, enum: Object.values(ACCOUNT_PROVIDER), required: true },
+      status: {
+        type: String,
+        enum: Object.values(ACCOUNT_STATUS),
+        default: ACCOUNT_STATUS.Active,
+        index: true
+      },
+      // WARNING: SMTP/IMAP credentials are stored as plaintext in the database.
+      // Consumers MUST encrypt `smtp.pass` and `imap.pass` at the application layer
+      // before storing, and decrypt after retrieval. A built-in encryption layer
+      // is planned for a future version.
+      smtp: {
+        type: {
+          host: { type: String, required: true },
+          port: { type: Number, required: true },
+          user: { type: String, required: true },
+          pass: { type: String, required: true }
+        },
+        required: true,
+        _id: false
+      },
+      imap: {
+        type: {
+          host: { type: String, required: true },
+          port: { type: Number, required: true },
+          user: { type: String, required: true },
+          pass: { type: String, required: true }
+        },
+        _id: false
+      },
+      ses: {
+        type: {
+          region: { type: String, required: true },
+          configurationSet: String
+        },
+        _id: false
+      },
+      limits: {
+        type: {
+          dailyMax: { type: Number, required: true, default: 100 }
+        },
+        required: true,
+        _id: false
+      },
+      health: {
+        type: {
+          score: { type: Number, default: 100, min: 0, max: 100 },
+          consecutiveErrors: { type: Number, default: 0 },
+          bounceCount: { type: Number, default: 0 },
+          thresholds: {
+            type: {
+              minScore: { type: Number, default: 50 },
+              maxBounceRate: { type: Number, default: 5 },
+              maxConsecutiveErrors: { type: Number, default: 10 }
+            },
+            _id: false
+          }
+        },
+        required: true,
+        _id: false
+      },
+      warmup: {
+        type: {
+          enabled: { type: Boolean, default: true },
+          startedAt: Date,
+          completedAt: Date,
+          currentDay: { type: Number, default: 1 },
+          schedule: [{
+            days: { type: [Number], required: true },
+            dailyLimit: { type: Number, required: true },
+            delayMinMs: { type: Number, required: true },
+            delayMaxMs: { type: Number, required: true },
+            _id: false
+          }]
+        },
+        required: true,
+        _id: false
+      },
+      totalEmailsSent: { type: Number, default: 0 },
+      lastSuccessfulSendAt: Date,
+      lastImapCheckAt: Date
+    },
+    {
+      timestamps: true,
+      collection: options?.collectionName || "email_accounts",
+      statics: {
+        findActive() {
+          return this.find({
+            status: { $in: [ACCOUNT_STATUS.Active, ACCOUNT_STATUS.Warmup] }
+          });
+        },
+        findByProvider(provider) {
+          return this.find({ provider });
+        },
+        findByEmail(email) {
+          return this.findOne({ email: email.toLowerCase().trim() });
+        },
+        async getBestAvailable() {
+          const accounts = await this.find({
+            status: { $in: [ACCOUNT_STATUS.Active, ACCOUNT_STATUS.Warmup] }
+          });
+          if (accounts.length === 0) return null;
+          return accounts.sort((a, b) => b.health.score - a.health.score)[0] || null;
+        }
+      }
+    }
+  );
+  schema.index({ status: 1, "health.score": -1 });
+  schema.index({ "health.score": -1 });
+  schema.index({ provider: 1 });
+  return schema;
+}
+function createEmailDailyStatsSchema(options) {
+  const schema = new mongoose.Schema(
+    {
+      accountId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true },
+      date: { type: String, required: true, index: true },
+      sent: { type: Number, default: 0 },
+      failed: { type: Number, default: 0 },
+      bounced: { type: Number, default: 0 },
+      delivered: { type: Number, default: 0 },
+      complained: { type: Number, default: 0 },
+      opened: { type: Number, default: 0 },
+      clicked: { type: Number, default: 0 },
+      unsubscribed: { type: Number, default: 0 }
+    },
+    {
+      timestamps: true,
+      collection: options?.collectionName || "email_daily_stats",
+      statics: {
+        incrementStat(accountId, field, count = 1, date) {
+          const targetDate = date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          const update = {};
+          update[field] = count;
+          return this.findOneAndUpdate(
+            { accountId: new mongoose.Types.ObjectId(accountId), date: targetDate },
+            { $inc: update },
+            { upsert: true, new: true }
+          );
+        },
+        getForAccount(accountId, days = 30) {
+          const startDate = /* @__PURE__ */ new Date();
+          startDate.setDate(startDate.getDate() - days);
+          const startDateStr = startDate.toISOString().split("T")[0];
+          return this.find({
+            accountId: new mongoose.Types.ObjectId(accountId),
+            date: { $gte: startDateStr }
+          }).sort({ date: -1 });
+        },
+        getForDate(date) {
+          return this.find({ date });
+        }
+      }
+    }
+  );
+  schema.index({ accountId: 1, date: -1 }, { unique: true });
+  return schema;
+}
+function createEmailIdentifierSchema(options) {
+  const schema = new mongoose.Schema(
+    {
+      email: { type: String, required: true, unique: true, lowercase: true },
+      status: {
+        type: String,
+        enum: Object.values(IDENTIFIER_STATUS),
+        default: IDENTIFIER_STATUS.Active,
+        index: true
+      },
+      sentCount: { type: Number, default: 0 },
+      bounceCount: { type: Number, default: 0 },
+      lastSentAt: Date,
+      lastBouncedAt: Date,
+      bounceType: { type: String, enum: Object.values(BOUNCE_TYPE) },
+      unsubscribedAt: Date,
+      metadata: { type: mongoose.Schema.Types.Mixed }
+    },
+    {
+      timestamps: true,
+      collection: options?.collectionName || "email_identifiers",
+      statics: {
+        async findOrCreate(email) {
+          const normalized = email.toLowerCase().trim();
+          const existing = await this.findOne({ email: normalized });
+          if (existing) {
+            return { identifier: existing, created: false };
+          }
+          const identifier = await this.findOneAndUpdate(
+            { email: normalized },
+            {
+              $setOnInsert: {
+                email: normalized,
+                status: IDENTIFIER_STATUS.Active,
+                sentCount: 0,
+                bounceCount: 0
+              }
+            },
+            { upsert: true, new: true }
+          );
+          return { identifier, created: true };
+        },
+        markBounced(email, bounceType) {
+          const normalized = email.toLowerCase().trim();
+          return this.findOneAndUpdate(
+            { email: normalized },
+            {
+              $set: {
+                status: IDENTIFIER_STATUS.Bounced,
+                bounceType,
+                lastBouncedAt: /* @__PURE__ */ new Date()
+              },
+              $inc: { bounceCount: 1 }
+            },
+            { new: true }
+          );
+        },
+        markUnsubscribed(email) {
+          const normalized = email.toLowerCase().trim();
+          return this.findOneAndUpdate(
+            { email: normalized },
+            {
+              $set: {
+                status: IDENTIFIER_STATUS.Unsubscribed,
+                unsubscribedAt: /* @__PURE__ */ new Date()
+              }
+            },
+            { new: true }
+          );
+        },
+        incrementSentCount(email) {
+          const normalized = email.toLowerCase().trim();
+          return this.findOneAndUpdate(
+            { email: normalized },
+            {
+              $inc: { sentCount: 1 },
+              $set: { lastSentAt: /* @__PURE__ */ new Date() }
+            },
+            { new: true, upsert: true }
+          );
+        },
+        findByEmail(email) {
+          const normalized = email.toLowerCase().trim();
+          return this.findOne({ email: normalized });
+        }
+      }
+    }
+  );
+  schema.index({ email: 1 }, { unique: true });
+  schema.index({ status: 1 });
+  return schema;
+}
+function createEmailDraftSchema(options) {
+  const schema = new mongoose.Schema(
+    {
+      to: { type: String, required: true, lowercase: true },
+      subject: { type: String, required: true },
+      htmlBody: { type: String, required: true },
+      textBody: String,
+      accountId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true },
+      status: {
+        type: String,
+        enum: Object.values(DRAFT_STATUS),
+        default: DRAFT_STATUS.Pending,
+        index: true
+      },
+      approvedAt: Date,
+      rejectedAt: Date,
+      rejectionReason: String,
+      sentAt: Date,
+      scheduledAt: Date,
+      failureReason: String,
+      metadata: { type: mongoose.Schema.Types.Mixed }
+    },
+    {
+      timestamps: true,
+      collection: options?.collectionName || "email_drafts",
+      statics: {
+        findPending(limit = 50) {
+          return this.find({ status: DRAFT_STATUS.Pending }).sort({ createdAt: -1 }).limit(limit);
+        },
+        findByStatus(status, limit = 50) {
+          return this.find({ status }).sort({ createdAt: -1 }).limit(limit);
+        },
+        async countByStatus() {
+          const results = await this.aggregate([
+            { $group: { _id: "$status", count: { $sum: 1 } } }
+          ]);
+          const counts = {};
+          for (const status of Object.values(DRAFT_STATUS)) {
+            counts[status] = 0;
+          }
+          for (const result of results) {
+            counts[result._id] = result.count;
+          }
+          return counts;
+        }
+      }
+    }
+  );
+  schema.index({ status: 1, createdAt: -1 });
+  schema.index({ accountId: 1, status: 1 });
+  return schema;
+}
+var DEFAULT_SETTINGS = {
+  timezone: "UTC",
+  devMode: {
+    enabled: false,
+    testEmails: []
+  },
+  imap: {
+    enabled: false,
+    pollIntervalMs: 3e5,
+    searchSince: "last_check",
+    bounceSenders: ["mailer-daemon@googlemail.com"]
+  },
+  ses: {
+    configurationSet: void 0,
+    trackOpens: true,
+    trackClicks: true
+  },
+  approval: {
+    enabled: false,
+    defaultMode: "manual",
+    autoApproveDelayMs: 0,
+    sendWindow: {
+      timezone: "UTC",
+      startHour: 9,
+      endHour: 21
+    },
+    spreadStrategy: "random",
+    maxSpreadMinutes: 120
+  },
+  unsubscribePage: {
+    companyName: "",
+    logoUrl: void 0,
+    accentColor: void 0
+  },
+  queues: {
+    sendConcurrency: 3,
+    sendAttempts: 3,
+    sendBackoffMs: 5e3,
+    approvalConcurrency: 1,
+    approvalAttempts: 3,
+    approvalBackoffMs: 1e4
+  }
+};
+function createGlobalSettingsSchema(options) {
+  const schema = new mongoose.Schema(
+    {
+      _id: { type: String, default: "global" },
+      timezone: { type: String, default: DEFAULT_SETTINGS.timezone },
+      devMode: {
+        type: {
+          enabled: { type: Boolean, default: false },
+          testEmails: [{ type: String }]
+        },
+        default: () => ({ ...DEFAULT_SETTINGS.devMode }),
+        _id: false
+      },
+      imap: {
+        type: {
+          enabled: { type: Boolean, default: false },
+          pollIntervalMs: { type: Number, default: 3e5 },
+          searchSince: { type: String, enum: ["last_check", "last_24h", "last_7d"], default: "last_check" },
+          bounceSenders: [{ type: String }]
+        },
+        default: () => ({ ...DEFAULT_SETTINGS.imap }),
+        _id: false
+      },
+      ses: {
+        type: {
+          configurationSet: String,
+          trackOpens: { type: Boolean, default: true },
+          trackClicks: { type: Boolean, default: true }
+        },
+        default: () => ({ ...DEFAULT_SETTINGS.ses }),
+        _id: false
+      },
+      approval: {
+        type: {
+          enabled: { type: Boolean, default: false },
+          defaultMode: { type: String, enum: ["manual", "auto"], default: "manual" },
+          autoApproveDelayMs: { type: Number, default: 0 },
+          sendWindow: {
+            type: {
+              timezone: { type: String, default: "UTC" },
+              startHour: { type: Number, default: 9, min: 0, max: 23 },
+              endHour: { type: Number, default: 21, min: 0, max: 23 }
+            },
+            _id: false
+          },
+          spreadStrategy: { type: String, enum: ["random", "even"], default: "random" },
+          maxSpreadMinutes: { type: Number, default: 120 }
+        },
+        default: () => ({ ...DEFAULT_SETTINGS.approval, sendWindow: { ...DEFAULT_SETTINGS.approval.sendWindow } }),
+        _id: false
+      },
+      unsubscribePage: {
+        type: {
+          companyName: { type: String, default: "" },
+          logoUrl: String,
+          accentColor: String
+        },
+        default: () => ({ ...DEFAULT_SETTINGS.unsubscribePage }),
+        _id: false
+      },
+      queues: {
+        type: {
+          sendConcurrency: { type: Number, default: 3 },
+          sendAttempts: { type: Number, default: 3 },
+          sendBackoffMs: { type: Number, default: 5e3 },
+          approvalConcurrency: { type: Number, default: 1 },
+          approvalAttempts: { type: Number, default: 3 },
+          approvalBackoffMs: { type: Number, default: 1e4 }
+        },
+        default: () => ({ ...DEFAULT_SETTINGS.queues }),
+        _id: false
+      }
+    },
+    {
+      timestamps: { createdAt: false, updatedAt: true },
+      collection: options?.collectionName || "global_settings",
+      statics: {
+        async getSettings() {
+          let doc = await this.findById("global");
+          if (!doc) {
+            doc = await this.create({ _id: "global", ...DEFAULT_SETTINGS });
+          }
+          return doc;
+        },
+        async updateSettings(partial) {
+          const flatUpdate = {};
+          for (const [key, value] of Object.entries(partial)) {
+            if (value !== void 0 && typeof value === "object" && !Array.isArray(value)) {
+              for (const [subKey, subValue] of Object.entries(value)) {
+                flatUpdate[`${key}.${subKey}`] = subValue;
+              }
+            } else {
+              flatUpdate[key] = value;
+            }
+          }
+          const doc = await this.findOneAndUpdate(
+            { _id: "global" },
+            { $set: flatUpdate },
+            { new: true, upsert: true }
+          );
+          return doc;
+        }
+      }
+    }
+  );
+  return schema;
+}
+
+// src/services/settings.service.ts
+var DEFAULTS = {
+  timezone: "UTC",
+  devMode: { enabled: false, testEmails: [] },
+  imap: {
+    enabled: false,
+    pollIntervalMs: 3e5,
+    searchSince: "last_check",
+    bounceSenders: ["mailer-daemon@googlemail.com"]
+  },
+  ses: { trackOpens: true, trackClicks: true },
+  approval: {
+    enabled: false,
+    defaultMode: "manual",
+    autoApproveDelayMs: 0,
+    sendWindow: { timezone: "UTC", startHour: 9, endHour: 21 },
+    spreadStrategy: "random",
+    maxSpreadMinutes: 120
+  },
+  unsubscribePage: { companyName: "" },
+  queues: {
+    sendConcurrency: 3,
+    sendAttempts: 3,
+    sendBackoffMs: 5e3,
+    approvalConcurrency: 1,
+    approvalAttempts: 3,
+    approvalBackoffMs: 1e4
+  }
+};
+var SettingsService = class {
+  constructor(GlobalSettings, logger) {
+    this.GlobalSettings = GlobalSettings;
+    this.logger = logger;
+  }
+  cache = null;
+  async get() {
+    if (this.cache) return this.cache;
+    let doc = await this.GlobalSettings.findById("global").lean();
+    if (!doc) {
+      doc = await this.GlobalSettings.create({
+        _id: "global",
+        ...DEFAULTS,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      this.logger.info("GlobalSettings created with defaults");
+    }
+    this.cache = doc;
+    return doc;
+  }
+  async update(partial) {
+    const flattened = flattenObject({ ...partial, updatedAt: /* @__PURE__ */ new Date() });
+    const doc = await this.GlobalSettings.findByIdAndUpdate(
+      "global",
+      { $set: flattened },
+      { new: true, upsert: true }
+    ).lean();
+    this.cache = doc;
+    this.logger.info("GlobalSettings updated", { sections: Object.keys(partial) });
+    return doc;
+  }
+  async updateSection(section, data) {
+    const setFields = { updatedAt: /* @__PURE__ */ new Date() };
+    if (typeof data === "object" && data !== null) {
+      for (const [key, value] of Object.entries(data)) {
+        setFields[`${section}.${key}`] = value;
+      }
+    } else {
+      setFields[section] = data;
+    }
+    const doc = await this.GlobalSettings.findByIdAndUpdate(
+      "global",
+      { $set: setFields },
+      { new: true, upsert: true }
+    ).lean();
+    this.cache = doc;
+    this.logger.info("GlobalSettings section updated", { section });
+    return doc;
+  }
+  invalidateCache() {
+    this.cache = null;
+  }
+};
+function flattenObject(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+      Object.assign(result, flattenObject(value, fullKey));
+    } else {
+      result[fullKey] = value;
+    }
+  }
+  return result;
+}
+
+// src/services/identifier.service.ts
+var IdentifierService = class {
+  constructor(EmailIdentifier, logger, hooks) {
+    this.EmailIdentifier = EmailIdentifier;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  async findOrCreate(email) {
+    const normalized = email.toLowerCase().trim();
+    const doc = await this.EmailIdentifier.findOneAndUpdate(
+      { email: normalized },
+      {
+        $setOnInsert: {
+          email: normalized,
+          status: IDENTIFIER_STATUS.Active,
+          sentCount: 0,
+          bounceCount: 0
+        }
+      },
+      { upsert: true, new: true }
+    );
+    return doc;
+  }
+  async findByEmail(email) {
+    return this.EmailIdentifier.findOne({ email: email.toLowerCase().trim() });
+  }
+  async markBounced(email, bounceType) {
+    const normalized = email.toLowerCase().trim();
+    await this.EmailIdentifier.findOneAndUpdate(
+      { email: normalized },
+      {
+        $set: {
+          status: IDENTIFIER_STATUS.Bounced,
+          bounceType,
+          lastBouncedAt: /* @__PURE__ */ new Date()
+        },
+        $inc: { bounceCount: 1 }
+      },
+      { upsert: true }
+    );
+    this.logger.warn("Identifier marked bounced", { email: normalized, bounceType });
+    this.hooks?.onBounce?.({ accountId: "", email: normalized, bounceType, provider: "" });
+  }
+  async markUnsubscribed(email) {
+    const normalized = email.toLowerCase().trim();
+    await this.EmailIdentifier.findOneAndUpdate(
+      { email: normalized },
+      {
+        $set: {
+          status: IDENTIFIER_STATUS.Unsubscribed,
+          unsubscribedAt: /* @__PURE__ */ new Date()
+        }
+      },
+      { upsert: true }
+    );
+    this.logger.info("Identifier marked unsubscribed", { email: normalized });
+    this.hooks?.onUnsubscribe?.({ email: normalized });
+  }
+  async updateStatus(email, status) {
+    await this.EmailIdentifier.findOneAndUpdate(
+      { email: email.toLowerCase().trim() },
+      { $set: { status } }
+    );
+  }
+  async incrementSentCount(email) {
+    await this.EmailIdentifier.findOneAndUpdate(
+      { email: email.toLowerCase().trim() },
+      {
+        $inc: { sentCount: 1 },
+        $set: { lastSentAt: /* @__PURE__ */ new Date() }
+      }
+    );
+  }
+  async merge(sourceEmail, targetEmail) {
+    const source = await this.findByEmail(sourceEmail);
+    const target = await this.findByEmail(targetEmail);
+    if (!source) {
+      this.logger.warn("Merge source not found", { sourceEmail });
+      return;
+    }
+    if (!target) {
+      await this.EmailIdentifier.findOneAndUpdate(
+        { email: sourceEmail.toLowerCase().trim() },
+        { $set: { email: targetEmail.toLowerCase().trim() } }
+      );
+      return;
+    }
+    await this.EmailIdentifier.findByIdAndUpdate(target._id, {
+      $inc: {
+        sentCount: source.sentCount || 0,
+        bounceCount: source.bounceCount || 0
+      },
+      $set: {
+        ...source.lastSentAt && (!target.lastSentAt || source.lastSentAt > target.lastSentAt) ? { lastSentAt: source.lastSentAt } : {},
+        ...source.metadata ? { metadata: { ...source.metadata, ...target.metadata || {} } } : {}
+      }
+    });
+    await this.EmailIdentifier.findByIdAndDelete(source._id);
+    this.logger.info("Identifiers merged", { sourceEmail, targetEmail });
+  }
+  async list(filters, page = 1, limit = 50) {
+    const query = {};
+    if (filters?.status) query.status = filters.status;
+    const [items, total] = await Promise.all([
+      this.EmailIdentifier.find(query).sort({ updatedAt: -1 }).skip((page - 1) * limit).limit(limit),
+      this.EmailIdentifier.countDocuments(query)
+    ]);
+    return { items, total };
+  }
+};
+
+// src/services/health-tracker.ts
+var HealthTracker = class {
+  constructor(EmailAccount, EmailDailyStats, settings, logger, hooks) {
+    this.EmailAccount = EmailAccount;
+    this.EmailDailyStats = EmailDailyStats;
+    this.settings = settings;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  async recordSuccess(accountId) {
+    const updated = await this.EmailAccount.findByIdAndUpdate(
+      accountId,
+      [
+        {
+          $set: {
+            "health.score": { $min: [100, { $add: ["$health.score", 1] }] },
+            "health.consecutiveErrors": 0,
+            lastSuccessfulSendAt: /* @__PURE__ */ new Date(),
+            totalEmailsSent: { $add: ["$totalEmailsSent", 1] }
+          }
+        }
+      ],
+      { new: true }
+    );
+    if (!updated) return;
+    const dateStr = await this.getTodayDateString();
+    await this.incrementDailyStat(accountId, "sent", 1, dateStr);
+  }
+  async recordError(accountId, error) {
+    const updated = await this.EmailAccount.findByIdAndUpdate(
+      accountId,
+      [
+        {
+          $set: {
+            "health.score": { $max: [0, { $subtract: ["$health.score", 5] }] },
+            "health.consecutiveErrors": { $add: ["$health.consecutiveErrors", 1] }
+          }
+        }
+      ],
+      { new: true }
+    );
+    if (!updated) return;
+    const acct = updated;
+    const newScore = acct.health.score;
+    const newErrors = acct.health.consecutiveErrors;
+    this.logger.warn("Account health degraded", {
+      accountId,
+      error,
+      score: newScore,
+      consecutiveErrors: newErrors
+    });
+    this.hooks?.onHealthDegraded?.({ accountId, healthScore: newScore });
+    const thresholds = acct.health.thresholds;
+    const shouldDisable = newScore < thresholds.minScore || newErrors > thresholds.maxConsecutiveErrors;
+    if (shouldDisable) {
+      const reason = newScore < thresholds.minScore ? `Health score ${newScore} below minimum ${thresholds.minScore}` : `${newErrors} consecutive errors exceeds maximum ${thresholds.maxConsecutiveErrors}`;
+      await this.EmailAccount.findByIdAndUpdate(accountId, {
+        $set: { status: ACCOUNT_STATUS.Disabled }
+      });
+      this.logger.error("Account auto-disabled", { accountId, reason });
+      this.hooks?.onAccountDisabled?.({ accountId, reason });
+    }
+  }
+  async recordBounce(accountId, email, bounceType) {
+    const updated = await this.EmailAccount.findByIdAndUpdate(
+      accountId,
+      [
+        {
+          $set: {
+            "health.score": { $max: [0, { $subtract: ["$health.score", 10] }] },
+            "health.bounceCount": { $add: ["$health.bounceCount", 1] }
+          }
+        }
+      ],
+      { new: true }
+    );
+    if (!updated) return;
+    const acct = updated;
+    const newScore = acct.health.score;
+    const newBounceCount = acct.health.bounceCount;
+    const totalSent = acct.totalEmailsSent || 1;
+    const bounceRate = newBounceCount / totalSent * 100;
+    const dateStr = await this.getTodayDateString();
+    await this.incrementDailyStat(accountId, "bounced", 1, dateStr);
+    this.logger.warn("Bounce recorded", { accountId, email, bounceType, score: newScore });
+    this.hooks?.onBounce?.({
+      accountId,
+      email,
+      bounceType,
+      provider: acct.provider
+    });
+    if (bounceRate > acct.health.thresholds.maxBounceRate) {
+      const reason = `Bounce rate ${bounceRate.toFixed(1)}% exceeds maximum ${acct.health.thresholds.maxBounceRate}%`;
+      await this.EmailAccount.findByIdAndUpdate(accountId, {
+        $set: { status: ACCOUNT_STATUS.Disabled }
+      });
+      this.logger.error("Account auto-disabled due to bounce rate", { accountId, reason });
+      this.hooks?.onAccountDisabled?.({ accountId, reason });
+    }
+  }
+  async getHealth(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return null;
+    return this.toAccountHealth(account);
+  }
+  async getAllHealth() {
+    const accounts = await this.EmailAccount.find();
+    return accounts.map((a) => this.toAccountHealth(a));
+  }
+  toAccountHealth(account) {
+    return {
+      accountId: account._id.toString(),
+      email: account.email,
+      score: account.health.score,
+      consecutiveErrors: account.health.consecutiveErrors,
+      bounceCount: account.health.bounceCount,
+      thresholds: account.health.thresholds,
+      status: account.status
+    };
+  }
+  async getTodayDateString() {
+    const globalSettings = await this.settings.get();
+    const tz = globalSettings.timezone || "UTC";
+    const now = /* @__PURE__ */ new Date();
+    const formatted = now.toLocaleDateString("en-CA", { timeZone: tz });
+    return formatted;
+  }
+  async incrementDailyStat(accountId, field, amount, date) {
+    await this.EmailDailyStats.findOneAndUpdate(
+      { accountId, date },
+      { $inc: { [field]: amount } },
+      { upsert: true }
+    );
+  }
+};
+
+// src/services/warmup-manager.ts
+var WarmupManager = class {
+  constructor(EmailAccount, config, logger, hooks) {
+    this.EmailAccount = EmailAccount;
+    this.config = config;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  async startWarmup(accountId) {
+    const defaultSchedule = this.config.options?.warmup?.defaultSchedule;
+    await this.EmailAccount.findByIdAndUpdate(accountId, {
+      $set: {
+        "warmup.enabled": true,
+        "warmup.startedAt": /* @__PURE__ */ new Date(),
+        "warmup.completedAt": null,
+        "warmup.currentDay": 1,
+        status: ACCOUNT_STATUS.Warmup,
+        ...defaultSchedule ? { "warmup.schedule": defaultSchedule } : {}
+      }
+    });
+    this.logger.info("Warmup started", { accountId });
+  }
+  async completeWarmup(accountId) {
+    const account = await this.EmailAccount.findByIdAndUpdate(
+      accountId,
+      {
+        $set: {
+          "warmup.enabled": false,
+          "warmup.completedAt": /* @__PURE__ */ new Date(),
+          status: ACCOUNT_STATUS.Active
+        }
+      },
+      { new: true }
+    );
+    if (account) {
+      this.logger.info("Warmup completed", { accountId, email: account.email });
+      this.hooks?.onWarmupComplete?.({
+        accountId,
+        email: account.email
+      });
+    }
+  }
+  async resetWarmup(accountId) {
+    await this.EmailAccount.findByIdAndUpdate(accountId, {
+      $set: {
+        "warmup.enabled": true,
+        "warmup.startedAt": /* @__PURE__ */ new Date(),
+        "warmup.completedAt": null,
+        "warmup.currentDay": 1,
+        status: ACCOUNT_STATUS.Warmup
+      }
+    });
+    this.logger.info("Warmup reset", { accountId });
+  }
+  async getCurrentPhase(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return null;
+    const warmup = account.warmup;
+    if (!warmup?.enabled || !warmup.schedule) return null;
+    return this.findPhaseForDay(warmup.schedule, warmup.currentDay);
+  }
+  async getRecommendedDelay(accountId) {
+    const phase = await this.getCurrentPhase(accountId);
+    if (!phase) return 0;
+    return Math.floor(Math.random() * (phase.delayMaxMs - phase.delayMinMs + 1)) + phase.delayMinMs;
+  }
+  async getDailyLimit(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return 0;
+    const warmup = account.warmup;
+    if (!warmup?.enabled) return account.limits.dailyMax;
+    const phase = this.findPhaseForDay(warmup.schedule, warmup.currentDay);
+    return phase ? phase.dailyLimit : account.limits.dailyMax;
+  }
+  async advanceDay(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return;
+    const warmup = account.warmup;
+    if (!warmup?.enabled) return;
+    const nextDay = warmup.currentDay + 1;
+    const maxDay = this.getMaxDay(warmup.schedule);
+    if (maxDay > 0 && nextDay > maxDay) {
+      await this.completeWarmup(accountId);
+    } else {
+      await this.EmailAccount.findByIdAndUpdate(accountId, {
+        $set: { "warmup.currentDay": nextDay }
+      });
+    }
+  }
+  async getStatus(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return null;
+    const acct = account;
+    const warmup = acct.warmup;
+    const phase = warmup?.schedule ? this.findPhaseForDay(warmup.schedule, warmup.currentDay) : null;
+    return {
+      accountId: acct._id.toString(),
+      email: acct.email,
+      enabled: warmup?.enabled ?? false,
+      currentDay: warmup?.currentDay ?? 0,
+      startedAt: warmup?.startedAt,
+      completedAt: warmup?.completedAt,
+      currentPhase: phase,
+      dailyLimit: phase ? phase.dailyLimit : acct.limits.dailyMax,
+      delayRange: phase ? { min: phase.delayMinMs, max: phase.delayMaxMs } : { min: 0, max: 0 }
+    };
+  }
+  async updateSchedule(accountId, schedule) {
+    await this.EmailAccount.findByIdAndUpdate(accountId, {
+      $set: { "warmup.schedule": schedule }
+    });
+    this.logger.info("Warmup schedule updated", { accountId, phases: schedule.length });
+  }
+  findPhaseForDay(schedule, day) {
+    for (const phase of schedule) {
+      const [start, end] = phase.days;
+      if (end === 0) {
+        if (day >= start) return phase;
+      } else {
+        if (day >= start && day <= end) return phase;
+      }
+    }
+    return null;
+  }
+  getMaxDay(schedule) {
+    let max = 0;
+    for (const phase of schedule) {
+      if (phase.days[1] === 0) return 0;
+      if (phase.days[1] > max) max = phase.days[1];
+    }
+    return max;
+  }
+};
+
+// src/services/capacity-manager.ts
+var CapacityManager = class {
+  constructor(EmailAccount, EmailDailyStats, warmupManager, settings, logger) {
+    this.EmailAccount = EmailAccount;
+    this.EmailDailyStats = EmailDailyStats;
+    this.warmupManager = warmupManager;
+    this.settings = settings;
+    this.logger = logger;
+  }
+  async getBestAccount() {
+    const accounts = await this.EmailAccount.find({
+      status: { $in: [ACCOUNT_STATUS.Active, ACCOUNT_STATUS.Warmup] }
+    }).sort({ "health.score": -1 });
+    for (const account of accounts) {
+      const acct = account;
+      const capacity = await this.getAccountCapacity(acct._id.toString());
+      if (capacity.remaining > 0) {
+        return account;
+      }
+    }
+    return null;
+  }
+  async getAccountCapacity(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) {
+      return {
+        accountId,
+        email: "",
+        provider: "gmail",
+        dailyMax: 0,
+        sentToday: 0,
+        remaining: 0,
+        usagePercent: 0
+      };
+    }
+    const acct = account;
+    const sentToday = await this.getSentToday(accountId);
+    const dailyMax = await this.getDailyLimit(acct);
+    const remaining = Math.max(0, dailyMax - sentToday);
+    const usagePercent = dailyMax > 0 ? Math.round(sentToday / dailyMax * 100) : 0;
+    return {
+      accountId: acct._id.toString(),
+      email: acct.email,
+      provider: acct.provider,
+      dailyMax,
+      sentToday,
+      remaining,
+      usagePercent
+    };
+  }
+  async getAllCapacity() {
+    const accounts = await this.EmailAccount.find({
+      status: { $in: [ACCOUNT_STATUS.Active, ACCOUNT_STATUS.Warmup] }
+    });
+    const capacities = await Promise.all(
+      accounts.map((a) => this.getAccountCapacity(a._id.toString()))
+    );
+    const totalRemaining = capacities.reduce((sum, c) => sum + c.remaining, 0);
+    return { accounts: capacities, totalRemaining };
+  }
+  async getSentToday(accountId) {
+    const dateStr = await this.getTodayDateString();
+    const stat = await this.EmailDailyStats.findOne({ accountId, date: dateStr });
+    return stat?.sent || 0;
+  }
+  async getDailyLimit(account) {
+    if (account.warmup?.enabled) {
+      const warmupLimit = await this.warmupManager.getDailyLimit(account._id.toString());
+      return warmupLimit;
+    }
+    return account.limits.dailyMax;
+  }
+  async getTodayDateString() {
+    const globalSettings = await this.settings.get();
+    const tz = globalSettings.timezone || "UTC";
+    return (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA", { timeZone: tz });
+  }
+};
+var SEPARATOR = "|";
+var UnsubscribeService = class {
+  constructor(EmailIdentifier, config, logger, hooks) {
+    this.EmailIdentifier = EmailIdentifier;
+    this.config = config;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  generateUrl(email, accountId) {
+    const customGenerator = this.config.options?.unsubscribe?.generateUrl;
+    if (customGenerator) {
+      return customGenerator(email, accountId || "");
+    }
+    const builtin = this.config.options?.unsubscribe?.builtin;
+    if (!builtin?.enabled || !builtin.baseUrl) {
+      return "";
+    }
+    const token = this.generateToken(email);
+    return `${builtin.baseUrl}?token=${token}`;
+  }
+  generateToken(email) {
+    const secret = this.config.options?.unsubscribe?.builtin?.secret;
+    if (!secret) return "";
+    const timestamp = Date.now().toString();
+    const payload = `${email.toLowerCase()}${SEPARATOR}${timestamp}`;
+    const signature = crypto__default.default.createHmac("sha256", secret).update(payload).digest("base64url");
+    const token = `${payload}${SEPARATOR}${signature}`;
+    return Buffer.from(token).toString("base64url");
+  }
+  verifyToken(email, token) {
+    try {
+      const secret = this.config.options?.unsubscribe?.builtin?.secret;
+      if (!secret) return false;
+      const decoded = Buffer.from(token, "base64url").toString("utf-8");
+      const parts = decoded.split(SEPARATOR);
+      if (parts.length !== 3) return false;
+      const [tokenEmail, timestampStr, providedSignature] = parts;
+      const payload = `${tokenEmail}${SEPARATOR}${timestampStr}`;
+      const expectedSignature = crypto__default.default.createHmac("sha256", secret).update(payload).digest("base64url");
+      const sig1 = Buffer.from(providedSignature);
+      const sig2 = Buffer.from(expectedSignature);
+      if (sig1.length !== sig2.length || !crypto__default.default.timingSafeEqual(sig1, sig2)) {
+        return false;
+      }
+      if (email && tokenEmail !== email.toLowerCase()) {
+        return false;
+      }
+      const expiryDays = this.config.options?.unsubscribe?.builtin?.tokenExpiryDays;
+      if (expiryDays) {
+        const timestamp = parseInt(timestampStr, 10);
+        const expiresAt = timestamp + expiryDays * 24 * 60 * 60 * 1e3;
+        if (Date.now() > expiresAt) return false;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async handleUnsubscribe(email, token) {
+    const decoded = Buffer.from(token, "base64url").toString("utf-8");
+    const parts = decoded.split(SEPARATOR);
+    const tokenEmail = parts.length === 3 ? parts[0] : email;
+    if (!this.verifyToken(tokenEmail, token)) {
+      return { success: false, error: "Invalid or expired unsubscribe link" };
+    }
+    const identifier = await this.EmailIdentifier.findOne({
+      email: tokenEmail.toLowerCase()
+    });
+    if (!identifier) {
+      return { success: true, email: tokenEmail };
+    }
+    if (identifier.status === IDENTIFIER_STATUS.Unsubscribed) {
+      return { success: true, email: tokenEmail };
+    }
+    await this.EmailIdentifier.findByIdAndUpdate(identifier._id, {
+      $set: {
+        status: IDENTIFIER_STATUS.Unsubscribed,
+        unsubscribedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    this.logger.info("Unsubscribe processed", { email: tokenEmail });
+    this.hooks?.onUnsubscribe?.({ email: tokenEmail });
+    return { success: true, email: tokenEmail };
+  }
+  getConfirmationHtml(email, success) {
+    const statusIcon = success ? "&#10003;" : "&#10007;";
+    const statusColor = success ? "#22c55e" : "#ef4444";
+    const title = success ? "Unsubscribed" : "Error";
+    const message = success ? `${email ? email + " has" : "You have"} been unsubscribed successfully.` : "Invalid or expired unsubscribe link. Please try again.";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Unsubscribe</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    }
+    .card {
+      background: white;
+      padding: 40px 50px;
+      border-radius: 16px;
+      box-shadow: 0 10px 40px rgba(0,0,0,0.1);
+      text-align: center;
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 48px;
+      color: ${statusColor};
+      margin-bottom: 20px;
+    }
+    h1 { color: #1f2937; font-size: 24px; margin: 0 0 12px; }
+    p { color: #6b7280; font-size: 16px; margin: 0; line-height: 1.5; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="icon">${statusIcon}</div>
+    <h1>${title}</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+  }
+};
+var QueueService = class {
+  constructor(redis, config, settings, logger) {
+    this.redis = redis;
+    this.config = config;
+    this.settings = settings;
+    this.logger = logger;
+  }
+  sendQueue;
+  approvalQueue;
+  sendWorker;
+  approvalWorker;
+  async init(processors) {
+    const keyPrefix = this.config.redis.keyPrefix || "eam:";
+    const sendQueueName = this.config.options?.queues?.sendQueueName || "email-send";
+    const approvalQueueName = this.config.options?.queues?.approvalQueueName || "email-approved";
+    const globalSettings = await this.settings.get();
+    const queueSettings = globalSettings.queues;
+    const redisConnection = this.redis;
+    this.sendQueue = new bullmq.Queue(sendQueueName, {
+      connection: redisConnection,
+      prefix: keyPrefix
+    });
+    this.approvalQueue = new bullmq.Queue(approvalQueueName, {
+      connection: redisConnection,
+      prefix: keyPrefix
+    });
+    this.sendWorker = new bullmq.Worker(
+      sendQueueName,
+      processors.sendProcessor,
+      {
+        connection: redisConnection,
+        prefix: keyPrefix,
+        concurrency: queueSettings.sendConcurrency
+      }
+    );
+    this.approvalWorker = new bullmq.Worker(
+      approvalQueueName,
+      processors.approvalProcessor,
+      {
+        connection: redisConnection,
+        prefix: keyPrefix,
+        concurrency: queueSettings.approvalConcurrency
+      }
+    );
+    this.sendWorker.on("failed", (job, err) => {
+      this.logger.error("Send job failed", {
+        jobId: job?.id,
+        error: err.message
+      });
+    });
+    this.approvalWorker.on("failed", (job, err) => {
+      this.logger.error("Approval job failed", {
+        jobId: job?.id,
+        error: err.message
+      });
+    });
+    this.logger.info("Queue service initialized", {
+      sendQueue: sendQueueName,
+      approvalQueue: approvalQueueName
+    });
+  }
+  async enqueueSend(data) {
+    const globalSettings = await this.settings.get();
+    const queueSettings = globalSettings.queues;
+    const job = await this.sendQueue.add("send", data, {
+      attempts: queueSettings.sendAttempts,
+      backoff: {
+        type: "exponential",
+        delay: queueSettings.sendBackoffMs
+      }
+    });
+    return job.id || "";
+  }
+  async enqueueApproval(data) {
+    const globalSettings = await this.settings.get();
+    const queueSettings = globalSettings.queues;
+    const delay = data.scheduledAt ? Math.max(0, new Date(data.scheduledAt).getTime() - Date.now()) : 0;
+    const job = await this.approvalQueue.add("approved", data, {
+      attempts: queueSettings.approvalAttempts,
+      backoff: {
+        type: "exponential",
+        delay: queueSettings.approvalBackoffMs
+      },
+      delay
+    });
+    return job.id || "";
+  }
+  async getStats() {
+    const [sendCounts, approvalCounts] = await Promise.all([
+      this.sendQueue.getJobCounts("waiting", "active", "completed", "failed", "delayed"),
+      this.approvalQueue.getJobCounts("waiting", "active", "completed", "failed", "delayed")
+    ]);
+    return {
+      send: sendCounts,
+      approval: approvalCounts
+    };
+  }
+  async pause(queue) {
+    const target = queue === "send" ? this.sendQueue : this.approvalQueue;
+    await target.pause();
+    this.logger.info("Queue paused", { queue });
+  }
+  async resume(queue) {
+    const target = queue === "send" ? this.sendQueue : this.approvalQueue;
+    await target.resume();
+    this.logger.info("Queue resumed", { queue });
+  }
+  async close() {
+    await Promise.all([
+      this.sendWorker?.close(),
+      this.approvalWorker?.close(),
+      this.sendQueue?.close(),
+      this.approvalQueue?.close()
+    ]);
+    this.logger.info("Queue service closed");
+  }
+};
+var SmtpService = class {
+  constructor(EmailAccount, capacityManager, healthTracker, identifierService, unsubscribeService, queueService, settings, config, logger, hooks) {
+    this.EmailAccount = EmailAccount;
+    this.capacityManager = capacityManager;
+    this.healthTracker = healthTracker;
+    this.identifierService = identifierService;
+    this.unsubscribeService = unsubscribeService;
+    this.queueService = queueService;
+    this.settings = settings;
+    this.config = config;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  devRoundRobinIndex = 0;
+  transporterPool = /* @__PURE__ */ new Map();
+  async send(params) {
+    const globalSettings = await this.settings.get();
+    if (globalSettings.approval.enabled) {
+      return { success: true, draftId: "approval-required" };
+    }
+    const account = params.accountId ? await this.EmailAccount.findById(params.accountId) : await this.capacityManager.getBestAccount();
+    if (!account) {
+      return { success: false, error: "No available email account" };
+    }
+    const acct = account;
+    const unsubscribeUrl = this.unsubscribeService.generateUrl(params.to, acct._id.toString());
+    const jobId = await this.queueService.enqueueSend({
+      accountId: acct._id.toString(),
+      to: params.to,
+      subject: params.subject,
+      html: params.html,
+      text: params.text || "",
+      unsubscribeUrl: unsubscribeUrl || void 0,
+      metadata: params.metadata
+    });
+    return { success: true, messageId: jobId };
+  }
+  async testConnection(accountId) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return { success: false, error: "Account not found" };
+    try {
+      const acct = account;
+      const transporter = this.createTransporter(acct);
+      await transporter.verify();
+      transporter.close();
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+  async executeSend(accountId, to, subject, html, text2, unsubscribeUrl) {
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return { success: false, error: "Account not found" };
+    const acct = account;
+    try {
+      const globalSettings = await this.settings.get();
+      let recipientEmail = to;
+      if (globalSettings.devMode.enabled && globalSettings.devMode.testEmails.length > 0) {
+        const testEmails = globalSettings.devMode.testEmails;
+        const devIndex = this.devRoundRobinIndex++ % testEmails.length;
+        recipientEmail = testEmails[devIndex];
+        this.logger.info("Dev mode: email redirected", { original: to, redirected: recipientEmail });
+      }
+      const transporter = this.getOrCreateTransporter(accountId, acct);
+      const headers = {};
+      if (acct.provider === ACCOUNT_PROVIDER.Ses && acct.ses?.configurationSet) {
+        headers["X-SES-CONFIGURATION-SET"] = acct.ses.configurationSet;
+      }
+      if (unsubscribeUrl) {
+        headers["List-Unsubscribe"] = `<${unsubscribeUrl}>`;
+        headers["List-Unsubscribe-Post"] = "List-Unsubscribe=One-Click";
+      }
+      const mailOptions = {
+        from: `${acct.senderName} <${acct.email}>`,
+        to: recipientEmail,
+        subject,
+        text: text2,
+        html,
+        headers
+      };
+      const info = await transporter.sendMail(mailOptions);
+      const messageId = info.messageId?.replace(/[<>]/g, "");
+      await this.healthTracker.recordSuccess(accountId);
+      await this.identifierService.incrementSentCount(to);
+      this.hooks?.onSend?.({ accountId, email: to, messageId });
+      this.logger.info("Email sent", { accountId, to, messageId });
+      return { success: true, messageId };
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Unknown error";
+      this.transporterPool.delete(accountId);
+      await this.healthTracker.recordError(accountId, errorMsg);
+      this.hooks?.onSendError?.({ accountId, email: to, error: errorMsg });
+      this.logger.error("Email send failed", { accountId, to, error: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  }
+  closeAll() {
+    for (const [id, transporter] of this.transporterPool) {
+      try {
+        transporter.close();
+      } catch {
+      }
+    }
+    this.transporterPool.clear();
+  }
+  getOrCreateTransporter(accountId, account) {
+    const existing = this.transporterPool.get(accountId);
+    if (existing) return existing;
+    const transporter = this.createTransporter(account, true);
+    this.transporterPool.set(accountId, transporter);
+    return transporter;
+  }
+  createTransporter(account, pooled = false) {
+    return nodemailer__default.default.createTransport({
+      host: account.smtp.host,
+      port: account.smtp.port || 587,
+      secure: account.smtp.port === 465,
+      auth: {
+        user: account.smtp.user,
+        pass: account.smtp.pass
+      },
+      ...pooled ? { pool: true, maxConnections: 5, maxMessages: 100 } : {}
+    });
+  }
+};
+
+// src/services/approval.service.ts
+var ApprovalService = class {
+  constructor(EmailDraft, queueService, settings, logger, hooks) {
+    this.EmailDraft = EmailDraft;
+    this.queueService = queueService;
+    this.settings = settings;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  async createDraft(input) {
+    const draft = await this.EmailDraft.create({
+      ...input,
+      status: DRAFT_STATUS.Pending
+    });
+    this.logger.info("Draft created", { draftId: draft._id.toString(), to: input.to });
+    this.hooks?.onDraftCreated?.({
+      draftId: draft._id.toString(),
+      to: input.to,
+      subject: input.subject
+    });
+    return draft;
+  }
+  async approve(draftId) {
+    const draft = await this.EmailDraft.findById(draftId);
+    if (!draft) throw new DraftNotFoundError(draftId);
+    const scheduledAt = await this.calculateScheduledTime(0, 1);
+    await this.EmailDraft.findByIdAndUpdate(draftId, {
+      $set: {
+        status: DRAFT_STATUS.Approved,
+        approvedAt: /* @__PURE__ */ new Date(),
+        scheduledAt
+      }
+    });
+    await this.queueService.enqueueApproval({
+      draftId,
+      scheduledAt: scheduledAt?.toISOString()
+    });
+    this.logger.info("Draft approved", { draftId });
+    this.hooks?.onDraftApproved?.({
+      draftId,
+      to: draft.to,
+      scheduledAt
+    });
+  }
+  async reject(draftId, reason) {
+    const draft = await this.EmailDraft.findById(draftId);
+    if (!draft) throw new DraftNotFoundError(draftId);
+    await this.EmailDraft.findByIdAndUpdate(draftId, {
+      $set: {
+        status: DRAFT_STATUS.Rejected,
+        rejectedAt: /* @__PURE__ */ new Date(),
+        ...reason ? { rejectionReason: reason } : {}
+      }
+    });
+    this.logger.info("Draft rejected", { draftId, reason });
+    this.hooks?.onDraftRejected?.({
+      draftId,
+      to: draft.to,
+      reason
+    });
+  }
+  async bulkApprove(draftIds) {
+    const total = draftIds.length;
+    for (let i = 0; i < total; i++) {
+      const scheduledAt = await this.calculateScheduledTime(i, total);
+      await this.EmailDraft.findByIdAndUpdate(draftIds[i], {
+        $set: {
+          status: DRAFT_STATUS.Approved,
+          approvedAt: /* @__PURE__ */ new Date(),
+          scheduledAt
+        }
+      });
+      await this.queueService.enqueueApproval({
+        draftId: draftIds[i],
+        scheduledAt: scheduledAt?.toISOString()
+      });
+    }
+    this.logger.info("Bulk approve completed", { count: total });
+  }
+  async bulkReject(draftIds, reason) {
+    await this.EmailDraft.updateMany(
+      { _id: { $in: draftIds } },
+      {
+        $set: {
+          status: DRAFT_STATUS.Rejected,
+          rejectedAt: /* @__PURE__ */ new Date(),
+          ...reason ? { rejectionReason: reason } : {}
+        }
+      }
+    );
+    this.logger.info("Bulk reject completed", { count: draftIds.length, reason });
+  }
+  async sendNow(draftId) {
+    const draft = await this.EmailDraft.findById(draftId);
+    if (!draft) throw new DraftNotFoundError(draftId);
+    await this.EmailDraft.findByIdAndUpdate(draftId, {
+      $set: {
+        status: DRAFT_STATUS.Approved,
+        approvedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    await this.queueService.enqueueApproval({ draftId });
+    this.logger.info("Draft sent immediately", { draftId });
+  }
+  async updateContent(draftId, content) {
+    const updates = {};
+    if (content.subject !== void 0) updates.subject = content.subject;
+    if (content.htmlBody !== void 0) updates.htmlBody = content.htmlBody;
+    if (content.textBody !== void 0) updates.textBody = content.textBody;
+    const draft = await this.EmailDraft.findByIdAndUpdate(
+      draftId,
+      { $set: updates },
+      { new: true }
+    );
+    if (!draft) throw new DraftNotFoundError(draftId);
+    return draft;
+  }
+  async getDrafts(filters, page = 1, limit = 50) {
+    const query = {};
+    if (filters?.status) query.status = filters.status;
+    const [items, total] = await Promise.all([
+      this.EmailDraft.find(query).sort({ createdAt: -1 }).skip((page - 1) * limit).limit(limit),
+      this.EmailDraft.countDocuments(query)
+    ]);
+    return { items, total };
+  }
+  async getDraftById(draftId) {
+    return this.EmailDraft.findById(draftId);
+  }
+  async countByStatus() {
+    const counts = await this.EmailDraft.aggregate([
+      { $group: { _id: "$status", count: { $sum: 1 } } }
+    ]);
+    const result = {};
+    for (const entry of counts) {
+      result[entry._id] = entry.count;
+    }
+    return result;
+  }
+  async calculateScheduledTime(index, total) {
+    const globalSettings = await this.settings.get();
+    const approval = globalSettings.approval;
+    if (!approval.sendWindow) {
+      return /* @__PURE__ */ new Date();
+    }
+    const now = /* @__PURE__ */ new Date();
+    const tz = approval.sendWindow.timezone || globalSettings.timezone || "UTC";
+    const currentHour = parseInt(
+      now.toLocaleString("en-US", { timeZone: tz, hour: "numeric", hour12: false }),
+      10
+    );
+    let scheduledDate = new Date(now);
+    if (currentHour < approval.sendWindow.startHour) {
+      const diff = approval.sendWindow.startHour - currentHour;
+      scheduledDate = new Date(now.getTime() + diff * 60 * 60 * 1e3);
+    } else if (currentHour >= approval.sendWindow.endHour) {
+      const hoursUntilNextStart = 24 - currentHour + approval.sendWindow.startHour;
+      scheduledDate = new Date(now.getTime() + hoursUntilNextStart * 60 * 60 * 1e3);
+    }
+    if (total <= 1) return scheduledDate;
+    const maxSpreadMs = approval.maxSpreadMinutes * 60 * 1e3;
+    if (approval.spreadStrategy === "even") {
+      const interval = total > 1 ? maxSpreadMs / (total - 1) : 0;
+      return new Date(scheduledDate.getTime() + index * interval);
+    }
+    const randomDelay = Math.floor(Math.random() * maxSpreadMs);
+    return new Date(scheduledDate.getTime() + randomDelay);
+  }
+};
+
+// src/services/imap-bounce-checker.ts
+var BOUNCE_PATTERNS = [
+  { pattern: /recipient inbox full|mailbox full|mail box full|delivery incomplete/i, type: BOUNCE_TYPE.InboxFull },
+  { pattern: /address not found|user unknown|no such user|does not exist|invalid address|message blocked/i, type: BOUNCE_TYPE.InvalidEmail }
+];
+var ImapBounceChecker = class {
+  constructor(EmailAccount, healthTracker, identifierService, settings, logger, hooks) {
+    this.EmailAccount = EmailAccount;
+    this.healthTracker = healthTracker;
+    this.identifierService = identifierService;
+    this.settings = settings;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  polling = null;
+  async start() {
+    const globalSettings = await this.settings.get();
+    if (!globalSettings.imap.enabled) {
+      this.logger.info("IMAP bounce checker disabled");
+      return;
+    }
+    const intervalMs = globalSettings.imap.pollIntervalMs || 3e5;
+    this.polling = setInterval(async () => {
+      try {
+        await this.checkNow();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        this.logger.error("IMAP polling error", { error: msg });
+      }
+    }, intervalMs);
+    this.logger.info("IMAP bounce checker started", { intervalMs });
+  }
+  stop() {
+    if (this.polling) {
+      clearInterval(this.polling);
+      this.polling = null;
+      this.logger.info("IMAP bounce checker stopped");
+    }
+  }
+  async checkNow() {
+    const accounts = await this.EmailAccount.find({
+      provider: ACCOUNT_PROVIDER.Gmail,
+      status: { $in: [ACCOUNT_STATUS.Active, ACCOUNT_STATUS.Warmup] },
+      "imap.host": { $exists: true }
+    });
+    this.logger.info("IMAP bounce check starting", { accounts: accounts.length });
+    for (const account of accounts) {
+      try {
+        await this.checkAccount(account._id.toString());
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        this.logger.error("IMAP check failed for account", {
+          accountId: account._id.toString(),
+          error: msg
+        });
+      }
+    }
+  }
+  async checkAccount(accountId) {
+    let ImapFlow;
+    try {
+      ImapFlow = (await import('imapflow')).ImapFlow;
+    } catch {
+      this.logger.warn("imapflow package not installed, skipping IMAP check");
+      return { bouncesFound: 0 };
+    }
+    const account = await this.EmailAccount.findById(accountId);
+    if (!account) return { bouncesFound: 0 };
+    const acct = account;
+    if (!acct.imap?.host || !acct.imap?.user || !acct.imap?.pass) {
+      return { bouncesFound: 0 };
+    }
+    const globalSettings = await this.settings.get();
+    const bounceSenders = globalSettings.imap.bounceSenders || ["mailer-daemon@googlemail.com"];
+    const client = new ImapFlow({
+      host: acct.imap.host,
+      port: acct.imap.port || 993,
+      secure: true,
+      auth: {
+        user: acct.imap.user,
+        pass: acct.imap.pass
+      },
+      logger: false
+    });
+    let bouncesFound = 0;
+    try {
+      await client.connect();
+      const lock = await client.getMailboxLock("INBOX");
+      try {
+        const searchDate = this.getSearchDate(globalSettings.imap.searchSince, acct.lastImapCheckAt);
+        const senderQuery = bounceSenders.map((s) => ({ from: s }));
+        const messages = client.fetch(
+          {
+            or: senderQuery,
+            since: searchDate
+          },
+          { source: true }
+        );
+        for await (const msg of messages) {
+          try {
+            const source = msg.source?.toString() || "";
+            const recipientMatch = source.match(
+              /Original-Recipient:.*?;?\s*<?([^\s<>]+@[^\s<>]+)>?/i
+            ) || source.match(
+              /Final-Recipient:.*?;?\s*<?([^\s<>]+@[^\s<>]+)>?/i
+            ) || source.match(
+              /was\s+not\s+delivered\s+to\s+<?([^\s<>]+@[^\s<>]+)>?/i
+            );
+            if (!recipientMatch) continue;
+            const recipientEmail = recipientMatch[1].toLowerCase();
+            const bounceType = this.classifyBounce(source);
+            await this.identifierService.markBounced(recipientEmail, bounceType);
+            await this.healthTracker.recordBounce(accountId, recipientEmail, bounceType);
+            this.hooks?.onBounce?.({
+              accountId,
+              email: recipientEmail,
+              bounceType,
+              provider: ACCOUNT_PROVIDER.Gmail
+            });
+            bouncesFound++;
+          } catch (err) {
+            const msg2 = err instanceof Error ? err.message : "Unknown error";
+            this.logger.warn("Failed to parse bounce message", { error: msg2 });
+          }
+        }
+      } finally {
+        lock.release();
+      }
+      await client.logout();
+      await this.EmailAccount.findByIdAndUpdate(accountId, {
+        $set: { lastImapCheckAt: /* @__PURE__ */ new Date() }
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      this.logger.error("IMAP connection failed", { accountId, error: msg });
+      try {
+        await client.logout();
+      } catch {
+      }
+    }
+    this.logger.info("IMAP bounce check completed", { accountId, bouncesFound });
+    return { bouncesFound };
+  }
+  classifyBounce(messageBody) {
+    for (const { pattern, type } of BOUNCE_PATTERNS) {
+      if (pattern.test(messageBody)) return type;
+    }
+    return BOUNCE_TYPE.Soft;
+  }
+  getSearchDate(searchSince, lastImapCheckAt) {
+    const now = /* @__PURE__ */ new Date();
+    const fallback24h = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
+    switch (searchSince) {
+      case "last_24h":
+        return fallback24h;
+      case "last_7d":
+        return new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+      case "last_check":
+        return lastImapCheckAt ? new Date(lastImapCheckAt) : fallback24h;
+      default:
+        return fallback24h;
+    }
+  }
+};
+var SNS_SIGNATURE_KEYS = [
+  "Message",
+  "MessageId",
+  "Subject",
+  "SubscribeURL",
+  "Timestamp",
+  "Token",
+  "TopicArn",
+  "Type"
+];
+var SesWebhookHandler = class {
+  constructor(healthTracker, identifierService, EmailAccount, config, logger, hooks) {
+    this.healthTracker = healthTracker;
+    this.identifierService = identifierService;
+    this.EmailAccount = EmailAccount;
+    this.config = config;
+    this.logger = logger;
+    this.hooks = hooks;
+  }
+  async handleSnsMessage(body) {
+    const message = this.parseBody(body);
+    if (!message || !message.Type) {
+      return { processed: false, error: "Invalid SNS message format" };
+    }
+    const validateSignature = this.config.options?.ses?.validateSignature !== false;
+    if (validateSignature && message.SignatureVersion) {
+      const valid = await this.validateSignature(message);
+      if (!valid) {
+        throw new SnsSignatureError();
+      }
+    }
+    const allowedTopics = this.config.options?.ses?.allowedTopicArns;
+    if (allowedTopics?.length && !allowedTopics.includes(message.TopicArn)) {
+      return { processed: false, error: "Topic ARN not allowed" };
+    }
+    if (message.Type === SNS_MESSAGE_TYPE.SubscriptionConfirmation) {
+      return this.handleSubscriptionConfirmation(message);
+    }
+    if (message.Type === SNS_MESSAGE_TYPE.UnsubscribeConfirmation) {
+      return { processed: true, type: "unsubscribe_confirmed" };
+    }
+    if (message.Type === SNS_MESSAGE_TYPE.Notification) {
+      const notification = JSON.parse(message.Message);
+      return this.processNotification(notification);
+    }
+    return { processed: true, type: "ignored" };
+  }
+  async handleSubscriptionConfirmation(message) {
+    if (!message.SubscribeURL) {
+      return { processed: false, error: "No SubscribeURL provided" };
+    }
+    try {
+      const url = new URL(message.SubscribeURL);
+      if (!url.hostname.endsWith(".amazonaws.com")) {
+        this.logger.warn("Rejected SubscribeURL with non-AWS hostname", {
+          hostname: url.hostname
+        });
+        return { processed: false, error: "SubscribeURL hostname is not from amazonaws.com" };
+      }
+    } catch {
+      return { processed: false, error: "Invalid SubscribeURL" };
+    }
+    return new Promise((resolve) => {
+      https__default.default.get(message.SubscribeURL, (res) => {
+        resolve({
+          processed: res.statusCode === 200,
+          type: "subscription_confirmed"
+        });
+      }).on("error", (err) => {
+        resolve({ processed: false, error: err.message });
+      });
+    });
+  }
+  async processNotification(notification) {
+    const accountId = await this.findAccountIdBySource(notification.mail.source);
+    switch (notification.notificationType) {
+      case SES_NOTIFICATION_TYPE.Bounce:
+        return this.processBounce(accountId, notification.bounce);
+      case SES_NOTIFICATION_TYPE.Complaint:
+        return this.processComplaint(accountId, notification.complaint);
+      case SES_NOTIFICATION_TYPE.Delivery:
+        if (notification.delivery) {
+          for (const recipient of notification.delivery.recipients) {
+            this.hooks?.onDelivery?.({ accountId: accountId || "", email: recipient });
+          }
+        }
+        return { processed: true, type: "delivery" };
+      case SES_NOTIFICATION_TYPE.Open:
+        if (notification.open) {
+          const recipients = notification.mail.destination || [];
+          for (const email of recipients) {
+            this.hooks?.onOpen?.({
+              accountId: accountId || "",
+              email,
+              timestamp: new Date(notification.open.timestamp)
+            });
+          }
+        }
+        return { processed: true, type: "open" };
+      case SES_NOTIFICATION_TYPE.Click:
+        if (notification.click) {
+          const recipients = notification.mail.destination || [];
+          for (const email of recipients) {
+            this.hooks?.onClick?.({
+              accountId: accountId || "",
+              email,
+              link: notification.click.link
+            });
+          }
+        }
+        return { processed: true, type: "click" };
+      default:
+        return { processed: true, type: "unknown" };
+    }
+  }
+  async processBounce(accountId, bounce) {
+    const bounceType = bounce.bounceType === SES_BOUNCE_TYPE.Permanent ? BOUNCE_TYPE.Hard : BOUNCE_TYPE.Soft;
+    for (const recipient of bounce.bouncedRecipients) {
+      const email = recipient.emailAddress;
+      if (bounce.bounceType === SES_BOUNCE_TYPE.Permanent) {
+        const subType = bounce.bounceSubType?.toLowerCase();
+        if (subType === "noemail" || subType === "general") {
+          await this.identifierService.updateStatus(email, IDENTIFIER_STATUS.Invalid);
+        } else {
+          await this.identifierService.markBounced(email, BOUNCE_TYPE.Hard);
+        }
+      } else {
+        if (bounce.bounceSubType?.toLowerCase() === "mailboxfull") {
+          await this.identifierService.markBounced(email, BOUNCE_TYPE.InboxFull);
+        } else {
+          await this.identifierService.markBounced(email, BOUNCE_TYPE.Soft);
+        }
+      }
+      if (accountId) {
+        await this.healthTracker.recordBounce(accountId, email, bounceType);
+      }
+      this.hooks?.onBounce?.({
+        accountId: accountId || "",
+        email,
+        bounceType,
+        provider: ACCOUNT_PROVIDER.Ses
+      });
+    }
+    return { processed: true, type: "bounce" };
+  }
+  async processComplaint(accountId, complaint) {
+    for (const recipient of complaint.complainedRecipients) {
+      await this.identifierService.updateStatus(
+        recipient.emailAddress,
+        IDENTIFIER_STATUS.Blocked
+      );
+      this.hooks?.onComplaint?.({
+        accountId: accountId || "",
+        email: recipient.emailAddress
+      });
+    }
+    return { processed: true, type: "complaint" };
+  }
+  async validateSignature(message) {
+    try {
+      if (message.SignatureVersion !== "1") return false;
+      const certificate = await this.fetchCertificate(message.SigningCertURL);
+      const parts = [];
+      const record = message;
+      for (const key of SNS_SIGNATURE_KEYS) {
+        const value = record[key];
+        if (value !== void 0 && value !== null) {
+          parts.push(key);
+          parts.push(String(value));
+        }
+      }
+      const stringToSign = parts.join("\n") + "\n";
+      const verifier = crypto__default.default.createVerify("SHA1");
+      verifier.update(stringToSign, "utf8");
+      const signatureBuffer = Buffer.from(message.Signature, "base64");
+      return verifier.verify(certificate, signatureBuffer);
+    } catch {
+      return false;
+    }
+  }
+  async fetchCertificate(certUrl) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(certUrl);
+      if (!url.hostname.endsWith(".amazonaws.com")) {
+        return reject(new Error("Invalid certificate URL: not from amazonaws.com"));
+      }
+      if (url.protocol !== "https:") {
+        return reject(new Error("Invalid certificate URL: must be HTTPS"));
+      }
+      https__default.default.get(certUrl, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve(data));
+        res.on("error", reject);
+      }).on("error", reject);
+    });
+  }
+  parseBody(rawBody) {
+    if (typeof rawBody === "string") {
+      return JSON.parse(rawBody);
+    }
+    return rawBody;
+  }
+  async findAccountIdBySource(source) {
+    const email = source.replace(/.*<(.+)>/, "$1").toLowerCase();
+    const account = await this.EmailAccount.findOne({ email });
+    return account ? account._id.toString() : null;
+  }
+};
+
+// src/queues/send.queue.ts
+function createSendProcessor(smtpService, logger) {
+  return async (job) => {
+    const { accountId, to, subject, html, text: text2, unsubscribeUrl } = job.data;
+    logger.info("Processing send job", { jobId: job.id, accountId, to });
+    const result = await smtpService.executeSend(accountId, to, subject, html, text2, unsubscribeUrl);
+    if (!result.success) {
+      throw new Error(result.error || "Send failed");
+    }
+  };
+}
+
+// src/queues/approval.queue.ts
+function createApprovalProcessor(EmailDraft, smtpService, queueService, logger) {
+  return async (job) => {
+    const { draftId } = job.data;
+    const draft = await EmailDraft.findById(draftId);
+    if (!draft) {
+      logger.warn("Approval job: draft not found", { draftId });
+      return;
+    }
+    const d = draft;
+    if (d.status !== DRAFT_STATUS.Approved) {
+      logger.warn("Approval job: draft not in approved status", { draftId, status: d.status });
+      return;
+    }
+    logger.info("Processing approved draft", { draftId, to: d.to });
+    await EmailDraft.findByIdAndUpdate(draftId, {
+      $set: { status: DRAFT_STATUS.Queued }
+    });
+    await queueService.enqueueSend({
+      accountId: d.accountId.toString(),
+      to: d.to,
+      subject: d.subject,
+      html: d.htmlBody,
+      text: d.textBody || ""
+    });
+  };
+}
+
+// src/controllers/account.controller.ts
+function createAccountController(EmailAccount, capacityManager, healthTracker, warmupManager, smtpService, imapBounceChecker, config) {
+  return {
+    async list(req, res) {
+      try {
+        const accounts = await EmailAccount.find().select("-smtp.pass -imap.pass").sort({ createdAt: -1 });
+        res.json({ success: true, data: { accounts } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getById(req, res) {
+      try {
+        const account = await EmailAccount.findById(req.params.id).select("-smtp.pass -imap.pass");
+        if (!account) {
+          return res.status(404).json({ success: false, error: "Account not found" });
+        }
+        res.json({ success: true, data: { account } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async create(req, res) {
+      try {
+        const input = req.body;
+        if (!input.email || !input.senderName) {
+          return res.status(400).json({ success: false, error: "email and senderName are required" });
+        }
+        const existing = await EmailAccount.findOne({ email: input.email.toLowerCase() });
+        if (existing) {
+          return res.status(400).json({ success: false, error: "Email account already exists" });
+        }
+        const healthDefaults = config.options?.healthDefaults;
+        const warmupDefaults = config.options?.warmup?.defaultSchedule;
+        const accountData = {
+          email: input.email.toLowerCase(),
+          senderName: input.senderName,
+          provider: input.provider,
+          smtp: input.smtp,
+          ...input.imap ? { imap: input.imap } : {},
+          ...input.ses ? { ses: input.ses } : {},
+          limits: { dailyMax: input.limits?.dailyMax || 450 },
+          health: {
+            score: 100,
+            consecutiveErrors: 0,
+            bounceCount: 0,
+            thresholds: {
+              minScore: input.health?.thresholds?.minScore ?? healthDefaults?.minScore ?? 50,
+              maxBounceRate: input.health?.thresholds?.maxBounceRate ?? healthDefaults?.maxBounceRate ?? 5,
+              maxConsecutiveErrors: input.health?.thresholds?.maxConsecutiveErrors ?? healthDefaults?.maxConsecutiveErrors ?? 10
+            }
+          },
+          warmup: {
+            enabled: true,
+            startedAt: /* @__PURE__ */ new Date(),
+            currentDay: 1,
+            schedule: input.warmup?.schedule || warmupDefaults || []
+          },
+          status: "warmup",
+          totalEmailsSent: 0
+        };
+        const account = await EmailAccount.create(accountData);
+        const saved = account.toObject();
+        delete saved.smtp?.pass;
+        delete saved.imap?.pass;
+        res.status(201).json({ success: true, data: { account: saved } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async update(req, res) {
+      try {
+        const input = req.body;
+        const updates = {};
+        if (input.senderName !== void 0) updates.senderName = input.senderName;
+        if (input.status !== void 0) updates.status = input.status;
+        if (input.smtp) {
+          for (const [k, v] of Object.entries(input.smtp)) {
+            if (v !== void 0 && (k !== "pass" || v !== "")) updates[`smtp.${k}`] = v;
+          }
+        }
+        if (input.imap) {
+          for (const [k, v] of Object.entries(input.imap)) {
+            if (v !== void 0 && (k !== "pass" || v !== "")) updates[`imap.${k}`] = v;
+          }
+        }
+        if (input.ses) {
+          for (const [k, v] of Object.entries(input.ses)) {
+            if (v !== void 0) updates[`ses.${k}`] = v;
+          }
+        }
+        if (input.limits?.dailyMax !== void 0) updates["limits.dailyMax"] = input.limits.dailyMax;
+        const account = await EmailAccount.findByIdAndUpdate(
+          req.params.id,
+          { $set: updates },
+          { new: true }
+        ).select("-smtp.pass -imap.pass");
+        if (!account) {
+          return res.status(404).json({ success: false, error: "Account not found" });
+        }
+        res.json({ success: true, data: { account } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async remove(req, res) {
+      try {
+        const result = await EmailAccount.findByIdAndDelete(req.params.id);
+        if (!result) {
+          return res.status(404).json({ success: false, error: "Account not found" });
+        }
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async bulkUpdate(req, res) {
+      try {
+        const { accountIds, updates } = req.body;
+        if (!Array.isArray(accountIds) || accountIds.length === 0) {
+          return res.status(400).json({ success: false, error: "accountIds array is required" });
+        }
+        const allowed = {};
+        if (updates?.status !== void 0) allowed.status = updates.status;
+        if (updates?.dailyMax !== void 0) allowed["limits.dailyMax"] = updates.dailyMax;
+        if (Object.keys(allowed).length === 0) {
+          return res.status(400).json({ success: false, error: "No valid updates provided" });
+        }
+        const result = await EmailAccount.updateMany(
+          { _id: { $in: accountIds } },
+          { $set: allowed }
+        );
+        res.json({ success: true, data: { matched: result.matchedCount, modified: result.modifiedCount } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getCapacity(_req, res) {
+      try {
+        const result = await capacityManager.getAllCapacity();
+        res.json({ success: true, data: result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getHealth(_req, res) {
+      try {
+        const accounts = await healthTracker.getAllHealth();
+        res.json({ success: true, data: { accounts } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getWarmupStatus(_req, res) {
+      try {
+        const accounts = await EmailAccount.find({ "warmup.enabled": true });
+        const statuses = await Promise.all(
+          accounts.map((a) => warmupManager.getStatus(a._id.toString()))
+        );
+        res.json({ success: true, data: { accounts: statuses.filter(Boolean) } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async testConnection(req, res) {
+      try {
+        const result = await smtpService.testConnection(req.params.id);
+        res.json({ success: true, data: result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async checkBounces(req, res) {
+      try {
+        if (!imapBounceChecker) {
+          return res.status(400).json({ success: false, error: "IMAP bounce checker not available" });
+        }
+        const result = await imapBounceChecker.checkAccount(req.params.id);
+        res.json({ success: true, data: result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getWarmup(req, res) {
+      try {
+        const status = await warmupManager.getStatus(req.params.id);
+        if (!status) {
+          return res.status(404).json({ success: false, error: "Account not found" });
+        }
+        res.json({ success: true, data: status });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateWarmupSchedule(req, res) {
+      try {
+        const { schedule } = req.body;
+        if (!Array.isArray(schedule)) {
+          return res.status(400).json({ success: false, error: "schedule array is required" });
+        }
+        await warmupManager.updateSchedule(req.params.id, schedule);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async startWarmup(req, res) {
+      try {
+        await warmupManager.startWarmup(req.params.id);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async completeWarmup(req, res) {
+      try {
+        await warmupManager.completeWarmup(req.params.id);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async resetWarmup(req, res) {
+      try {
+        await warmupManager.resetWarmup(req.params.id);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateHealthThresholds(req, res) {
+      try {
+        const { thresholds } = req.body;
+        if (!thresholds || typeof thresholds !== "object") {
+          return res.status(400).json({ success: false, error: "thresholds object is required" });
+        }
+        const updates = {};
+        if (thresholds.minScore !== void 0) updates["health.thresholds.minScore"] = thresholds.minScore;
+        if (thresholds.maxBounceRate !== void 0) updates["health.thresholds.maxBounceRate"] = thresholds.maxBounceRate;
+        if (thresholds.maxConsecutiveErrors !== void 0) updates["health.thresholds.maxConsecutiveErrors"] = thresholds.maxConsecutiveErrors;
+        const account = await EmailAccount.findByIdAndUpdate(
+          req.params.id,
+          { $set: updates },
+          { new: true }
+        ).select("-smtp.pass -imap.pass");
+        if (!account) {
+          return res.status(404).json({ success: false, error: "Account not found" });
+        }
+        res.json({ success: true, data: { account } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    }
+  };
+}
+
+// src/controllers/identifier.controller.ts
+function createIdentifierController(identifierService) {
+  return {
+    async list(req, res) {
+      try {
+        const status = req.query.status;
+        const page = parseInt(req.query.page, 10) || 1;
+        const limit = parseInt(req.query.limit, 10) || 50;
+        const result = await identifierService.list(
+          status ? { status } : void 0,
+          page,
+          limit
+        );
+        res.json({ success: true, data: result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getByEmail(req, res) {
+      try {
+        const identifier = await identifierService.findByEmail(req.params.email);
+        if (!identifier) {
+          return res.status(404).json({ success: false, error: "Identifier not found" });
+        }
+        res.json({ success: true, data: { identifier } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateStatus(req, res) {
+      try {
+        const { status } = req.body;
+        if (!status) {
+          return res.status(400).json({ success: false, error: "status is required" });
+        }
+        await identifierService.updateStatus(req.params.email, status);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async merge(req, res) {
+      try {
+        const { sourceEmail, targetEmail } = req.body;
+        if (!sourceEmail || !targetEmail) {
+          return res.status(400).json({ success: false, error: "sourceEmail and targetEmail are required" });
+        }
+        await identifierService.merge(sourceEmail, targetEmail);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    }
+  };
+}
+
+// src/controllers/approval.controller.ts
+function createApprovalController(approvalService) {
+  return {
+    async getDrafts(req, res) {
+      try {
+        const status = req.query.status;
+        const page = parseInt(req.query.page, 10) || 1;
+        const limit = parseInt(req.query.limit, 10) || 50;
+        const result = await approvalService.getDrafts(
+          status ? { status } : void 0,
+          page,
+          limit
+        );
+        res.json({ success: true, data: result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getDraftById(req, res) {
+      try {
+        const draft = await approvalService.getDraftById(req.params.id);
+        if (!draft) {
+          return res.status(404).json({ success: false, error: "Draft not found" });
+        }
+        res.json({ success: true, data: { draft } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async countByStatus(_req, res) {
+      try {
+        const counts = await approvalService.countByStatus();
+        res.json({ success: true, data: counts });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async approve(req, res) {
+      try {
+        await approvalService.approve(req.params.id);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async reject(req, res) {
+      try {
+        const { reason } = req.body;
+        await approvalService.reject(req.params.id, reason);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async sendNow(req, res) {
+      try {
+        await approvalService.sendNow(req.params.id);
+        res.json({ success: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateContent(req, res) {
+      try {
+        const draft = await approvalService.updateContent(req.params.id, req.body);
+        res.json({ success: true, data: { draft } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async bulkApprove(req, res) {
+      try {
+        const { draftIds } = req.body;
+        if (!Array.isArray(draftIds) || draftIds.length === 0) {
+          return res.status(400).json({ success: false, error: "draftIds array is required" });
+        }
+        await approvalService.bulkApprove(draftIds);
+        res.json({ success: true, data: { approved: draftIds.length } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async bulkReject(req, res) {
+      try {
+        const { draftIds, reason } = req.body;
+        if (!Array.isArray(draftIds) || draftIds.length === 0) {
+          return res.status(400).json({ success: false, error: "draftIds array is required" });
+        }
+        await approvalService.bulkReject(draftIds, reason);
+        res.json({ success: true, data: { rejected: draftIds.length } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    }
+  };
+}
+
+// src/controllers/settings.controller.ts
+function createSettingsController(settingsService) {
+  return {
+    async getSettings(_req, res) {
+      try {
+        const settings = await settingsService.get();
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateSettings(req, res) {
+      try {
+        const settings = await settingsService.update(req.body);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateTimezone(req, res) {
+      try {
+        const settings = await settingsService.updateSection("timezone", req.body.timezone);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateDevMode(req, res) {
+      try {
+        const settings = await settingsService.updateSection("devMode", req.body);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateImap(req, res) {
+      try {
+        const settings = await settingsService.updateSection("imap", req.body);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateApproval(req, res) {
+      try {
+        const settings = await settingsService.updateSection("approval", req.body);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateQueues(req, res) {
+      try {
+        const settings = await settingsService.updateSection("queues", req.body);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async updateSes(req, res) {
+      try {
+        const settings = await settingsService.updateSection("ses", req.body);
+        res.json({ success: true, data: { settings } });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    }
+  };
+}
+
+// src/controllers/unsubscribe.controller.ts
+function createUnsubscribeController(unsubscribeService) {
+  return {
+    async handleGet(req, res) {
+      try {
+        const token = req.query.token;
+        if (!token) {
+          const html2 = unsubscribeService.getConfirmationHtml("", false);
+          return res.status(400).type("html").send(html2);
+        }
+        const result = await unsubscribeService.handleUnsubscribe("", token);
+        const html = unsubscribeService.getConfirmationHtml(result.email || "", result.success);
+        res.status(200).type("html").send(html);
+      } catch {
+        const html = unsubscribeService.getConfirmationHtml("", false);
+        res.status(500).type("html").send(html);
+      }
+    },
+    async handlePost(req, res) {
+      try {
+        const token = req.query.token || req.body?.token;
+        if (!token) {
+          return res.status(400).json({ success: false, error: "Missing token" });
+        }
+        const result = await unsubscribeService.handleUnsubscribe("", token);
+        res.json({ success: result.success, error: result.error });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    }
+  };
+}
+function createAdminRoutes(deps) {
+  const router = express.Router();
+  const {
+    accountController,
+    identifierController,
+    approvalController,
+    settingsController,
+    queueService
+  } = deps;
+  router.get("/accounts", accountController.list);
+  router.post("/accounts", accountController.create);
+  router.get("/accounts/capacity", accountController.getCapacity);
+  router.get("/accounts/health", accountController.getHealth);
+  router.get("/accounts/warmup", accountController.getWarmupStatus);
+  router.patch("/accounts/bulk-update", accountController.bulkUpdate);
+  router.get("/accounts/:id", accountController.getById);
+  router.put("/accounts/:id", accountController.update);
+  router.delete("/accounts/:id", accountController.remove);
+  router.post("/accounts/:id/test", accountController.testConnection);
+  router.post("/accounts/:id/check-bounces", accountController.checkBounces);
+  router.get("/accounts/:id/warmup", accountController.getWarmup);
+  router.put("/accounts/:id/warmup/schedule", accountController.updateWarmupSchedule);
+  router.post("/accounts/:id/warmup/start", accountController.startWarmup);
+  router.post("/accounts/:id/warmup/complete", accountController.completeWarmup);
+  router.post("/accounts/:id/warmup/reset", accountController.resetWarmup);
+  router.put("/accounts/:id/health/thresholds", accountController.updateHealthThresholds);
+  router.get("/identifiers", identifierController.list);
+  router.get("/identifiers/:email", identifierController.getByEmail);
+  router.patch("/identifiers/:email/status", identifierController.updateStatus);
+  router.post("/identifiers/merge", identifierController.merge);
+  router.get("/drafts", approvalController.getDrafts);
+  router.get("/drafts/count", approvalController.countByStatus);
+  router.post("/drafts/bulk-approve", approvalController.bulkApprove);
+  router.post("/drafts/bulk-reject", approvalController.bulkReject);
+  router.get("/drafts/:id", approvalController.getDraftById);
+  router.patch("/drafts/:id/approve", approvalController.approve);
+  router.patch("/drafts/:id/reject", approvalController.reject);
+  router.post("/drafts/:id/send-now", approvalController.sendNow);
+  router.patch("/drafts/:id/content", approvalController.updateContent);
+  router.get("/settings", settingsController.getSettings);
+  router.put("/settings", settingsController.updateSettings);
+  router.patch("/settings/timezone", settingsController.updateTimezone);
+  router.patch("/settings/dev-mode", settingsController.updateDevMode);
+  router.patch("/settings/imap", settingsController.updateImap);
+  router.patch("/settings/approval", settingsController.updateApproval);
+  router.patch("/settings/queues", settingsController.updateQueues);
+  router.patch("/settings/ses", settingsController.updateSes);
+  router.get("/queues/stats", async (_req, res) => {
+    try {
+      const stats = await queueService.getStats();
+      res.json({ success: true, data: stats });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      res.status(500).json({ success: false, error: message });
+    }
+  });
+  return router;
+}
+function createSesWebhookRoutes(handler) {
+  const router = express.Router();
+  router.use(express.text({ type: "*/*" }));
+  router.use(express.json({ type: "application/json" }));
+  router.post("/", async (req, res) => {
+    try {
+      const body = typeof req.body === "string" ? JSON.parse(req.body) : req.body;
+      const result = await handler.handleSnsMessage(body);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      const status = message.includes("signature") ? 403 : 500;
+      res.status(status).json({ success: false, error: message });
+    }
+  });
+  return router;
+}
+function createUnsubscribeRoutes(controller) {
+  const router = express.Router();
+  router.get("/", controller.handleGet);
+  router.post("/", controller.handlePost);
+  return router;
+}
+
+// src/index.ts
+var noopLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function createEmailAccountManager(config) {
+  validateConfig(config);
+  const conn = config.db.connection;
+  const prefix = config.db.collectionPrefix || "";
+  const logger = config.logger || noopLogger;
+  const hooks = config.hooks;
+  const EmailAccount = conn.model(
+    `${prefix}EmailAccount`,
+    createEmailAccountSchema()
+  );
+  const EmailDailyStats = conn.model(
+    `${prefix}EmailDailyStats`,
+    createEmailDailyStatsSchema()
+  );
+  const EmailIdentifier = conn.model(
+    `${prefix}EmailIdentifier`,
+    createEmailIdentifierSchema()
+  );
+  const EmailDraft = conn.model(
+    `${prefix}EmailDraft`,
+    createEmailDraftSchema()
+  );
+  const GlobalSettings = conn.model(
+    `${prefix}GlobalSettings`,
+    createGlobalSettingsSchema()
+  );
+  const settingsService = new SettingsService(GlobalSettings, logger);
+  const identifierService = new IdentifierService(EmailIdentifier, logger, hooks);
+  const healthTracker = new HealthTracker(
+    EmailAccount,
+    EmailDailyStats,
+    settingsService,
+    logger,
+    hooks
+  );
+  const warmupManager = new WarmupManager(EmailAccount, config, logger, hooks);
+  const capacityManager = new CapacityManager(
+    EmailAccount,
+    EmailDailyStats,
+    warmupManager,
+    settingsService,
+    logger
+  );
+  const unsubscribeService = new UnsubscribeService(EmailIdentifier, config, logger, hooks);
+  const queueService = new QueueService(
+    config.redis.connection,
+    config,
+    settingsService,
+    logger
+  );
+  const smtpService = new SmtpService(
+    EmailAccount,
+    capacityManager,
+    healthTracker,
+    identifierService,
+    unsubscribeService,
+    queueService,
+    settingsService,
+    config,
+    logger,
+    hooks
+  );
+  const approvalService = new ApprovalService(
+    EmailDraft,
+    queueService,
+    settingsService,
+    logger,
+    hooks
+  );
+  const imapBounceChecker = new ImapBounceChecker(
+    EmailAccount,
+    healthTracker,
+    identifierService,
+    settingsService,
+    logger,
+    hooks
+  );
+  const sesWebhookHandler = new SesWebhookHandler(
+    healthTracker,
+    identifierService,
+    EmailAccount,
+    config,
+    logger,
+    hooks
+  );
+  const sendProcessor = createSendProcessor(smtpService, logger);
+  const approvalProcessor = createApprovalProcessor(
+    EmailDraft,
+    smtpService,
+    queueService,
+    logger
+  );
+  queueService.init({ sendProcessor, approvalProcessor }).catch((err) => {
+    logger.error("Failed to initialize queues", {
+      error: err instanceof Error ? err.message : "Unknown error"
+    });
+  });
+  imapBounceChecker.start().catch((err) => {
+    logger.error("Failed to start IMAP bounce checker", {
+      error: err instanceof Error ? err.message : "Unknown error"
+    });
+  });
+  const accountController = createAccountController(
+    EmailAccount,
+    capacityManager,
+    healthTracker,
+    warmupManager,
+    smtpService,
+    imapBounceChecker,
+    config
+  );
+  const identifierController = createIdentifierController(identifierService);
+  const approvalController = createApprovalController(approvalService);
+  const settingsController = createSettingsController(settingsService);
+  const unsubscribeController = createUnsubscribeController(unsubscribeService);
+  const routes = createAdminRoutes({
+    accountController,
+    identifierController,
+    approvalController,
+    settingsController,
+    queueService
+  });
+  const sesWebhookRouter = createSesWebhookRoutes(sesWebhookHandler);
+  const unsubscribeRouter = createUnsubscribeRoutes(unsubscribeController);
+  const accounts = {
+    model: EmailAccount,
+    create: (data) => EmailAccount.create(data),
+    findById: (id) => EmailAccount.findById(id),
+    update: (id, data) => EmailAccount.findByIdAndUpdate(id, { $set: data }, { new: true }),
+    remove: (id) => EmailAccount.findByIdAndDelete(id)
+  };
+  async function destroy() {
+    imapBounceChecker.stop();
+    smtpService.closeAll();
+    await queueService.close();
+    logger.info("EmailAccountManager destroyed");
+  }
+  return {
+    routes,
+    webhookRoutes: { ses: sesWebhookRouter },
+    unsubscribeRoutes: unsubscribeRouter,
+    accounts,
+    capacity: capacityManager,
+    health: healthTracker,
+    warmup: warmupManager,
+    smtp: smtpService,
+    imap: imapBounceChecker,
+    approval: approvalService,
+    unsubscribe: unsubscribeService,
+    identifiers: identifierService,
+    queues: queueService,
+    settings: settingsService,
+    destroy
+  };
+}
+
+exports.ACCOUNT_PROVIDER = ACCOUNT_PROVIDER;
+exports.ACCOUNT_STATUS = ACCOUNT_STATUS;
+exports.AccountDisabledError = AccountDisabledError;
+exports.AccountNotFoundError = AccountNotFoundError;
+exports.AlxAccountError = AlxAccountError;
+exports.ApprovalService = ApprovalService;
+exports.BOUNCE_TYPE = BOUNCE_TYPE;
+exports.CapacityManager = CapacityManager;
+exports.ConfigValidationError = ConfigValidationError;
+exports.DRAFT_STATUS = DRAFT_STATUS;
+exports.DraftNotFoundError = DraftNotFoundError;
+exports.EMAIL_EVENT_TYPE = EMAIL_EVENT_TYPE;
+exports.HealthTracker = HealthTracker;
+exports.IDENTIFIER_STATUS = IDENTIFIER_STATUS;
+exports.IdentifierService = IdentifierService;
+exports.ImapBounceChecker = ImapBounceChecker;
+exports.InvalidTokenError = InvalidTokenError;
+exports.NoAvailableAccountError = NoAvailableAccountError;
+exports.QueueService = QueueService;
+exports.QuotaExceededError = QuotaExceededError;
+exports.SES_BOUNCE_TYPE = SES_BOUNCE_TYPE;
+exports.SES_COMPLAINT_TYPE = SES_COMPLAINT_TYPE;
+exports.SES_NOTIFICATION_TYPE = SES_NOTIFICATION_TYPE;
+exports.SNS_MESSAGE_TYPE = SNS_MESSAGE_TYPE;
+exports.SesWebhookHandler = SesWebhookHandler;
+exports.SettingsService = SettingsService;
+exports.SmtpConnectionError = SmtpConnectionError;
+exports.SmtpService = SmtpService;
+exports.SnsSignatureError = SnsSignatureError;
+exports.UnsubscribeService = UnsubscribeService;
+exports.WarmupManager = WarmupManager;
+exports.createEmailAccountManager = createEmailAccountManager;
+exports.createEmailAccountSchema = createEmailAccountSchema;
+exports.createEmailDailyStatsSchema = createEmailDailyStatsSchema;
+exports.createEmailDraftSchema = createEmailDraftSchema;
+exports.createEmailIdentifierSchema = createEmailIdentifierSchema;
+exports.createGlobalSettingsSchema = createGlobalSettingsSchema;
+exports.validateConfig = validateConfig;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map