@vicacha-devs/strapi-plugin-inbox 0.0.0-stage → 1.0.0

package/dist/server/index.mjs

@@ -0,0 +1,3108 @@
+import { randomBytes } from "node:crypto";
+const PLUGIN_ID = "inbox";
+const FORM_BUILDER_CMS_PLUGIN_ID = "strapi-plugin-form-builder-cms";
+const FORM_BUILDER_CMS_FORM_UID = `plugin::${FORM_BUILDER_CMS_PLUGIN_ID}.form`;
+const FORM_BUILDER_CMS_SUBMISSION_UID = `plugin::${FORM_BUILDER_CMS_PLUGIN_ID}.form-submission`;
+const SUBMISSION_UID = `plugin::${PLUGIN_ID}.submission`;
+const SUBSCRIBER_UID = `plugin::${PLUGIN_ID}.subscriber`;
+const ALERT_BANNER_UID = `plugin::${PLUGIN_ID}.alert-banner`;
+const DECORATIVE_FIELD_TYPES = [
+  "heading",
+  "paragraph",
+  "divider"
+];
+const CAPTCHA_ENDPOINTS = {
+  turnstile: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+  recaptcha: "https://www.google.com/recaptcha/api/siteverify"
+};
+const DEFAULT_INBOX_SETTINGS = {
+  primaryCalendar: "gregory",
+  secondaryCalendars: ["islamic-umalqura"],
+  defaultLocale: "es",
+  supportedLocales: ["es", "en", "ar"],
+  defaultRateLimitPerHour: 15,
+  defaultHoneypotField: "_website_url",
+  defaultCaptchaProvider: "none",
+  turnstileSiteKey: "",
+  turnstileSecretKey: "",
+  recaptchaSiteKey: "",
+  recaptchaSecretKey: "",
+  enableDoubleOptIn: true,
+  availableTopics: ["announcements", "events", "courses", "newsletter"],
+  availableDepartments: [
+    "general",
+    "administration",
+    "services",
+    "education",
+    "social_aid"
+  ],
+  enableFormBuilderBridge: true,
+  autoSyncFormBuilderForms: true,
+  enableBookingBridge: true,
+  enableCertificateBridge: true,
+  defaultNotifyEmails: [],
+  outboundWebhookUrl: ""
+};
+function isValidEmail(value) {
+  if (/\s/.test(value))
+    return false;
+  const at = value.indexOf("@");
+  if (at < 1 || at !== value.lastIndexOf("@"))
+    return false;
+  const domain = value.slice(at + 1);
+  const dot = domain.indexOf(".");
+  return dot > 0 && dot < domain.length - 1;
+}
+function freezeOptions(items) {
+  return Object.freeze(items.map((item) => Object.freeze({ ...item })));
+}
+freezeOptions([
+  { value: "es", label: "es — Español (Spanish)" },
+  { value: "en", label: "en — English" },
+  { value: "ar", label: "ar — العربية (Arabic)" },
+  { value: "tr", label: "tr — Türkçe (Turkish)" },
+  { value: "fr", label: "fr — Français (French)" },
+  { value: "de", label: "de — Deutsch (German)" },
+  { value: "pt", label: "pt — Português (Portuguese)" },
+  { value: "it", label: "it — Italiano (Italian)" },
+  { value: "nl", label: "nl — Nederlands (Dutch)" },
+  { value: "pl", label: "pl — Polski (Polish)" },
+  { value: "ru", label: "ru — Русский (Russian)" },
+  { value: "id", label: "id — Bahasa Indonesia" },
+  { value: "ur", label: "ur — اردو (Urdu)" },
+  { value: "zh", label: "zh — 中文 (Chinese)" }
+]);
+freezeOptions([
+  {
+    value: "islamic-umalqura",
+    label: "islamic-umalqura (Hijri Umm al-Qura)"
+  },
+  { value: "islamic-civil", label: "islamic-civil (Tabular Islamic Civil)" },
+  { value: "islamic-tbla", label: "islamic-tbla (Tabular Astronomical)" },
+  { value: "hebrew", label: "hebrew (Hebrew)" },
+  { value: "persian", label: "persian (Solar Hijri)" },
+  { value: "none", label: "none (Gregorian Only)" }
+]);
+const LOCALIZED_REQUIRED_FALLBACK = {
+  es: (label) => `${label} es obligatorio`,
+  en: (label) => `${label} is required`,
+  ar: (label) => `${label} مطلوب`
+};
+function isValueEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "boolean") return value === false;
+  return false;
+}
+function resolveRuleMessage(rule, locale, fallback) {
+  if (!rule) return fallback;
+  if (rule.localizedMessages && rule.localizedMessages[locale]) {
+    return rule.localizedMessages[locale];
+  }
+  if (rule.message) return rule.message;
+  return fallback;
+}
+function isValidHttpUrl(strVal) {
+  try {
+    const parsed = new URL(strVal);
+    return ["http:", "https:"].includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function checkFieldOptions(field, rawValue, strVal, fieldLabel) {
+  if (!Array.isArray(field.options) || field.options.length === 0) return null;
+  const allowed = new Set(field.options.map((o) => o.value));
+  if (field.type === "select" || field.type === "radio") {
+    return allowed.has(strVal) ? null : `${fieldLabel} contains an invalid selection`;
+  }
+  if (field.type === "checkbox-group") {
+    const values = Array.isArray(rawValue) ? rawValue.map(String) : [strVal];
+    return values.some((v) => !allowed.has(v)) ? `${fieldLabel} contains an invalid selection` : null;
+  }
+  return null;
+}
+function validateFieldTypeAndOptions(field, rawValue, strVal, fieldLabel, locale, rules) {
+  const fieldErrors = [];
+  if (field.type === "email" && !isValidEmail(strVal)) {
+    const emailRule = rules.find((r) => r.type === "email");
+    fieldErrors.push(
+      resolveRuleMessage(
+        emailRule,
+        locale,
+        `${fieldLabel} must be a valid email address`
+      )
+    );
+  }
+  if (field.type === "url" && !isValidHttpUrl(strVal)) {
+    const urlRule = rules.find((r) => r.type === "url");
+    fieldErrors.push(
+      resolveRuleMessage(urlRule, locale, `${fieldLabel} must be a valid URL`)
+    );
+  }
+  const optError = checkFieldOptions(field, rawValue, strVal, fieldLabel);
+  if (optError) fieldErrors.push(optError);
+  return fieldErrors;
+}
+function checkLengthRule(rule, limit, strVal, fieldLabel, locale) {
+  if (rule.type === "minLength" && strVal.length < limit) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at least ${limit} characters`
+    );
+  }
+  if (rule.type === "maxLength" && strVal.length > limit) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at most ${limit} characters`
+    );
+  }
+  return null;
+}
+function checkNumericBoundRule(rule, limit, rawValue, fieldLabel, locale) {
+  const num = Number(rawValue);
+  if (rule.type === "min" && (Number.isNaN(num) || num < limit)) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at least ${limit}`
+    );
+  }
+  if (rule.type === "max" && (Number.isNaN(num) || num > limit)) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at most ${limit}`
+    );
+  }
+  return null;
+}
+function checkLengthOrNumberRule(rule, rawValue, strVal, fieldLabel, locale) {
+  if (typeof rule.value !== "number") return null;
+  return checkLengthRule(rule, rule.value, strVal, fieldLabel, locale) ?? checkNumericBoundRule(rule, rule.value, rawValue, fieldLabel, locale);
+}
+function checkPatternOrEmailRule(rule, fieldType, strVal, fieldLabel, locale) {
+  if (rule.type === "pattern" && typeof rule.value === "string") {
+    try {
+      const regex = new RegExp(rule.value);
+      if (!regex.test(strVal)) {
+        return resolveRuleMessage(
+          rule,
+          locale,
+          `${fieldLabel} format is invalid`
+        );
+      }
+    } catch {
+    }
+  }
+  if (rule.type === "email" && fieldType !== "email" && !isValidEmail(strVal)) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be a valid email address`
+    );
+  }
+  return null;
+}
+function evaluateCustomRules(field, rawValue, strVal, fieldLabel, locale, rules) {
+  const errors = [];
+  for (const rule of rules) {
+    if (rule.type === "required") continue;
+    const lenOrNumErr = checkLengthOrNumberRule(
+      rule,
+      rawValue,
+      strVal,
+      fieldLabel,
+      locale
+    );
+    if (lenOrNumErr) errors.push(lenOrNumErr);
+    const patOrEmailErr = checkPatternOrEmailRule(
+      rule,
+      field.type,
+      strVal,
+      fieldLabel,
+      locale
+    );
+    if (patOrEmailErr) errors.push(patOrEmailErr);
+  }
+  return errors;
+}
+function resolveFieldLabel(field, locale) {
+  return field.localizedLabels?.[locale] || field.label || field.name;
+}
+function buildRequiredError(rules, locale, fieldLabel) {
+  const reqRule = rules.find((r) => r.type === "required");
+  const fallbackFn = LOCALIZED_REQUIRED_FALLBACK[locale] || LOCALIZED_REQUIRED_FALLBACK.en;
+  return resolveRuleMessage(reqRule, locale, fallbackFn(fieldLabel));
+}
+function validateSingleField(field, data, locale) {
+  const rawValue = data[field.name] ?? field.defaultValue;
+  const fieldLabel = resolveFieldLabel(field, locale);
+  const rules = field.validation || [];
+  if (field.required && isValueEmpty(rawValue)) {
+    return {
+      fieldErrors: [buildRequiredError(rules, locale, fieldLabel)],
+      cleanedValue: null
+    };
+  }
+  if (isValueEmpty(rawValue)) {
+    return { fieldErrors: [], cleanedValue: rawValue ?? null };
+  }
+  const strVal = typeof rawValue === "string" ? rawValue.trim() : String(rawValue);
+  const fieldErrors = [
+    ...validateFieldTypeAndOptions(
+      field,
+      rawValue,
+      strVal,
+      fieldLabel,
+      locale,
+      rules
+    ),
+    ...evaluateCustomRules(field, rawValue, strVal, fieldLabel, locale, rules)
+  ];
+  return {
+    fieldErrors,
+    cleanedValue: typeof rawValue === "string" ? strVal : rawValue
+  };
+}
+function validateFormSubmission(fields, data, locale = "en") {
+  const errors = {};
+  const cleanedData = {};
+  for (const field of fields) {
+    if (DECORATIVE_FIELD_TYPES.includes(field.type)) continue;
+    const { fieldErrors, cleanedValue } = validateSingleField(
+      field,
+      data,
+      locale
+    );
+    if (fieldErrors.length > 0) {
+      errors[field.name] = fieldErrors;
+    } else {
+      cleanedData[field.name] = cleanedValue;
+    }
+  }
+  return {
+    valid: Object.keys(errors).length === 0,
+    errors,
+    cleanedData
+  };
+}
+function isHoneypotTriggered(payload, honeypotField = "_website_url") {
+  if (!honeypotField) return false;
+  const val = payload[honeypotField];
+  return typeof val === "string" && val.trim().length > 0;
+}
+class SlidingWindowRateLimiter {
+  hits = /* @__PURE__ */ new Map();
+  check(ip, bucketKey, limitPerHour, nowMs = Date.now()) {
+    if (limitPerHour <= 0) {
+      return { allowed: true, remaining: 999, retryAfterSeconds: 0 };
+    }
+    const windowMs = 60 * 60 * 1e3;
+    const key = `${bucketKey}::${ip || "unknown"}`;
+    const cutoff = nowMs - windowMs;
+    const previous = (this.hits.get(key) || []).filter((ts) => ts > cutoff);
+    if (previous.length >= limitPerHour) {
+      const oldest = previous[0] ?? nowMs;
+      const retryAfterSeconds = Math.max(
+        1,
+        Math.ceil((oldest + windowMs - nowMs) / 1e3)
+      );
+      this.hits.set(key, previous);
+      return {
+        allowed: false,
+        remaining: 0,
+        retryAfterSeconds
+      };
+    }
+    previous.push(nowMs);
+    this.hits.set(key, previous);
+    return {
+      allowed: true,
+      remaining: Math.max(0, limitPerHour - previous.length),
+      retryAfterSeconds: 0
+    };
+  }
+  reset() {
+    this.hits.clear();
+  }
+}
+const defaultRateLimiter = new SlidingWindowRateLimiter();
+function resolveFetchRunner(fetchImpl) {
+  return fetchImpl ?? globalThis.fetch;
+}
+async function postCaptchaVerify(runner, url, params) {
+  try {
+    const res = await runner(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: params.toString()
+    });
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function verifyCaptchaToken(provider, secret, token, ip = "", fetchImpl) {
+  if (provider === "none") return true;
+  const url = CAPTCHA_ENDPOINTS[provider];
+  const trimmedSecret = (secret || "").trim();
+  const trimmedToken = (token || "").trim();
+  const runner = resolveFetchRunner(fetchImpl);
+  if (!url || !trimmedSecret || !trimmedToken || !runner) return false;
+  const params = new URLSearchParams({
+    secret: trimmedSecret,
+    response: trimmedToken
+  });
+  if (ip) params.append("remoteip", ip);
+  const json = await postCaptchaVerify(runner, url, params);
+  return Boolean(json?.success);
+}
+async function testCaptchaSecretKey(provider, secret, fetchImpl) {
+  if (provider === "none") return { ok: true };
+  const url = CAPTCHA_ENDPOINTS[provider];
+  if (!url) return { ok: false, reason: "Unknown CAPTCHA provider" };
+  const trimmedSecret = (secret || "").trim();
+  if (!trimmedSecret) return { ok: false, reason: "Secret key is empty" };
+  const runner = resolveFetchRunner(fetchImpl);
+  if (!runner) return { ok: false, reason: "Fetch implementation unavailable" };
+  const params = new URLSearchParams({
+    secret: trimmedSecret,
+    response: "test-token"
+  });
+  const json = await postCaptchaVerify(runner, url, params);
+  if (!json) {
+    return { ok: false, reason: "Could not reach the CAPTCHA provider" };
+  }
+  const codes = json["error-codes"] || [];
+  if (codes.includes("invalid-input-secret") || codes.includes("missing-input-secret")) {
+    return { ok: false, reason: "Secret key is invalid" };
+  }
+  return { ok: true };
+}
+const STARTER_FORM_TEMPLATES = [
+  {
+    id: "general-contact",
+    name: "General Contact & Inquiry",
+    description: "Multi-language contact form with subject routing and anti-spam protection.",
+    form: {
+      title: "General Contact",
+      slug: "general-contact",
+      description: "Send us a message and our team will respond promptly.",
+      category: "contact",
+      active: true,
+      publishedAt: "2026-01-01T00:00:00.000Z",
+      translations: {
+        es: {
+          title: "Contacto General",
+          description: "Envíanos un mensaje y nuestro equipo te responderá pronto.",
+          submitButtonLabel: "Enviar mensaje",
+          successMessage: "Gracias por contactarnos. Hemos recibido tu mensaje."
+        },
+        en: {
+          title: "General Contact",
+          description: "Send us a message and our team will respond promptly.",
+          submitButtonLabel: "Send message",
+          successMessage: "Thank you for reaching out. We have received your message."
+        },
+        ar: {
+          title: "الاتصال العام",
+          description: "أرسل لنا رسالة وسيرد فريقنا في أقرب وقت.",
+          submitButtonLabel: "إرسال الرسالة",
+          successMessage: "شكراً لتواصلك معنا. لقد استلمنا رسالتك."
+        }
+      },
+      fields: [
+        {
+          id: "fld_full_name",
+          type: "text",
+          name: "fullName",
+          label: "Full Name",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Nombre completo",
+            en: "Full Name",
+            ar: "الاسم الكامل"
+          },
+          validation: [{ type: "minLength", value: 2 }]
+        },
+        {
+          id: "fld_email",
+          type: "email",
+          name: "email",
+          label: "Email Address",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Correo electrónico",
+            en: "Email Address",
+            ar: "البريد الإلكتروني"
+          }
+        },
+        {
+          id: "fld_phone",
+          type: "phone",
+          name: "phone",
+          label: "Phone / WhatsApp",
+          required: false,
+          width: "half",
+          localizedLabels: {
+            es: "Teléfono / WhatsApp",
+            en: "Phone / WhatsApp",
+            ar: "الهاتف / واتساب"
+          }
+        },
+        {
+          id: "fld_subject",
+          type: "select",
+          name: "subject",
+          label: "Subject",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Asunto",
+            en: "Subject",
+            ar: "الموضوع"
+          },
+          options: [
+            {
+              value: "general",
+              label: "General Inquiry",
+              localizedLabels: {
+                es: "Consulta general",
+                en: "General Inquiry",
+                ar: "استفسار عام"
+              }
+            },
+            {
+              value: "visit",
+              label: "Guided Visit",
+              localizedLabels: {
+                es: "Visita guiada",
+                en: "Guided Visit",
+                ar: "زيارة إرشادية"
+              }
+            },
+            {
+              value: "support",
+              label: "Support & Assistance",
+              localizedLabels: {
+                es: "Apoyo y asistencia",
+                en: "Support & Assistance",
+                ar: "الدعم والمساعدة"
+              }
+            }
+          ]
+        },
+        {
+          id: "fld_message",
+          type: "textarea",
+          name: "message",
+          label: "Message",
+          required: true,
+          width: "full",
+          localizedLabels: {
+            es: "Mensaje",
+            en: "Message",
+            ar: "الرسالة"
+          },
+          validation: [
+            { type: "minLength", value: 10 },
+            { type: "maxLength", value: 2e3 }
+          ]
+        }
+      ],
+      settings: {
+        honeypotField: "_website_url",
+        rateLimitPerHour: 15,
+        captchaProvider: "none",
+        defaultPriority: "normal",
+        department: "general"
+      }
+    }
+  },
+  {
+    id: "service-desk-application",
+    name: "Service-Desk Casework & Document Checklist",
+    description: "Casework intake form with document verification checklist, booking bridge, and certificate bridge.",
+    form: {
+      title: "Formal Service Request",
+      slug: "service-request",
+      description: "Submit an official service application and required supporting documents.",
+      category: "service_desk",
+      active: true,
+      publishedAt: "2026-01-01T00:00:00.000Z",
+      translations: {
+        es: {
+          title: "Solicitud Formal de Servicio",
+          description: "Envía una solicitud oficial de servicio con los documentos requeridos.",
+          submitButtonLabel: "Radicar solicitud",
+          successMessage: "Tu solicitud ha sido radicada con éxito."
+        },
+        en: {
+          title: "Formal Service Request",
+          description: "Submit an official service application and required supporting documents.",
+          submitButtonLabel: "Submit application",
+          successMessage: "Your application has been registered."
+        },
+        ar: {
+          title: "طلب خدمة رسمي",
+          description: "قدم طلب خدمة رسمي مع المستندات المطلوبة.",
+          submitButtonLabel: "تقديم الطلب",
+          successMessage: "تم تسجيل طلبك بنجاح."
+        }
+      },
+      fields: [
+        {
+          id: "fld_applicant_name",
+          type: "text",
+          name: "applicantName",
+          label: "Applicant Full Name",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Nombre completo del solicitante",
+            en: "Applicant Full Name",
+            ar: "الاسم الكامل لمقدم الطلب"
+          }
+        },
+        {
+          id: "fld_applicant_email",
+          type: "email",
+          name: "applicantEmail",
+          label: "Applicant Email",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Correo del solicitante",
+            en: "Applicant Email",
+            ar: "البريد الإلكتروني لمقدم الطلب"
+          }
+        },
+        {
+          id: "fld_applicant_phone",
+          type: "phone",
+          name: "applicantPhone",
+          label: "Contact Phone",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Teléfono de contacto",
+            en: "Contact Phone",
+            ar: "هاتف الاتصال"
+          }
+        },
+        {
+          id: "fld_preferred_date",
+          type: "date",
+          name: "preferredDate",
+          label: "Preferred Appointment Date",
+          required: false,
+          width: "half",
+          localizedLabels: {
+            es: "Fecha preferida de cita",
+            en: "Preferred Appointment Date",
+            ar: "تاريخ الموعد المفضل"
+          }
+        },
+        {
+          id: "fld_details",
+          type: "textarea",
+          name: "details",
+          label: "Case Details & Notes",
+          required: true,
+          width: "full",
+          localizedLabels: {
+            es: "Detalles del caso y observaciones",
+            en: "Case Details & Notes",
+            ar: "تفاصيل الطلب والملاحظات"
+          }
+        }
+      ],
+      checklistTemplate: [
+        {
+          id: "chk_id_document",
+          label: "Government ID / Passport Copy",
+          required: true,
+          verified: false,
+          localizedLabels: {
+            es: "Copia de documento de identidad / Pasaporte",
+            en: "Government ID / Passport Copy",
+            ar: "نسخة من بطاقة الهوية أو جواز السفر"
+          }
+        },
+        {
+          id: "chk_supporting_form",
+          label: "Signed Application Form",
+          required: true,
+          verified: false,
+          localizedLabels: {
+            es: "Formulario de solicitud firmado",
+            en: "Signed Application Form",
+            ar: "نموذج الطلب الموقع"
+          }
+        }
+      ],
+      settings: {
+        honeypotField: "_website_url",
+        rateLimitPerHour: 10,
+        captchaProvider: "none",
+        enableBookingBridge: true,
+        enableCertificateBridge: true,
+        defaultPriority: "normal",
+        department: "services"
+      }
+    }
+  }
+];
+function localizeFormForLocale(form, locale) {
+  const tr = form.translations?.[locale];
+  const localizedFields = (form.fields || []).map((field) => ({
+    ...field,
+    label: field.localizedLabels?.[locale] || field.label,
+    placeholder: field.localizedPlaceholders?.[locale] || field.placeholder,
+    helpText: field.localizedHelpTexts?.[locale] || field.helpText,
+    options: field.options?.map((opt) => ({
+      ...opt,
+      label: opt.localizedLabels?.[locale] || opt.label
+    }))
+  }));
+  const localizedChecklist = form.checklistTemplate?.map((item) => ({
+    ...item,
+    label: item.localizedLabels?.[locale] || item.label
+  }));
+  return {
+    ...form,
+    title: tr?.title || form.title,
+    description: tr?.description || form.description,
+    fields: localizedFields,
+    checklistTemplate: localizedChecklist,
+    settings: {
+      ...form.settings,
+      submitButtonLabel: tr?.submitButtonLabel || form.settings?.localizedSubmitLabels?.[locale] || form.settings?.submitButtonLabel,
+      successMessage: tr?.successMessage || form.settings?.localizedSuccessMessages?.[locale] || form.settings?.successMessage
+    }
+  };
+}
+const FORMULA_PREFIXES = ["=", "+", "-", "@", "	", "\r"];
+function escapeCsvCell(value) {
+  if (value === null || value === void 0) return "";
+  const raw = typeof value === "object" ? JSON.stringify(value) : String(value);
+  const sanitized = raw.length > 0 && FORMULA_PREFIXES.includes(raw[0]) ? `'${raw}` : raw;
+  if (sanitized.includes('"') || sanitized.includes(",") || sanitized.includes("\n") || sanitized.includes("\r")) {
+    return `"${sanitized.replace(/"/g, '""')}"`;
+  }
+  return sanitized;
+}
+function collectDataFieldNames(submissions, fields) {
+  const dataFieldNames = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (!DECORATIVE_FIELD_TYPES.includes(field.type) && !seen.has(field.name)) {
+      seen.add(field.name);
+      dataFieldNames.push(field.name);
+    }
+  }
+  for (const sub of submissions) {
+    for (const key of Object.keys(sub.data || {})) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        dataFieldNames.push(key);
+      }
+    }
+  }
+  return dataFieldNames;
+}
+function getBaseSubmissionValues(sub) {
+  return [
+    sub.referenceCode,
+    sub.formSlug,
+    sub.status,
+    sub.priority,
+    sub.department ?? "",
+    sub.locale,
+    sub.applicantName ?? "",
+    sub.applicantEmail ?? "",
+    sub.applicantPhone ?? "",
+    sub.submittedAt,
+    sub.secondaryDate?.formatted ?? "",
+    sub.linkedBookingId ?? "",
+    sub.linkedCertificateNumber ?? ""
+  ];
+}
+const BASE_CSV_HEADERS = [
+  "referenceCode",
+  "formSlug",
+  "status",
+  "priority",
+  "department",
+  "locale",
+  "applicantName",
+  "applicantEmail",
+  "applicantPhone",
+  "submittedAt",
+  "secondaryDate",
+  "linkedBookingId",
+  "linkedCertificateNumber"
+];
+function submissionsToCsv(submissions, fields = []) {
+  const dataFieldNames = collectDataFieldNames(submissions, fields);
+  const headers = [...BASE_CSV_HEADERS, ...dataFieldNames];
+  const rows = [headers.map(escapeCsvCell).join(",")];
+  for (const sub of submissions) {
+    const baseValues = getBaseSubmissionValues(sub);
+    const dynamicValues = dataFieldNames.map((name) => sub.data?.[name] ?? "");
+    rows.push([...baseValues, ...dynamicValues].map(escapeCsvCell).join(","));
+  }
+  return rows.join("\n");
+}
+function convertIsoDateToCalendar(isoDateString, calendar = "islamic-umalqura", locale = "en") {
+  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)
+    };
+  }
+}
+let mirroringToFormBuilderCms = false;
+function generateReferenceCode(now = /* @__PURE__ */ new Date()) {
+  const datePart = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const randPart = randomBytes(3).toString("hex").toUpperCase();
+  return `INB-${datePart}-${randPart}`;
+}
+async function mirrorSubmissionToFormBuilderCms(strapi, params) {
+  const { settings: settings2, form, cleanedData, ip, userAgent } = params;
+  if (settings2.enableFormBuilderBridge === false || !form.formBuilderId || typeof strapi.db?.query !== "function" || !(strapi.contentTypes?.[FORM_BUILDER_CMS_SUBMISSION_UID] || Boolean(
+    strapi.__hasFormBuilderCms
+  ))) {
+    return null;
+  }
+  try {
+    mirroringToFormBuilderCms = true;
+    const fieldsSnapshot = (form.fields || []).filter((f) => !DECORATIVE_FIELD_TYPES.includes(f.type)).map((f, idx) => ({
+      name: f.name,
+      label: f.label,
+      type: f.type,
+      order: idx,
+      options: f.options
+    }));
+    const cmsSub = await strapi.db.query(FORM_BUILDER_CMS_SUBMISSION_UID).create({
+      data: {
+        form: form.formBuilderId,
+        data: cleanedData,
+        fields: fieldsSnapshot,
+        ipAddress: ip,
+        userAgent,
+        status: "new"
+      }
+    });
+    return cmsSub?.id ? Number(cmsSub.id) : null;
+  } catch {
+    return null;
+  } finally {
+    mirroringToFormBuilderCms = false;
+  }
+}
+function extractFormRelationObject(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  if (Array.isArray(raw)) {
+    return raw.length > 0 ? extractFormRelationObject(raw[0]) : null;
+  }
+  const obj = raw;
+  if (Array.isArray(obj.connect) && obj.connect.length > 0) {
+    return extractFormRelationObject(obj.connect[0]);
+  }
+  if (Array.isArray(obj.set) && obj.set.length > 0) {
+    return extractFormRelationObject(obj.set[0]);
+  }
+  return obj;
+}
+function resolveCmsSubmissionFormRef(cmsSubmission, meta) {
+  let formId = meta?.formId ?? null;
+  let formSlug = meta?.formSlug ?? "";
+  const rawFormRel = cmsSubmission.form;
+  if (typeof rawFormRel === "number") {
+    formId = rawFormRel;
+  } else if (typeof rawFormRel === "string" && /^\d+$/.test(rawFormRel.trim())) {
+    formId = Number(rawFormRel.trim());
+  } else {
+    const relObj = extractFormRelationObject(rawFormRel);
+    if (relObj?.id) formId = Number(relObj.id);
+    if (relObj?.slug) formSlug = String(relObj.slug);
+  }
+  return { formId, formSlug };
+}
+async function fetchPopulatedCmsSubmissionFormRef(strapi, cmsSubId) {
+  if (cmsSubId === null || typeof strapi.db?.query !== "function") {
+    return { formId: null, formSlug: "" };
+  }
+  try {
+    const populated = await strapi.db.query(FORM_BUILDER_CMS_SUBMISSION_UID).findOne({
+      where: { id: cmsSubId },
+      populate: ["form"]
+    });
+    return populated ? resolveCmsSubmissionFormRef(populated) : { formId: null, formSlug: "" };
+  } catch {
+    return { formId: null, formSlug: "" };
+  }
+}
+async function resolveTargetInboxForm(strapi, formService2, formId, formSlug) {
+  if (formId !== null && typeof strapi.db?.query === "function") {
+    const cmsForm = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).findOne({ where: { id: formId } });
+    if (cmsForm) {
+      const synced = await formService2.syncFormFromBuilderCms(cmsForm);
+      if (synced) return synced;
+    }
+  }
+  return formSlug ? formService2.findBySlug(formSlug) : null;
+}
+function firstNonEmptyString(...values) {
+  for (const val of values) {
+    if (val !== void 0 && val !== null) {
+      const str = String(val).trim();
+      if (str.length > 0) return str;
+    }
+  }
+  return void 0;
+}
+function extractApplicantDetails(rawData) {
+  const firstLast = [rawData.firstName, rawData.lastName].filter(Boolean).join(" ").trim();
+  return {
+    applicantName: firstNonEmptyString(
+      rawData.applicantName,
+      rawData.fullName,
+      rawData.name,
+      firstLast
+    ),
+    applicantEmail: firstNonEmptyString(rawData.applicantEmail, rawData.email),
+    applicantPhone: firstNonEmptyString(
+      rawData.applicantPhone,
+      rawData.phone,
+      rawData.tel
+    )
+  };
+}
+function extractRawSubmissionData(cmsSubmission) {
+  const raw = cmsSubmission.data;
+  if (raw && typeof raw === "object") {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object")
+        return parsed;
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function parseTimestampValue(raw) {
+  if (typeof raw === "number") return new Date(raw);
+  if (raw instanceof Date) return raw;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    return /^\d+$/.test(trimmed) ? new Date(Number(trimmed)) : new Date(trimmed);
+  }
+  return null;
+}
+function resolveIngestionTimestamp(cmsSubmission, nowMs) {
+  const raw = cmsSubmission.createdAt ?? cmsSubmission.created_at;
+  const parsed = parseTimestampValue(raw);
+  if (parsed && !Number.isNaN(parsed.getTime())) {
+    return parsed.toISOString();
+  }
+  return new Date(nowMs ?? Date.now()).toISOString();
+}
+function buildIngestedSubmissionPayload(params) {
+  const { cmsSubmission, inboxForm, formSlug, cmsSubId, settings: settings2, nowMs } = params;
+  const rawData = extractRawSubmissionData(cmsSubmission);
+  const applicant = extractApplicantDetails(rawData);
+  const locale = firstNonEmptyString(
+    rawData.locale,
+    settings2.defaultLocale,
+    "es"
+  );
+  const nowIso = resolveIngestionTimestamp(cmsSubmission, nowMs);
+  const secondaryCal = firstNonEmptyString(
+    settings2.secondaryCalendars?.[0],
+    "islamic-umalqura"
+  );
+  const converted = convertIsoDateToCalendar(
+    nowIso.slice(0, 10),
+    secondaryCal,
+    locale
+  );
+  const templateItems = inboxForm?.checklistTemplate;
+  const checklistItems = (templateItems ? templateItems : []).map((item) => ({
+    ...item,
+    verified: false
+  }));
+  const resolvedSlug = firstNonEmptyString(
+    inboxForm?.slug,
+    formSlug,
+    "visual-form"
+  );
+  return {
+    resolvedSlug,
+    submissionData: {
+      referenceCode: generateReferenceCode(new Date(nowIso)),
+      formSlug: resolvedSlug,
+      formTitle: firstNonEmptyString(inboxForm?.title, resolvedSlug),
+      category: firstNonEmptyString(
+        inboxForm?.category,
+        "contact"
+      ),
+      status: "new",
+      priority: firstNonEmptyString(
+        inboxForm?.settings?.defaultPriority,
+        "normal"
+      ),
+      department: firstNonEmptyString(
+        inboxForm?.settings?.department,
+        "general"
+      ),
+      locale,
+      ...applicant,
+      data: rawData,
+      checklistItems,
+      formBuilderSubmissionId: cmsSubId,
+      ipAddress: firstNonEmptyString(cmsSubmission.ipAddress, "127.0.0.1"),
+      userAgent: firstNonEmptyString(cmsSubmission.userAgent) || "",
+      submittedAt: nowIso,
+      secondaryDate: {
+        formatted: converted.formatted,
+        year: converted.year,
+        month: converted.month,
+        day: converted.day
+      }
+    }
+  };
+}
+async function findExistingByCmsSubId(strapi, cmsSubId) {
+  if (cmsSubId === null) return null;
+  const existingSub = await strapi.documents(SUBMISSION_UID).findMany({
+    filters: { formBuilderSubmissionId: cmsSubId },
+    limit: 1
+  });
+  return existingSub && existingSub.length > 0 ? existingSub[0] : null;
+}
+async function resolveSubmissionFormContext(strapi, formService2, cmsSubmission, cmsSubId, meta) {
+  let { formId, formSlug } = resolveCmsSubmissionFormRef(cmsSubmission, meta);
+  if (formId === null && !formSlug) {
+    const populatedRef = await fetchPopulatedCmsSubmissionFormRef(
+      strapi,
+      cmsSubId
+    );
+    formId = populatedRef.formId;
+    formSlug = populatedRef.formSlug;
+  }
+  const inboxForm = await resolveTargetInboxForm(
+    strapi,
+    formService2,
+    formId,
+    formSlug
+  );
+  return { formSlug, inboxForm };
+}
+async function ingestFormBuilderSubmission(strapi, cmsSubmission, meta) {
+  if (mirroringToFormBuilderCms || !cmsSubmission) return null;
+  const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+  const formService2 = strapi.plugin(PLUGIN_ID).service("formService");
+  const settings2 = await settingsService.getSettings();
+  if (settings2.enableFormBuilderBridge === false) return null;
+  const cmsSubId = cmsSubmission.id ? Number(cmsSubmission.id) : null;
+  const existing = await findExistingByCmsSubId(strapi, cmsSubId);
+  if (existing) return existing;
+  const { formSlug, inboxForm } = await resolveSubmissionFormContext(
+    strapi,
+    formService2,
+    cmsSubmission,
+    cmsSubId,
+    meta
+  );
+  const { resolvedSlug, submissionData } = buildIngestedSubmissionPayload({
+    cmsSubmission,
+    inboxForm,
+    formSlug,
+    cmsSubId,
+    settings: settings2,
+    nowMs: meta?.nowMs
+  });
+  const created = await strapi.documents(SUBMISSION_UID).create({
+    data: submissionData
+  });
+  strapi.eventHub?.emit("inbox.submission.created", {
+    submission: created,
+    formSlug: resolvedSlug,
+    source: "strapi-plugin-form-builder-cms"
+  });
+  return created;
+}
+function canQueryFormBuilderSubmissions(strapi) {
+  return typeof strapi.db?.query === "function" && Boolean(
+    strapi.contentTypes?.[FORM_BUILDER_CMS_SUBMISSION_UID] || strapi.__hasFormBuilderCms
+  );
+}
+async function syncSubmissionsFromFormBuilderCms(strapi) {
+  if (mirroringToFormBuilderCms || !canQueryFormBuilderSubmissions(strapi))
+    return 0;
+  try {
+    const cmsSubmissions = await strapi.db.query(FORM_BUILDER_CMS_SUBMISSION_UID).findMany({
+      populate: ["form"],
+      orderBy: { createdAt: "asc" }
+    });
+    let syncedCount = 0;
+    for (const cmsSub of cmsSubmissions || []) {
+      const sub = await ingestFormBuilderSubmission(strapi, cmsSub);
+      if (sub) syncedCount += 1;
+    }
+    return syncedCount;
+  } catch {
+    return 0;
+  }
+}
+async function registerPluginPermissions(strapi) {
+  if (!strapi.admin?.services?.permission?.actionProvider?.registerMany) return;
+  await strapi.admin.services.permission.actionProvider.registerMany([
+    {
+      section: "plugins",
+      displayName: "Manage Forms & Builder",
+      uid: "forms.manage",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Manage Submissions & Casework",
+      uid: "submissions.manage",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Manage Subscribers & Alert Banners",
+      uid: "subscribers.manage",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Manage Inbox Settings",
+      uid: "settings.manage",
+      pluginName: PLUGIN_ID
+    }
+  ]);
+}
+function mergePresetFieldOptions(existingOptions, presetOptions) {
+  if (!existingOptions) return void 0;
+  return existingOptions.map((eo) => {
+    const po = presetOptions?.find((o) => o.value === eo.value);
+    const localizedLabels = eo.localizedLabels || po?.localizedLabels;
+    return localizedLabels ? { ...eo, localizedLabels } : { ...eo };
+  });
+}
+function mergePresetField(ef, presetFields) {
+  const pf = presetFields?.find((f) => f.id === ef.id || f.name === ef.name);
+  if (!pf) return ef;
+  return {
+    ...pf,
+    ...ef,
+    localizedLabels: ef.localizedLabels || pf.localizedLabels,
+    localizedPlaceholders: ef.localizedPlaceholders || pf.localizedPlaceholders,
+    localizedHelpTexts: ef.localizedHelpTexts || pf.localizedHelpTexts,
+    options: mergePresetFieldOptions(ef.options, pf.options)
+  };
+}
+function pickFirst(...vals) {
+  for (const v of vals) {
+    if (v !== void 0 && v !== null) return v;
+  }
+  return vals[vals.length - 1];
+}
+function pickNonDefault(val, fallback, defaultVal) {
+  if (val && val !== defaultVal) return val;
+  return fallback || defaultVal;
+}
+function mergePresetSettings(existingSettings, presetSettings) {
+  return {
+    ...pickFirst(presetSettings, {}),
+    ...pickFirst(existingSettings, {}),
+    department: pickNonDefault(
+      existingSettings?.department,
+      presetSettings?.department,
+      "general"
+    ),
+    defaultPriority: pickNonDefault(
+      existingSettings?.defaultPriority,
+      presetSettings?.defaultPriority,
+      "normal"
+    ),
+    enableBookingBridge: pickFirst(
+      existingSettings?.enableBookingBridge,
+      presetSettings?.enableBookingBridge
+    ),
+    enableCertificateBridge: pickFirst(
+      existingSettings?.enableCertificateBridge,
+      presetSettings?.enableCertificateBridge
+    ),
+    defaultBookingServiceSlug: pickFirst(
+      existingSettings?.defaultBookingServiceSlug,
+      presetSettings?.defaultBookingServiceSlug
+    ),
+    defaultCertificateTemplateId: pickFirst(
+      existingSettings?.defaultCertificateTemplateId,
+      presetSettings?.defaultCertificateTemplateId
+    )
+  };
+}
+function needsPresetBackfill(existing, preset) {
+  const missingChecklist = Boolean(preset.checklistTemplate?.length) && !existing.checklistTemplate?.length;
+  const missingTranslations = Boolean(
+    preset.translations && Object.keys(preset.translations).length > 0
+  ) && !Object.keys(existing.translations || {}).length;
+  const missingCategory = Boolean(preset.category && preset.category !== "contact") && existing.category === "contact";
+  return missingChecklist || missingTranslations || missingCategory;
+}
+function buildMergedPresetForm(existing, preset) {
+  const baseFields = existing.fields?.length ? existing.fields : pickFirst(preset.fields, []);
+  const mergedFields = baseFields.map(
+    (ef) => mergePresetField(ef, preset.fields)
+  );
+  const checklistTemplate = existing.checklistTemplate?.length ? existing.checklistTemplate : pickFirst(preset.checklistTemplate, []);
+  const translations = Object.keys(existing.translations || {}).length ? existing.translations : pickFirst(preset.translations, {});
+  return {
+    ...preset,
+    ...existing,
+    slug: existing.slug,
+    title: existing.title || preset.title,
+    category: pickNonDefault(existing.category, preset.category, "contact"),
+    fields: mergedFields,
+    checklistTemplate,
+    translations,
+    settings: mergePresetSettings(existing.settings, preset.settings)
+  };
+}
+async function seedSinglePresetForm(formService2, preset) {
+  if (!preset?.slug || !preset?.title) return;
+  const existing = await formService2.findBySlug(preset.slug);
+  if (!existing) {
+    await formService2.saveForm(preset);
+    return;
+  }
+  if (needsPresetBackfill(existing, preset)) {
+    await formService2.saveForm(buildMergedPresetForm(existing, preset));
+  }
+}
+async function seedPresetForms(strapi, formService2) {
+  try {
+    const rawConfig = strapi.config.get(
+      `plugin::${PLUGIN_ID}`,
+      {}
+    );
+    const presetForms = Array.isArray(rawConfig?.presetForms) ? rawConfig.presetForms : [];
+    for (const preset of presetForms) {
+      await seedSinglePresetForm(formService2, preset);
+    }
+  } catch (err) {
+    strapi.log?.warn?.(
+      `[${PLUGIN_ID}] Could not seed presetForms: ${err.message}`
+    );
+  }
+}
+async function preserveCmsFormInboxSettings(strapi, event) {
+  const data = event.params?.data;
+  const where = event.params?.where;
+  if (!data || !where) return;
+  const incomingSettings = data.settings;
+  if (!incomingSettings || incomingSettings.inbox) return;
+  const existing = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).findOne({ where });
+  const prevInbox = existing?.settings?.inbox;
+  if (!prevInbox) return;
+  incomingSettings.inbox = prevInbox;
+  if (data.publishedData && typeof data.publishedData === "object") {
+    const pd = data.publishedData;
+    pd.settings = {
+      ...pd.settings,
+      inbox: prevInbox
+    };
+  }
+}
+function extractLifecycleFormId(event) {
+  const dataForm = event.params?.data?.form;
+  const resultForm = event.result?.form;
+  const fromData = dataForm !== void 0 ? resolveCmsSubmissionFormRef({ form: dataForm }).formId : null;
+  if (fromData !== null) return fromData;
+  const fromResult = resultForm !== void 0 ? resolveCmsSubmissionFormRef({ form: resultForm }).formId : null;
+  return fromResult ?? void 0;
+}
+function subscribeFormBuilderLifecycles(strapi, formService2, submissionService2) {
+  if (!strapi.db?.lifecycles?.subscribe) return;
+  if (strapi.contentTypes?.[FORM_BUILDER_CMS_FORM_UID]) {
+    strapi.db.lifecycles.subscribe({
+      models: [FORM_BUILDER_CMS_FORM_UID],
+      async beforeUpdate(event) {
+        await preserveCmsFormInboxSettings(strapi, event);
+      },
+      async afterCreate(event) {
+        if (event.result) {
+          await formService2.syncFormFromBuilderCms(event.result);
+        }
+      }
+    });
+  }
+  if (strapi.contentTypes?.[FORM_BUILDER_CMS_SUBMISSION_UID]) {
+    strapi.db.lifecycles.subscribe({
+      models: [FORM_BUILDER_CMS_SUBMISSION_UID],
+      async afterCreate(event) {
+        if (event.result) {
+          await submissionService2.ingestFormBuilderSubmission(event.result, {
+            formId: extractLifecycleFormId(event)
+          });
+        }
+      }
+    });
+  }
+}
+const bootstrap = async ({ strapi }) => {
+  const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+  const formService2 = strapi.plugin(PLUGIN_ID).service("formService");
+  const submissionService2 = strapi.plugin(PLUGIN_ID).service("submissionService");
+  const settings2 = await settingsService.getSettings();
+  await registerPluginPermissions(strapi);
+  await seedPresetForms(strapi, formService2);
+  try {
+    if (settings2.enableFormBuilderBridge !== false && settings2.autoSyncFormBuilderForms !== false) {
+      await formService2.syncWithFormBuilderCms();
+    }
+    subscribeFormBuilderLifecycles(strapi, formService2, submissionService2);
+  } catch (err) {
+    strapi.log?.warn?.(
+      `[${PLUGIN_ID}] Could not initialize Form Builder CMS bridge: ${err.message}`
+    );
+  }
+};
+const config = {
+  default: DEFAULT_INBOX_SETTINGS,
+  validator() {
+  }
+};
+const kind$2 = "collectionType";
+const collectionName$2 = "inbox_alert_banners";
+const info$2 = { "singularName": "alert-banner", "pluralName": "alert-banners", "displayName": "Inbox Alert Banner", "description": "Time-bounded multi-language urgent announcement ticker / banner" };
+const options$2 = { "draftAndPublish": false };
+const pluginOptions$2 = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes$2 = { "code": { "type": "string", "required": true, "unique": true }, "title": { "type": "string", "required": true }, "message": { "type": "text", "required": true }, "severity": { "type": "enumeration", "enum": ["info", "warning", "urgent", "celebration"], "default": "info", "required": true }, "ctaLabel": { "type": "string" }, "ctaUrl": { "type": "string" }, "dismissible": { "type": "boolean", "default": true }, "active": { "type": "boolean", "default": true }, "priority": { "type": "integer", "default": 10 }, "startsAt": { "type": "datetime" }, "endsAt": { "type": "datetime" }, "translations": { "type": "json", "default": {} } };
+const schema$2 = {
+  kind: kind$2,
+  collectionName: collectionName$2,
+  info: info$2,
+  options: options$2,
+  pluginOptions: pluginOptions$2,
+  attributes: attributes$2
+};
+const alertBanner = {
+  schema: schema$2
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "inbox_submissions";
+const info$1 = { "singularName": "submission", "pluralName": "submissions", "displayName": "Inbox Submission", "description": "Form submission & Service-Desk Casework ticket" };
+const options$1 = { "draftAndPublish": false };
+const pluginOptions$1 = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes$1 = { "referenceCode": { "type": "string", "required": true, "unique": true }, "formSlug": { "type": "string", "required": true }, "formTitle": { "type": "string" }, "category": { "type": "enumeration", "enum": ["contact", "service_desk", "inquiry", "application", "volunteer", "custom"], "default": "contact" }, "status": { "type": "enumeration", "enum": ["new", "read", "under_review", "scheduled", "completed", "rejected", "archived"], "default": "new", "required": true }, "priority": { "type": "enumeration", "enum": ["low", "normal", "high", "urgent"], "default": "normal", "required": true }, "department": { "type": "string", "default": "general" }, "locale": { "type": "string", "default": "es" }, "applicantName": { "type": "string" }, "applicantEmail": { "type": "email" }, "applicantPhone": { "type": "string" }, "data": { "type": "json", "required": true, "default": {} }, "checklistItems": { "type": "json", "default": [] }, "staffNotes": { "type": "text" }, "assignedTo": { "type": "string" }, "linkedBookingId": { "type": "string" }, "linkedCertificateNumber": { "type": "string" }, "formBuilderSubmissionId": { "type": "integer" }, "ipAddress": { "type": "string", "private": true }, "userAgent": { "type": "string", "private": true }, "submittedAt": { "type": "datetime", "required": true }, "secondaryDate": { "type": "json" } };
+const schema$1 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const submission = {
+  schema: schema$1
+};
+const kind = "collectionType";
+const collectionName = "inbox_subscribers";
+const info = { "singularName": "subscriber", "pluralName": "subscribers", "displayName": "Inbox Subscriber", "description": "Double Opt-In newsletter and community topic subscriber" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes = { "email": { "type": "email", "required": true, "unique": true }, "fullName": { "type": "string" }, "phone": { "type": "string" }, "locale": { "type": "string", "default": "es" }, "topics": { "type": "json", "default": ["announcements"] }, "status": { "type": "enumeration", "enum": ["pending", "confirmed", "unsubscribed"], "default": "pending", "required": true }, "confirmToken": { "type": "string", "private": true }, "unsubscribeToken": { "type": "string", "required": true, "private": true }, "confirmedAt": { "type": "datetime" }, "unsubscribedAt": { "type": "datetime" }, "sourceFormSlug": { "type": "string" } };
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const subscriber = {
+  schema
+};
+const contentTypes = {
+  submission,
+  subscriber,
+  "alert-banner": alertBanner
+};
+const createCaseworkHandlers = (strapi) => ({
+  async listSubmissions(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    const data = await svc.listSubmissions({
+      formSlug: ctx.query?.formSlug,
+      status: ctx.query?.status,
+      priority: ctx.query?.priority,
+      department: ctx.query?.department
+    });
+    ctx.body = { data };
+  },
+  async updateCasework(ctx) {
+    const documentId = ctx.params?.documentId || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    const data = await svc.updateCasework(
+      documentId,
+      ctx.request.body || {}
+    );
+    ctx.body = { data };
+  },
+  async scheduleBooking(ctx) {
+    const documentId = ctx.params?.documentId || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    const body = ctx.request.body || {};
+    const data = await svc.scheduleBookingFromSubmission(documentId, body);
+    ctx.body = { data };
+  },
+  async issueCertificate(ctx) {
+    const documentId = ctx.params?.documentId || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    const body = ctx.request.body || {};
+    const data = await svc.issueCertificateFromSubmission(documentId, body);
+    ctx.body = { data };
+  },
+  async exportCsv(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    const csv = await svc.exportCsv(ctx.query?.formSlug);
+    ctx.set?.("Content-Type", "text/csv; charset=utf-8");
+    ctx.body = csv;
+  },
+  async testCaptcha(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    const body = ctx.request.body || {};
+    const data = await svc.testCaptchaSecret(body.provider, body.secret);
+    ctx.body = { data };
+  }
+});
+const createCommunityHandlers = (strapi) => ({
+  async subscribe(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("subscriberService");
+    try {
+      const body = ctx.request.body || {};
+      const subscriber2 = await svc.subscribe(body);
+      ctx.status = 201;
+      ctx.body = {
+        data: {
+          email: subscriber2.email,
+          status: subscriber2.status,
+          topics: subscriber2.topics,
+          locale: subscriber2.locale
+        }
+      };
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { error: err.message };
+    }
+  },
+  async confirmSubscription(ctx) {
+    const token = ctx.params?.token || ctx.query?.token || (ctx.request.body?.token ?? "");
+    const svc = strapi.plugin(PLUGIN_ID).service("subscriberService");
+    try {
+      const subscriber2 = await svc.confirmSubscription(token);
+      ctx.body = {
+        data: {
+          email: subscriber2.email,
+          status: subscriber2.status,
+          confirmedAt: subscriber2.confirmedAt
+        }
+      };
+    } catch (err) {
+      ctx.status = 404;
+      ctx.body = { error: err.message };
+    }
+  },
+  async unsubscribe(ctx) {
+    const token = ctx.params?.token || ctx.query?.token || (ctx.request.body?.token ?? "");
+    const svc = strapi.plugin(PLUGIN_ID).service("subscriberService");
+    try {
+      const subscriber2 = await svc.unsubscribe(token);
+      ctx.body = {
+        data: {
+          email: subscriber2.email,
+          status: subscriber2.status,
+          unsubscribedAt: subscriber2.unsubscribedAt
+        }
+      };
+    } catch (err) {
+      ctx.status = 404;
+      ctx.body = { error: err.message };
+    }
+  },
+  async listSubscribers(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("subscriberService");
+    const data = await svc.listSubscribers({
+      status: ctx.query?.status,
+      topic: ctx.query?.topic,
+      locale: ctx.query?.locale
+    });
+    ctx.body = { data };
+  },
+  async getActiveAlerts(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("alertService");
+    const data = await svc.getActiveAlerts({
+      locale: ctx.query?.locale,
+      nowIso: ctx.query?.now
+    });
+    ctx.body = { data };
+  },
+  async upsertAlertBanner(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("alertService");
+    const body = ctx.request.body || {};
+    const data = await svc.upsertAlertBanner(body);
+    ctx.body = { data };
+  }
+});
+function extractPlainObject(val) {
+  return val && typeof val === "object" && !Array.isArray(val) ? val : null;
+}
+function normalizeSubmitPayload(rawBody) {
+  const nestedData = extractPlainObject(rawBody.data) || extractPlainObject(rawBody.payload);
+  return nestedData ? { ...rawBody, ...nestedData } : rawBody;
+}
+function resolveClientIp(ctx) {
+  const forwarded = ctx.request.headers?.["x-forwarded-for"]?.split(",")[0]?.trim();
+  return forwarded || ctx.request.ip || "127.0.0.1";
+}
+const ERROR_STATUS_MAP = {
+  NotFoundError: 404,
+  TooManyRequestsError: 429,
+  ForbiddenError: 403
+};
+const createFormHandlers = (strapi) => ({
+  async getSettings(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("settings");
+    const data = await svc.getSettings();
+    ctx.body = { data };
+  },
+  async updateSettings(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("settings");
+    const data = await svc.updateSettings(
+      ctx.request.body || {}
+    );
+    ctx.body = { data };
+  },
+  async listTemplates(ctx) {
+    ctx.body = { data: STARTER_FORM_TEMPLATES };
+  },
+  async listFormBuilderForms(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("formService");
+    const data = await svc.listFormBuilderForms();
+    ctx.body = { data };
+  },
+  async syncFormBuilder(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("formService");
+    const data = await svc.syncWithFormBuilderCms();
+    ctx.body = { data };
+  },
+  async listForms(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("formService");
+    const data = await svc.listForms({
+      category: ctx.query?.category,
+      activeOnly: ctx.query?.activeOnly !== "false",
+      locale: ctx.query?.locale,
+      publicSafe: ctx.query?.admin !== "true"
+    });
+    ctx.body = { data };
+  },
+  async getFormBySlug(ctx) {
+    const slug = ctx.params?.slug || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("formService");
+    const form = await svc.findBySlug(slug, {
+      locale: ctx.query?.locale,
+      publicSafe: true
+    });
+    if (!form || form.active === false) {
+      ctx.status = 404;
+      ctx.body = { error: `Form "${slug}" not found` };
+      return;
+    }
+    ctx.body = { data: form };
+  },
+  async saveForm(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("formService");
+    const body = ctx.request.body || {};
+    const data = await svc.saveForm(body);
+    ctx.body = { data };
+  },
+  async createFromTemplate(ctx) {
+    const svc = strapi.plugin(PLUGIN_ID).service("formService");
+    const body = ctx.request.body || {};
+    const data = await svc.createFromTemplate(body.templateId, body.overrides);
+    ctx.body = { data };
+  },
+  async submitForm(ctx) {
+    const slug = ctx.params?.slug || "";
+    const svc = strapi.plugin(PLUGIN_ID).service("submissionService");
+    try {
+      const rawBody = ctx.request.body || {};
+      const payload = normalizeSubmitPayload(rawBody);
+      const data = await svc.submitForm(slug, payload, {
+        ip: resolveClientIp(ctx),
+        userAgent: ctx.request.headers?.["user-agent"] || "",
+        locale: rawBody.locale || ctx.query?.locale,
+        captchaToken: rawBody.captchaToken || payload.captchaToken
+      });
+      ctx.status = 201;
+      ctx.body = { data };
+    } catch (err) {
+      const error = err;
+      ctx.status = ERROR_STATUS_MAP[error.name] ?? 400;
+      ctx.body = {
+        error: error.message,
+        details: error.details || {}
+      };
+    }
+  }
+});
+const inboxController = ({ strapi }) => ({
+  ...createFormHandlers(strapi),
+  ...createCaseworkHandlers(strapi),
+  ...createCommunityHandlers(strapi)
+});
+const controllers = {
+  inboxController
+};
+const destroy = ({ strapi }) => {
+  strapi.log.debug("[@vicacha-devs/strapi-plugin-inbox] Destroyed");
+};
+const register = ({ strapi }) => {
+  strapi.log.debug(
+    "[@vicacha-devs/strapi-plugin-inbox] Registered inbox & form builder plugin"
+  );
+};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "inboxController.getSettings",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "inboxController.updateSettings",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/templates",
+      handler: "inboxController.listTemplates",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/form-builder-forms",
+      handler: "inboxController.listFormBuilderForms",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/forms/sync-builder",
+      handler: "inboxController.syncFormBuilder",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/forms",
+      handler: "inboxController.listForms",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/forms",
+      handler: "inboxController.saveForm",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/forms/from-template",
+      handler: "inboxController.createFromTemplate",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/submissions",
+      handler: "inboxController.listSubmissions",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/submissions/:documentId/casework",
+      handler: "inboxController.updateCasework",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/submissions/:documentId/schedule-booking",
+      handler: "inboxController.scheduleBooking",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/submissions/:documentId/issue-certificate",
+      handler: "inboxController.issueCertificate",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/submissions/export-csv",
+      handler: "inboxController.exportCsv",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/captcha/test",
+      handler: "inboxController.testCaptcha",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/subscribers",
+      handler: "inboxController.listSubscribers",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/alerts",
+      handler: "inboxController.getActiveAlerts",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/alerts",
+      handler: "inboxController.upsertAlertBanner",
+      config: { policies: [] }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/forms",
+      handler: "inboxController.listForms",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/forms/:slug",
+      handler: "inboxController.getFormBySlug",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/forms/:slug/submit",
+      handler: "inboxController.submitForm",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/subscribers",
+      handler: "inboxController.subscribe",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/subscribers/confirm/:token",
+      handler: "inboxController.confirmSubscription",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/subscribers/unsubscribe/:token",
+      handler: "inboxController.unsubscribe",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/alerts",
+      handler: "inboxController.getActiveAlerts",
+      config: {
+        policies: [],
+        auth: false
+      }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentApi,
+  admin
+};
+function getDocuments(strapi, uid) {
+  return strapi.documents(uid);
+}
+function buildAlertBannerPayload(input) {
+  return {
+    code: input.code,
+    title: input.title,
+    message: input.message,
+    severity: input.severity ?? "info",
+    ctaLabel: input.ctaLabel ?? "",
+    ctaUrl: input.ctaUrl ?? "",
+    dismissible: input.dismissible ?? true,
+    active: input.active ?? true,
+    priority: input.priority ?? 10,
+    startsAt: input.startsAt ?? null,
+    endsAt: input.endsAt ?? null,
+    translations: input.translations ?? {}
+  };
+}
+const alertService = ({ strapi }) => ({
+  async getActiveAlerts(params) {
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const settings2 = await settingsService.getSettings();
+    const locale = params?.locale || settings2.defaultLocale || "es";
+    const nowMs = new Date(params?.nowIso || Date.now()).getTime();
+    const docs = await getDocuments(strapi, ALERT_BANNER_UID).findMany({
+      filters: { active: true },
+      limit: 50
+    });
+    const activeInWindow = docs.filter((banner) => {
+      if (!banner.active) return false;
+      if (banner.startsAt) {
+        const startMs = new Date(banner.startsAt).getTime();
+        if (!Number.isNaN(startMs) && nowMs < startMs) return false;
+      }
+      if (banner.endsAt) {
+        const endMs = new Date(banner.endsAt).getTime();
+        if (!Number.isNaN(endMs) && nowMs > endMs) return false;
+      }
+      return true;
+    });
+    activeInWindow.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    const secondaryCal = settings2.secondaryCalendars?.[0] || "islamic-umalqura";
+    const refDateIso = new Date(nowMs).toISOString().slice(0, 10);
+    const secondaryDate = convertIsoDateToCalendar(
+      refDateIso,
+      secondaryCal,
+      locale
+    );
+    return activeInWindow.map((banner) => {
+      const tr = banner.translations?.[locale];
+      return {
+        ...banner,
+        title: tr?.title || banner.title,
+        message: tr?.message || banner.message,
+        ctaLabel: tr?.ctaLabel || banner.ctaLabel,
+        ctaUrl: tr?.ctaUrl || banner.ctaUrl,
+        secondaryDateLabel: secondaryDate.formatted
+      };
+    });
+  },
+  async upsertAlertBanner(input) {
+    const existingDocs = await getDocuments(strapi, ALERT_BANNER_UID).findMany(
+      {
+        filters: { code: input.code },
+        limit: 1
+      }
+    );
+    const existing = existingDocs[0] || null;
+    const payload = buildAlertBannerPayload(input);
+    if (existing?.documentId) {
+      const updated = await getDocuments(strapi, ALERT_BANNER_UID).update({
+        documentId: existing.documentId,
+        data: payload
+      });
+      return updated;
+    }
+    const created = await getDocuments(strapi, ALERT_BANNER_UID).create({
+      data: payload
+    });
+    return created;
+  }
+});
+function sanitizePublicForm(form, locale) {
+  const localized = locale ? localizeFormForLocale(form, locale) : { ...form };
+  const safeSettings = { ...localized.settings };
+  delete safeSettings.captchaSecretKey;
+  delete safeSettings.notifyEmails;
+  delete safeSettings.webhookUrl;
+  return {
+    ...localized,
+    settings: safeSettings
+  };
+}
+function pick(...values) {
+  for (const v of values) {
+    if (v !== void 0 && v !== null && v !== "") return v;
+  }
+  return values[values.length - 1];
+}
+function pickDef(...values) {
+  for (const v of values) {
+    if (v !== void 0 && v !== null) return v;
+  }
+  return values[values.length - 1];
+}
+function asObj(val) {
+  return val && typeof val === "object" ? val : {};
+}
+function resolveFieldWidth(width) {
+  if (width === "half" || width === "third") return width;
+  return "full";
+}
+function mapFieldToCms(f, idx) {
+  const mapped = {
+    id: pick(f.id, `fld_${idx + 1}`),
+    type: f.type === "file" ? "text" : f.type,
+    name: f.name,
+    label: f.label,
+    placeholder: pick(f.placeholder, ""),
+    helpText: pick(f.helpText, ""),
+    defaultValue: f.defaultValue,
+    required: Boolean(f.required),
+    order: idx,
+    width: resolveFieldWidth(f.width),
+    options: (f.options ?? []).map(
+      (o) => o.localizedLabels ? { label: o.label, value: o.value, localizedLabels: o.localizedLabels } : { label: o.label, value: o.value }
+    ),
+    validation: (f.validation ?? []).map(
+      (v) => v.localizedMessages ? {
+        type: v.type,
+        value: v.value,
+        message: v.message,
+        localizedMessages: v.localizedMessages
+      } : { type: v.type, value: v.value, message: v.message }
+    )
+  };
+  if (f.localizedLabels) mapped.localizedLabels = f.localizedLabels;
+  if (f.localizedPlaceholders)
+    mapped.localizedPlaceholders = f.localizedPlaceholders;
+  if (f.localizedHelpTexts) mapped.localizedHelpTexts = f.localizedHelpTexts;
+  return mapped;
+}
+function buildInboxMetadata(form, existingInbox) {
+  const fs = form.settings;
+  return {
+    ...existingInbox,
+    category: pick(form.category, existingInbox.category, "contact"),
+    checklistTemplate: pickDef(
+      form.checklistTemplate,
+      existingInbox.checklistTemplate,
+      []
+    ),
+    translations: pickDef(form.translations, existingInbox.translations, {}),
+    active: pickDef(form.active, existingInbox.active, true),
+    submissionCount: pickDef(
+      form.submissionCount,
+      existingInbox.submissionCount,
+      0
+    ),
+    department: pickDef(fs?.department, existingInbox.department, "general"),
+    defaultPriority: pickDef(
+      fs?.defaultPriority,
+      existingInbox.defaultPriority,
+      "normal"
+    ),
+    honeypotField: pickDef(fs?.honeypotField, existingInbox.honeypotField),
+    webhookUrl: pickDef(fs?.webhookUrl, existingInbox.webhookUrl),
+    enableBookingBridge: pickDef(
+      fs?.enableBookingBridge,
+      existingInbox.enableBookingBridge
+    ),
+    defaultBookingServiceSlug: pickDef(
+      fs?.defaultBookingServiceSlug,
+      existingInbox.defaultBookingServiceSlug
+    ),
+    enableCertificateBridge: pickDef(
+      fs?.enableCertificateBridge,
+      existingInbox.enableCertificateBridge
+    ),
+    defaultCertificateTemplateId: pickDef(
+      fs?.defaultCertificateTemplateId,
+      existingInbox.defaultCertificateTemplateId
+    ),
+    localizedSubmitLabels: pickDef(
+      fs?.localizedSubmitLabels,
+      existingInbox.localizedSubmitLabels
+    ),
+    localizedSuccessMessages: pickDef(
+      fs?.localizedSuccessMessages,
+      existingInbox.localizedSuccessMessages
+    )
+  };
+}
+function buildCmsSettings(form, existingSettings, inboxMeta) {
+  const fs = form.settings;
+  const existingCaptcha = asObj(existingSettings.captcha);
+  return {
+    ...existingSettings,
+    submitButtonText: pick(
+      fs?.submitButtonLabel,
+      existingSettings.submitButtonText,
+      "Submit"
+    ),
+    successMessage: pick(
+      fs?.successMessage,
+      existingSettings.successMessage,
+      "Form submitted successfully"
+    ),
+    enableHoneypot: Boolean(pickDef(fs?.honeypotField, true)),
+    enableRateLimit: Boolean(pickDef(fs?.rateLimitPerHour, true)),
+    maxSubmissionsPerHour: pickDef(
+      fs?.rateLimitPerHour,
+      existingSettings.maxSubmissionsPerHour,
+      60
+    ),
+    notificationEmails: pickDef(
+      fs?.notifyEmails,
+      existingSettings.notificationEmails,
+      []
+    ),
+    redirectUrl: pickDef(
+      fs?.redirectUrl,
+      existingSettings.redirectUrl,
+      ""
+    ),
+    customCss: pickDef(existingSettings.customCss, ""),
+    publicPage: pickDef(existingSettings.publicPage, true),
+    captcha: {
+      provider: pick(
+        fs?.captchaProvider,
+        existingCaptcha.provider,
+        "none"
+      ),
+      siteKey: pickDef(
+        fs?.captchaSiteKey,
+        existingCaptcha.siteKey,
+        ""
+      ),
+      secretKey: pickDef(
+        fs?.captchaSecretKey,
+        existingCaptcha.secretKey,
+        ""
+      )
+    },
+    inbox: inboxMeta
+  };
+}
+function toFormBuilderCmsPayload(form, existingCms) {
+  const existingSettings = asObj(existingCms?.settings);
+  const existingInbox = asObj(existingSettings.inbox);
+  const fields = (form.fields ?? []).map(mapFieldToCms);
+  const inboxMeta = buildInboxMetadata(form, existingInbox);
+  const settings2 = buildCmsSettings(form, existingSettings, inboxMeta);
+  const conditionalLogic = Array.isArray(existingCms?.conditionalLogic) ? existingCms.conditionalLogic : [];
+  const publishedAt = form.publishedAt !== void 0 ? form.publishedAt : pickDef(
+    existingCms?.publishedAt,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const description = pickDef(
+    form.description,
+    existingCms?.description,
+    ""
+  );
+  return {
+    title: form.title,
+    slug: pick(form.formBuilderSlug, form.slug),
+    description,
+    fields,
+    conditionalLogic,
+    settings: settings2,
+    publishedAt,
+    publishedData: {
+      title: form.title,
+      description,
+      fields,
+      conditionalLogic,
+      settings: settings2
+    }
+  };
+}
+function mapCmsOption(opt, prevOptions) {
+  if (typeof opt === "string") {
+    const value2 = opt.toLowerCase().replace(/[^a-z0-9]+/g, "_");
+    const prevLoc2 = prevOptions?.find(
+      (po) => po.value === value2
+    )?.localizedLabels;
+    return prevLoc2 ? { label: opt, value: value2, localizedLabels: prevLoc2 } : { label: opt, value: value2 };
+  }
+  const label = String(pick(opt.label, opt.value, ""));
+  const value = String(pick(opt.value, opt.label, ""));
+  const prevLoc = prevOptions?.find(
+    (po) => po.value === value
+  )?.localizedLabels;
+  const optLoc = pickDef(
+    opt.localizedLabels,
+    prevLoc
+  );
+  return optLoc ? { label, value, localizedLabels: optLoc } : { label, value };
+}
+function resolveOptionalString(raw, fallback) {
+  return raw !== void 0 ? String(pickDef(raw, "")) : fallback;
+}
+function mapCmsFieldToInbox(cf, index, existingFields) {
+  const fieldName = String(pick(cf.name, `field_${index + 1}`));
+  const fieldId = String(pick(cf.id, `fld_${fieldName}`));
+  const prev = existingFields.find(
+    (ef) => ef.id === fieldId || ef.name === fieldName
+  );
+  const rawOpts = Array.isArray(cf.options) ? cf.options : void 0;
+  const mergedOptions = rawOpts?.map((opt) => mapCmsOption(opt, prev?.options));
+  const width = resolveFieldWidth(
+    pick(cf.width, prev?.width)
+  );
+  return {
+    ...prev,
+    id: fieldId,
+    type: pick(cf.type, prev?.type, "text"),
+    name: fieldName,
+    label: String(pick(cf.label, prev?.label, fieldName)),
+    placeholder: resolveOptionalString(cf.placeholder, prev?.placeholder),
+    helpText: resolveOptionalString(cf.helpText, prev?.helpText),
+    defaultValue: pickDef(cf.defaultValue, prev?.defaultValue),
+    required: Boolean(pickDef(cf.required, prev?.required, false)),
+    width,
+    ...mergedOptions ? { options: mergedOptions } : {},
+    validation: Array.isArray(cf.validation) ? cf.validation : prev?.validation,
+    localizedLabels: pick(
+      cf.localizedLabels,
+      prev?.localizedLabels
+    ),
+    localizedPlaceholders: pick(
+      cf.localizedPlaceholders,
+      prev?.localizedPlaceholders
+    ),
+    localizedHelpTexts: pick(
+      cf.localizedHelpTexts,
+      prev?.localizedHelpTexts
+    )
+  };
+}
+function buildInboxSettingsFromCms(cmsSettings, inboxMeta, prevSettings) {
+  const cmsCaptcha = asObj(cmsSettings.captcha);
+  const rateLimit = typeof cmsSettings.maxSubmissionsPerHour === "number" ? cmsSettings.maxSubmissionsPerHour : prevSettings.rateLimitPerHour;
+  const notifyEmails = Array.isArray(cmsSettings.notificationEmails) ? cmsSettings.notificationEmails : prevSettings.notifyEmails;
+  return {
+    ...prevSettings,
+    submitButtonLabel: pick(
+      cmsSettings.submitButtonText,
+      prevSettings.submitButtonLabel
+    ),
+    localizedSubmitLabels: pick(
+      inboxMeta.localizedSubmitLabels,
+      prevSettings.localizedSubmitLabels
+    ),
+    successMessage: pick(
+      cmsSettings.successMessage,
+      prevSettings.successMessage
+    ),
+    localizedSuccessMessages: pick(
+      inboxMeta.localizedSuccessMessages,
+      prevSettings.localizedSuccessMessages
+    ),
+    redirectUrl: pickDef(
+      cmsSettings.redirectUrl,
+      prevSettings.redirectUrl
+    ),
+    honeypotField: pickDef(inboxMeta.honeypotField, prevSettings.honeypotField),
+    rateLimitPerHour: rateLimit,
+    notifyEmails,
+    webhookUrl: pickDef(inboxMeta.webhookUrl, prevSettings.webhookUrl),
+    captchaProvider: pick(
+      cmsCaptcha.provider,
+      prevSettings.captchaProvider
+    ),
+    captchaSiteKey: pickDef(
+      cmsCaptcha.siteKey,
+      prevSettings.captchaSiteKey
+    ),
+    captchaSecretKey: pickDef(
+      cmsCaptcha.secretKey,
+      prevSettings.captchaSecretKey
+    ),
+    department: pick(inboxMeta.department, prevSettings.department, "general"),
+    defaultPriority: pick(
+      inboxMeta.defaultPriority,
+      prevSettings.defaultPriority,
+      "normal"
+    ),
+    enableBookingBridge: pickDef(
+      inboxMeta.enableBookingBridge,
+      prevSettings.enableBookingBridge
+    ),
+    defaultBookingServiceSlug: pickDef(
+      inboxMeta.defaultBookingServiceSlug,
+      prevSettings.defaultBookingServiceSlug
+    ),
+    enableCertificateBridge: pickDef(
+      inboxMeta.enableCertificateBridge,
+      prevSettings.enableCertificateBridge
+    ),
+    defaultCertificateTemplateId: pickDef(
+      inboxMeta.defaultCertificateTemplateId,
+      prevSettings.defaultCertificateTemplateId
+    )
+  };
+}
+function resolveCmsDocId(cmsForm, existing, cmsId) {
+  if (cmsForm.documentId) return String(cmsForm.documentId);
+  if (existing?.documentId) return existing.documentId;
+  return cmsId ? `cms_doc_${cmsId}` : void 0;
+}
+function fromFormBuilderCmsRow(cmsForm, existing) {
+  const cmsSettings = asObj(cmsForm.settings);
+  const publishedSettings = asObj(asObj(cmsForm.publishedData).settings);
+  const inboxMeta = pick(
+    cmsSettings.inbox,
+    publishedSettings.inbox,
+    {}
+  );
+  const rawFields = Array.isArray(cmsForm.fields) ? cmsForm.fields : [];
+  const existingFields = pickDef(existing?.fields, []);
+  const mergedFields = rawFields.map(
+    (cf, index) => mapCmsFieldToInbox(cf, index, existingFields)
+  );
+  const mergedSettings = buildInboxSettingsFromCms(
+    cmsSettings,
+    inboxMeta,
+    pickDef(existing?.settings, {})
+  );
+  const cmsSlug = String(pick(cmsForm.slug, existing?.slug, "form"));
+  const cmsId = cmsForm.id ? Number(cmsForm.id) : pickDef(existing?.formBuilderId, null);
+  const submissionCount = typeof cmsForm.submissionCount === "number" ? cmsForm.submissionCount : pickDef(inboxMeta.submissionCount, existing?.submissionCount, 0);
+  return {
+    documentId: resolveCmsDocId(cmsForm, existing, cmsId),
+    title: String(pick(cmsForm.title, existing?.title, "Untitled Form")),
+    slug: cmsSlug,
+    description: pickDef(
+      resolveOptionalString(cmsForm.description, existing?.description),
+      ""
+    ),
+    category: pick(inboxMeta.category, existing?.category, "contact"),
+    fields: mergedFields.length > 0 ? mergedFields : existingFields,
+    checklistTemplate: pick(
+      inboxMeta.checklistTemplate,
+      existing?.checklistTemplate,
+      []
+    ),
+    settings: mergedSettings,
+    translations: pick(inboxMeta.translations, existing?.translations, {}),
+    active: pickDef(inboxMeta.active, existing?.active, true),
+    submissionCount,
+    formBuilderId: cmsId,
+    formBuilderSlug: cmsSlug,
+    publishedAt: pickDef(
+      cmsForm.publishedAt,
+      existing?.publishedAt,
+      (/* @__PURE__ */ new Date()).toISOString()
+    )
+  };
+}
+function isFormBuilderCmsAvailable(strapi) {
+  const hasContentType = Boolean(
+    strapi.contentTypes?.[FORM_BUILDER_CMS_FORM_UID]
+  );
+  const hasDbQuery = typeof strapi.db?.query === "function";
+  return hasDbQuery && (hasContentType || Boolean(
+    strapi.__hasFormBuilderCms
+  ));
+}
+async function countSubmissionsForForm(strapi, formId, slug) {
+  let cmsCount;
+  let inboxCount;
+  try {
+    cmsCount = await strapi.db.query(FORM_BUILDER_CMS_SUBMISSION_UID).count({ where: { form: formId } });
+  } catch {
+    cmsCount = 0;
+  }
+  try {
+    const inboxSubs = await strapi.documents(SUBMISSION_UID).findMany({
+      filters: { formSlug: slug },
+      limit: 1e3
+    });
+    inboxCount = Array.isArray(inboxSubs) ? inboxSubs.length : 0;
+  } catch {
+    inboxCount = 0;
+  }
+  return Math.max(cmsCount, inboxCount);
+}
+async function listFormBuilderForms(strapi) {
+  if (!isFormBuilderCmsAvailable(strapi)) {
+    return { available: false, forms: [] };
+  }
+  const cmsForms = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).findMany({ orderBy: { createdAt: "desc" } });
+  const summaries = await Promise.all(
+    (cmsForms || []).map(async (cf) => {
+      const parsed = fromFormBuilderCmsRow(cf);
+      const id = Number(cf.id);
+      const slug = parsed.slug;
+      const submissionCount = await countSubmissionsForForm(strapi, id, slug);
+      return {
+        id,
+        documentId: parsed.documentId,
+        slug,
+        title: parsed.title,
+        description: parsed.description || "",
+        fieldCount: parsed.fields.length,
+        submissionCount: Math.max(submissionCount, parsed.submissionCount || 0),
+        publishedAt: parsed.publishedAt || null,
+        linkedInboxSlug: slug,
+        linkedCategory: parsed.category
+      };
+    })
+  );
+  return { available: true, forms: summaries };
+}
+async function syncFormToBuilderCms(strapi, form) {
+  if (!isFormBuilderCmsAvailable(strapi)) return null;
+  const query = strapi.db.query(FORM_BUILDER_CMS_FORM_UID);
+  let existingCms = null;
+  if (form.formBuilderId) {
+    existingCms = await query.findOne({ where: { id: form.formBuilderId } });
+  }
+  if (!existingCms && form.formBuilderSlug) {
+    existingCms = await query.findOne({
+      where: { slug: form.formBuilderSlug }
+    });
+  }
+  if (!existingCms) {
+    existingCms = await query.findOne({ where: { slug: form.slug } });
+  }
+  const payload = toFormBuilderCmsPayload(form, existingCms);
+  let savedCms;
+  if (existingCms?.id) {
+    savedCms = await query.update({
+      where: { id: existingCms.id },
+      data: {
+        ...payload,
+        slug: existingCms.slug || payload.slug
+      }
+    });
+  } else {
+    savedCms = await query.create({
+      data: payload
+    });
+  }
+  return {
+    formBuilderId: Number(savedCms.id),
+    formBuilderSlug: String(savedCms.slug || form.slug)
+  };
+}
+function shouldBackfillStarterTemplate(parsed, starterTpl) {
+  if (!starterTpl) return false;
+  const hasTranslations = Object.keys(parsed.translations || {}).length > 0;
+  if (hasTranslations) return false;
+  return !parsed.checklistTemplate?.length || !starterTpl.checklistTemplate?.length;
+}
+function pickNonDefaultSetting(val, fallback, defaultVal) {
+  if (val && val !== defaultVal) return val;
+  return fallback || defaultVal;
+}
+function mergeStarterSettings(parsedSettings, starterSettings) {
+  const baseStarter = starterSettings ?? {};
+  const baseParsed = parsedSettings ?? {};
+  return {
+    ...baseStarter,
+    ...baseParsed,
+    department: pickNonDefaultSetting(
+      baseParsed.department,
+      baseStarter.department,
+      "general"
+    ),
+    defaultPriority: pickNonDefaultSetting(
+      baseParsed.defaultPriority,
+      baseStarter.defaultPriority,
+      "normal"
+    ),
+    enableBookingBridge: baseParsed.enableBookingBridge ?? baseStarter.enableBookingBridge,
+    enableCertificateBridge: baseParsed.enableCertificateBridge ?? baseStarter.enableCertificateBridge
+  };
+}
+function enrichFormWithStarterTemplate(parsed, starterTpl) {
+  if (!starterTpl) return parsed;
+  const category = parsed.category && parsed.category !== "contact" ? parsed.category : starterTpl.category;
+  const checklistTemplate = parsed.checklistTemplate?.length ? parsed.checklistTemplate : starterTpl.checklistTemplate || [];
+  const translations = Object.keys(parsed.translations || {}).length ? parsed.translations : starterTpl.translations || {};
+  return {
+    ...parsed,
+    category,
+    checklistTemplate,
+    translations,
+    settings: mergeStarterSettings(parsed.settings, starterTpl.settings)
+  };
+}
+async function syncFormFromBuilderCms(strapi, cmsForm) {
+  if (!cmsForm) return null;
+  const parsed = fromFormBuilderCmsRow(cmsForm);
+  const rawSettings = cmsForm.settings || {};
+  const starterTpl = STARTER_FORM_TEMPLATES.find(
+    (t) => t.form.slug === parsed.slug || t.id === parsed.slug
+  )?.form;
+  const needsBackfill = !rawSettings.inbox || shouldBackfillStarterTemplate(parsed, starterTpl);
+  if (needsBackfill && cmsForm.id && isFormBuilderCmsAvailable(strapi)) {
+    const enriched = enrichFormWithStarterTemplate(parsed, starterTpl);
+    const payload = toFormBuilderCmsPayload(enriched, cmsForm);
+    const updated = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).update({
+      where: { id: cmsForm.id },
+      data: {
+        settings: payload.settings,
+        publishedData: payload.publishedData
+      }
+    });
+    return fromFormBuilderCmsRow(updated || cmsForm, enriched);
+  }
+  return parsed;
+}
+function pickVal(...values) {
+  for (const v of values) {
+    if (v !== void 0 && v !== null && v !== "") return v;
+  }
+  return values[values.length - 1];
+}
+function pickDefVal(...values) {
+  for (const v of values) {
+    if (v !== void 0 && v !== null) return v;
+  }
+  return values[values.length - 1];
+}
+async function findExistingCmsFormRow(query, input) {
+  if (input.formBuilderId) {
+    const byId = await query.findOne({ where: { id: input.formBuilderId } });
+    if (byId) return byId;
+  }
+  if (input.slug) {
+    const bySlug = await query.findOne({ where: { slug: input.slug } });
+    if (bySlug) return bySlug;
+  }
+  return null;
+}
+function buildMergedFormRecord(input, existing) {
+  const publishedAt = input.publishedAt !== void 0 ? input.publishedAt : pickDefVal(existing?.publishedAt, (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    documentId: existing?.documentId,
+    title: pickVal(input.title, existing?.title, "Untitled Form"),
+    slug: pickVal(input.slug, existing?.slug, "form"),
+    description: pickDefVal(input.description, existing?.description, ""),
+    category: pickVal(input.category, existing?.category, "contact"),
+    fields: pickVal(input.fields, existing?.fields, []),
+    checklistTemplate: pickDefVal(
+      input.checklistTemplate,
+      existing?.checklistTemplate,
+      []
+    ),
+    settings: {
+      ...pickDefVal(existing?.settings, {}),
+      ...pickDefVal(input.settings, {})
+    },
+    translations: pickDefVal(input.translations, existing?.translations, {}),
+    active: pickDefVal(input.active, existing?.active, true),
+    submissionCount: pickDefVal(
+      input.submissionCount,
+      existing?.submissionCount,
+      0
+    ),
+    formBuilderId: pickDefVal(
+      input.formBuilderId,
+      existing?.formBuilderId,
+      null
+    ),
+    formBuilderSlug: pickDefVal(
+      input.formBuilderSlug,
+      existing?.formBuilderSlug,
+      input.slug
+    ),
+    publishedAt
+  };
+}
+const formService = ({ strapi }) => ({
+  isFormBuilderCmsAvailable() {
+    return isFormBuilderCmsAvailable(strapi);
+  },
+  async listFormBuilderForms() {
+    return listFormBuilderForms(strapi);
+  },
+  async syncFormToBuilderCms(form) {
+    return syncFormToBuilderCms(strapi, form);
+  },
+  async syncFormFromBuilderCms(cmsForm) {
+    return syncFormFromBuilderCms(strapi, cmsForm);
+  },
+  async syncWithFormBuilderCms() {
+    if (!this.isFormBuilderCmsAvailable()) {
+      return {
+        available: false,
+        syncedToBuilder: 0,
+        syncedFromBuilder: 0,
+        forms: []
+      };
+    }
+    const cmsForms = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).findMany({ orderBy: { createdAt: "desc" } });
+    let syncedFromBuilder = 0;
+    for (const cmsForm of cmsForms || []) {
+      const synced = await this.syncFormFromBuilderCms(cmsForm);
+      if (synced) syncedFromBuilder += 1;
+    }
+    await syncSubmissionsFromFormBuilderCms(strapi);
+    const forms = await this.listForms({ activeOnly: false });
+    return {
+      available: true,
+      syncedToBuilder: 0,
+      syncedFromBuilder,
+      forms
+    };
+  },
+  async listForms(params) {
+    if (!this.isFormBuilderCmsAvailable()) return [];
+    const cmsRows = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).findMany({ orderBy: { createdAt: "desc" } });
+    const allForms = await Promise.all(
+      (cmsRows || []).map(async (row) => {
+        const parsed = fromFormBuilderCmsRow(row);
+        const count = await countSubmissionsForForm(
+          strapi,
+          Number(row.id),
+          parsed.slug
+        );
+        return {
+          ...parsed,
+          submissionCount: Math.max(count, parsed.submissionCount || 0)
+        };
+      })
+    );
+    const filtered = allForms.filter((doc) => {
+      if (params?.category && doc.category !== params.category) return false;
+      if (params?.activeOnly !== false && doc.active === false) return false;
+      return true;
+    });
+    return filtered.map(
+      (doc) => params?.publicSafe ? sanitizePublicForm(doc, params?.locale) : params?.locale ? localizeFormForLocale(doc, params.locale) : doc
+    );
+  },
+  async findBySlug(slug, options2) {
+    if (!this.isFormBuilderCmsAvailable()) return null;
+    const cmsRow = await strapi.db.query(FORM_BUILDER_CMS_FORM_UID).findOne({ where: { slug } });
+    if (!cmsRow) return null;
+    const form = fromFormBuilderCmsRow(cmsRow);
+    const count = await countSubmissionsForForm(
+      strapi,
+      Number(cmsRow.id),
+      form.slug
+    );
+    form.submissionCount = Math.max(count, form.submissionCount || 0);
+    if (options2?.publicSafe) {
+      return sanitizePublicForm(form, options2?.locale);
+    }
+    if (options2?.locale) {
+      return localizeFormForLocale(form, options2.locale);
+    }
+    return form;
+  },
+  async saveForm(input) {
+    const query = strapi.db.query(FORM_BUILDER_CMS_FORM_UID);
+    const existingRow = await findExistingCmsFormRow(query, input);
+    const existing = existingRow ? fromFormBuilderCmsRow(existingRow) : null;
+    const mergedForm = buildMergedFormRecord(input, existing);
+    const payload = toFormBuilderCmsPayload(mergedForm, existingRow);
+    const savedRow = existingRow?.id ? await query.update({
+      where: { id: existingRow.id },
+      data: {
+        ...payload,
+        slug: existingRow.slug || payload.slug
+      }
+    }) : await query.create({ data: payload });
+    return fromFormBuilderCmsRow(savedRow, mergedForm);
+  },
+  async createFromTemplate(templateId, overrides) {
+    const tpl = STARTER_FORM_TEMPLATES.find((t) => t.id === templateId);
+    if (!tpl) {
+      throw new Error(`Starter template "${templateId}" not found`);
+    }
+    return this.saveForm({
+      ...tpl.form,
+      ...overrides,
+      slug: overrides?.slug || tpl.form.slug,
+      title: overrides?.title || tpl.form.title
+    });
+  }
+});
+const settings = ({ strapi }) => ({
+  async getSettings() {
+    const pluginStore = strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID
+    });
+    const configDefaults = strapi.config.get(
+      `plugin::${PLUGIN_ID}`,
+      {}
+    );
+    const stored = await pluginStore.get({
+      key: "settings"
+    });
+    return {
+      ...DEFAULT_INBOX_SETTINGS,
+      ...configDefaults,
+      ...stored
+    };
+  },
+  async updateSettings(patch) {
+    const current = await this.getSettings();
+    const updated = {
+      ...current,
+      ...patch
+    };
+    const pluginStore = strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID
+    });
+    await pluginStore.set({
+      key: "settings",
+      value: updated
+    });
+    return updated;
+  }
+});
+async function tryCreatePluginBooking(strapi, existing, bookingInput, fallbackId) {
+  try {
+    const bookingsPlugin = strapi.plugin("bookings");
+    const bookingSvc = bookingsPlugin?.service("bookingService");
+    if (!bookingSvc?.createBooking) return fallbackId;
+    const createdBooking = await bookingSvc.createBooking({
+      serviceSlug: bookingInput.serviceSlug,
+      date: bookingInput.date,
+      startTime: bookingInput.startTime,
+      endTime: bookingInput.endTime ?? "11:00",
+      requesterName: existing.applicantName ?? "Applicant",
+      requesterEmail: existing.applicantEmail ?? "noreply@example.org",
+      requesterPhone: existing.applicantPhone ?? "",
+      notes: bookingInput.notes ?? `Casework Ref: ${existing.referenceCode}`
+    });
+    return createdBooking?.referenceCode || createdBooking?.documentId || fallbackId;
+  } catch {
+    return fallbackId;
+  }
+}
+async function scheduleBookingFromSubmission(strapi, documentId, bookingInput) {
+  const existing = await getDocuments(strapi, SUBMISSION_UID).findOne({
+    documentId
+  });
+  if (!existing) {
+    throw new Error(`Submission "${documentId}" not found`);
+  }
+  const bookingId = await tryCreatePluginBooking(
+    strapi,
+    existing,
+    bookingInput,
+    `BKG-${existing.referenceCode}`
+  );
+  const updated = await getDocuments(strapi, SUBMISSION_UID).update({
+    documentId,
+    data: {
+      status: "scheduled",
+      linkedBookingId: bookingId
+    }
+  });
+  return { submission: updated, bookingId };
+}
+function assertRequiredChecklistVerified(existing, requireVerified) {
+  if (requireVerified === false) return;
+  const unverifiedRequired = (existing.checklistItems || []).filter(
+    (item) => item.required && !item.verified
+  );
+  if (unverifiedRequired.length > 0) {
+    throw new Error(
+      `Cannot issue certificate: ${unverifiedRequired.length} required document(s) are not yet verified`
+    );
+  }
+}
+async function tryIssuePluginCertificate(strapi, existing, certInput, fallbackCertNumber) {
+  try {
+    const certsPlugin = strapi.plugin("certificates");
+    const certSvc = certsPlugin?.service("certificateService");
+    if (!certSvc?.issueCertificate) return fallbackCertNumber;
+    const issued = await certSvc.issueCertificate({
+      templateSlug: certInput?.templateSlug || "official-service-certificate",
+      recipientName: certInput?.recipientName || existing.applicantName || "Applicant",
+      recipientEmail: existing.applicantEmail,
+      metadata: {
+        submissionReference: existing.referenceCode,
+        formSlug: existing.formSlug
+      }
+    });
+    return issued?.certificateNumber || fallbackCertNumber;
+  } catch {
+    return fallbackCertNumber;
+  }
+}
+async function issueCertificateFromSubmission(strapi, documentId, certInput) {
+  const existing = await getDocuments(strapi, SUBMISSION_UID).findOne({
+    documentId
+  });
+  if (!existing) {
+    throw new Error(`Submission "${documentId}" not found`);
+  }
+  assertRequiredChecklistVerified(
+    existing,
+    certInput?.requireChecklistVerified
+  );
+  const certificateNumber = await tryIssuePluginCertificate(
+    strapi,
+    existing,
+    certInput,
+    `CERT-${existing.referenceCode}`
+  );
+  const updated = await getDocuments(strapi, SUBMISSION_UID).update({
+    documentId,
+    data: {
+      status: "completed",
+      linkedCertificateNumber: certificateNumber
+    }
+  });
+  return { submission: updated, certificateNumber };
+}
+async function exportSubmissionsCsv(strapi, submissions, formSlug) {
+  let fields = [];
+  if (formSlug) {
+    const formService2 = strapi.plugin(PLUGIN_ID).service("formService");
+    const form = await formService2.findBySlug(formSlug);
+    fields = form?.fields || [];
+  }
+  return submissionsToCsv(submissions, fields);
+}
+function firstStr(...vals) {
+  for (const val of vals) {
+    if (typeof val === "string" && val.trim().length > 0) return val.trim();
+  }
+  return "";
+}
+function enforceHoneypotAndRateLimit(form, settings2, payload, ip, nowMs) {
+  const honeypotField = firstStr(form.settings?.honeypotField, settings2.defaultHoneypotField) || "_website_url";
+  if (isHoneypotTriggered(payload, honeypotField)) {
+    const err = new Error("Bot submission rejected by honeypot");
+    err.name = "ForbiddenError";
+    throw err;
+  }
+  const rateLimit = form.settings?.rateLimitPerHour ?? settings2.defaultRateLimitPerHour ?? 15;
+  const limitCheck = defaultRateLimiter.check(ip, form.slug, rateLimit, nowMs);
+  if (!limitCheck.allowed) {
+    const err = new Error(
+      `Rate limit exceeded. Try again in ${limitCheck.retryAfterSeconds}s`
+    );
+    err.name = "TooManyRequestsError";
+    throw err;
+  }
+}
+async function enforceCaptchaVerification(form, settings2, payload, ip, meta) {
+  const captchaProvider = form.settings?.captchaProvider || settings2.defaultCaptchaProvider || "none";
+  if (captchaProvider === "none") return;
+  const providerSecret = captchaProvider === "turnstile" ? settings2.turnstileSecretKey : settings2.recaptchaSecretKey;
+  const secret = firstStr(form.settings?.captchaSecretKey, providerSecret);
+  const token = firstStr(
+    meta?.captchaToken,
+    payload.captchaToken,
+    payload["cf-turnstile-response"],
+    payload["g-recaptcha-response"]
+  );
+  const verified = await verifyCaptchaToken(
+    captchaProvider,
+    secret,
+    token,
+    ip,
+    meta?.fetchImpl
+  );
+  if (!verified) {
+    const err = new Error("CAPTCHA verification failed");
+    err.name = "ValidationError";
+    throw err;
+  }
+}
+function validateOrThrow(form, payload, locale) {
+  const validation = validateFormSubmission(form.fields || [], payload, locale);
+  if (!validation.valid) {
+    const firstField = Object.keys(validation.errors)[0];
+    const firstError = validation.errors[firstField]?.[0] || "Validation failed";
+    const err = new Error(firstError);
+    err.name = "ValidationError";
+    err.details = validation.errors;
+    throw err;
+  }
+  return validation.cleanedData;
+}
+function buildSubmissionDataRecord(params) {
+  const {
+    form,
+    settings: settings2,
+    cleaned,
+    payload,
+    locale,
+    ip,
+    userAgent,
+    nowMs,
+    mirroredCmsSubmissionId
+  } = params;
+  const applicantName = firstStr(
+    cleaned.applicantName,
+    cleaned.fullName,
+    cleaned.name,
+    payload.applicantName
+  );
+  const applicantEmail = firstStr(
+    cleaned.applicantEmail,
+    cleaned.email,
+    payload.applicantEmail
+  );
+  const applicantPhone = firstStr(
+    cleaned.applicantPhone,
+    cleaned.phone,
+    payload.applicantPhone
+  );
+  const timestamp = nowMs ?? Date.now();
+  const nowIso = new Date(timestamp).toISOString();
+  const secondaryCal = settings2.secondaryCalendars?.[0] ?? "islamic-umalqura";
+  const converted = convertIsoDateToCalendar(
+    nowIso.slice(0, 10),
+    secondaryCal,
+    locale
+  );
+  const checklistItems = (form.checklistTemplate ?? []).map(
+    (item) => ({
+      ...item,
+      verified: false
+    })
+  );
+  return {
+    referenceCode: generateReferenceCode(new Date(timestamp)),
+    formSlug: form.slug,
+    formTitle: form.title,
+    category: form.category ?? "contact",
+    status: "new",
+    priority: form.settings?.defaultPriority ?? "normal",
+    department: form.settings?.department ?? "general",
+    locale,
+    applicantName: applicantName || void 0,
+    applicantEmail: applicantEmail || void 0,
+    applicantPhone: applicantPhone || void 0,
+    data: cleaned,
+    checklistItems,
+    formBuilderSubmissionId: mirroredCmsSubmissionId,
+    ipAddress: ip,
+    userAgent,
+    submittedAt: nowIso,
+    secondaryDate: {
+      formatted: converted.formatted,
+      year: converted.year,
+      month: converted.month,
+      day: converted.day
+    }
+  };
+}
+const submissionService = ({ strapi }) => ({
+  async testCaptchaSecret(provider, secret, fetchImpl) {
+    return testCaptchaSecretKey(provider, secret, fetchImpl);
+  },
+  async submitForm(slug, payload, meta) {
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const formService2 = strapi.plugin(PLUGIN_ID).service("formService");
+    const settings2 = await settingsService.getSettings();
+    const form = await formService2.findBySlug(slug);
+    if (!form || form.active === false) {
+      const err = new Error(`Active form "${slug}" not found`);
+      err.name = "NotFoundError";
+      throw err;
+    }
+    const locale = firstStr(meta?.locale, payload.locale, settings2.defaultLocale) || "es";
+    const ip = firstStr(meta?.ip) || "127.0.0.1";
+    const userAgent = firstStr(meta?.userAgent);
+    enforceHoneypotAndRateLimit(form, settings2, payload, ip, meta?.nowMs);
+    await enforceCaptchaVerification(form, settings2, payload, ip, meta);
+    const cleaned = validateOrThrow(form, payload, locale);
+    const mirroredCmsSubmissionId = await mirrorSubmissionToFormBuilderCms(
+      strapi,
+      {
+        settings: settings2,
+        form,
+        cleanedData: cleaned,
+        ip,
+        userAgent
+      }
+    );
+    const submissionData = buildSubmissionDataRecord({
+      form,
+      settings: settings2,
+      cleaned,
+      payload,
+      locale,
+      ip,
+      userAgent,
+      nowMs: meta?.nowMs,
+      mirroredCmsSubmissionId
+    });
+    const created = await getDocuments(strapi, SUBMISSION_UID).create({
+      data: submissionData
+    });
+    strapi.eventHub?.emit("inbox.submission.created", {
+      submission: created,
+      formSlug: form.slug
+    });
+    return created;
+  },
+  async ingestFormBuilderSubmission(cmsSubmission, meta) {
+    return ingestFormBuilderSubmission(strapi, cmsSubmission, meta);
+  },
+  async listSubmissions(filters) {
+    await syncSubmissionsFromFormBuilderCms(strapi);
+    const queryFilters = {};
+    if (filters?.formSlug) queryFilters.formSlug = filters.formSlug;
+    if (filters?.status) queryFilters.status = filters.status;
+    if (filters?.priority) queryFilters.priority = filters.priority;
+    if (filters?.department) queryFilters.department = filters.department;
+    const docs = await getDocuments(strapi, SUBMISSION_UID).findMany({
+      filters: queryFilters,
+      limit: filters?.limit || 100
+    });
+    return docs;
+  },
+  async updateCasework(documentId, patch) {
+    const existing = await getDocuments(strapi, SUBMISSION_UID).findOne({
+      documentId
+    });
+    if (!existing) {
+      throw new Error(`Submission "${documentId}" not found`);
+    }
+    const updated = await getDocuments(strapi, SUBMISSION_UID).update({
+      documentId,
+      data: {
+        ...patch.status ? { status: patch.status } : {},
+        ...patch.priority ? { priority: patch.priority } : {},
+        ...patch.department !== void 0 ? { department: patch.department } : {},
+        ...patch.staffNotes !== void 0 ? { staffNotes: patch.staffNotes } : {},
+        ...patch.assignedTo !== void 0 ? { assignedTo: patch.assignedTo } : {},
+        ...patch.checklistItems ? { checklistItems: patch.checklistItems } : {}
+      }
+    });
+    strapi.eventHub?.emit("inbox.submission.updated", {
+      submission: updated
+    });
+    return updated;
+  },
+  async scheduleBookingFromSubmission(documentId, bookingInput) {
+    return scheduleBookingFromSubmission(strapi, documentId, bookingInput);
+  },
+  async issueCertificateFromSubmission(documentId, certInput) {
+    return issueCertificateFromSubmission(strapi, documentId, certInput);
+  },
+  async exportCsv(formSlug) {
+    const submissions = await this.listSubmissions(
+      formSlug ? { formSlug, limit: 1e3 } : { limit: 1e3 }
+    );
+    return exportSubmissionsCsv(strapi, submissions, formSlug);
+  }
+});
+function normalizeSubscriberTopics(topics) {
+  return Array.isArray(topics) && topics.length > 0 ? Array.from(new Set(topics)) : ["announcements"];
+}
+function pickSubscriberStr(...values) {
+  for (const val of values) {
+    if (val && val.trim().length > 0) return val;
+  }
+  return "";
+}
+function buildSubscriberPayload(email, input, existing, settings2) {
+  const doubleOptIn = settings2.enableDoubleOptIn !== false;
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const status = doubleOptIn ? "pending" : "confirmed";
+  return {
+    email,
+    fullName: pickSubscriberStr(input.fullName, existing?.fullName),
+    phone: pickSubscriberStr(input.phone, existing?.phone),
+    locale: pickSubscriberStr(input.locale, settings2.defaultLocale, "es"),
+    topics: normalizeSubscriberTopics(input.topics),
+    status,
+    confirmToken: doubleOptIn ? randomBytes(20).toString("hex") : null,
+    unsubscribeToken: pickSubscriberStr(
+      existing?.unsubscribeToken,
+      randomBytes(20).toString("hex")
+    ),
+    confirmedAt: doubleOptIn ? null : nowIso,
+    unsubscribedAt: null,
+    sourceFormSlug: pickSubscriberStr(
+      input.sourceFormSlug,
+      existing?.sourceFormSlug,
+      "newsletter"
+    )
+  };
+}
+const subscriberService = ({ strapi }) => ({
+  async subscribe(input) {
+    const email = (input.email || "").trim().toLowerCase();
+    if (!isValidEmail(email)) {
+      const err = new Error("A valid email address is required to subscribe");
+      err.name = "ValidationError";
+      throw err;
+    }
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const settings2 = await settingsService.getSettings();
+    const existingDocs = await getDocuments(strapi, SUBSCRIBER_UID).findMany({
+      filters: { email },
+      limit: 1
+    });
+    const existing = existingDocs[0] || null;
+    const payload = buildSubscriberPayload(email, input, existing, settings2);
+    if (existing?.documentId) {
+      const updated = await getDocuments(strapi, SUBSCRIBER_UID).update({
+        documentId: existing.documentId,
+        data: payload
+      });
+      return updated;
+    }
+    const created = await getDocuments(strapi, SUBSCRIBER_UID).create({
+      data: payload
+    });
+    strapi.eventHub?.emit("inbox.subscriber.created", {
+      subscriber: created
+    });
+    return created;
+  },
+  async confirmSubscription(token) {
+    const trimmed = (token || "").trim();
+    if (!trimmed) {
+      throw new Error("Confirmation token is required");
+    }
+    const docs = await getDocuments(strapi, SUBSCRIBER_UID).findMany({
+      filters: { confirmToken: trimmed },
+      limit: 1
+    });
+    const subscriber2 = docs[0];
+    if (!subscriber2 || !subscriber2.documentId) {
+      const err = new Error("Invalid or expired confirmation token");
+      err.name = "NotFoundError";
+      throw err;
+    }
+    const updated = await getDocuments(strapi, SUBSCRIBER_UID).update({
+      documentId: subscriber2.documentId,
+      data: {
+        status: "confirmed",
+        confirmToken: null,
+        confirmedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        unsubscribedAt: null
+      }
+    });
+    strapi.eventHub?.emit("inbox.subscriber.confirmed", {
+      subscriber: updated
+    });
+    return updated;
+  },
+  async unsubscribe(token) {
+    const trimmed = (token || "").trim();
+    if (!trimmed) {
+      throw new Error("Unsubscribe token is required");
+    }
+    const docs = await getDocuments(strapi, SUBSCRIBER_UID).findMany({
+      filters: { unsubscribeToken: trimmed },
+      limit: 1
+    });
+    const subscriber2 = docs[0];
+    if (!subscriber2 || !subscriber2.documentId) {
+      const err = new Error("Invalid unsubscribe token");
+      err.name = "NotFoundError";
+      throw err;
+    }
+    const updated = await getDocuments(strapi, SUBSCRIBER_UID).update({
+      documentId: subscriber2.documentId,
+      data: {
+        status: "unsubscribed",
+        unsubscribedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    strapi.eventHub?.emit("inbox.subscriber.unsubscribed", {
+      subscriber: updated
+    });
+    return updated;
+  },
+  async listSubscribers(filters) {
+    const queryFilters = {};
+    if (filters?.status) queryFilters.status = filters.status;
+    if (filters?.locale) queryFilters.locale = filters.locale;
+    const docs = await getDocuments(strapi, SUBSCRIBER_UID).findMany({
+      filters: queryFilters,
+      limit: 500
+    });
+    if (filters?.topic) {
+      return docs.filter((sub) => (sub.topics || []).includes(filters.topic));
+    }
+    return docs;
+  }
+});
+const services = {
+  settings,
+  formService,
+  submissionService,
+  subscriberService,
+  alertService
+};
+const serverEntry = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  contentTypes,
+  controllers,
+  routes,
+  services
+};
+export {
+  serverEntry as default
+};