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

package/dist/server/index.cjs

@@ -0,0 +1,2585 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const node_crypto = require("node:crypto");
+const PLUGIN_ID = "calendar";
+function getCalendarService(strapi, pluginId, serviceName) {
+  return strapi.plugin(pluginId).service(serviceName);
+}
+function formatErrorMessage(err, fallback) {
+  if (err instanceof Error && err.message) {
+    return err.message;
+  }
+  return fallback;
+}
+const bootstrap = async ({ strapi }) => {
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Read Calendar & Occurrences",
+      uid: "read",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Create & Reschedule Calendar Entries",
+      uid: "update",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Manage Calendar Settings",
+      uid: "settings.update",
+      pluginName: PLUGIN_ID
+    }
+  ];
+  const actionProvider = strapi.admin?.services?.permission?.actionProvider;
+  if (actionProvider && typeof actionProvider.registerMany === "function") {
+    await actionProvider.registerMany(actions);
+  }
+  const settingsService = getCalendarService(strapi, PLUGIN_ID, "settings");
+  if (settingsService && typeof settingsService.ensureInitialized === "function") {
+    await settingsService.ensureInitialized();
+  }
+};
+const DEFAULT_CALENDAR_SETTINGS = {
+  theme: "breeze",
+  colorScheme: "auto",
+  themePalette: "default",
+  secondaryCalendarLanguage: "local",
+  defaultTimezone: "UTC",
+  defaultLocale: "auto",
+  direction: "auto",
+  defaultView: "dayGridMonth",
+  firstDayOfWeek: 1,
+  weekNumbers: false,
+  weekNumberCalculation: "ISO",
+  timeFormat24h: true,
+  startHour: "07:00:00",
+  endHour: "21:00:00",
+  slotDuration: "00:30:00",
+  primaryColor: "#0284C7",
+  showWeekends: true,
+  showTodayButton: true,
+  showCreateButton: true,
+  monthView: true,
+  weekView: true,
+  dayView: true,
+  agendaView: true,
+  yearView: true,
+  businessHours: [
+    {
+      daysOfWeek: [1, 2, 3, 4, 5],
+      startTime: "08:00",
+      endTime: "18:00"
+    }
+  ],
+  feedTitle: "Organization Calendar",
+  sources: [],
+  secondaryCalendars: [],
+  recurrencePresets: [
+    { id: "daily", label: "Daily", rrule: "FREQ=DAILY;INTERVAL=1" },
+    {
+      id: "weekly-mon",
+      label: "Weekly on Mondays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=MO"
+    },
+    {
+      id: "weekly-tue",
+      label: "Weekly on Tuesdays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=TU"
+    },
+    {
+      id: "weekly-wed",
+      label: "Weekly on Wednesdays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=WE"
+    },
+    {
+      id: "weekly-thu",
+      label: "Weekly on Thursdays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=TH"
+    },
+    {
+      id: "weekly-fri",
+      label: "Weekly on Fridays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=FR"
+    },
+    {
+      id: "weekly-sat",
+      label: "Weekly on Saturdays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=SA"
+    },
+    {
+      id: "weekly-sun",
+      label: "Weekly on Sundays",
+      rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=SU"
+    },
+    { id: "monthly", label: "Monthly", rrule: "FREQ=MONTHLY;INTERVAL=1" },
+    { id: "yearly", label: "Yearly", rrule: "FREQ=YEARLY;INTERVAL=1" }
+  ]
+};
+const config = {
+  default: DEFAULT_CALENDAR_SETTINGS,
+  validator(config2) {
+    if (config2.firstDayOfWeek !== void 0 && (config2.firstDayOfWeek < 0 || config2.firstDayOfWeek > 6)) {
+      throw new Error(
+        "calendar plugin config: firstDayOfWeek must be between 0 and 6"
+      );
+    }
+  }
+};
+function readOptString(val) {
+  return typeof val === "string" && val ? val : void 0;
+}
+function parseQuickCreateBody(body) {
+  const statusRaw = body.bookingStatus;
+  const bookingStatus = statusRaw === "pending" || statusRaw === "confirmed" ? statusRaw : void 0;
+  return {
+    sourceId: readOptString(body.sourceId),
+    title: String(body.title ?? ""),
+    startDate: String(body.startDate ?? ""),
+    endDate: readOptString(body.endDate),
+    location: readOptString(body.location),
+    category: readOptString(body.category),
+    summary: readOptString(body.summary),
+    rrule: readOptString(body.rrule),
+    customerName: readOptString(body.customerName),
+    customerEmail: readOptString(body.customerEmail),
+    customerPhone: readOptString(body.customerPhone),
+    partySize: body.partySize !== void 0 ? Number(body.partySize) : void 0,
+    bookingStatus
+  };
+}
+const admin$1 = ({ strapi }) => {
+  const getSettingsService = () => getCalendarService(strapi, PLUGIN_ID, "settings");
+  const getOccurrenceService = () => getCalendarService(strapi, PLUGIN_ID, "occurrence");
+  return {
+    async getCalendar(ctx) {
+      try {
+        const query = ctx.query ?? {};
+        const occurrences = await getOccurrenceService().getOccurrences({
+          from: readOptString(query.from),
+          to: readOptString(query.to),
+          locale: readOptString(query.locale),
+          category: readOptString(query.category),
+          sourceId: readOptString(query.sourceId),
+          includeDrafts: query.includeDrafts !== "false"
+        });
+        const settings2 = await getSettingsService().getSettings();
+        ctx.body = {
+          data: {
+            occurrences,
+            settings: settings2
+          }
+        };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Failed to load calendar data.")
+          }
+        };
+      }
+    },
+    async reschedule(ctx) {
+      try {
+        const body = ctx.request?.body ?? {};
+        const updated = await getOccurrenceService().rescheduleOccurrence({
+          sourceId: readOptString(body.sourceId),
+          uid: readOptString(body.uid),
+          documentId: String(body.documentId ?? ""),
+          locale: readOptString(body.locale),
+          occurrenceDate: String(body.occurrenceDate ?? ""),
+          newStartDate: String(body.newStartDate ?? ""),
+          newEndDate: readOptString(body.newEndDate),
+          applyToSeries: Boolean(body.applyToSeries),
+          cancelOccurrence: Boolean(body.cancelOccurrence)
+        });
+        ctx.body = { data: updated };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(
+              err,
+              "Failed to reschedule occurrence."
+            )
+          }
+        };
+      }
+    },
+    async quickCreate(ctx) {
+      try {
+        const body = ctx.request?.body ?? {};
+        const created = await getOccurrenceService().quickCreateEntry(
+          parseQuickCreateBody(body)
+        );
+        ctx.status = 201;
+        ctx.body = { data: created };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(
+              err,
+              "Failed to create calendar entry."
+            )
+          }
+        };
+      }
+    },
+    async getSettings(ctx) {
+      try {
+        const settings2 = await getSettingsService().getSettings();
+        ctx.body = { data: settings2 };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Failed to fetch settings.")
+          }
+        };
+      }
+    },
+    async updateSettings(ctx) {
+      try {
+        const body = ctx.request?.body ?? {};
+        const updated = await getSettingsService().updateSettings(body);
+        ctx.body = { data: updated };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Failed to update settings.")
+          }
+        };
+      }
+    },
+    async clearSettings(ctx) {
+      try {
+        const reset = await getSettingsService().clearSettings();
+        ctx.body = { data: reset };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Failed to reset settings.")
+          }
+        };
+      }
+    },
+    async getContentTypes(ctx) {
+      try {
+        const contentTypes = getSettingsService().discoverContentTypes();
+        ctx.body = { data: contentTypes };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(
+              err,
+              "Failed to discover content types."
+            )
+          }
+        };
+      }
+    }
+  };
+};
+const contentApi$1 = ({ strapi }) => {
+  const getOccurrenceService = () => getCalendarService(strapi, PLUGIN_ID, "occurrence");
+  const getIcalService = () => getCalendarService(strapi, PLUGIN_ID, "ical");
+  return {
+    async getOccurrences(ctx) {
+      try {
+        const query = ctx.query ?? {};
+        const occurrences = await getOccurrenceService().getOccurrences({
+          from: typeof query.from === "string" ? query.from : void 0,
+          to: typeof query.to === "string" ? query.to : void 0,
+          locale: typeof query.locale === "string" ? query.locale : void 0,
+          category: typeof query.category === "string" ? query.category : void 0,
+          sourceId: typeof query.sourceId === "string" ? query.sourceId : void 0,
+          documentId: typeof query.documentId === "string" ? query.documentId : void 0,
+          includeDrafts: false,
+          publicOnly: true
+        });
+        ctx.body = {
+          data: occurrences,
+          meta: {
+            total: occurrences.length
+          }
+        };
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Could not fetch occurrences.")
+          }
+        };
+      }
+    },
+    async downloadFeedIcs(ctx) {
+      try {
+        const query = ctx.query ?? {};
+        const ics = await getIcalService().buildFeedIcs({
+          from: typeof query.from === "string" ? query.from : void 0,
+          to: typeof query.to === "string" ? query.to : void 0,
+          locale: typeof query.locale === "string" ? query.locale : void 0,
+          category: typeof query.category === "string" ? query.category : void 0,
+          sourceId: typeof query.sourceId === "string" ? query.sourceId : void 0,
+          publicOnly: true
+        });
+        ctx.set?.("Content-Type", "text/calendar; charset=utf-8");
+        ctx.set?.("Content-Disposition", 'attachment; filename="calendar.ics"');
+        ctx.set?.("X-Content-Type-Options", "nosniff");
+        ctx.body = ics;
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Could not generate iCal feed.")
+          }
+        };
+      }
+    },
+    async downloadEventIcs(ctx) {
+      try {
+        const documentId = String(ctx.params?.documentId ?? "");
+        const query = ctx.query ?? {};
+        const ics = await getIcalService().buildSingleInviteIcs({
+          documentId,
+          occurrenceDate: typeof query.occurrenceDate === "string" ? query.occurrenceDate : void 0,
+          locale: typeof query.locale === "string" ? query.locale : void 0,
+          publicOnly: true
+        });
+        ctx.set?.("Content-Type", "text/calendar; charset=utf-8");
+        ctx.set?.(
+          "Content-Disposition",
+          `attachment; filename="invite-${documentId.replace(/[^a-zA-Z0-9_-]/g, "")}.ics"`
+        );
+        ctx.set?.("X-Content-Type-Options", "nosniff");
+        ctx.body = ics;
+      } catch (err) {
+        ctx.status = 400;
+        ctx.body = {
+          error: {
+            message: formatErrorMessage(err, "Could not generate invite .ics.")
+          }
+        };
+      }
+    }
+  };
+};
+const controllers = {
+  admin: admin$1,
+  "content-api": contentApi$1
+};
+const destroy = ({ strapi: _strapi }) => {
+};
+const register = ({ strapi }) => {
+  strapi.customFields.register({
+    name: "rrule",
+    plugin: PLUGIN_ID,
+    type: "json",
+    inputSize: {
+      default: 12,
+      isResizable: true
+    }
+  });
+};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/calendar",
+      handler: "admin.getCalendar",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.read`] }
+          }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/calendar/reschedule",
+      handler: "admin.reschedule",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.update`] }
+          }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/calendar/quick-create",
+      handler: "admin.quickCreate",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.update`] }
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "admin.getContentTypes",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.read`] }
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "admin.getSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.read`] }
+          }
+        ]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "admin.updateSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.settings.update`] }
+          }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/clear-settings",
+      handler: "admin.clearSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: [`plugin::${PLUGIN_ID}.settings.update`] }
+          }
+        ]
+      }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/occurrences",
+      handler: "content-api.getOccurrences",
+      config: {}
+    },
+    {
+      method: "GET",
+      path: "/feed.ics",
+      handler: "content-api.downloadFeedIcs",
+      config: {}
+    },
+    {
+      method: "GET",
+      path: "/:documentId/invite.ics",
+      handler: "content-api.downloadEventIcs",
+      config: {}
+    }
+  ]
+};
+const routes = {
+  admin,
+  "content-api": contentApi
+};
+function escapeIcsText(value) {
+  if (!value) return "";
+  return String(value).replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\r?\n/g, "\\n");
+}
+const utf8Encoder = new TextEncoder();
+function foldIcsLine(line) {
+  if (utf8Encoder.encode(line).byteLength <= 75) {
+    return line;
+  }
+  const chunks = [];
+  let current = "";
+  let currentBytes = 0;
+  for (const codePoint of line) {
+    const cpBytes = utf8Encoder.encode(codePoint).byteLength;
+    if (currentBytes + cpBytes > 75) {
+      chunks.push(current);
+      current = ` ${codePoint}`;
+      currentBytes = 1 + cpBytes;
+    } else {
+      current += codePoint;
+      currentBytes += cpBytes;
+    }
+  }
+  if (current) {
+    chunks.push(current);
+  }
+  return chunks.join("\r\n");
+}
+const pad = (n) => String(n).padStart(2, "0");
+function toIcsTimestamp(iso, allDay = false) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) {
+    return "19700101T000000Z";
+  }
+  const y = date.getUTCFullYear();
+  const m = pad(date.getUTCMonth() + 1);
+  const d = pad(date.getUTCDate());
+  if (allDay) {
+    return `${y}${m}${d}`;
+  }
+  const hh = pad(date.getUTCHours());
+  const mm = pad(date.getUTCMinutes());
+  const ss = pad(date.getUTCSeconds());
+  return `${y}${m}${d}T${hh}${mm}${ss}Z`;
+}
+function toExclusiveAllDayEndStamp(startIso, endIso) {
+  const startDate = new Date(startIso);
+  const endDate = new Date(endIso);
+  if (Number.isNaN(startDate.getTime())) {
+    return "19700102";
+  }
+  const startMidnight = Date.UTC(
+    startDate.getUTCFullYear(),
+    startDate.getUTCMonth(),
+    startDate.getUTCDate()
+  );
+  const endMidnight = Number.isNaN(endDate.getTime()) ? startMidnight : Date.UTC(
+    endDate.getUTCFullYear(),
+    endDate.getUTCMonth(),
+    endDate.getUTCDate()
+  );
+  const isAlreadyExclusiveMidnight = !Number.isNaN(endDate.getTime()) && endMidnight > startMidnight && endDate.getUTCHours() === 0 && endDate.getUTCMinutes() === 0 && endDate.getUTCSeconds() === 0;
+  const exclusiveDate = new Date(
+    isAlreadyExclusiveMidnight ? endMidnight : Math.max(startMidnight, endMidnight) + 864e5
+  );
+  return toIcsTimestamp(exclusiveDate.toISOString(), true);
+}
+function buildCalendarLinks(params) {
+  const startStamp = toIcsTimestamp(params.startDate, params.allDay);
+  const endStamp = params.allDay ? toExclusiveAllDayEndStamp(params.startDate, params.endDate) : toIcsTimestamp(params.endDate, false);
+  const googleParams = new URLSearchParams({
+    action: "TEMPLATE",
+    text: params.title,
+    dates: `${startStamp}/${endStamp}`
+  });
+  if (params.summary) googleParams.set("details", params.summary);
+  if (params.location) googleParams.set("location", params.location);
+  const outlookParams = new URLSearchParams({
+    path: "/calendar/action/compose",
+    rru: "addevent",
+    subject: params.title,
+    startdt: params.startDate,
+    enddt: params.endDate
+  });
+  if (params.summary) outlookParams.set("body", params.summary);
+  if (params.location) outlookParams.set("location", params.location);
+  const yahooParams = new URLSearchParams({
+    v: "60",
+    title: params.title,
+    st: startStamp,
+    et: endStamp
+  });
+  if (params.summary) yahooParams.set("desc", params.summary);
+  if (params.location) yahooParams.set("in_loc", params.location);
+  const querySuffix = params.occurrenceDate ? `?occurrenceDate=${encodeURIComponent(params.occurrenceDate)}` : "";
+  return {
+    google: `https://calendar.google.com/calendar/render?${googleParams.toString()}`,
+    outlook: `https://outlook.live.com/calendar/0/deeplink/compose?${outlookParams.toString()}`,
+    yahoo: `https://calendar.yahoo.com/?${yahooParams.toString()}`,
+    icsPath: `/api/calendar/${encodeURIComponent(params.documentId)}/invite.ics${querySuffix}`
+  };
+}
+function generateIcsCalendar(params) {
+  const nowStamp = toIcsTimestamp((/* @__PURE__ */ new Date()).toISOString());
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Vicacha Devs//Strapi Plugin Calendar//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    `X-WR-CALNAME:${escapeIcsText(params.calendarTitle)}`,
+    `X-WR-TIMEZONE:${escapeIcsText(params.timezone)}`
+  ];
+  for (const occ of params.occurrences) {
+    lines.push("BEGIN:VEVENT");
+    lines.push(`UID:${escapeIcsText(occ.occurrenceId)}@strapi-plugin-calendar`);
+    lines.push(`DTSTAMP:${nowStamp}`);
+    if (occ.allDay) {
+      lines.push(`DTSTART;VALUE=DATE:${toIcsTimestamp(occ.startDate, true)}`);
+      lines.push(
+        `DTEND;VALUE=DATE:${toExclusiveAllDayEndStamp(occ.startDate, occ.endDate)}`
+      );
+    } else {
+      lines.push(`DTSTART:${toIcsTimestamp(occ.startDate, false)}`);
+      lines.push(`DTEND:${toIcsTimestamp(occ.endDate, false)}`);
+    }
+    lines.push(`SUMMARY:${escapeIcsText(occ.title)}`);
+    if (occ.summary) {
+      lines.push(`DESCRIPTION:${escapeIcsText(occ.summary)}`);
+    }
+    if (occ.location) {
+      lines.push(`LOCATION:${escapeIcsText(occ.location)}`);
+    }
+    if (occ.category) {
+      lines.push(`CATEGORIES:${escapeIcsText(occ.category)}`);
+    }
+    if (occ.alternateDates) {
+      for (const alt of Object.values(occ.alternateDates)) {
+        const safeCalId = alt.calendarId.replace(/[^A-Za-z0-9-]/g, "").toUpperCase();
+        if (!safeCalId) continue;
+        lines.push(`X-ALT-DATE-${safeCalId}:${escapeIcsText(alt.formatted)}`);
+      }
+    }
+    const icsStatus = occ.status === "cancelled" ? "CANCELLED" : occ.status === "postponed" ? "TENTATIVE" : "CONFIRMED";
+    lines.push(`STATUS:${icsStatus}`);
+    lines.push("END:VEVENT");
+  }
+  lines.push("END:VCALENDAR");
+  return `${lines.map(foldIcsLine).join("\r\n")}\r
+`;
+}
+const ical = ({ strapi }) => {
+  const getSettingsService = () => getCalendarService(strapi, PLUGIN_ID, "settings");
+  const getOccurrenceService = () => getCalendarService(strapi, PLUGIN_ID, "occurrence");
+  return {
+    async buildFeedIcs(params) {
+      const settings2 = await getSettingsService().getSettings();
+      const occurrences = await getOccurrenceService().getOccurrences({
+        ...params,
+        includeDrafts: false
+      });
+      return generateIcsCalendar({
+        calendarTitle: settings2.feedTitle || "Calendar",
+        timezone: settings2.defaultTimezone || "UTC",
+        occurrences
+      });
+    },
+    async buildSingleInviteIcs(params) {
+      const settings2 = await getSettingsService().getSettings();
+      const refYear = params.occurrenceDate && /^\d{4}-\d{2}-\d{2}$/.test(params.occurrenceDate) ? Number.parseInt(params.occurrenceDate.slice(0, 4), 10) : (/* @__PURE__ */ new Date()).getUTCFullYear();
+      const from = new Date(Date.UTC(refYear - 1, 0, 1)).toISOString();
+      const to = new Date(
+        Date.UTC(refYear + 2, 11, 31, 23, 59, 59)
+      ).toISOString();
+      let occurrences = await getOccurrenceService().getOccurrences({
+        documentId: params.documentId,
+        from,
+        to,
+        locale: params.locale,
+        includeDrafts: false,
+        publicOnly: params.publicOnly
+      });
+      if (params.occurrenceDate) {
+        occurrences = occurrences.filter(
+          (o) => o.occurrenceDate === params.occurrenceDate
+        );
+      } else if (occurrences.length > 1) {
+        occurrences = [occurrences[0]];
+      }
+      return generateIcsCalendar({
+        calendarTitle: occurrences[0]?.title || settings2.feedTitle || "Calendar Invite",
+        timezone: settings2.defaultTimezone || "UTC",
+        occurrences
+      });
+    }
+  };
+};
+const customFormatters = /* @__PURE__ */ new Map();
+function registerCalendarSystemFormatter(calendarId, formatter) {
+  if (!calendarId || typeof formatter !== "function") {
+    throw new Error("Both calendarId and formatter function are required.");
+  }
+  customFormatters.set(calendarId, formatter);
+}
+function unregisterCalendarSystemFormatter(calendarId) {
+  customFormatters.delete(calendarId);
+}
+function applyDayOffset(date, dayOffset) {
+  if (!dayOffset || !Number.isFinite(dayOffset)) {
+    return date;
+  }
+  const offsetDays = Math.trunc(dayOffset);
+  return new Date(date.getTime() + offsetDays * 864e5);
+}
+function parseDigits(raw) {
+  const n = Number.parseInt(raw.replace(/[^0-9]/g, ""), 10);
+  return Number.isFinite(n) ? n : 0;
+}
+const INTL_PART_FIELD_MAP = {
+  year: "year",
+  relatedYear: "year",
+  month: "month",
+  day: "day"
+};
+function parseIntlPartsToYmd(parts) {
+  const ymd = { year: 0, month: 0, day: 0 };
+  for (const part of parts) {
+    const key = INTL_PART_FIELD_MAP[String(part.type)];
+    if (!key) continue;
+    const val = parseDigits(part.value);
+    if (val > 0) ymd[key] = val;
+  }
+  return ymd.month >= 1 && ymd.day >= 1 ? ymd : null;
+}
+const intlFormatterCache = /* @__PURE__ */ new Map();
+function getCachedIntlFormatter(locale, options) {
+  const key = `${locale}|${options.year ?? ""}|${options.month ?? ""}|${options.day ?? ""}|${options.timeZone ?? "UTC"}`;
+  let fmt = intlFormatterCache.get(key);
+  if (!fmt) {
+    if (intlFormatterCache.size >= 200) {
+      const oldestKey = intlFormatterCache.keys().next().value;
+      if (oldestKey !== void 0) intlFormatterCache.delete(oldestKey);
+    }
+    fmt = new Intl.DateTimeFormat(locale, options);
+    intlFormatterCache.set(key, fmt);
+  }
+  return fmt;
+}
+function extractCalendarParts(date, intlCalendar, dayOffset = 0) {
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  const effectiveDate = applyDayOffset(date, dayOffset);
+  const calendarTag = (intlCalendar || "gregory").trim().toLowerCase();
+  try {
+    const formatter = getCachedIntlFormatter(`en-u-ca-${calendarTag}-nu-latn`, {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      timeZone: "UTC"
+    });
+    const parsed = parseIntlPartsToYmd(formatter.formatToParts(effectiveDate));
+    if (parsed) return parsed;
+  } catch {
+  }
+  return {
+    year: effectiveDate.getUTCFullYear(),
+    month: effectiveDate.getUTCMonth() + 1,
+    day: effectiveDate.getUTCDate()
+  };
+}
+function resolveCalendarLocaleTag(systemLocale, fallbackLocale) {
+  const rawLocale = systemLocale && systemLocale !== "auto" ? systemLocale : fallbackLocale && fallbackLocale !== "auto" ? fallbackLocale : "en";
+  return rawLocale.split("-u-")[0];
+}
+function tryFormatWithCustomFormatter(effectiveDate, system, effectiveLocale, compact) {
+  const customFn = customFormatters.get(system.id) ?? customFormatters.get(system.intlCalendar);
+  if (!customFn) return null;
+  try {
+    return customFn(effectiveDate, {
+      locale: effectiveLocale,
+      system,
+      compact
+    });
+  } catch {
+    return null;
+  }
+}
+function formatWithIntlFallback(effectiveDate, isoOrDateKey, intlLocale, compact) {
+  try {
+    const formatter = getCachedIntlFormatter(
+      intlLocale,
+      compact ? { day: "numeric", month: "short", timeZone: "UTC" } : { day: "numeric", month: "long", year: "numeric", timeZone: "UTC" }
+    );
+    return formatter.format(effectiveDate);
+  } catch {
+    try {
+      const fallback = getCachedIntlFormatter("en-u-ca-gregory", {
+        day: "numeric",
+        month: "short",
+        year: "numeric",
+        timeZone: "UTC"
+      });
+      return fallback.format(effectiveDate);
+    } catch {
+      return isoOrDateKey.slice(0, 10);
+    }
+  }
+}
+function formatDateInCalendarSystem(isoOrDateKey, system, locale = "en", options) {
+  const rawDate = /^\d{4}-\d{2}-\d{2}$/.test(isoOrDateKey) ? /* @__PURE__ */ new Date(`${isoOrDateKey}T12:00:00.000Z`) : new Date(isoOrDateKey);
+  if (Number.isNaN(rawDate.getTime())) {
+    return "";
+  }
+  const effectiveDate = applyDayOffset(rawDate, system.dayOffset);
+  const effectiveLocale = resolveCalendarLocaleTag(system.locale, locale);
+  const compact = Boolean(options?.compact);
+  const customResult = tryFormatWithCustomFormatter(
+    effectiveDate,
+    system,
+    effectiveLocale,
+    compact
+  );
+  if (customResult !== null) {
+    return customResult;
+  }
+  const calendarTag = (system.intlCalendar || "gregory").trim();
+  return formatWithIntlFallback(
+    effectiveDate,
+    isoOrDateKey,
+    `${effectiveLocale}-u-ca-${calendarTag}`,
+    compact
+  );
+}
+function readTrimmedString(val) {
+  return typeof val === "string" ? val.trim() : "";
+}
+function extractDocAltDatesMap(doc) {
+  if (doc.alternateDates && typeof doc.alternateDates === "object" && !Array.isArray(doc.alternateDates)) {
+    return doc.alternateDates;
+  }
+  return null;
+}
+function resolveSystemOverrideText(sys, doc, sourceAltFields, docAltDatesMap) {
+  const fieldName = sourceAltFields[sys.id] || sys.overrideField;
+  const rawFieldOverride = fieldName ? readTrimmedString(doc[fieldName]) : "";
+  const rawJsonOverride = docAltDatesMap ? readTrimmedString(docAltDatesMap[sys.id]) : "";
+  return rawFieldOverride || rawJsonOverride;
+}
+function buildSingleSecondaryCalendarEntry(args) {
+  const {
+    sys,
+    occurrenceDate,
+    rawDateObj,
+    isBaseOccurrence,
+    doc,
+    sourceAltFields,
+    docAltDatesMap,
+    locale
+  } = args;
+  const rawOverride = resolveSystemOverrideText(
+    sys,
+    doc,
+    sourceAltFields,
+    docAltDatesMap
+  );
+  const parts = extractCalendarParts(
+    rawDateObj,
+    sys.intlCalendar,
+    sys.dayOffset ?? 0
+  );
+  const label = sys.label || sys.id;
+  if (rawOverride && isBaseOccurrence) {
+    return {
+      calendarId: sys.id,
+      label,
+      formatted: rawOverride,
+      compact: rawOverride,
+      intlCalendar: sys.intlCalendar,
+      year: parts?.year,
+      month: parts?.month,
+      day: parts?.day,
+      isOverridden: true
+    };
+  }
+  const formatted = formatDateInCalendarSystem(occurrenceDate, sys, locale, {
+    compact: false
+  });
+  if (!formatted) return null;
+  const compact = formatDateInCalendarSystem(occurrenceDate, sys, locale, {
+    compact: true
+  });
+  return {
+    calendarId: sys.id,
+    label,
+    formatted,
+    compact: compact || formatted,
+    intlCalendar: sys.intlCalendar,
+    year: parts?.year,
+    month: parts?.month,
+    day: parts?.day,
+    isOverridden: false
+  };
+}
+function appendDirectSourceFieldOverrides(result, sourceAltFields, doc) {
+  for (const [calendarId, fieldName] of Object.entries(sourceAltFields)) {
+    if (result[calendarId] || !fieldName) continue;
+    const rawVal = readTrimmedString(doc[fieldName]);
+    if (rawVal) {
+      result[calendarId] = {
+        calendarId,
+        label: calendarId,
+        formatted: rawVal,
+        compact: rawVal,
+        isOverridden: true
+      };
+    }
+  }
+}
+function appendJsonMapOverrides(result, docAltDatesMap) {
+  for (const [calendarId, val] of Object.entries(docAltDatesMap)) {
+    if (result[calendarId]) continue;
+    const trimmed = readTrimmedString(val);
+    if (trimmed) {
+      result[calendarId] = {
+        calendarId,
+        label: calendarId,
+        formatted: trimmed,
+        compact: trimmed,
+        isOverridden: true
+      };
+    }
+  }
+}
+function populateSecondarySystems(args) {
+  for (const sys of args.secondaryCalendars) {
+    if (!sys?.enabled || !sys.id) continue;
+    const entry = buildSingleSecondaryCalendarEntry({ ...args, sys });
+    if (entry) args.result[sys.id] = entry;
+  }
+}
+function resolveOccurrenceAlternateDates(params) {
+  const { occurrenceDate, baseDateKey, isRecurring, doc, source } = params;
+  const result = {};
+  const sourceAltFields = source.fields.alternateDateFields ?? {};
+  const isBaseOccurrence = !isRecurring || occurrenceDate === baseDateKey;
+  const docAltDatesMap = extractDocAltDatesMap(doc);
+  populateSecondarySystems({
+    result,
+    secondaryCalendars: params.secondaryCalendars ?? [],
+    occurrenceDate,
+    rawDateObj: /* @__PURE__ */ new Date(`${occurrenceDate}T12:00:00.000Z`),
+    isBaseOccurrence,
+    doc,
+    sourceAltFields,
+    docAltDatesMap,
+    locale: params.locale ?? "en"
+  });
+  if (isBaseOccurrence) {
+    appendDirectSourceFieldOverrides(result, sourceAltFields, doc);
+    if (docAltDatesMap) appendJsonMapOverrides(result, docAltDatesMap);
+  }
+  return result;
+}
+const VALID_FREQUENCIES = [
+  "NONE",
+  "DAILY",
+  "WEEKLY",
+  "MONTHLY",
+  "YEARLY"
+];
+const JS_DAY_TO_RRULE_DAY = [
+  "SU",
+  "MO",
+  "TU",
+  "WE",
+  "TH",
+  "FR",
+  "SA"
+];
+function parseBoundedInt(val, min, max) {
+  const n = Number.parseInt(val, 10);
+  return Number.isFinite(n) && n >= min && n <= max ? n : void 0;
+}
+function parseUntilDate(val) {
+  if (/^\d{8}(?:T\d{6}Z?)?$/.test(val)) {
+    return `${val.slice(0, 4)}-${val.slice(4, 6)}-${val.slice(6, 8)}`;
+  }
+  return /^\d{4}-\d{2}-\d{2}/.test(val) ? val.slice(0, 10) : void 0;
+}
+function parseByDayList(val) {
+  return val.split(",").map((d) => d.trim().slice(-2)).filter((d) => JS_DAY_TO_RRULE_DAY.includes(d));
+}
+const intAssigner = (key, min, max) => (p, v) => {
+  const n = parseBoundedInt(v, min, max);
+  if (n !== void 0) p[key] = n;
+};
+const RRULE_PART_ASSIGNERS = {
+  RSCALE: (p, v) => {
+    if (v) p.rscale = v.toLowerCase();
+  },
+  FREQ: (p, v) => {
+    if (VALID_FREQUENCIES.includes(v)) {
+      p.freq = v;
+    }
+  },
+  INTERVAL: intAssigner("interval", 1, 365),
+  BYDAY: (p, v) => {
+    p.byDay = parseByDayList(v);
+  },
+  BYMONTH: intAssigner("byMonth", 1, 13),
+  BYMONTHDAY: intAssigner("byMonthDay", 1, 31),
+  COUNT: intAssigner("count", 1, 1e3),
+  UNTIL: (p, v) => {
+    const u = parseUntilDate(v);
+    if (u !== void 0) p.until = u;
+  }
+};
+function parseRRule(rawRule) {
+  const defaultParsed = { freq: "NONE", interval: 1, byDay: [] };
+  if (!rawRule || typeof rawRule !== "string") return defaultParsed;
+  const cleaned = rawRule.trim().replace(/^RRULE:/i, "");
+  if (!cleaned) return defaultParsed;
+  const parsed = { ...defaultParsed };
+  for (const part of cleaned.split(";")) {
+    const [rawKey, rawVal] = part.split("=");
+    if (!rawKey || !rawVal) continue;
+    RRULE_PART_ASSIGNERS[rawKey.trim().toUpperCase()]?.(
+      parsed,
+      rawVal.trim().toUpperCase()
+    );
+  }
+  return parsed;
+}
+function normalizeRRuleObject(obj, defaultTimezone) {
+  const rrule = typeof obj.rrule === "string" ? obj.rrule : "";
+  const parsed = parseRRule(rrule);
+  const timezone = typeof obj.timezone === "string" && obj.timezone ? obj.timezone : defaultTimezone;
+  const rscale = typeof obj.rscale === "string" ? obj.rscale : parsed.rscale;
+  const exdates = Array.isArray(obj.exdates) ? obj.exdates.filter((d) => typeof d === "string") : [];
+  const overrides = obj.overrides && typeof obj.overrides === "object" ? obj.overrides : {};
+  return {
+    rrule,
+    timezone,
+    rscale,
+    allDay: Boolean(obj.allDay),
+    exdates,
+    overrides
+  };
+}
+function parseRRuleFieldValue(raw, defaultTimezone = "UTC") {
+  const fallback = normalizeRRuleObject({}, defaultTimezone);
+  if (!raw) return fallback;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const obj = JSON.parse(trimmed);
+        return normalizeRRuleObject(obj, defaultTimezone);
+      } catch {
+        return fallback;
+      }
+    }
+    const parsed = parseRRule(trimmed);
+    return { ...fallback, rrule: trimmed, rscale: parsed.rscale };
+  }
+  return typeof raw === "object" ? normalizeRRuleObject(raw, defaultTimezone) : fallback;
+}
+const toDateKeyUTC = (date) => date.toISOString().slice(0, 10);
+function buildEffectiveSlot(candidateDate, dateKey, ctx, isRecurring) {
+  if (ctx.exdatesSet.has(dateKey)) return null;
+  const override = ctx.overridesMap[dateKey];
+  if (override?.cancelled) return null;
+  const effStart = override?.startDate ? new Date(override.startDate) : candidateDate;
+  const effEnd = override?.endDate ? new Date(override.endDate) : new Date(effStart.getTime() + ctx.durationMs);
+  if (effEnd.getTime() < ctx.winStartMs || effStart.getTime() > ctx.winEndMs)
+    return null;
+  return {
+    occurrenceDate: dateKey,
+    startDate: effStart.toISOString(),
+    endDate: effEnd.toISOString(),
+    isRecurring,
+    isOverridden: Boolean(override),
+    ...isRecurring ? { rscale: ctx.effectiveRScale } : {},
+    override
+  };
+}
+function matchesNonGregorianFrequency(candidateDate, ctx) {
+  const calParts = extractCalendarParts(candidateDate, ctx.effectiveRScale);
+  if (!calParts || !ctx.baseParts) return false;
+  const interval = Math.max(1, ctx.parsed.interval);
+  if (ctx.parsed.freq === "MONTHLY") {
+    const monthsDiff = (calParts.year - ctx.baseParts.year) * 12 + (calParts.month - ctx.baseParts.month);
+    return monthsDiff >= 0 && monthsDiff % interval === 0 && calParts.day === ctx.targetDayOfMonth;
+  }
+  const yearsDiff = calParts.year - ctx.baseParts.year;
+  return yearsDiff >= 0 && yearsDiff % interval === 0 && calParts.month === ctx.targetMonth && calParts.day === ctx.targetDayOfMonth;
+}
+function matchesGregorianFrequency(candidateDate, dayOffset, ctx) {
+  const { freq, interval } = ctx.parsed;
+  if (freq === "DAILY") return dayOffset % interval === 0;
+  if (freq === "WEEKLY") {
+    const rruleDay = JS_DAY_TO_RRULE_DAY[candidateDate.getUTCDay()];
+    const startWeekDay = (ctx.startObj.getUTCDay() + 6) % 7;
+    const weekIdx = Math.floor((dayOffset + startWeekDay) / 7);
+    return weekIdx % interval === 0 && ctx.targetWeekdays.includes(rruleDay);
+  }
+  if (freq === "MONTHLY") {
+    const monthsDiff = (candidateDate.getUTCFullYear() - ctx.startObj.getUTCFullYear()) * 12 + (candidateDate.getUTCMonth() - ctx.startObj.getUTCMonth());
+    return monthsDiff >= 0 && monthsDiff % interval === 0 && candidateDate.getUTCDate() === ctx.targetDayOfMonth;
+  }
+  const yearsDiff = candidateDate.getUTCFullYear() - ctx.startObj.getUTCFullYear();
+  return yearsDiff >= 0 && yearsDiff % interval === 0 && candidateDate.getUTCMonth() + 1 === ctx.targetMonth && candidateDate.getUTCDate() === ctx.targetDayOfMonth;
+}
+function matchesCandidateRule(candidateDate, dayOffset, ctx) {
+  const isMonthOrYear = ctx.parsed.freq === "MONTHLY" || ctx.parsed.freq === "YEARLY";
+  if (ctx.isNonGregorianRScale && ctx.effectiveRScale && isMonthOrYear) {
+    return matchesNonGregorianFrequency(candidateDate, ctx);
+  }
+  return matchesGregorianFrequency(candidateDate, dayOffset, ctx);
+}
+function resolveEndDate(startObj, baseEndDate) {
+  if (baseEndDate) {
+    const parsedEnd = new Date(baseEndDate);
+    if (!Number.isNaN(parsedEnd.getTime())) return parsedEnd;
+  }
+  return new Date(startObj.getTime() + 60 * 60 * 1e3);
+}
+function resolveCalendarTargets(startObj, parsed, effectiveRScale) {
+  const isNonGregorianRScale = Boolean(effectiveRScale) && effectiveRScale !== "gregory" && effectiveRScale !== "iso8601";
+  const baseParts = isNonGregorianRScale && effectiveRScale ? extractCalendarParts(startObj, effectiveRScale) : null;
+  const targetMonth = parsed.byMonth ?? (baseParts ? baseParts.month : startObj.getUTCMonth() + 1);
+  const targetDayOfMonth = parsed.byMonthDay ?? (baseParts ? baseParts.day : startObj.getUTCDate());
+  const targetWeekdays = parsed.byDay.length > 0 ? parsed.byDay : [JS_DAY_TO_RRULE_DAY[startObj.getUTCDay()]];
+  return {
+    isNonGregorianRScale,
+    baseParts,
+    targetMonth,
+    targetDayOfMonth,
+    targetWeekdays
+  };
+}
+function createSlotContext(params) {
+  const { startObj, baseEndDate, recurrence, windowStart, windowEnd } = params;
+  const endObj = resolveEndDate(startObj, baseEndDate);
+  const parsed = parseRRule(recurrence?.rrule);
+  const effectiveRScale = recurrence?.rscale || parsed.rscale;
+  const targets = resolveCalendarTargets(startObj, parsed, effectiveRScale);
+  const untilMs = parsed.until ? (/* @__PURE__ */ new Date(`${parsed.until}T23:59:59.999Z`)).getTime() : Number.POSITIVE_INFINITY;
+  return {
+    startObj,
+    durationMs: Math.max(0, endObj.getTime() - startObj.getTime()),
+    winStartMs: new Date(windowStart).getTime(),
+    winEndMs: new Date(windowEnd).getTime(),
+    untilMs,
+    maxCount: parsed.count ?? params.maxOccurrences,
+    maxOccurrences: params.maxOccurrences,
+    parsed,
+    exdatesSet: new Set(recurrence?.exdates ?? []),
+    overridesMap: recurrence?.overrides ?? {},
+    effectiveRScale,
+    ...targets,
+    anchorMidnightMs: Date.UTC(
+      startObj.getUTCFullYear(),
+      startObj.getUTCMonth(),
+      startObj.getUTCDate()
+    ),
+    timeOffsetMs: startObj.getUTCHours() * 36e5 + startObj.getUTCMinutes() * 6e4 + startObj.getUTCSeconds() * 1e3
+  };
+}
+function scanRecurringSlots(ctx) {
+  const results = [];
+  let generatedCount = 0;
+  const daysToWinEnd = Math.ceil((ctx.winEndMs - ctx.anchorMidnightMs) / 864e5) + 1;
+  const maxDayOffset = Math.min(Math.max(daysToWinEnd, 0), 36500);
+  const startDayOffset = ctx.parsed.count === void 0 && !ctx.isNonGregorianRScale ? Math.max(
+    0,
+    Math.floor(
+      (ctx.winStartMs - ctx.durationMs - ctx.anchorMidnightMs) / 864e5
+    ) - 1
+  ) : 0;
+  for (let dayOffset = startDayOffset; dayOffset <= maxDayOffset; dayOffset++) {
+    if (generatedCount >= ctx.maxCount || results.length >= ctx.maxOccurrences)
+      break;
+    const candidateDate = new Date(
+      ctx.anchorMidnightMs + dayOffset * 864e5 + ctx.timeOffsetMs
+    );
+    const candidateMs = candidateDate.getTime();
+    if (candidateMs > ctx.untilMs || candidateMs > ctx.winEndMs) break;
+    if (!matchesCandidateRule(candidateDate, dayOffset, ctx)) continue;
+    generatedCount++;
+    const slot = buildEffectiveSlot(
+      candidateDate,
+      toDateKeyUTC(candidateDate),
+      ctx,
+      true
+    );
+    if (slot) results.push(slot);
+  }
+  return results;
+}
+function expandRuleSlots(params) {
+  const startObj = new Date(params.baseStartDate);
+  if (Number.isNaN(startObj.getTime())) return [];
+  const ctx = createSlotContext({
+    ...params,
+    startObj,
+    maxOccurrences: params.maxOccurrences ?? 366
+  });
+  if (ctx.parsed.freq === "NONE") {
+    const slot = buildEffectiveSlot(
+      startObj,
+      toDateKeyUTC(startObj),
+      ctx,
+      false
+    );
+    return slot ? [slot] : [];
+  }
+  return scanRecurringSlots(ctx);
+}
+const DEFAULT_TIME_SLOTS = {
+  morning: { start: "09:00:00", end: "11:00:00" },
+  afternoon: { start: "14:00:00", end: "16:00:00" },
+  evening: { start: "18:00:00", end: "20:00:00" }
+};
+function resolveDateOnlyWithSlot(rawStart, rawSlot, source) {
+  if (typeof rawSlot === "string" && rawSlot) {
+    const mapped = { ...DEFAULT_TIME_SLOTS, ...source.timeSlotMap }[rawSlot];
+    if (mapped) {
+      return {
+        startDate: `${rawStart}T${mapped.start}.000Z`,
+        endDate: `${rawStart}T${mapped.end}.000Z`,
+        allDay: false
+      };
+    }
+    if (/^\d{2}:\d{2}(:\d{2})?$/.test(rawSlot)) {
+      const normalizedTime = rawSlot.length === 5 ? `${rawSlot}:00` : rawSlot;
+      return {
+        startDate: `${rawStart}T${normalizedTime}.000Z`,
+        endDate: null,
+        allDay: false
+      };
+    }
+  }
+  return {
+    startDate: `${rawStart}T00:00:00.000Z`,
+    endDate: `${rawStart}T23:59:59.000Z`,
+    allDay: source.defaultAllDay ?? true
+  };
+}
+function resolveStartEndFromDocument(doc, source) {
+  const rawStart = doc[source.fields.startDate];
+  if (!rawStart || typeof rawStart !== "string") return null;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(rawStart)) {
+    const rawSlot = source.fields.timeSlot ? doc[source.fields.timeSlot] : null;
+    return resolveDateOnlyWithSlot(rawStart, rawSlot, source);
+  }
+  const rawEnd = source.fields.endDate ? doc[source.fields.endDate] : null;
+  const allDay = typeof doc.allDay === "boolean" ? doc.allDay : Boolean(source.defaultAllDay);
+  return {
+    startDate: rawStart,
+    endDate: typeof rawEnd === "string" && rawEnd ? rawEnd : null,
+    allDay
+  };
+}
+const STATUS_MAP = {
+  cancelled: "cancelled",
+  canceled: "cancelled",
+  rejected: "cancelled",
+  postponed: "postponed",
+  pending: "postponed",
+  rescheduled: "rescheduled"
+};
+function mapStatus(rawStatus) {
+  if (typeof rawStatus !== "string") return "scheduled";
+  return STATUS_MAP[rawStatus.toLowerCase()] ?? "scheduled";
+}
+function matchesKeyword(source, keyword, canonicalUid) {
+  if (source.uid === canonicalUid) return true;
+  return source.id.toLowerCase().includes(keyword) || source.uid.toLowerCase().includes(keyword);
+}
+function matchesSourceFilter(source, filter) {
+  if (!filter || filter === "all") return true;
+  if (source.id === filter || source.uid === filter) return true;
+  const lowerFilter = filter.toLowerCase();
+  if (lowerFilter === "events" || lowerFilter === "event") {
+    return matchesKeyword(source, "event", "plugin::events.event");
+  }
+  if (lowerFilter === "bookings" || lowerFilter === "booking") {
+    return matchesKeyword(source, "booking", "plugin::bookings.booking");
+  }
+  return false;
+}
+function resolveTargetSource(sources, sourceId) {
+  if (!Array.isArray(sources) || sources.length === 0) {
+    return void 0;
+  }
+  if (sourceId && sourceId !== "all") {
+    const exact = sources.find((s) => s.id === sourceId || s.uid === sourceId);
+    if (exact) return exact;
+    const aliasMatch = sources.find((s) => matchesSourceFilter(s, sourceId));
+    if (aliasMatch) return aliasMatch;
+  }
+  return sources.find((s) => s.enabled) ?? sources[0];
+}
+function isBookingCollectionSource(source, schema) {
+  if (source.uid === "plugin::bookings.booking") return true;
+  const attrs = schema?.attributes ?? {};
+  return "bookingCode" in attrs && "customerEmail" in attrs;
+}
+function generateBookingCode(startIso) {
+  const dateCompact = startIso.slice(0, 10).replace(/-/g, "") || "20260101";
+  const rand = node_crypto.randomInt(1e3, 9999);
+  return `BK-${dateCompact}-${rand}`;
+}
+function computeEffectiveEnd(rawStart, endDate) {
+  const normalizedStart = rawStart.includes("T") ? rawStart : `${rawStart}T10:00:00.000Z`;
+  const startMs = new Date(normalizedStart).getTime();
+  const defaultEndIso = Number.isNaN(startMs) ? normalizedStart : new Date(startMs + 36e5).toISOString();
+  const trimmedEnd = endDate?.trim();
+  return {
+    normalizedStart,
+    effectiveEnd: trimmedEnd || defaultEndIso
+  };
+}
+function setTrimmedIfMapped(data, fieldName, rawVal) {
+  if (fieldName && rawVal) {
+    data[fieldName] = rawVal.trim();
+  }
+}
+function applyOptionalSourceFields(data, params, source, defaultTimezone, slug, effectiveEnd, isPluginBooking) {
+  const shouldSetEnd = Boolean(params.endDate) || isPluginBooking;
+  if (source.fields.endDate && shouldSetEnd) {
+    data[source.fields.endDate] = effectiveEnd;
+  }
+  if (source.fields.slug) {
+    data[source.fields.slug] = `${slug}-${Date.now().toString(36)}`;
+  }
+  setTrimmedIfMapped(data, source.fields.location, params.location);
+  setTrimmedIfMapped(data, source.fields.summary, params.summary);
+  if (source.fields.rrule && params.rrule) {
+    data[source.fields.rrule] = {
+      rrule: params.rrule,
+      timezone: defaultTimezone,
+      allDay: false,
+      exdates: [],
+      overrides: {}
+    };
+  }
+}
+function applyCategoryIfApplicable(data, params, source, isPluginBooking) {
+  const catField = source.fields.category;
+  if (!catField || !params.category || isPluginBooking) return;
+  if (catField !== source.fields.status) {
+    data[catField] = params.category;
+  }
+}
+function hasFieldOrBookingUid(field, attrs, source) {
+  return field in attrs || source.uid === "plugin::bookings.booking";
+}
+function setIfBookingFieldPresent(data, field, value, attrs, source) {
+  if (value !== void 0 && hasFieldOrBookingUid(field, attrs, source)) {
+    data[field] = value;
+  }
+}
+function applyBookingCollectionFields(data, params, source, attrs, title, normalizedStart, effectiveEnd) {
+  setIfBookingFieldPresent(
+    data,
+    "bookingCode",
+    generateBookingCode(normalizedStart),
+    attrs,
+    source
+  );
+  setIfBookingFieldPresent(
+    data,
+    "customerName",
+    params.customerName?.trim() || title,
+    attrs,
+    source
+  );
+  setIfBookingFieldPresent(
+    data,
+    "customerEmail",
+    params.customerEmail?.trim() || "noreply@example.com",
+    attrs,
+    source
+  );
+  const phone = params.customerPhone?.trim();
+  setIfBookingFieldPresent(
+    data,
+    "customerPhone",
+    phone || void 0,
+    attrs,
+    source
+  );
+  const partySize = Math.max(1, Math.floor(Number(params.partySize) || 1));
+  setIfBookingFieldPresent(data, "partySize", partySize, attrs, source);
+  const statusField = source.fields.status || "status";
+  const statusVal = params.bookingStatus === "pending" ? "pending" : "confirmed";
+  setIfBookingFieldPresent(data, statusField, statusVal, attrs, source);
+  const endField = source.fields.endDate || "endDate";
+  if (!data[endField]) {
+    data[endField] = effectiveEnd;
+  }
+}
+function buildQuickCreatePayload(params, source, defaultTimezone, schema) {
+  const title = (params.title ?? "").trim();
+  if (!title) throw new Error("Entry title is required.");
+  const rawStart = (params.startDate ?? "").trim();
+  if (!rawStart) throw new Error("Start date is required.");
+  const { normalizedStart, effectiveEnd } = computeEffectiveEnd(
+    rawStart,
+    params.endDate
+  );
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+  const attrs = schema?.attributes ?? {};
+  const isPluginBooking = isBookingCollectionSource(source, schema);
+  const data = {
+    [source.fields.title]: title,
+    [source.fields.startDate]: rawStart
+  };
+  applyOptionalSourceFields(
+    data,
+    params,
+    source,
+    defaultTimezone,
+    slug,
+    effectiveEnd,
+    isPluginBooking
+  );
+  applyCategoryIfApplicable(data, params, source, isPluginBooking);
+  if (isPluginBooking) {
+    applyBookingCollectionFields(
+      data,
+      params,
+      source,
+      attrs,
+      title,
+      normalizedStart,
+      effectiveEnd
+    );
+  }
+  const shouldPublish = schema?.options?.draftAndPublish !== void 0 ? Boolean(schema.options.draftAndPublish) : source.uid !== "plugin::bookings.booking";
+  return { data, shouldPublish };
+}
+function buildDirectUpdatePayload(params, source, existingDoc) {
+  if (params.cancelOccurrence) {
+    return source.fields.status ? { [source.fields.status]: "cancelled" } : {};
+  }
+  const rawExistingStart = existingDoc?.[source.fields.startDate];
+  const isDateOnlyStart = typeof rawExistingStart === "string" && /^\d{4}-\d{2}-\d{2}$/.test(rawExistingStart);
+  const payload = {
+    [source.fields.startDate]: isDateOnlyStart ? params.newStartDate.slice(0, 10) : params.newStartDate
+  };
+  if (params.newEndDate && source.fields.endDate) {
+    const rawExistingEnd = existingDoc?.[source.fields.endDate];
+    const isDateOnlyEnd = isDateOnlyStart || typeof rawExistingEnd === "string" && /^\d{4}-\d{2}-\d{2}$/.test(rawExistingEnd);
+    payload[source.fields.endDate] = isDateOnlyEnd ? params.newEndDate.slice(0, 10) : params.newEndDate;
+  }
+  return payload;
+}
+function buildRecurrenceOverridePayload(recurrence, rruleField, params) {
+  const overrides = {
+    ...recurrence.overrides,
+    [params.occurrenceDate]: {
+      ...recurrence.overrides?.[params.occurrenceDate],
+      originalDate: params.occurrenceDate,
+      cancelled: Boolean(params.cancelOccurrence),
+      startDate: params.newStartDate || void 0,
+      endDate: params.newEndDate || void 0
+    }
+  };
+  return { [rruleField]: { ...recurrence, overrides } };
+}
+function resolveQueryWindow(params) {
+  const y = (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const defaultFrom = new Date(Date.UTC(y, 0, 1, 0, 0, 0)).toISOString();
+  const defaultTo = new Date(Date.UTC(y, 11, 31, 23, 59, 59)).toISOString();
+  const validFrom = params.from && !Number.isNaN(new Date(params.from).getTime());
+  const validTo = params.to && !Number.isNaN(new Date(params.to).getTime());
+  return {
+    windowStart: validFrom ? params.from : defaultFrom,
+    windowEnd: validTo ? params.to : defaultTo
+  };
+}
+function buildWindowFilters(source, windowStart, windowEnd) {
+  if (source.fields.rrule) {
+    return { [source.fields.startDate]: { $lte: windowEnd } };
+  }
+  if (source.fields.endDate) {
+    return {
+      [source.fields.startDate]: { $lte: windowEnd },
+      [source.fields.endDate]: { $gte: windowStart }
+    };
+  }
+  return {
+    [source.fields.startDate]: { $gte: windowStart, $lte: windowEnd }
+  };
+}
+function buildDocQueryOpts(params, source, windowStart, windowEnd, includeLocale) {
+  const opts = {
+    limit: 1e3,
+    filters: params.documentId ? { documentId: { $eq: params.documentId } } : buildWindowFilters(source, windowStart, windowEnd),
+    ...{
+      sort: { [source.fields.startDate]: "desc" }
+    }
+  };
+  if (includeLocale && params.locale && params.locale !== "auto") {
+    opts.locale = params.locale;
+  }
+  if (!params.includeDrafts) opts.status = "published";
+  return opts;
+}
+const docKey = (d) => String(d.documentId ?? d.id);
+async function fetchDocumentsForSource(strapi, source, params, windowStart, windowEnd) {
+  const find = (withLocale) => strapi.documents(source.uid).findMany(
+    buildDocQueryOpts(params, source, windowStart, windowEnd, withLocale)
+  ).catch(() => []);
+  if (!params.locale || params.locale === "auto") return find(false);
+  const [primary, fallback] = await Promise.all([find(true), find(false)]);
+  const seen = new Set(primary.map(docKey));
+  return [...primary, ...fallback.filter((d) => !seen.has(docKey(d)))];
+}
+function extractCustomFields(doc, keys) {
+  if (!Array.isArray(keys) || keys.length === 0) return void 0;
+  const extracted = {};
+  for (const key of keys) {
+    if (key && doc[key] !== void 0) extracted[key] = doc[key];
+  }
+  return Object.keys(extracted).length > 0 ? extracted : void 0;
+}
+const HEX_COLOR_RE$1 = /^#[0-9a-fA-F]{3,8}$/;
+function resolveDocColor(doc, source, categoryVal) {
+  const catColor = categoryVal ? source.categoryColors?.[categoryVal] : void 0;
+  if (typeof catColor === "string" && HEX_COLOR_RE$1.test(catColor.trim())) {
+    return catColor.trim();
+  }
+  const docColorVal = source.fields.color ? doc[source.fields.color] : doc.color;
+  if (typeof docColorVal === "string" && HEX_COLOR_RE$1.test(docColorVal.trim())) {
+    return docColorVal.trim();
+  }
+  return HEX_COLOR_RE$1.test(source.color) ? source.color : "#4945ff";
+}
+const optStr = (v) => v ? v : void 0;
+const readField = (doc, key) => key ? String(doc[key] ?? "") : "";
+function buildOccurrenceItem(slot, meta) {
+  const effectiveTitle = slot.override?.title || meta.baseTitle;
+  const effectiveLocation = slot.override?.location || meta.baseLocation;
+  const allDay = Boolean(meta.recurrence.allDay);
+  const calendarLinks = buildCalendarLinks({
+    documentId: meta.docId,
+    title: effectiveTitle,
+    startDate: slot.startDate,
+    endDate: slot.endDate,
+    allDay,
+    summary: meta.summary,
+    location: effectiveLocation,
+    occurrenceDate: slot.occurrenceDate
+  });
+  const alternateDates = resolveOccurrenceAlternateDates({
+    occurrenceDate: slot.occurrenceDate,
+    baseDateKey: meta.baseDateKey,
+    isRecurring: slot.isRecurring,
+    doc: meta.doc,
+    source: meta.source,
+    secondaryCalendars: meta.secondaryCalendars,
+    locale: meta.locale
+  });
+  return {
+    occurrenceId: `${meta.source.id}:${meta.docId}:${slot.occurrenceDate}`,
+    sourceId: meta.source.id,
+    sourceLabel: meta.source.label,
+    uid: meta.source.uid,
+    documentId: meta.docId,
+    locale: meta.docLocale,
+    occurrenceDate: slot.occurrenceDate,
+    startDate: slot.startDate,
+    endDate: slot.endDate,
+    allDay,
+    timezone: meta.recurrence.timezone,
+    title: effectiveTitle,
+    slug: meta.slug,
+    summary: optStr(meta.summary),
+    location: optStr(effectiveLocation),
+    category: meta.categoryVal,
+    status: meta.statusVal,
+    color: meta.color,
+    isRecurring: slot.isRecurring,
+    rrule: optStr(meta.recurrence.rrule),
+    rscale: slot.rscale,
+    isOverridden: slot.isOverridden,
+    calendarLinks,
+    alternateDates: Object.keys(alternateDates).length > 0 ? alternateDates : void 0,
+    customFields: meta.customFields
+  };
+}
+function matchesCategoryParam(categoryVal, filterCategory) {
+  if (!filterCategory || filterCategory === "all") return true;
+  return categoryVal.toLowerCase() === filterCategory.toLowerCase();
+}
+function resolveDocRecurrence(doc, source, defaultTimezone, allDay) {
+  const rawRecurrence = source.fields.rrule ? doc[source.fields.rrule] : null;
+  const tz = typeof doc.timezone === "string" && doc.timezone ? doc.timezone : defaultTimezone;
+  const recurrence = parseRRuleFieldValue(rawRecurrence, tz);
+  if (allDay) recurrence.allDay = true;
+  return recurrence;
+}
+function buildDocExpansionMeta(doc, docId, source, recurrence, categoryVal, baseDateKey, settings2, locale = "en") {
+  return {
+    doc,
+    docId,
+    docLocale: typeof doc.locale === "string" ? optStr(doc.locale) : void 0,
+    source,
+    recurrence,
+    baseTitle: String(doc[source.fields.title] ?? doc.title ?? "Untitled"),
+    baseLocation: readField(doc, source.fields.location),
+    summary: readField(doc, source.fields.summary),
+    slug: optStr(readField(doc, source.fields.slug)),
+    categoryVal: optStr(categoryVal),
+    statusVal: mapStatus(
+      source.fields.status ? doc[source.fields.status] : doc.status
+    ),
+    color: resolveDocColor(doc, source, categoryVal),
+    baseDateKey,
+    customFields: extractCustomFields(doc, source.fields.customFields),
+    secondaryCalendars: settings2.secondaryCalendars ?? [],
+    locale
+  };
+}
+function expandDocumentOccurrences(doc, source, settings2, params, windowStart, windowEnd) {
+  const docId = String(doc.documentId ?? doc.id ?? "");
+  if (!docId) return [];
+  const startEnd = resolveStartEndFromDocument(doc, source);
+  if (!startEnd) return [];
+  const categoryVal = readField(doc, source.fields.category);
+  if (!matchesCategoryParam(categoryVal, params.category)) return [];
+  const recurrence = resolveDocRecurrence(
+    doc,
+    source,
+    settings2.defaultTimezone,
+    startEnd.allDay
+  );
+  const slots = expandRuleSlots({
+    baseStartDate: startEnd.startDate,
+    baseEndDate: startEnd.endDate,
+    recurrence,
+    windowStart,
+    windowEnd
+  });
+  if (slots.length === 0) return [];
+  const meta = buildDocExpansionMeta(
+    doc,
+    docId,
+    source,
+    recurrence,
+    categoryVal,
+    startEnd.startDate.slice(0, 10),
+    settings2,
+    params.locale
+  );
+  return slots.map((slot) => buildOccurrenceItem(slot, meta));
+}
+const occurrence = ({ strapi }) => {
+  const getSettingsService = () => getCalendarService(strapi, PLUGIN_ID, "settings");
+  return {
+    registerCalendarFormatter: registerCalendarSystemFormatter,
+    unregisterCalendarFormatter: unregisterCalendarSystemFormatter,
+    formatDateInCalendarSystem,
+    async getOccurrences(params) {
+      const settings2 = await getSettingsService().getSettings();
+      const { windowStart, windowEnd } = resolveQueryWindow(params);
+      const activeSources = (settings2.sources ?? []).filter(
+        (s) => s.enabled && (!params.publicOnly || s.publicFeed !== false) && matchesSourceFilter(s, params.sourceId)
+      );
+      const allOccurrences = [];
+      for (const source of activeSources) {
+        const docs = await fetchDocumentsForSource(
+          strapi,
+          source,
+          params,
+          windowStart,
+          windowEnd
+        );
+        for (const doc of docs) {
+          const items = expandDocumentOccurrences(
+            doc,
+            source,
+            settings2,
+            params,
+            windowStart,
+            windowEnd
+          );
+          allOccurrences.push(...items);
+        }
+      }
+      return allOccurrences.sort(
+        (a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime()
+      );
+    },
+    async rescheduleOccurrence(params) {
+      const settings2 = await getSettingsService().getSettings();
+      const sources = settings2.sources ?? [];
+      const source = params.sourceId || params.uid ? sources.find(
+        (s) => s.id === params.sourceId || s.uid === params.uid
+      ) : sources[0];
+      if (!source) throw new Error("Target calendar source is not configured.");
+      const localeOpt = params.locale && params.locale !== "auto" ? { locale: params.locale } : {};
+      const existing = await strapi.documents(source.uid).findOne({ documentId: params.documentId, ...localeOpt });
+      if (!existing) {
+        throw new Error(
+          `Document ${params.documentId} not found in ${source.uid}.`
+        );
+      }
+      const rruleField = source.fields.rrule;
+      const recurrence = rruleField ? parseRRuleFieldValue(existing[rruleField], settings2.defaultTimezone) : null;
+      const data = recurrence?.rrule && !params.applyToSeries && rruleField ? buildRecurrenceOverridePayload(recurrence, rruleField, params) : buildDirectUpdatePayload(params, source, existing);
+      const updatedDoc = await strapi.documents(source.uid).update({ documentId: params.documentId, data, ...localeOpt });
+      return updatedDoc ?? {};
+    },
+    async quickCreateEntry(params) {
+      const settings2 = await getSettingsService().getSettings();
+      const source = resolveTargetSource(
+        settings2.sources ?? [],
+        params.sourceId
+      );
+      if (!source)
+        throw new Error("No calendar collection source is configured.");
+      const contentTypes = strapi.contentTypes ?? {};
+      const { data, shouldPublish } = buildQuickCreatePayload(
+        params,
+        source,
+        settings2.defaultTimezone,
+        contentTypes[source.uid]
+      );
+      if (shouldPublish) {
+        try {
+          return await strapi.documents(source.uid).create({ data, status: "published" });
+        } catch {
+          return await strapi.documents(source.uid).create({ data });
+        }
+      }
+      return strapi.documents(source.uid).create({ data });
+    }
+  };
+};
+const registry = ({ strapi: _strapi }) => {
+  const registeredSources = /* @__PURE__ */ new Map();
+  const registeredCalendars = /* @__PURE__ */ new Map();
+  return {
+    registerSource(source) {
+      if (!source || !source.id || !source.uid) {
+        throw new Error("Calendar source registration requires id and uid.");
+      }
+      registeredSources.set(source.id, source);
+    },
+    unregisterSource(sourceId) {
+      registeredSources.delete(sourceId);
+    },
+    getRegisteredSources() {
+      return Array.from(registeredSources.values());
+    },
+    registerSecondaryCalendar(calendar) {
+      if (!calendar || !calendar.id || !calendar.intlCalendar) {
+        throw new Error(
+          "Secondary calendar registration requires id and intlCalendar."
+        );
+      }
+      registeredCalendars.set(calendar.id, calendar);
+    },
+    getRegisteredSecondaryCalendars() {
+      return Array.from(registeredCalendars.values());
+    },
+    registerCalendarFormatter(calendarId, formatter) {
+      registerCalendarSystemFormatter(calendarId, formatter);
+    },
+    unregisterCalendarFormatter(calendarId) {
+      unregisterCalendarSystemFormatter(calendarId);
+    }
+  };
+};
+const CALENDAR_COLOR_PALETTES = {
+  default: {
+    id: "default",
+    label: "Theme Default",
+    lightPrimary: "#0284C7",
+    darkPrimary: "#38BDF8",
+    lightHeaderBg: "#E0F2FE",
+    lightHeaderText: "#0C4A6E",
+    lightTodayBg: "#F0F9FF",
+    lightBadgeBg: "#E0F2FE",
+    lightBadgeText: "#0369A1",
+    lightBadgeBorder: "#7DD3FC",
+    darkHeaderBg: "#1E293B",
+    darkHeaderText: "#E2E8F0",
+    darkTodayBg: "#172554",
+    darkBadgeBg: "#1E293B",
+    darkBadgeText: "#7DD3FC",
+    darkBadgeBorder: "#0369A1"
+  },
+  purple: {
+    id: "purple",
+    label: "Monarch Purple",
+    lightPrimary: "#6750A4",
+    darkPrimary: "#D0BCFF",
+    lightHeaderBg: "#F3EDF7",
+    lightHeaderText: "#381E72",
+    lightTodayBg: "#F7F2FA",
+    lightBadgeBg: "#EADDFF",
+    lightBadgeText: "#4F378B",
+    lightBadgeBorder: "#D0BCFF",
+    darkHeaderBg: "#211F26",
+    darkHeaderText: "#E6E0E9",
+    darkTodayBg: "#2B223C",
+    darkBadgeBg: "#381E72",
+    darkBadgeText: "#EADDFF",
+    darkBadgeBorder: "#4F378B"
+  },
+  blue: {
+    id: "blue",
+    label: "Forma / Pulse Blue",
+    lightPrimary: "#0F6CBD",
+    darkPrimary: "#60A5FA",
+    lightHeaderBg: "#EFF6FC",
+    lightHeaderText: "#0A4478",
+    lightTodayBg: "#F0F7FF",
+    lightBadgeBg: "#DBEAFE",
+    lightBadgeText: "#1E40AF",
+    lightBadgeBorder: "#93C5FD",
+    darkHeaderBg: "#172130",
+    darkHeaderText: "#DBEAFE",
+    darkTodayBg: "#172554",
+    darkBadgeBg: "#1E3A8A",
+    darkBadgeText: "#BFDBFE",
+    darkBadgeBorder: "#2563EB"
+  },
+  indigo: {
+    id: "indigo",
+    label: "Breezy Indigo",
+    lightPrimary: "#4F46E5",
+    darkPrimary: "#818CF8",
+    lightHeaderBg: "#EEF2FF",
+    lightHeaderText: "#312E81",
+    lightTodayBg: "#EEF2FF",
+    lightBadgeBg: "#E0E7FF",
+    lightBadgeText: "#3730A3",
+    lightBadgeBorder: "#A5B4FC",
+    darkHeaderBg: "#1E1B4B",
+    darkHeaderText: "#E0E7FF",
+    darkTodayBg: "#1E1B4B",
+    darkBadgeBg: "#312E81",
+    darkBadgeText: "#C7D2FE",
+    darkBadgeBorder: "#4F46E5"
+  },
+  emerald: {
+    id: "emerald",
+    label: "Emerald Green",
+    lightPrimary: "#059669",
+    darkPrimary: "#34D399",
+    lightHeaderBg: "#ECFDF5",
+    lightHeaderText: "#065F46",
+    lightTodayBg: "#F0FDF4",
+    lightBadgeBg: "#D1FAE5",
+    lightBadgeText: "#065F46",
+    lightBadgeBorder: "#6EE7B7",
+    darkHeaderBg: "#064E3B",
+    darkHeaderText: "#D1FAE5",
+    darkTodayBg: "#064E3B",
+    darkBadgeBg: "#065F46",
+    darkBadgeText: "#A7F3D0",
+    darkBadgeBorder: "#059669"
+  },
+  rose: {
+    id: "rose",
+    label: "Pulse Rose",
+    lightPrimary: "#E11D48",
+    darkPrimary: "#FB7185",
+    lightHeaderBg: "#FFF1F2",
+    lightHeaderText: "#881337",
+    lightTodayBg: "#FFF1F2",
+    lightBadgeBg: "#FFE4E6",
+    lightBadgeText: "#9F1239",
+    lightBadgeBorder: "#FDA4AF",
+    darkHeaderBg: "#3B0A19",
+    darkHeaderText: "#FFE4E6",
+    darkTodayBg: "#4C0519",
+    darkBadgeBg: "#881337",
+    darkBadgeText: "#FECDD3",
+    darkBadgeBorder: "#E11D48"
+  },
+  amber: {
+    id: "amber",
+    label: "Monarch Amber",
+    lightPrimary: "#D97706",
+    darkPrimary: "#FBBF24",
+    lightHeaderBg: "#FFFBEB",
+    lightHeaderText: "#78350F",
+    lightTodayBg: "#FEF3C7",
+    lightBadgeBg: "#FEF3C7",
+    lightBadgeText: "#92400E",
+    lightBadgeBorder: "#FCD34D",
+    darkHeaderBg: "#3B2506",
+    darkHeaderText: "#FEF3C7",
+    darkTodayBg: "#451A03",
+    darkBadgeBg: "#78350F",
+    darkBadgeText: "#FDE68A",
+    darkBadgeBorder: "#D97706"
+  }
+};
+const CALENDAR_THEME_PRESETS = {
+  breeze: {
+    id: "breeze",
+    label: "Breezy (Modern Default)",
+    description: "FullCalendar Breezy style — airy sky & slate grid, soft-tinted event pills, and rounded-lg container",
+    category: "modern",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 1px 3px rgba(15, 23, 42, 0.06)",
+    eventRadius: "6px",
+    eventStyle: "tinted",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#0284C7",
+    headerBg: "#F8FAFC",
+    headerText: "#0F172A",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F8FAFC",
+    cellHoverBg: "#F0F9FF",
+    cellText: "#111827",
+    cellMutedText: "#6B7280",
+    borderColor: "#E5E7EB",
+    todayBg: "#F0F9FF",
+    todayBorder: "#0284C7",
+    todayNumberBg: "#0284C7",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#E0F2FE",
+    badgeText: "#0369A1",
+    badgeBorder: "#7DD3FC"
+  },
+  monarch: {
+    id: "monarch",
+    label: "Monarch (Material 3)",
+    description: "FullCalendar Monarch style — pill-shaped headers, centered day badges, tonal surfaces & rounded-xl frame",
+    category: "modern",
+    fontFamily: "'Roboto Variable', Roboto, system-ui, sans-serif",
+    containerRadius: "14px",
+    containerShadow: "0 2px 8px rgba(103, 80, 164, 0.08)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "center",
+    todayHeaderAccent: "pill",
+    primaryColor: "#6750A4",
+    headerBg: "#F7F2FA",
+    headerText: "#1D1B20",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#FAF8FC",
+    cellHoverBg: "#F3EDF7",
+    cellText: "#0C090C",
+    cellMutedText: "#79747E",
+    borderColor: "#DEDCE1",
+    todayBg: "#F7F2FA",
+    todayBorder: "#6750A4",
+    todayNumberBg: "#895264",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#EADDFF",
+    badgeText: "#4F378B",
+    badgeBorder: "#D0BCFF"
+  },
+  forma: {
+    id: "forma",
+    label: "Forma (Fluent Enterprise)",
+    description: "FullCalendar Forma style — architectural 6px left-accent event bars, top-accent Today bar & crisp 4px corners",
+    category: "modern",
+    fontFamily: "'Noto Sans Variable', 'Noto Sans', system-ui, sans-serif",
+    containerRadius: "4px",
+    containerShadow: "0 1px 2px rgba(0, 0, 0, 0.06)",
+    eventRadius: "3px",
+    eventStyle: "accent-bar",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "top-bar",
+    primaryColor: "#0F6CBD",
+    headerBg: "#FFFFFF",
+    headerText: "#030712",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F9FAFB",
+    cellHoverBg: "#EFF6FC",
+    cellText: "#030712",
+    cellMutedText: "#6B7280",
+    borderColor: "#E0E0E0",
+    todayBg: "#F5F9FF",
+    todayBorder: "#0F6CBD",
+    todayNumberBg: "#0F6CBD",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#EFF6FC",
+    badgeText: "#0F6CBD",
+    badgeBorder: "#B4D6FA"
+  },
+  pulse: {
+    id: "pulse",
+    label: "Pulse (Apple / macOS)",
+    description: "FullCalendar Pulse style — right-aligned day numbers, crimson Today circle, elevated controls & dotted minor slots",
+    category: "modern",
+    fontFamily: "ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
+    containerRadius: "8px",
+    containerShadow: "0 1px 3px rgba(0, 0, 0, 0.12)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "end",
+    todayHeaderAccent: "pill",
+    primaryColor: "#117AFF",
+    headerBg: "#FFFFFF",
+    headerText: "#232D3E",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F9FAFB",
+    cellHoverBg: "#F0F7FF",
+    cellText: "#232D3E",
+    cellMutedText: "#545C6C",
+    borderColor: "#E5E7EB",
+    todayBg: "#FFF5F5",
+    todayBorder: "#FD453B",
+    todayNumberBg: "#FD453B",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#EFF6FF",
+    badgeText: "#1D4ED8",
+    badgeBorder: "#BFDBFE"
+  },
+  classic: {
+    id: "classic",
+    label: "Classic (FullCalendar Standard)",
+    description: "Traditional FullCalendar v6/v7 studio grid with slate headers, warm yellow Today cell tint & solid events",
+    category: "modern",
+    fontFamily: "ui-sans-serif, system-ui, sans-serif",
+    containerRadius: "6px",
+    containerShadow: "none",
+    eventRadius: "4px",
+    eventStyle: "solid",
+    dayNumberAlign: "end",
+    todayHeaderAccent: "tint",
+    primaryColor: "#3788D8",
+    headerBg: "#F8FAFC",
+    headerText: "#1E293B",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F8FAFC",
+    cellHoverBg: "#F1F5F9",
+    cellText: "#030712",
+    cellMutedText: "#6B7280",
+    borderColor: "#DDDDDD",
+    todayBg: "#FEFCE8",
+    todayBorder: "#EAB308",
+    todayNumberBg: "#334155",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#F1F5F9",
+    badgeText: "#334155",
+    badgeBorder: "#CBD5E1"
+  },
+  shadcn: {
+    id: "shadcn",
+    label: "Shadcn UI (Zinc Minimal)",
+    description: "Design-system theme matching Shadcn UI — ultra-clean 1px zinc borders, monochrome primary & tinted badges",
+    category: "design-system",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "8px",
+    containerShadow: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+    eventRadius: "5px",
+    eventStyle: "tinted",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#18181B",
+    headerBg: "#FAFAFA",
+    headerText: "#09090B",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#FAFAFA",
+    cellHoverBg: "#F4F4F5",
+    cellText: "#09090B",
+    cellMutedText: "#71717A",
+    borderColor: "#E4E4E7",
+    todayBg: "#F4F4F5",
+    todayBorder: "#18181B",
+    todayNumberBg: "#18181B",
+    todayNumberText: "#FAFAFA",
+    badgeBg: "#F4F4F5",
+    badgeText: "#18181B",
+    badgeBorder: "#D4D4D8"
+  },
+  mui: {
+    id: "mui",
+    label: "Material UI (MUI Paper)",
+    description: "Design-system theme matching Material UI — Paper surface elevation, Roboto uppercase headers & Material blue",
+    category: "design-system",
+    fontFamily: "'Roboto Variable', Roboto, Helvetica, Arial, sans-serif",
+    containerRadius: "8px",
+    containerShadow: "0px 2px 4px -1px rgba(0,0,0,0.08), 0px 4px 5px 0px rgba(0,0,0,0.05)",
+    eventRadius: "4px",
+    eventStyle: "solid",
+    dayNumberAlign: "center",
+    todayHeaderAccent: "pill",
+    primaryColor: "#1976D2",
+    headerBg: "#F5F7FA",
+    headerText: "#1E293B",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#FAFAFA",
+    cellHoverBg: "#E3F2FD",
+    cellText: "#212121",
+    cellMutedText: "#757575",
+    borderColor: "#E0E0E0",
+    todayBg: "#E3F2FD",
+    todayBorder: "#1976D2",
+    todayNumberBg: "#1976D2",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#E3F2FD",
+    badgeText: "#1565C0",
+    badgeBorder: "#90CAF9"
+  },
+  emerald: {
+    id: "emerald",
+    label: "Emerald Mosque",
+    description: "Lush emerald & teal palette inspired by traditional Islamic architecture",
+    category: "heritage",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 1px 3px rgba(13, 148, 136, 0.08)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#0D9488",
+    headerBg: "#CCFBF1",
+    headerText: "#115E59",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F0FDFA",
+    cellHoverBg: "#CCFBF1",
+    cellText: "#0F172A",
+    cellMutedText: "#475569",
+    borderColor: "#99F6E4",
+    todayBg: "#F0FDFA",
+    todayBorder: "#0D9488",
+    todayNumberBg: "#0D9488",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#CCFBF1",
+    badgeText: "#0F766E",
+    badgeBorder: "#5EEAD4"
+  },
+  sand: {
+    id: "sand",
+    label: "Warm Sand & Gold",
+    description: "Warm parchment & amber tones for high-comfort reading",
+    category: "heritage",
+    fontFamily: "'Noto Sans Variable', 'Noto Sans', system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 1px 3px rgba(180, 83, 9, 0.08)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#B45309",
+    headerBg: "#FEF3C7",
+    headerText: "#78350F",
+    cellBg: "#FFFBEB",
+    cellAltBg: "#FEF9C3",
+    cellHoverBg: "#FEF3C7",
+    cellText: "#1C1917",
+    cellMutedText: "#78716C",
+    borderColor: "#FDE68A",
+    todayBg: "#FEF3C7",
+    todayBorder: "#D97706",
+    todayNumberBg: "#B45309",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#FEF3C7",
+    badgeText: "#92400E",
+    badgeBorder: "#FCD34D"
+  },
+  midnight: {
+    id: "midnight",
+    label: "Midnight Slate",
+    description: "Deep dark-mode slate grid with luminous sky accents",
+    category: "heritage",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 4px 12px rgba(2, 6, 23, 0.35)",
+    eventRadius: "6px",
+    eventStyle: "tinted",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#38BDF8",
+    headerBg: "#1E293B",
+    headerText: "#E2E8F0",
+    cellBg: "#0F172A",
+    cellAltBg: "#162032",
+    cellHoverBg: "#1E293B",
+    cellText: "#F8FAFC",
+    cellMutedText: "#94A3B8",
+    borderColor: "#334155",
+    todayBg: "#172554",
+    todayBorder: "#38BDF8",
+    todayNumberBg: "#0284C7",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#1E293B",
+    badgeText: "#7DD3FC",
+    badgeBorder: "#0369A1"
+  }
+};
+const BUILTIN_EVENTS_SOURCE = {
+  id: "events",
+  label: "Events",
+  uid: "plugin::events.event",
+  color: "#4945FF",
+  enabled: true,
+  publicFeed: true,
+  fields: {
+    title: "title",
+    startDate: "startDate",
+    endDate: "endDate",
+    rrule: "recurrence",
+    location: "location",
+    category: "category",
+    status: "eventStatus",
+    summary: "summary",
+    slug: "slug",
+    color: "color"
+  }
+};
+const BUILTIN_BOOKINGS_SOURCE = {
+  id: "bookings",
+  label: "Bookings & Reservations",
+  uid: "plugin::bookings.booking",
+  color: "#0D9488",
+  enabled: true,
+  publicFeed: false,
+  fields: {
+    title: "title",
+    startDate: "startDate",
+    endDate: "endDate",
+    status: "status",
+    location: "assignedHost",
+    summary: "notes",
+    category: "status"
+  }
+};
+const STORE_KEY = "settings";
+const INTERNAL_PLUGIN_PREFIXES = [
+  "plugin::upload",
+  "plugin::i18n",
+  "plugin::users-permissions",
+  "plugin::content-releases",
+  "plugin::review-workflows",
+  "plugin::navigation",
+  "plugin::email-designer-5",
+  "plugin::strapi-cache",
+  "plugin::typesense",
+  "plugin::preview-button",
+  "plugin::seo"
+];
+function appendAutoDetectedPluginSources(mergedSources, contentTypes) {
+  for (const builtin of [BUILTIN_EVENTS_SOURCE, BUILTIN_BOOKINGS_SOURCE]) {
+    if (contentTypes[builtin.uid] && !mergedSources.some((s) => s.uid === builtin.uid)) {
+      mergedSources.push({ ...builtin, fields: { ...builtin.fields } });
+    }
+  }
+}
+function mergeUserConfigSources(mergedSources, userSources) {
+  if (!Array.isArray(userSources)) return;
+  for (const src of userSources) {
+    if (!src?.id || !src.uid) continue;
+    const idx = mergedSources.findIndex(
+      (s) => s.id === src.id || s.uid === src.uid
+    );
+    if (idx >= 0) {
+      mergedSources[idx] = {
+        ...mergedSources[idx],
+        ...src,
+        fields: { ...mergedSources[idx].fields, ...src.fields }
+      };
+    } else {
+      mergedSources.push(src);
+    }
+  }
+}
+function mergeUserSecondaryCalendars(mergedCalendars, userCalendars) {
+  if (!Array.isArray(userCalendars)) return;
+  for (const cal of userCalendars) {
+    if (!cal?.id || !cal.intlCalendar) continue;
+    const idx = mergedCalendars.findIndex((c) => c.id === cal.id);
+    if (idx >= 0) {
+      mergedCalendars[idx] = { ...mergedCalendars[idx], ...cal };
+    } else {
+      mergedCalendars.push(cal);
+    }
+  }
+}
+function mergePresetLists(defaults, stored) {
+  const result = [...defaults ?? []];
+  if (!Array.isArray(stored)) return result;
+  for (const item of stored) {
+    if (!item?.id || !item.rrule) continue;
+    const idx = result.findIndex(
+      (p) => p.id === item.id || p.rrule === item.rrule
+    );
+    if (idx >= 0) {
+      result[idx] = { ...result[idx], ...item };
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function mergeSourceLists(defaults, stored) {
+  return Array.isArray(stored) ? [...stored] : [...defaults ?? []];
+}
+function mergeCalendarLists(defaults, stored) {
+  return Array.isArray(stored) ? [...stored] : [...defaults ?? []];
+}
+function pickNonEmptyStr(val, fallback, maxLen) {
+  if (typeof val === "string" && val.trim()) {
+    const trimmed = val.trim();
+    return maxLen ? trimmed.slice(0, maxLen) : trimmed;
+  }
+  return fallback;
+}
+function pickBool(val, fallback) {
+  return typeof val === "boolean" ? val : fallback;
+}
+function pickEnum(val, allowed, fallback) {
+  return typeof val === "string" && allowed.includes(val) ? val : fallback;
+}
+function pickArray(val, fallback) {
+  return Array.isArray(val) ? val : fallback;
+}
+function pickRecordKey(val, record, fallback) {
+  return typeof val === "string" && val in record ? val : fallback;
+}
+const HEX_COLOR_RE = /^#[0-9a-fA-F]{3,8}$/;
+function pickPrimaryHex(val, fallback) {
+  return typeof val === "string" && HEX_COLOR_RE.test(val.trim()) ? val.trim() : fallback;
+}
+function resolveThemePatch(current, patch) {
+  return {
+    theme: pickRecordKey(
+      patch.theme,
+      CALENDAR_THEME_PRESETS,
+      current.theme ?? "breeze"
+    ),
+    colorScheme: pickEnum(
+      patch.colorScheme,
+      ["auto", "light", "dark"],
+      current.colorScheme ?? "auto"
+    ),
+    themePalette: pickRecordKey(
+      patch.themePalette,
+      CALENDAR_COLOR_PALETTES,
+      current.themePalette ?? "default"
+    ),
+    secondaryCalendarLanguage: pickEnum(
+      patch.secondaryCalendarLanguage,
+      ["local", "ar", "off"],
+      current.secondaryCalendarLanguage ?? "local"
+    ),
+    primaryColor: pickPrimaryHex(patch.primaryColor, current.primaryColor)
+  };
+}
+function resolveViewBooleansPatch(current, patch) {
+  return {
+    weekNumbers: pickBool(patch.weekNumbers, current.weekNumbers ?? false),
+    timeFormat24h: pickBool(patch.timeFormat24h, current.timeFormat24h ?? true),
+    showWeekends: pickBool(patch.showWeekends, current.showWeekends),
+    showTodayButton: pickBool(patch.showTodayButton, current.showTodayButton),
+    showCreateButton: pickBool(
+      patch.showCreateButton,
+      current.showCreateButton
+    ),
+    monthView: pickBool(patch.monthView, current.monthView),
+    weekView: pickBool(patch.weekView, current.weekView),
+    dayView: pickBool(patch.dayView, current.dayView),
+    agendaView: pickBool(patch.agendaView, current.agendaView),
+    yearView: pickBool(patch.yearView, current.yearView)
+  };
+}
+function sanitizeSourceItem(src) {
+  const categoryColors = src.categoryColors ? Object.fromEntries(
+    Object.entries(src.categoryColors).filter(
+      ([, v]) => typeof v === "string" && HEX_COLOR_RE.test(v.trim())
+    )
+  ) : void 0;
+  return {
+    ...src,
+    color: pickPrimaryHex(src.color, "#4945ff"),
+    ...categoryColors ? { categoryColors } : {}
+  };
+}
+function buildUpdatedSettings(current, patch) {
+  const firstDay = typeof patch.firstDayOfWeek === "number" && patch.firstDayOfWeek >= 0 && patch.firstDayOfWeek <= 6 ? Math.floor(patch.firstDayOfWeek) : current.firstDayOfWeek;
+  return {
+    ...current,
+    ...resolveThemePatch(current, patch),
+    ...resolveViewBooleansPatch(current, patch),
+    defaultTimezone: pickNonEmptyStr(
+      patch.defaultTimezone,
+      current.defaultTimezone
+    ),
+    defaultLocale: pickNonEmptyStr(
+      patch.defaultLocale,
+      current.defaultLocale ?? "auto"
+    ),
+    direction: pickEnum(
+      patch.direction,
+      ["auto", "ltr", "rtl"],
+      current.direction ?? "auto"
+    ),
+    defaultView: typeof patch.defaultView === "string" ? patch.defaultView : current.defaultView,
+    firstDayOfWeek: firstDay,
+    weekNumberCalculation: pickEnum(
+      patch.weekNumberCalculation,
+      ["local", "ISO"],
+      current.weekNumberCalculation ?? "ISO"
+    ),
+    startHour: pickNonEmptyStr(patch.startHour, current.startHour),
+    endHour: pickNonEmptyStr(patch.endHour, current.endHour),
+    slotDuration: pickNonEmptyStr(patch.slotDuration, current.slotDuration),
+    feedTitle: pickNonEmptyStr(patch.feedTitle, current.feedTitle, 140),
+    businessHours: pickArray(patch.businessHours, current.businessHours),
+    sources: pickArray(patch.sources, current.sources).map(sanitizeSourceItem),
+    secondaryCalendars: pickArray(
+      patch.secondaryCalendars,
+      current.secondaryCalendars ?? []
+    ),
+    recurrencePresets: pickArray(
+      patch.recurrencePresets,
+      current.recurrencePresets ?? []
+    )
+  };
+}
+function isDiscoverableSchema(uid, schema) {
+  if (!schema || typeof schema !== "object") return false;
+  if (!uid.startsWith("api::") && !uid.startsWith("plugin::")) return false;
+  if (INTERNAL_PLUGIN_PREFIXES.some((prefix) => uid.startsWith(prefix)))
+    return false;
+  const typed = schema;
+  return !typed.kind || typed.kind === "collectionType";
+}
+function extractSchemaFields(attributes) {
+  const fields = Object.entries(attributes).filter(([, def]) => def && typeof def.type === "string").map(([name, def]) => ({
+    name,
+    type: String(def.customField || def.type)
+  }));
+  if (!fields.some((f) => f.name === "publishedAt")) {
+    fields.push({ name: "publishedAt", type: "datetime" });
+  }
+  if (!fields.some((f) => f.name === "createdAt")) {
+    fields.push({ name: "createdAt", type: "datetime" });
+  }
+  return fields;
+}
+function scoreContentTypeUid(uid) {
+  if (uid === "plugin::events.event") return 0;
+  if (uid === "plugin::bookings.booking") return 1;
+  return uid.startsWith("api::") ? 2 : 3;
+}
+function mergeStoredWithDefaults(defaults, stored) {
+  return {
+    ...defaults,
+    ...stored,
+    sources: mergeSourceLists(defaults.sources, stored.sources),
+    secondaryCalendars: mergeCalendarLists(
+      defaults.secondaryCalendars,
+      stored.secondaryCalendars
+    ),
+    recurrencePresets: mergePresetLists(
+      defaults.recurrencePresets,
+      stored.recurrencePresets
+    )
+  };
+}
+const settings = ({ strapi }) => {
+  const getStore = () => strapi.store({ type: "plugin", name: PLUGIN_ID });
+  const getRegistryService = () => getCalendarService(strapi, PLUGIN_ID, "registry");
+  const getConfigDefaults = () => {
+    const userConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+    const registry2 = getRegistryService();
+    const mergedSources = [
+      ...DEFAULT_CALENDAR_SETTINGS.sources,
+      ...registry2?.getRegisteredSources?.() ?? []
+    ];
+    appendAutoDetectedPluginSources(
+      mergedSources,
+      strapi.contentTypes ?? {}
+    );
+    mergeUserConfigSources(mergedSources, userConfig.sources);
+    const mergedCalendars = [
+      ...DEFAULT_CALENDAR_SETTINGS.secondaryCalendars ?? [],
+      ...registry2?.getRegisteredSecondaryCalendars?.() ?? []
+    ];
+    mergeUserSecondaryCalendars(mergedCalendars, userConfig.secondaryCalendars);
+    return {
+      ...DEFAULT_CALENDAR_SETTINGS,
+      ...userConfig,
+      sources: mergedSources,
+      secondaryCalendars: mergedCalendars,
+      recurrencePresets: mergePresetLists(
+        DEFAULT_CALENDAR_SETTINGS.recurrencePresets,
+        userConfig.recurrencePresets
+      )
+    };
+  };
+  const service = {
+    async ensureInitialized() {
+      const store = getStore();
+      const existing = await store.get({
+        key: STORE_KEY
+      });
+      const defaults = getConfigDefaults();
+      const merged = existing ? mergeStoredWithDefaults(defaults, existing) : defaults;
+      await store.set({ key: STORE_KEY, value: merged });
+      return merged;
+    },
+    async getSettings() {
+      const stored = await getStore().get({
+        key: STORE_KEY
+      });
+      const defaults = getConfigDefaults();
+      return stored ? mergeStoredWithDefaults(defaults, stored) : defaults;
+    },
+    async updateSettings(patch) {
+      const next = buildUpdatedSettings(await service.getSettings(), patch);
+      await getStore().set({ key: STORE_KEY, value: next });
+      return next;
+    },
+    async clearSettings() {
+      const defaults = getConfigDefaults();
+      await getStore().set({ key: STORE_KEY, value: defaults });
+      return defaults;
+    },
+    discoverContentTypes() {
+      const contentTypes = strapi.contentTypes ?? {};
+      const discovered = [];
+      for (const [uid, schema] of Object.entries(contentTypes)) {
+        if (!isDiscoverableSchema(uid, schema)) continue;
+        const fields = extractSchemaFields(schema.attributes ?? {});
+        if (fields.length === 0) continue;
+        discovered.push({
+          uid,
+          displayName: String(schema.info?.displayName || uid),
+          kind: String(schema.kind || "collectionType"),
+          fields
+        });
+      }
+      discovered.sort(
+        (a, b) => scoreContentTypeUid(a.uid) - scoreContentTypeUid(b.uid) || a.displayName.localeCompare(b.displayName)
+      );
+      return discovered;
+    }
+  };
+  return service;
+};
+const services = {
+  settings,
+  registry,
+  occurrence,
+  ical
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services
+};
+exports.default = index;