@astralibx/email-rule-engine 12.10.1 → 14.0.0

package/dist/index.cjs

@@ -1,403 +1,16 @@
 'use strict';
 
-var mongoose = require('mongoose');
-var Handlebars = require('handlebars');
+var ruleEngine = require('@astralibx/rule-engine');
 var mjml2html = require('mjml');
 var htmlToText = require('html-to-text');
-var core = require('@astralibx/core');
-var crypto = require('crypto');
-var express = require('express');
-var zod = require('zod');
-var bullmq = require('bullmq');
+var Handlebars = require('handlebars');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 var mjml2html__default = /*#__PURE__*/_interopDefault(mjml2html);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-
-// src/schemas/template.schema.ts
-
-// src/constants/field-types.ts
-var FIELD_TYPE = {
-  String: "string",
-  Number: "number",
-  Boolean: "boolean",
-  Date: "date",
-  ObjectId: "objectId",
-  Array: "array",
-  Object: "object"
-};
-var TYPE_OPERATORS = {
-  string: ["eq", "neq", "contains", "in", "not_in", "exists", "not_exists"],
-  number: ["eq", "neq", "gt", "gte", "lt", "lte", "in", "not_in", "exists", "not_exists"],
-  boolean: ["eq", "neq", "exists", "not_exists"],
-  date: ["eq", "neq", "gt", "gte", "lt", "lte", "exists", "not_exists"],
-  objectId: ["eq", "neq", "in", "not_in", "exists", "not_exists"],
-  array: ["contains", "in", "not_in", "exists", "not_exists"],
-  object: ["exists", "not_exists"]
-};
-
-// src/constants/index.ts
-var TEMPLATE_CATEGORY = {
-  Onboarding: "onboarding",
-  Engagement: "engagement",
-  Transactional: "transactional",
-  ReEngagement: "re-engagement",
-  Announcement: "announcement"
-};
-var TEMPLATE_AUDIENCE = {
-  Customer: "customer",
-  Provider: "provider",
-  All: "all"
-};
-var RULE_OPERATOR = {
-  Eq: "eq",
-  Neq: "neq",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-  Exists: "exists",
-  NotExists: "not_exists",
-  In: "in",
-  NotIn: "not_in",
-  Contains: "contains"
-};
-var EMAIL_TYPE = {
-  Automated: "automated",
-  Transactional: "transactional"
-};
-var RUN_TRIGGER = {
-  Cron: "cron",
-  Manual: "manual"
-};
-var THROTTLE_WINDOW = {
-  Rolling: "rolling"
-};
-var EMAIL_SEND_STATUS = {
-  Sent: "sent",
-  Error: "error",
-  Skipped: "skipped",
-  Invalid: "invalid",
-  Throttled: "throttled"
-};
-var TARGET_MODE = {
-  Query: "query",
-  List: "list"
-};
-var RUN_LOG_STATUS = {
-  Completed: "completed",
-  Cancelled: "cancelled",
-  Failed: "failed"
-};
-
-// src/schemas/template.schema.ts
-function createEmailTemplateSchema(platformValues, audienceValues, categoryValues, collectionPrefix) {
-  const schema = new mongoose.Schema(
-    {
-      name: { type: String, required: true },
-      slug: { type: String, required: true, unique: true, maxlength: 200 },
-      description: String,
-      category: { type: String, enum: categoryValues || Object.values(TEMPLATE_CATEGORY), required: true },
-      audience: { type: String, enum: audienceValues || Object.values(TEMPLATE_AUDIENCE), required: true },
-      platform: {
-        type: String,
-        required: true,
-        ...platformValues ? { enum: platformValues } : {}
-      },
-      textBody: String,
-      subjects: { type: [{ type: String }], required: true, validate: [(v) => v.length >= 1, "At least one subject is required"] },
-      bodies: { type: [{ type: String }], required: true, validate: [(v) => v.length >= 1, "At least one body is required"] },
-      preheaders: [{ type: String }],
-      fields: {
-        type: mongoose.Schema.Types.Mixed,
-        default: {},
-        validate: {
-          validator: (v) => {
-            if (!v || typeof v !== "object") return true;
-            return Object.values(v).every((val) => typeof val === "string");
-          },
-          message: "All field values must be strings"
-        }
-      },
-      variables: [{ type: String }],
-      attachments: {
-        type: [{
-          _id: false,
-          filename: { type: String, required: true },
-          url: { type: String, required: true },
-          contentType: { type: String, required: true }
-        }],
-        default: []
-      },
-      version: { type: Number, default: 1 },
-      isActive: { type: Boolean, default: true }
-    },
-    {
-      timestamps: true,
-      collection: `${collectionPrefix || ""}email_templates`,
-      statics: {
-        findBySlug(slug) {
-          return this.findOne({ slug });
-        },
-        findActive() {
-          return this.find({ isActive: true }).sort({ category: 1, name: 1 });
-        },
-        findByCategory(category) {
-          return this.find({ category, isActive: true }).sort({ name: 1 });
-        },
-        findByAudience(audience) {
-          return this.find({
-            $or: [{ audience }, { audience: TEMPLATE_AUDIENCE.All }],
-            isActive: true
-          }).sort({ name: 1 });
-        },
-        async createTemplate(input) {
-          return this.create({
-            name: input.name,
-            slug: input.slug,
-            description: input.description,
-            category: input.category,
-            audience: input.audience,
-            platform: input.platform,
-            textBody: input.textBody,
-            subjects: input.subjects,
-            bodies: input.bodies,
-            preheaders: input.preheaders || [],
-            fields: input.fields || {},
-            variables: input.variables || [],
-            attachments: input.attachments || [],
-            version: 1,
-            isActive: true
-          });
-        }
-      }
-    }
-  );
-  schema.index({ category: 1, isActive: 1 });
-  schema.index({ audience: 1, platform: 1, isActive: 1 });
-  return schema;
-}
-function createRunStatsSchema() {
-  return new mongoose.Schema({
-    matched: { type: Number, default: 0 },
-    sent: { type: Number, default: 0 },
-    skipped: { type: Number, default: 0 },
-    skippedByThrottle: { type: Number, default: 0 },
-    errorCount: { type: Number, default: 0 }
-  }, { _id: false });
-}
+var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 
-// src/schemas/rule.schema.ts
-function createEmailRuleSchema(platformValues, audienceValues, collectionPrefix) {
-  const RuleConditionSchema = new mongoose.Schema({
-    field: { type: String, required: true },
-    operator: { type: String, enum: Object.values(RULE_OPERATOR), required: true },
-    value: { type: mongoose.Schema.Types.Mixed }
-  }, { _id: false });
-  const RuleTargetSchema = new mongoose.Schema({
-    mode: { type: String, enum: Object.values(TARGET_MODE), required: true },
-    role: { type: String, enum: audienceValues || Object.values(TEMPLATE_AUDIENCE) },
-    platform: {
-      type: String,
-      ...platformValues ? { enum: platformValues } : {}
-    },
-    conditions: [RuleConditionSchema],
-    identifiers: [{ type: String }],
-    collectionName: { type: String }
-  }, { _id: false });
-  const RuleRunStatsSchema = createRunStatsSchema();
-  const schema = new mongoose.Schema(
-    {
-      name: { type: String, required: true },
-      description: String,
-      isActive: { type: Boolean, default: false },
-      sortOrder: { type: Number, default: 10 },
-      target: { type: RuleTargetSchema, required: true },
-      templateId: { type: mongoose.Schema.Types.ObjectId, ref: "EmailTemplate", required: true, index: true },
-      sendOnce: { type: Boolean, default: true },
-      resendAfterDays: Number,
-      cooldownDays: Number,
-      autoApprove: { type: Boolean, default: true },
-      maxPerRun: Number,
-      validFrom: { type: Date },
-      validTill: { type: Date },
-      bypassThrottle: { type: Boolean, default: false },
-      throttleOverride: {
-        type: {
-          maxPerUserPerDay: { type: Number },
-          maxPerUserPerWeek: { type: Number },
-          minGapDays: { type: Number }
-        },
-        _id: false,
-        default: void 0
-      },
-      emailType: { type: String, enum: Object.values(EMAIL_TYPE), default: EMAIL_TYPE.Automated },
-      schedule: {
-        type: {
-          enabled: { type: Boolean, default: false },
-          cron: { type: String },
-          timezone: { type: String, default: "UTC" }
-        },
-        _id: false
-      },
-      totalSent: { type: Number, default: 0 },
-      totalSkipped: { type: Number, default: 0 },
-      lastRunAt: Date,
-      lastRunStats: RuleRunStatsSchema
-    },
-    {
-      timestamps: true,
-      collection: `${collectionPrefix || ""}email_rules`,
-      statics: {
-        findActive() {
-          return this.find({ isActive: true }).sort({ sortOrder: 1 });
-        },
-        findByTemplateId(templateId) {
-          return this.find({ templateId });
-        },
-        async createRule(input) {
-          return this.create({
-            name: input.name,
-            description: input.description,
-            isActive: false,
-            sortOrder: input.sortOrder ?? 10,
-            target: input.target,
-            templateId: input.templateId,
-            sendOnce: input.sendOnce ?? true,
-            resendAfterDays: input.resendAfterDays,
-            cooldownDays: input.cooldownDays,
-            autoApprove: input.autoApprove ?? true,
-            maxPerRun: input.maxPerRun,
-            validFrom: input.validFrom,
-            validTill: input.validTill,
-            bypassThrottle: input.bypassThrottle ?? false,
-            throttleOverride: input.throttleOverride,
-            schedule: input.schedule,
-            emailType: input.emailType ?? EMAIL_TYPE.Automated,
-            totalSent: 0,
-            totalSkipped: 0
-          });
-        }
-      }
-    }
-  );
-  schema.index({ isActive: 1, sortOrder: 1 });
-  return schema;
-}
-function createEmailRuleSendSchema(collectionPrefix) {
-  const schema = new mongoose.Schema(
-    {
-      ruleId: { type: mongoose.Schema.Types.ObjectId, ref: "EmailRule", required: true },
-      userId: { type: String, required: true },
-      emailIdentifierId: { type: String },
-      messageId: { type: String },
-      sentAt: { type: Date, required: true, default: () => /* @__PURE__ */ new Date() },
-      status: { type: String },
-      accountId: { type: String },
-      senderName: { type: String },
-      subject: { type: String },
-      subjectIndex: { type: Number },
-      bodyIndex: { type: Number },
-      preheaderIndex: { type: Number },
-      failureReason: { type: String }
-    },
-    {
-      collection: `${collectionPrefix || ""}email_rule_sends`,
-      statics: {
-        findLatestForUser(ruleId, userId) {
-          return this.findOne({ ruleId, userId }).sort({ sentAt: -1 });
-        },
-        findRecentByUserIds(userIds, sinceDays) {
-          const since = new Date(Date.now() - sinceDays * 864e5);
-          return this.find({
-            userId: { $in: userIds },
-            sentAt: { $gte: since }
-          }).sort({ sentAt: -1 });
-        },
-        async logSend(ruleId, userId, emailIdentifierId, messageId, extra) {
-          return this.create({
-            ruleId,
-            userId,
-            emailIdentifierId,
-            messageId,
-            sentAt: /* @__PURE__ */ new Date(),
-            ...extra
-          });
-        }
-      }
-    }
-  );
-  schema.index({ ruleId: 1, userId: 1, sentAt: -1 });
-  schema.index({ userId: 1, sentAt: -1 });
-  schema.index({ ruleId: 1, sentAt: -1 });
-  schema.index({ status: 1, sentAt: -1 });
-  return schema;
-}
-function createEmailRuleRunLogSchema(collectionPrefix) {
-  const baseStatsSchema = createRunStatsSchema();
-  const PerRuleStatsSchema = new mongoose.Schema({
-    ruleId: { type: mongoose.Schema.Types.ObjectId, ref: "EmailRule", required: true },
-    ruleName: { type: String, required: true },
-    ...baseStatsSchema.obj
-  }, { _id: false });
-  const TotalStatsSchema = createRunStatsSchema();
-  const schema = new mongoose.Schema(
-    {
-      runId: { type: String, index: true },
-      runAt: { type: Date, required: true, default: () => /* @__PURE__ */ new Date() },
-      status: { type: String, enum: Object.values(RUN_LOG_STATUS), default: RUN_LOG_STATUS.Completed },
-      triggeredBy: { type: String, enum: Object.values(RUN_TRIGGER), required: true },
-      duration: { type: Number, required: true },
-      rulesProcessed: { type: Number, required: true },
-      totalStats: { type: TotalStatsSchema, required: true },
-      perRuleStats: [PerRuleStatsSchema]
-    },
-    {
-      collection: `${collectionPrefix || ""}email_rule_run_logs`,
-      statics: {
-        getRecent(limit = 20) {
-          return this.find().sort({ runAt: -1 }).limit(limit);
-        },
-        getByRuleId(ruleId, limit = 20) {
-          return this.find({ "perRuleStats.ruleId": ruleId }).sort({ runAt: -1 }).limit(limit);
-        }
-      }
-    }
-  );
-  schema.index({ runAt: -1 }, { expireAfterSeconds: 90 * 86400 });
-  return schema;
-}
-function createEmailThrottleConfigSchema(collectionPrefix) {
-  const schema = new mongoose.Schema(
-    {
-      maxPerUserPerDay: { type: Number, default: 1 },
-      maxPerUserPerWeek: { type: Number, default: 2 },
-      minGapDays: { type: Number, default: 3 },
-      throttleWindow: { type: String, enum: Object.values(THROTTLE_WINDOW), default: THROTTLE_WINDOW.Rolling }
-    },
-    {
-      timestamps: true,
-      collection: `${collectionPrefix || ""}email_throttle_config`,
-      statics: {
-        async getConfig() {
-          let config = await this.findOne();
-          if (!config) {
-            config = await this.create({
-              maxPerUserPerDay: 1,
-              maxPerUserPerWeek: 2,
-              minGapDays: 3,
-              throttleWindow: THROTTLE_WINDOW.Rolling
-            });
-          }
-          return config;
-        }
-      }
-    }
-  );
-  return schema;
-}
+// src/index.ts
 var MJML_BASE_OPEN = `<mjml>
   <mj-head>
     <mj-attributes>
@@ -414,67 +27,19 @@ var MJML_BASE_CLOSE = `        </mj-text>
     </mj-section>
   </mj-body>
 </mjml>`;
-var DATE_FORMAT_OPTIONS = {
-  day: "numeric",
-  month: "short",
-  year: "numeric"
-};
-function registerHelpers() {
-  Handlebars__default.default.registerHelper("currency", (val) => {
-    return `\u20B9${Number(val).toLocaleString("en-IN")}`;
-  });
-  Handlebars__default.default.registerHelper("formatDate", (date) => {
-    const d = new Date(date);
-    return d.toLocaleDateString("en-IN", DATE_FORMAT_OPTIONS);
-  });
-  Handlebars__default.default.registerHelper("capitalize", (str) => {
-    if (!str) return "";
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  Handlebars__default.default.registerHelper("eq", (a, b) => a === b);
-  Handlebars__default.default.registerHelper("neq", (a, b) => a !== b);
-  Handlebars__default.default.registerHelper("not", (val) => !val);
-  Handlebars__default.default.registerHelper("gt", (a, b) => a > b);
-  Handlebars__default.default.registerHelper("lt", (a, b) => a < b);
-  Handlebars__default.default.registerHelper("gte", (a, b) => a >= b);
-  Handlebars__default.default.registerHelper("lte", (a, b) => a <= b);
-  Handlebars__default.default.registerHelper("lowercase", (str) => {
-    return str ? str.toLowerCase() : "";
-  });
-  Handlebars__default.default.registerHelper("uppercase", (str) => {
-    return str ? str.toUpperCase() : "";
-  });
-  Handlebars__default.default.registerHelper("join", (arr, separator) => {
-    if (!Array.isArray(arr)) return "";
-    const sep = typeof separator === "string" ? separator : ", ";
-    return arr.join(sep);
-  });
-  Handlebars__default.default.registerHelper("pluralize", (count, singular, plural) => {
-    return count === 1 ? singular : typeof plural === "string" ? plural : singular + "s";
-  });
-}
-var helpersRegistered = false;
-function ensureHelpers() {
-  if (!helpersRegistered) {
-    registerHelpers();
-    helpersRegistered = true;
-  }
-}
-function wrapInMjml(body) {
-  if (body.trim().startsWith("<mjml")) {
+function renderMjml(body) {
+  if (!body.includes("<mj-") && !body.trim().startsWith("<mjml")) {
     return body;
   }
-  return `${MJML_BASE_OPEN}${body}${MJML_BASE_CLOSE}`;
-}
-function compileMjml(mjmlSource) {
-  const result = mjml2html__default.default(mjmlSource, {
+  const fullMjml = body.trim().startsWith("<mjml") ? body : `${MJML_BASE_OPEN}${body}${MJML_BASE_CLOSE}`;
+  const result = mjml2html__default.default(fullMjml, {
     validationLevel: "soft",
     minify: false
   });
-  if (result.errors && result.errors.length > 0) {
-    const criticalErrors = result.errors.filter((e) => e.tagName !== void 0);
-    if (criticalErrors.length > 0) {
-      throw new Error(`MJML compilation errors: ${criticalErrors.map((e) => e.message).join("; ")}`);
+  if (result.errors?.length) {
+    const critical = result.errors.filter((e) => e.tagName !== void 0);
+    if (critical.length > 0) {
+      throw new Error(`MJML compilation errors: ${critical.map((e) => e.message).join("; ")}`);
     }
   }
   return result.html;
@@ -488,2053 +53,67 @@ function htmlToPlainText(html) {
     ]
   });
 }
-var TemplateRenderService = class {
-  constructor() {
-    ensureHelpers();
-  }
-  renderSingle(subject, body, data, textBody) {
-    const subjectFn = Handlebars__default.default.compile(subject, { strict: false });
-    const resolvedSubject = subjectFn(data);
-    const bodyFn = Handlebars__default.default.compile(body, { strict: false });
-    const resolvedBody = bodyFn(data);
-    const mjmlSource = wrapInMjml(resolvedBody);
-    const html = compileMjml(mjmlSource);
-    let text;
-    if (textBody) {
-      const textFn = Handlebars__default.default.compile(textBody, { strict: false });
-      text = textFn(data);
-    } else {
-      text = htmlToPlainText(html);
-    }
-    return { html, text, subject: resolvedSubject };
-  }
-  compileBatch(subject, body, textBody) {
-    const mjmlSource = wrapInMjml(body);
-    const htmlWithHandlebars = compileMjml(mjmlSource);
-    const subjectFn = Handlebars__default.default.compile(subject, { strict: false });
-    const bodyFn = Handlebars__default.default.compile(htmlWithHandlebars, { strict: false });
-    const textBodyFn = textBody ? Handlebars__default.default.compile(textBody, { strict: false }) : void 0;
-    return { subjectFn, bodyFn, textBodyFn };
-  }
-  compileBatchVariants(subjects, bodies, textBody, preheaders) {
-    const subjectFns = subjects.map((s) => Handlebars__default.default.compile(s, { strict: false }));
-    const bodyFns = bodies.map((b) => {
-      const mjmlSource = wrapInMjml(b);
-      const htmlWithHandlebars = compileMjml(mjmlSource);
-      return Handlebars__default.default.compile(htmlWithHandlebars, { strict: false });
-    });
-    const textBodyFn = textBody ? Handlebars__default.default.compile(textBody, { strict: false }) : void 0;
-    const preheaderFns = preheaders && preheaders.length > 0 ? preheaders.map((p) => Handlebars__default.default.compile(p, { strict: false })) : void 0;
-    return { subjectFns, bodyFns, textBodyFn, preheaderFns };
-  }
-  renderFromCompiled(compiled, data) {
-    const subject = compiled.subjectFn(data);
-    const html = compiled.bodyFn(data);
-    const text = compiled.textBodyFn ? compiled.textBodyFn(data) : htmlToPlainText(html);
-    return { html, text, subject };
-  }
-  renderPreview(subject, body, data, textBody) {
-    const subjectFn = Handlebars__default.default.compile(subject, { strict: false });
-    const resolvedSubject = subjectFn(data);
-    const bodyFn = Handlebars__default.default.compile(body, { strict: false });
-    const resolvedBody = bodyFn(data);
-    const mjmlSource = wrapInMjml(resolvedBody);
-    const html = compileMjml(mjmlSource);
-    let text;
-    if (textBody) {
-      const textFn = Handlebars__default.default.compile(textBody, { strict: false });
-      text = textFn(data);
-    } else {
-      text = htmlToPlainText(html);
-    }
-    return { html, text, subject: resolvedSubject };
-  }
-  htmlToText(html) {
-    return htmlToPlainText(html);
-  }
-  extractVariables(template) {
-    const regex = /\{\{(?!#|\/|!|>)([^}]+)\}\}/g;
-    const variables = /* @__PURE__ */ new Set();
-    let match;
-    while ((match = regex.exec(template)) !== null) {
-      const variable = match[1].trim();
-      if (!variable.startsWith("else")) {
-        variables.add(variable);
-      }
-    }
-    return Array.from(variables).sort();
-  }
-  validateTemplate(body) {
-    const errors = [];
-    try {
-      Handlebars__default.default.precompile(body);
-    } catch (e) {
-      errors.push(`Handlebars syntax error: ${e.message}`);
-    }
-    const mjmlSource = wrapInMjml(body);
-    try {
-      const result = mjml2html__default.default(mjmlSource, { validationLevel: "strict" });
-      if (result.errors && result.errors.length > 0) {
-        for (const err of result.errors) {
-          errors.push(`MJML error: ${err.message}`);
-        }
-      }
-    } catch (e) {
-      errors.push(`MJML compilation error: ${e.message}`);
-    }
-    return { valid: errors.length === 0, errors };
-  }
-};
-var AlxEmailError = class extends core.AlxError {
-  constructor(message, code) {
-    super(message, code);
-    this.name = "AlxEmailError";
-  }
-};
-var ConfigValidationError = class extends AlxEmailError {
-  constructor(message, field) {
-    super(message, "CONFIG_VALIDATION");
-    this.field = field;
-    this.name = "ConfigValidationError";
-  }
-};
-var TemplateNotFoundError = class extends AlxEmailError {
-  constructor(templateId) {
-    super(`Template not found: ${templateId}`, "TEMPLATE_NOT_FOUND");
-    this.templateId = templateId;
-    this.name = "TemplateNotFoundError";
-  }
-};
-var TemplateSyntaxError = class extends AlxEmailError {
-  constructor(message, errors) {
-    super(message, "TEMPLATE_SYNTAX");
-    this.errors = errors;
-    this.name = "TemplateSyntaxError";
-  }
-};
-var RuleNotFoundError = class extends AlxEmailError {
-  constructor(ruleId) {
-    super(`Rule not found: ${ruleId}`, "RULE_NOT_FOUND");
-    this.ruleId = ruleId;
-    this.name = "RuleNotFoundError";
-  }
-};
-var RuleTemplateIncompatibleError = class extends AlxEmailError {
-  constructor(reason) {
-    super(`Rule-template incompatibility: ${reason}`, "RULE_TEMPLATE_INCOMPATIBLE");
-    this.reason = reason;
-    this.name = "RuleTemplateIncompatibleError";
-  }
-};
-var LockAcquisitionError = class extends AlxEmailError {
-  constructor() {
-    super("Could not acquire distributed lock \u2014 another run is in progress", "LOCK_ACQUISITION");
-    this.name = "LockAcquisitionError";
-  }
-};
-var DuplicateSlugError = class extends AlxEmailError {
-  constructor(slug) {
-    super(`Template with slug "${slug}" already exists`, "DUPLICATE_SLUG");
-    this.slug = slug;
-    this.name = "DuplicateSlugError";
-  }
-};
-
-// src/utils/query-helpers.ts
-function isValidDateString(s) {
-  return s.trim() !== "" && !isNaN(new Date(s).getTime());
-}
-function buildDateRangeFilter(dateField, from, to) {
-  const validFrom = from && isValidDateString(from) ? from : void 0;
-  const validTo = to && isValidDateString(to) ? to : void 0;
-  if (!validFrom && !validTo) return {};
-  const filter = {};
-  filter[dateField] = {};
-  if (validFrom) filter[dateField].$gte = new Date(validFrom);
-  if (validTo) filter[dateField].$lte = /* @__PURE__ */ new Date(validTo + "T23:59:59.999Z");
-  return filter;
-}
-function calculatePagination(page, limit, maxLimit = 500) {
-  const rawPage = page != null && !isNaN(page) ? page : 1;
-  const rawLimit = limit != null && !isNaN(limit) ? limit : 200;
-  const p = Math.max(1, rawPage);
-  const l = Math.max(1, Math.min(rawLimit, maxLimit));
-  const skip = (p - 1) * l;
-  return { page: p, limit: l, skip };
-}
-function filterUpdateableFields(input, allowedFields) {
-  const result = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (value !== void 0 && allowedFields.has(key)) {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-// src/services/template.service.ts
-function stripScriptTags(text) {
-  return text.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
-}
-var UPDATEABLE_FIELDS = /* @__PURE__ */ new Set([
-  "name",
-  "description",
-  "category",
-  "audience",
-  "platform",
-  "textBody",
-  "subjects",
-  "bodies",
-  "preheaders",
-  "variables",
-  "isActive",
-  "fields",
-  "attachments"
-]);
-function slugify(name) {
-  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-var TemplateService = class {
-  constructor(EmailTemplate, config, EmailRule) {
-    this.EmailTemplate = EmailTemplate;
-    this.config = config;
-    this.EmailRule = EmailRule;
-  }
-  renderService = new TemplateRenderService();
-  async list(filters) {
-    const query = {};
-    if (filters?.category) query["category"] = filters.category;
-    if (filters?.audience) query["audience"] = filters.audience;
-    if (filters?.platform) query["platform"] = filters.platform;
-    if (filters?.isActive !== void 0) query["isActive"] = filters.isActive;
-    const page = filters?.page ?? 1;
-    const limit = filters?.limit ?? 200;
-    const skip = (page - 1) * limit;
-    const [templates, total] = await Promise.all([
-      this.EmailTemplate.find(query).sort({ category: 1, name: 1 }).skip(skip).limit(limit),
-      this.EmailTemplate.countDocuments(query)
-    ]);
-    return { templates, total };
-  }
-  async getById(id) {
-    return this.EmailTemplate.findById(id);
-  }
-  async getBySlug(slug) {
-    return this.EmailTemplate.findBySlug(slug);
-  }
-  async create(input) {
-    const slug = input.slug || slugify(input.name);
-    const existing = await this.EmailTemplate.findBySlug(slug);
-    if (existing) {
-      throw new DuplicateSlugError(slug);
-    }
-    const subjects = input.subjects.map((s) => stripScriptTags(s));
-    const bodies = input.bodies.map((b) => stripScriptTags(b));
-    if (subjects.length === 0) throw new TemplateSyntaxError("At least one subject is required", ["At least one subject is required"]);
-    if (bodies.length === 0) throw new TemplateSyntaxError("At least one body is required", ["At least one body is required"]);
-    for (const b of bodies) {
-      const validation = this.renderService.validateTemplate(b);
-      if (!validation.valid) {
-        throw new TemplateSyntaxError(`Template validation failed: ${validation.errors.join("; ")}`, validation.errors);
-      }
-    }
-    const allContent = [...subjects, ...bodies, ...input.preheaders || [], input.textBody || ""].join(" ");
-    const variables = input.variables || this.renderService.extractVariables(allContent);
-    return this.EmailTemplate.createTemplate({
-      ...input,
-      slug,
-      subjects,
-      bodies,
-      variables
-    });
-  }
-  async update(id, input) {
-    const template = await this.EmailTemplate.findById(id);
-    if (!template) return null;
-    if (input.subjects) {
-      input.subjects = input.subjects.map((s) => stripScriptTags(s));
-    }
-    if (input.bodies) {
-      input.bodies = input.bodies.map((b) => stripScriptTags(b));
-    }
-    if (input.subjects && input.subjects.length === 0) {
-      throw new TemplateSyntaxError("At least one subject is required", ["At least one subject is required"]);
-    }
-    if (input.bodies && input.bodies.length === 0) {
-      throw new TemplateSyntaxError("At least one body is required", ["At least one body is required"]);
-    }
-    const bodiesToValidate = input.bodies || null;
-    if (bodiesToValidate) {
-      for (const b of bodiesToValidate) {
-        const validation = this.renderService.validateTemplate(b);
-        if (!validation.valid) {
-          throw new TemplateSyntaxError(`Template validation failed: ${validation.errors.join("; ")}`, validation.errors);
-        }
-      }
-    }
-    if (input.textBody || input.subjects || input.bodies || input.preheaders) {
-      const subjects = input.subjects ?? template.subjects;
-      const bodies = input.bodies ?? template.bodies;
-      const preheaders = input.preheaders ?? template.preheaders ?? [];
-      const textBody = input.textBody ?? template.textBody;
-      const allContent = [...subjects, ...bodies, ...preheaders, textBody || ""].join(" ");
-      input.variables = this.renderService.extractVariables(allContent);
-    }
-    const setFields = filterUpdateableFields(input, UPDATEABLE_FIELDS);
-    const update = { $set: setFields };
-    if (input.textBody || input.subjects || input.bodies || input.preheaders) {
-      update["$inc"] = { version: 1 };
-    }
-    return this.EmailTemplate.findByIdAndUpdate(
-      id,
-      update,
-      { new: true }
-    );
-  }
-  async delete(id) {
-    if (this.EmailRule) {
-      const activeRules = await this.EmailRule.find({ templateId: id, isActive: true });
-      if (activeRules.length > 0) {
-        const names = activeRules.map((r) => r.name).join(", ");
-        throw new Error(`Cannot delete template: ${activeRules.length} active rule(s) reference it (${names}). Deactivate them first.`);
-      }
-    }
-    const result = await this.EmailTemplate.findByIdAndDelete(id);
-    return result !== null;
-  }
-  async toggleActive(id) {
-    const template = await this.EmailTemplate.findById(id);
-    if (!template) return null;
-    template.isActive = !template.isActive;
-    await template.save();
-    return template;
-  }
-  _buildSampleData(variables, provided) {
-    const data = { ...provided };
-    for (const v of variables) {
-      if (!(v in data)) {
-        data[v] = `[${v}]`;
-      }
-    }
-    return data;
-  }
-  async preview(id, sampleData) {
-    const template = await this.EmailTemplate.findById(id);
-    if (!template) return null;
-    const variables = template.variables ?? [];
-    const data = this._buildSampleData(variables, sampleData);
-    return this.renderService.renderPreview(
-      template.subjects[0],
-      template.bodies[0],
-      data,
-      template.textBody
-    );
-  }
-  async previewRaw(subject, body, sampleData, variables, textBody) {
-    const data = this._buildSampleData(variables ?? [], sampleData);
-    return this.renderService.renderPreview(subject, body, data, textBody);
-  }
-  async validate(body) {
-    const validation = this.renderService.validateTemplate(body);
-    const variables = this.renderService.extractVariables(body);
-    return { ...validation, variables };
-  }
-  async clone(sourceId, newName) {
-    const source = await this.EmailTemplate.findById(sourceId);
-    if (!source) throw new Error("Template not found");
-    const { _id, __v, createdAt, updatedAt, ...rest } = source.toObject();
-    rest.name = newName || `${rest.name} (copy)`;
-    rest.slug = `${rest.slug}-copy-${Date.now()}`;
-    rest.isActive = false;
-    return this.EmailTemplate.create(rest);
-  }
-  async sendTestEmail(id, testEmail, sampleData) {
-    if (!this.config.adapters.sendTestEmail) {
-      return { success: false, error: "Test email sending not configured" };
-    }
-    const template = await this.EmailTemplate.findById(id);
-    if (!template) {
-      return { success: false, error: "Template not found" };
-    }
-    const rendered = this.renderService.renderSingle(
-      template.subjects[0],
-      template.bodies[0],
-      sampleData,
-      template.textBody
-    );
-    try {
-      await this.config.adapters.sendTestEmail(
-        testEmail,
-        `[TEST] ${rendered.subject}`,
-        rendered.html,
-        rendered.text,
-        template.attachments || []
-      );
-      return { success: true };
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
-  }
-  async previewWithRecipient(templateId, recipientData) {
-    const template = await this.EmailTemplate.findById(templateId);
-    if (!template) return null;
-    const variables = template.variables ?? [];
-    const data = this._buildSampleData(variables, { ...template.fields ?? {}, ...recipientData });
-    return this.renderService.renderPreview(
-      template.subjects[0],
-      template.bodies[0],
-      data,
-      template.textBody
-    );
-  }
-};
-
-// src/controllers/collection.controller.ts
-function flattenFields(fields, prefix = "", parentIsArray = false) {
-  const result = [];
-  for (const field of fields) {
-    const path = prefix ? `${prefix}.${field.name}` : field.name;
-    const isArray = field.type === "array";
-    if (field.type === "object" && field.fields?.length) {
-      result.push({
-        path,
-        type: "object",
-        label: field.label,
-        description: field.description
-      });
-      result.push(...flattenFields(field.fields, path, false));
-    } else if (isArray && field.fields?.length) {
-      result.push({
-        path: `${path}[]`,
-        type: "array",
-        label: field.label,
-        description: field.description,
-        isArray: true
-      });
-      result.push(...flattenFields(field.fields, `${path}[]`, true));
-    } else {
-      result.push({
-        path,
-        type: field.type,
-        label: field.label,
-        description: field.description,
-        enumValues: field.enumValues,
-        isArray: parentIsArray || isArray
-      });
-    }
-  }
-  return result;
-}
-function createCollectionController(collections) {
-  return {
-    list(_req, res) {
-      const summary = collections.map((c) => ({
-        name: c.name,
-        label: c.label,
-        description: c.description,
-        identifierField: c.identifierField,
-        fieldCount: c.fields.length,
-        joinCount: c.joins?.length ?? 0
-      }));
-      res.json({ collections: summary });
-    },
-    getFields(req, res) {
-      const { name } = req.params;
-      const collection = collections.find((c) => c.name === name);
-      if (!collection) {
-        res.status(404).json({ error: `Collection "${name}" not found` });
-        return;
-      }
-      const fields = flattenFields(collection.fields);
-      if (collection.joins?.length) {
-        for (const join of collection.joins) {
-          const joinedCollection = collections.find((c) => c.name === join.from);
-          if (joinedCollection) {
-            const joinedFields = flattenFields(joinedCollection.fields, join.as);
-            fields.push(...joinedFields);
-          }
-        }
-      }
-      res.json({
-        name: collection.name,
-        label: collection.label,
-        identifierField: collection.identifierField,
-        fields,
-        typeOperators: TYPE_OPERATORS
-      });
-    }
-  };
-}
-
-// src/validation/condition.validator.ts
-function validateConditions(conditions, collectionName, collections) {
-  if (!collectionName || collections.length === 0) return [];
-  const collection = collections.find((c) => c.name === collectionName);
-  if (!collection) return [];
-  const flatFields = flattenFields(collection.fields);
-  if (collection.joins?.length) {
-    for (const join of collection.joins) {
-      const joinedCollection = collections.find((c) => c.name === join.from);
-      if (joinedCollection) {
-        flatFields.push(...flattenFields(joinedCollection.fields, join.as));
-      }
-    }
-  }
-  const fieldMap = /* @__PURE__ */ new Map();
-  for (const f of flatFields) {
-    fieldMap.set(f.path, f);
-  }
-  const errors = [];
-  for (let i = 0; i < conditions.length; i++) {
-    const cond = conditions[i];
-    const fieldDef = fieldMap.get(cond.field);
-    if (!fieldDef) {
-      errors.push({
-        index: i,
-        field: cond.field,
-        message: `Field "${cond.field}" does not exist in collection "${collectionName}"`
-      });
-      continue;
-    }
-    const allowedOps = TYPE_OPERATORS[fieldDef.type];
-    if (allowedOps && !allowedOps.includes(cond.operator)) {
-      errors.push({
-        index: i,
-        field: cond.field,
-        message: `Operator "${cond.operator}" is not valid for field type "${fieldDef.type}"`
-      });
-    }
-  }
-  return errors;
-}
-
-// src/services/rule.service.ts
-function isQueryTarget(target) {
-  return !target.mode || target.mode === "query";
-}
-var UPDATEABLE_FIELDS2 = /* @__PURE__ */ new Set([
-  "name",
-  "description",
-  "sortOrder",
-  "target",
-  "templateId",
-  "sendOnce",
-  "resendAfterDays",
-  "cooldownDays",
-  "autoApprove",
-  "maxPerRun",
-  "bypassThrottle",
-  "throttleOverride",
-  "emailType",
-  "validFrom",
-  "validTill",
-  "schedule"
-]);
-function validateRuleTemplateCompat(targetRole, targetPlatform, template) {
-  const templateAudience = template.audience;
-  const templatePlatform = template.platform;
-  if (templateAudience !== "all") {
-    if (targetRole === "all") {
-      return `Template "${template.name}" targets ${templateAudience} only, but rule targets all users`;
-    }
-    if (targetRole !== templateAudience) {
-      return `Template targets ${templateAudience}, but rule targets ${targetRole}`;
-    }
-  }
-  if (templatePlatform !== "both") {
-    if (targetPlatform === "both") {
-      return `Template is for ${templatePlatform} only, but rule targets all platforms`;
-    }
-    if (templatePlatform !== targetPlatform) {
-      return `Template is for ${templatePlatform}, but rule targets ${targetPlatform}`;
-    }
-  }
-  return null;
-}
-var RuleService = class {
-  constructor(EmailRule, EmailTemplate, EmailRuleRunLog, config) {
-    this.EmailRule = EmailRule;
-    this.EmailTemplate = EmailTemplate;
-    this.EmailRuleRunLog = EmailRuleRunLog;
-    this.config = config;
-  }
-  async list(opts) {
-    const page = opts?.page ?? 1;
-    const limit = opts?.limit ?? 200;
-    const skip = (page - 1) * limit;
-    const [rules, total] = await Promise.all([
-      this.EmailRule.find().populate("templateId", "name slug").sort({ sortOrder: 1, createdAt: -1 }).skip(skip).limit(limit),
-      this.EmailRule.countDocuments()
-    ]);
-    return { rules, total };
-  }
-  async getById(id) {
-    return this.EmailRule.findById(id);
-  }
-  async create(input) {
-    const template = await this.EmailTemplate.findById(input.templateId);
-    if (!template) {
-      throw new TemplateNotFoundError(input.templateId);
-    }
-    if (isQueryTarget(input.target)) {
-      if (!input.target.role || !input.target.platform) {
-        throw new RuleTemplateIncompatibleError("target.role and target.platform are required for query mode, validation failed");
-      }
-      const compatError = validateRuleTemplateCompat(
-        input.target.role,
-        input.target.platform,
-        template
-      );
-      if (compatError) {
-        throw new RuleTemplateIncompatibleError(compatError);
-      }
-    } else {
-      if (!input.target.identifiers || input.target.identifiers.length === 0) {
-        throw new RuleTemplateIncompatibleError("target.identifiers must be a non-empty array for list mode, validation failed");
-      }
-    }
-    if (isQueryTarget(input.target) && input.target.collectionName && this.config.collections?.length) {
-      const condErrors = validateConditions(input.target.conditions, input.target.collectionName, this.config.collections);
-      if (condErrors.length > 0) {
-        throw new RuleTemplateIncompatibleError(
-          `Invalid conditions: ${condErrors.map((e) => e.message).join("; ")}`
-        );
-      }
-    }
-    return this.EmailRule.createRule(input);
-  }
-  async update(id, input) {
-    const rule = await this.EmailRule.findById(id);
-    if (!rule) return null;
-    const templateId = input.templateId ?? rule.templateId.toString();
-    if (input.target) {
-      if (isQueryTarget(input.target)) {
-        if (!input.target.role || !input.target.platform) {
-          throw new RuleTemplateIncompatibleError("target.role and target.platform are required for query mode, validation failed");
-        }
-      } else {
-        if (!input.target.identifiers || input.target.identifiers.length === 0) {
-          throw new RuleTemplateIncompatibleError("target.identifiers must be a non-empty array for list mode, validation failed");
-        }
-      }
-    }
-    const effectiveTarget = input.target ?? rule.target;
-    if ((input.templateId || input.target) && isQueryTarget(effectiveTarget)) {
-      const qt = effectiveTarget;
-      const template = await this.EmailTemplate.findById(templateId);
-      if (!template) {
-        throw new TemplateNotFoundError(templateId);
-      }
-      const compatError = validateRuleTemplateCompat(qt.role, qt.platform, template);
-      if (compatError) {
-        throw new RuleTemplateIncompatibleError(compatError);
-      }
-    }
-    if (isQueryTarget(effectiveTarget)) {
-      const qt = effectiveTarget;
-      if (qt.collectionName && this.config.collections?.length) {
-        const condErrors = validateConditions(qt.conditions || [], qt.collectionName, this.config.collections);
-        if (condErrors.length > 0) {
-          throw new RuleTemplateIncompatibleError(
-            `Invalid conditions: ${condErrors.map((e) => e.message).join("; ")}`
-          );
-        }
-      }
-    }
-    const setFields = filterUpdateableFields(input, UPDATEABLE_FIELDS2);
-    return this.EmailRule.findByIdAndUpdate(
-      id,
-      { $set: setFields },
-      { new: true }
-    );
-  }
-  async delete(id) {
-    const rule = await this.EmailRule.findById(id);
-    if (!rule) return { deleted: false };
-    if (rule.totalSent > 0) {
-      rule.isActive = false;
-      await rule.save();
-      return { deleted: false, disabled: true };
-    }
-    await this.EmailRule.findByIdAndDelete(id);
-    return { deleted: true };
-  }
-  async toggleActive(id) {
-    const rule = await this.EmailRule.findById(id);
-    if (!rule) return null;
-    if (!rule.isActive) {
-      const template = await this.EmailTemplate.findById(rule.templateId);
-      if (!template) {
-        throw new TemplateNotFoundError(rule.templateId.toString());
-      }
-      if (!template.isActive) {
-        throw new RuleTemplateIncompatibleError("Cannot activate rule: linked template is inactive");
-      }
-    }
-    rule.isActive = !rule.isActive;
-    await rule.save();
-    return rule;
-  }
-  async dryRun(id) {
-    const rule = await this.EmailRule.findById(id);
-    if (!rule) {
-      throw new RuleNotFoundError(id);
-    }
-    const defaultMaxPerRun = this.config.options?.defaultMaxPerRun;
-    const effectiveLimit = rule.maxPerRun || defaultMaxPerRun || 500;
-    const target = rule.target;
-    if (target.mode === "list") {
-      const identifiers = target.identifiers || [];
-      const matchedCount2 = identifiers.length;
-      const willProcess2 = Math.min(matchedCount2, effectiveLimit);
-      const sample2 = identifiers.slice(0, 10).map((id2) => ({ email: id2 }));
-      return { matchedCount: matchedCount2, effectiveLimit, willProcess: willProcess2, ruleId: id, sample: sample2 };
-    }
-    const queryTarget = rule.target;
-    const collectionName = queryTarget.collectionName;
-    const collectionSchema = collectionName ? this.config.collections?.find((c) => c.name === collectionName) : void 0;
-    const users = await this.config.adapters.queryUsers(rule.target, 5e4, collectionSchema ? { collectionSchema } : void 0);
-    const matchedCount = users.length;
-    const willProcess = Math.min(matchedCount, effectiveLimit);
-    const sample = users.slice(0, 10).map((u) => ({
-      email: u.email || "",
-      name: u.name || u.firstName || "",
-      ...u._id ? { id: String(u._id) } : {}
-    }));
-    return { matchedCount, effectiveLimit, willProcess, ruleId: id, sample };
-  }
-  async clone(sourceId, newName) {
-    const source = await this.EmailRule.findById(sourceId);
-    if (!source) throw new Error("Rule not found");
-    const { _id, __v, createdAt, updatedAt, ...rest } = source.toObject();
-    rest.name = newName || `${rest.name} (copy)`;
-    rest.isActive = false;
-    rest.totalSent = 0;
-    rest.totalSkipped = 0;
-    rest.lastRunAt = void 0;
-    rest.lastRunStats = void 0;
-    return this.EmailRule.create(rest);
-  }
-  async getRunHistory(limit = 20, opts) {
-    const filter = buildDateRangeFilter("runAt", opts?.from, opts?.to);
-    const pagination = calculatePagination(opts?.page, limit);
-    return this.EmailRuleRunLog.find(filter).sort({ runAt: -1 }).skip(pagination.skip).limit(pagination.limit);
-  }
-  async getRunHistoryCount(opts) {
-    const filter = buildDateRangeFilter("runAt", opts?.from, opts?.to);
-    return this.EmailRuleRunLog.countDocuments(filter);
-  }
+var DATE_FORMAT_OPTIONS = {
+  day: "numeric",
+  month: "short",
+  year: "numeric"
 };
-var MS_PER_DAY = 864e5;
-var DEFAULT_LOCK_TTL_MS = 30 * 60 * 1e3;
-var IDENTIFIER_CHUNK_SIZE = 50;
-function getLocalDate(date, timezone) {
-  if (!timezone) return date;
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false
-  }).formatToParts(date);
-  const get = (type) => parts.find((p) => p.type === type)?.value || "0";
-  return /* @__PURE__ */ new Date(`${get("year")}-${get("month")}-${get("day")}T${get("hour")}:${get("minute")}:${get("second")}`);
-}
-async function processInChunks(items, fn, chunkSize) {
-  const results = [];
-  for (let i = 0; i < items.length; i += chunkSize) {
-    const chunk = items.slice(i, i + chunkSize);
-    const chunkResults = await Promise.all(chunk.map(fn));
-    results.push(...chunkResults);
-  }
-  return results;
+function registerEmailHelpers() {
+  Handlebars__default.default.registerHelper("currency", (val) => {
+    const num = Number(val);
+    if (isNaN(num)) return String(val ?? "");
+    return `\u20B9${num.toLocaleString("en-IN")}`;
+  });
+  Handlebars__default.default.registerHelper("formatDate", (date) => {
+    if (!date) return "";
+    const d = new Date(date);
+    if (isNaN(d.getTime())) return String(date);
+    return d.toLocaleDateString("en-IN", DATE_FORMAT_OPTIONS);
+  });
 }
-var RuleRunnerService = class {
-  constructor(EmailRule, EmailTemplate, EmailRuleSend, EmailRuleRunLog, EmailThrottleConfig, config) {
-    this.EmailRule = EmailRule;
-    this.EmailTemplate = EmailTemplate;
-    this.EmailRuleSend = EmailRuleSend;
-    this.EmailRuleRunLog = EmailRuleRunLog;
-    this.EmailThrottleConfig = EmailThrottleConfig;
-    this.config = config;
-    this.keyPrefix = config.redis.keyPrefix || "";
-    this.redis = config.redis.connection;
-    const lockTTL = config.options?.lockTTLMs || DEFAULT_LOCK_TTL_MS;
-    this.lock = new core.RedisLock(
-      this.redis,
-      `${this.keyPrefix}email-rule-runner:lock`,
-      lockTTL,
-      config.logger
-    );
-    this.logger = config.logger || core.noopLogger;
-  }
-  templateRenderer = new TemplateRenderService();
-  lock;
-  logger;
-  redis;
-  keyPrefix;
-  async runAllRules(triggeredBy = RUN_TRIGGER.Cron, runId) {
-    if (!runId) runId = crypto__default.default.randomUUID();
-    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (this.config.options?.sendWindow) {
-      const { startHour, endHour, timezone } = this.config.options.sendWindow;
-      const now = /* @__PURE__ */ new Date();
-      const formatter = new Intl.DateTimeFormat("en-US", { hour: "numeric", hour12: false, timeZone: timezone });
-      const currentHour = parseInt(formatter.format(now), 10);
-      if (currentHour < startHour || currentHour >= endHour) {
-        this.logger.info("Outside send window, skipping run", { currentHour, startHour, endHour, timezone });
-        return { runId };
-      }
-    }
-    const lockAcquired = await this.lock.acquire();
-    if (!lockAcquired) {
-      this.logger.warn("Rule runner already executing, skipping");
-      await this.updateRunProgress(runId, { status: "failed", currentRule: "Another run is already in progress" });
-      return { runId };
-    }
-    const runStartTime = Date.now();
-    await this.updateRunProgress(runId, {
-      runId,
-      status: "running",
-      currentRule: "",
-      progress: { rulesTotal: 0, rulesCompleted: 0, sent: 0, failed: 0, skipped: 0, invalid: 0 },
-      startedAt,
-      elapsed: 0
-    });
-    let runStatus = "completed";
-    try {
-      const throttleConfig = await this.EmailThrottleConfig.getConfig();
-      const allActiveRules = await this.EmailRule.findActive();
-      const now = /* @__PURE__ */ new Date();
-      const tz = this.config.options?.sendWindow?.timezone;
-      const activeRules = allActiveRules.filter((rule) => {
-        if (rule.validFrom) {
-          const localNow = getLocalDate(now, tz);
-          const localValidFrom = getLocalDate(new Date(rule.validFrom), tz);
-          if (localNow < localValidFrom) return false;
-        }
-        if (rule.validTill) {
-          const localNow = getLocalDate(now, tz);
-          const localValidTill = getLocalDate(new Date(rule.validTill), tz);
-          if (localNow > localValidTill) return false;
-        }
-        return true;
-      });
-      this.config.hooks?.onRunStart?.({ rulesCount: activeRules.length, triggeredBy, runId });
-      await this.updateRunProgress(runId, {
-        progress: { rulesTotal: activeRules.length, rulesCompleted: 0, sent: 0, failed: 0, skipped: 0, invalid: 0 }
-      });
-      if (activeRules.length === 0) {
-        this.logger.info("No active rules to process");
-        await this.EmailRuleRunLog.create({
-          runId,
-          runAt: /* @__PURE__ */ new Date(),
-          triggeredBy,
-          duration: Date.now() - runStartTime,
-          rulesProcessed: 0,
-          totalStats: { matched: 0, sent: 0, skipped: 0, skippedByThrottle: 0, errorCount: 0 },
-          perRuleStats: [],
-          status: "completed"
-        });
-        await this.updateRunProgress(runId, { status: "completed", elapsed: Date.now() - runStartTime });
-        return { runId };
-      }
-      const templateIds = [...new Set(activeRules.map((r) => r.templateId.toString()))];
-      const templates = await this.EmailTemplate.find({ _id: { $in: templateIds } }).lean();
-      const templateMap = /* @__PURE__ */ new Map();
-      for (const t of templates) {
-        templateMap.set(t._id.toString(), t);
-      }
-      const recentSends = await this.EmailRuleSend.find({
-        sentAt: { $gte: new Date(Date.now() - 7 * MS_PER_DAY) }
-      }).lean();
-      const throttleMap = this.buildThrottleMap(recentSends);
-      const perRuleStats = [];
-      let totalSent = 0;
-      let totalFailed = 0;
-      let totalSkipped = 0;
-      let totalInvalid = 0;
-      for (let ri = 0; ri < activeRules.length; ri++) {
-        const rule = activeRules[ri];
-        const cancelKey = `${this.keyPrefix}run:${runId}:cancel`;
-        const cancelled = await this.redis.exists(cancelKey);
-        if (cancelled) {
-          runStatus = "cancelled";
-          break;
-        }
-        await this.updateRunProgress(runId, {
-          currentRule: rule.name,
-          elapsed: Date.now() - runStartTime
-        });
-        const stats = await this.executeRule(rule, throttleMap, throttleConfig, templateMap, runId);
-        totalSent += stats.sent;
-        totalFailed += stats.errorCount;
-        totalSkipped += stats.skipped + stats.skippedByThrottle;
-        totalInvalid += stats.matched - stats.sent - stats.skipped - stats.skippedByThrottle - stats.errorCount;
-        perRuleStats.push({
-          ruleId: rule._id.toString(),
-          ruleName: rule.name,
-          ...stats
-        });
-        await this.updateRunProgress(runId, {
-          progress: {
-            rulesTotal: activeRules.length,
-            rulesCompleted: ri + 1,
-            sent: totalSent,
-            failed: totalFailed,
-            skipped: totalSkipped,
-            invalid: totalInvalid < 0 ? 0 : totalInvalid
-          },
-          elapsed: Date.now() - runStartTime
-        });
-      }
-      const totalStats = perRuleStats.reduce(
-        (acc, s) => ({
-          matched: acc.matched + s.matched,
-          sent: acc.sent + s.sent,
-          skipped: acc.skipped + s.skipped,
-          skippedByThrottle: acc.skippedByThrottle + s.skippedByThrottle,
-          errorCount: acc.errorCount + s.errorCount
-        }),
-        { matched: 0, sent: 0, skipped: 0, skippedByThrottle: 0, errorCount: 0 }
-      );
-      await this.EmailRuleRunLog.create({
-        runId,
-        runAt: /* @__PURE__ */ new Date(),
-        triggeredBy,
-        duration: Date.now() - runStartTime,
-        rulesProcessed: activeRules.length,
-        totalStats,
-        perRuleStats,
-        status: runStatus
-      });
-      await this.updateRunProgress(runId, { status: runStatus, currentRule: "", elapsed: Date.now() - runStartTime });
-      this.config.hooks?.onRunComplete?.({ duration: Date.now() - runStartTime, totalStats, perRuleStats, runId });
-      this.logger.info("Rule run completed", {
-        triggeredBy,
-        rulesProcessed: activeRules.length,
-        totalSent: totalStats.sent,
-        totalSkipped: totalStats.skipped,
-        duration: Date.now() - runStartTime
-      });
-    } catch (err) {
-      runStatus = "failed";
-      await this.updateRunProgress(runId, { status: "failed", elapsed: Date.now() - runStartTime });
-      throw err;
-    } finally {
-      await this.lock.release();
-    }
-    return { runId };
-  }
-  async executeRule(rule, throttleMap, throttleConfig, templateMap, runId) {
-    const stats = { matched: 0, sent: 0, skipped: 0, skippedByThrottle: 0, errorCount: 0 };
-    const template = templateMap?.get(rule.templateId.toString()) ?? await this.EmailTemplate.findById(rule.templateId);
-    if (!template) {
-      this.logger.error(`Rule "${rule.name}": template ${rule.templateId} not found`);
-      stats.errorCount = 1;
-      return stats;
-    }
-    const isListMode = rule.target?.mode === "list";
-    if (isListMode) {
-      return this.executeListMode(rule, template, throttleMap, throttleConfig, stats, runId);
-    }
-    return this.executeQueryMode(rule, template, throttleMap, throttleConfig, stats, runId);
-  }
-  emitSendEvent(rule, email, status, templateId, runId, opts) {
-    this.config.hooks?.onSend?.({
-      ruleId: rule._id.toString(),
-      ruleName: rule.name,
-      email,
-      status,
-      accountId: opts?.accountId ?? "",
-      templateId,
-      runId: runId || "",
-      subjectIndex: opts?.subjectIndex ?? -1,
-      bodyIndex: opts?.bodyIndex ?? -1,
-      preheaderIndex: opts?.preheaderIndex,
-      failureReason: opts?.failureReason
-    });
-  }
-  async processSingleUser(params) {
-    const { rule, email, userKey, identifier, user, sendMap, throttleMap, throttleConfig, template, compiledVariants, templateId, ruleId, runId, stats } = params;
-    const lastSend = sendMap.get(userKey);
-    if (lastSend) {
-      if (rule.sendOnce && rule.resendAfterDays == null) {
-        stats.skipped++;
-        this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "send once" });
-        return "skipped";
-      }
-      if (rule.resendAfterDays != null) {
-        const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
-        if (daysSince < rule.resendAfterDays) {
-          stats.skipped++;
-          this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "resend too soon" });
-          return "skipped";
-        }
-      } else {
-        stats.skipped++;
-        this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "send once" });
-        return "skipped";
-      }
-      if (rule.cooldownDays) {
-        const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
-        if (daysSince < rule.cooldownDays) {
-          stats.skipped++;
-          this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "cooldown period" });
-          return "skipped";
-        }
-      }
-    }
-    if (!this.checkThrottle(rule, userKey, email, throttleMap, throttleConfig, stats, templateId, runId)) return "skipped";
-    const agentSelection = await this.config.adapters.selectAgent(identifier.id, { ruleId, templateId });
-    if (!agentSelection) {
-      stats.skipped++;
-      this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "no account available" });
-      return "skipped";
-    }
-    const resolvedData = this.config.adapters.resolveData(user);
-    const templateData = { ...template.fields || {}, ...resolvedData };
-    const si = Math.floor(Math.random() * compiledVariants.subjectFns.length);
-    const bi = Math.floor(Math.random() * compiledVariants.bodyFns.length);
-    const renderedSubject = compiledVariants.subjectFns[si](templateData);
-    const renderedHtml = compiledVariants.bodyFns[bi](templateData);
-    const renderedText = compiledVariants.textBodyFn ? compiledVariants.textBodyFn(templateData) : this.templateRenderer.htmlToText(renderedHtml);
-    let finalHtml = renderedHtml;
-    let finalText = renderedText;
-    let finalSubject = renderedSubject;
-    let pi;
-    if (compiledVariants.preheaderFns && compiledVariants.preheaderFns.length > 0) {
-      pi = Math.floor(Math.random() * compiledVariants.preheaderFns.length);
-      const renderedPreheader = compiledVariants.preheaderFns[pi](templateData);
-      if (renderedPreheader) {
-        const preheaderHtml = `<div style="display:none;font-size:1px;color:#ffffff;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">${renderedPreheader}</div>`;
-        finalHtml = finalHtml.replace(/(<body[^>]*>)/i, `$1${preheaderHtml}`);
-      }
-    }
-    if (this.config.hooks?.beforeSend) {
-      try {
-        const modified = await this.config.hooks.beforeSend({
-          htmlBody: finalHtml,
-          textBody: finalText,
-          subject: finalSubject,
-          account: {
-            id: agentSelection.accountId,
-            email: agentSelection.email,
-            metadata: agentSelection.metadata
-          },
-          user: {
-            id: String(userKey),
-            email,
-            name: String(user.name || user.firstName || "")
-          },
-          context: {
-            ruleId,
-            templateId,
-            runId: runId || ""
-          }
+function createEmailRuleEngine(config) {
+  registerEmailHelpers();
+  const coreConfig = {
+    ...config,
+    adapters: {
+      queryUsers: config.adapters.queryUsers,
+      resolveData: config.adapters.resolveData,
+      selectAgent: config.adapters.selectAgent,
+      findIdentifier: config.adapters.findIdentifier,
+      send: async (params) => {
+        const html = renderMjml(params.body);
+        const text = params.textBody || htmlToPlainText(html);
+        await config.adapters.sendEmail({
+          identifierId: params.identifierId,
+          contactId: params.contactId,
+          accountId: params.accountId,
+          subject: params.subject || "",
+          htmlBody: html,
+          textBody: text,
+          ruleId: params.ruleId,
+          autoApprove: params.autoApprove,
+          attachments: params.metadata?.attachments ?? void 0
         });
-        finalHtml = modified.htmlBody;
-        finalText = modified.textBody;
-        finalSubject = modified.subject;
-      } catch (hookErr) {
-        this.logger.error(`beforeSend hook failed for email ${email}: ${hookErr.message}`);
-        stats.errorCount++;
-        this.emitSendEvent(rule, email, "error", templateId, runId || "", { accountId: agentSelection.accountId, subjectIndex: si, bodyIndex: bi, failureReason: hookErr.message });
-        return "error";
-      }
-    }
-    await this.config.adapters.sendEmail({
-      identifierId: identifier.id,
-      contactId: identifier.contactId,
-      accountId: agentSelection.accountId,
-      subject: finalSubject,
-      htmlBody: finalHtml,
-      textBody: finalText,
-      ruleId,
-      autoApprove: rule.autoApprove ?? true,
-      attachments: template.attachments || []
-    });
-    await this.EmailRuleSend.logSend(
-      ruleId,
-      userKey,
-      identifier.id,
-      void 0,
-      { status: "sent", accountId: agentSelection.accountId, subject: finalSubject, subjectIndex: si, bodyIndex: bi, preheaderIndex: pi }
-    );
-    const current = throttleMap.get(userKey) || { today: 0, thisWeek: 0};
-    throttleMap.set(userKey, {
-      today: current.today + 1,
-      thisWeek: current.thisWeek + 1,
-      lastSentDate: /* @__PURE__ */ new Date()
-    });
-    stats.sent++;
-    this.emitSendEvent(rule, email, "sent", templateId, runId || "", { accountId: agentSelection.accountId, subjectIndex: si, bodyIndex: bi, preheaderIndex: pi });
-    return "sent";
-  }
-  async resolveIdentifiers(emails) {
-    const identifierResults = await processInChunks(
-      emails,
-      async (email) => {
-        const result = await this.config.adapters.findIdentifier(email);
-        return result ? { email, ...result } : null;
       },
-      IDENTIFIER_CHUNK_SIZE
-    );
-    const map = /* @__PURE__ */ new Map();
-    for (const result of identifierResults) {
-      if (result) {
-        map.set(result.email, { id: result.id, contactId: result.contactId });
-      }
-    }
-    return map;
-  }
-  buildSendMap(sends) {
-    const map = /* @__PURE__ */ new Map();
-    for (const send of sends) {
-      const uid = send.userId.toString();
-      if (!map.has(uid)) {
-        map.set(uid, send);
-      }
-    }
-    return map;
-  }
-  compileTemplateVariants(template) {
-    const preheaders = template.preheaders || [];
-    return this.templateRenderer.compileBatchVariants(
-      template.subjects,
-      template.bodies,
-      template.textBody,
-      preheaders
-    );
-  }
-  async checkCancelled(runId, index) {
-    if (!runId || index % 10 !== 0) return false;
-    const cancelKey = `${this.keyPrefix}run:${runId}:cancel`;
-    return !!await this.redis.exists(cancelKey);
-  }
-  async applySendDelay(isLast) {
-    if (isLast) return;
-    const delayMs = this.config.options?.delayBetweenSendsMs || 0;
-    const jitterMs = this.config.options?.jitterMs || 0;
-    if (delayMs > 0 || jitterMs > 0) {
-      const totalDelay = delayMs + Math.floor(Math.random() * (jitterMs + 1));
-      if (totalDelay > 0) await new Promise((resolve) => setTimeout(resolve, totalDelay));
+      sendTest: config.adapters.sendTestEmail ? async (to, body, subject, metadata) => {
+        const html = renderMjml(body);
+        const text = htmlToPlainText(html);
+        await config.adapters.sendTestEmail(to, subject || "", html, text, metadata?.attachments ?? void 0);
+      } : void 0
     }
-  }
-  async finalizeRuleStats(rule, stats, ruleId, templateId, runId) {
-    await this.EmailRule.findByIdAndUpdate(rule._id, {
-      $set: { lastRunAt: /* @__PURE__ */ new Date(), lastRunStats: stats },
-      $inc: { totalSent: stats.sent, totalSkipped: stats.skipped }
-    });
-    this.config.hooks?.onRuleComplete?.({ ruleId, ruleName: rule.name, stats, templateId, runId: runId || "" });
-  }
-  async executeListMode(rule, template, throttleMap, throttleConfig, stats, runId) {
-    const rawIdentifiers = rule.target.identifiers || [];
-    const uniqueEmails = [...new Set(rawIdentifiers.map((e) => e.toLowerCase().trim()).filter(Boolean))];
-    const limit = rule.maxPerRun || this.config.options?.defaultMaxPerRun || 500;
-    if (uniqueEmails.length > limit) {
-      this.logger.warn(`Rule "${rule.name}" matched ${uniqueEmails.length} users but maxPerRun is ${limit} \u2014 only ${limit} will be processed`, { ruleId: rule._id.toString(), matchedCount: uniqueEmails.length, maxPerRun: limit });
-    }
-    const emailsToProcess = uniqueEmails.slice(0, limit);
-    stats.matched = emailsToProcess.length;
-    const ruleId = rule._id.toString();
-    const templateId = rule.templateId.toString();
-    this.config.hooks?.onRuleStart?.({ ruleId, ruleName: rule.name, matchedCount: emailsToProcess.length, templateId, runId: runId || "" });
-    if (emailsToProcess.length === 0) return stats;
-    const identifierMap = await this.resolveIdentifiers(emailsToProcess);
-    const validEmails = emailsToProcess.filter((e) => identifierMap.has(e));
-    const identifierIds = validEmails.map((e) => identifierMap.get(e).id);
-    const allRuleSends = await this.EmailRuleSend.find({ ruleId: rule._id, userId: { $in: identifierIds } }).sort({ sentAt: -1 }).lean();
-    const sendMap = this.buildSendMap(allRuleSends);
-    const compiledVariants = this.compileTemplateVariants(template);
-    let totalProcessed = 0;
-    for (let i = 0; i < emailsToProcess.length; i++) {
-      const email = emailsToProcess[i];
-      if (await this.checkCancelled(runId, i)) break;
-      try {
-        const identifier = identifierMap.get(email);
-        if (!identifier) {
-          stats.skipped++;
-          this.emitSendEvent(rule, email, "invalid", templateId, runId || "", { failureReason: "invalid email" });
-          continue;
-        }
-        const result = await this.processSingleUser({
-          rule,
-          email,
-          userKey: identifier.id,
-          identifier,
-          user: { _id: identifier.id, email },
-          sendMap,
-          throttleMap,
-          throttleConfig,
-          template,
-          compiledVariants,
-          templateId,
-          ruleId,
-          runId,
-          stats
-        });
-        if (result === "sent") {
-          totalProcessed++;
-          if (runId && totalProcessed % 10 === 0) await this.updateRunSendProgress(runId, stats);
-          await this.applySendDelay(i >= emailsToProcess.length - 1);
-        }
-      } catch (err) {
-        stats.errorCount++;
-        this.emitSendEvent(rule, email, "error", templateId, runId || "", { failureReason: err.message || "unknown error" });
-        this.logger.error(`Rule "${rule.name}" failed for identifier ${email}`, { error: err });
-      }
-    }
-    await this.finalizeRuleStats(rule, stats, ruleId, templateId, runId);
-    if (rule.sendOnce) {
-      const allIdentifiers = rule.target.identifiers || [];
-      const totalIdentifiers = new Set(allIdentifiers.map((e) => e.toLowerCase().trim()).filter(Boolean)).size;
-      const sends = await this.EmailRuleSend.find({
-        ruleId: rule._id
-      }).lean();
-      const sentOrProcessedIds = new Set(
-        sends.filter((s) => s.status !== "throttled").map((s) => String(s.userId || s.emailIdentifierId))
-      );
-      const throttledCount = sends.filter((s) => s.status === "throttled").length;
-      if (sentOrProcessedIds.size >= totalIdentifiers && throttledCount === 0) {
-        await this.EmailRule.findByIdAndUpdate(rule._id, { $set: { isActive: false } });
-        this.logger.info(`Rule '${rule.name}' auto-disabled \u2014 all identifiers processed`);
-      }
-    }
-    return stats;
-  }
-  async executeQueryMode(rule, template, throttleMap, throttleConfig, stats, runId) {
-    const limit = rule.maxPerRun || this.config.options?.defaultMaxPerRun || 500;
-    let users;
-    try {
-      const collectionName = rule.target?.collectionName;
-      const collectionSchema = collectionName ? this.config.collections?.find((c) => c.name === collectionName) : void 0;
-      users = await this.config.adapters.queryUsers(rule.target, limit, collectionSchema ? { collectionSchema } : void 0);
-    } catch (err) {
-      this.logger.error(`Rule "${rule.name}": query failed`, { error: err });
-      stats.errorCount = 1;
-      return stats;
-    }
-    if (users.length > limit) {
-      this.logger.warn(`Rule "${rule.name}" matched ${users.length} users but maxPerRun is ${limit} \u2014 only ${limit} will be processed`, { ruleId: rule._id.toString(), matchedCount: users.length, maxPerRun: limit });
-    }
-    stats.matched = users.length;
-    this.config.hooks?.onRuleStart?.({ ruleId: rule._id.toString(), ruleName: rule.name, matchedCount: users.length, templateId: rule.templateId.toString(), runId: runId || "" });
-    if (users.length === 0) return stats;
-    const userIds = users.map((u) => u._id?.toString()).filter(Boolean);
-    const emails = users.map((u) => u.email).filter(Boolean);
-    const allRuleSends = await this.EmailRuleSend.find({ ruleId: rule._id, userId: { $in: userIds } }).sort({ sentAt: -1 }).lean();
-    const sendMap = this.buildSendMap(allRuleSends);
-    const uniqueEmails = [...new Set(emails.map((e) => e.toLowerCase().trim()))];
-    const identifierMap = await this.resolveIdentifiers(uniqueEmails);
-    const compiledVariants = this.compileTemplateVariants(template);
-    const ruleId = rule._id.toString();
-    const templateId = rule.templateId.toString();
-    let totalProcessed = 0;
-    for (let i = 0; i < users.length; i++) {
-      const user = users[i];
-      if (await this.checkCancelled(runId, i)) break;
-      try {
-        const userId = user._id?.toString();
-        const email = user.email;
-        if (!userId || !email) {
-          stats.skipped++;
-          this.emitSendEvent(rule, email || "unknown", "invalid", templateId, runId || "", { failureReason: "invalid email" });
-          continue;
-        }
-        const identifier = identifierMap.get(email.toLowerCase().trim());
-        if (!identifier) {
-          stats.skipped++;
-          this.emitSendEvent(rule, email, "invalid", templateId, runId || "", { failureReason: "invalid email" });
-          continue;
-        }
-        const result = await this.processSingleUser({
-          rule,
-          email,
-          userKey: userId,
-          identifier,
-          user,
-          sendMap,
-          throttleMap,
-          throttleConfig,
-          template,
-          compiledVariants,
-          templateId,
-          ruleId,
-          runId,
-          stats
-        });
-        if (result === "sent") {
-          totalProcessed++;
-          if (runId && totalProcessed % 10 === 0) await this.updateRunSendProgress(runId, stats);
-          await this.applySendDelay(i >= users.length - 1);
-        }
-      } catch (err) {
-        stats.errorCount++;
-        this.emitSendEvent(rule, user.email || "unknown", "error", templateId, runId || "", { failureReason: err.message || "unknown error" });
-        this.logger.error(`Rule "${rule.name}" failed for user ${user._id?.toString()}`, { error: err });
-      }
-    }
-    await this.finalizeRuleStats(rule, stats, ruleId, templateId, runId);
-    return stats;
-  }
-  checkThrottle(rule, userId, email, throttleMap, config, stats, templateId, runId) {
-    if (rule.emailType === EMAIL_TYPE.Transactional || rule.bypassThrottle) return true;
-    const overrides = rule.throttleOverride || {};
-    const dailyLimit = overrides.maxPerUserPerDay ?? config.maxPerUserPerDay;
-    const weeklyLimit = overrides.maxPerUserPerWeek ?? config.maxPerUserPerWeek;
-    const minGap = overrides.minGapDays ?? config.minGapDays;
-    const userThrottle = throttleMap.get(userId) || { today: 0, thisWeek: 0, lastSentDate: null };
-    if (userThrottle.today >= dailyLimit) {
-      stats.skippedByThrottle++;
-      this.emitSendEvent(rule, email, "throttled", templateId || "", runId || "", { failureReason: "daily throttle limit" });
-      return false;
-    }
-    if (userThrottle.thisWeek >= weeklyLimit) {
-      stats.skippedByThrottle++;
-      this.emitSendEvent(rule, email, "throttled", templateId || "", runId || "", { failureReason: "weekly throttle limit" });
-      return false;
-    }
-    if (userThrottle.lastSentDate) {
-      const daysSinceLastSend = (Date.now() - userThrottle.lastSentDate.getTime()) / MS_PER_DAY;
-      if (daysSinceLastSend < minGap) {
-        stats.skippedByThrottle++;
-        this.emitSendEvent(rule, email, "throttled", templateId || "", runId || "", { failureReason: "min gap days" });
-        return false;
-      }
-    }
-    return true;
-  }
-  getTodayStart() {
-    const timezone = this.config.options?.sendWindow?.timezone;
-    if (timezone) {
-      const now = /* @__PURE__ */ new Date();
-      const parts = new Intl.DateTimeFormat("en-US", {
-        timeZone: timezone,
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-        hour12: false
-      }).formatToParts(now);
-      const get = (type) => parts.find((p) => p.type === type)?.value || "0";
-      const tzNowMs = Date.UTC(
-        parseInt(get("year")),
-        parseInt(get("month")) - 1,
-        parseInt(get("day")),
-        parseInt(get("hour")),
-        parseInt(get("minute")),
-        parseInt(get("second"))
-      );
-      const tzMidnightMs = Date.UTC(
-        parseInt(get("year")),
-        parseInt(get("month")) - 1,
-        parseInt(get("day"))
-      );
-      const offsetMs = now.getTime() - tzNowMs;
-      return new Date(tzMidnightMs + offsetMs);
-    }
-    const todayStart = /* @__PURE__ */ new Date();
-    todayStart.setHours(0, 0, 0, 0);
-    return todayStart;
-  }
-  async updateRunProgress(runId, data) {
-    const key = `${this.keyPrefix}run:${runId}:progress`;
-    const flat = [];
-    for (const [k, v] of Object.entries(data)) {
-      if (typeof v === "object" && v !== null) {
-        flat.push(k, JSON.stringify(v));
-      } else {
-        flat.push(k, String(v));
-      }
-    }
-    if (flat.length > 0) {
-      await this.redis.hset(key, ...flat);
-      await this.redis.expire(key, 3600);
-    }
-  }
-  async updateRunSendProgress(runId, stats) {
-    const key = `${this.keyPrefix}run:${runId}:progress`;
-    const existing = await this.redis.hget(key, "progress");
-    let progress = { rulesTotal: 0, rulesCompleted: 0, sent: 0, failed: 0, skipped: 0, invalid: 0 };
-    if (existing) {
-      try {
-        progress = JSON.parse(existing);
-      } catch {
-      }
-    }
-    progress.sent = stats.sent;
-    progress.failed = stats.errorCount;
-    progress.skipped = stats.skipped + stats.skippedByThrottle;
-    await this.redis.hset(key, "progress", JSON.stringify(progress));
-    await this.redis.expire(key, 3600);
-  }
-  async getStatus(runId) {
-    const key = `${this.keyPrefix}run:${runId}:progress`;
-    const data = await this.redis.hgetall(key);
-    if (!data || Object.keys(data).length === 0) return null;
-    let progress = { rulesTotal: 0, rulesCompleted: 0, sent: 0, failed: 0, skipped: 0, invalid: 0 };
-    if (data.progress) {
-      try {
-        progress = JSON.parse(data.progress);
-      } catch {
-      }
-    }
-    return {
-      runId: data.runId || runId,
-      status: data.status || "running",
-      currentRule: data.currentRule || "",
-      progress,
-      startedAt: data.startedAt || "",
-      elapsed: parseInt(data.elapsed || "0", 10)
-    };
-  }
-  async cancel(runId) {
-    const progressKey = `${this.keyPrefix}run:${runId}:progress`;
-    const exists = await this.redis.exists(progressKey);
-    if (!exists) return { ok: false };
-    const cancelKey = `${this.keyPrefix}run:${runId}:cancel`;
-    await this.redis.set(cancelKey, "1", "EX", 3600);
-    return { ok: true };
-  }
-  trigger(triggeredBy) {
-    const runId = crypto__default.default.randomUUID();
-    this.runAllRules(triggeredBy || RUN_TRIGGER.Manual, runId).catch((err) => {
-      this.logger.error("Background rule run failed", { error: err, runId });
-      this.updateRunProgress(runId, { status: "failed" }).catch(() => {
-      });
-    });
-    return { runId, started: true };
-  }
-  buildThrottleMap(recentSends) {
-    const map = /* @__PURE__ */ new Map();
-    const todayStart = this.getTodayStart();
-    for (const send of recentSends) {
-      const key = send.userId.toString();
-      const current = map.get(key) || { today: 0, thisWeek: 0, lastSentDate: null };
-      const sentAt = new Date(send.sentAt);
-      current.thisWeek++;
-      if (sentAt >= todayStart) {
-        current.today++;
-      }
-      if (!current.lastSentDate || sentAt > current.lastSentDate) {
-        current.lastSentDate = sentAt;
-      }
-      map.set(key, current);
-    }
-    return map;
-  }
-};
-
-// src/utils/controller.ts
-function getErrorStatus(message) {
-  if (message.includes("not found")) return 404;
-  if (message.includes("already exists") || message.includes("validation failed") || message.includes("mismatch") || message.includes("Cannot activate") || message.includes("Cannot delete")) return 400;
-  return 500;
-}
-function isValidValue(allowed, value) {
-  return typeof value === "string" && allowed.includes(value);
-}
-function asyncHandler(handler) {
-  return (req, res) => {
-    handler(req, res).catch((error) => {
-      if (res.headersSent) return;
-      const message = error instanceof Error ? error.message : "Unknown error";
-      const status = getErrorStatus(message);
-      res.status(status).json({ success: false, error: message });
-    });
   };
+  return ruleEngine.createRuleEngine(coreConfig);
 }
 
-// src/controllers/template.controller.ts
-function createTemplateController(templateService, options) {
-  const platformValues = options?.platforms;
-  const validCategories = options?.categories || Object.values(TEMPLATE_CATEGORY);
-  const validAudiences = options?.audiences || Object.values(TEMPLATE_AUDIENCE);
-  const list = asyncHandler(async (req, res) => {
-    const { category, audience, platform, isActive, page, limit } = req.query;
-    const { templates, total } = await templateService.list({
-      category,
-      audience,
-      platform,
-      isActive: isActive !== void 0 ? isActive === "true" : void 0,
-      ...calculatePagination(parseInt(String(page), 10) || void 0, parseInt(String(limit), 10) || void 0)
-    });
-    res.json({ success: true, data: { templates, total } });
-  });
-  const getById = asyncHandler(async (req, res) => {
-    const template = await templateService.getById(core.getParam(req, "id"));
-    if (!template) {
-      return res.status(404).json({ success: false, error: "Template not found" });
-    }
-    res.json({ success: true, data: { template } });
-  });
-  const create = asyncHandler(async (req, res) => {
-    const { name, subjects, bodies, category, audience, platform, preheaders } = req.body;
-    if (!name || !subjects || subjects.length === 0 || !bodies || bodies.length === 0 || !category || !audience || !platform) {
-      return res.status(400).json({ success: false, error: "name, subjects, bodies, category, audience, and platform are required" });
-    }
-    if (!isValidValue(validCategories, category)) {
-      return res.status(400).json({ success: false, error: `Invalid category. Must be one of: ${validCategories.join(", ")}` });
-    }
-    if (!isValidValue(validAudiences, audience)) {
-      return res.status(400).json({ success: false, error: `Invalid audience. Must be one of: ${validAudiences.join(", ")}` });
-    }
-    if (platformValues && !platformValues.includes(platform)) {
-      return res.status(400).json({ success: false, error: `Invalid platform. Must be one of: ${platformValues.join(", ")}` });
-    }
-    const template = await templateService.create(req.body);
-    res.status(201).json({ success: true, data: { template } });
-  });
-  const update = asyncHandler(async (req, res) => {
-    const template = await templateService.update(core.getParam(req, "id"), req.body);
-    if (!template) {
-      return res.status(404).json({ success: false, error: "Template not found" });
-    }
-    res.json({ success: true, data: { template } });
-  });
-  const remove = asyncHandler(async (req, res) => {
-    const deleted = await templateService.delete(core.getParam(req, "id"));
-    if (!deleted) {
-      return res.status(404).json({ success: false, error: "Template not found" });
-    }
-    res.json({ success: true });
-  });
-  const toggleActive = asyncHandler(async (req, res) => {
-    const template = await templateService.toggleActive(core.getParam(req, "id"));
-    if (!template) {
-      return res.status(404).json({ success: false, error: "Template not found" });
-    }
-    res.json({ success: true, data: { template } });
-  });
-  const preview = asyncHandler(async (req, res) => {
-    const { sampleData } = req.body;
-    const result = await templateService.preview(core.getParam(req, "id"), sampleData || {});
-    if (!result) {
-      return res.status(404).json({ success: false, error: "Template not found" });
-    }
-    res.json({ success: true, data: result });
-  });
-  const previewRaw = asyncHandler(async (req, res) => {
-    const { subject, body, textBody, sampleData, variables } = req.body;
-    if (!subject || !body) {
-      return res.status(400).json({ success: false, error: "subject and body are required" });
-    }
-    const result = await templateService.previewRaw(subject, body, sampleData || {}, variables, textBody);
-    res.json({ success: true, data: result });
-  });
-  const validate = asyncHandler(async (req, res) => {
-    const { body: templateBody } = req.body;
-    if (!templateBody) {
-      return res.status(400).json({ success: false, error: "body is required" });
-    }
-    const result = await templateService.validate(templateBody);
-    res.json({ success: true, data: result });
-  });
-  const clone = asyncHandler(async (req, res) => {
-    const { name } = req.body;
-    const result = await templateService.clone(core.getParam(req, "id"), name);
-    res.json({ success: true, data: result });
-  });
-  const sendTestEmail = asyncHandler(async (req, res) => {
-    const { testEmail, sampleData } = req.body;
-    if (!testEmail) {
-      return res.status(400).json({ success: false, error: "testEmail is required" });
-    }
-    const result = await templateService.sendTestEmail(core.getParam(req, "id"), testEmail, sampleData || {});
-    if (!result.success) {
-      return res.status(400).json({ success: false, error: result.error });
-    }
-    res.json({ success: true });
-  });
-  const previewWithRecipient = asyncHandler(async (req, res) => {
-    const { recipientData } = req.body;
-    if (!recipientData || typeof recipientData !== "object") {
-      return res.status(400).json({ success: false, error: "recipientData object is required" });
-    }
-    const result = await templateService.previewWithRecipient(core.getParam(req, "id"), recipientData);
-    if (!result) {
-      return res.status(404).json({ success: false, error: "Template not found" });
-    }
-    res.json({ success: true, data: result });
-  });
-  return { list, getById, create, update, remove, toggleActive, preview, previewRaw, validate, sendTestEmail, clone, previewWithRecipient };
-}
-function createRuleController(ruleService, options) {
-  const platformValues = options?.platforms;
-  const validAudiences = options?.audiences || Object.values(TEMPLATE_AUDIENCE);
-  const validEmailTypes = Object.values(EMAIL_TYPE);
-  const list = asyncHandler(async (req, res) => {
-    const { page, limit } = calculatePagination(
-      parseInt(String(req.query.page), 10) || void 0,
-      parseInt(String(req.query.limit), 10) || void 0
-    );
-    const { rules, total } = await ruleService.list({ page, limit });
-    res.json({ success: true, data: { rules, total } });
-  });
-  const getById = asyncHandler(async (req, res) => {
-    const rule = await ruleService.getById(core.getParam(req, "id"));
-    if (!rule) {
-      return res.status(404).json({ success: false, error: "Rule not found" });
-    }
-    res.json({ success: true, data: { rule } });
-  });
-  const create = asyncHandler(async (req, res) => {
-    const { name, target, templateId } = req.body;
-    if (!name || !target || !templateId) {
-      return res.status(400).json({ success: false, error: "name, target, and templateId are required" });
-    }
-    const mode = target.mode || "query";
-    if (mode === "list") {
-      if (!Array.isArray(target.identifiers) || target.identifiers.length === 0) {
-        return res.status(400).json({ success: false, error: "target.identifiers must be a non-empty array for list mode" });
-      }
-    } else {
-      if (!target.role || !isValidValue(validAudiences, target.role)) {
-        return res.status(400).json({ success: false, error: `Invalid target.role. Must be one of: ${validAudiences.join(", ")}` });
-      }
-      if (platformValues && !platformValues.includes(target.platform)) {
-        return res.status(400).json({ success: false, error: `Invalid target.platform. Must be one of: ${platformValues.join(", ")}` });
-      }
-      if (!Array.isArray(target.conditions)) {
-        return res.status(400).json({ success: false, error: "target.conditions must be an array" });
-      }
-    }
-    if (req.body.emailType && !isValidValue(validEmailTypes, req.body.emailType)) {
-      return res.status(400).json({ success: false, error: `Invalid emailType. Must be one of: ${validEmailTypes.join(", ")}` });
-    }
-    const rule = await ruleService.create(req.body);
-    res.status(201).json({ success: true, data: { rule } });
-  });
-  const update = asyncHandler(async (req, res) => {
-    const { target, emailType } = req.body;
-    if (target) {
-      const mode = target.mode || "query";
-      if (mode === "list") {
-        if (target.identifiers && (!Array.isArray(target.identifiers) || target.identifiers.length === 0)) {
-          return res.status(400).json({ success: false, error: "target.identifiers must be a non-empty array for list mode" });
-        }
-      } else {
-        if (target.role && !isValidValue(validAudiences, target.role)) {
-          return res.status(400).json({ success: false, error: `Invalid target.role. Must be one of: ${validAudiences.join(", ")}` });
-        }
-        if (target.platform && platformValues && !platformValues.includes(target.platform)) {
-          return res.status(400).json({ success: false, error: `Invalid target.platform. Must be one of: ${platformValues.join(", ")}` });
-        }
-        if (target.conditions && !Array.isArray(target.conditions)) {
-          return res.status(400).json({ success: false, error: "target.conditions must be an array" });
-        }
-      }
-    }
-    if (emailType && !isValidValue(validEmailTypes, emailType)) {
-      return res.status(400).json({ success: false, error: `Invalid emailType. Must be one of: ${validEmailTypes.join(", ")}` });
-    }
-    const rule = await ruleService.update(core.getParam(req, "id"), req.body);
-    if (!rule) {
-      return res.status(404).json({ success: false, error: "Rule not found" });
-    }
-    res.json({ success: true, data: { rule } });
-  });
-  const remove = asyncHandler(async (req, res) => {
-    const result = await ruleService.delete(core.getParam(req, "id"));
-    if (!result.deleted && !result.disabled) {
-      return res.status(404).json({ success: false, error: "Rule not found" });
-    }
-    res.json({ success: true, data: result });
-  });
-  const toggleActive = asyncHandler(async (req, res) => {
-    const rule = await ruleService.toggleActive(core.getParam(req, "id"));
-    if (!rule) {
-      return res.status(404).json({ success: false, error: "Rule not found" });
-    }
-    res.json({ success: true, data: { rule } });
-  });
-  const dryRun = asyncHandler(async (req, res) => {
-    const result = await ruleService.dryRun(core.getParam(req, "id"));
-    res.json({ success: true, data: result });
-  });
-  const clone = asyncHandler(async (req, res) => {
-    const { name } = req.body;
-    const result = await ruleService.clone(core.getParam(req, "id"), name);
-    res.json({ success: true, data: result });
-  });
-  const runHistory = asyncHandler(async (req, res) => {
-    const { page, limit } = calculatePagination(
-      parseInt(String(req.query.page), 10) || void 0,
-      parseInt(String(req.query.limit), 10) || 20
-    );
-    const from = req.query.from ? String(req.query.from) : void 0;
-    const to = req.query.to ? String(req.query.to) : void 0;
-    const logs = await ruleService.getRunHistory(limit, { page, from, to });
-    const total = await ruleService.getRunHistoryCount({ from, to });
-    res.json({ success: true, data: { logs, total } });
-  });
-  return { list, getById, create, update, remove, toggleActive, dryRun, runHistory, clone };
-}
-function createRunnerController(runnerService, EmailRuleRunLog, logger) {
-  const triggerManualRun = asyncHandler(async (_req, res) => {
-    const { runId } = runnerService.trigger(RUN_TRIGGER.Manual);
-    res.json({ success: true, data: { message: "Rule run triggered", runId } });
-  });
-  const getLatestRun = asyncHandler(async (_req, res) => {
-    const latestRun = await EmailRuleRunLog.findOne().sort({ runAt: -1 });
-    res.json({ success: true, data: { latestRun } });
-  });
-  const getStatusByRunId = asyncHandler(async (req, res) => {
-    const status = await runnerService.getStatus(core.getParam(req, "runId"));
-    if (!status) {
-      res.status(404).json({ success: false, error: "Run not found" });
-      return;
-    }
-    res.json({ success: true, data: status });
-  });
-  const cancelRun = asyncHandler(async (req, res) => {
-    const result = await runnerService.cancel(core.getParam(req, "runId"));
-    if (!result.ok) {
-      res.status(404).json({ success: false, error: "Run not found" });
-      return;
-    }
-    res.json({ success: true, data: { message: "Cancel requested" } });
-  });
-  return { triggerManualRun, getLatestRun, getStatusByRunId, cancelRun };
-}
-
-// src/controllers/settings.controller.ts
-function createSettingsController(EmailThrottleConfig) {
-  const getThrottleConfig = asyncHandler(async (_req, res) => {
-    const config = await EmailThrottleConfig.getConfig();
-    res.json({ success: true, data: { config } });
-  });
-  const updateThrottleConfig = asyncHandler(async (req, res) => {
-    const { maxPerUserPerDay, maxPerUserPerWeek, minGapDays } = req.body;
-    const updates = {};
-    if (maxPerUserPerDay !== void 0) {
-      if (!Number.isInteger(maxPerUserPerDay) || maxPerUserPerDay < 1) {
-        return res.status(400).json({ success: false, error: "maxPerUserPerDay must be a positive integer" });
-      }
-      updates.maxPerUserPerDay = maxPerUserPerDay;
-    }
-    if (maxPerUserPerWeek !== void 0) {
-      if (!Number.isInteger(maxPerUserPerWeek) || maxPerUserPerWeek < 1) {
-        return res.status(400).json({ success: false, error: "maxPerUserPerWeek must be a positive integer" });
-      }
-      updates.maxPerUserPerWeek = maxPerUserPerWeek;
-    }
-    if (minGapDays !== void 0) {
-      if (!Number.isInteger(minGapDays) || minGapDays < 0) {
-        return res.status(400).json({ success: false, error: "minGapDays must be a non-negative integer" });
-      }
-      updates.minGapDays = minGapDays;
-    }
-    if (Object.keys(updates).length === 0) {
-      return res.status(400).json({ success: false, error: "No valid fields to update" });
-    }
-    const config = await EmailThrottleConfig.getConfig();
-    const finalDaily = updates.maxPerUserPerDay ?? config.maxPerUserPerDay;
-    const finalWeekly = updates.maxPerUserPerWeek ?? config.maxPerUserPerWeek;
-    if (finalWeekly < finalDaily) {
-      return res.status(400).json({ success: false, error: "maxPerUserPerWeek must be >= maxPerUserPerDay" });
-    }
-    const updated = await EmailThrottleConfig.findByIdAndUpdate(
-      config._id,
-      { $set: updates },
-      { new: true }
-    );
-    res.json({ success: true, data: { config: updated } });
-  });
-  return { getThrottleConfig, updateThrottleConfig };
-}
-
-// src/controllers/send-log.controller.ts
-function createSendLogController(EmailRuleSend) {
-  const list = asyncHandler(async (req, res) => {
-    const { ruleId, status, email, from, to, page, limit } = req.query;
-    const filter = {};
-    if (ruleId) filter.ruleId = ruleId;
-    if (status) filter.status = status;
-    if (email) filter.userId = { $regex: email, $options: "i" };
-    Object.assign(filter, buildDateRangeFilter("sentAt", from, to));
-    const pagination = calculatePagination(Number(page) || void 0, Number(limit) || 50, 200);
-    const [sends, total] = await Promise.all([
-      EmailRuleSend.find(filter).sort({ sentAt: -1 }).skip(pagination.skip).limit(pagination.limit).lean(),
-      EmailRuleSend.countDocuments(filter)
-    ]);
-    res.json({ success: true, data: { sends, total } });
-  });
-  return { list };
-}
-
-// src/routes/index.ts
-function createRoutes(deps) {
-  const router = express.Router();
-  const templateCtrl = createTemplateController(deps.templateService, {
-    platforms: deps.platformValues,
-    categories: deps.categoryValues,
-    audiences: deps.audienceValues
-  });
-  const ruleCtrl = createRuleController(deps.ruleService, {
-    platforms: deps.platformValues,
-    audiences: deps.audienceValues
-  });
-  const runnerCtrl = createRunnerController(deps.runnerService, deps.EmailRuleRunLog);
-  const settingsCtrl = createSettingsController(deps.EmailThrottleConfig);
-  const sendLogCtrl = createSendLogController(deps.EmailRuleSend);
-  const collectionCtrl = createCollectionController(deps.collections || []);
-  const templateRouter = express.Router();
-  templateRouter.get("/", templateCtrl.list);
-  templateRouter.post("/", templateCtrl.create);
-  templateRouter.post("/validate", templateCtrl.validate);
-  templateRouter.post("/preview", templateCtrl.previewRaw);
-  templateRouter.get("/:id", templateCtrl.getById);
-  templateRouter.put("/:id", templateCtrl.update);
-  templateRouter.delete("/:id", templateCtrl.remove);
-  templateRouter.patch("/:id/toggle", templateCtrl.toggleActive);
-  templateRouter.post("/:id/preview", templateCtrl.preview);
-  templateRouter.post("/:id/test-email", templateCtrl.sendTestEmail);
-  templateRouter.post("/:id/preview-with-data", templateCtrl.previewWithRecipient);
-  templateRouter.post("/:id/clone", templateCtrl.clone);
-  const ruleRouter = express.Router();
-  ruleRouter.get("/", ruleCtrl.list);
-  ruleRouter.post("/", ruleCtrl.create);
-  ruleRouter.get("/:id", ruleCtrl.getById);
-  ruleRouter.patch("/:id", ruleCtrl.update);
-  ruleRouter.delete("/:id", ruleCtrl.remove);
-  ruleRouter.post("/:id/toggle", ruleCtrl.toggleActive);
-  ruleRouter.post("/:id/dry-run", ruleCtrl.dryRun);
-  ruleRouter.post("/:id/clone", ruleCtrl.clone);
-  const runnerRouter = express.Router();
-  runnerRouter.post("/", runnerCtrl.triggerManualRun);
-  runnerRouter.get("/status", runnerCtrl.getLatestRun);
-  runnerRouter.get("/status/:runId", runnerCtrl.getStatusByRunId);
-  runnerRouter.post("/cancel/:runId", runnerCtrl.cancelRun);
-  runnerRouter.get("/logs", ruleCtrl.runHistory);
-  const sendLogRouter = express.Router();
-  sendLogRouter.get("/", sendLogCtrl.list);
-  const collectionRouter = express.Router();
-  collectionRouter.get("/", collectionCtrl.list);
-  collectionRouter.get("/:name/fields", collectionCtrl.getFields);
-  router.use("/templates", templateRouter);
-  router.use("/rules", ruleRouter);
-  router.use("/runner", runnerRouter);
-  router.use("/sends", sendLogRouter);
-  router.use("/collections", collectionRouter);
-  router.get("/throttle", settingsCtrl.getThrottleConfig);
-  router.put("/throttle", settingsCtrl.updateThrottleConfig);
-  return router;
-}
-var configSchema = zod.z.object({
-  db: core.baseDbSchema,
-  redis: core.baseRedisSchema,
-  adapters: zod.z.object({
-    queryUsers: zod.z.function(),
-    resolveData: zod.z.function(),
-    sendEmail: zod.z.function(),
-    selectAgent: zod.z.function(),
-    findIdentifier: zod.z.function(),
-    sendTestEmail: zod.z.function().optional()
-  }),
-  collections: zod.z.array(zod.z.object({
-    name: zod.z.string(),
-    label: zod.z.string().optional(),
-    description: zod.z.string().optional(),
-    identifierField: zod.z.string().optional(),
-    fields: zod.z.array(zod.z.any()),
-    joins: zod.z.array(zod.z.object({
-      from: zod.z.string(),
-      localField: zod.z.string(),
-      foreignField: zod.z.string(),
-      as: zod.z.string()
-    })).optional()
-  })).optional(),
-  platforms: zod.z.array(zod.z.string()).optional(),
-  audiences: zod.z.array(zod.z.string()).optional(),
-  categories: zod.z.array(zod.z.string()).optional(),
-  logger: core.loggerSchema.optional(),
-  options: zod.z.object({
-    lockTTLMs: zod.z.number().positive().optional(),
-    defaultMaxPerRun: zod.z.number().positive().optional(),
-    sendWindow: zod.z.object({
-      startHour: zod.z.number().min(0).max(23),
-      endHour: zod.z.number().min(0).max(23),
-      timezone: zod.z.string()
-    }).optional(),
-    delayBetweenSendsMs: zod.z.number().min(0).optional(),
-    jitterMs: zod.z.number().min(0).optional()
-  }).optional(),
-  hooks: zod.z.object({
-    onRunStart: zod.z.function().optional(),
-    onRuleStart: zod.z.function().optional(),
-    onSend: zod.z.function().optional(),
-    onRuleComplete: zod.z.function().optional(),
-    onRunComplete: 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 EmailRuleEngineConfig:
-${issues}`,
-      result.error.issues[0]?.path.join(".") ?? ""
-    );
-  }
-}
-var SchedulerService = class {
-  queue;
-  worker;
-  keyPrefix;
-  constructor(connection, keyPrefix = "") {
-    this.keyPrefix = keyPrefix;
-    const connectionOpts = { host: connection.options?.host, port: connection.options?.port, password: connection.options?.password, db: connection.options?.db };
-    this.queue = new bullmq.Queue("email-scheduler", { connection: connectionOpts, prefix: keyPrefix });
-  }
-  async syncRule(rule) {
-    const ruleId = String(rule._id);
-    const jobId = `sched-${ruleId}`;
-    const existing = await this.queue.getRepeatableJobs();
-    for (const job of existing) {
-      if (job.id === jobId) {
-        await this.queue.removeRepeatableByKey(job.key);
-      }
-    }
-    if (rule.schedule?.enabled && rule.schedule.cron) {
-      await this.queue.add("run-scheduled", { ruleId }, {
-        repeat: { pattern: rule.schedule.cron, tz: rule.schedule.timezone || "UTC" },
-        jobId
-      });
-    }
-  }
-  async removeRule(ruleId) {
-    const jobId = `sched-${ruleId}`;
-    const existing = await this.queue.getRepeatableJobs();
-    for (const job of existing) {
-      if (job.id === jobId) {
-        await this.queue.removeRepeatableByKey(job.key);
-      }
-    }
-  }
-  startWorker(runFn) {
-    const connectionOpts = this.queue.opts?.connection;
-    this.worker = new bullmq.Worker("email-scheduler", async (job) => {
-      const { ruleId } = job.data;
-      await runFn(`scheduled:${ruleId}`);
-    }, { connection: connectionOpts, prefix: this.keyPrefix });
-  }
-  async stopWorker() {
-    if (this.worker) {
-      await this.worker.close();
-      this.worker = void 0;
-    }
-  }
-  async getScheduledJobs() {
-    const jobs = await this.queue.getRepeatableJobs();
-    return jobs.map((j) => ({
-      ruleId: (j.id || "").replace("sched-", ""),
-      cron: j.pattern || "",
-      next: j.next ?? null
-    }));
-  }
-};
-
-// src/index.ts
-function createEmailRuleEngine(config) {
-  validateConfig(config);
-  const conn = config.db.connection;
-  const prefix = config.db.collectionPrefix || "";
-  const EmailTemplate = conn.model(
-    `${prefix}EmailTemplate`,
-    createEmailTemplateSchema(config.platforms, config.audiences, config.categories, prefix)
-  );
-  const EmailRule = conn.model(
-    `${prefix}EmailRule`,
-    createEmailRuleSchema(config.platforms, config.audiences, prefix)
-  );
-  const EmailRuleSend = conn.model(
-    `${prefix}EmailRuleSend`,
-    createEmailRuleSendSchema(prefix)
-  );
-  const EmailRuleRunLog = conn.model(
-    `${prefix}EmailRuleRunLog`,
-    createEmailRuleRunLogSchema(prefix)
-  );
-  const EmailThrottleConfig = conn.model(
-    `${prefix}EmailThrottleConfig`,
-    createEmailThrottleConfigSchema(prefix)
-  );
-  const templateService = new TemplateService(EmailTemplate, config, EmailRule);
-  const ruleService = new RuleService(EmailRule, EmailTemplate, EmailRuleRunLog, config);
-  const runnerService = new RuleRunnerService(
-    EmailRule,
-    EmailTemplate,
-    EmailRuleSend,
-    EmailRuleRunLog,
-    EmailThrottleConfig,
-    config
-  );
-  const routes = createRoutes({
-    templateService,
-    ruleService,
-    runnerService,
-    EmailRuleRunLog,
-    EmailRuleSend,
-    EmailThrottleConfig,
-    platformValues: config.platforms,
-    categoryValues: config.categories,
-    audienceValues: config.audiences,
-    logger: config.logger,
-    collections: config.collections || []
+exports.createEmailRuleEngine = createEmailRuleEngine;
+exports.htmlToPlainText = htmlToPlainText;
+exports.registerEmailHelpers = registerEmailHelpers;
+exports.renderMjml = renderMjml;
+Object.keys(ruleEngine).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return ruleEngine[k]; }
   });
