@vicacha-devs/strapi-plugin-broadcasts 0.0.0-stage → 0.1.0

package/dist/server/index.mjs

@@ -0,0 +1,3399 @@
+import { SUPPORTED_INTL_CALENDARS } from "@vicacha-devs/strapi-plugin-calendar/shared";
+import { createHmac, randomBytes } from "node:crypto";
+function isSupportedCalendar(cal) {
+  if (typeof cal !== "string" || !cal.trim()) return false;
+  return SUPPORTED_INTL_CALENDARS.some((item) => item.id === cal.trim());
+}
+function formatSecondaryDate(isoDateString, calendar = "islamic-umalqura", locale = "es") {
+  if (!isoDateString) {
+    return { calendar, formatted: "" };
+  }
+  const date = new Date(isoDateString);
+  if (Number.isNaN(date.getTime())) {
+    return { calendar, formatted: isoDateString };
+  }
+  try {
+    const formatter = new Intl.DateTimeFormat(`${locale}-u-ca-${calendar}`, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+    const parts = formatter.formatToParts(date);
+    const year = Number(parts.find((p) => p.type === "year")?.value) || void 0;
+    const month = Number(parts.find((p) => p.type === "month")?.value) || void 0;
+    const day = Number(parts.find((p) => p.type === "day")?.value) || void 0;
+    return {
+      calendar,
+      formatted: formatter.format(date),
+      year,
+      month,
+      day
+    };
+  } catch {
+    return {
+      calendar,
+      formatted: date.toISOString().slice(0, 10)
+    };
+  }
+}
+const PLUGIN_ID = "broadcasts";
+const CAMPAIGN_UID = "plugin::broadcasts.campaign";
+const AUTOMATION_RULE_UID = "plugin::broadcasts.automation-rule";
+const DELIVERY_LOG_UID = "plugin::broadcasts.delivery-log";
+const SUPPORTED_CHANNELS = [
+  "email",
+  "telegram",
+  "whatsapp"
+];
+const SUPPORTED_WHATSAPP_DRIVERS = [
+  "meta-cloud",
+  "openwa",
+  "evolution"
+];
+const DEFAULT_BROADCAST_TOPICS = [
+  "announcements",
+  "events",
+  "courses",
+  "ramadan_eid",
+  "urgent_janazah",
+  "newsletter"
+];
+const DEFAULT_BROADCAST_SETTINGS = {
+  primaryCalendar: "gregory",
+  secondaryCalendars: ["islamic-umalqura"],
+  defaultLocale: "es",
+  supportedLocales: ["es", "en", "ar", "tr"],
+  availableTopics: [...DEFAULT_BROADCAST_TOPICS],
+  dryRun: true,
+  enableInboxSubscriberBridge: true,
+  enableEventHubAutomations: true,
+  enableEmailDesignerBridge: true,
+  defaultEmailTemplateRef: "",
+  siteBaseUrl: "https://mezquitabogota.org",
+  organizationName: "Mezquita Central Abu Bakr As-Siddiq — Bogotá",
+  emailFromAddress: "no-reply@mezquitabogota.org",
+  emailReplyToAddress: "info@mezquitabogota.org",
+  telegramEnabled: true,
+  telegramBotToken: "",
+  telegramDefaultChatId: "@MezquitaCentralBogota",
+  telegramTopicChatMap: {},
+  telegramTopicThreadMap: {},
+  whatsappEnabled: true,
+  whatsappDriver: "meta-cloud",
+  whatsappPhoneNumberId: "",
+  whatsappAccessToken: "",
+  whatsappGatewayUrl: "",
+  whatsappGatewaySession: "default",
+  whatsappGatewayApiKey: "",
+  whatsappDefaultRecipients: [],
+  whatsappTopicGroupMap: {},
+  allowLocalhostGateways: false,
+  publicChannelLinks: [
+    {
+      id: "telegram-main",
+      channel: "telegram",
+      label: "Canal Oficial de Telegram",
+      handle: "@MezquitaCentralBogota",
+      inviteUrl: "https://t.me/MezquitaCentralBogota",
+      topic: "announcements",
+      localizedLabels: {
+        es: "Canal Oficial de Telegram",
+        en: "Official Telegram Channel",
+        ar: "القناة الرسمية على تيليجرام",
+        tr: "Resmi Telegram Kanalı"
+      },
+      localizedDescriptions: {
+        es: "Horarios de Jumu’ah, avistamiento lunar de Ramadán, cursos y avisos urgentes.",
+        en: "Jumu’ah schedules, Ramadan moon sighting, courses, and urgent community notices.",
+        ar: "مواعيد صلاة الجمعة، تحري هلال رمضان، الدورات والإعلانات العاجلة.",
+        tr: "Cuma vakitleri, Ramazan hilal gözlemi, kurslar ve acil duyurular."
+      }
+    },
+    {
+      id: "whatsapp-community",
+      channel: "whatsapp",
+      label: "Comunidad Oficial de WhatsApp",
+      handle: "+57 310 000 0000",
+      inviteUrl: "https://whatsapp.com/channel/0029VaMezquitaBogota",
+      topic: "announcements",
+      localizedLabels: {
+        es: "Comunidad Oficial de WhatsApp",
+        en: "Official WhatsApp Community",
+        ar: "مجتمع واتساب الرسمي",
+        tr: "Resmi WhatsApp Topluluğu"
+      },
+      localizedDescriptions: {
+        es: "Alertas directas de oración funeraria (Janazah), eventos comunitarios y boletín semanal.",
+        en: "Direct Janazah funeral prayer alerts, community events, and weekly newsletter.",
+        ar: "تنبيهات صلاة الجنازة العاجلة، الفعاليات المجتمعية والنشرة الأسبوعية.",
+        tr: "Acil cenaze namazı duyuruları, topluluk etkinlikleri ve haftalık bülten."
+      }
+    }
+  ]
+};
+const STARTER_CAMPAIGN_TEMPLATES = [
+  {
+    id: "jumuah-weekly-reminder",
+    slug: "jumuah-weekly-reminder",
+    title: "Recordatorio Semanal de Khutbah y Oración del Viernes (Jumu’ah)",
+    topic: "announcements",
+    channels: ["email", "telegram", "whatsapp"],
+    priority: "normal",
+    subject: "🕌 Jumu’ah en {{organizationName}} ({{secondaryDate}})",
+    bodyText: "As-salamu alaykum {{recipientName}}. Te esperamos este viernes para la Khutbah y oración de Jumu’ah en {{organizationName}}. Fecha Hijri: {{secondaryDate}}.",
+    bodyHtml: "<p>As-salamu alaykum <strong>{{recipientName}}</strong>,</p><p>Te esperamos este viernes para la Khutbah y oración congregacional de <strong>Jumu’ah</strong> en {{organizationName}}.</p><p>Calendario Hijri: <em>{{secondaryDate}}</em></p>",
+    ctaLabel: "Ver Horarios de Oración",
+    ctaUrl: "https://mezquitabogota.org/es/horarios",
+    translations: {
+      es: {
+        subject: "🕌 Jumu’ah en {{organizationName}} ({{secondaryDate}})",
+        bodyText: "As-salamu alaykum {{recipientName}}. Te esperamos este viernes para la Khutbah y oración de Jumu’ah en {{organizationName}}. Fecha Hijri: {{secondaryDate}}.",
+        bodyHtml: "<p>As-salamu alaykum <strong>{{recipientName}}</strong>,</p><p>Te esperamos este viernes para la Khutbah y oración congregacional de <strong>Jumu’ah</strong> en {{organizationName}}.</p><p>Calendario Hijri: <em>{{secondaryDate}}</em></p>",
+        ctaLabel: "Ver Horarios de Oración",
+        ctaUrl: "https://mezquitabogota.org/es/horarios"
+      },
+      en: {
+        subject: "🕌 Friday Jumu’ah Reminder — {{organizationName}} ({{secondaryDate}})",
+        bodyText: "As-salamu alaykum {{recipientName}}. Join us this Friday for the Jumu’ah Khutbah and congregational prayer at {{organizationName}}. Hijri date: {{secondaryDate}}.",
+        bodyHtml: "<p>As-salamu alaykum <strong>{{recipientName}}</strong>,</p><p>Join us this Friday for the <strong>Jumu’ah Khutbah</strong> and congregational prayer at {{organizationName}}.</p><p>Hijri date: <em>{{secondaryDate}}</em></p>",
+        ctaLabel: "View Prayer Schedule",
+        ctaUrl: "https://mezquitabogota.org/en/prayer-times"
+      },
+      ar: {
+        subject: "🕌 تذكير صلاة وخطبة الجمعة — {{organizationName}} ({{secondaryDate}})",
+        bodyText: "السلام عليكم {{recipientName}}، ندعوكم لحضور خطبة وصلاة الجمعة في {{organizationName}}. التاريخ الهجري: {{secondaryDate}}.",
+        bodyHtml: "<p>السلام عليكم <strong>{{recipientName}}</strong>،</p><p>ندعوكم لحضور خطبة وصلاة <strong>الجمعة</strong> في {{organizationName}}.</p><p>التاريخ الهجري: <em>{{secondaryDate}}</em></p>",
+        ctaLabel: "عرض مواقيت الصلاة",
+        ctaUrl: "https://mezquitabogota.org/ar/prayer-times"
+      },
+      tr: {
+        subject: "🕌 Cuma Hutbesi ve Namazı Hatırlatması — {{organizationName}} ({{secondaryDate}})",
+        bodyText: "Es-selamu aleyküm {{recipientName}}. Bu Cuma {{organizationName}} bünyesinde Cuma hutbesi ve namazına davetlisiniz. Hicri Tarih: {{secondaryDate}}.",
+        bodyHtml: "<p>Es-selamu aleyküm <strong>{{recipientName}}</strong>,</p><p>Bu Cuma {{organizationName}} bünyesinde <strong>Cuma Hutbesi ve Namazına</strong> davetlisiniz.</p><p>Hicri Tarih: <em>{{secondaryDate}}</em></p>",
+        ctaLabel: "Namaz Vakitlerini Gör",
+        ctaUrl: "https://mezquitabogota.org/tr/prayer-times"
+      }
+    }
+  },
+  {
+    id: "urgent-janazah-alert",
+    slug: "urgent-janazah-alert",
+    title: "Aviso Urgente de Oración Funeraria (Salat al-Janazah)",
+    topic: "urgent_janazah",
+    channels: ["telegram", "whatsapp", "email"],
+    priority: "urgent",
+    subject: "🕯️ Aviso Urgente: Salat al-Janazah en {{organizationName}}",
+    bodyText: "Inna lillahi wa inna ilayhi raji’un. Informamos a la comunidad que se realizará la oración funeraria (Salat al-Janazah) en {{organizationName}} después de la oración de Dhuhr ({{secondaryDate}}).",
+    bodyHtml: "<p><strong>Inna lillahi wa inna ilayhi raji’un</strong></p><p>Informamos a la comunidad que se realizará la oración funeraria (<strong>Salat al-Janazah</strong>) en {{organizationName}} después de la oración de Dhuhr ({{secondaryDate}}).</p>",
+    ctaLabel: "Detalles y Ubicación",
+    ctaUrl: "https://mezquitabogota.org/es/avisos",
+    translations: {
+      es: {
+        subject: "🕯️ Aviso Urgente: Salat al-Janazah en {{organizationName}}",
+        bodyText: "Inna lillahi wa inna ilayhi raji’un. Informamos a la comunidad que se realizará la oración funeraria (Salat al-Janazah) en {{organizationName}} después de la oración de Dhuhr ({{secondaryDate}}).",
+        ctaLabel: "Detalles y Ubicación",
+        ctaUrl: "https://mezquitabogota.org/es/avisos"
+      },
+      en: {
+        subject: "🕯️ Urgent Community Notice: Salat al-Janazah at {{organizationName}}",
+        bodyText: "Inna lillahi wa inna ilayhi raji’un. Funeral prayer (Salat al-Janazah) will be held at {{organizationName}} following Dhuhr prayer ({{secondaryDate}}).",
+        ctaLabel: "Details & Location",
+        ctaUrl: "https://mezquitabogota.org/en/announcements"
+      },
+      ar: {
+        subject: "🕯️ إعلان عاجل: صلاة الجنازة في {{organizationName}}",
+        bodyText: "إنا لله وإنا إليه راجعون. تُقام صلاة الجنازة في {{organizationName}} عقب صلاة الظهر ({{secondaryDate}}).",
+        ctaLabel: "التفاصيل والموقع",
+        ctaUrl: "https://mezquitabogota.org/ar/announcements"
+      },
+      tr: {
+        subject: "🕯️ Acil Duyuru: {{organizationName}} Cenaze Namazı",
+        bodyText: "İnna lillahi ve inna ileyhi raciun. Öğle namazını müteakip {{organizationName}} camiimizde cenaze namazı kılınacaktır ({{secondaryDate}}).",
+        ctaLabel: "Detaylar ve Konum",
+        ctaUrl: "https://mezquitabogota.org/tr/announcements"
+      }
+    }
+  }
+];
+const STARTER_AUTOMATION_RULES = [
+  {
+    slug: "auto-alert-banner-broadcast",
+    name: "Auto-Broadcast Urgent Site Alert Banners",
+    eventName: "inbox.alert.published",
+    topic: "announcements",
+    channels: ["telegram", "whatsapp"],
+    active: true,
+    priority: "urgent",
+    subjectTemplate: "🚨 {{title}} — {{organizationName}}",
+    bodyTextTemplate: "🚨 {{title}}: {{message}} ({{secondaryDate}})",
+    bodyHtmlTemplate: "<p><strong>🚨 {{title}}</strong></p><p>{{message}}</p><p><em>{{secondaryDate}}</em></p>",
+    ctaLabelTemplate: "Ver Aviso Oficial",
+    ctaUrlTemplate: "{{siteBaseUrl}}"
+  },
+  {
+    slug: "auto-event-published-broadcast",
+    name: "Auto-Broadcast Newly Published Community Events",
+    eventName: "event.published",
+    targetContentType: "api::event.event",
+    topic: "events",
+    channels: ["telegram", "email"],
+    active: true,
+    priority: "normal",
+    subjectTemplate: "📅 Nuevo Evento: {{title}} ({{secondaryDate}})",
+    bodyTextTemplate: "Nuevo evento comunitario en {{organizationName}}: {{title}}. {{summary}} ({{secondaryDate}}).",
+    bodyHtmlTemplate: "<p>Nuevo evento comunitario en <strong>{{organizationName}}</strong>:</p><h3>{{title}}</h3><p>{{summary}}</p><p><em>{{secondaryDate}}</em></p>",
+    ctaLabelTemplate: "Inscribirse al Evento",
+    ctaUrlTemplate: "{{siteBaseUrl}}/events"
+  }
+];
+const HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+const TELEGRAM_INLINE_TAGS = /* @__PURE__ */ new Set([
+  "b",
+  "strong",
+  "i",
+  "em",
+  "u",
+  "ins",
+  "s",
+  "strike",
+  "del",
+  "code",
+  "pre",
+  "tg-spoiler"
+]);
+function escapeHtml(raw) {
+  return String(raw).replace(
+    /[&<>"']/g,
+    (char) => HTML_ESCAPE_MAP[char] || char
+  );
+}
+function stripHeaderControlChars(raw) {
+  return String(raw || "").replace(/[\r\n<>]/g, "").replace(/[\u0000-\u001f\u007f]/g, "").trim();
+}
+function extractSafeAnchorHref(attrs) {
+  const match = attrs.match(
+    /\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i
+  );
+  const rawHref = (match?.[1] ?? match?.[2] ?? match?.[3] ?? "").replace(/&amp;/gi, "&").trim();
+  if (!rawHref || /[\u0000-\u001f\u007f]/.test(rawHref)) return null;
+  try {
+    const parsed = new URL(rawHref);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      return null;
+    }
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+function sanitizeTelegramHtml(rawHtml) {
+  if (!rawHtml) return "";
+  let text = String(rawHtml).replace(/[\u0001\u0002]/g, "").replace(/<script\b[^>]*>[\s\S]*?<\/script\s*>/gi, "").replace(/<style\b[^>]*>[\s\S]*?<\/style\s*>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<h[1-6](?:\s[^>]*)?>/gi, "<b>").replace(/<\/h[1-6]\s*>/gi, "</b>\n").replace(/<p(?:\s[^>]*)?>/gi, "").replace(/<\/p\s*>/gi, "\n\n").replace(/<div(?:\s[^>]*)?>/gi, "").replace(/<\/div\s*>/gi, "\n").replace(/<li(?:\s[^>]*)?>/gi, "• ").replace(/<\/li\s*>/gi, "\n");
+  let openAnchors = 0;
+  text = text.replace(
+    /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)(\s[^<>]*)?(\/?)>/g,
+    (_full, slash, rawName, attrs = "", selfClose = "") => {
+      const tag = rawName.toLowerCase();
+      if (selfClose === "/") return "";
+      if (slash === "/") {
+        if (TELEGRAM_INLINE_TAGS.has(tag)) return `
/${tag}`;
+        if (tag === "a" && openAnchors > 0) {
+          openAnchors -= 1;
+          return "
/a";
+        }
+        return "";
+      }
+      if (TELEGRAM_INLINE_TAGS.has(tag)) return `
${tag}`;
+      if (tag === "a") {
+        const safeHref = extractSafeAnchorHref(attrs);
+        if (!safeHref) return "";
+        openAnchors += 1;
+        return `
a href="${escapeHtml(safeHref)}"`;
+      }
+      return "";
+    }
+  );
+  while (openAnchors > 0) {
+    text += "
/a";
+    openAnchors -= 1;
+  }
+  text = text.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/&(?!(?:amp|lt|gt|quot|apos|#\d+|#x[0-9a-f]+);)/gi, "&amp;").replace(/\u0001([^\u0002]+)\u0002/g, "<$1>").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return text;
+}
+function interpolateBroadcastTemplate(template, variables, options2 = {}) {
+  if (!template) return "";
+  const shouldEscape = Boolean(options2.escapeHtmlValues);
+  return template.replace(
+    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
+    (_match, key) => {
+      const rawValue = variables[key];
+      if (rawValue === void 0 || rawValue === null) {
+        return "";
+      }
+      const strValue = String(rawValue);
+      return shouldEscape ? escapeHtml(strValue) : strValue;
+    }
+  );
+}
+function maskEmail(email) {
+  const trimmed = String(email || "").trim().toLowerCase();
+  const atIndex = trimmed.indexOf("@");
+  if (atIndex <= 0) {
+    return "***@invalid";
+  }
+  const local = trimmed.slice(0, atIndex);
+  const domain = trimmed.slice(atIndex + 1);
+  if (!domain) {
+    return "***@invalid";
+  }
+  const visiblePrefix = local.slice(0, 1);
+  return `${visiblePrefix}***@${domain}`;
+}
+function maskPhone(phone) {
+  const normalized = normalizeE164Phone(phone);
+  if (normalized.length <= 4) {
+    return "***";
+  }
+  const prefix = normalized.startsWith("+") ? normalized.slice(0, 3) : normalized.slice(0, 2);
+  const suffix = normalized.slice(-4);
+  return `${prefix}***${suffix}`;
+}
+function isWhatsAppGroupOrChannelJid(raw) {
+  const trimmed = String(raw || "").trim().toLowerCase();
+  return /^[\d-]+@g\.us$/.test(trimmed) || /^[\d-]+@newsletter$/.test(trimmed);
+}
+function normalizeWhatsAppTarget(raw, defaultCountryCode = "57") {
+  const trimmed = String(raw || "").trim();
+  if (!trimmed) {
+    return {
+      normalized: "",
+      isGroupOrChannel: false,
+      chatId: "",
+      evolutionNumber: ""
+    };
+  }
+  const lower = trimmed.toLowerCase();
+  if (isWhatsAppGroupOrChannelJid(lower)) {
+    return {
+      normalized: lower,
+      isGroupOrChannel: true,
+      chatId: lower,
+      evolutionNumber: lower
+    };
+  }
+  if (lower.endsWith("@c.us") || lower.endsWith("@s.whatsapp.net")) {
+    const userPart = lower.split("@")[0];
+    const e1642 = normalizeE164Phone(userPart, defaultCountryCode);
+    const digits2 = e1642.replace(/^\+/, "");
+    return {
+      normalized: e1642,
+      isGroupOrChannel: false,
+      chatId: digits2 ? `${digits2}@c.us` : "",
+      evolutionNumber: digits2
+    };
+  }
+  const e164 = normalizeE164Phone(trimmed, defaultCountryCode);
+  const digits = e164.replace(/^\+/, "");
+  return {
+    normalized: e164,
+    isGroupOrChannel: false,
+    chatId: digits ? `${digits}@c.us` : "",
+    evolutionNumber: digits
+  };
+}
+function maskRecipientIdentifier(identifier) {
+  const trimmed = String(identifier || "").trim();
+  if (!trimmed) return "***";
+  const lower = trimmed.toLowerCase();
+  if (isWhatsAppGroupOrChannelJid(lower)) {
+    return lower;
+  }
+  if (trimmed.includes("@") && !trimmed.startsWith("@")) {
+    return maskEmail(trimmed);
+  }
+  if (trimmed.startsWith("@") || /^-\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  return maskPhone(trimmed);
+}
+function normalizeE164Phone(phone, defaultCountryCode = "57") {
+  const raw = String(phone || "").trim();
+  if (!raw) return "";
+  if (isWhatsAppGroupOrChannelJid(raw)) {
+    return raw.toLowerCase();
+  }
+  const hasPlus = raw.startsWith("+");
+  const digitsOnly = raw.replace(/\D+/g, "");
+  if (!digitsOnly) return "";
+  if (hasPlus) {
+    return `+${digitsOnly}`;
+  }
+  if (digitsOnly.startsWith("00") && digitsOnly.length > 4) {
+    return `+${digitsOnly.slice(2)}`;
+  }
+  if (digitsOnly.length === 10 && defaultCountryCode) {
+    return `+${defaultCountryCode.replace(/\D+/g, "")}${digitsOnly}`;
+  }
+  return `+${digitsOnly}`;
+}
+function resolveLocalizedCampaignCopy(campaign2, locale, defaultLocale = "es") {
+  const translations = campaign2.translations || {};
+  const match = translations[locale] || translations[defaultLocale];
+  return {
+    subject: match?.subject || campaign2.subject,
+    bodyText: match?.bodyText || campaign2.bodyText,
+    bodyHtml: match?.bodyHtml || campaign2.bodyHtml,
+    ctaLabel: match?.ctaLabel || campaign2.ctaLabel,
+    ctaUrl: match?.ctaUrl || campaign2.ctaUrl
+  };
+}
+const SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "metadata.google.internal",
+  "metadata",
+  "100.100.100.200"
+]);
+function parseIpv4Octets(host) {
+  const match = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!match) return null;
+  const octets = [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3]),
+    Number(match[4])
+  ];
+  if (octets.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
+    return null;
+  }
+  return octets;
+}
+function isBlockedIpv4([a, b, c, d], allowLoopback) {
+  if (a === 127) {
+    return !(allowLoopback && b === 0 && c === 0 && d === 1);
+  }
+  if (a === 0 || a === 10 || a >= 224) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  return false;
+}
+function expandIpv6Groups(rawHost) {
+  if (!rawHost.includes(":") || rawHost.includes("%")) return null;
+  let candidate = rawHost;
+  const lastColon = candidate.lastIndexOf(":");
+  const tail = candidate.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    const v4 = parseIpv4Octets(tail);
+    if (!v4) return null;
+    const hi = (v4[0] << 8 | v4[1]).toString(16);
+    const lo = (v4[2] << 8 | v4[3]).toString(16);
+    candidate = `${candidate.slice(0, lastColon)}:${hi}:${lo}`;
+  }
+  const dblParts = candidate.split("::");
+  if (dblParts.length > 2) return null;
+  const parsePart = (part) => {
+    if (!part) return [];
+    const tokens = part.split(":");
+    const nums = [];
+    for (const tok of tokens) {
+      if (!/^[0-9a-f]{1,4}$/i.test(tok)) return null;
+      nums.push(Number.parseInt(tok, 16));
+    }
+    return nums;
+  };
+  const left = parsePart(dblParts[0]);
+  if (!left) return null;
+  if (dblParts.length === 1) {
+    return left.length === 8 ? left : null;
+  }
+  const right = parsePart(dblParts[1]);
+  if (!right) return null;
+  const missing = 8 - (left.length + right.length);
+  if (missing < 1) return null;
+  return [...left, ...Array.from({ length: missing }, () => 0), ...right];
+}
+function isBlockedIpv6(groups, allowLoopback) {
+  const allZeroPrefix = groups.slice(0, 7).every((g) => g === 0);
+  if (allZeroPrefix && groups[7] === 0) return true;
+  if (allZeroPrefix && groups[7] === 1) return !allowLoopback;
+  const first = groups[0];
+  if ((first & 65024) === 64512) return true;
+  if ((first & 65472) === 65152) return true;
+  if ((first & 65280) === 65280) return true;
+  if (first === 8194) {
+    const embedded6to4 = [
+      groups[1] >> 8 & 255,
+      groups[1] & 255,
+      groups[2] >> 8 & 255,
+      groups[2] & 255
+    ];
+    return isBlockedIpv4(embedded6to4, false);
+  }
+  const isMappedV4 = groups.slice(0, 5).every((g) => g === 0) && (groups[5] === 65535 || groups[5] === 0);
+  const isNat64 = groups[0] === 100 && groups[1] === 65435 && groups.slice(2, 6).every((g) => g === 0);
+  if (isMappedV4 || isNat64) {
+    const mappedQuad = [
+      groups[6] >> 8 & 255,
+      groups[6] & 255,
+      groups[7] >> 8 & 255,
+      groups[7] & 255
+    ];
+    return isBlockedIpv4(mappedQuad, false);
+  }
+  return false;
+}
+function normalizeUrlHostname(rawHostname) {
+  const lower = rawHostname.toLowerCase();
+  let unbracketed = lower.startsWith("[") && lower.endsWith("]") ? lower.slice(1, -1) : lower;
+  while (unbracketed.endsWith(".")) {
+    unbracketed = unbracketed.slice(0, -1);
+  }
+  return unbracketed;
+}
+function evaluateGatewayHost(host, allowLocalhost) {
+  if (!host) {
+    return { isExactLoopback: false, blockedError: "Invalid gateway hostname" };
+  }
+  const isExactLoopback = host === "localhost" || host === "127.0.0.1" || host === "::1";
+  if (BLOCKED_HOSTNAMES.has(host) || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) {
+    return {
+      isExactLoopback: false,
+      blockedError: "Private, loopback, and metadata hosts are forbidden (SSRF protection)"
+    };
+  }
+  if (host === "localhost") {
+    return {
+      isExactLoopback: true,
+      blockedError: allowLocalhost ? null : "Localhost gateway URLs are forbidden unless explicitly allowed"
+    };
+  }
+  const v4 = parseIpv4Octets(host);
+  if (v4) {
+    return {
+      isExactLoopback,
+      blockedError: isBlockedIpv4(v4, allowLocalhost) ? "Private, loopback, CGNAT, and link-local IPv4 hosts are forbidden" : null
+    };
+  }
+  if (host.includes(":")) {
+    const v6 = expandIpv6Groups(host);
+    if (!v6 || isBlockedIpv6(v6, allowLocalhost)) {
+      return {
+        isExactLoopback,
+        blockedError: "Private, loopback, link-local, and mapped IPv6 hosts are forbidden"
+      };
+    }
+  }
+  return { isExactLoopback, blockedError: null };
+}
+function validateGatewayUrl(rawUrl, options2 = {}) {
+  const errors = [];
+  const trimmed = String(rawUrl || "").trim();
+  if (!trimmed) {
+    return { valid: false, errors: ["Gateway URL is required"] };
+  }
+  if (trimmed.includes("\\") || /[\u0000-\u001f\u007f]/.test(trimmed)) {
+    return {
+      valid: false,
+      errors: ["Gateway URL must not contain backslashes or control chars"]
+    };
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return { valid: false, errors: ["Invalid URL format"] };
+  }
+  if (parsed.username || parsed.password) {
+    errors.push("Gateway URL must not contain embedded credentials");
+  }
+  if (parsed.search || parsed.hash) {
+    errors.push("Gateway URL must not contain query parameters or fragments");
+  }
+  const allowLocalhost = Boolean(options2.allowLocalhost);
+  const host = normalizeUrlHostname(parsed.hostname);
+  const { isExactLoopback, blockedError } = evaluateGatewayHost(
+    host,
+    allowLocalhost
+  );
+  if (blockedError) errors.push(blockedError);
+  if (parsed.protocol === "http:") {
+    if (!allowLocalhost || !isExactLoopback) {
+      errors.push("HTTPS protocol is required for external gateway URLs");
+    }
+  } else if (parsed.protocol !== "https:") {
+    errors.push(
+      "Only HTTPS (or explicitly allowed localhost HTTP) protocol is permitted"
+    );
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isSafeHttpUrl(rawUrl) {
+  if (typeof rawUrl !== "string") return false;
+  const trimmed = rawUrl.trim();
+  if (!trimmed || /[\u0000-\u001f\u007f<>\\]/.test(trimmed)) return false;
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.username || parsed.password) return false;
+    return parsed.protocol === "https:" || parsed.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function validatePublicChannelLinks(links) {
+  const errors = [];
+  if (!Array.isArray(links)) {
+    return { valid: false, errors: ["publicChannelLinks must be an array"] };
+  }
+  for (let i = 0; i < links.length; i += 1) {
+    const item = links[i];
+    if (!item || typeof item !== "object") {
+      errors.push(`publicChannelLinks[${i}] must be an object`);
+      continue;
+    }
+    if (!isSafeHttpUrl(item.inviteUrl)) {
+      errors.push(
+        `publicChannelLinks[${i}].inviteUrl must be a valid http(s) URL`
+      );
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function normalizeChannels(rawChannels, fallback = ["email"]) {
+  if (!Array.isArray(rawChannels)) {
+    return [...fallback];
+  }
+  const filtered = rawChannels.map((c) => String(c).trim().toLowerCase()).filter(
+    (c) => SUPPORTED_CHANNELS.includes(c)
+  );
+  return filtered.length > 0 ? Array.from(new Set(filtered)) : [...fallback];
+}
+function isSupportedWhatsAppDriver(driver) {
+  return SUPPORTED_WHATSAPP_DRIVERS.includes(
+    String(driver || "").trim()
+  );
+}
+const GATEWAY_SESSION_RE = /^[A-Za-z0-9_-]{1,64}$/;
+function isValidGatewaySession(session) {
+  return typeof session === "string" && GATEWAY_SESSION_RE.test(session.trim());
+}
+function validateCampaignChannelsList(rawChannels, errors) {
+  const channels = Array.isArray(rawChannels) ? rawChannels : [];
+  if (channels.length === 0) {
+    errors.push("At least one broadcast channel is required");
+    return;
+  }
+  for (const ch of channels) {
+    const normalized = String(ch).trim().toLowerCase();
+    if (!SUPPORTED_CHANNELS.includes(normalized)) {
+      errors.push(`Unsupported broadcast channel: ${String(ch)}`);
+    }
+  }
+}
+function validateOptionalHttpUrl(urlValue, fieldName, errors) {
+  if (!urlValue) return;
+  if (!isSafeHttpUrl(urlValue)) {
+    errors.push(`${fieldName} must use http or https protocol`);
+  }
+}
+function validateCampaignInput(input) {
+  const errors = [];
+  const slug = String(input.slug || "").trim();
+  const title = String(input.title || "").trim();
+  const subject = String(input.subject || "").trim();
+  const bodyText = String(input.bodyText || "").trim();
+  if (!slug || !SLUG_REGEX.test(slug)) {
+    errors.push("Campaign slug must be lowercase kebab-case");
+  }
+  if (title.length < 3) {
+    errors.push("Campaign title must be at least 3 characters");
+  }
+  if (subject.length < 3) {
+    errors.push("Campaign subject must be at least 3 characters");
+  }
+  if (bodyText.length < 5) {
+    errors.push("Campaign bodyText must be at least 5 characters");
+  }
+  validateCampaignChannelsList(input.channels, errors);
+  validateOptionalHttpUrl(input.ctaUrl, "ctaUrl", errors);
+  validateOptionalHttpUrl(input.mediaUrl, "mediaUrl", errors);
+  if (input.translations && typeof input.translations === "object") {
+    for (const [locale, tr] of Object.entries(input.translations)) {
+      if (tr && typeof tr === "object" && tr.ctaUrl) {
+        validateOptionalHttpUrl(
+          tr.ctaUrl,
+          `translations.${locale}.ctaUrl`,
+          errors
+        );
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function requireNonEmptyFields(fields, errors) {
+  for (const [val, errMessage] of fields) {
+    if (!String(val || "").trim()) {
+      errors.push(errMessage);
+    }
+  }
+}
+function validateCtaUrlTemplate(rawTemplate, errors) {
+  if (!rawTemplate) return;
+  const trimmed = String(rawTemplate).trim();
+  if (!trimmed) return;
+  const resolvedProbe = trimmed.replace(/^\{\{\s*siteBaseUrl\s*\}\}/, "https://example.org").replace(/\{\{\s*[a-zA-Z0-9_.-]+\s*\}\}/g, "segment");
+  if (!isSafeHttpUrl(resolvedProbe)) {
+    errors.push("ctaUrlTemplate must resolve to an http or https URL");
+  }
+}
+function validateAutomationRuleInput(input) {
+  const errors = [];
+  const slug = String(input.slug || "").trim();
+  const name = String(input.name || "").trim();
+  const eventName = String(input.eventName || "").trim();
+  const targetUid = String(input.targetContentType || "").trim();
+  if (!slug || !SLUG_REGEX.test(slug)) {
+    errors.push("Automation rule slug must be lowercase kebab-case");
+  }
+  if (name.length < 3) {
+    errors.push("Automation rule name must be at least 3 characters");
+  }
+  requireNonEmptyFields(
+    [
+      [input.eventName, "eventName is required"],
+      [input.subjectTemplate, "subjectTemplate is required"],
+      [input.bodyTextTemplate, "bodyTextTemplate is required"]
+    ],
+    errors
+  );
+  if (eventName.toLowerCase().startsWith("broadcasts.")) {
+    errors.push('eventName cannot start with "broadcasts." (loop protection)');
+  }
+  if (targetUid.toLowerCase().startsWith("plugin::broadcasts.")) {
+    errors.push(
+      'targetContentType cannot target "plugin::broadcasts.*" (loop protection)'
+    );
+  }
+  if (input.channels !== void 0) {
+    validateCampaignChannelsList(input.channels, errors);
+  }
+  validateCtaUrlTemplate(input.ctaUrlTemplate, errors);
+  return { valid: errors.length === 0, errors };
+}
+const MONITORED_EVENTS = [
+  "inbox.alert.published",
+  "inbox.subscriber.confirmed",
+  "event.published",
+  "media-feeds.episode.synced"
+];
+const hubRegistry = /* @__PURE__ */ new WeakMap();
+function getOrCreateEntry(strapi) {
+  let entry = hubRegistry.get(strapi);
+  if (!entry) {
+    entry = { unsubs: [], boundEvents: /* @__PURE__ */ new Set(), usesCatchAll: false };
+    hubRegistry.set(strapi, entry);
+  }
+  return entry;
+}
+async function dispatchEventToAutomation(strapi, eventName, payload) {
+  if (!eventName || eventName.toLowerCase().startsWith("broadcasts.")) {
+    return;
+  }
+  try {
+    const automationService = strapi.plugin(PLUGIN_ID).service("automationService");
+    const safePayload = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    await automationService.handleEventTrigger(eventName, safePayload);
+  } catch (err) {
+    strapi.log.warn(
+      `[@vicacha-devs/strapi-plugin-broadcasts] EventHub automation warning for ${eventName}: ${err.message}`
+    );
+  }
+}
+function ensureEventHubListener(strapi, rawEventName) {
+  const evt = String(rawEventName || "").trim();
+  if (!evt || evt.toLowerCase().startsWith("broadcasts.")) return;
+  const entry = getOrCreateEntry(strapi);
+  if (entry.usesCatchAll || entry.boundEvents.has(evt)) return;
+  if (typeof strapi.eventHub?.on !== "function") return;
+  const listener = async (payload) => {
+    await dispatchEventToAutomation(strapi, evt, payload);
+  };
+  strapi.eventHub.on(evt, listener);
+  entry.boundEvents.add(evt);
+  entry.unsubs.push(() => {
+    if (typeof strapi.eventHub?.off === "function") {
+      strapi.eventHub.off(evt, listener);
+    } else if (typeof strapi.eventHub?.removeListener === "function") {
+      strapi.eventHub.removeListener(evt, listener);
+    }
+  });
+}
+async function registerEventHubListeners(strapi) {
+  cleanupEventHubListeners(strapi);
+  if (!strapi.eventHub) return;
+  const entry = getOrCreateEntry(strapi);
+  if (typeof strapi.eventHub.subscribe === "function") {
+    const unsubscribe = strapi.eventHub.subscribe(
+      async (eventName, payload) => {
+        await dispatchEventToAutomation(strapi, eventName, payload);
+      }
+    );
+    entry.usesCatchAll = true;
+    if (typeof unsubscribe === "function") {
+      entry.unsubs.push(unsubscribe);
+    }
+    return;
+  }
+  for (const evt of MONITORED_EVENTS) {
+    ensureEventHubListener(strapi, evt);
+  }
+  const automationService = strapi.plugin(PLUGIN_ID).service("automationService");
+  const existingRules = await automationService.listRules();
+  for (const rule of existingRules) {
+    if (rule.eventName) {
+      ensureEventHubListener(strapi, rule.eventName);
+    }
+  }
+}
+function cleanupEventHubListeners(strapi) {
+  const entry = hubRegistry.get(strapi);
+  if (!entry) return;
+  for (const unsub of entry.unsubs) {
+    try {
+      unsub();
+    } catch {
+    }
+  }
+  hubRegistry.delete(strapi);
+}
+const bootstrap = async ({ strapi }) => {
+  const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+  await settingsService.getSettings();
+  const campaignService = strapi.plugin(PLUGIN_ID).service("campaignService");
+  await campaignService.seedStarterCampaigns();
+  const automationService = strapi.plugin(PLUGIN_ID).service("automationService");
+  await automationService.seedStarterRules();
+  await registerEventHubListeners(strapi);
+  if (strapi.admin?.services?.permission?.actionProvider?.registerMany) {
+    await strapi.admin.services.permission.actionProvider.registerMany([
+      {
+        section: "plugins",
+        displayName: "Read Broadcast Campaigns & Delivery Ledger",
+        uid: "read",
+        pluginName: PLUGIN_ID
+      },
+      {
+        section: "plugins",
+        displayName: "Manage Broadcast Campaigns",
+        uid: "campaigns.manage",
+        pluginName: PLUGIN_ID
+      },
+      {
+        section: "plugins",
+        displayName: "Send & Dispatch Broadcasts",
+        uid: "campaigns.send",
+        pluginName: PLUGIN_ID
+      },
+      {
+        section: "plugins",
+        displayName: "Manage EventHub Automation Rules",
+        uid: "automations.manage",
+        pluginName: PLUGIN_ID
+      },
+      {
+        section: "plugins",
+        displayName: "Manage Broadcast Transport Settings",
+        uid: "settings.manage",
+        pluginName: PLUGIN_ID
+      }
+    ]);
+  }
+};
+const config = {
+  default: DEFAULT_BROADCAST_SETTINGS,
+  validator() {
+  }
+};
+const kind$2 = "collectionType";
+const collectionName$2 = "broadcast_automation_rules";
+const info$2 = { "singularName": "automation-rule", "pluralName": "automation-rules", "displayName": "Broadcast Automation Rule", "description": "EventHub-driven automated multi-channel broadcast rule" };
+const options$2 = { "draftAndPublish": false };
+const pluginOptions$2 = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes$2 = { "name": { "type": "string", "required": true }, "slug": { "type": "uid", "targetField": "name", "required": true }, "eventName": { "type": "string", "required": true }, "targetContentType": { "type": "string" }, "topic": { "type": "string", "default": "announcements", "required": true }, "channels": { "type": "json", "required": true, "default": ["telegram"] }, "active": { "type": "boolean", "default": true }, "priority": { "type": "enumeration", "enum": ["low", "normal", "high", "urgent"], "default": "normal" }, "subjectTemplate": { "type": "string", "required": true }, "bodyTextTemplate": { "type": "text", "required": true }, "bodyHtmlTemplate": { "type": "richtext" }, "ctaLabelTemplate": { "type": "string" }, "ctaUrlTemplate": { "type": "string" }, "translations": { "type": "json", "default": {} }, "lastTriggeredAt": { "type": "datetime" }, "triggerCount": { "type": "integer", "default": 0, "min": 0 } };
+const schema$2 = {
+  kind: kind$2,
+  collectionName: collectionName$2,
+  info: info$2,
+  options: options$2,
+  pluginOptions: pluginOptions$2,
+  attributes: attributes$2
+};
+const automationRule = {
+  schema: schema$2
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "broadcast_campaigns";
+const info$1 = { "singularName": "campaign", "pluralName": "campaigns", "displayName": "Broadcast Campaign", "description": "Omnichannel Email, Telegram & WhatsApp broadcast campaign" };
+const options$1 = { "draftAndPublish": false };
+const pluginOptions$1 = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes$1 = { "title": { "type": "string", "required": true }, "slug": { "type": "uid", "targetField": "title", "required": true }, "topic": { "type": "string", "default": "announcements", "required": true }, "channels": { "type": "json", "required": true, "default": ["email", "telegram"] }, "priority": { "type": "enumeration", "enum": ["low", "normal", "high", "urgent"], "default": "normal", "required": true }, "status": { "type": "enumeration", "enum": ["draft", "scheduled", "sending", "sent", "failed", "cancelled"], "default": "draft", "required": true }, "scheduledAt": { "type": "datetime" }, "sentAt": { "type": "datetime" }, "subject": { "type": "string", "required": true }, "bodyText": { "type": "text", "required": true }, "bodyHtml": { "type": "richtext" }, "ctaLabel": { "type": "string" }, "ctaUrl": { "type": "string" }, "mediaUrl": { "type": "string" }, "emailTemplateRef": { "type": "string" }, "whatsappTemplateName": { "type": "string" }, "whatsappGroupIds": { "type": "json", "default": [] }, "telegramChatId": { "type": "string" }, "telegramThreadId": { "type": "integer" }, "translations": { "type": "json", "default": {} }, "secondaryDate": { "type": "json", "default": {} }, "secondaryDateLabel": { "type": "string" }, "stats": { "type": "json", "default": {} }, "metadata": { "type": "json", "default": {} } };
+const schema$1 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const campaign = {
+  schema: schema$1
+};
+const kind = "collectionType";
+const collectionName = "broadcast_delivery_logs";
+const info = { "singularName": "delivery-log", "pluralName": "delivery-logs", "displayName": "Broadcast Delivery Log", "description": "Idempotent, PII-masked multi-channel delivery audit log" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes = { "idempotencyKey": { "type": "string", "required": true, "unique": true }, "campaignSlug": { "type": "string", "required": true }, "channel": { "type": "enumeration", "enum": ["email", "telegram", "whatsapp"], "required": true }, "driver": { "type": "string", "required": true }, "recipientMasked": { "type": "string", "required": true }, "locale": { "type": "string", "default": "es", "required": true }, "status": { "type": "enumeration", "enum": ["sent", "simulated", "skipped_duplicate", "failed"], "required": true }, "externalMessageId": { "type": "string" }, "errorMessage": { "type": "text" }, "sentAt": { "type": "datetime", "required": true }, "secondaryDateLabel": { "type": "string" } };
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const deliveryLog = {
+  schema
+};
+const contentTypes = {
+  campaign,
+  "automation-rule": automationRule,
+  "delivery-log": deliveryLog
+};
+const SECRET_MASK_ONLY_RE = /^[•*]+$/;
+function computeIdempotencyKey(campaignSlug, channel, recipient, options2 = {}) {
+  const normalizedRecipient = String(recipient || "").trim().toLowerCase();
+  const digest = createHmac("sha256", "vicacha-broadcasts-idempotency-v1").update(`${campaignSlug}:${channel}:${normalizedRecipient}`, "utf8").digest("hex").slice(0, 24);
+  const baseKey = `${campaignSlug}:${channel}:${digest}`;
+  return options2.isTest ? `test:${baseKey}` : baseKey;
+}
+function generateUniqueSlugSuffix() {
+  return `${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+}
+function redactSecretsFromMessage(rawMessage, secrets = []) {
+  let sanitized = String(rawMessage || "");
+  if (!sanitized) return "";
+  for (const candidate of secrets) {
+    const trimmed = typeof candidate === "string" ? candidate.trim() : "";
+    if (trimmed.length < 4 || SECRET_MASK_ONLY_RE.test(trimmed)) continue;
+    sanitized = sanitized.split(trimmed).join("[REDACTED]");
+    const encoded = encodeURIComponent(trimmed);
+    if (encoded !== trimmed && encoded.length >= 4) {
+      sanitized = sanitized.split(encoded).join("[REDACTED]");
+    }
+  }
+  sanitized = sanitized.replace(/bot\d+:[A-Za-z0-9_-]+/g, "bot[REDACTED]");
+  sanitized = sanitized.replace(/\b\d{6,}:[A-Za-z0-9_-]{16,}\b/g, "[REDACTED]");
+  sanitized = sanitized.replace(
+    /Bearer\s+[A-Z0-9._~+/=-]+/gi,
+    "Bearer [REDACTED]"
+  );
+  sanitized = sanitized.replace(
+    /((?:api[_-]?key|access[_-]?token|token)=)[^&\s"']+/gi,
+    "$1[REDACTED]"
+  );
+  return sanitized;
+}
+const TELEGRAM_BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]+$/;
+const FETCH_TIMEOUT_MS = 15e3;
+function clampLimit(val, defaultLimit) {
+  if (val === void 0 || val === null || val === "") return defaultLimit;
+  const parsed = typeof val === "number" ? val : typeof val === "string" ? Number(val) : Number.NaN;
+  if (!Number.isFinite(parsed)) return defaultLimit;
+  return Math.min(100, Math.max(1, Math.trunc(parsed)));
+}
+function buildTelegramIdempotencyKey(payload, targetChatId) {
+  const hasThread = typeof payload.threadId === "number" && payload.threadId > 0;
+  const threadKeySuffix = hasThread ? `:${payload.threadId}` : "";
+  return computeIdempotencyKey(
+    payload.campaignSlug,
+    "telegram",
+    `${targetChatId}${threadKeySuffix}:${payload.locale}`,
+    { isTest: payload.isTestDispatch }
+  );
+}
+function makeResult(channel, driver, recipientMasked, locale, status, idempotencyKey, extra) {
+  return {
+    channel,
+    driver,
+    recipientMasked,
+    locale,
+    status,
+    idempotencyKey,
+    ...extra
+  };
+}
+function parseTargetList(raw) {
+  if (!raw) return [];
+  const items = Array.isArray(raw) ? raw : String(raw).split(",");
+  return Array.from(
+    new Set(items.map((item) => String(item).trim()).filter(Boolean))
+  );
+}
+function resolveTelegramTargets(campaign2, settings) {
+  const fromCampaign = parseTargetList(campaign2.telegramChatId);
+  if (fromCampaign.length > 0) return fromCampaign;
+  const fromTopic = parseTargetList(
+    settings.telegramTopicChatMap?.[campaign2.topic]
+  );
+  if (fromTopic.length > 0) return fromTopic;
+  return parseTargetList(settings.telegramDefaultChatId);
+}
+function resolveWhatsAppRecipients(campaign2, settings, subscribers, isTestDispatch) {
+  const configuredGroupsAndNumbers = isTestDispatch ? [] : [
+    ...parseTargetList(settings.whatsappDefaultRecipients),
+    ...parseTargetList(settings.whatsappTopicGroupMap?.[campaign2.topic]),
+    ...parseTargetList(campaign2.whatsappGroupIds)
+  ];
+  const rawPhoneRecipients = [
+    ...subscribers.filter((r) => Boolean(r.phone)),
+    ...configuredGroupsAndNumbers.map((phone) => ({
+      phone,
+      fullName: "Comunidad",
+      locale: settings.defaultLocale || "es",
+      topics: [campaign2.topic]
+    }))
+  ];
+  const seenWhatsAppTargets = /* @__PURE__ */ new Set();
+  const deduplicated = [];
+  for (const recipient of rawPhoneRecipients) {
+    if (!recipient.phone) continue;
+    const normKey = normalizeWhatsAppTarget(recipient.phone).normalized;
+    if (!normKey || seenWhatsAppTargets.has(normKey)) continue;
+    seenWhatsAppTargets.add(normKey);
+    deduplicated.push(recipient);
+  }
+  return deduplicated;
+}
+function createEmptyStats() {
+  return {
+    totalRecipients: 0,
+    sentCount: 0,
+    simulatedCount: 0,
+    skippedCount: 0,
+    failedCount: 0,
+    byChannel: {}
+  };
+}
+function recordResultInStats(stats, result) {
+  stats.totalRecipients += 1;
+  const bucket = stats.byChannel[result.channel] || {
+    sent: 0,
+    simulated: 0,
+    skipped: 0,
+    failed: 0
+  };
+  if (result.status === "sent") {
+    stats.sentCount += 1;
+    bucket.sent += 1;
+  } else if (result.status === "simulated") {
+    stats.simulatedCount += 1;
+    bucket.simulated += 1;
+  } else if (result.status === "skipped_duplicate") {
+    stats.skippedCount += 1;
+    bucket.skipped += 1;
+  } else {
+    stats.failedCount += 1;
+    bucket.failed += 1;
+  }
+  stats.byChannel[result.channel] = bucket;
+}
+function resolveEffectiveEmailTemplateRef(payload, settings) {
+  if (settings.enableEmailDesignerBridge === false) return "";
+  return String(
+    payload.emailTemplateRef || settings.defaultEmailTemplateRef || ""
+  ).trim();
+}
+function buildEmailTemplateVariables(payload, settings, inlineHtml) {
+  const extraEntries = Object.entries(payload.templateData || {}).map(
+    ([k, v]) => [
+      k,
+      v !== void 0 && v !== null ? escapeHtml(String(v)) : void 0
+    ]
+  );
+  return {
+    subject: escapeHtml(payload.subject),
+    bodyText: escapeHtml(payload.text),
+    bodyHtml: inlineHtml,
+    text: escapeHtml(payload.text),
+    html: inlineHtml,
+    ctaLabel: escapeHtml(payload.ctaLabel || ""),
+    ctaUrl: escapeHtml(payload.ctaUrl || settings.siteBaseUrl),
+    unsubscribeUrl: escapeHtml(payload.unsubscribeUrl || ""),
+    secondaryDate: escapeHtml(payload.secondaryDateLabel || ""),
+    organizationName: escapeHtml(settings.organizationName),
+    siteBaseUrl: escapeHtml(settings.siteBaseUrl),
+    ...Object.fromEntries(extraEntries)
+  };
+}
+function buildTelegramRequestPayload(payload, targetChatId) {
+  const normalizedSubject = String(payload.subject || "").replace(/[\u0000-\u001f\u007f]+/g, " ").trim();
+  const safeSubject = escapeHtml(normalizedSubject);
+  const safeBody = sanitizeTelegramHtml(payload.htmlBody);
+  const text = safeBody ? `<b>${safeSubject}</b>
+
+${safeBody}` : `<b>${safeSubject}</b>`;
+  const bodyPayload = {
+    chat_id: targetChatId,
+    text,
+    parse_mode: "HTML",
+    disable_web_page_preview: false
+  };
+  if (typeof payload.threadId === "number" && payload.threadId > 0) {
+    bodyPayload.message_thread_id = payload.threadId;
+  }
+  if (payload.ctaLabel && payload.ctaUrl && isSafeHttpUrl(payload.ctaUrl)) {
+    bodyPayload.reply_markup = {
+      inline_keyboard: [[{ text: payload.ctaLabel, url: payload.ctaUrl }]]
+    };
+  }
+  return bodyPayload;
+}
+async function executeTelegramHttpSend(payload, targetChatId, botToken) {
+  const cleanToken = String(botToken || "").trim();
+  if (!TELEGRAM_BOT_TOKEN_RE.test(cleanToken)) {
+    throw new Error("Invalid Telegram bot token format");
+  }
+  const endpoint = `https://api.telegram.org/bot${cleanToken}/sendMessage`;
+  const bodyPayload = buildTelegramRequestPayload(payload, targetChatId);
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(bodyPayload),
+    redirect: "error",
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  const json = await response.json();
+  if (!response.ok || !json.ok) {
+    throw new Error(json.description || `Telegram HTTP ${response.status}`);
+  }
+  return String(json.result?.message_id || Date.now());
+}
+async function sendViaMetaCloudApi(payload, settings, evolutionNumber, fullText) {
+  const phoneId = String(settings.whatsappPhoneNumberId || "").trim();
+  if (!/^[A-Za-z0-9_-]+$/.test(phoneId)) {
+    throw new Error("Invalid Meta WABA phoneNumberId format");
+  }
+  const endpoint = `https://graph.facebook.com/v20.0/${encodeURIComponent(
+    phoneId
+  )}/messages`;
+  const reqBody = payload.templateName ? {
+    messaging_product: "whatsapp",
+    to: evolutionNumber,
+    type: "template",
+    template: {
+      name: payload.templateName,
+      language: { code: payload.locale }
+    }
+  } : {
+    messaging_product: "whatsapp",
+    to: evolutionNumber,
+    type: "text",
+    text: { preview_url: true, body: fullText }
+  };
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${settings.whatsappAccessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(reqBody),
+    redirect: "error",
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  const json = await res.json();
+  if (!res.ok) {
+    throw new Error(json.error?.message || `Meta Cloud HTTP ${res.status}`);
+  }
+  return json.messages?.[0]?.id || `waba_${Date.now()}`;
+}
+async function sendViaSelfHostedGateway(driver, settings, target, fullText) {
+  const gatewayCheck = validateGatewayUrl(settings.whatsappGatewayUrl || "", {
+    allowLocalhost: Boolean(settings.allowLocalhostGateways)
+  });
+  if (!gatewayCheck.valid) throw new Error(gatewayCheck.errors.join("; "));
+  const rawSession = String(
+    settings.whatsappGatewaySession || "default"
+  ).trim();
+  if (!isValidGatewaySession(rawSession)) {
+    throw new Error("Invalid WhatsApp gateway session identifier");
+  }
+  let baseUrl = settings.whatsappGatewayUrl || "";
+  while (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  const session = encodeURIComponent(rawSession);
+  const endpoint = driver === "evolution" ? `${baseUrl}/message/sendText/${session}` : `${baseUrl}/api/sendText`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (settings.whatsappGatewayApiKey) {
+    headers.apikey = settings.whatsappGatewayApiKey;
+    headers["X-Api-Key"] = settings.whatsappGatewayApiKey;
+  }
+  const body = driver === "evolution" ? { number: target.evolutionNumber, text: fullText } : {
+    session: rawSession,
+    chatId: target.chatId,
+    text: fullText
+  };
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    redirect: "error",
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok) throw new Error(`${driver} gateway HTTP ${res.status}`);
+  return `${driver}_${Date.now()}`;
+}
+async function executeWhatsAppHttpSend(driver, payload, settings, target) {
+  const safeCtaUrl = payload.ctaUrl && isSafeHttpUrl(payload.ctaUrl) ? payload.ctaUrl : void 0;
+  const fullText = safeCtaUrl ? `${payload.textBody}
+
+🔗 ${safeCtaUrl}` : payload.textBody;
+  if (driver === "meta-cloud") {
+    return sendViaMetaCloudApi(
+      payload,
+      settings,
+      target.evolutionNumber,
+      fullText
+    );
+  }
+  return sendViaSelfHostedGateway(driver, settings, target, fullText);
+}
+function hasWhatsAppCredentials(driver, settings) {
+  if (driver === "meta-cloud") {
+    return Boolean(
+      settings.whatsappPhoneNumberId && settings.whatsappAccessToken
+    );
+  }
+  return Boolean(settings.whatsappGatewayUrl);
+}
+function toPlainString(val) {
+  if (typeof val !== "string") return void 0;
+  const trimmed = val.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function respondError(ctx, err) {
+  const message = err?.message || "Invalid request";
+  if (/not found$/i.test(message)) {
+    if (typeof ctx.notFound === "function") {
+      return ctx.notFound(message);
+    }
+    ctx.status = 404;
+    ctx.body = { error: message };
+    return void 0;
+  }
+  if (typeof ctx.badRequest === "function") {
+    return ctx.badRequest(message);
+  }
+  ctx.status = 400;
+  ctx.body = { error: message };
+  return void 0;
+}
+const broadcastController = ({ strapi }) => ({
+  async getSettings(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("settings");
+    const data = await svc.getPublicSafeSettings();
+    ctx.body = { data };
+  },
+  async updateSettings(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("settings");
+    try {
+      await svc.updateSettings(
+        ctx.request.body || {}
+      );
+      const data = await svc.getPublicSafeSettings();
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async listStarterTemplates(ctx) {
+    ctx.body = { data: STARTER_CAMPAIGN_TEMPLATES };
+  },
+  async listEmailTemplates(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("transportService");
+    const data = await svc.listEmailDesignerTemplates();
+    ctx.body = { data };
+  },
+  async listCampaigns(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("campaignService");
+    const data = await svc.listCampaigns({
+      status: toPlainString(ctx.query?.status),
+      topic: toPlainString(ctx.query?.topic)
+    });
+    ctx.body = { data };
+  },
+  async createCampaign(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("campaignService");
+    try {
+      const data = await svc.createCampaign(
+        ctx.request.body || {}
+      );
+      ctx.status = 201;
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async updateCampaign(ctx) {
+    const documentId = toPlainString(ctx.params?.documentId) || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("campaignService");
+    try {
+      const data = await svc.updateCampaign(
+        documentId,
+        ctx.request.body || {}
+      );
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async createFromTemplate(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("campaignService");
+    try {
+      const body = ctx.request.body || {};
+      const templateId = toPlainString(body.templateId) || "";
+      const data = await svc.createFromStarterTemplate(templateId);
+      ctx.status = 201;
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async sendCampaign(ctx) {
+    const documentId = toPlainString(ctx.params?.documentId) || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("campaignService");
+    try {
+      const rawBody = ctx.request.body && typeof ctx.request.body === "object" && !Array.isArray(ctx.request.body) ? ctx.request.body : {};
+      const customRecipients = Array.isArray(rawBody.customRecipients) ? rawBody.customRecipients.filter(
+        (item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)
+      ) : void 0;
+      const data = await svc.dispatchCampaign(documentId, {
+        customRecipients,
+        testRecipientEmail: toPlainString(rawBody.testRecipientEmail),
+        testRecipientPhone: toPlainString(rawBody.testRecipientPhone),
+        testTelegramChatId: toPlainString(rawBody.testTelegramChatId)
+      });
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async listAutomationRules(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("automationService");
+    const data = await svc.listRules();
+    ctx.body = { data };
+  },
+  async createAutomationRule(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("automationService");
+    try {
+      const data = await svc.createRule(
+        ctx.request.body || {}
+      );
+      ctx.status = 201;
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async updateAutomationRule(ctx) {
+    const documentId = toPlainString(ctx.params?.documentId) || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("automationService");
+    try {
+      const data = await svc.updateRule(
+        documentId,
+        ctx.request.body || {}
+      );
+      ctx.body = { data };
+      return void 0;
+    } catch (err) {
+      return respondError(ctx, err);
+    }
+  },
+  async listDeliveryLogs(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("transportService");
+    const rawChannel = toPlainString(ctx.query?.channel);
+    const channel = rawChannel && SUPPORTED_CHANNELS.includes(rawChannel) ? rawChannel : void 0;
+    const data = await svc.listDeliveryLogs({
+      campaignSlug: toPlainString(ctx.query?.campaignSlug),
+      channel,
+      limit: clampLimit(ctx.query?.limit, 100)
+    });
+    ctx.body = { data };
+  },
+  async listPublicChannels(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("settings");
+    const settings = await svc.getSettings();
+    const safeLinks = (settings.publicChannelLinks || []).filter(
+      (link) => isSafeHttpUrl(link?.inviteUrl)
+    );
+    ctx.body = {
+      data: {
+        organizationName: settings.organizationName,
+        defaultLocale: settings.defaultLocale,
+        supportedLocales: settings.supportedLocales,
+        availableTopics: settings.availableTopics,
+        publicChannelLinks: safeLinks
+      }
+    };
+  },
+  async listPublicArchive(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("campaignService");
+    const data = await svc.listPublicArchive({
+      topic: toPlainString(ctx.query?.topic),
+      limit: clampLimit(ctx.query?.limit, 20)
+    });
+    ctx.body = { data };
+  }
+});
+const controllers = {
+  broadcastController
+};
+const destroy = ({ strapi }) => {
+  cleanupEventHubListeners(strapi);
+  strapi.log.debug("[@vicacha-devs/strapi-plugin-broadcasts] Destroyed");
+};
+const DANGEROUS_KEYS$1 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function sanitizeAttributeDefinition(attrDef) {
+  const safe = {};
+  for (const [key, val] of Object.entries(attrDef)) {
+    if (DANGEROUS_KEYS$1.has(key) || !Object.hasOwn(attrDef, key)) continue;
+    safe[key] = val;
+  }
+  return safe;
+}
+function applyAttributeExtension(schema2, attrName, attrDef) {
+  if (!schema2 || DANGEROUS_KEYS$1.has(attrName)) return;
+  const safeDef = sanitizeAttributeDefinition(attrDef);
+  if (schema2.attributes) {
+    const prev = Object.hasOwn(schema2.attributes, attrName) ? schema2.attributes[attrName] : {};
+    schema2.attributes[attrName] = { ...prev, ...safeDef };
+  }
+  if (schema2.__schema__?.attributes) {
+    const prev = Object.hasOwn(schema2.__schema__.attributes, attrName) ? schema2.__schema__.attributes[attrName] : {};
+    schema2.__schema__.attributes[attrName] = { ...prev, ...safeDef };
+  }
+}
+function extendContentTypeSchema(strapi, targetKey, extraAttributes) {
+  if (!targetKey || DANGEROUS_KEYS$1.has(targetKey) || !extraAttributes || typeof extraAttributes !== "object" || Array.isArray(extraAttributes)) {
+    return;
+  }
+  const resolvedUid = targetKey.startsWith("plugin::") ? targetKey : `plugin::${PLUGIN_ID}.${targetKey}`;
+  if (DANGEROUS_KEYS$1.has(resolvedUid)) return;
+  const contentTypes2 = strapi.contentTypes;
+  const schema2 = contentTypes2 && Object.hasOwn(contentTypes2, resolvedUid) ? contentTypes2[resolvedUid] : void 0;
+  for (const [attrName, attrDef] of Object.entries(extraAttributes)) {
+    if (!attrName || DANGEROUS_KEYS$1.has(attrName) || !Object.hasOwn(extraAttributes, attrName) || !attrDef || typeof attrDef !== "object" || Array.isArray(attrDef)) {
+      continue;
+    }
+    applyAttributeExtension(schema2, attrName, attrDef);
+  }
+}
+const register = ({ strapi }) => {
+  const config2 = strapi.config?.get?.(`plugin::${PLUGIN_ID}`) ?? {};
+  const extensions = config2.schemaExtensions;
+  if (extensions && typeof extensions === "object" && !Array.isArray(extensions)) {
+    for (const [targetKey, extraAttributes] of Object.entries(extensions)) {
+      if (!Object.hasOwn(extensions, targetKey)) continue;
+      extendContentTypeSchema(strapi, targetKey, extraAttributes);
+    }
+  }
+  strapi.log.debug(
+    "[@vicacha-devs/strapi-plugin-broadcasts] Registered omnichannel broadcasts plugin"
+  );
+};
+function adminPolicies(...actionUids) {
+  return [
+    "admin::isAuthenticatedAdmin",
+    {
+      name: "admin::hasPermissions",
+      config: {
+        actions: actionUids.map((uid) => `plugin::${PLUGIN_ID}.${uid}`)
+      }
+    }
+  ];
+}
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "broadcastController.getSettings",
+      config: { policies: adminPolicies("settings.manage") }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "broadcastController.updateSettings",
+      config: { policies: adminPolicies("settings.manage") }
+    },
+    {
+      method: "GET",
+      path: "/templates",
+      handler: "broadcastController.listStarterTemplates",
+      config: { policies: adminPolicies("read") }
+    },
+    {
+      method: "GET",
+      path: "/email-templates",
+      handler: "broadcastController.listEmailTemplates",
+      config: { policies: adminPolicies("read") }
+    },
+    {
+      method: "GET",
+      path: "/campaigns",
+      handler: "broadcastController.listCampaigns",
+      config: { policies: adminPolicies("read") }
+    },
+    {
+      method: "POST",
+      path: "/campaigns",
+      handler: "broadcastController.createCampaign",
+      config: { policies: adminPolicies("campaigns.manage") }
+    },
+    {
+      method: "PUT",
+      path: "/campaigns/:documentId",
+      handler: "broadcastController.updateCampaign",
+      config: { policies: adminPolicies("campaigns.manage") }
+    },
+    {
+      method: "POST",
+      path: "/campaigns/from-template",
+      handler: "broadcastController.createFromTemplate",
+      config: { policies: adminPolicies("campaigns.manage") }
+    },
+    {
+      method: "POST",
+      path: "/campaigns/:documentId/send",
+      handler: "broadcastController.sendCampaign",
+      config: { policies: adminPolicies("campaigns.send") }
+    },
+    {
+      method: "GET",
+      path: "/automation-rules",
+      handler: "broadcastController.listAutomationRules",
+      config: { policies: adminPolicies("read") }
+    },
+    {
+      method: "POST",
+      path: "/automation-rules",
+      handler: "broadcastController.createAutomationRule",
+      config: { policies: adminPolicies("automations.manage") }
+    },
+    {
+      method: "PUT",
+      path: "/automation-rules/:documentId",
+      handler: "broadcastController.updateAutomationRule",
+      config: { policies: adminPolicies("automations.manage") }
+    },
+    {
+      method: "GET",
+      path: "/delivery-logs",
+      handler: "broadcastController.listDeliveryLogs",
+      config: { policies: adminPolicies("read") }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/public/channels",
+      handler: "broadcastController.listPublicChannels",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/public/archive",
+      handler: "broadcastController.listPublicArchive",
+      config: {
+        policies: [],
+        auth: false
+      }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentApi,
+  admin
+};
+function buildRuleDocumentData(rule, channels, fallbackActive = true) {
+  const safeBodyTemplate = String(rule.bodyTextTemplate || "");
+  return {
+    slug: rule.slug,
+    name: rule.name,
+    eventName: rule.eventName,
+    targetContentType: rule.targetContentType,
+    topic: rule.topic || "announcements",
+    channels,
+    active: rule.active ?? fallbackActive,
+    priority: rule.priority || "normal",
+    subjectTemplate: rule.subjectTemplate,
+    bodyTextTemplate: safeBodyTemplate,
+    bodyHtmlTemplate: rule.bodyHtmlTemplate || `<p>${escapeHtml(safeBodyTemplate)}</p>`,
+    ctaLabelTemplate: rule.ctaLabelTemplate,
+    ctaUrlTemplate: rule.ctaUrlTemplate,
+    translations: rule.translations || {}
+  };
+}
+function buildPresetRulePayload(preset) {
+  return {
+    slug: preset.slug,
+    name: preset.name,
+    eventName: preset.eventName,
+    targetContentType: preset.targetContentType,
+    topic: preset.topic || "announcements",
+    channels: preset.channels || ["telegram"],
+    active: preset.active ?? true,
+    priority: preset.priority || "normal",
+    subjectTemplate: preset.subjectTemplate || "📢 {{title}}",
+    bodyTextTemplate: preset.bodyTextTemplate || "{{title}}: {{message}} ({{secondaryDate}})",
+    bodyHtmlTemplate: preset.bodyHtmlTemplate,
+    ctaLabelTemplate: preset.ctaLabelTemplate,
+    ctaUrlTemplate: preset.ctaUrlTemplate,
+    translations: preset.translations || {}
+  };
+}
+function doesRuleMatchTrigger(rule, eventName, payload) {
+  if (!rule.active || rule.eventName !== eventName) return false;
+  if (rule.targetContentType && payload.model && String(payload.model) !== rule.targetContentType) {
+    return false;
+  }
+  return true;
+}
+function firstNonEmptyString(record, keys, fallback) {
+  for (const key of keys) {
+    const val = record[key];
+    if (val !== void 0 && val !== null && String(val) !== "") {
+      return String(val);
+    }
+  }
+  return fallback;
+}
+function extractTriggerVariables(eventName, payload, settings, secondaryDateFormatted) {
+  const entryRecord = payload.entry ?? payload;
+  return {
+    title: firstNonEmptyString(
+      entryRecord,
+      ["title", "name", "subject"],
+      eventName
+    ),
+    message: firstNonEmptyString(
+      entryRecord,
+      ["message", "summary", "description"],
+      ""
+    ),
+    summary: firstNonEmptyString(
+      entryRecord,
+      ["summary", "description", "message"],
+      ""
+    ),
+    code: firstNonEmptyString(entryRecord, ["code", "slug"], "event"),
+    organizationName: settings.organizationName,
+    siteBaseUrl: settings.siteBaseUrl,
+    secondaryDate: secondaryDateFormatted
+  };
+}
+function buildAutoCampaignInput(rule, vars) {
+  let rawCode = String(vars.code || "item").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "");
+  while (rawCode.endsWith("-")) {
+    rawCode = rawCode.slice(0, -1);
+  }
+  const safeCode = rawCode || "item";
+  const uniqueSuffix = generateUniqueSlugSuffix();
+  const bodyHtml = rule.bodyHtmlTemplate ? interpolateBroadcastTemplate(rule.bodyHtmlTemplate, vars, {
+    escapeHtmlValues: true
+  }) : `<p>${escapeHtml(interpolateBroadcastTemplate(rule.bodyTextTemplate, vars))}</p>`;
+  const rawCtaUrl = rule.ctaUrlTemplate ? interpolateBroadcastTemplate(rule.ctaUrlTemplate, vars) : void 0;
+  return {
+    slug: `auto-${rule.slug}-${safeCode}-${uniqueSuffix}`,
+    title: `[Auto] ${rule.name}: ${vars.title}`,
+    topic: rule.topic,
+    channels: rule.channels,
+    priority: rule.priority,
+    subject: interpolateBroadcastTemplate(rule.subjectTemplate, vars),
+    bodyText: interpolateBroadcastTemplate(rule.bodyTextTemplate, vars),
+    bodyHtml,
+    ctaLabel: rule.ctaLabelTemplate ? interpolateBroadcastTemplate(rule.ctaLabelTemplate, vars) : void 0,
+    ctaUrl: rawCtaUrl && isSafeHttpUrl(rawCtaUrl) ? rawCtaUrl : void 0
+  };
+}
+function isSelfBroadcastEvent(eventName, payload) {
+  const normalizedEvent = String(eventName || "").trim().toLowerCase();
+  if (!normalizedEvent || normalizedEvent.startsWith("broadcasts.")) {
+    return true;
+  }
+  const model = typeof payload?.model === "string" ? payload.model.trim().toLowerCase() : "";
+  const uid = typeof payload?.uid === "string" ? payload.uid.trim().toLowerCase() : "";
+  return model.startsWith("plugin::broadcasts.") || uid.startsWith("plugin::broadcasts.");
+}
+const createAutomationService = ({ strapi }) => ({
+  getSettingsService() {
+    return strapi.plugin(PLUGIN_ID).service("settings");
+  },
+  getCampaignService() {
+    return strapi.plugin(PLUGIN_ID).service("campaignService");
+  },
+  async listRules() {
+    const docs = await strapi.documents(AUTOMATION_RULE_UID).findMany({
+      limit: 100
+    });
+    return docs;
+  },
+  async getRuleBySlug(slug) {
+    const docs = await strapi.documents(AUTOMATION_RULE_UID).findMany({
+      filters: { slug },
+      limit: 1
+    });
+    return docs[0] || null;
+  },
+  async findRuleByDocIdOrSlug(documentIdOrSlug) {
+    const byDoc = await strapi.documents(AUTOMATION_RULE_UID).findOne({
+      documentId: documentIdOrSlug
+    });
+    return byDoc ?? await this.getRuleBySlug(documentIdOrSlug);
+  },
+  async createRule(input) {
+    const rawChannels = input.channels === void 0 ? ["telegram"] : input.channels;
+    const validation = validateAutomationRuleInput({
+      ...input,
+      channels: rawChannels
+    });
+    if (!validation.valid) {
+      throw new Error(validation.errors.join("; "));
+    }
+    const channels = normalizeChannels(rawChannels, ["telegram"]);
+    const candidate = {
+      ...input
+    };
+    const created = await strapi.documents(AUTOMATION_RULE_UID).create({
+      data: {
+        ...buildRuleDocumentData(candidate, channels, true),
+        triggerCount: 0
+      }
+    });
+    if (candidate.eventName) {
+      ensureEventHubListener(strapi, candidate.eventName);
+    }
+    return created;
+  },
+  async updateRule(documentIdOrSlug, input) {
+    const existing = await this.findRuleByDocIdOrSlug(documentIdOrSlug);
+    if (!existing?.documentId) {
+      throw new Error(`Automation rule "${documentIdOrSlug}" not found`);
+    }
+    const rawChannels = input.channels === void 0 ? existing.channels : input.channels;
+    const resolvedBodyHtmlTemplate = input.bodyHtmlTemplate !== void 0 ? input.bodyHtmlTemplate : input.bodyTextTemplate !== void 0 && (input.bodyTextTemplate !== existing.bodyTextTemplate || !existing.bodyHtmlTemplate) ? `<p>${escapeHtml(String(input.bodyTextTemplate))}</p>` : existing.bodyHtmlTemplate;
+    const mergedForValidation = {
+      ...existing,
+      ...input,
+      bodyHtmlTemplate: resolvedBodyHtmlTemplate,
+      channels: rawChannels
+    };
+    const validation = validateAutomationRuleInput(mergedForValidation);
+    if (!validation.valid) {
+      throw new Error(validation.errors.join("; "));
+    }
+    const channels = normalizeChannels(rawChannels, ["telegram"]);
+    const merged = {
+      ...mergedForValidation,
+      channels
+    };
+    const updated = await strapi.documents(AUTOMATION_RULE_UID).update({
+      documentId: existing.documentId,
+      data: buildRuleDocumentData(merged, channels, existing.active ?? true)
+    });
+    if (merged.eventName) {
+      ensureEventHubListener(strapi, merged.eventName);
+    }
+    return updated || merged;
+  },
+  async seedStarterRules() {
+    const settings = await this.getSettingsService().getSettings();
+    const presets = settings.presetAutomationRules?.length ? settings.presetAutomationRules : STARTER_AUTOMATION_RULES;
+    let seededCount = 0;
+    for (const preset of presets) {
+      if (!preset.slug || !preset.name || !preset.eventName) continue;
+      const existing = await this.getRuleBySlug(preset.slug);
+      if (existing) continue;
+      await this.createRule(buildPresetRulePayload(preset));
+      seededCount += 1;
+    }
+    return seededCount;
+  },
+  async executeSingleTriggerRule(rule, vars) {
+    const campaignService = this.getCampaignService();
+    const campaign2 = await campaignService.createCampaign(
+      buildAutoCampaignInput(rule, vars)
+    );
+    const dispatched = await campaignService.dispatchCampaign(
+      campaign2.documentId || campaign2.slug
+    );
+    if (rule.documentId) {
+      await strapi.documents(AUTOMATION_RULE_UID).update({
+        documentId: rule.documentId,
+        data: {
+          lastTriggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          triggerCount: (rule.triggerCount || 0) + 1
+        }
+      });
+    }
+    return {
+      ruleSlug: rule.slug,
+      campaignSlug: dispatched.campaign.slug,
+      results: dispatched.results
+    };
+  },
+  async handleEventTrigger(eventName, payload = {}) {
+    if (isSelfBroadcastEvent(eventName, payload)) {
+      return [];
+    }
+    const settings = await this.getSettingsService().getSettings();
+    if (!settings.enableEventHubAutomations) return [];
+    const allRules = await this.listRules();
+    const matchingRules = allRules.filter(
+      (rule) => doesRuleMatchTrigger(rule, eventName, payload)
+    );
+    if (matchingRules.length === 0) return [];
+    const secondaryCal = settings.secondaryCalendars?.[0] || "islamic-umalqura";
+    const secondaryDate = formatSecondaryDate(
+      (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      secondaryCal,
+      settings.defaultLocale || "es"
+    );
+    const vars = extractTriggerVariables(
+      eventName,
+      payload,
+      settings,
+      secondaryDate.formatted
+    );
+    const outcomes = [];
+    for (const rule of matchingRules) {
+      outcomes.push(await this.executeSingleTriggerRule(rule, vars));
+    }
+    return outcomes;
+  }
+});
+function buildCampaignDocumentData(candidate, channels, resolvedStatus = "draft") {
+  const safeBodyText = String(candidate.bodyText || "");
+  return {
+    title: candidate.title,
+    slug: candidate.slug,
+    topic: candidate.topic || "announcements",
+    channels,
+    priority: candidate.priority || "normal",
+    status: resolvedStatus,
+    scheduledAt: candidate.scheduledAt,
+    subject: candidate.subject,
+    bodyText: safeBodyText,
+    bodyHtml: candidate.bodyHtml || `<p>${escapeHtml(safeBodyText)}</p>`,
+    ctaLabel: candidate.ctaLabel,
+    ctaUrl: candidate.ctaUrl,
+    mediaUrl: candidate.mediaUrl,
+    emailTemplateRef: candidate.emailTemplateRef,
+    whatsappTemplateName: candidate.whatsappTemplateName,
+    whatsappGroupIds: Array.isArray(candidate.whatsappGroupIds) ? candidate.whatsappGroupIds : [],
+    telegramChatId: candidate.telegramChatId,
+    telegramThreadId: candidate.telegramThreadId,
+    translations: candidate.translations || {}
+  };
+}
+function buildPresetCampaignPayload(preset) {
+  return {
+    slug: preset.slug,
+    title: preset.title,
+    topic: preset.topic || "announcements",
+    channels: preset.channels || ["email", "telegram"],
+    priority: preset.priority || "normal",
+    subject: preset.subject || preset.title,
+    bodyText: preset.bodyText || preset.title,
+    bodyHtml: preset.bodyHtml,
+    ctaLabel: preset.ctaLabel,
+    ctaUrl: preset.ctaUrl,
+    emailTemplateRef: preset.emailTemplateRef,
+    translations: preset.translations || {}
+  };
+}
+function mapRawSubscriber(sub, defaultLocale) {
+  return {
+    email: typeof sub.email === "string" ? sub.email : void 0,
+    phone: typeof sub.phone === "string" ? sub.phone : void 0,
+    fullName: typeof sub.fullName === "string" ? sub.fullName : void 0,
+    locale: typeof sub.locale === "string" && sub.locale ? sub.locale : defaultLocale,
+    topics: Array.isArray(sub.topics) ? sub.topics.map((t) => String(t)) : ["announcements"],
+    unsubscribeToken: typeof sub.unsubscribeToken === "string" ? sub.unsubscribeToken : void 0
+  };
+}
+async function dispatchTelegramChannel(transport, campaign2, settings, secondaryDateLabel, isTestDispatch, testTelegramChatId, stats, results) {
+  if (isTestDispatch && !testTelegramChatId) {
+    return;
+  }
+  const channelLocale = settings.defaultLocale || "es";
+  const localized = resolveLocalizedCampaignCopy(
+    campaign2,
+    channelLocale,
+    settings.defaultLocale
+  );
+  const vars = {
+    recipientName: "Comunidad",
+    organizationName: settings.organizationName,
+    secondaryDate: secondaryDateLabel,
+    siteBaseUrl: settings.siteBaseUrl
+  };
+  const tgTargets = isTestDispatch ? parseTargetList(testTelegramChatId) : resolveTelegramTargets(campaign2, settings);
+  const threadId = campaign2.telegramThreadId ?? settings.telegramTopicThreadMap?.[campaign2.topic];
+  const htmlBody = localized.bodyHtml ? interpolateBroadcastTemplate(localized.bodyHtml, vars, {
+    escapeHtmlValues: true
+  }) : escapeHtml(interpolateBroadcastTemplate(localized.bodyText, vars));
+  const interpolatedCtaUrl = localized.ctaUrl ? interpolateBroadcastTemplate(localized.ctaUrl, vars) : void 0;
+  for (const chatId of tgTargets) {
+    const tgRes = await transport.sendTelegramBroadcast({
+      campaignSlug: campaign2.slug,
+      chatId,
+      threadId,
+      locale: channelLocale,
+      subject: interpolateBroadcastTemplate(localized.subject, vars),
+      htmlBody,
+      ctaLabel: localized.ctaLabel ? interpolateBroadcastTemplate(localized.ctaLabel, vars) : void 0,
+      ctaUrl: interpolatedCtaUrl && isSafeHttpUrl(interpolatedCtaUrl) ? interpolatedCtaUrl : void 0,
+      secondaryDateLabel,
+      isTestDispatch
+    });
+    results.push(tgRes);
+    recordResultInStats(stats, tgRes);
+  }
+}
+function buildEmailSendPayloadForRecipient(campaign2, recipient, settings, secondaryDateLabel, isTestDispatch) {
+  const locale = recipient.locale || settings.defaultLocale || "es";
+  const localized = resolveLocalizedCampaignCopy(
+    campaign2,
+    locale,
+    settings.defaultLocale
+  );
+  let baseSite = settings.siteBaseUrl;
+  while (baseSite.endsWith("/")) {
+    baseSite = baseSite.slice(0, -1);
+  }
+  const rawUnsubscribeUrl = recipient.unsubscribeToken ? `${baseSite}/api/inbox/public/unsubscribe?token=${encodeURIComponent(
+    recipient.unsubscribeToken
+  )}` : `${baseSite}/${encodeURIComponent(locale)}/unsubscribe`;
+  const unsubscribeUrl = stripHeaderControlChars(rawUnsubscribeUrl);
+  const recipientName = recipient.fullName || recipient.email;
+  const vars = {
+    recipientName,
+    organizationName: settings.organizationName,
+    secondaryDate: secondaryDateLabel,
+    siteBaseUrl: settings.siteBaseUrl,
+    unsubscribeUrl
+  };
+  const html = localized.bodyHtml ? interpolateBroadcastTemplate(localized.bodyHtml, vars, {
+    escapeHtmlValues: true
+  }) : `<p>${escapeHtml(interpolateBroadcastTemplate(localized.bodyText, vars))}</p>`;
+  const resolvedCtaUrl = localized.ctaUrl ? interpolateBroadcastTemplate(localized.ctaUrl, vars) : void 0;
+  return {
+    campaignSlug: campaign2.slug,
+    recipientEmail: recipient.email,
+    locale,
+    subject: stripHeaderControlChars(
+      interpolateBroadcastTemplate(localized.subject, vars)
+    ),
+    text: interpolateBroadcastTemplate(localized.bodyText, vars),
+    html,
+    ctaLabel: localized.ctaLabel ? interpolateBroadcastTemplate(localized.ctaLabel, vars) : void 0,
+    ctaUrl: resolvedCtaUrl && isSafeHttpUrl(resolvedCtaUrl) ? resolvedCtaUrl : void 0,
+    unsubscribeUrl,
+    emailTemplateRef: campaign2.emailTemplateRef,
+    secondaryDateLabel,
+    templateData: {
+      recipientName,
+      title: campaign2.title,
+      topic: campaign2.topic
+    },
+    isTestDispatch
+  };
+}
+async function dispatchEmailChannel(transport, campaign2, settings, recipients, secondaryDateLabel, isTestDispatch, stats, results) {
+  for (const recipient of recipients) {
+    if (!recipient.email) continue;
+    const payload = buildEmailSendPayloadForRecipient(
+      campaign2,
+      recipient,
+      settings,
+      secondaryDateLabel,
+      isTestDispatch
+    );
+    const emailRes = await transport.sendEmailBroadcast(payload);
+    results.push(emailRes);
+    recordResultInStats(stats, emailRes);
+  }
+}
+async function dispatchWhatsAppChannel(transport, campaign2, settings, recipients, isTestDispatch, secondaryDateLabel, stats, results) {
+  const waRecipients = resolveWhatsAppRecipients(
+    campaign2,
+    settings,
+    recipients,
+    isTestDispatch
+  );
+  for (const recipient of waRecipients) {
+    if (!recipient.phone) continue;
+    const locale = recipient.locale || settings.defaultLocale || "es";
+    const localized = resolveLocalizedCampaignCopy(
+      campaign2,
+      locale,
+      settings.defaultLocale
+    );
+    const vars = {
+      recipientName: recipient.fullName || "Comunidad",
+      organizationName: settings.organizationName,
+      secondaryDate: secondaryDateLabel,
+      siteBaseUrl: settings.siteBaseUrl
+    };
+    const resolvedCtaUrl = localized.ctaUrl ? interpolateBroadcastTemplate(localized.ctaUrl, vars) : void 0;
+    const waRes = await transport.sendWhatsAppBroadcast({
+      campaignSlug: campaign2.slug,
+      recipientPhone: recipient.phone,
+      locale,
+      textBody: interpolateBroadcastTemplate(localized.bodyText, vars),
+      templateName: campaign2.whatsappTemplateName,
+      ctaUrl: resolvedCtaUrl && isSafeHttpUrl(resolvedCtaUrl) ? resolvedCtaUrl : void 0,
+      secondaryDateLabel,
+      isTestDispatch
+    });
+    results.push(waRes);
+    recordResultInStats(stats, waRes);
+  }
+}
+async function dispatchAllActiveChannels(params) {
+  const {
+    transport,
+    campaign: campaign2,
+    settings,
+    recipients,
+    isTestDispatch,
+    testTelegramChatId,
+    secondaryDateLabel,
+    stats
+  } = params;
+  const results = [];
+  const activeChannels = normalizeChannels(campaign2.channels);
+  if (activeChannels.includes("telegram") && settings.telegramEnabled) {
+    await dispatchTelegramChannel(
+      transport,
+      campaign2,
+      settings,
+      secondaryDateLabel,
+      isTestDispatch,
+      testTelegramChatId,
+      stats,
+      results
+    );
+  }
+  if (activeChannels.includes("email")) {
+    await dispatchEmailChannel(
+      transport,
+      campaign2,
+      settings,
+      recipients,
+      secondaryDateLabel,
+      isTestDispatch,
+      stats,
+      results
+    );
+  }
+  if (activeChannels.includes("whatsapp") && settings.whatsappEnabled) {
+    await dispatchWhatsAppChannel(
+      transport,
+      campaign2,
+      settings,
+      recipients,
+      isTestDispatch,
+      secondaryDateLabel,
+      stats,
+      results
+    );
+  }
+  return results;
+}
+const ALLOWED_INITIAL_STATUSES = /* @__PURE__ */ new Set([
+  "draft",
+  "scheduled"
+]);
+const ALLOWED_USER_STATUS_TRANSITIONS = {
+  draft: ["draft", "scheduled", "cancelled"],
+  scheduled: ["draft", "scheduled", "cancelled"],
+  sending: [],
+  sent: ["sent"],
+  failed: ["draft", "scheduled", "cancelled"],
+  cancelled: ["cancelled", "draft"]
+};
+function resolveInitialStatus(rawStatus) {
+  if (rawStatus === void 0) return "draft";
+  if (!ALLOWED_INITIAL_STATUSES.has(rawStatus)) {
+    throw new Error('Initial campaign status must be "draft" or "scheduled"');
+  }
+  return rawStatus;
+}
+function resolveUpdatedStatus(currentStatus, requestedStatus) {
+  if (currentStatus === "sending") {
+    throw new Error("Cannot modify a campaign while it is sending");
+  }
+  if (requestedStatus === void 0 || requestedStatus === currentStatus) {
+    return currentStatus;
+  }
+  const allowed = ALLOWED_USER_STATUS_TRANSITIONS[currentStatus] || [];
+  if (!allowed.includes(requestedStatus)) {
+    throw new Error(
+      `Invalid campaign status transition from "${currentStatus}" to "${requestedStatus}"`
+    );
+  }
+  return requestedStatus;
+}
+function computeCampaignSecondaryDate(campaign2, settings) {
+  if (campaign2.secondaryDate?.formatted) {
+    return campaign2.secondaryDate;
+  }
+  const secondaryCal = settings.secondaryCalendars?.[0] || "islamic-umalqura";
+  return formatSecondaryDate(
+    (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    secondaryCal,
+    settings.defaultLocale || "es"
+  );
+}
+function toOptionalPlainString(val) {
+  if (typeof val !== "string") return void 0;
+  const trimmed = val.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function sanitizeDispatchOptions(rawOptions, defaultLocale) {
+  const safeObj = rawOptions && typeof rawOptions === "object" && !Array.isArray(rawOptions) ? rawOptions : {};
+  const testRecipientEmail = toOptionalPlainString(safeObj.testRecipientEmail);
+  const testRecipientPhone = toOptionalPlainString(safeObj.testRecipientPhone);
+  const testTelegramChatId = toOptionalPlainString(safeObj.testTelegramChatId);
+  const hasCustomRecipientsList = Array.isArray(safeObj.customRecipients) && safeObj.customRecipients.length > 0;
+  const customRecipients = hasCustomRecipientsList ? safeObj.customRecipients.filter(
+    (item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)
+  ).map((item) => mapRawSubscriber(item, defaultLocale)) : [];
+  return {
+    hasCustomRecipientsList,
+    customRecipients,
+    testRecipientEmail,
+    testRecipientPhone,
+    testTelegramChatId
+  };
+}
+async function buildSelectedRecipients(campaign2, settings, options2, resolveTopicRecipients) {
+  const clean = sanitizeDispatchOptions(
+    options2,
+    settings.defaultLocale || "es"
+  );
+  const isTestDispatch = Boolean(
+    clean.testRecipientEmail || clean.testRecipientPhone || clean.testTelegramChatId
+  );
+  if (isTestDispatch) {
+    return {
+      isTestDispatch: true,
+      testTelegramChatId: clean.testTelegramChatId,
+      recipients: [
+        {
+          email: clean.testRecipientEmail,
+          phone: clean.testRecipientPhone,
+          telegramChatId: clean.testTelegramChatId,
+          fullName: "Test Recipient",
+          locale: settings.defaultLocale,
+          topics: [campaign2.topic]
+        }
+      ]
+    };
+  }
+  if (clean.hasCustomRecipientsList) {
+    return { isTestDispatch: false, recipients: clean.customRecipients };
+  }
+  return {
+    isTestDispatch: false,
+    recipients: await resolveTopicRecipients(campaign2.topic)
+  };
+}
+const createCampaignService = ({ strapi }) => {
+  const activeDispatches = /* @__PURE__ */ new Set();
+  return {
+    getSettingsService() {
+      return strapi.plugin(PLUGIN_ID).service("settings");
+    },
+    getTransportService() {
+      return strapi.plugin(PLUGIN_ID).service("transportService");
+    },
+    async listCampaigns(params) {
+      const filters = {};
+      if (typeof params?.status === "string" && params.status.trim()) {
+        filters.status = params.status.trim();
+      }
+      if (typeof params?.topic === "string" && params.topic.trim()) {
+        filters.topic = params.topic.trim();
+      }
+      const docs = await strapi.documents(CAMPAIGN_UID).findMany({ filters, limit: 100 });
+      return docs;
+    },
+    async listPublicArchive(params) {
+      const filters = { status: "sent" };
+      if (typeof params?.topic === "string" && params.topic.trim()) {
+        filters.topic = params.topic.trim();
+      }
+      const docs = await strapi.documents(CAMPAIGN_UID).findMany({
+        filters,
+        limit: clampLimit(params?.limit, 20)
+      });
+      return docs.map((c) => ({
+        slug: c.slug,
+        title: c.title,
+        topic: c.topic,
+        subject: c.subject,
+        bodyText: c.bodyText,
+        ctaLabel: c.ctaLabel,
+        ctaUrl: c.ctaUrl,
+        sentAt: c.sentAt,
+        secondaryDateLabel: c.secondaryDateLabel,
+        translations: c.translations
+      }));
+    },
+    async getCampaignBySlug(slug) {
+      const docs = await strapi.documents(CAMPAIGN_UID).findMany({
+        filters: { slug },
+        limit: 1
+      });
+      return docs[0] || null;
+    },
+    async findCampaignByDocIdOrSlug(documentIdOrSlug) {
+      const byDoc = await strapi.documents(CAMPAIGN_UID).findOne({
+        documentId: documentIdOrSlug
+      });
+      return byDoc ?? await this.getCampaignBySlug(documentIdOrSlug);
+    },
+    async createCampaign(input) {
+      const initialStatus = resolveInitialStatus(input.status);
+      const rawChannels = input.channels === void 0 ? ["email"] : input.channels;
+      const validation = validateCampaignInput({
+        ...input,
+        channels: rawChannels
+      });
+      if (!validation.valid) {
+        throw new Error(validation.errors.join("; "));
+      }
+      const channels = normalizeChannels(rawChannels);
+      const candidate = {
+        ...input,
+        emailTemplateRef: input.emailTemplateRef !== void 0 ? String(input.emailTemplateRef).trim() : void 0
+      };
+      const settings = await this.getSettingsService().getSettings();
+      const secondaryCal = settings.secondaryCalendars?.[0] || "islamic-umalqura";
+      const baseIso = input.scheduledAt || (/* @__PURE__ */ new Date()).toISOString();
+      const referenceIso = baseIso.slice(0, 10);
+      const secondaryDate = formatSecondaryDate(
+        referenceIso,
+        secondaryCal,
+        settings.defaultLocale || "es"
+      );
+      const created = await strapi.documents(CAMPAIGN_UID).create({
+        data: {
+          ...buildCampaignDocumentData(candidate, channels, initialStatus),
+          secondaryDate,
+          secondaryDateLabel: secondaryDate.formatted,
+          stats: createEmptyStats(),
+          metadata: candidate.metadata || {}
+        }
+      });
+      return created;
+    },
+    async updateCampaign(documentIdOrSlug, input) {
+      const existing = await this.findCampaignByDocIdOrSlug(documentIdOrSlug);
+      if (!existing?.documentId) {
+        throw new Error(`Campaign "${documentIdOrSlug}" not found`);
+      }
+      const nextStatus = resolveUpdatedStatus(
+        existing.status || "draft",
+        input.status
+      );
+      const rawChannels = input.channels === void 0 ? existing.channels : input.channels;
+      const resolvedBodyHtml = input.bodyHtml !== void 0 ? input.bodyHtml : input.bodyText !== void 0 && (input.bodyText !== existing.bodyText || !existing.bodyHtml) ? `<p>${escapeHtml(String(input.bodyText))}</p>` : existing.bodyHtml;
+      const resolvedEmailTemplateRef = input.emailTemplateRef !== void 0 ? String(input.emailTemplateRef).trim() : existing.emailTemplateRef;
+      const mergedForValidation = {
+        ...existing,
+        ...input,
+        bodyHtml: resolvedBodyHtml,
+        emailTemplateRef: resolvedEmailTemplateRef,
+        channels: rawChannels,
+        status: nextStatus
+      };
+      const validation = validateCampaignInput(mergedForValidation);
+      if (!validation.valid) {
+        throw new Error(validation.errors.join("; "));
+      }
+      const channels = normalizeChannels(rawChannels);
+      const merged = {
+        ...mergedForValidation,
+        channels
+      };
+      const updated = await strapi.documents(CAMPAIGN_UID).update({
+        documentId: existing.documentId,
+        data: buildCampaignDocumentData(merged, channels, nextStatus)
+      });
+      return updated || merged;
+    },
+    async createFromStarterTemplate(templateId) {
+      const tpl = STARTER_CAMPAIGN_TEMPLATES.find(
+        (item) => item.id === templateId || item.slug === templateId
+      );
+      if (!tpl) {
+        throw new Error(`Starter campaign template "${templateId}" not found`);
+      }
+      const existing = await this.getCampaignBySlug(tpl.slug);
+      if (existing) return existing;
+      return this.createCampaign(buildPresetCampaignPayload(tpl));
+    },
+    async seedStarterCampaigns() {
+      const settings = await this.getSettingsService().getSettings();
+      const presets = settings.presetCampaigns?.length ? settings.presetCampaigns : STARTER_CAMPAIGN_TEMPLATES;
+      let seededCount = 0;
+      for (const preset of presets) {
+        if (!preset.slug || !preset.title) continue;
+        const existing = await this.getCampaignBySlug(preset.slug);
+        if (existing) continue;
+        await this.createCampaign(buildPresetCampaignPayload(preset));
+        seededCount += 1;
+      }
+      return seededCount;
+    },
+    async resolveRecipientsForTopic(topic) {
+      const settings = await this.getSettingsService().getSettings();
+      if (!settings.enableInboxSubscriberBridge) return [];
+      try {
+        const inboxPlugin = strapi.plugin("inbox");
+        const subscriberService = inboxPlugin?.service("subscriberService");
+        if (subscriberService?.listSubscribers) {
+          const list = await subscriberService.listSubscribers({
+            status: "confirmed",
+            topic
+          });
+          return list.map(
+            (sub) => mapRawSubscriber(sub, settings.defaultLocale || "es")
+          );
+        }
+      } catch {
+      }
+      return [];
+    },
+    async selectCampaignRecipients(campaign2, settings, options2) {
+      return buildSelectedRecipients(
+        campaign2,
+        settings,
+        options2,
+        (topic) => this.resolveRecipientsForTopic(topic)
+      );
+    },
+    async finalizeDispatchedCampaign(campaign2, secondaryDate, secondaryDateLabel, stats) {
+      const finalStatus = stats.totalRecipients > 0 && stats.failedCount === stats.totalRecipients ? "failed" : "sent";
+      const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+      let updatedCampaign = {
+        ...campaign2,
+        status: finalStatus,
+        sentAt,
+        secondaryDateLabel,
+        stats
+      };
+      if (campaign2.documentId) {
+        const updated = await strapi.documents(CAMPAIGN_UID).update({
+          documentId: campaign2.documentId,
+          data: {
+            status: finalStatus,
+            sentAt,
+            secondaryDate,
+            secondaryDateLabel,
+            stats
+          }
+        });
+        if (updated) updatedCampaign = updated;
+      }
+      strapi.eventHub?.emit("broadcasts.campaign.sent", {
+        slug: updatedCampaign.slug,
+        topic: updatedCampaign.topic,
+        stats
+      });
+      return updatedCampaign;
+    },
+    async dispatchCampaign(documentIdOrSlug, options2 = {}) {
+      const acquiredLocks = [];
+      const tryAcquireBatch = (keys, label) => {
+        const toAcquire = Array.from(
+          new Set(keys.filter((k) => Boolean(k) && !acquiredLocks.includes(k)))
+        );
+        for (const key of toAcquire) {
+          if (activeDispatches.has(key)) {
+            throw new Error(`Campaign "${label}" is already being dispatched`);
+          }
+        }
+        for (const key of toAcquire) {
+          activeDispatches.add(key);
+          acquiredLocks.push(key);
+        }
+      };
+      const rawRef = String(documentIdOrSlug || "").trim();
+      tryAcquireBatch([`req:${rawRef}`], rawRef || documentIdOrSlug);
+      let campaign2 = null;
+      let transitionedToSending = false;
+      try {
+        campaign2 = await this.findCampaignByDocIdOrSlug(rawRef);
+        if (!campaign2) {
+          throw new Error(`Campaign "${documentIdOrSlug}" not found`);
+        }
+        const canonicalKeys = [`slug:${campaign2.slug}`, `req:${campaign2.slug}`];
+        if (campaign2.documentId) {
+          canonicalKeys.push(
+            `doc:${campaign2.documentId}`,
+            `req:${campaign2.documentId}`
+          );
+        }
+        tryAcquireBatch(canonicalKeys, campaign2.slug);
+        if (campaign2.status === "cancelled") {
+          throw new Error(
+            `Cannot dispatch cancelled campaign "${campaign2.slug}"`
+          );
+        }
+        if (campaign2.status === "sending") {
+          throw new Error(`Campaign "${campaign2.slug}" is already sending`);
+        }
+        const settings = await this.getSettingsService().getSettings();
+        const transport = this.getTransportService();
+        const secondaryDate = computeCampaignSecondaryDate(campaign2, settings);
+        const secondaryDateLabel = campaign2.secondaryDateLabel || secondaryDate.formatted;
+        const { isTestDispatch, testTelegramChatId, recipients } = await this.selectCampaignRecipients(
+          campaign2,
+          settings,
+          options2
+        );
+        if (!isTestDispatch && campaign2.documentId) {
+          await strapi.documents(CAMPAIGN_UID).update({
+            documentId: campaign2.documentId,
+            data: { status: "sending" }
+          });
+          transitionedToSending = true;
+        }
+        const stats = createEmptyStats();
+        const results = await dispatchAllActiveChannels({
+          transport,
+          campaign: campaign2,
+          settings,
+          recipients,
+          isTestDispatch,
+          testTelegramChatId,
+          secondaryDateLabel,
+          stats
+        });
+        if (isTestDispatch) {
+          return { campaign: campaign2, results };
+        }
+        const updatedCampaign = await this.finalizeDispatchedCampaign(
+          campaign2,
+          secondaryDate,
+          secondaryDateLabel,
+          stats
+        );
+        return { campaign: updatedCampaign, results };
+      } catch (err) {
+        if (transitionedToSending && campaign2?.documentId) {
+          try {
+            await strapi.documents(CAMPAIGN_UID).update({
+              documentId: campaign2.documentId,
+              data: { status: "failed" }
+            });
+          } catch {
+          }
+        }
+        throw err;
+      } finally {
+        for (const key of acquiredLocks) {
+          activeDispatches.delete(key);
+        }
+      }
+    }
+  };
+};
+const SETTINGS_KEY = "settings";
+const MASKED_SECRET = "••••••••";
+const SECRET_MASK_RE = /^[•*]+$/;
+const DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+  "primaryCalendar",
+  "secondaryCalendars",
+  "defaultLocale",
+  "supportedLocales",
+  "availableTopics",
+  "dryRun",
+  "enableInboxSubscriberBridge",
+  "enableEventHubAutomations",
+  "enableEmailDesignerBridge",
+  "defaultEmailTemplateRef",
+  "siteBaseUrl",
+  "organizationName",
+  "emailFromAddress",
+  "emailReplyToAddress",
+  "telegramEnabled",
+  "telegramBotToken",
+  "telegramDefaultChatId",
+  "telegramTopicChatMap",
+  "telegramTopicThreadMap",
+  "whatsappEnabled",
+  "whatsappDriver",
+  "whatsappPhoneNumberId",
+  "whatsappAccessToken",
+  "whatsappGatewayUrl",
+  "whatsappGatewaySession",
+  "whatsappGatewayApiKey",
+  "whatsappDefaultRecipients",
+  "whatsappTopicGroupMap",
+  "allowLocalhostGateways",
+  "publicChannelLinks",
+  "presetCampaigns",
+  "presetAutomationRules"
+]);
+const NESTED_MAP_KEYS = /* @__PURE__ */ new Set([
+  "telegramTopicChatMap",
+  "telegramTopicThreadMap",
+  "whatsappTopicGroupMap"
+]);
+function sanitizePlainMap(val) {
+  if (!val || typeof val !== "object" || Array.isArray(val)) return {};
+  const clean = {};
+  for (const [k, v] of Object.entries(val)) {
+    if (DANGEROUS_KEYS.has(k) || !Object.hasOwn(val, k)) continue;
+    clean[k] = v;
+  }
+  return clean;
+}
+function pickAllowedSettings(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return {};
+  }
+  const clean = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (DANGEROUS_KEYS.has(key) || !Object.hasOwn(raw, key) || !ALLOWED_SETTINGS_KEYS.has(key)) {
+      continue;
+    }
+    clean[key] = NESTED_MAP_KEYS.has(key) ? sanitizePlainMap(value) : value;
+  }
+  return clean;
+}
+function maskSecret(val) {
+  if (!val || SECRET_MASK_RE.test(val.trim())) return "";
+  return MASKED_SECRET;
+}
+function resolveSecretValue(incoming, current) {
+  if (incoming === void 0 || incoming === null) {
+    return current ?? "";
+  }
+  const str = String(incoming);
+  const trimmed = str.trim();
+  if (trimmed.length > 0 && SECRET_MASK_RE.test(trimmed)) {
+    return current ?? "";
+  }
+  return str;
+}
+function resolveSecondaryCalendars(incoming, fallback) {
+  if (!Array.isArray(incoming)) return fallback;
+  return incoming.filter(
+    (cal) => isSupportedCalendar(cal)
+  );
+}
+const createSettingsService = ({ strapi }) => ({
+  getPluginStore() {
+    return strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID
+    });
+  },
+  getConfigDefaults() {
+    const rawConfig = pickAllowedSettings(
+      strapi.config.get(`plugin::${PLUGIN_ID}`, {})
+    );
+    const primaryCalendar = isSupportedCalendar(
+      rawConfig.primaryCalendar
+    ) ? rawConfig.primaryCalendar : DEFAULT_BROADCAST_SETTINGS.primaryCalendar;
+    const secondaryCalendars = resolveSecondaryCalendars(
+      rawConfig.secondaryCalendars,
+      DEFAULT_BROADCAST_SETTINGS.secondaryCalendars
+    );
+    return {
+      ...DEFAULT_BROADCAST_SETTINGS,
+      ...rawConfig,
+      primaryCalendar,
+      secondaryCalendars,
+      whatsappDriver: isSupportedWhatsAppDriver(rawConfig.whatsappDriver) ? rawConfig.whatsappDriver : DEFAULT_BROADCAST_SETTINGS.whatsappDriver
+    };
+  },
+  async getSettings() {
+    const defaults = this.getConfigDefaults();
+    const store = this.getPluginStore();
+    const rawStored = await store.get({ key: SETTINGS_KEY });
+    const stored = pickAllowedSettings(rawStored);
+    if (!rawStored) {
+      return defaults;
+    }
+    return {
+      ...defaults,
+      ...stored
+    };
+  },
+  async getPublicSafeSettings() {
+    const full = await this.getSettings();
+    return {
+      ...full,
+      telegramBotToken: maskSecret(full.telegramBotToken),
+      whatsappAccessToken: maskSecret(full.whatsappAccessToken),
+      whatsappGatewayApiKey: maskSecret(full.whatsappGatewayApiKey)
+    };
+  },
+  async updateSettings(rawPartial) {
+    const partial = pickAllowedSettings(rawPartial);
+    const current = await this.getSettings();
+    const effectiveAllowLocalhost = Boolean(
+      partial.allowLocalhostGateways ?? current.allowLocalhostGateways
+    );
+    const effectiveGatewayUrl = String(
+      partial.whatsappGatewayUrl ?? current.whatsappGatewayUrl ?? ""
+    ).trim();
+    if (effectiveGatewayUrl) {
+      const check = validateGatewayUrl(effectiveGatewayUrl, {
+        allowLocalhost: effectiveAllowLocalhost
+      });
+      if (!check.valid) {
+        throw new Error(check.errors.join("; "));
+      }
+    }
+    const effectiveSiteBaseUrl = String(
+      partial.siteBaseUrl ?? current.siteBaseUrl ?? ""
+    ).trim();
+    if (effectiveSiteBaseUrl && !isSafeHttpUrl(effectiveSiteBaseUrl)) {
+      throw new Error("siteBaseUrl must be a valid http or https URL");
+    }
+    if (partial.publicChannelLinks !== void 0) {
+      const linksCheck = validatePublicChannelLinks(partial.publicChannelLinks);
+      if (!linksCheck.valid) {
+        throw new Error(linksCheck.errors.join("; "));
+      }
+    }
+    if (partial.whatsappGatewaySession !== void 0) {
+      const candidateSession = String(partial.whatsappGatewaySession).trim();
+      if (candidateSession && !isValidGatewaySession(candidateSession)) {
+        throw new Error(
+          "whatsappGatewaySession must be 1-64 alphanumeric, underscore, or hyphen characters"
+        );
+      }
+    }
+    const effectiveGatewaySession = String(
+      partial.whatsappGatewaySession ?? current.whatsappGatewaySession ?? "default"
+    ).trim() || "default";
+    if (!isValidGatewaySession(effectiveGatewaySession)) {
+      throw new Error(
+        "whatsappGatewaySession must be 1-64 alphanumeric, underscore, or hyphen characters"
+      );
+    }
+    const next = {
+      ...current,
+      ...partial,
+      siteBaseUrl: effectiveSiteBaseUrl || current.siteBaseUrl,
+      whatsappGatewaySession: effectiveGatewaySession,
+      emailFromAddress: stripHeaderControlChars(
+        partial.emailFromAddress ?? current.emailFromAddress
+      ),
+      emailReplyToAddress: stripHeaderControlChars(
+        partial.emailReplyToAddress ?? current.emailReplyToAddress
+      ),
+      primaryCalendar: isSupportedCalendar(partial.primaryCalendar) ? partial.primaryCalendar : current.primaryCalendar,
+      secondaryCalendars: resolveSecondaryCalendars(
+        partial.secondaryCalendars,
+        current.secondaryCalendars
+      ),
+      whatsappDriver: isSupportedWhatsAppDriver(partial.whatsappDriver) ? partial.whatsappDriver : current.whatsappDriver,
+      telegramBotToken: resolveSecretValue(
+        partial.telegramBotToken,
+        current.telegramBotToken
+      ),
+      whatsappAccessToken: resolveSecretValue(
+        partial.whatsappAccessToken,
+        current.whatsappAccessToken
+      ),
+      whatsappGatewayApiKey: resolveSecretValue(
+        partial.whatsappGatewayApiKey,
+        current.whatsappGatewayApiKey
+      )
+    };
+    const store = this.getPluginStore();
+    await store.set({
+      key: SETTINGS_KEY,
+      value: next
+    });
+    return next;
+  }
+});
+const EMAIL_DESIGNER_TEMPLATE_UID = "plugin::email-designer-5.email-designer-template";
+const KNOWN_LOCALES = ["es", "en", "ar", "tr", "fr", "pt", "de", "it"];
+function getNormalizedTags(row) {
+  if (!Array.isArray(row.tags)) return [];
+  return row.tags.map((t) => String(t).toLowerCase());
+}
+async function fetchRawEmailDesignerTemplates(strapi) {
+  try {
+    const dbQuery = strapi.db?.query?.(EMAIL_DESIGNER_TEMPLATE_UID);
+    if (dbQuery?.findMany) {
+      const rows = await dbQuery.findMany({
+        orderBy: { templateReferenceId: "asc" },
+        limit: 200
+      });
+      if (Array.isArray(rows)) return rows;
+    }
+  } catch {
+  }
+  try {
+    const docs = await strapi.documents(
+      EMAIL_DESIGNER_TEMPLATE_UID
+    ).findMany({ limit: 200 });
+    if (Array.isArray(docs)) return docs;
+  } catch {
+  }
+  return [];
+}
+function toTemplateSummary(row) {
+  const refId = Number(row.templateReferenceId ?? row.id ?? 0);
+  const name = String(row.name || "").trim();
+  if (!refId && !name) return null;
+  return {
+    templateReferenceId: refId,
+    name: name || `Template #${refId}`,
+    subject: typeof row.subject === "string" ? row.subject : void 0,
+    tags: Array.isArray(row.tags) ? row.tags.map((t) => String(t)) : void 0,
+    updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : void 0
+  };
+}
+async function listEmailDesignerTemplatesFromDb(strapi) {
+  const rows = await fetchRawEmailDesignerTemplates(strapi);
+  const seen = /* @__PURE__ */ new Set();
+  const summaries = [];
+  for (const row of rows) {
+    const summary = toTemplateSummary(row);
+    if (!summary) continue;
+    const key = `${summary.templateReferenceId}:${summary.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    summaries.push(summary);
+  }
+  return summaries.sort(
+    (a, b) => a.templateReferenceId - b.templateReferenceId
+  );
+}
+function findDirectLocalizedTemplate(rows, trimmedRef, normLocale) {
+  const lowerRef = trimmedRef.toLowerCase();
+  const expectedName = `${lowerRef}_${normLocale}`;
+  const normalizedGroupTag = trimmedRef.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return rows.find((r) => {
+    const rowName = String(r.name || "").toLowerCase();
+    if (rowName === expectedName) return true;
+    const rowTags = getNormalizedTags(r);
+    return (rowTags.includes(lowerRef) || rowTags.includes(normalizedGroupTag)) && rowTags.includes(normLocale);
+  });
+}
+function findSiblingBySuffix(rows, primary, normLocale) {
+  if (typeof primary.name !== "string") return void 0;
+  const suffixMatch = primary.name.match(/^(.+)_([a-z]{2,3})$/i);
+  if (!suffixMatch || suffixMatch[2].toLowerCase() === normLocale) {
+    return void 0;
+  }
+  const targetSiblingName = `${suffixMatch[1]}_${normLocale}`.toLowerCase();
+  return rows.find(
+    (r) => String(r.name || "").toLowerCase() === targetSiblingName
+  );
+}
+function findSiblingByCategoryTags(rows, primary, normLocale) {
+  const primaryTags = getNormalizedTags(primary);
+  if (primaryTags.includes(normLocale)) return void 0;
+  const categoryTags = primaryTags.filter(
+    (t) => !KNOWN_LOCALES.includes(t) && t !== "visitor" && t !== "community"
+  );
+  if (categoryTags.length === 0) return void 0;
+  return rows.find((r) => {
+    const rTags = getNormalizedTags(r);
+    return rTags.includes(normLocale) && categoryTags.some((cat) => rTags.includes(cat));
+  });
+}
+function findPrimaryTemplate(rows, trimmed) {
+  const numericRef = /^\d+$/.test(trimmed) ? Number(trimmed) : null;
+  const lowerTrimmed = trimmed.toLowerCase();
+  return rows.find(
+    (r) => numericRef !== null && Number(r.templateReferenceId) === numericRef || String(r.name || "").toLowerCase() === lowerTrimmed
+  );
+}
+function findSiblingTemplate(rows, primary, normLocale) {
+  if (!normLocale) return void 0;
+  return findSiblingBySuffix(rows, primary, normLocale) ?? findSiblingByCategoryTags(rows, primary, normLocale);
+}
+async function resolveEmailDesignerTemplateFromDb(strapi, templateRef, locale) {
+  const trimmed = String(templateRef || "").trim();
+  if (!trimmed) return null;
+  const rows = await fetchRawEmailDesignerTemplates(strapi);
+  if (rows.length === 0) return null;
+  const normLocale = locale ? locale.toLowerCase() : void 0;
+  if (normLocale) {
+    const localizedDirect = findDirectLocalizedTemplate(
+      rows,
+      trimmed,
+      normLocale
+    );
+    if (localizedDirect) return localizedDirect;
+  }
+  const primary = findPrimaryTemplate(rows, trimmed);
+  if (!primary) return null;
+  return findSiblingTemplate(rows, primary, normLocale) ?? primary;
+}
+async function trySendViaPluginService(strapi, numericTemplateId, recipientEmail, fromAddress, replyToAddress, headers, subject, templateVars) {
+  if (!numericTemplateId) return null;
+  try {
+    const emailDesignerPlugin = strapi.plugin("email-designer-5");
+    const emailDesignerService = emailDesignerPlugin?.service("email");
+    if (emailDesignerService?.sendTemplatedEmail) {
+      await emailDesignerService.sendTemplatedEmail(
+        {
+          to: stripHeaderControlChars(recipientEmail),
+          from: stripHeaderControlChars(fromAddress),
+          replyTo: stripHeaderControlChars(replyToAddress),
+          headers
+        },
+        {
+          templateReferenceId: numericTemplateId,
+          subject: stripHeaderControlChars(subject)
+        },
+        templateVars
+      );
+      return `ed5_${numericTemplateId}_${Date.now()}`;
+    }
+  } catch {
+  }
+  return null;
+}
+async function trySendEmailViaDesigner5(params) {
+  const {
+    strapi,
+    effectiveTemplateRef,
+    locale,
+    recipientEmail,
+    fromAddress,
+    replyToAddress,
+    subject,
+    text,
+    headers,
+    templateVars,
+    interpolate
+  } = params;
+  const resolvedTemplate = await resolveEmailDesignerTemplateFromDb(
+    strapi,
+    effectiveTemplateRef,
+    locale
+  );
+  const numericTemplateId = resolvedTemplate?.templateReferenceId ?? (/^\d+$/.test(effectiveTemplateRef) ? Number(effectiveTemplateRef) : null);
+  const pluginSentId = await trySendViaPluginService(
+    strapi,
+    numericTemplateId,
+    recipientEmail,
+    fromAddress,
+    replyToAddress,
+    headers,
+    subject,
+    templateVars
+  );
+  if (pluginSentId) return pluginSentId;
+  const emailService = strapi.plugin("email")?.service("email");
+  if (!resolvedTemplate?.bodyHtml || !emailService?.send) {
+    return null;
+  }
+  const renderedHtml = interpolate(resolvedTemplate.bodyHtml, templateVars);
+  const renderedText = resolvedTemplate.bodyText ? interpolate(resolvedTemplate.bodyText, {
+    ...templateVars,
+    subject,
+    bodyText: text
+  }) : text;
+  const renderedSubject = stripHeaderControlChars(
+    subject || (resolvedTemplate.subject ? interpolate(resolvedTemplate.subject, { ...templateVars, subject }) : "")
+  );
+  await emailService.send({
+    to: stripHeaderControlChars(recipientEmail),
+    from: stripHeaderControlChars(fromAddress),
+    replyTo: stripHeaderControlChars(replyToAddress),
+    subject: renderedSubject,
+    text: renderedText,
+    html: renderedHtml,
+    headers
+  });
+  return `ed5_${resolvedTemplate.templateReferenceId || effectiveTemplateRef}_${Date.now()}`;
+}
+function buildSafeListUnsubscribeHeader(rawUnsubscribeUrl) {
+  if (!rawUnsubscribeUrl) return {};
+  const cleaned = stripHeaderControlChars(rawUnsubscribeUrl);
+  if (!cleaned || !isSafeHttpUrl(cleaned)) return {};
+  return { "List-Unsubscribe": `<${cleaned}>` };
+}
+async function hasAlreadyDeliveredInDb(strapi, idempotencyKey) {
+  const existing = await strapi.documents(DELIVERY_LOG_UID).findMany({
+    filters: { idempotencyKey, status: { $in: ["sent", "simulated"] } },
+    limit: 1
+  });
+  return existing.length > 0;
+}
+async function upsertDeliveryLogInDb(strapi, entry, secrets = []) {
+  const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+  const safeEntry = {
+    ...entry,
+    errorMessage: entry.errorMessage ? redactSecretsFromMessage(entry.errorMessage, secrets) : void 0
+  };
+  const existing = await strapi.documents(DELIVERY_LOG_UID).findMany({
+    filters: { idempotencyKey: safeEntry.idempotencyKey },
+    limit: 1
+  });
+  const existingDocId = typeof existing[0]?.documentId === "string" ? existing[0].documentId : void 0;
+  if (existingDocId) {
+    const updated = await strapi.documents(DELIVERY_LOG_UID).update({
+      documentId: existingDocId,
+      data: { ...safeEntry, sentAt }
+    });
+    return updated ?? {
+      ...safeEntry,
+      documentId: existingDocId,
+      sentAt
+    };
+  }
+  const created = await strapi.documents(DELIVERY_LOG_UID).create({
+    data: { ...safeEntry, sentAt }
+  });
+  return created;
+}
+async function listDeliveryLogsFromDb(strapi, params) {
+  const filters = {};
+  if (typeof params?.campaignSlug === "string" && params.campaignSlug.trim()) {
+    filters.campaignSlug = params.campaignSlug.trim();
+  }
+  if (typeof params?.channel === "string" && SUPPORTED_CHANNELS.includes(params.channel)) {
+    filters.channel = params.channel;
+  }
+  const docs = await strapi.documents(DELIVERY_LOG_UID).findMany({
+    filters,
+    limit: clampLimit(params?.limit, 100)
+  });
+  return docs;
+}
+function extractSecretList(settings) {
+  if (!settings) return [];
+  return [
+    settings.telegramBotToken,
+    settings.whatsappAccessToken,
+    settings.whatsappGatewayApiKey
+  ];
+}
+function sanitizeDispatchResult(result, secrets) {
+  return {
+    ...result,
+    errorMessage: result.errorMessage ? redactSecretsFromMessage(result.errorMessage, secrets) : void 0
+  };
+}
+async function sendLiveEmailViaProviders(strapi, payload, settings, effectiveTemplateRef) {
+  const headers = buildSafeListUnsubscribeHeader(payload.unsubscribeUrl);
+  const safeSubject = stripHeaderControlChars(payload.subject);
+  const safeFrom = stripHeaderControlChars(settings.emailFromAddress);
+  const safeReplyTo = stripHeaderControlChars(settings.emailReplyToAddress);
+  const safeRecipient = stripHeaderControlChars(payload.recipientEmail);
+  const inlineHtml = payload.html || `<p>${escapeHtml(payload.text)}</p>`;
+  const templateVars = buildEmailTemplateVariables(
+    { ...payload, subject: safeSubject },
+    settings,
+    inlineHtml
+  );
+  if (effectiveTemplateRef) {
+    const externalMessageId = await trySendEmailViaDesigner5({
+      strapi,
+      effectiveTemplateRef,
+      locale: payload.locale,
+      recipientEmail: safeRecipient,
+      fromAddress: safeFrom,
+      replyToAddress: safeReplyTo,
+      subject: safeSubject,
+      text: payload.text,
+      headers,
+      templateVars,
+      interpolate: interpolateBroadcastTemplate
+    });
+    if (externalMessageId) {
+      return {
+        driver: "email-designer-5",
+        status: "sent",
+        externalMessageId
+      };
+    }
+  }
+  const emailService = strapi.plugin("email")?.service("email");
+  if (!emailService?.send) {
+    return {
+      driver: "strapi-email-fallback",
+      status: "simulated",
+      externalMessageId: `sim_fallback_${Date.now()}`
+    };
+  }
+  await emailService.send({
+    to: safeRecipient,
+    from: safeFrom,
+    replyTo: safeReplyTo,
+    subject: safeSubject,
+    text: payload.text,
+    html: inlineHtml,
+    headers
+  });
+  return {
+    driver: "strapi-email",
+    status: "sent",
+    externalMessageId: `email_${Date.now()}`
+  };
+}
+const createTransportService = ({ strapi }) => ({
+  getSettingsService() {
+    return strapi.plugin(PLUGIN_ID).service("settings");
+  },
+  async fetchRawEmailDesignerTemplates() {
+    return fetchRawEmailDesignerTemplates(strapi);
+  },
+  async listEmailDesignerTemplates() {
+    return listEmailDesignerTemplatesFromDb(strapi);
+  },
+  async resolveEmailDesignerTemplate(templateRef, locale) {
+    return resolveEmailDesignerTemplateFromDb(strapi, templateRef, locale);
+  },
+  async hasAlreadyDelivered(idempotencyKey) {
+    return hasAlreadyDeliveredInDb(strapi, idempotencyKey);
+  },
+  async recordDeliveryLog(entry, secrets = []) {
+    return upsertDeliveryLogInDb(strapi, entry, secrets);
+  },
+  async listDeliveryLogs(params) {
+    return listDeliveryLogsFromDb(strapi, params);
+  },
+  async persistResult(campaignSlug, secondaryDateLabel, result, settings) {
+    const secrets = extractSecretList(settings);
+    const safeResult = sanitizeDispatchResult(result, secrets);
+    try {
+      await this.recordDeliveryLog(
+        {
+          ...safeResult,
+          campaignSlug,
+          secondaryDateLabel
+        },
+        secrets
+      );
+    } catch (logErr) {
+      const safeErr = redactSecretsFromMessage(
+        logErr?.message || "log write error",
+        secrets
+      );
+      strapi.log?.warn?.(
+        `[@vicacha-devs/strapi-plugin-broadcasts] Delivery log fallback for ${safeResult.idempotencyKey}: ${safeErr}`
+      );
+    }
+    return safeResult;
+  },
+  async logOutcome(p, channel, driver, recipientMasked, status, idempotencyKey, extra, settings) {
+    return this.persistResult(
+      p.campaignSlug,
+      p.secondaryDateLabel,
+      makeResult(
+        channel,
+        driver,
+        recipientMasked,
+        p.locale,
+        status,
+        idempotencyKey,
+        extra
+      ),
+      settings
+    );
+  },
+  async simulateDryRunEmail(payload, effectiveTemplateRef, recipientMasked, idempotencyKey, settings) {
+    const resolvedDryRunTpl = effectiveTemplateRef ? await this.resolveEmailDesignerTemplate(
+      effectiveTemplateRef,
+      payload.locale
+    ) : null;
+    const useDesigner = Boolean(effectiveTemplateRef);
+    const refSuffix = resolvedDryRunTpl?.templateReferenceId || effectiveTemplateRef;
+    return this.logOutcome(
+      payload,
+      "email",
+      useDesigner ? "email-designer-5-dryrun" : "strapi-email-dryrun",
+      recipientMasked,
+      "simulated",
+      idempotencyKey,
+      {
+        externalMessageId: useDesigner ? `sim_ed5_${refSuffix}_${Date.now()}` : `sim_email_${Date.now()}`
+      },
+      settings
+    );
+  },
+  async executeLiveEmailSend(payload, settings, effectiveTemplateRef, recipientMasked, idempotencyKey) {
+    const sent = await sendLiveEmailViaProviders(
+      strapi,
+      payload,
+      settings,
+      effectiveTemplateRef
+    );
+    return this.logOutcome(
+      payload,
+      "email",
+      sent.driver,
+      recipientMasked,
+      sent.status,
+      idempotencyKey,
+      { externalMessageId: sent.externalMessageId },
+      settings
+    );
+  },
+  async sendEmailBroadcast(payload) {
+    const settings = await this.getSettingsService().getSettings();
+    const idempotencyKey = computeIdempotencyKey(
+      payload.campaignSlug,
+      "email",
+      payload.recipientEmail,
+      { isTest: payload.isTestDispatch }
+    );
+    const recipientMasked = maskRecipientIdentifier(payload.recipientEmail);
+    const effectiveTemplateRef = resolveEffectiveEmailTemplateRef(
+      payload,
+      settings
+    );
+    const defaultDriver = effectiveTemplateRef ? "email-designer-5" : "strapi-email";
+    if (!payload.isTestDispatch && await this.hasAlreadyDelivered(idempotencyKey)) {
+      return makeResult(
+        "email",
+        defaultDriver,
+        recipientMasked,
+        payload.locale,
+        "skipped_duplicate",
+        idempotencyKey
+      );
+    }
+    if (settings.dryRun) {
+      return this.simulateDryRunEmail(
+        payload,
+        effectiveTemplateRef,
+        recipientMasked,
+        idempotencyKey,
+        settings
+      );
+    }
+    try {
+      return await this.executeLiveEmailSend(
+        payload,
+        settings,
+        effectiveTemplateRef,
+        recipientMasked,
+        idempotencyKey
+      );
+    } catch (err) {
+      return this.logOutcome(
+        payload,
+        "email",
+        defaultDriver,
+        recipientMasked,
+        "failed",
+        idempotencyKey,
+        { errorMessage: err?.message || "Email delivery failed" },
+        settings
+      );
+    }
+  },
+  async sendTelegramBroadcast(payload) {
+    const settings = await this.getSettingsService().getSettings();
+    const targetChatId = payload.chatId || settings.telegramDefaultChatId;
+    const idempotencyKey = buildTelegramIdempotencyKey(payload, targetChatId);
+    const recipientMasked = maskRecipientIdentifier(targetChatId);
+    if (!payload.isTestDispatch && await this.hasAlreadyDelivered(idempotencyKey)) {
+      return makeResult(
+        "telegram",
+        "telegram-bot-api",
+        recipientMasked,
+        payload.locale,
+        "skipped_duplicate",
+        idempotencyKey
+      );
+    }
+    if (settings.dryRun || !settings.telegramBotToken) {
+      return this.logOutcome(
+        payload,
+        "telegram",
+        "telegram-bot-dryrun",
+        recipientMasked,
+        "simulated",
+        idempotencyKey,
+        { externalMessageId: `sim_tg_${Date.now()}` },
+        settings
+      );
+    }
+    try {
+      const externalMessageId = await executeTelegramHttpSend(
+        payload,
+        targetChatId,
+        settings.telegramBotToken
+      );
+      return this.logOutcome(
+        payload,
+        "telegram",
+        "telegram-bot-api",
+        recipientMasked,
+        "sent",
+        idempotencyKey,
+        { externalMessageId },
+        settings
+      );
+    } catch (err) {
+      return this.logOutcome(
+        payload,
+        "telegram",
+        "telegram-bot-api",
+        recipientMasked,
+        "failed",
+        idempotencyKey,
+        {
+          errorMessage: err?.message || "Telegram delivery failed"
+        },
+        settings
+      );
+    }
+  },
+  async sendWhatsAppBroadcast(payload) {
+    const settings = await this.getSettingsService().getSettings();
+    const target = normalizeWhatsAppTarget(payload.recipientPhone);
+    const driver = settings.whatsappDriver || "meta-cloud";
+    const idempotencyKey = computeIdempotencyKey(
+      payload.campaignSlug,
+      "whatsapp",
+      target.normalized,
+      { isTest: payload.isTestDispatch }
+    );
+    const recipientMasked = maskRecipientIdentifier(target.normalized);
+    if (!payload.isTestDispatch && await this.hasAlreadyDelivered(idempotencyKey)) {
+      return makeResult(
+        "whatsapp",
+        driver,
+        recipientMasked,
+        payload.locale,
+        "skipped_duplicate",
+        idempotencyKey
+      );
+    }
+    if (settings.dryRun || !hasWhatsAppCredentials(driver, settings)) {
+      return this.logOutcome(
+        payload,
+        "whatsapp",
+        `${driver}-dryrun`,
+        recipientMasked,
+        "simulated",
+        idempotencyKey,
+        { externalMessageId: `sim_wa_${Date.now()}` },
+        settings
+      );
+    }
+    if (driver === "meta-cloud" && target.isGroupOrChannel) {
+      return this.logOutcome(
+        payload,
+        "whatsapp",
+        "meta-cloud",
+        recipientMasked,
+        "failed",
+        idempotencyKey,
+        {
+          errorMessage: "Meta WhatsApp Cloud API does not support @g.us group or @newsletter channel JIDs; use evolution or openwa gateway driver"
+        },
+        settings
+      );
+    }
+    try {
+      const externalMessageId = await executeWhatsAppHttpSend(
+        driver,
+        payload,
+        settings,
+        target
+      );
+      return this.logOutcome(
+        payload,
+        "whatsapp",
+        driver,
+        recipientMasked,
+        "sent",
+        idempotencyKey,
+        { externalMessageId },
+        settings
+      );
+    } catch (err) {
+      return this.logOutcome(
+        payload,
+        "whatsapp",
+        driver,
+        recipientMasked,
+        "failed",
+        idempotencyKey,
+        {
+          errorMessage: err?.message || "WhatsApp delivery failed"
+        },
+        settings
+      );
+    }
+  }
+});
+const services = {
+  settings: createSettingsService,
+  transportService: createTransportService,
+  campaignService: createCampaignService,
+  automationService: createAutomationService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  contentTypes,
+  controllers,
+  routes,
+  services
+};
+export {
+  index as default
+};