@infuro/cms-core 1.0.46 → 1.0.50

package/dist/{chunk-CRYKVJTO.js → chunk-IPDHT2UV.js}

@@ -1,9 +1,629 @@
+import { notificationTriggerEmitter } from './chunk-HCIRL37O.js';
 import { queueEmail } from './chunk-L3525VXI.js';
 import { mergeEmailLayoutCompanyDetails } from './chunk-2KUCQVAQ.js';
+import { applyTemplateVars } from './chunk-CRFV5WJK.js';
 import { __name } from './chunk-SHUYVCID.js';
 import { SESClient, SendRawEmailCommand, SendEmailCommand } from '@aws-sdk/client-ses';
 import { createRequire } from 'module';
 import nodemailer from 'nodemailer';
+import * as crypto from 'crypto';
+
+// src/lib/event-order-template-context.ts
+function resolvePublicSiteUrl() {
+  if (typeof process !== "undefined") {
+    const u = (process.env.CMS_PUBLIC_URL || process.env.NEXT_PUBLIC_SITE_URL || "").trim();
+    if (u) return u.replace(/\/+$/, "");
+    const v = (process.env.VERCEL_URL || "").trim();
+    if (v) return v.startsWith("http") ? v.replace(/\/+$/, "") : `https://${v.replace(/\/+$/, "")}`;
+  }
+  return "";
+}
+__name(resolvePublicSiteUrl, "resolvePublicSiteUrl");
+function buildOrderTrackUrl(qrToken, siteUrl, orderNumber) {
+  const token = qrToken?.trim() || orderNumber?.trim();
+  if (!token) return "";
+  const base = (siteUrl ?? resolvePublicSiteUrl()).replace(/\/+$/, "");
+  if (!base) return `/track/${token}`;
+  return `${base}/track/${token}`;
+}
+__name(buildOrderTrackUrl, "buildOrderTrackUrl");
+function formatOrderDetailsText(input) {
+  const { orderNumber, total, currency, lines } = input;
+  const header = `Order: ${orderNumber}
+Total: ${total} ${currency}`;
+  if (!lines.length) return header;
+  const items = lines.map((line) => `- ${line.name} \xD7 ${line.quantity} (${line.total} ${line.currency})`).join("\n");
+  return `${header}
+
+Items:
+${items}`;
+}
+__name(formatOrderDetailsText, "formatOrderDetailsText");
+function formatOrderDetailsHtml(input) {
+  const text = formatOrderDetailsText(input);
+  const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<pre style="font-family:inherit;white-space:pre-wrap;margin:0">${escaped}</pre>`;
+}
+__name(formatOrderDetailsHtml, "formatOrderDetailsHtml");
+function buildEventOrderTemplateVariables(input) {
+  const { event, order, contact, productNames, vendorName = "", orderLines = [], siteUrl } = input;
+  const trackUrl = buildOrderTrackUrl(order.qrToken, siteUrl, order.orderNumber);
+  const baseSite = (siteUrl ?? resolvePublicSiteUrl()).replace(/\/+$/, "");
+  const invoiceNumber = `INV-${order.orderNumber ?? ""}`;
+  const invoiceUrl = baseSite ? `${baseSite}/api/orders/${order.orderNumber ?? ""}/invoice` : `/api/orders/${order.orderNumber ?? ""}/invoice`;
+  const orderDetailsPayload = {
+    orderNumber: String(order.orderNumber ?? ""),
+    total: String(order.total ?? ""),
+    currency: String(order.currency ?? "INR"),
+    lines: orderLines
+  };
+  return {
+    eventName: event.name ?? productNames ?? "",
+    vendorName: vendorName.trim(),
+    eventSlug: event.slug ?? "",
+    venue: event.venue ?? "",
+    startDate: formatEventDate(event.startDate),
+    orderNumber: String(order.orderNumber ?? ""),
+    orderTotal: String(order.total ?? ""),
+    currency: String(order.currency ?? "INR"),
+    customerName: contact.name?.trim() || contact.email?.split("@")[0] || "Guest",
+    customerEmail: contact.email?.trim() || "",
+    customerPhone: contact.phone?.trim() || "",
+    productNames,
+    trackUrl,
+    invoiceNumber,
+    invoiceUrl,
+    orderDetails: formatOrderDetailsText(orderDetailsPayload),
+    orderDetailsHtml: formatOrderDetailsHtml(orderDetailsPayload)
+  };
+}
+__name(buildEventOrderTemplateVariables, "buildEventOrderTemplateVariables");
+function formatEventDate(d) {
+  if (!d) return "";
+  try {
+    return new Date(d).toLocaleString(void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    });
+  } catch {
+    return String(d);
+  }
+}
+__name(formatEventDate, "formatEventDate");
+
+// src/lib/order-notification-context.ts
+async function loadOrderLines(dataSource, entityMap, orderId, currency) {
+  if (!entityMap.order_items) return [];
+  const itemRows = await dataSource.getRepository(entityMap.order_items).find({
+    where: {
+      orderId
+    },
+    relations: [
+      "product"
+    ],
+    order: {
+      id: "ASC"
+    }
+  });
+  return itemRows.map((item) => {
+    const row = item;
+    const name = row.product?.name || row.product?.title || `Product #${row.productId}`;
+    return {
+      name: String(name),
+      quantity: Number(row.quantity) || 1,
+      total: row.total,
+      currency
+    };
+  });
+}
+__name(loadOrderLines, "loadOrderLines");
+async function loadPrimaryEvent(dataSource, entityMap, itemRows) {
+  if (!entityMap.event_products || !entityMap.events) {
+    return {
+      productNames: []
+    };
+  }
+  const epRepo = dataSource.getRepository(entityMap.event_products);
+  const eventRepo = dataSource.getRepository(entityMap.events);
+  const eventMap = /* @__PURE__ */ new Map();
+  for (const item of itemRows) {
+    const productId = item.productId;
+    const productName = item.product?.name || item.product?.title || `Product #${productId}`;
+    const eps = await epRepo.find({
+      where: {
+        productId,
+        isActive: true
+      }
+    });
+    for (const ep of eps) {
+      const eventId = ep.eventId;
+      const existing = eventMap.get(eventId);
+      if (existing) {
+        if (!existing.productNames.includes(String(productName))) {
+          existing.productNames.push(String(productName));
+        }
+      } else {
+        const event = await eventRepo.findOne({
+          where: {
+            id: eventId,
+            deleted: false
+          }
+        });
+        if (event) {
+          eventMap.set(eventId, {
+            event,
+            productNames: [
+              String(productName)
+            ]
+          });
+        }
+      }
+    }
+  }
+  const first = eventMap.values().next().value;
+  if (!first) return {
+    productNames: []
+  };
+  return {
+    event: first.event,
+    productNames: first.productNames
+  };
+}
+__name(loadPrimaryEvent, "loadPrimaryEvent");
+async function isFeatureGroupEnabled(dataSource, entityMap, group) {
+  if (!entityMap.configs) return true;
+  try {
+    const rows = await dataSource.getRepository(entityMap.configs).find({
+      where: {
+        settings: group,
+        deleted: false
+      }
+    });
+    const settings = Object.fromEntries(rows.map((r) => [
+      r.key,
+      r.value
+    ]));
+    return settings.enabled !== "false" && settings.enabled !== "0";
+  } catch {
+    return true;
+  }
+}
+__name(isFeatureGroupEnabled, "isFeatureGroupEnabled");
+async function loadOrderNotificationContexts(orderId, deps) {
+  if (!deps.entityMap.orders) return null;
+  const order = await deps.dataSource.getRepository(deps.entityMap.orders).findOne({
+    where: {
+      id: orderId,
+      deleted: false
+    },
+    relations: [
+      "contact"
+    ]
+  });
+  if (!order) return null;
+  const o = order;
+  const meta = o.metadata && typeof o.metadata === "object" && !Array.isArray(o.metadata) ? o.metadata : {};
+  const metaBuyerEmail = typeof meta.buyerEmail === "string" && meta.buyerEmail.includes("@") ? meta.buyerEmail.trim() : null;
+  const metaCheckoutEmail = typeof meta.checkoutEmail === "string" && meta.checkoutEmail.includes("@") ? meta.checkoutEmail.trim() : null;
+  const metaBuyerName = typeof meta.buyerName === "string" && meta.buyerName.trim() ? meta.buyerName.trim() : null;
+  const rawContact = o.contact ?? {};
+  const contact = {
+    name: metaBuyerName || rawContact.name,
+    email: metaBuyerEmail || metaCheckoutEmail || rawContact.email,
+    phone: rawContact.phone
+  };
+  const currency = String(o.currency ?? "INR");
+  const siteUrl = resolvePublicSiteUrl();
+  const itemRows = await deps.dataSource.getRepository(deps.entityMap.order_items).find({
+    where: {
+      orderId
+    },
+    relations: [
+      "product"
+    ],
+    order: {
+      id: "ASC"
+    }
+  });
+  const orderLines = await loadOrderLines(deps.dataSource, deps.entityMap, orderId, currency);
+  const { event, productNames: eventProductNames } = await loadPrimaryEvent(deps.dataSource, deps.entityMap, itemRows);
+  const allProductNames = orderLines.map((line) => line.name);
+  const productNames = eventProductNames.length > 0 ? eventProductNames.join(", ") : allProductNames.join(", ");
+  const [multiVendorEnabled, eventsEnabled] = await Promise.all([
+    isFeatureGroupEnabled(deps.dataSource, deps.entityMap, "multi_vendor"),
+    isFeatureGroupEnabled(deps.dataSource, deps.entityMap, "events")
+  ]);
+  let vendorName = "";
+  if (multiVendorEnabled) {
+    const vendorId = o.vendorId ?? event?.vendorId;
+    if (vendorId && deps.entityMap.vendors) {
+      try {
+        const vRow = await deps.dataSource.getRepository(deps.entityMap.vendors).findOne({
+          where: {
+            id: vendorId
+          }
+        });
+        if (vRow) {
+          const v = vRow;
+          vendorName = String(v.storeName?.trim() || v.name?.trim() || v.companyName?.trim() || "");
+        }
+      } catch {
+      }
+    }
+  }
+  const effectiveEvent = eventsEnabled ? event : void 0;
+  const variables = effectiveEvent ? buildEventOrderTemplateVariables({
+    event: effectiveEvent,
+    order: {
+      orderNumber: o.orderNumber,
+      total: o.total,
+      currency,
+      qrToken: o.qrToken
+    },
+    contact,
+    productNames,
+    vendorName,
+    orderLines,
+    siteUrl
+  }) : buildEventOrderTemplateVariables({
+    event: {
+      name: eventsEnabled ? productNames || "Your order" : "",
+      slug: "",
+      venue: "",
+      startDate: null
+    },
+    order: {
+      orderNumber: o.orderNumber,
+      total: o.total,
+      currency,
+      qrToken: o.qrToken
+    },
+    contact,
+    productNames,
+    vendorName,
+    orderLines,
+    siteUrl
+  });
+  return {
+    order: {
+      id: o.id,
+      orderNumber: String(o.orderNumber ?? ""),
+      total: o.total,
+      currency,
+      qrToken: o.qrToken
+    },
+    contact,
+    orderLines,
+    productNames,
+    event,
+    variables
+  };
+}
+__name(loadOrderNotificationContexts, "loadOrderNotificationContexts");
+
+// src/plugins/whatsapp/whatsapp-queue.ts
+var WHATSAPP_QUEUE_NAME = "whatsapp";
+function maskPhone(raw) {
+  const digits = raw.replace(/\D/g, "");
+  if (digits.length <= 4) return "****";
+  return `${"*".repeat(Math.max(0, digits.length - 4))}${digits.slice(-4)}`;
+}
+__name(maskPhone, "maskPhone");
+function registerWhatsAppQueueProcessor(cms) {
+  const queue = cms.getPlugin("queue");
+  const whatsapp = cms.getPlugin("whatsapp");
+  if (!queue) {
+    console.warn("[whatsapp] queue processor not registered: queue plugin missing");
+    return;
+  }
+  if (!whatsapp || typeof whatsapp.send !== "function") {
+    console.warn("[whatsapp] queue processor not registered: whatsapp plugin missing or not configured");
+    return;
+  }
+  queue.registerProcessor(WHATSAPP_QUEUE_NAME, async (data) => {
+    const payload = data;
+    if (!payload.to) {
+      console.warn("[whatsapp] queue job skipped: missing recipient");
+      return;
+    }
+    console.log("[whatsapp] queue job processing", {
+      to: maskPhone(payload.to),
+      templateKey: payload.templateKey ?? null,
+      externalTemplateRef: payload.externalTemplateRef ?? null
+    });
+    try {
+      const ok = await whatsapp.send(payload);
+      if (ok) {
+        console.log("[whatsapp] queue job completed", {
+          to: maskPhone(payload.to),
+          sent: true
+        });
+      } else {
+        console.warn("[whatsapp] queue job completed without delivery", {
+          to: maskPhone(payload.to),
+          sent: false
+        });
+      }
+    } catch (err) {
+      console.error("[whatsapp] queue job failed", {
+        to: maskPhone(payload.to),
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  console.log("[whatsapp] queue processor registered", {
+    queue: WHATSAPP_QUEUE_NAME
+  });
+}
+__name(registerWhatsAppQueueProcessor, "registerWhatsAppQueueProcessor");
+async function queueWhatsApp(cms, payload) {
+  const queue = cms.getPlugin("queue");
+  if (queue) {
+    console.log("[whatsapp] enqueue", {
+      to: maskPhone(payload.to),
+      templateKey: payload.templateKey ?? null,
+      externalTemplateRef: payload.externalTemplateRef ?? null
+    });
+    await queue.add(WHATSAPP_QUEUE_NAME, payload);
+    return true;
+  }
+  const whatsapp = cms.getPlugin("whatsapp");
+  if (whatsapp && typeof whatsapp.send === "function") {
+    console.log("[whatsapp] no queue plugin \u2014 sending immediately", {
+      to: maskPhone(payload.to)
+    });
+    return whatsapp.send(payload);
+  }
+  console.warn("[whatsapp] send skipped: neither queue nor whatsapp plugin available", {
+    to: maskPhone(payload.to)
+  });
+  return false;
+}
+__name(queueWhatsApp, "queueWhatsApp");
+
+// src/plugins/whatsapp/whatsapp-service.ts
+function norm(v) {
+  const t = v?.trim();
+  return t || void 0;
+}
+__name(norm, "norm");
+function pick(plugin, db, env, ...keys) {
+  for (const key of keys) {
+    const pk = key;
+    if (pk in plugin && plugin[pk] !== void 0 && String(plugin[pk]).trim() !== "") {
+      const v = norm(String(plugin[pk]));
+      if (v) return v;
+    }
+    if (norm(db[key])) return norm(db[key]);
+    if (norm(env[key])) return norm(env[key]);
+  }
+  return void 0;
+}
+__name(pick, "pick");
+function mergeWhatsAppConfigLayers(env, db, plugin) {
+  return {
+    accessToken: pick(plugin, db, env, "accessToken", "WHATSAPP_ACCESS_TOKEN"),
+    phoneNumberId: pick(plugin, db, env, "phoneNumberId", "WHATSAPP_PHONE_NUMBER_ID"),
+    apiVersion: pick(plugin, db, env, "apiVersion", "WHATSAPP_API_VERSION") ?? "v21.0"
+  };
+}
+__name(mergeWhatsAppConfigLayers, "mergeWhatsAppConfigLayers");
+function isWhatsAppPluginEnabled(db) {
+  const v = (db.enabled ?? "true").toLowerCase();
+  return v !== "false" && v !== "0";
+}
+__name(isWhatsAppPluginEnabled, "isWhatsAppPluginEnabled");
+function whatsAppConfigured(config) {
+  return Boolean(config.accessToken?.trim() && config.phoneNumberId?.trim());
+}
+__name(whatsAppConfigured, "whatsAppConfigured");
+function normalizeWhatsAppRecipient(to) {
+  const digits = to.replace(/\D/g, "");
+  return digits;
+}
+__name(normalizeWhatsAppRecipient, "normalizeWhatsAppRecipient");
+function resolveMetaWhatsAppTemplateName(opts) {
+  const ref = opts.externalTemplateRef?.trim();
+  const rowName = opts.name?.trim();
+  if (ref && !/^\d+$/.test(ref)) return ref;
+  if (rowName) return rowName;
+  return ref || void 0;
+}
+__name(resolveMetaWhatsAppTemplateName, "resolveMetaWhatsAppTemplateName");
+function maskPhone2(digits) {
+  if (digits.length <= 4) return "****";
+  return `${"*".repeat(Math.max(0, digits.length - 4))}${digits.slice(-4)}`;
+}
+__name(maskPhone2, "maskPhone");
+function logWhatsApp(level, message, extra) {
+  const line = extra ? `${message} ${JSON.stringify(extra)}` : message;
+  if (level === "info") console.log(`[whatsapp] ${line}`);
+  else if (level === "warn") console.warn(`[whatsapp] ${line}`);
+  else console.error(`[whatsapp] ${line}`);
+}
+__name(logWhatsApp, "logWhatsApp");
+var WhatsAppService = class {
+  static {
+    __name(this, "WhatsAppService");
+  }
+  getWhatsAppSettings;
+  config;
+  getMessageTemplateRow;
+  constructor(env, plugin = {}, getWhatsAppSettings, getMessageTemplateRow) {
+    this.getWhatsAppSettings = getWhatsAppSettings;
+    this.getMessageTemplateRow = getMessageTemplateRow;
+    this.config = mergeWhatsAppConfigLayers(env, {}, plugin);
+  }
+  async mergedConfig() {
+    let db = {};
+    try {
+      db = await this.getWhatsAppSettings?.() ?? {};
+    } catch {
+    }
+    return mergeWhatsAppConfigLayers((typeof process !== "undefined" ? process.env : {}) ?? {}, db, this.config);
+  }
+  async send(opts) {
+    const cfg = await this.mergedConfig();
+    if (!whatsAppConfigured(cfg)) {
+      logWhatsApp("warn", "send skipped: not configured (Plugins \u2192 WhatsApp or WHATSAPP_ACCESS_TOKEN + WHATSAPP_PHONE_NUMBER_ID)");
+      return false;
+    }
+    const to = normalizeWhatsAppRecipient(opts.to);
+    if (!to) {
+      logWhatsApp("warn", "send skipped: invalid recipient", {
+        rawTo: opts.to
+      });
+      return false;
+    }
+    logWhatsApp("info", "send started", {
+      to: maskPhone2(to),
+      templateKey: opts.templateKey ?? null,
+      externalTemplateRef: opts.externalTemplateRef ?? null,
+      phoneNumberId: cfg.phoneNumberId
+    });
+    let templateName = resolveMetaWhatsAppTemplateName({
+      externalTemplateRef: opts.externalTemplateRef
+    });
+    let templateLanguage = opts.templateLanguage?.trim();
+    let body = opts.body?.trim() ?? "";
+    const variables = opts.variables ?? {};
+    if (opts.templateKey?.trim() && this.getMessageTemplateRow) {
+      const { resolveEventOrderTemplate, EVENT_ORDER_TEMPLATE_KEY } = await import('./event-order-defaults-H4RT7NMR.js');
+      if (opts.templateKey.trim() === EVENT_ORDER_TEMPLATE_KEY) {
+        const resolved = await resolveEventOrderTemplate("whatsapp", async (ch, key) => {
+          const row = await this.getMessageTemplateRow(ch, key);
+          if (!row) return null;
+          return {
+            subject: null,
+            body: row.body,
+            externalTemplateRef: row.externalTemplateRef,
+            enabled: row.enabled
+          };
+        });
+        if (resolved && !resolved.enabled) {
+          logWhatsApp("warn", "send skipped: template disabled in message_templates", {
+            templateKey: opts.templateKey
+          });
+          return false;
+        }
+        if (resolved) {
+          body = resolved.body;
+          if (resolved.externalTemplateRef) templateName = resolved.externalTemplateRef;
+        }
+      }
+    }
+    const { applyTemplateVars: applyTemplateVars2 } = await import('./interpolate-WDUWDF3I.js');
+    if (body) body = applyTemplateVars2(body, variables);
+    if (templateName) {
+      const paramValues = opts.templateParamOrder?.length ? opts.templateParamOrder.map((key) => String(variables[key] ?? "").slice(0, 1024)) : Object.keys(variables).length ? Object.values(variables) : body ? [
+        body
+      ] : [];
+      logWhatsApp("info", "sending template message", {
+        to: maskPhone2(to),
+        templateName,
+        paramCount: paramValues.length,
+        paramOrder: opts.templateParamOrder ?? null
+      });
+      return this.sendTemplateMessage(cfg, to, templateName, paramValues, templateLanguage);
+    }
+    if (!body) {
+      logWhatsApp("warn", "send skipped: no template name and empty body", {
+        to: maskPhone2(to)
+      });
+      return false;
+    }
+    logWhatsApp("info", "sending text message", {
+      to: maskPhone2(to),
+      bodyLength: body.length
+    });
+    return this.sendTextMessage(cfg, to, body);
+  }
+  async sendTextMessage(cfg, to, body) {
+    const url = `https://graph.facebook.com/${cfg.apiVersion}/${cfg.phoneNumberId}/messages`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${cfg.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        messaging_product: "whatsapp",
+        to,
+        type: "text",
+        text: {
+          body
+        }
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      logWhatsApp("error", "text send failed", {
+        status: res.status,
+        to: maskPhone2(to),
+        error: errText
+      });
+      return false;
+    }
+    const data = await res.json().catch(() => ({}));
+    logWhatsApp("info", "text send succeeded", {
+      to: maskPhone2(to),
+      messageId: data.messages?.[0]?.id ?? null
+    });
+    return true;
+  }
+  async sendTemplateMessage(cfg, to, templateName, paramValues, templateLanguage) {
+    const components = paramValues.length > 0 ? [
+      {
+        type: "body",
+        parameters: paramValues.map((text) => ({
+          type: "text",
+          text: String(text).slice(0, 1024)
+        }))
+      }
+    ] : void 0;
+    const url = `https://graph.facebook.com/${cfg.apiVersion}/${cfg.phoneNumberId}/messages`;
+    const payload = {
+      messaging_product: "whatsapp",
+      to,
+      type: "template",
+      template: {
+        name: templateName,
+        language: {
+          code: templateLanguage?.trim() || "en"
+        },
+        ...components ? {
+          components
+        } : {}
+      }
+    };
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${cfg.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      logWhatsApp("error", "template send failed", {
+        status: res.status,
+        to: maskPhone2(to),
+        templateName,
+        paramCount: paramValues.length,
+        error: errText
+      });
+      return false;
+    }
+    const data = await res.json().catch(() => ({}));
+    logWhatsApp("info", "template send succeeded", {
+      to: maskPhone2(to),
+      templateName,
+      messageId: data.messages?.[0]?.id ?? null
+    });
+    return true;
+  }
+};
 
 // src/plugins/email/templates/layout.ts
 function escapeHtml(s) {
@@ -567,6 +1187,19 @@ ${slugNote}
       `Owner / invitee: ${ownerName?.trim() || "\u2014"} (${ownerEmail})`,
       `Activation: ${activation === "invite" ? "Invitation" : "Password set"}`
     ].filter(Boolean).join("\n");
+  } else if (kind === "team_invite" && activation === "membership" && inviteLink) {
+    subject = `You're invited to ${storeLabel}`;
+    bodyHtml = `<p style="margin:0 0 12px 0;font-size:15px;line-height:1.5;color:#333;">${greeting}</p>
+<p style="margin:0 0 12px 0;font-size:15px;line-height:1.5;color:#333;">You have been invited to join the vendor team for <strong>${escapeHtml2(storeLabel)}</strong>. You already have an account \u2014 accept below to join this store. You will not need to set a new password.</p>
+${primaryCtaButton(inviteLink, "Accept invitation")}
+<p style="margin:16px 0 0 0;font-size:12px;line-height:1.5;color:#888;">If the button does not work, copy and paste this URL into your browser:<br/><span style="word-break:break-all;">${escapeHtml2(inviteLink)}</span></p>`;
+    text = [
+      ownerName?.trim() ? `Hello ${ownerName.trim()},` : "Hello,",
+      "",
+      `You have been invited to join ${storeLabel}.`,
+      "Open this link to accept (no new password required):",
+      inviteLink
+    ].join("\n");
   } else if (kind === "team_invite" && activation === "invite" && inviteLink) {
     subject = `You're invited to ${storeLabel}`;
     bodyHtml = `<p style="margin:0 0 12px 0;font-size:15px;line-height:1.5;color:#333;">${greeting}</p>
@@ -665,6 +1298,8 @@ function renderEmail(templateName, ctx, options) {
   return render12(ctx);
 }
 __name(renderEmail, "renderEmail");
+
+// src/plugins/email/email-service.ts
 var require2 = createRequire(import.meta.url);
 var MailComposer = require2("nodemailer/lib/mail-composer");
 var SES_REGIONS_WITHOUT_SMTP = /* @__PURE__ */ new Set([
@@ -1031,8 +1666,8 @@ function resolveChatEmailToolSettings(configMap, sources) {
 __name(resolveChatEmailToolSettings, "resolveChatEmailToolSettings");
 function intentByKey(intents, key) {
   if (!key) return null;
-  const norm = normalizeIntentKey(key);
-  return intents.find((i) => i.intent === norm) ?? null;
+  const norm2 = normalizeIntentKey(key);
+  return intents.find((i) => i.intent === norm2) ?? null;
 }
 __name(intentByKey, "intentByKey");
 function buildIntentTableForPrompt(intents) {
@@ -1417,5 +2052,787 @@ function emailPlugin(config) {
   };
 }
 __name(emailPlugin, "emailPlugin");
+function base64UrlEncode(str) {
+  const buf = typeof str === "string" ? Buffer.from(str, "utf8") : str;
+  return buf.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+__name(base64UrlEncode, "base64UrlEncode");
+async function getGoogleAccessToken(clientEmail, privateKey) {
+  const now = Math.floor(Date.now() / 1e3);
+  const header = {
+    alg: "RS256",
+    typ: "JWT"
+  };
+  const claimSet = {
+    iss: clientEmail,
+    scope: "https://www.googleapis.com/auth/firebase.messaging",
+    aud: "https://oauth2.googleapis.com/token",
+    exp: now + 3600,
+    iat: now
+  };
+  const encodedHeader = base64UrlEncode(JSON.stringify(header));
+  const encodedClaimSet = base64UrlEncode(JSON.stringify(claimSet));
+  const signatureInput = `${encodedHeader}.${encodedClaimSet}`;
+  const formattedKey = privateKey.replace(/\\n/g, "\n");
+  const signer = crypto.createSign("RSA-SHA256");
+  signer.update(signatureInput);
+  const signature = signer.sign(formattedKey, "base64");
+  const jwt = `${signatureInput}.${signature.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_")}`;
+  const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      assertion: jwt
+    }).toString()
+  });
+  if (!tokenRes.ok) {
+    const errText = await tokenRes.text();
+    throw new Error(`Failed to obtain Google access token: ${errText}`);
+  }
+  const tokenData = await tokenRes.json();
+  if (!tokenData.access_token) {
+    throw new Error("Google OAuth token response missing access_token");
+  }
+  return tokenData.access_token;
+}
+__name(getGoogleAccessToken, "getGoogleAccessToken");
+async function resolveFcmServiceAccount(dataSource, entityMap) {
+  const pushSettings = await getSettingsGroup(dataSource, entityMap, "push");
+  let projectId = pushSettings.firebase_project_id?.trim();
+  let clientEmail = pushSettings.firebase_client_email?.trim();
+  let privateKey = pushSettings.firebase_private_key?.trim();
+  if (pushSettings.firebase_service_account_json?.trim()) {
+    try {
+      const parsed = JSON.parse(pushSettings.firebase_service_account_json.trim());
+      if (parsed.project_id) projectId = parsed.project_id;
+      if (parsed.client_email) clientEmail = parsed.client_email;
+      if (parsed.private_key) privateKey = parsed.private_key;
+    } catch {
+    }
+  }
+  if (!projectId || !clientEmail || !privateKey) {
+    return {
+      ok: false,
+      error: "Firebase Service Account JSON / credentials are not configured"
+    };
+  }
+  return {
+    ok: true,
+    account: {
+      projectId,
+      clientEmail,
+      privateKey
+    }
+  };
+}
+__name(resolveFcmServiceAccount, "resolveFcmServiceAccount");
+async function validateFcmCredentials(dataSource, entityMap) {
+  try {
+    const resolved = await resolveFcmServiceAccount(dataSource, entityMap);
+    if (!resolved.ok) {
+      return {
+        success: false,
+        error: resolved.error
+      };
+    }
+    const { projectId, clientEmail, privateKey } = resolved.account;
+    await getGoogleAccessToken(clientEmail, privateKey);
+    return {
+      success: true,
+      projectId,
+      clientEmail
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : "Unknown credential validation error";
+    console.error("[fcm-push] Exception in validateFcmCredentials", errorMsg);
+    return {
+      success: false,
+      error: errorMsg
+    };
+  }
+}
+__name(validateFcmCredentials, "validateFcmCredentials");
+async function sendFcmPushNotification(dataSource, entityMap, msg) {
+  try {
+    const resolved = await resolveFcmServiceAccount(dataSource, entityMap);
+    if (!resolved.ok) {
+      return {
+        success: false,
+        error: resolved.error
+      };
+    }
+    const { projectId, clientEmail, privateKey } = resolved.account;
+    const accessToken = await getGoogleAccessToken(clientEmail, privateKey);
+    const fcmEndpoint = `https://fcm.googleapis.com/v1/projects/${projectId}/messages:send`;
+    const fcmPayload = {
+      message: {
+        token: msg.token,
+        notification: {
+          title: msg.title,
+          body: msg.body
+        },
+        data: msg.data || {}
+      }
+    };
+    const response = await fetch(fcmEndpoint, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(fcmPayload)
+    });
+    const resData = await response.json();
+    if (!response.ok) {
+      const errorMsg = resData.error?.message || "FCM request failed";
+      console.error("[fcm-push] Error sending push notification", errorMsg);
+      return {
+        success: false,
+        error: errorMsg
+      };
+    }
+    return {
+      success: true,
+      messageId: resData.name
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : "Unknown push error";
+    console.error("[fcm-push] Exception in sendFcmPushNotification", errorMsg);
+    return {
+      success: false,
+      error: errorMsg
+    };
+  }
+}
+__name(sendFcmPushNotification, "sendFcmPushNotification");
+
+// src/lib/order-notification-dispatcher.ts
+var initialized = false;
+function maskPhone3(raw) {
+  const digits = String(raw ?? "").replace(/\D/g, "");
+  if (digits.length <= 4) return "(none)";
+  return `***${digits.slice(-4)}`;
+}
+__name(maskPhone3, "maskPhone");
+async function getSettingsGroup(dataSource, entityMap, group) {
+  if (!entityMap.configs) return {};
+  const rows = await dataSource.getRepository(entityMap.configs).find({
+    where: {
+      settings: group,
+      deleted: false
+    }
+  });
+  return Object.fromEntries(rows.map((r) => [
+    r.key,
+    r.value
+  ]));
+}
+__name(getSettingsGroup, "getSettingsGroup");
+async function isEmailNotificationsEnabled(dataSource, entityMap) {
+  const settings = await getSettingsGroup(dataSource, entityMap, "event_notifications");
+  if (settings.enabled === "false" || settings.enabled === "0") return false;
+  return settings.email_enabled !== "false" && settings.email_enabled !== "0";
+}
+__name(isEmailNotificationsEnabled, "isEmailNotificationsEnabled");
+async function isWhatsappNotificationsEnabled(dataSource, entityMap) {
+  const settings = await getSettingsGroup(dataSource, entityMap, "event_notifications");
+  if (settings.enabled === "false" || settings.enabled === "0") return false;
+  return settings.whatsapp_enabled !== "false" && settings.whatsapp_enabled !== "0";
+}
+__name(isWhatsappNotificationsEnabled, "isWhatsappNotificationsEnabled");
+async function isTriggerCatalogEnabled(triggerKey, dataSource, entityMap) {
+  if (!entityMap.order_notification_triggers) {
+    console.warn("[order-notifications] order_notification_triggers missing \u2014 run migration 1781230000000-AddOrderNotificationTriggers");
+    return false;
+  }
+  try {
+    const row = await dataSource.getRepository(entityMap.order_notification_triggers).findOne({
+      where: {
+        triggerKey,
+        enabled: true
+      }
+    });
+    if (!row) {
+      console.warn("[order-notifications] trigger disabled or not in DB", {
+        triggerKey
+      });
+    }
+    return Boolean(row);
+  } catch (err) {
+    console.error("[order-notifications] failed to load trigger catalog", {
+      triggerKey,
+      err
+    });
+    return false;
+  }
+}
+__name(isTriggerCatalogEnabled, "isTriggerCatalogEnabled");
+async function loadBoundTemplate(triggerKey, channel, audienceType = "customers", dataSource, entityMap) {
+  if (!entityMap.order_notification_bindings || !entityMap.message_templates) {
+    console.warn("[order-notifications] order_notification_bindings or message_templates missing from entityMap");
+    return null;
+  }
+  const bindingRepo = dataSource.getRepository(entityMap.order_notification_bindings);
+  let binding = await bindingRepo.findOne({
+    where: {
+      triggerKey,
+      channel,
+      type: audienceType,
+      enabled: true
+    }
+  });
+  if (!binding && audienceType === "customers") {
+    binding = await bindingRepo.findOne({
+      where: {
+        triggerKey,
+        channel,
+        enabled: true
+      }
+    });
+  }
+  if (!binding) {
+    console.warn("[order-notifications] no order_notification_bindings row", {
+      triggerKey,
+      channel,
+      audienceType
+    });
+    return null;
+  }
+  const templateId = binding.messageTemplateId;
+  if (templateId == null) {
+    console.warn("[order-notifications] binding exists but no template selected", {
+      triggerKey,
+      channel,
+      audienceType
+    });
+    return null;
+  }
+  const template = await dataSource.getRepository(entityMap.message_templates).findOne({
+    where: {
+      id: templateId,
+      channel,
+      deleted: false,
+      enabled: true
+    }
+  });
+  if (!template) {
+    console.warn("[order-notifications] bound template not found or disabled", {
+      triggerKey,
+      channel,
+      audienceType,
+      templateId
+    });
+    return null;
+  }
+  return template;
+}
+__name(loadBoundTemplate, "loadBoundTemplate");
+function mergeTriggerVariables(payload, rich) {
+  const basic = {
+    orderId: String(payload.orderId ?? ""),
+    orderNumber: payload.orderNumber,
+    customerName: payload.customerName,
+    customerPhone: payload.customerPhone ?? "",
+    total: String(payload.total),
+    orderTotal: String(payload.total),
+    currency: payload.currency,
+    vendorId: String(payload.vendorId ?? ""),
+    ...payload.refundAmount != null ? {
+      refundAmount: String(payload.refundAmount)
+    } : {}
+  };
+  return {
+    ...basic,
+    ...rich ?? {}
+  };
+}
+__name(mergeTriggerVariables, "mergeTriggerVariables");
+async function isAudienceEmailEnabled(dataSource, entityMap, audience) {
+  const settings = await getSettingsGroup(dataSource, entityMap, "event_notifications");
+  if (settings.enabled === "false" || settings.enabled === "0") return false;
+  if (settings.email_enabled === "false" || settings.email_enabled === "0") return false;
+  const key = `email_${audience}_enabled`;
+  return settings[key] !== "false" && settings[key] !== "0";
+}
+__name(isAudienceEmailEnabled, "isAudienceEmailEnabled");
+async function isPushNotificationsEnabled(dataSource, entityMap) {
+  const settings = await getSettingsGroup(dataSource, entityMap, "event_notifications");
+  if (settings.enabled === "false" || settings.enabled === "0") return false;
+  return settings.push_enabled !== "false" && settings.push_enabled !== "0";
+}
+__name(isPushNotificationsEnabled, "isPushNotificationsEnabled");
+async function isAudiencePushEnabled(dataSource, entityMap, audience) {
+  const settings = await getSettingsGroup(dataSource, entityMap, "event_notifications");
+  if (settings.enabled === "false" || settings.enabled === "0") return false;
+  if (settings.push_enabled === "false" || settings.push_enabled === "0") return false;
+  const key = `push_${audience}_enabled`;
+  return settings[key] !== "false" && settings[key] !== "0";
+}
+__name(isAudiencePushEnabled, "isAudiencePushEnabled");
+async function sendPushNotificationForTrigger(triggerKey, orderId, audienceType, targetId, variables, dataSource, entityMap) {
+  let template = await loadBoundTemplate(triggerKey, "mobile", audienceType, dataSource, entityMap);
+  if (!template) {
+    template = await loadBoundTemplate(triggerKey, "push", audienceType, dataSource, entityMap);
+  }
+  if (!template || !template.body) return;
+  const rawTitle = template.subject?.trim() || "Order Notification";
+  const title = applyTemplateVars(rawTitle, variables);
+  const body = applyTemplateVars(template.body, variables);
+  if (!entityMap.user_device_tokens) return;
+  const tokenRepo = dataSource.getRepository(entityMap.user_device_tokens);
+  let targetTokens = [];
+  try {
+    if (audienceType === "customers") {
+      targetTokens = await tokenRepo.find({
+        where: {
+          userId: targetId,
+          isActive: true
+        },
+        select: [
+          "token"
+        ]
+      });
+    } else if (audienceType === "vendors") {
+      targetTokens = await tokenRepo.find({
+        where: {
+          vendorId: targetId,
+          isActive: true
+        },
+        select: [
+          "token"
+        ]
+      });
+    } else if (audienceType === "admin") {
+      targetTokens = await tokenRepo.find({
+        where: {
+          isActive: true
+        },
+        select: [
+          "token"
+        ]
+      });
+    }
+  } catch (err) {
+    console.error("[order-notifications] Error querying device tokens for push", err);
+    return;
+  }
+  for (const t of targetTokens) {
+    if (t.token?.trim()) {
+      await sendFcmPushNotification(dataSource, entityMap, {
+        token: t.token.trim(),
+        title,
+        body,
+        data: {
+          orderId: String(orderId),
+          triggerKey
+        }
+      });
+    }
+  }
+}
+__name(sendPushNotificationForTrigger, "sendPushNotificationForTrigger");
+async function getOrderVendorEmails(orderId, orderVendorId, dataSource, entityMap) {
+  const emails = /* @__PURE__ */ new Set();
+  if (!entityMap.vendors) return [];
+  const vendorRepo = dataSource.getRepository(entityMap.vendors);
+  if (orderVendorId) {
+    try {
+      const v = await vendorRepo.findOne({
+        where: {
+          id: orderVendorId
+        }
+      });
+      if (v) {
+        const row = v;
+        if (row.email?.trim()) emails.add(row.email.trim());
+        if (row.supportEmail?.trim()) emails.add(row.supportEmail.trim());
+      }
+    } catch {
+    }
+  }
+  if (entityMap.order_items) {
+    try {
+      const items = await dataSource.getRepository(entityMap.order_items).find({
+        where: {
+          orderId
+        },
+        relations: [
+          "product"
+        ]
+      });
+      for (const item of items) {
+        const row = item;
+        const vId = row.product?.vendorId;
+        if (vId && vId !== orderVendorId) {
+          const v = await vendorRepo.findOne({
+            where: {
+              id: vId
+            }
+          });
+          if (v) {
+            const vRow = v;
+            if (vRow.email?.trim()) emails.add(vRow.email.trim());
+            if (vRow.supportEmail?.trim()) emails.add(vRow.supportEmail.trim());
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(emails);
+}
+__name(getOrderVendorEmails, "getOrderVendorEmails");
+async function getAdminRecipientEmails(dataSource, entityMap) {
+  const emails = /* @__PURE__ */ new Set();
+  const emailSettings = await getSettingsGroup(dataSource, entityMap, "email");
+  const rawRecipients = [
+    emailSettings.salesTeamEmails,
+    emailSettings.salesTeamEmail,
+    emailSettings.fulfilmentTeamEmails,
+    emailSettings.fulfilmentTeamEmail,
+    emailSettings.adminEmail
+  ];
+  for (const raw of rawRecipients) {
+    if (!raw) continue;
+    const parts = String(raw).split(/[,;]/);
+    for (const p of parts) {
+      const trimmed = p.trim();
+      if (trimmed && trimmed.includes("@")) emails.add(trimmed.toLowerCase());
+    }
+  }
+  if (entityMap.users) {
+    try {
+      const userRepo = dataSource.getRepository(entityMap.users);
+      const adminUsers = await userRepo.find({
+        where: [
+          {
+            groupId: 1,
+            blocked: false
+          },
+          {
+            adminAccess: true,
+            blocked: false
+          }
+        ]
+      });
+      for (const u of adminUsers) {
+        const em = u.email?.trim().toLowerCase();
+        if (em && em.includes("@")) {
+          emails.add(em);
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const rows = await dataSource.query(`SELECT DISTINCT LOWER(TRIM(email)) AS email
+         FROM users
+        WHERE ("groupId" = 1 OR "adminAccess" = true)
+          AND COALESCE(blocked, false) = false
+          AND COALESCE(deleted, false) = false
+          AND "deletedAt" IS NULL`);
+    for (const r of rows) {
+      const em = r.email?.trim().toLowerCase();
+      if (em && em.includes("@")) {
+        emails.add(em);
+      }
+    }
+  } catch {
+  }
+  return Array.from(emails);
+}
+__name(getAdminRecipientEmails, "getAdminRecipientEmails");
+function formatBodyForEmailHtml(body) {
+  if (!body) return "";
+  if (/^\s*<(html|body|table|section)[\s>]/i.test(body.trim())) {
+    return body;
+  }
+  const withBreaks = body.replace(/\r\n/g, "\n").replace(/\n/g, "<br />");
+  return `<div style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; font-size: 15px; line-height: 1.6; color: #1f2937;">${withBreaks}</div>`;
+}
+__name(formatBodyForEmailHtml, "formatBodyForEmailHtml");
+async function sendEmailForTrigger(triggerKey, orderId, audienceType, variables, contactEmail, dataSource, entityMap, getCms) {
+  const template = await loadBoundTemplate(triggerKey, "email", audienceType, dataSource, entityMap);
+  if (!template) return;
+  const [branding, emailSettings] = await Promise.all([
+    getSettingsGroup(dataSource, entityMap, "branding"),
+    getSettingsGroup(dataSource, entityMap, "email")
+  ]);
+  const companyDetails = mergeEmailLayoutCompanyDetails(branding, emailSettings);
+  const subject = applyTemplateVars(template.subject ?? "Order update", variables);
+  const rawBody = applyTemplateVars(template.body, variables);
+  const bodyHtml = formatBodyForEmailHtml(rawBody);
+  const html = renderLayout({
+    bodyHtml,
+    companyDetails
+  });
+  const cms = await getCms();
+  const isCustomer = audienceType === "customers";
+  await queueEmail(cms, {
+    to: contactEmail,
+    subject,
+    html,
+    text: rawBody.replace(/<[^>]+>/g, "").trim(),
+    ...isCustomer ? {
+      orderId,
+      attachInvoice: true
+    } : {}
+  });
+  console.log("[order-notifications] email queued", {
+    triggerKey,
+    audienceType,
+    orderId,
+    to: contactEmail,
+    attachInvoice: isCustomer
+  });
+}
+__name(sendEmailForTrigger, "sendEmailForTrigger");
+async function sendWhatsAppForTrigger(triggerKey, orderId, phone, variables, dataSource, entityMap, getCms) {
+  const template = await loadBoundTemplate(triggerKey, "whatsapp", "customers", dataSource, entityMap);
+  if (!template) return;
+  const paramOrder = template.providerMeta?.paramOrder ?? [];
+  if (paramOrder.length === 0) {
+    console.warn("[order-notifications] WhatsApp template has no paramOrder set \u2014 variables may send blank/wrong", {
+      triggerKey
+    });
+  }
+  const cms = await getCms();
+  const metaTemplateName = resolveMetaWhatsAppTemplateName({
+    externalTemplateRef: template.externalTemplateRef,
+    name: template.name
+  });
+  if (!metaTemplateName) {
+    console.warn("[order-notifications] bound WhatsApp template has no Meta template name", {
+      triggerKey,
+      templateId: template.id
+    });
+    return;
+  }
+  const sent = await queueWhatsApp(cms, {
+    to: phone.trim(),
+    templateKey: triggerKey,
+    externalTemplateRef: metaTemplateName,
+    templateLanguage: template.providerMeta?.language ?? void 0,
+    body: template.body,
+    variables,
+    templateParamOrder: paramOrder
+  });
+  if (!sent) {
+    console.warn("[order-notifications] WhatsApp send failed", {
+      triggerKey,
+      orderId,
+      hint: "Register whatsappPlugin() + queuePlugin() in getCms(), or set WHATSAPP_ACCESS_TOKEN and WHATSAPP_PHONE_NUMBER_ID"
+    });
+  } else {
+    console.log("[order-notifications] WhatsApp queued/sent", {
+      triggerKey,
+      orderId,
+      phone: maskPhone3(phone)
+    });
+  }
+}
+__name(sendWhatsAppForTrigger, "sendWhatsAppForTrigger");
+async function isOrderPaymentConfirmed(orderId, dataSource, entityMap) {
+  if (!entityMap.orders) return true;
+  try {
+    const orderRepo = dataSource.getRepository(entityMap.orders);
+    const order = await orderRepo.findOne({
+      where: {
+        id: orderId
+      }
+    });
+    if (!order) return false;
+    const o = order;
+    const status = String(o.status ?? "").toLowerCase().trim();
+    const total = Number(o.total ?? 0);
+    if (total <= 0) return true;
+    const confirmedStatuses = [
+      "confirmed",
+      "completed",
+      "processing",
+      "paid",
+      "fulfilled",
+      "shipped"
+    ];
+    if (confirmedStatuses.includes(status)) {
+      return true;
+    }
+    if (entityMap.payments) {
+      const paymentRepo = dataSource.getRepository(entityMap.payments);
+      const payment = await paymentRepo.findOne({
+        where: {
+          orderId
+        }
+      });
+      if (payment) {
+        const pStatus = String(payment.status ?? "").toLowerCase().trim();
+        if (pStatus === "paid" || pStatus === "captured" || pStatus === "completed") {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (err) {
+    console.error("[order-notifications] failed to check order payment confirmation", err);
+    return false;
+  }
+}
+__name(isOrderPaymentConfirmed, "isOrderPaymentConfirmed");
+async function handleTrigger(triggerKey, payload, dataSource, entityMap, getCms) {
+  console.log("[order-notifications] received", {
+    triggerKey,
+    orderId: payload.orderId,
+    phone: maskPhone3(payload.customerPhone)
+  });
+  if (triggerKey === "order_placed") {
+    const isConfirmed = await isOrderPaymentConfirmed(payload.orderId, dataSource, entityMap);
+    if (!isConfirmed) {
+      console.log("[order-notifications] skip order_placed: order payment not confirmed yet", {
+        orderId: payload.orderId
+      });
+      return;
+    }
+  }
+  const [emailChannelEnabled, whatsappChannelEnabled, pushChannelEnabled] = await Promise.all([
+    isEmailNotificationsEnabled(dataSource, entityMap),
+    isWhatsappNotificationsEnabled(dataSource, entityMap),
+    isPushNotificationsEnabled(dataSource, entityMap)
+  ]);
+  if (!emailChannelEnabled && !whatsappChannelEnabled && !pushChannelEnabled) {
+    console.warn("[order-notifications] skip: Email, WhatsApp, and Mobile Push notifications are disabled");
+    return;
+  }
+  const triggerEnabled = await isTriggerCatalogEnabled(triggerKey, dataSource, entityMap);
+  if (!triggerEnabled) return;
+  const context = await loadOrderNotificationContexts(payload.orderId, {
+    dataSource,
+    entityMap
+  });
+  const variables = mergeTriggerVariables(payload, context?.variables);
+  const contactEmail = context?.contact.email?.trim() || "";
+  const contactPhone = context?.contact.phone?.trim() || payload.customerPhone?.trim() || "";
+  if (emailChannelEnabled) {
+    const [customerEnabled, vendorEnabled, adminEnabled] = await Promise.all([
+      isAudienceEmailEnabled(dataSource, entityMap, "customer"),
+      isAudienceEmailEnabled(dataSource, entityMap, "vendor"),
+      isAudienceEmailEnabled(dataSource, entityMap, "admin")
+    ]);
+    if (customerEnabled && contactEmail) {
+      await sendEmailForTrigger(triggerKey, payload.orderId, "customers", variables, contactEmail, dataSource, entityMap, getCms);
+    }
+    if (vendorEnabled) {
+      const multiVendorSettings = await getSettingsGroup(dataSource, entityMap, "multi_vendor");
+      if (multiVendorSettings.enabled !== "false" && multiVendorSettings.enabled !== "0") {
+        const vendorEmails = await getOrderVendorEmails(payload.orderId, payload.vendorId, dataSource, entityMap);
+        for (const vEmail of vendorEmails) {
+          await sendEmailForTrigger(triggerKey, payload.orderId, "vendors", variables, vEmail, dataSource, entityMap, getCms);
+        }
+      }
+    }
+    if (adminEnabled) {
+      const adminEmails = await getAdminRecipientEmails(dataSource, entityMap);
+      for (const aEmail of adminEmails) {
+        await sendEmailForTrigger(triggerKey, payload.orderId, "admin", variables, aEmail, dataSource, entityMap, getCms);
+      }
+    }
+  } else {
+    console.log("[order-notifications] skip email: Email notifications channel is disabled");
+  }
+  if (pushChannelEnabled) {
+    const [pushCustomerEnabled, pushVendorEnabled, pushAdminEnabled] = await Promise.all([
+      isAudiencePushEnabled(dataSource, entityMap, "customer"),
+      isAudiencePushEnabled(dataSource, entityMap, "vendor"),
+      isAudiencePushEnabled(dataSource, entityMap, "admin")
+    ]);
+    const targetCustomerId = context?.order?.customerContactId || context?.order?.contactId || context?.order?.userId || context?.order?.id;
+    if (pushCustomerEnabled && targetCustomerId) {
+      await sendPushNotificationForTrigger(triggerKey, payload.orderId, "customers", String(targetCustomerId), variables, dataSource, entityMap);
+    }
+    if (pushVendorEnabled && payload.vendorId) {
+      await sendPushNotificationForTrigger(triggerKey, payload.orderId, "vendors", String(payload.vendorId), variables, dataSource, entityMap);
+    }
+    if (pushAdminEnabled) {
+      await sendPushNotificationForTrigger(triggerKey, payload.orderId, "admin", "admin", variables, dataSource, entityMap);
+    }
+  }
+  if (whatsappChannelEnabled) {
+    if (contactPhone) {
+      await sendWhatsAppForTrigger(triggerKey, payload.orderId, contactPhone, variables, dataSource, entityMap, getCms);
+    } else {
+      console.warn("[order-notifications] skip WhatsApp: no customer phone", {
+        triggerKey,
+        orderId: payload.orderId
+      });
+    }
+  } else {
+    console.log("[order-notifications] skip WhatsApp: WhatsApp notifications channel is disabled");
+  }
+}
+__name(handleTrigger, "handleTrigger");
+function initWhatsappTriggerDispatcher(deps) {
+  if (initialized) return;
+  initialized = true;
+  const { dataSource, entityMap, getCms } = deps;
+  notificationTriggerEmitter.onAnyTrigger((triggerKey, payload) => {
+    void handleTrigger(triggerKey, payload, dataSource, entityMap, getCms).catch((err) => {
+      console.error("[order-notifications]", triggerKey, err);
+    });
+  });
+  console.log("[order-notifications] dispatcher initialized (email + WhatsApp, unified via order_notification_bindings)");
+}
+__name(initWhatsappTriggerDispatcher, "initWhatsappTriggerDispatcher");
+async function resendOrderNotification(triggerKey, orderId, deps) {
+  if (!deps.entityMap.orders) return {
+    ok: false,
+    error: "orders entity missing"
+  };
+  const [emailEnabled, whatsappEnabled] = await Promise.all([
+    isEmailNotificationsEnabled(deps.dataSource, deps.entityMap),
+    isWhatsappNotificationsEnabled(deps.dataSource, deps.entityMap)
+  ]);
+  if (!emailEnabled && !whatsappEnabled) {
+    return {
+      ok: false,
+      error: "Both Email and WhatsApp notifications are disabled"
+    };
+  }
+  const triggerEnabled = await isTriggerCatalogEnabled(triggerKey, deps.dataSource, deps.entityMap);
+  if (!triggerEnabled) {
+    return {
+      ok: false,
+      error: `Trigger "${triggerKey}" is disabled or migration 1781230000000 not applied`
+    };
+  }
+  const order = await deps.dataSource.getRepository(deps.entityMap.orders).findOne({
+    where: {
+      id: orderId,
+      deleted: false
+    },
+    relations: [
+      "contact"
+    ]
+  });
+  if (!order) return {
+    ok: false,
+    error: "Order not found"
+  };
+  const o = order;
+  await handleTrigger(triggerKey, {
+    orderId,
+    orderNumber: String(o.orderNumber ?? ""),
+    customerName: o.contact?.name ?? "",
+    customerPhone: o.contact?.phone ?? null,
+    total: o.total ?? 0,
+    currency: String(o.currency ?? "INR"),
+    vendorId: o.vendorId ?? null
+  }, deps.dataSource, deps.entityMap, deps.getCms);
+  return {
+    ok: true
+  };
+}
+__name(resendOrderNotification, "resendOrderNotification");
 
-export { CHAT_EMAIL_LOG, EmailService, buildChatbotSystemPromptWithEmailTool, buildTranscriptForLeadEmail, detectChatLeadIntent, emailPlugin, emailTemplates, joinRecipientsForSend, parseEmailRecipientsFromConfig, parseIntentRecipientEmails, renderEmail, renderLayout, resolveChatEmailToolSettings, sendChatLeadEmail, serializeEmailRecipients };
+export { CHAT_EMAIL_LOG, EmailService, WhatsAppService, buildChatbotSystemPromptWithEmailTool, buildEventOrderTemplateVariables, buildTranscriptForLeadEmail, detectChatLeadIntent, emailPlugin, emailTemplates, getSettingsGroup, initWhatsappTriggerDispatcher, isWhatsAppPluginEnabled, joinRecipientsForSend, mergeWhatsAppConfigLayers, parseEmailRecipientsFromConfig, parseIntentRecipientEmails, queueWhatsApp, registerWhatsAppQueueProcessor, renderEmail, renderLayout, resendOrderNotification, resolveChatEmailToolSettings, sendChatLeadEmail, sendFcmPushNotification, serializeEmailRecipients, validateFcmCredentials, whatsAppConfigured };