-  return {
-    routes,
-    runner: runnerService,
-    templateService,
-    ruleService,
-    models: { EmailTemplate, EmailRule, EmailRuleSend, EmailRuleRunLog, EmailThrottleConfig }
-  };
-}
-
-Object.defineProperty(exports, "RedisLock", {
-  enumerable: true,
-  get: function () { return core.RedisLock; }
 });
-exports.AlxEmailError = AlxEmailError;
-exports.ConfigValidationError = ConfigValidationError;
-exports.DuplicateSlugError = DuplicateSlugError;
-exports.EMAIL_SEND_STATUS = EMAIL_SEND_STATUS;
-exports.EMAIL_TYPE = EMAIL_TYPE;
-exports.FIELD_TYPE = FIELD_TYPE;
-exports.LockAcquisitionError = LockAcquisitionError;
-exports.RULE_OPERATOR = RULE_OPERATOR;
-exports.RUN_LOG_STATUS = RUN_LOG_STATUS;
-exports.RUN_TRIGGER = RUN_TRIGGER;
-exports.RuleNotFoundError = RuleNotFoundError;
-exports.RuleRunnerService = RuleRunnerService;
-exports.RuleService = RuleService;
-exports.RuleTemplateIncompatibleError = RuleTemplateIncompatibleError;
-exports.SchedulerService = SchedulerService;
-exports.TARGET_MODE = TARGET_MODE;
-exports.TEMPLATE_AUDIENCE = TEMPLATE_AUDIENCE;
-exports.TEMPLATE_CATEGORY = TEMPLATE_CATEGORY;
-exports.THROTTLE_WINDOW = THROTTLE_WINDOW;
-exports.TYPE_OPERATORS = TYPE_OPERATORS;
-exports.TemplateNotFoundError = TemplateNotFoundError;
-exports.TemplateRenderService = TemplateRenderService;
-exports.TemplateService = TemplateService;
-exports.TemplateSyntaxError = TemplateSyntaxError;
-exports.createEmailRuleEngine = createEmailRuleEngine;
-exports.createEmailRuleRunLogSchema = createEmailRuleRunLogSchema;
-exports.createEmailRuleSchema = createEmailRuleSchema;
-exports.createEmailRuleSendSchema = createEmailRuleSendSchema;
-exports.createEmailTemplateSchema = createEmailTemplateSchema;
-exports.createEmailThrottleConfigSchema = createEmailThrottleConfigSchema;
-exports.flattenFields = flattenFields;
-exports.validateConditions = validateConditions;
-exports.validateConfig = validateConfig;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map