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

package/dist/server/index.js

@@ -0,0 +1,3709 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const shared = require("@vicacha-devs/strapi-plugin-calendar/shared");
+const crypto = require("node:crypto");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const crypto__default = /* @__PURE__ */ _interopDefault(crypto);
+const PLUGIN_ID = "events";
+const EVENT_CONTENT_TYPE_UID = `plugin::${PLUGIN_ID}.event`;
+const REGISTRATION_CONTENT_TYPE_UID = `plugin::${PLUGIN_ID}.registration`;
+class PluginValidationError extends Error {
+  statusCode = 400;
+  constructor(message) {
+    super(message);
+    this.name = "PluginValidationError";
+  }
+}
+class PluginNotFoundError extends Error {
+  statusCode = 404;
+  constructor(message) {
+    super(message);
+    this.name = "PluginNotFoundError";
+  }
+}
+function getDocumentsClient(strapi, uid) {
+  return strapi.documents(
+    uid
+  );
+}
+function getSettingsService(strapi) {
+  return strapi.plugin(PLUGIN_ID).service("settings");
+}
+function getOccurrenceService(strapi) {
+  return strapi.plugin(PLUGIN_ID).service("occurrence");
+}
+function getRsvpService(strapi) {
+  return strapi.plugin(PLUGIN_ID).service("rsvp");
+}
+function getIcalService(strapi) {
+  return strapi.plugin(PLUGIN_ID).service("ical");
+}
+function clampPaginatedSlice(items, params) {
+  const maxLimit = params?.maxLimit ?? 500;
+  const defaultLimit = params?.defaultLimit ?? maxLimit;
+  if (params?.page !== void 0 || params?.pageSize !== void 0) {
+    const rawPage = Number(params.page);
+    const page = Number.isFinite(rawPage) && rawPage >= 1 ? Math.min(1e3, Math.floor(rawPage)) : 1;
+    const rawSize = Number(params.pageSize ?? params.limit);
+    const pageSize = Number.isFinite(rawSize) && rawSize >= 1 ? Math.min(maxLimit, Math.floor(rawSize)) : Math.min(50, maxLimit);
+    const offset = (page - 1) * pageSize;
+    return items.slice(offset, offset + pageSize);
+  }
+  if (params?.limit !== void 0) {
+    const rawLimit = Number(params.limit);
+    const safeLimit = Number.isFinite(rawLimit) && rawLimit >= 1 ? Math.min(maxLimit, Math.floor(rawLimit)) : Math.min(defaultLimit, maxLimit);
+    return items.slice(0, safeLimit);
+  }
+  return items.slice(0, defaultLimit);
+}
+function handleControllerError(strapi, ctx, err, fallbackMessage) {
+  if (err instanceof PluginNotFoundError) {
+    if (typeof ctx.notFound === "function") {
+      return ctx.notFound(err.message);
+    }
+    ctx.status = 404;
+    ctx.body = { error: { status: 404, message: err.message } };
+    return void 0;
+  }
+  if (err instanceof PluginValidationError) {
+    return ctx.badRequest(err.message);
+  }
+  const detail = err instanceof Error ? err.message : String(err);
+  strapi.log?.error?.(`[events] ${fallbackMessage}: ${detail}`);
+  return ctx.badRequest(fallbackMessage);
+}
+const bootstrap = async ({ strapi }) => {
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Read Calendar & Events",
+      uid: "read",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Create & Reschedule Events / Manage RSVPs",
+      uid: "update",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Manage Events Plugin Settings",
+      uid: "settings.update",
+      pluginName: PLUGIN_ID
+    }
+  ];
+  if (strapi.admin?.services?.permission?.actionProvider?.registerMany) {
+    await strapi.admin.services.permission.actionProvider.registerMany(actions);
+  }
+  const settingsService = getSettingsService(strapi);
+  let settings2 = null;
+  if (settingsService && typeof settingsService.ensureInitialized === "function") {
+    settings2 = await settingsService.ensureInitialized();
+  }
+  const calendarPlugin = strapi.plugin("calendar");
+  const calendarRegistry = calendarPlugin?.service("registry");
+  if (calendarRegistry && typeof calendarRegistry.registerSource === "function" && settings2) {
+    for (const source of settings2.sources ?? []) {
+      try {
+        await calendarRegistry.registerSource({
+          id: source.id,
+          label: source.label,
+          uid: source.uid,
+          color: source.color,
+          enabled: source.enabled,
+          fields: {
+            title: source.fields.title,
+            startDate: source.fields.startDate,
+            endDate: source.fields.endDate,
+            rrule: source.fields.rrule,
+            location: source.fields.location,
+            category: source.fields.category,
+            status: source.fields.status,
+            summary: source.fields.summary,
+            slug: source.fields.slug,
+            timeSlot: source.fields.timeSlot,
+            alternateDateFields: source.fields.alternateDateFields,
+            customFields: source.fields.customFields
+          },
+          timeSlotMap: source.timeSlotMap,
+          categoryColors: source.categoryColors,
+          defaultAllDay: source.defaultAllDay
+        });
+      } catch {
+      }
+    }
+  }
+};
+const DEFAULT_PLUGIN_SETTINGS = {
+  defaultTimezone: "UTC",
+  defaultCapacity: 100,
+  waitlistEnabledByDefault: true,
+  defaultMaxGuestsPerRegistration: 5,
+  sendRsvpEmails: true,
+  feedTitle: "Events Calendar",
+  sources: [
+    {
+      id: "builtin-events",
+      label: "Events",
+      uid: EVENT_CONTENT_TYPE_UID,
+      color: "#0D9488",
+      enabled: true,
+      fields: {
+        title: "title",
+        startDate: "startDate",
+        endDate: "endDate",
+        rrule: "recurrence",
+        location: "location",
+        category: "category",
+        status: "eventStatus",
+        summary: "summary",
+        slug: "slug",
+        capacity: "capacity",
+        rsvpEnabled: "rsvpEnabled",
+        poster: "poster",
+        actionLinks: "actionLinks",
+        spotlightConfig: "spotlightConfig"
+      }
+    }
+  ],
+  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_PLUGIN_SETTINGS,
+  validator(config2) {
+    if (config2.defaultCapacity !== void 0 && config2.defaultCapacity < 1) {
+      throw new Error("events plugin config: defaultCapacity must be >= 1");
+    }
+  }
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "plugin_events_items";
+const info$1 = { "singularName": "event", "pluralName": "events", "displayName": "Event", "description": "Recurring & single events managed by strapi-plugin-events" };
+const options$1 = { "draftAndPublish": true };
+const pluginOptions$1 = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true }, "i18n": { "localized": true } };
+const attributes$1 = { "title": { "type": "string", "required": true, "maxLength": 200, "pluginOptions": { "i18n": { "localized": true } } }, "slug": { "type": "uid", "targetField": "title", "required": true, "pluginOptions": { "i18n": { "localized": true } } }, "summary": { "type": "text", "maxLength": 500, "pluginOptions": { "i18n": { "localized": true } } }, "description": { "type": "richtext", "pluginOptions": { "i18n": { "localized": true } } }, "startDate": { "type": "datetime", "required": true, "pluginOptions": { "i18n": { "localized": false } } }, "endDate": { "type": "datetime", "pluginOptions": { "i18n": { "localized": false } } }, "allDay": { "type": "boolean", "default": false, "pluginOptions": { "i18n": { "localized": false } } }, "timezone": { "type": "string", "default": "UTC", "pluginOptions": { "i18n": { "localized": false } } }, "recurrence": { "type": "customField", "customField": "plugin::events.rrule", "pluginOptions": { "i18n": { "localized": false } } }, "eventStatus": { "type": "enumeration", "enum": ["scheduled", "cancelled", "postponed", "rescheduled"], "default": "scheduled", "required": true, "pluginOptions": { "i18n": { "localized": false } } }, "locationType": { "type": "enumeration", "enum": ["in_person", "online", "hybrid"], "default": "in_person", "pluginOptions": { "i18n": { "localized": false } } }, "location": { "type": "string", "pluginOptions": { "i18n": { "localized": true } } }, "virtualUrl": { "type": "string", "pluginOptions": { "i18n": { "localized": false } } }, "category": { "type": "string", "default": "general", "pluginOptions": { "i18n": { "localized": false } } }, "speaker": { "type": "string", "pluginOptions": { "i18n": { "localized": true } } }, "speakerSlug": { "type": "string", "pluginOptions": { "i18n": { "localized": false } } }, "color": { "type": "string", "default": "#0D9488", "pluginOptions": { "i18n": { "localized": false } } }, "featured": { "type": "boolean", "default": false, "pluginOptions": { "i18n": { "localized": false } } }, "rsvpEnabled": { "type": "boolean", "default": false, "pluginOptions": { "i18n": { "localized": false } } }, "capacity": { "type": "integer", "min": 1, "pluginOptions": { "i18n": { "localized": false } } }, "waitlistEnabled": { "type": "boolean", "default": true, "pluginOptions": { "i18n": { "localized": false } } }, "maxGuestsPerRegistration": { "type": "integer", "min": 1, "max": 50, "default": 5, "pluginOptions": { "i18n": { "localized": false } } }, "registrationDeadline": { "type": "datetime", "pluginOptions": { "i18n": { "localized": false } } }, "alternateDates": { "type": "json", "pluginOptions": { "i18n": { "localized": true } } }, "poster": { "type": "media", "multiple": false, "required": false, "allowedTypes": ["images", "files"], "pluginOptions": { "i18n": { "localized": true } } }, "actionLinks": { "type": "json", "pluginOptions": { "i18n": { "localized": true } } }, "spotlightConfig": { "type": "json", "pluginOptions": { "i18n": { "localized": true } } }, "metadata": { "type": "json", "pluginOptions": { "i18n": { "localized": true } } } };
+const eventSchema = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const kind = "collectionType";
+const collectionName = "plugin_events_registrations";
+const info = { "singularName": "registration", "pluralName": "registrations", "displayName": "Event Registration (RSVP)", "description": "Attendee RSVPs, waitlists, and check-ins managed by strapi-plugin-events" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes = { "eventUid": { "type": "string", "required": true, "default": "plugin::events.event" }, "eventDocumentId": { "type": "string", "required": true }, "eventTitle": { "type": "string" }, "occurrenceDate": { "type": "string", "required": true }, "attendeeName": { "type": "string", "required": true, "maxLength": 160 }, "attendeeEmail": { "type": "email", "required": true }, "attendeePhone": { "type": "string", "maxLength": 50 }, "guestsCount": { "type": "integer", "required": true, "min": 1, "max": 50, "default": 1 }, "status": { "type": "enumeration", "enum": ["confirmed", "waitlisted", "cancelled", "checked_in"], "default": "confirmed", "required": true }, "checkInToken": { "type": "string", "private": true }, "checkedInAt": { "type": "datetime" }, "locale": { "type": "string", "default": "es" }, "notes": { "type": "text", "maxLength": 2e3 }, "metadata": { "type": "json" } };
+const registrationSchema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  event: { schema: eventSchema },
+  registration: { schema: registrationSchema }
+};
+function optStr$1(val) {
+  return typeof val === "string" && val ? val : void 0;
+}
+function optNum(val) {
+  return typeof val === "number" && Number.isFinite(val) ? val : void 0;
+}
+function optQueryInt$1(val) {
+  if (typeof val === "number" && Number.isFinite(val)) return val;
+  if (typeof val === "string" && val.trim() !== "") {
+    const parsed = Number(val);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function buildRescheduleInput(body) {
+  return {
+    sourceId: optStr$1(body.sourceId),
+    uid: optStr$1(body.uid),
+    documentId: String(body.documentId ?? ""),
+    occurrenceDate: String(body.occurrenceDate ?? ""),
+    newStartDate: String(body.newStartDate ?? ""),
+    newEndDate: optStr$1(body.newEndDate),
+    applyToSeries: Boolean(body.applyToSeries),
+    cancelOccurrence: Boolean(body.cancelOccurrence)
+  };
+}
+function buildQuickCreateInput(body) {
+  return {
+    sourceId: optStr$1(body.sourceId),
+    title: String(body.title ?? ""),
+    startDate: String(body.startDate ?? ""),
+    endDate: optStr$1(body.endDate),
+    location: optStr$1(body.location),
+    category: optStr$1(body.category),
+    summary: optStr$1(body.summary),
+    rrule: optStr$1(body.rrule),
+    rsvpEnabled: Boolean(body.rsvpEnabled),
+    capacity: optNum(body.capacity)
+  };
+}
+const admin$1 = ({ strapi }) => {
+  return {
+    async getSettings(ctx) {
+      const data = await getSettingsService(strapi).getSettings();
+      ctx.body = { data };
+    },
+    async updateSettings(ctx) {
+      try {
+        const payload = ctx.request?.body ?? {};
+        const data = await getSettingsService(strapi).updateSettings(payload);
+        ctx.body = { data };
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Unable to update settings."
+        );
+      }
+    },
+    async getCalendar(ctx) {
+      const q = ctx.query ?? {};
+      const settings2 = await getSettingsService(strapi).getSettings();
+      const occurrences = await getOccurrenceService(strapi).getOccurrences({
+        from: optStr$1(q.from),
+        to: optStr$1(q.to),
+        category: optStr$1(q.category),
+        sourceId: optStr$1(q.sourceId),
+        locale: optStr$1(q.locale),
+        includeDrafts: true,
+        limit: optQueryInt$1(q.limit),
+        page: optQueryInt$1(q.page),
+        pageSize: optQueryInt$1(q.pageSize)
+      });
+      ctx.body = {
+        data: {
+          occurrences,
+          settings: settings2
+        }
+      };
+    },
+    async reschedule(ctx) {
+      try {
+        const body = ctx.request?.body ?? {};
+        const updated = await getOccurrenceService(strapi).rescheduleOccurrence(
+          buildRescheduleInput(body)
+        );
+        ctx.body = { data: updated };
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Unable to reschedule event occurrence."
+        );
+      }
+    },
+    async quickCreate(ctx) {
+      try {
+        const body = ctx.request?.body ?? {};
+        const created = await getOccurrenceService(strapi).quickCreateEvent(
+          buildQuickCreateInput(body)
+        );
+        ctx.status = 201;
+        ctx.body = { data: created };
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Unable to create event."
+        );
+      }
+    },
+    async getEventStats(ctx) {
+      const { documentId } = ctx.params ?? {};
+      const q = ctx.query ?? {};
+      const data = await getRsvpService(strapi).getEventStats({
+        eventUid: optStr$1(q.eventUid),
+        eventDocumentId: String(documentId ?? ""),
+        occurrenceDate: optStr$1(q.occurrenceDate) ?? null,
+        includeDrafts: true
+      });
+      ctx.body = { data };
+    },
+    async listRegistrations(ctx) {
+      const q = ctx.query ?? {};
+      const data = await getRsvpService(strapi).listRegistrations({
+        eventDocumentId: optStr$1(q.eventDocumentId),
+        occurrenceDate: optStr$1(q.occurrenceDate),
+        status: optStr$1(q.status),
+        search: optStr$1(q.search),
+        limit: optQueryInt$1(q.limit),
+        page: optQueryInt$1(q.page),
+        pageSize: optQueryInt$1(q.pageSize)
+      });
+      ctx.body = { data };
+    },
+    async updateRegistrationStatus(ctx) {
+      try {
+        const { documentId } = ctx.params ?? {};
+        const { status } = ctx.request?.body ?? {};
+        const result = await getRsvpService(strapi).updateRegistrationStatus(
+          String(documentId ?? ""),
+          status
+        );
+        ctx.body = { data: result };
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Failed to update registration status."
+        );
+      }
+    },
+    async checkIn(ctx) {
+      try {
+        const { documentId } = ctx.params ?? {};
+        const { token } = ctx.request?.body ?? {};
+        const data = await getRsvpService(strapi).checkInAttendee({
+          documentId: optStr$1(documentId),
+          token: optStr$1(token)
+        });
+        ctx.body = { data };
+      } catch (err) {
+        return handleControllerError(strapi, ctx, err, "Check-in failed.");
+      }
+    },
+    async exportRegistrationsCsv(ctx) {
+      const q = ctx.query ?? {};
+      const csv = await getRsvpService(strapi).exportRegistrationsCsv({
+        eventDocumentId: optStr$1(q.eventDocumentId),
+        occurrenceDate: optStr$1(q.occurrenceDate),
+        status: optStr$1(q.status)
+      });
+      ctx.set("Content-Type", "text/csv; charset=utf-8");
+      ctx.set(
+        "Content-Disposition",
+        'attachment; filename="event-registrations.csv"'
+      );
+      ctx.set("X-Content-Type-Options", "nosniff");
+      ctx.body = csv;
+    }
+  };
+};
+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 DANGEROUS_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isSafeObjectKey(key) {
+  return typeof key === "string" && key.length > 0 && !DANGEROUS_OBJECT_KEYS.has(key);
+}
+function sanitizePlainRecord(raw, maxDepth = 4) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw) || maxDepth < 0) {
+    return null;
+  }
+  const clean = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (!isSafeObjectKey(k)) continue;
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      if (maxDepth === 0) continue;
+      clean[k] = sanitizePlainRecord(v, maxDepth - 1);
+    } else if (Array.isArray(v)) {
+      clean[k] = maxDepth === 0 ? [] : v.map(
+        (item) => item && typeof item === "object" && !Array.isArray(item) ? sanitizePlainRecord(item, maxDepth - 1) : item
+      );
+    } else {
+      clean[k] = v;
+    }
+  }
+  return clean;
+}
+const ALLOWED_ACTION_VARIANTS = /* @__PURE__ */ new Set([
+  "primary",
+  "secondary",
+  "outline"
+]);
+const HTTP_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:"]);
+const ACTION_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:", "mailto:"]);
+function isSafeRelativeUrl(trimmed) {
+  return trimmed.startsWith("/") && !trimmed.startsWith("//") && !trimmed.includes("\\");
+}
+function isAllowedAbsoluteUrl(trimmed, allowMailto) {
+  try {
+    const parsed = new URL(trimmed);
+    const proto = parsed.protocol.toLowerCase();
+    return allowMailto ? ACTION_PROTOCOLS.has(proto) : HTTP_PROTOCOLS.has(proto);
+  } catch {
+    return false;
+  }
+}
+function sanitizeEventUrl(rawUrl, options2) {
+  if (typeof rawUrl !== "string") return null;
+  const trimmed = rawUrl.trim();
+  if (!trimmed || trimmed.length > 2048 || /[\u0000-\u001F\u007F]/.test(trimmed)) {
+    return null;
+  }
+  const allowMailto = options2?.allowMailto ?? true;
+  if (isSafeRelativeUrl(trimmed) || isAllowedAbsoluteUrl(trimmed, allowMailto)) {
+    return trimmed;
+  }
+  return null;
+}
+function parseJsonIfNeeded(raw) {
+  if (typeof raw !== "string") return raw;
+  const trimmed = raw.trim();
+  const isJsonLike = trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+  if (!isJsonLike) return raw;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return raw;
+  }
+}
+function getTrimmedString(val, maxLen) {
+  if (typeof val !== "string") return void 0;
+  const trimmed = val.trim();
+  if (!trimmed) return void 0;
+  return maxLen ? trimmed.slice(0, maxLen) : trimmed;
+}
+function getPositiveInteger(val) {
+  if (typeof val !== "number" || !Number.isFinite(val) || val <= 0) {
+    return void 0;
+  }
+  return Math.round(val);
+}
+function unwrapPosterRecord(obj) {
+  if (obj.data && typeof obj.data === "object" && !Array.isArray(obj.data)) {
+    return unwrapPosterRecord(obj.data);
+  }
+  if (obj.attributes && typeof obj.attributes === "object" && !Array.isArray(obj.attributes)) {
+    return unwrapPosterRecord(obj.attributes);
+  }
+  return obj;
+}
+function resolvePosterAltText(obj, fallbackAlt) {
+  return getTrimmedString(obj.alt) || getTrimmedString(obj.alternativeText) || getTrimmedString(obj.caption) || fallbackAlt || void 0;
+}
+function normalizeEventPoster(rawPoster, fallbackAlt) {
+  if (!rawPoster) return void 0;
+  if (typeof rawPoster === "string") {
+    const safeUrl2 = sanitizeEventUrl(rawPoster, { allowMailto: false });
+    return safeUrl2 ? { url: safeUrl2, alt: fallbackAlt || void 0 } : void 0;
+  }
+  if (Array.isArray(rawPoster)) {
+    return rawPoster.length > 0 ? normalizeEventPoster(rawPoster[0], fallbackAlt) : void 0;
+  }
+  if (typeof rawPoster !== "object") return void 0;
+  const obj = unwrapPosterRecord(rawPoster);
+  const safeUrl = sanitizeEventUrl(obj.url, { allowMailto: false });
+  if (!safeUrl) return void 0;
+  return {
+    url: safeUrl,
+    alt: resolvePosterAltText(obj, fallbackAlt),
+    mime: getTrimmedString(obj.mime),
+    width: getPositiveInteger(obj.width),
+    height: getPositiveInteger(obj.height)
+  };
+}
+function resolveActionVariant(rawVariant, index2) {
+  const candidate = getTrimmedString(rawVariant);
+  if (candidate && ALLOWED_ACTION_VARIANTS.has(candidate)) {
+    return candidate;
+  }
+  return index2 === 0 ? "primary" : "outline";
+}
+function normalizeSingleActionLink(item, index2) {
+  if (!item || typeof item !== "object") return null;
+  const rec = item;
+  const label = getTrimmedString(rec.label, 120);
+  const safeUrl = sanitizeEventUrl(rec.url);
+  if (!label || !safeUrl) return null;
+  const external = typeof rec.external === "boolean" ? rec.external : /^https?:\/\//i.test(safeUrl);
+  const icon = getTrimmedString(rec.icon, 60);
+  return {
+    label,
+    url: safeUrl,
+    variant: resolveActionVariant(rec.variant, index2),
+    external,
+    ...icon ? { icon } : {}
+  };
+}
+function normalizeEventActionLinks(rawLinks) {
+  const parsed = parseJsonIfNeeded(rawLinks);
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    return void 0;
+  }
+  const normalized = parsed.map((item, idx) => normalizeSingleActionLink(item, idx)).filter((link) => link !== null);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isValidCalendarDateKey(dateStr) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+    return false;
+  }
+  const parsed = /* @__PURE__ */ new Date(`${dateStr}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.getTime())) {
+    return false;
+  }
+  return parsed.toISOString().slice(0, 10) === dateStr;
+}
+function toDateKey(dateInput) {
+  const d = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+  if (Number.isNaN(d.getTime())) {
+    return "";
+  }
+  return d.toISOString().slice(0, 10);
+}
+function normalizeRRuleString(raw) {
+  if (!raw || typeof raw !== "string") {
+    return "";
+  }
+  return raw.replace(/[\u0000-\u001F\u007F]+/g, "").trim().replace(/^RRULE:/i, "").trim();
+}
+function sanitizeOccurrenceOverrides(rawOverrides) {
+  const clean = {};
+  if (!rawOverrides || typeof rawOverrides !== "object" || Array.isArray(rawOverrides)) {
+    return clean;
+  }
+  for (const [key, ov] of Object.entries(rawOverrides)) {
+    if (!isSafeObjectKey(key) || !isValidCalendarDateKey(key)) continue;
+    if (!ov || typeof ov !== "object" || Array.isArray(ov)) continue;
+    let validStart;
+    let startMs = null;
+    if (ov.startDate !== void 0 && ov.startDate !== "") {
+      if (typeof ov.startDate !== "string") continue;
+      const parsedStart = new Date(ov.startDate).getTime();
+      if (Number.isNaN(parsedStart)) continue;
+      validStart = ov.startDate;
+      startMs = parsedStart;
+    }
+    let validEnd;
+    if (ov.endDate !== void 0 && ov.endDate !== "") {
+      if (typeof ov.endDate !== "string") continue;
+      const parsedEnd = new Date(ov.endDate).getTime();
+      if (Number.isNaN(parsedEnd)) continue;
+      const minStartMs = startMs ?? (/* @__PURE__ */ new Date(`${key}T00:00:00.000Z`)).getTime();
+      if (parsedEnd < minStartMs) continue;
+      validEnd = ov.endDate;
+    }
+    clean[key] = {
+      ...ov,
+      originalDate: typeof ov.originalDate === "string" && isValidCalendarDateKey(ov.originalDate) ? ov.originalDate : key,
+      startDate: validStart,
+      endDate: validEnd
+    };
+  }
+  return clean;
+}
+function sanitizeRRuleFieldValue(rec, defaultTimezone = "UTC") {
+  const rrule = normalizeRRuleString(rec?.rrule);
+  const timezone = typeof rec?.timezone === "string" && rec.timezone.trim() ? rec.timezone.trim() : defaultTimezone;
+  const exdates = Array.isArray(rec?.exdates) ? rec.exdates.filter(
+    (d) => typeof d === "string" && isValidCalendarDateKey(d)
+  ) : [];
+  const overrides = sanitizeOccurrenceOverrides(rec?.overrides);
+  return {
+    ...rec,
+    rrule,
+    timezone,
+    allDay: Boolean(rec?.allDay),
+    exdates,
+    overrides
+  };
+}
+function parseRRuleFieldValue(raw, defaultTimezone = "UTC") {
+  const parsed = shared.parseRRuleFieldValue(raw, defaultTimezone);
+  return sanitizeRRuleFieldValue(parsed, defaultTimezone);
+}
+function buildRRule(parsed) {
+  return shared.buildRRule({
+    freq: parsed.freq ?? "NONE",
+    interval: parsed.interval ?? 1,
+    byDay: parsed.byDay ?? [],
+    byMonthDay: parsed.byMonthDay,
+    count: parsed.count,
+    until: parsed.until
+  });
+}
+const FREQ_UNITS = {
+  DAILY: { singular: "day", plural: "days" },
+  WEEKLY: { singular: "week", plural: "weeks" },
+  MONTHLY: { singular: "month", plural: "months" },
+  YEARLY: { singular: "year", plural: "years" }
+};
+function formatIntervalUnit(freq, interval) {
+  const unit = Object.hasOwn(FREQ_UNITS, freq) ? FREQ_UNITS[freq] : FREQ_UNITS.YEARLY;
+  return interval === 1 ? unit.singular : `${interval} ${unit.plural}`;
+}
+function describeRRule(rruleString) {
+  const parsed = shared.parseRRule(normalizeRRuleString(rruleString));
+  if (parsed.freq === "NONE") {
+    return "Does not repeat";
+  }
+  let summary = `Every ${formatIntervalUnit(parsed.freq, parsed.interval)}`;
+  if (parsed.freq === "WEEKLY" && parsed.byDay.length > 0) {
+    summary += ` on ${parsed.byDay.join(", ")}`;
+  } else if (parsed.freq === "MONTHLY" && parsed.byMonthDay) {
+    summary += ` on day ${parsed.byMonthDay}`;
+  }
+  if (parsed.until) {
+    summary += ` until ${parsed.until}`;
+  } else if (parsed.count) {
+    summary += ` (${parsed.count} occurrences)`;
+  }
+  return summary;
+}
+function expandRuleSlots(options2) {
+  const baseStartMs = new Date(options2.baseStartDate).getTime();
+  if (Number.isNaN(baseStartMs)) {
+    return [];
+  }
+  let safeBaseEnd = null;
+  if (typeof options2.baseEndDate === "string" && options2.baseEndDate) {
+    const baseEndMs = new Date(options2.baseEndDate).getTime();
+    if (!Number.isNaN(baseEndMs) && baseEndMs >= baseStartMs) {
+      safeBaseEnd = options2.baseEndDate;
+    }
+  }
+  const windowStartIso = typeof options2.windowStart === "string" ? options2.windowStart : options2.windowStart.toISOString();
+  const windowEndIso = typeof options2.windowEnd === "string" ? options2.windowEnd : options2.windowEnd.toISOString();
+  if (Number.isNaN(new Date(windowStartIso).getTime()) || Number.isNaN(new Date(windowEndIso).getTime())) {
+    return [];
+  }
+  return shared.expandRuleSlots({
+    baseStartDate: options2.baseStartDate,
+    baseEndDate: safeBaseEnd,
+    recurrence: sanitizeRRuleFieldValue(
+      options2.recurrence,
+      options2.recurrence?.timezone || "UTC"
+    ),
+    windowStart: windowStartIso,
+    windowEnd: windowEndIso,
+    maxOccurrences: options2.maxInstances ?? 366
+  });
+}
+const ALLOWED_SPOTLIGHT_POSITIONS = /* @__PURE__ */ new Set([
+  "bottom-end",
+  "bottom-start"
+]);
+function resolveSpotlightPosition(rawPos) {
+  const candidate = getTrimmedString(rawPos);
+  return candidate && ALLOWED_SPOTLIGHT_POSITIONS.has(candidate) ? candidate : void 0;
+}
+function resolveFiniteRoundNumber(val) {
+  return typeof val === "number" && Number.isFinite(val) ? Math.round(val) : void 0;
+}
+function normalizeEventSpotlightConfig(rawConfig) {
+  const parsed = parseJsonIfNeeded(rawConfig);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const rec = parsed;
+  const config2 = {
+    enabled: Boolean(rec.enabled)
+  };
+  const badgeText = getTrimmedString(rec.badgeText, 80);
+  if (badgeText) config2.badgeText = badgeText;
+  const priority = resolveFiniteRoundNumber(rec.priority);
+  if (priority !== void 0) config2.priority = priority;
+  const position = resolveSpotlightPosition(rec.position);
+  if (position) config2.position = position;
+  if (typeof rec.showCountdown === "boolean") {
+    config2.showCountdown = rec.showCountdown;
+  }
+  const startAt = getTrimmedString(rec.startAt);
+  if (startAt) config2.startAt = startAt;
+  const endAt = getTrimmedString(rec.endAt);
+  if (endAt) config2.endAt = endAt;
+  return config2;
+}
+function toBoundaryTimestamp(rawIsoOrDate, isEndBoundary) {
+  const trimmed = rawIsoOrDate.trim();
+  const isoString = /^\d{4}-\d{2}-\d{2}$/.test(trimmed) ? `${trimmed}${isEndBoundary ? "T23:59:59.999Z" : "T00:00:00.000Z"}` : trimmed;
+  const ts = new Date(isoString).getTime();
+  return Number.isNaN(ts) ? null : ts;
+}
+function toReferenceTimestamp(referenceDate) {
+  if (referenceDate instanceof Date) {
+    const ts2 = referenceDate.getTime();
+    return Number.isNaN(ts2) ? null : ts2;
+  }
+  const str = getTrimmedString(referenceDate);
+  const dt = str ? new Date(str) : /* @__PURE__ */ new Date();
+  const ts = dt.getTime();
+  return Number.isNaN(ts) ? null : ts;
+}
+function isEventSpotlightActiveOnDate(params) {
+  const { spotlightConfig, eventStartDate, eventEndDate, referenceDate } = params;
+  if (!spotlightConfig?.enabled) return false;
+  const refTs = toReferenceTimestamp(referenceDate);
+  if (refTs === null) return false;
+  const startTs = toBoundaryTimestamp(
+    spotlightConfig.startAt || eventStartDate,
+    false
+  );
+  const endTs = toBoundaryTimestamp(
+    spotlightConfig.endAt || eventEndDate || eventStartDate,
+    true
+  );
+  const afterStart = startTs === null || refTs >= startTs;
+  const beforeEnd = endTs === null || refTs <= endTs;
+  return afterStart && beforeEnd;
+}
+function deduplicateAndSortSpotlights(occurrences) {
+  const byDocKey = /* @__PURE__ */ new Map();
+  for (const occ of occurrences) {
+    if (!occ.spotlightConfig?.enabled || occ.status === "cancelled") {
+      continue;
+    }
+    const key = `${occ.sourceId}:${occ.documentId}`;
+    if (!byDocKey.has(key)) {
+      byDocKey.set(key, occ);
+    }
+  }
+  const unique = Array.from(byDocKey.values());
+  unique.sort((a, b) => {
+    const prioA = a.spotlightConfig?.priority ?? 0;
+    const prioB = b.spotlightConfig?.priority ?? 0;
+    if (prioB !== prioA) {
+      return prioB - prioA;
+    }
+    return new Date(a.startDate).getTime() - new Date(b.startDate).getTime();
+  });
+  return unique;
+}
+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 buildSafeSlotMap(customSlots) {
+  const slotMap = { ...DEFAULT_TIME_SLOTS };
+  if (customSlots && typeof customSlots === "object") {
+    for (const [k, v] of Object.entries(customSlots)) {
+      if (isSafeObjectKey(k) && v && typeof v === "object") {
+        slotMap[k] = v;
+      }
+    }
+  }
+  return slotMap;
+}
+function resolveDateOnlySlotWindow(rawStart, rawSlot, source) {
+  if (!isSafeObjectKey(rawSlot)) return null;
+  const slotMap = buildSafeSlotMap(source.timeSlotMap);
+  const mapped = Object.hasOwn(slotMap, rawSlot) ? slotMap[rawSlot] : void 0;
+  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 null;
+}
+function resolveDateOnlyEnd(rawStart, rawEnd) {
+  if (typeof rawEnd === "string" && rawEnd) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(rawEnd) ? `${rawEnd}T23:59:59.000Z` : rawEnd;
+  }
+  return `${rawStart}T23:59:59.000Z`;
+}
+function readOptionalDocField(doc, fieldName) {
+  return fieldName && isSafeObjectKey(fieldName) ? doc[fieldName] : null;
+}
+function resolveNonEmptyEnd(rawEnd) {
+  return typeof rawEnd === "string" && rawEnd ? rawEnd : null;
+}
+function resolveStartEndFromDocument(doc, source) {
+  const startField = source.fields.startDate;
+  const rawStart = isSafeObjectKey(startField) ? doc[startField] : void 0;
+  if (typeof rawStart !== "string" || !rawStart) {
+    return null;
+  }
+  const rawEnd = readOptionalDocField(doc, source.fields.endDate);
+  const rawSlot = readOptionalDocField(doc, source.fields.timeSlot);
+  if (/^\d{4}-\d{2}-\d{2}$/.test(rawStart)) {
+    const slotWindow = resolveDateOnlySlotWindow(rawStart, rawSlot, source);
+    if (slotWindow) return slotWindow;
+    return {
+      startDate: `${rawStart}T00:00:00.000Z`,
+      endDate: resolveDateOnlyEnd(rawStart, rawEnd),
+      allDay: source.defaultAllDay ?? true
+    };
+  }
+  const allDay = typeof doc.allDay === "boolean" ? doc.allDay : Boolean(source.defaultAllDay);
+  return {
+    startDate: rawStart,
+    endDate: resolveNonEmptyEnd(rawEnd),
+    allDay
+  };
+}
+const EVENT_STATUS_ALIAS_MAP = {
+  cancelled: "cancelled",
+  canceled: "cancelled",
+  postponed: "postponed",
+  pending: "postponed",
+  rescheduled: "rescheduled"
+};
+function mapEventStatus(rawStatus) {
+  if (typeof rawStatus !== "string") return "scheduled";
+  const lower = rawStatus.toLowerCase();
+  return Object.hasOwn(EVENT_STATUS_ALIAS_MAP, lower) ? EVENT_STATUS_ALIAS_MAP[lower] : "scheduled";
+}
+const API_CONTENT_TYPE_UID_RE = /^api::[a-z0-9-]+\.[a-z0-9-]+$/i;
+const SENSITIVE_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "password",
+  "resetpasswordtoken",
+  "validationtoken",
+  "confirmationtoken",
+  "checkintoken",
+  "checkintokenhash",
+  "canceltoken",
+  "canceltokenhash"
+]);
+function isAllowedEventSourceUid(uid) {
+  if (typeof uid !== "string") return false;
+  const trimmed = uid.trim();
+  if (!trimmed) return false;
+  return trimmed === EVENT_CONTENT_TYPE_UID || API_CONTENT_TYPE_UID_RE.test(trimmed);
+}
+function extractCustomFields(strapi, sourceUid, doc, customFieldKeys) {
+  if (!Array.isArray(customFieldKeys) || customFieldKeys.length === 0) {
+    return void 0;
+  }
+  const schemaAttrs = strapi.contentTypes?.[sourceUid]?.attributes;
+  const extracted = {};
+  for (const key of customFieldKeys) {
+    if (!isSafeObjectKey(key)) continue;
+    if (SENSITIVE_FIELD_NAMES.has(key.toLowerCase())) continue;
+    const attrDef = schemaAttrs && Object.hasOwn(schemaAttrs, key) ? schemaAttrs[key] : void 0;
+    if (attrDef?.private === true) continue;
+    if (Object.hasOwn(doc, key) && doc[key] !== void 0) {
+      extracted[key] = doc[key];
+    }
+  }
+  return Object.keys(extracted).length > 0 ? extracted : void 0;
+}
+function buildEmptySlotRsvpStats(meta) {
+  const capacity = meta.capacity;
+  return {
+    eventUid: meta.eventUid,
+    eventDocumentId: meta.eventDocumentId,
+    occurrenceDate: meta.occurrenceDate,
+    rsvpEnabled: meta.rsvpEnabled,
+    capacity,
+    waitlistEnabled: meta.waitlistEnabled,
+    confirmedCount: 0,
+    confirmedSeats: 0,
+    checkedInSeats: 0,
+    waitlistedCount: 0,
+    waitlistedSeats: 0,
+    cancelledCount: 0,
+    remainingSeats: capacity !== null ? Math.max(0, capacity) : null,
+    isFull: capacity !== null ? capacity <= 0 : false
+  };
+}
+async function attachBatchedRsvpStats(strapi, occurrences, pendingByOccurrenceId) {
+  if (pendingByOccurrenceId.size === 0 || occurrences.length === 0) {
+    return;
+  }
+  const rsvpDocIdSet = /* @__PURE__ */ new Set();
+  const occDateSet = /* @__PURE__ */ new Set();
+  for (const meta of pendingByOccurrenceId.values()) {
+    if (meta.rsvpEnabled && meta.eventDocumentId && meta.occurrenceDate) {
+      rsvpDocIdSet.add(meta.eventDocumentId);
+      occDateSet.add(meta.occurrenceDate);
+    }
+  }
+  if (rsvpDocIdSet.size === 0 || occDateSet.size === 0) {
+    return;
+  }
+  const rsvpDocIds = Array.from(rsvpDocIdSet);
+  const occDates = Array.from(occDateSet);
+  let rows;
+  try {
+    rows = await getDocumentsClient(
+      strapi,
+      REGISTRATION_CONTENT_TYPE_UID
+    ).findMany({
+      filters: {
+        eventDocumentId: { $in: rsvpDocIds },
+        occurrenceDate: { $in: occDates }
+      },
+      limit: 1e4
+    });
+  } catch {
+    rows = [];
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const docId = typeof row.eventDocumentId === "string" ? row.eventDocumentId : "";
+    const occDate = typeof row.occurrenceDate === "string" ? row.occurrenceDate : "";
+    if (!docId || !occDate || !rsvpDocIdSet.has(docId)) continue;
+    const slotKey = `${docId}::${occDate}`;
+    const existingBucket = buckets.get(slotKey);
+    if (existingBucket) {
+      existingBucket.push(row);
+    } else {
+      buckets.set(slotKey, [row]);
+    }
+  }
+  for (const occ of occurrences) {
+    const meta = pendingByOccurrenceId.get(occ.occurrenceId);
+    if (!meta || !meta.rsvpEnabled) continue;
+    const slotKey = `${meta.eventDocumentId}::${meta.occurrenceDate}`;
+    const slotRecords = buckets.get(slotKey);
+    if (!slotRecords || slotRecords.length === 0) {
+      occ.rsvp = buildEmptySlotRsvpStats(meta);
+      continue;
+    }
+    const counts = aggregateRsvpCounts(slotRecords);
+    const remainingSeats = meta.capacity !== null ? Math.max(0, meta.capacity - counts.confirmedSeats) : null;
+    const isFull = meta.capacity !== null ? counts.confirmedSeats >= meta.capacity : false;
+    occ.rsvp = {
+      eventUid: meta.eventUid,
+      eventDocumentId: meta.eventDocumentId,
+      occurrenceDate: meta.occurrenceDate,
+      rsvpEnabled: meta.rsvpEnabled,
+      capacity: meta.capacity,
+      waitlistEnabled: meta.waitlistEnabled,
+      ...counts,
+      remainingSeats,
+      isFull
+    };
+  }
+}
+function maskEmail(email) {
+  const [local, domain] = (email || "").split("@");
+  if (!local || !domain) return "***";
+  const visible = local.slice(0, Math.min(2, local.length));
+  return `${visible}***@${domain}`;
+}
+function readNullablePositiveInt(val) {
+  if (typeof val === "number") {
+    return Number.isFinite(val) && val >= 1 ? Math.floor(val) : null;
+  }
+  if (typeof val === "string") {
+    const trimmed = val.trim();
+    if (!/^\d+$/.test(trimmed)) return null;
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isSafeInteger(parsed) && parsed >= 1 ? parsed : null;
+  }
+  return null;
+}
+function readBooleanWithDefault(val, fallback) {
+  return typeof val === "boolean" ? val : fallback;
+}
+function readMaxGuestsWithDefault(val, fallback) {
+  const parsed = readNullablePositiveInt(val);
+  return parsed !== null ? Math.min(50, parsed) : fallback;
+}
+function extractRawDeadline(rawDeadline) {
+  if (rawDeadline === null || rawDeadline === void 0 || rawDeadline === "") {
+    return null;
+  }
+  if (rawDeadline instanceof Date) {
+    return Number.isNaN(rawDeadline.getTime()) ? "INVALID_DEADLINE" : rawDeadline.toISOString();
+  }
+  if (typeof rawDeadline === "string") {
+    const trimmed = rawDeadline.trim();
+    return trimmed ? trimmed : null;
+  }
+  return "INVALID_DEADLINE";
+}
+function buildResolvedTargetEvent(doc, src, eventDocumentId, settings2) {
+  const startEnd = resolveStartEndFromDocument(doc, src);
+  if (!startEnd) {
+    return null;
+  }
+  const f = src.fields;
+  const title = String(
+    (isSafeObjectKey(f.title) ? doc[f.title] : void 0) ?? doc.title ?? "Event"
+  );
+  const rsvpField = f.rsvpEnabled && isSafeObjectKey(f.rsvpEnabled) ? f.rsvpEnabled : "rsvpEnabled";
+  const capField = f.capacity && isSafeObjectKey(f.capacity) ? f.capacity : "capacity";
+  const statusField = f.status && isSafeObjectKey(f.status) ? f.status : "eventStatus";
+  const rruleField = f.rrule && isSafeObjectKey(f.rrule) ? f.rrule : void 0;
+  const docTz = typeof doc.timezone === "string" && doc.timezone ? doc.timezone : settings2.defaultTimezone;
+  const recurrence = parseRRuleFieldValue(
+    rruleField ? doc[rruleField] : doc.recurrence,
+    docTz
+  );
+  if (startEnd.allDay) {
+    recurrence.allDay = true;
+  }
+  return {
+    uid: src.uid,
+    documentId: eventDocumentId,
+    title,
+    startDate: startEnd.startDate,
+    endDate: startEnd.endDate,
+    allDay: startEnd.allDay,
+    recurrence,
+    eventStatus: mapEventStatus(doc[statusField]),
+    rsvpEnabled: doc[rsvpField] !== void 0 ? Boolean(doc[rsvpField]) : false,
+    capacity: readNullablePositiveInt(doc[capField]),
+    waitlistEnabled: readBooleanWithDefault(
+      doc.waitlistEnabled,
+      settings2.waitlistEnabledByDefault
+    ),
+    maxGuestsPerRegistration: readMaxGuestsWithDefault(
+      doc.maxGuestsPerRegistration,
+      settings2.defaultMaxGuestsPerRegistration
+    ),
+    registrationDeadline: extractRawDeadline(doc.registrationDeadline)
+  };
+}
+async function resolveTargetEvent(strapi, eventDocumentId, preferredUid, options2) {
+  const includeDrafts = options2?.includeDrafts ?? false;
+  const settings2 = await getSettingsService(strapi).getSettings();
+  const sources = (settings2.sources ?? []).filter(
+    (s) => isAllowedEventSourceUid(s.uid)
+  );
+  const candidateSources = preferredUid ? [
+    ...sources.filter((s) => s.uid === preferredUid),
+    ...sources.filter((s) => s.uid !== preferredUid)
+  ] : sources;
+  for (const src of candidateSources) {
+    try {
+      const doc = await getDocumentsClient(strapi, src.uid).findOne({
+        documentId: eventDocumentId,
+        ...includeDrafts ? {} : { status: "published" }
+      });
+      if (!doc) continue;
+      if (!includeDrafts && doc.publishedAt === null) {
+        continue;
+      }
+      const resolved = buildResolvedTargetEvent(
+        doc,
+        src,
+        eventDocumentId,
+        settings2
+      );
+      if (resolved) return resolved;
+    } catch {
+    }
+  }
+  return null;
+}
+function readOptionalText(val) {
+  return val ? String(val) : void 0;
+}
+function readStoredGuestsCount(val) {
+  const parsed = readNullablePositiveInt(val);
+  return parsed ?? 1;
+}
+function assertValidGuestsCount(val) {
+  if (val === void 0) {
+    return 1;
+  }
+  if (typeof val !== "number" || !Number.isInteger(val) || val < 1) {
+    throw new PluginValidationError(
+      "Invalid guestsCount: must be an integer >= 1."
+    );
+  }
+  return val;
+}
+function formatRegistrationRecord(raw) {
+  return {
+    documentId: String(raw.documentId ?? ""),
+    eventUid: String(raw.eventUid ?? EVENT_CONTENT_TYPE_UID),
+    eventDocumentId: String(raw.eventDocumentId ?? ""),
+    eventTitle: readOptionalText(raw.eventTitle),
+    occurrenceDate: String(raw.occurrenceDate ?? ""),
+    attendeeName: String(raw.attendeeName ?? ""),
+    attendeeEmail: String(raw.attendeeEmail ?? ""),
+    attendeePhone: readOptionalText(raw.attendeePhone),
+    guestsCount: readStoredGuestsCount(raw.guestsCount),
+    status: raw.status ?? "confirmed",
+    checkedInAt: raw.checkedInAt ? String(raw.checkedInAt) : null,
+    locale: String(raw.locale ?? "es"),
+    notes: readOptionalText(raw.notes),
+    createdAt: readOptionalText(raw.createdAt)
+  };
+}
+function aggregateRsvpCounts(records) {
+  let confirmedCount = 0;
+  let confirmedSeats = 0;
+  let checkedInSeats = 0;
+  let waitlistedCount = 0;
+  let waitlistedSeats = 0;
+  let cancelledCount = 0;
+  for (const rec of records) {
+    const guests = readStoredGuestsCount(rec.guestsCount);
+    const st = rec.status;
+    if (st === "confirmed" || st === "checked_in") {
+      confirmedCount++;
+      confirmedSeats += guests;
+      if (st === "checked_in") {
+        checkedInSeats += guests;
+      }
+    } else if (st === "waitlisted") {
+      waitlistedCount++;
+      waitlistedSeats += guests;
+    } else if (st === "cancelled") {
+      cancelledCount++;
+    }
+  }
+  return {
+    confirmedCount,
+    confirmedSeats,
+    checkedInSeats,
+    waitlistedCount,
+    waitlistedSeats,
+    cancelledCount
+  };
+}
+function assertValidAttendeeIdentity(attendeeName, attendeeEmail) {
+  if (!attendeeName || attendeeName.length > 160) {
+    throw new PluginValidationError(
+      "Invalid attendeeName: must be between 1 and 160 characters."
+    );
+  }
+  if (!attendeeEmail || attendeeEmail.length > 254 || !isValidEmail(attendeeEmail)) {
+    throw new PluginValidationError(
+      "Invalid attendeeEmail: must be a valid email address."
+    );
+  }
+}
+function validateRegistrationInputAndEvent(input, targetEvent) {
+  const attendeeName = (input.attendeeName ?? "").trim();
+  const attendeeEmail = (input.attendeeEmail ?? "").trim().toLowerCase();
+  assertValidAttendeeIdentity(attendeeName, attendeeEmail);
+  if (targetEvent.eventStatus === "cancelled" || targetEvent.eventStatus === "postponed") {
+    throw new PluginValidationError(
+      `Registrations are unavailable because this event is ${targetEvent.eventStatus}.`
+    );
+  }
+  if (!targetEvent.rsvpEnabled) {
+    throw new PluginValidationError("Registrations are closed for this event.");
+  }
+  assertRegistrationBeforeDeadline(targetEvent.registrationDeadline);
+  const guestsCount = assertValidGuestsCount(input.guestsCount);
+  if (guestsCount > targetEvent.maxGuestsPerRegistration) {
+    throw new PluginValidationError(
+      `Maximum guests per registration is ${targetEvent.maxGuestsPerRegistration}.`
+    );
+  }
+  return { attendeeName, attendeeEmail, guestsCount };
+}
+function assertRegistrationBeforeDeadline(deadline) {
+  if (deadline === null) return;
+  const deadlineMs = new Date(deadline).getTime();
+  if (!Number.isFinite(deadlineMs) || Date.now() > deadlineMs) {
+    throw new PluginValidationError(
+      "The registration deadline for this event has passed."
+    );
+  }
+}
+function resolveAssignedRsvpStatus(targetEvent, confirmedSeats, guestsCount) {
+  if (targetEvent.capacity !== null && confirmedSeats + guestsCount > targetEvent.capacity) {
+    if (targetEvent.waitlistEnabled) {
+      return "waitlisted";
+    }
+    throw new PluginValidationError("Event has reached maximum capacity.");
+  }
+  return "confirmed";
+}
+async function trySendNotificationEmail(strapi, payload) {
+  try {
+    const settings2 = await getSettingsService(strapi).getSettings();
+    if (!settings2.sendRsvpEmails) return;
+    const emailPlugin = strapi.plugin("email");
+    const emailService = emailPlugin?.service("email");
+    if (!emailService || typeof emailService.send !== "function") return;
+    const statusHeadline = payload.promotedFromWaitlist ? "Your waitlist spot has been confirmed!" : payload.status === "waitlisted" ? "You have been added to the event waitlist" : "Your event registration is confirmed";
+    const safeTitle = payload.eventTitle.replace(/[\r\n]+/g, " ").trim();
+    const safeSubject = `${statusHeadline} — ${safeTitle}`.replace(/[\r\n]+/g, " ").trim();
+    const safeAttendeeName = payload.attendeeName.replace(/[\r\n]+/g, " ").trim();
+    await emailService.send({
+      to: payload.to,
+      subject: safeSubject,
+      text: [
+        `Hello ${safeAttendeeName},`,
+        "",
+        statusHeadline,
+        `Event: ${safeTitle}`,
+        `Date: ${payload.occurrenceDate}`,
+        `Seats: ${payload.guestsCount}`,
+        `Status: ${payload.status.toUpperCase()}`
+      ].join("\n")
+    });
+  } catch {
+    strapi.log?.debug?.(
+      `[events] Could not send RSVP notification email to ${maskEmail(payload.to)}`
+    );
+  }
+}
+function buildRegistrationCreateData(args) {
+  const {
+    targetEvent,
+    eventDocumentId,
+    occurrenceDate,
+    attendeeName,
+    attendeeEmail,
+    guestsCount,
+    assignedStatus,
+    tokenHash,
+    input
+  } = args;
+  return {
+    eventUid: targetEvent.uid,
+    eventDocumentId,
+    eventTitle: targetEvent.title,
+    occurrenceDate,
+    attendeeName,
+    attendeeEmail,
+    attendeePhone: input.attendeePhone ? String(input.attendeePhone).trim().slice(0, 50) : "",
+    guestsCount,
+    status: assignedStatus,
+    checkInToken: tokenHash,
+    locale: input.locale ? String(input.locale).slice(0, 10) : "es",
+    notes: input.notes ? String(input.notes).trim().slice(0, 2e3) : "",
+    metadata: sanitizePlainRecord(input.metadata)
+  };
+}
+const MAX_PUBLIC_PAGE_SIZE = 100;
+function optStr(val) {
+  return typeof val === "string" && val ? val : void 0;
+}
+function optQueryInt(val) {
+  if (typeof val === "number" && Number.isFinite(val)) return val;
+  if (typeof val === "string" && val.trim() !== "") {
+    const parsed = Number(val);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function clampPublicQueryPagination(q) {
+  const rawPage = optQueryInt(q.page);
+  const rawPageSize = optQueryInt(q.pageSize);
+  const rawLimit = optQueryInt(q.limit);
+  if (rawPage !== void 0 || rawPageSize !== void 0) {
+    const page = rawPage !== void 0 ? Math.max(1, Math.min(1e3, Math.floor(rawPage))) : 1;
+    const sizeCandidate = rawPageSize ?? rawLimit ?? 50;
+    const pageSize = Math.max(
+      1,
+      Math.min(MAX_PUBLIC_PAGE_SIZE, Math.floor(sizeCandidate))
+    );
+    return { page, pageSize };
+  }
+  const limit = rawLimit !== void 0 ? Math.max(1, Math.min(MAX_PUBLIC_PAGE_SIZE, Math.floor(rawLimit))) : MAX_PUBLIC_PAGE_SIZE;
+  return { limit };
+}
+function unwrapRequestData(rawBody) {
+  if (rawBody.data && typeof rawBody.data === "object" && !Array.isArray(rawBody.data)) {
+    return rawBody.data;
+  }
+  return rawBody;
+}
+function buildRegistrationInput(body) {
+  const guestsCount = assertValidGuestsCount(body.guestsCount);
+  const metadata = body.metadata && typeof body.metadata === "object" && !Array.isArray(body.metadata) ? body.metadata : void 0;
+  return {
+    eventUid: optStr(body.eventUid),
+    occurrenceDate: optStr(body.occurrenceDate),
+    attendeeName: String(body.attendeeName ?? ""),
+    attendeeEmail: String(body.attendeeEmail ?? ""),
+    attendeePhone: optStr(body.attendeePhone),
+    guestsCount,
+    locale: optStr(body.locale),
+    notes: optStr(body.notes),
+    metadata
+  };
+}
+const contentApi$1 = ({ strapi }) => {
+  return {
+    async listOccurrences(ctx) {
+      const q = ctx.query ?? {};
+      const pagination = clampPublicQueryPagination(q);
+      const data = await getOccurrenceService(strapi).getOccurrences({
+        from: optStr(q.from),
+        to: optStr(q.to),
+        category: optStr(q.category),
+        sourceId: optStr(q.sourceId),
+        locale: optStr(q.locale),
+        includeDrafts: false,
+        ...pagination
+      });
+      ctx.body = { data };
+    },
+    async listSpotlights(ctx) {
+      const q = ctx.query ?? {};
+      const pagination = clampPublicQueryPagination(q);
+      const data = await getOccurrenceService(strapi).getActiveSpotlights({
+        date: optStr(q.date),
+        category: optStr(q.category),
+        sourceId: optStr(q.sourceId),
+        locale: optStr(q.locale),
+        includeDrafts: false,
+        ...pagination
+      });
+      ctx.body = { data };
+    },
+    async getEventStats(ctx) {
+      const { documentId } = ctx.params ?? {};
+      const q = ctx.query ?? {};
+      const data = await getRsvpService(strapi).getEventStats({
+        eventUid: optStr(q.eventUid),
+        eventDocumentId: String(documentId ?? ""),
+        occurrenceDate: optStr(q.occurrenceDate) ?? null,
+        includeDrafts: false
+      });
+      ctx.body = { data };
+    },
+    async registerAttendee(ctx) {
+      try {
+        const { documentId } = ctx.params ?? {};
+        const body = unwrapRequestData(
+          ctx.request?.body ?? {}
+        );
+        const data = await getRsvpService(strapi).registerAttendee(
+          String(documentId ?? ""),
+          buildRegistrationInput(body)
+        );
+        ctx.status = 201;
+        ctx.body = { data };
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Registration could not be completed."
+        );
+      }
+    },
+    async cancelRegistration(ctx) {
+      try {
+        const { token } = ctx.params ?? {};
+        const data = await getRsvpService(strapi).cancelByToken(
+          String(token ?? "")
+        );
+        ctx.body = { data };
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Cancellation could not be processed."
+        );
+      }
+    },
+    async downloadFeedIcs(ctx) {
+      const q = ctx.query ?? {};
+      const ics = await getIcalService(strapi).generateFeedIcs({
+        from: optStr(q.from),
+        to: optStr(q.to),
+        category: optStr(q.category),
+        sourceId: optStr(q.sourceId),
+        locale: optStr(q.locale)
+      });
+      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;
+    },
+    async downloadEventInviteIcs(ctx) {
+      try {
+        const { documentId } = ctx.params ?? {};
+        const q = ctx.query ?? {};
+        const safeDocId = String(documentId ?? "event").replace(/[^a-zA-Z0-9_-]/g, "") || "event";
+        const ics = await getIcalService(strapi).generateEventInviteIcs({
+          documentId: String(documentId ?? ""),
+          occurrenceDate: optStr(q.occurrenceDate),
+          locale: optStr(q.locale)
+        });
+        ctx.set("Content-Type", "text/calendar; charset=utf-8");
+        ctx.set(
+          "Content-Disposition",
+          `attachment; filename="event-${safeDocId}.ics"`
+        );
+        ctx.set("X-Content-Type-Options", "nosniff");
+        ctx.body = ics;
+      } catch (err) {
+        return handleControllerError(
+          strapi,
+          ctx,
+          err,
+          "Invite could not be generated."
+        );
+      }
+    }
+  };
+};
+const controllers = {
+  admin: admin$1,
+  "content-api": contentApi$1
+};
+const utf8Encoder$1 = new TextEncoder();
+const DAY_MS$1 = 24 * 60 * 60 * 1e3;
+function generateRawRsvpToken() {
+  return crypto__default.default.randomBytes(24).toString("hex");
+}
+function hashRsvpToken(rawToken) {
+  return crypto__default.default.createHash("sha256").update(rawToken, "utf8").digest("hex");
+}
+function verifyTokenHashConstantTime(candidateHash, storedValue) {
+  if (typeof storedValue !== "string" || !storedValue) {
+    return false;
+  }
+  const a = utf8Encoder$1.encode(candidateHash);
+  const b = utf8Encoder$1.encode(storedValue);
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  return crypto__default.default.timingSafeEqual(a, b);
+}
+async function findRegistrationByRawToken(strapi, rawToken) {
+  const cleaned = (rawToken ?? "").trim();
+  if (cleaned.length < 16 || cleaned.length > 256) {
+    return null;
+  }
+  const tokenHash = hashRsvpToken(cleaned);
+  const matches = await getDocumentsClient(
+    strapi,
+    REGISTRATION_CONTENT_TYPE_UID
+  ).findMany({
+    filters: { checkInToken: { $eq: tokenHash } },
+    limit: 10
+  });
+  for (const item of matches) {
+    if (verifyTokenHashConstantTime(tokenHash, item.checkInToken)) {
+      return { record: item, tokenHash };
+    }
+  }
+  return null;
+}
+const strapiSlotLocks = /* @__PURE__ */ new WeakMap();
+function getSlotLocksMap(strapi) {
+  let map = strapiSlotLocks.get(strapi);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    strapiSlotLocks.set(strapi, map);
+  }
+  return map;
+}
+function clearOccurrenceLocks(strapi) {
+  const map = strapiSlotLocks.get(strapi);
+  if (map) {
+    map.clear();
+    strapiSlotLocks.delete(strapi);
+  }
+}
+async function withOccurrenceLock(strapi, eventDocumentId, occurrenceDate, fn) {
+  const slotLocks = getSlotLocksMap(strapi);
+  const lockKey = `${eventDocumentId}::${occurrenceDate}`;
+  const previous = slotLocks.get(lockKey) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const currentTail = previous.then(() => gate);
+  slotLocks.set(lockKey, currentTail);
+  await previous;
+  try {
+    const txFn = strapi.db?.transaction;
+    if (typeof txFn === "function") {
+      const runInTransaction = txFn.bind(strapi.db);
+      return await runInTransaction(() => fn());
+    }
+    return await fn();
+  } finally {
+    release();
+    if (slotLocks.get(lockKey) === currentTail) {
+      slotLocks.delete(lockKey);
+    }
+  }
+}
+function parseEndTimestamp(endIso, startIso, occurrenceDate, allDay) {
+  if (allDay) {
+    const ms = (/* @__PURE__ */ new Date(`${occurrenceDate}T23:59:59.999Z`)).getTime();
+    return Number.isFinite(ms) ? ms : null;
+  }
+  if (endIso) {
+    const endMs = new Date(endIso).getTime();
+    if (Number.isFinite(endMs)) return endMs;
+  }
+  const startMs = new Date(startIso).getTime();
+  return Number.isFinite(startMs) ? startMs + 60 * 60 * 1e3 : null;
+}
+function assertOccurrenceNotEnded(endMs) {
+  if (endMs !== null && Number.isFinite(endMs) && Date.now() > endMs) {
+    throw new PluginValidationError(
+      "Cannot register for an event occurrence that has already ended."
+    );
+  }
+}
+function assertScheduledOccurrence(targetEvent, occurrenceDate) {
+  if (!isValidCalendarDateKey(occurrenceDate)) {
+    throw new PluginValidationError(
+      "Invalid occurrenceDate: must be a valid YYYY-MM-DD calendar date."
+    );
+  }
+  const recurrence = targetEvent.recurrence;
+  if (recurrence.exdates?.includes(occurrenceDate)) {
+    throw new PluginValidationError(
+      `Date ${occurrenceDate} is excluded for this event.`
+    );
+  }
+  const directOverride = isSafeObjectKey(occurrenceDate) && recurrence.overrides && Object.hasOwn(recurrence.overrides, occurrenceDate) ? recurrence.overrides[occurrenceDate] : void 0;
+  if (directOverride?.cancelled) {
+    throw new PluginValidationError(
+      `Occurrence on ${occurrenceDate} has been cancelled.`
+    );
+  }
+  if (!recurrence.rrule) {
+    const baseKey = toDateKey(targetEvent.startDate);
+    if (occurrenceDate !== baseKey) {
+      throw new PluginValidationError(
+        `Date ${occurrenceDate} is not a scheduled occurrence for this event.`
+      );
+    }
+    const effStart = directOverride?.startDate || targetEvent.startDate;
+    const effEnd = directOverride?.endDate || targetEvent.endDate;
+    return parseEndTimestamp(
+      effEnd,
+      effStart,
+      occurrenceDate,
+      targetEvent.allDay
+    );
+  }
+  const anchorMs = (/* @__PURE__ */ new Date(`${occurrenceDate}T00:00:00.000Z`)).getTime();
+  const slots = expandRuleSlots({
+    baseStartDate: targetEvent.startDate,
+    baseEndDate: targetEvent.endDate,
+    recurrence,
+    windowStart: new Date(anchorMs - 31 * DAY_MS$1).toISOString(),
+    windowEnd: new Date(anchorMs + 32 * DAY_MS$1 - 1).toISOString(),
+    maxInstances: 1e4
+  });
+  const matched = slots.find(
+    (s) => s.occurrenceDate === occurrenceDate || toDateKey(s.startDate) === occurrenceDate
+  );
+  if (!matched) {
+    throw new PluginValidationError(
+      `Date ${occurrenceDate} is not a scheduled occurrence for this event.`
+    );
+  }
+  return parseEndTimestamp(
+    matched.endDate,
+    matched.startDate,
+    occurrenceDate,
+    Boolean(recurrence.allDay || targetEvent.allDay)
+  );
+}
+function resolveValidatedOccurrenceDate(inputDate, targetEvent) {
+  if (inputDate !== void 0 && inputDate !== "") {
+    const trimmed = String(inputDate).trim();
+    const endMs2 = assertScheduledOccurrence(targetEvent, trimmed);
+    assertOccurrenceNotEnded(endMs2);
+    return trimmed;
+  }
+  if (targetEvent.recurrence.rrule) {
+    const nowMs = Date.now();
+    const isAllDay = Boolean(
+      targetEvent.recurrence.allDay || targetEvent.allDay
+    );
+    const upcomingSlots = expandRuleSlots({
+      baseStartDate: targetEvent.startDate,
+      baseEndDate: targetEvent.endDate,
+      recurrence: targetEvent.recurrence,
+      windowStart: new Date(nowMs - DAY_MS$1).toISOString(),
+      windowEnd: new Date(nowMs + 366 * DAY_MS$1).toISOString(),
+      maxInstances: 1e3
+    });
+    for (const slot of upcomingSlots) {
+      const slotEndMs = parseEndTimestamp(
+        slot.endDate,
+        slot.startDate,
+        slot.occurrenceDate,
+        isAllDay
+      );
+      if (slotEndMs === null || !Number.isFinite(slotEndMs) || slotEndMs > nowMs) {
+        return slot.occurrenceDate;
+      }
+    }
+    throw new PluginValidationError(
+      "Cannot register for an event occurrence that has already ended."
+    );
+  }
+  const fallbackKey = toDateKey(targetEvent.startDate);
+  const endMs = assertScheduledOccurrence(targetEvent, fallbackKey);
+  assertOccurrenceNotEnded(endMs);
+  return fallbackKey;
+}
+const destroy = ({ strapi }) => {
+  clearOccurrenceLocks(strapi);
+};
+const middlewares = {};
+const policies = {};
+function mergeAttributeIntoTarget(target, attrName, attrDef) {
+  if (!target || typeof target !== "object" || !isSafeObjectKey(attrName)) {
+    return;
+  }
+  const prev = Object.hasOwn(target, attrName) ? target[attrName] : void 0;
+  const safeDef = {};
+  for (const [k, v] of Object.entries(attrDef)) {
+    if (isSafeObjectKey(k)) {
+      safeDef[k] = v;
+    }
+  }
+  target[attrName] = {
+    ...prev && typeof prev === "object" ? prev : {},
+    ...safeDef
+  };
+}
+function applyAttributeExtensions(contentType, extraAttributes) {
+  if (!contentType || !extraAttributes || typeof extraAttributes !== "object") {
+    return;
+  }
+  for (const [attrName, attrDef] of Object.entries(extraAttributes)) {
+    if (!isSafeObjectKey(attrName) || !attrDef || typeof attrDef !== "object" || Array.isArray(attrDef)) {
+      continue;
+    }
+    mergeAttributeIntoTarget(contentType.attributes, attrName, attrDef);
+    mergeAttributeIntoTarget(
+      contentType.__schema__?.attributes,
+      attrName,
+      attrDef
+    );
+  }
+}
+function buildCategoryEnumAttribute(categoryColors) {
+  const colorKeys = Object.keys(categoryColors).filter(isSafeObjectKey);
+  const enumValues = Array.from(/* @__PURE__ */ new Set(["general", ...colorKeys]));
+  return {
+    type: "enumeration",
+    enum: enumValues,
+    default: enumValues.includes("general") ? "general" : enumValues[0],
+    pluginOptions: {
+      i18n: {
+        localized: false
+      }
+    }
+  };
+}
+const register = ({ strapi }) => {
+  strapi.customFields.register({
+    name: "rrule",
+    plugin: PLUGIN_ID,
+    type: "json",
+    inputSize: {
+      default: 12,
+      isResizable: true
+    }
+  });
+  const userConfig = strapi.config?.get?.(`plugin::${PLUGIN_ID}`) ?? {};
+  const strapiInternal = strapi;
+  const getCt = (uid) => strapiInternal.contentTypes?.[uid] ?? strapiInternal.contentType?.(uid);
+  const eventSourceWithCategories = userConfig.sources?.find(
+    (s) => s?.uid === EVENT_CONTENT_TYPE_UID && Boolean(s.categoryColors && Object.keys(s.categoryColors).length > 0)
+  );
+  const eventExtensions = {};
+  if (userConfig.schemaExtensions?.event && typeof userConfig.schemaExtensions.event === "object") {
+    for (const [k, v] of Object.entries(userConfig.schemaExtensions.event)) {
+      if (isSafeObjectKey(k) && v && typeof v === "object") {
+        eventExtensions[k] = v;
+      }
+    }
+  }
+  if (eventSourceWithCategories?.categoryColors && !Object.hasOwn(eventExtensions, "category")) {
+    eventExtensions.category = buildCategoryEnumAttribute(
+      eventSourceWithCategories.categoryColors
+    );
+  }
+  if (Object.keys(eventExtensions).length > 0) {
+    applyAttributeExtensions(getCt(EVENT_CONTENT_TYPE_UID), eventExtensions);
+  }
+  if (userConfig.schemaExtensions?.registration) {
+    applyAttributeExtensions(
+      getCt(REGISTRATION_CONTENT_TYPE_UID),
+      userConfig.schemaExtensions.registration
+    );
+  }
+};
+const readPolicies = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [`plugin::${PLUGIN_ID}.read`] }
+  }
+];
+const updatePolicies = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [`plugin::${PLUGIN_ID}.update`] }
+  }
+];
+const settingsPolicies = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [`plugin::${PLUGIN_ID}.settings.update`] }
+  }
+];
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "admin.getSettings",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "admin.updateSettings",
+      config: {
+        policies: settingsPolicies
+      }
+    },
+    {
+      method: "GET",
+      path: "/calendar",
+      handler: "admin.getCalendar",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "POST",
+      path: "/calendar/reschedule",
+      handler: "admin.reschedule",
+      config: {
+        policies: updatePolicies
+      }
+    },
+    {
+      method: "POST",
+      path: "/calendar/quick-create",
+      handler: "admin.quickCreate",
+      config: {
+        policies: updatePolicies
+      }
+    },
+    {
+      method: "GET",
+      path: "/stats/:documentId",
+      handler: "admin.getEventStats",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "GET",
+      path: "/registrations",
+      handler: "admin.listRegistrations",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "GET",
+      path: "/registrations/export.csv",
+      handler: "admin.exportRegistrationsCsv",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "POST",
+      path: "/registrations/:documentId/status",
+      handler: "admin.updateRegistrationStatus",
+      config: {
+        policies: updatePolicies
+      }
+    },
+    {
+      method: "POST",
+      path: "/registrations/:documentId/check-in",
+      handler: "admin.checkIn",
+      config: {
+        policies: updatePolicies
+      }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/occurrences",
+      handler: "content-api.listOccurrences",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/spotlights",
+      handler: "content-api.listSpotlights",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/feed.ics",
+      handler: "content-api.downloadFeedIcs",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/:documentId/invite.ics",
+      handler: "content-api.downloadEventInviteIcs",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/:documentId/stats",
+      handler: "content-api.getEventStats",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/:documentId/register",
+      handler: "content-api.registerAttendee",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/registrations/:token/cancel",
+      handler: "content-api.cancelRegistration",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  admin,
+  "content-api": contentApi
+};
+const utf8Encoder = new TextEncoder();
+function toIcsTimestamp(isoString, allDay = false) {
+  const d = new Date(isoString);
+  if (Number.isNaN(d.getTime())) {
+    return "";
+  }
+  const iso = d.toISOString();
+  if (allDay) {
+    return iso.slice(0, 10).replace(/-/g, "");
+  }
+  return iso.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function resolveExclusiveAllDayEndStamp(startDate, endDate, dtStartStamp) {
+  const rawEndStamp = toIcsTimestamp(endDate, true);
+  if (rawEndStamp && rawEndStamp > dtStartStamp) {
+    return rawEndStamp;
+  }
+  const startObj = new Date(startDate);
+  if (Number.isNaN(startObj.getTime())) {
+    return rawEndStamp;
+  }
+  const nextDay = new Date(
+    Date.UTC(
+      startObj.getUTCFullYear(),
+      startObj.getUTCMonth(),
+      startObj.getUTCDate() + 1
+    )
+  );
+  return nextDay.toISOString().slice(0, 10).replace(/-/g, "");
+}
+function escapeIcsText(value) {
+  if (!value) return "";
+  return String(value).replace(/\\/g, "\\\\").replace(/\r\n|\r|\n/g, "\\n").replace(/;/g, "\\;").replace(/,/g, "\\,");
+}
+function foldIcsLine(line) {
+  if (utf8Encoder.encode(line).byteLength <= 75) {
+    return line;
+  }
+  const chunks = [];
+  let currentChunk = "";
+  let currentBytes = 0;
+  let maxBytes = 75;
+  for (const codePoint of line) {
+    const byteLen = utf8Encoder.encode(codePoint).byteLength;
+    if (currentBytes + byteLen > maxBytes && currentChunk.length > 0) {
+      chunks.push(chunks.length === 0 ? currentChunk : ` ${currentChunk}`);
+      currentChunk = codePoint;
+      currentBytes = byteLen;
+      maxBytes = 74;
+    } else {
+      currentChunk += codePoint;
+      currentBytes += byteLen;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(chunks.length === 0 ? currentChunk : ` ${currentChunk}`);
+  }
+  return chunks.join("\r\n");
+}
+function buildCalendarLinks(params) {
+  const {
+    documentId,
+    title,
+    startDate,
+    endDate,
+    allDay = false,
+    summary = "",
+    location = "",
+    occurrenceDate
+  } = params;
+  const icsStart = toIcsTimestamp(startDate, allDay);
+  const icsEnd = allDay ? resolveExclusiveAllDayEndStamp(startDate, endDate, icsStart) : toIcsTimestamp(endDate, false);
+  const googleParams = new URLSearchParams({
+    action: "TEMPLATE",
+    text: title,
+    dates: `${icsStart}/${icsEnd}`,
+    details: summary,
+    location
+  });
+  const outlookParams = new URLSearchParams({
+    path: "/calendar/action/compose",
+    rru: "addevent",
+    subject: title,
+    startdt: startDate,
+    enddt: endDate,
+    body: summary,
+    location,
+    allday: allDay ? "true" : "false"
+  });
+  const yahooParams = new URLSearchParams({
+    v: "60",
+    title,
+    st: icsStart,
+    et: icsEnd,
+    desc: summary,
+    in_loc: location
+  });
+  const querySuffix = occurrenceDate ? `?occurrenceDate=${encodeURIComponent(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/events/${encodeURIComponent(documentId)}/invite.ics${querySuffix}`
+  };
+}
+const ICS_STATUS_MAP = {
+  cancelled: "CANCELLED",
+  postponed: "TENTATIVE"
+};
+function resolveIcsStatus(status) {
+  return Object.hasOwn(ICS_STATUS_MAP, status) ? ICS_STATUS_MAP[status] : "CONFIRMED";
+}
+function appendVEventDateLines(lines, occ) {
+  const isAllDay = Boolean(occ.allDay);
+  const prefix = isAllDay ? ";VALUE=DATE" : "";
+  const startStamp = toIcsTimestamp(occ.startDate, isAllDay);
+  const endStamp = isAllDay ? resolveExclusiveAllDayEndStamp(occ.startDate, occ.endDate, startStamp) : toIcsTimestamp(occ.endDate, false);
+  lines.push(`DTSTART${prefix}:${startStamp}`);
+  lines.push(`DTEND${prefix}:${endStamp}`);
+}
+function appendVEventOptionalLines(lines, occ) {
+  if (occ.summary) {
+    lines.push(foldIcsLine(`DESCRIPTION:${escapeIcsText(occ.summary)}`));
+  }
+  if (occ.location) {
+    lines.push(foldIcsLine(`LOCATION:${escapeIcsText(occ.location)}`));
+  }
+  if (occ.virtualUrl) {
+    lines.push(foldIcsLine(`URL:${escapeIcsText(occ.virtualUrl)}`));
+  }
+  if (occ.isRecurring && occ.rrule) {
+    const normalized = normalizeRRuleString(occ.rrule).replace(/[\r\n]+/g, "");
+    if (normalized) {
+      lines.push(foldIcsLine(`RRULE:${normalized}`));
+    }
+  }
+}
+function generateIcsCalendar(occurrences, feedTitle = "Events Calendar") {
+  const nowStamp = toIcsTimestamp((/* @__PURE__ */ new Date()).toISOString(), false);
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Strapi v5//strapi-plugin-events//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    foldIcsLine(`X-WR-CALNAME:${escapeIcsText(feedTitle)}`)
+  ];
+  for (const occ of occurrences) {
+    const uid = `${occ.documentId}-${occ.occurrenceDate}@strapi-plugin-events`;
+    lines.push("BEGIN:VEVENT");
+    lines.push(foldIcsLine(`UID:${escapeIcsText(uid)}`));
+    lines.push(`DTSTAMP:${nowStamp}`);
+    appendVEventDateLines(lines, occ);
+    lines.push(foldIcsLine(`SUMMARY:${escapeIcsText(occ.title)}`));
+    appendVEventOptionalLines(lines, occ);
+    lines.push(`STATUS:${resolveIcsStatus(occ.status)}`);
+    lines.push("END:VEVENT");
+  }
+  lines.push("END:VCALENDAR");
+  return `${lines.join("\r\n")}\r
+`;
+}
+function sanitizeCsvCell(raw) {
+  if (raw === null || raw === void 0) {
+    return '""';
+  }
+  let text = String(raw);
+  if (/^[\s\u0085\u2028\u2029]*[=+\-@|]|^[\t\r\n]/.test(text)) {
+    text = `'${text}`;
+  }
+  const escaped = text.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+function generateRegistrationsCsv(records) {
+  const headers = [
+    "Document ID",
+    "Event UID",
+    "Event Document ID",
+    "Event Title",
+    "Occurrence Date",
+    "Attendee Name",
+    "Attendee Email",
+    "Attendee Phone",
+    "Guests Count",
+    "Status",
+    "Checked In At",
+    "Locale",
+    "Notes",
+    "Created At"
+  ];
+  const rows = [headers.map(sanitizeCsvCell).join(",")];
+  for (const r of records) {
+    rows.push(
+      [
+        r.documentId,
+        r.eventUid,
+        r.eventDocumentId,
+        r.eventTitle ?? "",
+        r.occurrenceDate,
+        r.attendeeName,
+        r.attendeeEmail,
+        r.attendeePhone ?? "",
+        r.guestsCount,
+        r.status,
+        r.checkedInAt ?? "",
+        r.locale,
+        r.notes ?? "",
+        r.createdAt ?? ""
+      ].map(sanitizeCsvCell).join(",")
+    );
+  }
+  return `${rows.join("\r\n")}\r
+`;
+}
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const ical = ({ strapi }) => {
+  return {
+    async generateFeedIcs(params) {
+      const settings2 = await getSettingsService(strapi).getSettings();
+      const occurrences = await getOccurrenceService(strapi).getOccurrences({
+        from: params?.from,
+        to: params?.to,
+        category: params?.category,
+        sourceId: params?.sourceId,
+        locale: params?.locale,
+        includeDrafts: false
+      });
+      return generateIcsCalendar(occurrences, settings2.feedTitle);
+    },
+    async generateEventInviteIcs(params) {
+      const docId = (params.documentId ?? "").trim();
+      if (!docId) {
+        throw new PluginValidationError("Event documentId is required.");
+      }
+      const settings2 = await getSettingsService(strapi).getSettings();
+      let from;
+      let to;
+      if (params.occurrenceDate) {
+        if (!isValidCalendarDateKey(params.occurrenceDate)) {
+          throw new PluginValidationError(
+            "Invalid occurrenceDate: must be a valid YYYY-MM-DD calendar date."
+          );
+        }
+        const anchorMs = (/* @__PURE__ */ new Date(
+          `${params.occurrenceDate}T00:00:00.000Z`
+        )).getTime();
+        from = new Date(anchorMs - 2 * DAY_MS).toISOString();
+        to = new Date(anchorMs + 3 * DAY_MS).toISOString();
+      } else {
+        const nowMs = Date.now();
+        from = new Date(nowMs - 30 * DAY_MS).toISOString();
+        to = new Date(nowMs + 335 * DAY_MS).toISOString();
+      }
+      const occurrences = await getOccurrenceService(strapi).getOccurrences({
+        documentId: docId,
+        from,
+        to,
+        locale: params.locale,
+        includeDrafts: false
+      });
+      const filtered = params.occurrenceDate ? occurrences.filter((o) => o.occurrenceDate === params.occurrenceDate) : occurrences.slice(0, 1);
+      return generateIcsCalendar(filtered, settings2.feedTitle);
+    }
+  };
+};
+const MAX_PUBLIC_WINDOW_MS = 366 * 24 * 60 * 60 * 1e3;
+const MAX_ADMIN_WINDOW_MS = 5 * 366 * 24 * 60 * 60 * 1e3;
+function assertValidIsoDateTime(raw, fieldName) {
+  if (typeof raw !== "string" || !raw.trim()) {
+    throw new PluginValidationError(
+      `Invalid ${fieldName}: must be a non-empty ISO 8601 date or datetime.`
+    );
+  }
+  const trimmed = raw.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    if (!isValidCalendarDateKey(trimmed)) {
+      throw new PluginValidationError(
+        `Invalid ${fieldName}: "${trimmed}" is not a valid calendar date.`
+      );
+    }
+    return (/* @__PURE__ */ new Date(`${trimmed}T00:00:00.000Z`)).getTime();
+  }
+  const ms = new Date(trimmed).getTime();
+  if (!Number.isFinite(ms)) {
+    throw new PluginValidationError(
+      `Invalid ${fieldName}: must be a valid ISO 8601 datetime.`
+    );
+  }
+  return ms;
+}
+function isValidIso(val) {
+  if (!val || typeof val !== "string") return false;
+  const trimmed = val.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    return isValidCalendarDateKey(trimmed);
+  }
+  return Number.isFinite(new Date(trimmed).getTime());
+}
+function resolveOccurrenceWindow(params) {
+  const now = /* @__PURE__ */ new Date();
+  const defaultFromMs = new Date(
+    now.getFullYear(),
+    now.getMonth() - 1,
+    1
+  ).getTime();
+  const defaultToMs = new Date(
+    now.getFullYear(),
+    now.getMonth() + 3,
+    0,
+    23,
+    59,
+    59
+  ).getTime();
+  const startMs = isValidIso(params.from) ? new Date(String(params.from)).getTime() : defaultFromMs;
+  const rawEndMs = isValidIso(params.to) ? new Date(String(params.to)).getTime() : defaultToMs;
+  if (rawEndMs < startMs) {
+    return {
+      windowStart: new Date(startMs).toISOString(),
+      windowEnd: new Date(rawEndMs).toISOString(),
+      isEmptyWindow: true
+    };
+  }
+  const maxSpanMs = params.includeDrafts ? MAX_ADMIN_WINDOW_MS : MAX_PUBLIC_WINDOW_MS;
+  const clampedEndMs = rawEndMs - startMs > maxSpanMs ? startMs + maxSpanMs : rawEndMs;
+  return {
+    windowStart: new Date(startMs).toISOString(),
+    windowEnd: new Date(clampedEndMs).toISOString(),
+    isEmptyWindow: false
+  };
+}
+function resolveQuickCreateSource(settings2, sourceId) {
+  const sources = (settings2.sources ?? []).filter(
+    (s) => isAllowedEventSourceUid(s.uid)
+  );
+  const chosen = sources.find((s) => s.id === sourceId) ?? sources.find((s) => s.uid === EVENT_CONTENT_TYPE_UID) ?? sources[0];
+  if (!chosen) {
+    throw new PluginValidationError("No allowed event source is configured.");
+  }
+  return chosen;
+}
+function applyQuickCreateRRuleAndRsvp(data, source, settings2, params) {
+  const rruleField = source.fields.rrule;
+  const cleanRRule = normalizeRRuleString(params.rrule);
+  if (rruleField && isSafeObjectKey(rruleField) && cleanRRule) {
+    data[rruleField] = {
+      rrule: cleanRRule,
+      timezone: settings2.defaultTimezone,
+      allDay: false,
+      exdates: [],
+      overrides: {}
+    };
+  }
+  if (source.fields.rsvpEnabled && isSafeObjectKey(source.fields.rsvpEnabled) && typeof params.rsvpEnabled === "boolean") {
+    data[source.fields.rsvpEnabled] = params.rsvpEnabled;
+  }
+  if (source.fields.capacity && isSafeObjectKey(source.fields.capacity) && typeof params.capacity === "number" && Number.isFinite(params.capacity) && params.capacity >= 1) {
+    data[source.fields.capacity] = Math.floor(params.capacity);
+  }
+}
+function buildQuickCreatePayload(source, settings2, params) {
+  const title = (params.title ?? "").trim();
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+  const data = {
+    [source.fields.title]: title,
+    [source.fields.startDate]: params.startDate
+  };
+  const optionalStrings = [
+    [source.fields.endDate, params.endDate],
+    [source.fields.location, params.location],
+    [source.fields.category, params.category],
+    [source.fields.summary, params.summary]
+  ];
+  for (const [fieldKey, val] of optionalStrings) {
+    if (fieldKey && isSafeObjectKey(fieldKey) && val) {
+      data[fieldKey] = val;
+    }
+  }
+  if (source.fields.slug && isSafeObjectKey(source.fields.slug)) {
+    data[source.fields.slug] = `${slug}-${Date.now().toString(36)}`;
+  }
+  applyQuickCreateRRuleAndRsvp(data, source, settings2, params);
+  return data;
+}
+function resolveEffectiveQueryLocale(paramLoc, defaultLoc) {
+  if (paramLoc && paramLoc !== "auto") return paramLoc;
+  return defaultLoc && defaultLoc !== "auto" ? defaultLoc : void 0;
+}
+function buildSourceQueryOptions(source, params, settings2) {
+  const posterField = source.fields.poster;
+  const queryOpts = {
+    limit: 500,
+    ...posterField ? { populate: [posterField] } : {}
+  };
+  if (params.documentId) {
+    queryOpts.filters = { documentId: { $eq: params.documentId } };
+  }
+  const loc = resolveEffectiveQueryLocale(
+    params.locale,
+    settings2.defaultLocale
+  );
+  if (loc) queryOpts.locale = loc;
+  if (!params.includeDrafts) queryOpts.status = "published";
+  return queryOpts;
+}
+function filterOutExplicitDrafts(docs, includeDrafts) {
+  if (includeDrafts) return docs;
+  return docs.filter((doc) => doc.publishedAt !== null);
+}
+async function fetchDocumentsForSource(strapi, source, params, settings2) {
+  if (!isAllowedEventSourceUid(source.uid)) {
+    return [];
+  }
+  const client = getDocumentsClient(strapi, source.uid);
+  try {
+    const queryOpts = buildSourceQueryOptions(source, params, settings2);
+    const docs = await client.findMany(queryOpts);
+    if (docs.length === 0 && queryOpts.locale) {
+      const { locale: _ignoredLocale, ...withoutLocaleOpts } = queryOpts;
+      const fallbackLocaleDocs = await client.findMany(withoutLocaleOpts);
+      return filterOutExplicitDrafts(fallbackLocaleDocs, params.includeDrafts);
+    }
+    return filterOutExplicitDrafts(docs, params.includeDrafts);
+  } catch {
+    return fetchDocumentsFallback(client, params);
+  }
+}
+async function fetchDocumentsFallback(client, params) {
+  try {
+    const fallbackOpts = { limit: 500 };
+    if (params.documentId) {
+      fallbackOpts.filters = { documentId: { $eq: params.documentId } };
+    }
+    if (!params.includeDrafts) {
+      fallbackOpts.status = "published";
+    }
+    const docs = await client.findMany(fallbackOpts);
+    return filterOutExplicitDrafts(docs, params.includeDrafts);
+  } catch {
+    return [];
+  }
+}
+function resolveDocColor(doc, source, categoryVal) {
+  const colors = source.categoryColors;
+  const categoryColor = categoryVal && isSafeObjectKey(categoryVal) && colors && Object.hasOwn(colors, categoryVal) ? colors[categoryVal] : void 0;
+  if (categoryColor) return categoryColor;
+  if (typeof doc.color === "string" && doc.color.startsWith("#")) {
+    return doc.color;
+  }
+  return source.color;
+}
+const readOptionalFieldString = (doc, key) => key && isSafeObjectKey(key) ? String(doc[key] ?? "") : "";
+function extractDocMetadata(strapi, doc, source, settings2, docId, baseDateKey) {
+  const f = source.fields;
+  const categoryVal = readOptionalFieldString(doc, f.category);
+  const baseTitle = String(
+    (isSafeObjectKey(f.title) ? doc[f.title] : void 0) ?? doc.title ?? "Untitled"
+  );
+  const slugVal = readOptionalFieldString(doc, f.slug);
+  const rsvpField = f.rsvpEnabled && isSafeObjectKey(f.rsvpEnabled) ? f.rsvpEnabled : "rsvpEnabled";
+  const capField = f.capacity && isSafeObjectKey(f.capacity) ? f.capacity : "capacity";
+  return {
+    docId,
+    baseTitle,
+    baseLocation: readOptionalFieldString(doc, f.location),
+    summary: readOptionalFieldString(doc, f.summary),
+    slug: slugVal || void 0,
+    categoryVal,
+    statusVal: mapEventStatus(
+      f.status && isSafeObjectKey(f.status) ? doc[f.status] : doc.eventStatus
+    ),
+    color: resolveDocColor(doc, source, categoryVal),
+    rsvpEnabled: doc[rsvpField] !== void 0 ? Boolean(doc[rsvpField]) : false,
+    capacity: readNullablePositiveInt(doc[capField]),
+    waitlistEnabled: typeof doc.waitlistEnabled === "boolean" ? doc.waitlistEnabled : settings2.waitlistEnabledByDefault,
+    baseDateKey,
+    virtualUrl: sanitizeEventUrl(doc.virtualUrl, { allowMailto: false }) ?? void 0,
+    poster: normalizeEventPoster(
+      f.poster && isSafeObjectKey(f.poster) ? doc[f.poster] : doc.poster,
+      baseTitle
+    ),
+    actionLinks: normalizeEventActionLinks(doc[f.actionLinks ?? "actionLinks"]),
+    spotlightConfig: normalizeEventSpotlightConfig(
+      doc[f.spotlightConfig ?? "spotlightConfig"]
+    ),
+    extractedCustomFields: extractCustomFields(
+      strapi,
+      source.uid,
+      doc,
+      f.customFields
+    )
+  };
+}
+const matchesCategoryFilter = (cat, filter) => !filter || filter === "all" || cat.toLowerCase() === filter.toLowerCase();
+function resolveDocumentRecurrence(doc, source, defaultTimezone, allDay) {
+  const rruleField = source.fields.rrule;
+  const rawRecurrence = rruleField && isSafeObjectKey(rruleField) ? doc[rruleField] : null;
+  const docTz = typeof doc.timezone === "string" && doc.timezone ? doc.timezone : defaultTimezone;
+  const recurrence = parseRRuleFieldValue(rawRecurrence, docTz);
+  if (allDay) recurrence.allDay = true;
+  return recurrence;
+}
+function expandDocumentOccurrencesSync(args) {
+  const {
+    strapi,
+    doc,
+    source,
+    params,
+    settings: settings2,
+    windowStart,
+    windowEnd,
+    pendingRsvpMap
+  } = args;
+  if (!isAllowedEventSourceUid(source.uid)) return [];
+  const docId = String(doc.documentId ?? doc.id ?? "");
+  if (!docId) return [];
+  const startEnd = resolveStartEndFromDocument(doc, source);
+  if (!startEnd) return [];
+  const meta = extractDocMetadata(
+    strapi,
+    doc,
+    source,
+    settings2,
+    docId,
+    startEnd.startDate.slice(0, 10)
+  );
+  if (params.onlySpotlights && !meta.spotlightConfig?.enabled) {
+    return [];
+  }
+  if (!matchesCategoryFilter(meta.categoryVal, params.category)) return [];
+  const recurrence = resolveDocumentRecurrence(
+    doc,
+    source,
+    settings2.defaultTimezone,
+    startEnd.allDay
+  );
+  const slots = expandRuleSlots({
+    baseStartDate: startEnd.startDate,
+    baseEndDate: startEnd.endDate,
+    recurrence,
+    windowStart,
+    windowEnd
+  });
+  const results = [];
+  for (const slot of slots) {
+    const occ = buildSingleExpandedOccurrence({
+      doc,
+      source,
+      meta,
+      slot,
+      recurrence,
+      settings: settings2,
+      paramLocale: params.locale
+    });
+    if (meta.rsvpEnabled) {
+      pendingRsvpMap.set(occ.occurrenceId, {
+        eventUid: source.uid,
+        eventDocumentId: meta.docId,
+        occurrenceDate: slot.occurrenceDate,
+        capacity: meta.capacity,
+        waitlistEnabled: meta.waitlistEnabled,
+        rsvpEnabled: meta.rsvpEnabled
+      });
+    }
+    results.push(occ);
+  }
+  return results;
+}
+const toUndefinedIfEmpty = (val) => val ? val : void 0;
+const readOptionalDocString = (doc, key) => typeof doc[key] === "string" && doc[key] ? doc[key] : void 0;
+function buildSingleExpandedOccurrence(args) {
+  const { doc, source, meta, slot, recurrence, settings: settings2, paramLocale } = args;
+  const effectiveTitle = slot.override?.title || meta.baseTitle;
+  const effectiveLocation = slot.override?.location || meta.baseLocation;
+  const calendarLinks = buildCalendarLinks({
+    documentId: meta.docId,
+    title: effectiveTitle,
+    startDate: slot.startDate,
+    endDate: slot.endDate,
+    allDay: Boolean(recurrence.allDay),
+    summary: meta.summary,
+    location: effectiveLocation,
+    occurrenceDate: slot.occurrenceDate
+  });
+  const alternateDates = shared.resolveOccurrenceAlternateDates({
+    occurrenceDate: slot.occurrenceDate,
+    baseDateKey: meta.baseDateKey,
+    isRecurring: slot.isRecurring,
+    doc,
+    source,
+    secondaryCalendars: settings2.secondaryCalendars ?? [],
+    locale: paramLocale && paramLocale !== "auto" ? paramLocale : "en"
+  });
+  return {
+    occurrenceId: `${source.id}:${meta.docId}:${slot.occurrenceDate}`,
+    sourceId: source.id,
+    sourceLabel: source.label,
+    uid: source.uid,
+    documentId: meta.docId,
+    locale: readOptionalDocString(doc, "locale"),
+    occurrenceDate: slot.occurrenceDate,
+    startDate: slot.startDate,
+    endDate: slot.endDate,
+    allDay: Boolean(recurrence.allDay),
+    timezone: recurrence.timezone,
+    title: effectiveTitle,
+    slug: meta.slug,
+    summary: toUndefinedIfEmpty(meta.summary),
+    location: toUndefinedIfEmpty(effectiveLocation),
+    virtualUrl: meta.virtualUrl,
+    category: toUndefinedIfEmpty(meta.categoryVal),
+    status: meta.statusVal,
+    color: meta.color,
+    isRecurring: slot.isRecurring,
+    rrule: toUndefinedIfEmpty(recurrence.rrule),
+    isOverridden: slot.isOverridden,
+    calendarLinks,
+    alternateDates: Object.keys(alternateDates).length > 0 ? alternateDates : void 0,
+    poster: meta.poster,
+    actionLinks: meta.actionLinks,
+    spotlightConfig: meta.spotlightConfig,
+    customFields: meta.extractedCustomFields
+  };
+}
+function validateRescheduleDates(params) {
+  if (params.cancelOccurrence && !params.newStartDate) {
+    return;
+  }
+  const startMs = assertValidIsoDateTime(params.newStartDate, "newStartDate");
+  if (params.newEndDate !== void 0 && params.newEndDate !== "") {
+    const endMs = assertValidIsoDateTime(params.newEndDate, "newEndDate");
+    if (endMs <= startMs) {
+      throw new PluginValidationError(
+        "Invalid newEndDate: must be after newStartDate."
+      );
+    }
+  }
+}
+function buildReschedulePayload(source, params) {
+  if (params.cancelOccurrence && source.fields.status && isSafeObjectKey(source.fields.status)) {
+    return { [source.fields.status]: "cancelled" };
+  }
+  const updatePayload = {
+    [source.fields.startDate]: params.newStartDate
+  };
+  if (params.newEndDate && source.fields.endDate && isSafeObjectKey(source.fields.endDate)) {
+    updatePayload[source.fields.endDate] = params.newEndDate;
+  }
+  return updatePayload;
+}
+function resolveRescheduleSource(sources, sourceId, uid) {
+  const list = (sources ?? []).filter((s) => isAllowedEventSourceUid(s.uid));
+  return list.find((s) => s.id === sourceId || s.uid === uid) ?? list[0];
+}
+function buildSingleOccurrenceOverridePatch(rruleField, recurrence, params) {
+  if (!isSafeObjectKey(params.occurrenceDate) || !isValidCalendarDateKey(params.occurrenceDate)) {
+    throw new PluginValidationError(
+      "Invalid occurrenceDate: must be a valid YYYY-MM-DD calendar date."
+    );
+  }
+  const nextOverrides = {};
+  if (recurrence.overrides && typeof recurrence.overrides === "object") {
+    for (const [k, v] of Object.entries(recurrence.overrides)) {
+      if (isSafeObjectKey(k) && v && typeof v === "object") {
+        nextOverrides[k] = v;
+      }
+    }
+  }
+  const prevOverride = Object.hasOwn(nextOverrides, params.occurrenceDate) ? nextOverrides[params.occurrenceDate] : void 0;
+  nextOverrides[params.occurrenceDate] = {
+    ...prevOverride,
+    originalDate: params.occurrenceDate,
+    cancelled: Boolean(params.cancelOccurrence),
+    startDate: params.newStartDate || void 0,
+    endDate: params.newEndDate || void 0
+  };
+  return { [rruleField]: { ...recurrence, overrides: nextOverrides } };
+}
+const occurrence = ({ strapi }) => {
+  return {
+    registerCalendarFormatter(calendarId, formatter) {
+      shared.registerCalendarSystemFormatter(calendarId, formatter);
+    },
+    unregisterCalendarFormatter(calendarId) {
+      shared.unregisterCalendarSystemFormatter(calendarId);
+    },
+    formatDateInCalendarSystem(isoOrDateKey, system, locale = "en", options2) {
+      return shared.formatDateInCalendarSystem(isoOrDateKey, system, locale, options2);
+    },
+    async getOccurrences(params) {
+      const settings2 = await getSettingsService(strapi).getSettings();
+      const { windowStart, windowEnd, isEmptyWindow } = resolveOccurrenceWindow(params);
+      if (isEmptyWindow) {
+        return [];
+      }
+      const activeSources = (settings2.sources ?? []).filter(
+        (s) => s.enabled && isAllowedEventSourceUid(s.uid) && (!params.sourceId || s.id === params.sourceId || s.uid === params.sourceId)
+      );
+      const allOccurrences = [];
+      const pendingRsvpMap = /* @__PURE__ */ new Map();
+      for (const source of activeSources) {
+        const docs = await fetchDocumentsForSource(
+          strapi,
+          source,
+          params,
+          settings2
+        );
+        for (const doc of docs) {
+          const docOccurrences = expandDocumentOccurrencesSync({
+            strapi,
+            doc,
+            source,
+            params,
+            settings: settings2,
+            windowStart,
+            windowEnd,
+            pendingRsvpMap
+          });
+          allOccurrences.push(...docOccurrences);
+        }
+      }
+      allOccurrences.sort(
+        (a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime()
+      );
+      const sliced = clampPaginatedSlice(allOccurrences, {
+        limit: params.limit,
+        page: params.page,
+        pageSize: params.pageSize,
+        defaultLimit: params.includeDrafts ? 2e3 : 500,
+        maxLimit: params.includeDrafts ? 2e3 : 500
+      });
+      await attachBatchedRsvpStats(strapi, sliced, pendingRsvpMap);
+      return sliced;
+    },
+    async getActiveSpotlights(params) {
+      const refDate = params?.date && !Number.isNaN(new Date(params.date).getTime()) ? new Date(params.date) : /* @__PURE__ */ new Date();
+      const fromWindow = new Date(
+        refDate.getTime() - 60 * 24 * 60 * 60 * 1e3
+      ).toISOString();
+      const toWindow = new Date(
+        refDate.getTime() + 180 * 24 * 60 * 60 * 1e3
+      ).toISOString();
+      const occurrences = await this.getOccurrences({
+        from: fromWindow,
+        to: toWindow,
+        locale: params?.locale,
+        sourceId: params?.sourceId,
+        category: params?.category,
+        includeDrafts: params?.includeDrafts ?? false,
+        onlySpotlights: true
+      });
+      const active = occurrences.filter(
+        (occ) => isEventSpotlightActiveOnDate({
+          spotlightConfig: occ.spotlightConfig,
+          eventStartDate: occ.startDate,
+          eventEndDate: occ.endDate,
+          referenceDate: refDate
+        })
+      );
+      const sorted = deduplicateAndSortSpotlights(active);
+      return clampPaginatedSlice(sorted, {
+        limit: params?.limit,
+        page: params?.page,
+        pageSize: params?.pageSize,
+        defaultLimit: 100,
+        maxLimit: 100
+      });
+    },
+    async rescheduleOccurrence(params) {
+      const docId = (params.documentId ?? "").trim();
+      if (!docId) {
+        throw new PluginValidationError("Event documentId is required.");
+      }
+      validateRescheduleDates(params);
+      const settings2 = await getSettingsService(strapi).getSettings();
+      const source = resolveRescheduleSource(
+        settings2.sources,
+        params.sourceId,
+        params.uid
+      );
+      if (!source || !isAllowedEventSourceUid(source.uid)) {
+        throw new PluginValidationError(
+          "Target event source is not configured."
+        );
+      }
+      const client = getDocumentsClient(strapi, source.uid);
+      const existing = await client.findOne({ documentId: docId });
+      if (!existing) {
+        throw new PluginNotFoundError(
+          `Document ${docId} not found in ${source.uid}.`
+        );
+      }
+      const rruleField = source.fields.rrule;
+      const recurrence = rruleField && isSafeObjectKey(rruleField) ? parseRRuleFieldValue(existing[rruleField], settings2.defaultTimezone) : null;
+      if (recurrence?.rrule && !params.applyToSeries && rruleField && isSafeObjectKey(rruleField)) {
+        return client.update({
+          documentId: docId,
+          data: buildSingleOccurrenceOverridePatch(
+            rruleField,
+            recurrence,
+            params
+          )
+        });
+      }
+      return client.update({
+        documentId: docId,
+        data: buildReschedulePayload(source, params)
+      });
+    },
+    async quickCreateEvent(params) {
+      const title = (params.title ?? "").trim();
+      if (!title) {
+        throw new PluginValidationError("Event title is required.");
+      }
+      const startMs = assertValidIsoDateTime(params.startDate, "startDate");
+      if (params.endDate !== void 0 && params.endDate !== "") {
+        const endMs = assertValidIsoDateTime(params.endDate, "endDate");
+        if (endMs <= startMs) {
+          throw new PluginValidationError(
+            "Invalid endDate: must be after startDate."
+          );
+        }
+      }
+      const settings2 = await getSettingsService(strapi).getSettings();
+      const source = resolveQuickCreateSource(settings2, params.sourceId);
+      const data = buildQuickCreatePayload(source, settings2, {
+        ...params,
+        title
+      });
+      return getDocumentsClient(strapi, source.uid).create({
+        data,
+        status: "published"
+      });
+    }
+  };
+};
+async function fetchRegistrationRecordsSafe(strapi, eventDocumentId, occurrenceDate) {
+  const filters = {
+    eventDocumentId: { $eq: eventDocumentId },
+    ...occurrenceDate ? { occurrenceDate: { $eq: occurrenceDate } } : {}
+  };
+  try {
+    return await getDocumentsClient(
+      strapi,
+      REGISTRATION_CONTENT_TYPE_UID
+    ).findMany({
+      filters,
+      limit: 5e3
+    });
+  } catch {
+    return [];
+  }
+}
+async function promoteFromWaitlistUnlocked(strapi, params) {
+  const targetEvent = params.targetEventOverride !== void 0 ? params.targetEventOverride : await resolveTargetEvent(
+    strapi,
+    params.eventDocumentId,
+    params.eventUid,
+    { includeDrafts: true }
+  );
+  if (!targetEvent || targetEvent.capacity === null || targetEvent.eventStatus === "cancelled") {
+    return { promoted: [], emails: [] };
+  }
+  const slotRecords = await fetchRegistrationRecordsSafe(
+    strapi,
+    params.eventDocumentId,
+    params.occurrenceDate
+  );
+  const counts = aggregateRsvpCounts(slotRecords);
+  let availableSeats = Math.max(
+    0,
+    targetEvent.capacity - counts.confirmedSeats
+  );
+  if (availableSeats <= 0) {
+    return { promoted: [], emails: [] };
+  }
+  const client = getDocumentsClient(strapi, REGISTRATION_CONTENT_TYPE_UID);
+  const waitlisted = await client.findMany({
+    filters: {
+      eventDocumentId: { $eq: params.eventDocumentId },
+      occurrenceDate: { $eq: params.occurrenceDate },
+      status: { $eq: "waitlisted" }
+    },
+    sort: "createdAt:asc",
+    limit: 200
+  });
+  const promoted = [];
+  const emails = [];
+  for (const candidate of waitlisted) {
+    if (availableSeats <= 0) break;
+    if (candidate.status !== "waitlisted") continue;
+    const needed = readStoredGuestsCount(candidate.guestsCount);
+    if (needed > availableSeats) continue;
+    const updated = await client.update({
+      documentId: String(candidate.documentId),
+      data: { status: "confirmed" }
+    });
+    availableSeats -= needed;
+    promoted.push(formatRegistrationRecord(updated));
+    emails.push({
+      to: String(candidate.attendeeEmail),
+      attendeeName: String(candidate.attendeeName),
+      eventTitle: String(candidate.eventTitle ?? targetEvent.title),
+      occurrenceDate: params.occurrenceDate,
+      guestsCount: needed,
+      status: "confirmed",
+      promotedFromWaitlist: true
+    });
+  }
+  return { promoted, emails };
+}
+async function executeCancelByToken(strapi, token) {
+  const cleanedToken = (token ?? "").trim();
+  if (!cleanedToken || cleanedToken.length < 16) {
+    throw new PluginValidationError("Invalid cancellation token.");
+  }
+  const initialMatch = await findRegistrationByRawToken(strapi, cleanedToken);
+  if (!initialMatch) {
+    throw new PluginNotFoundError(
+      "Registration not found for the provided token."
+    );
+  }
+  const regDocId = String(initialMatch.record.documentId);
+  const eventDocId = String(initialMatch.record.eventDocumentId);
+  const occDate = String(initialMatch.record.occurrenceDate);
+  const eventUid = String(
+    initialMatch.record.eventUid ?? EVENT_CONTENT_TYPE_UID
+  );
+  const targetEvent = await resolveTargetEvent(strapi, eventDocId, eventUid, {
+    includeDrafts: true
+  });
+  if (targetEvent) {
+    try {
+      const endMs = assertScheduledOccurrence(targetEvent, occDate);
+      if (endMs !== null && Number.isFinite(endMs) && Date.now() > endMs) {
+        throw new PluginValidationError(
+          "Cannot cancel registration after the event has ended."
+        );
+      }
+    } catch (err) {
+      if (err instanceof PluginValidationError && err.message.includes("ended")) {
+        throw err;
+      }
+    }
+  }
+  const { cancelledRecord, emails, promotedCount } = await withOccurrenceLock(
+    strapi,
+    eventDocId,
+    occDate,
+    async () => {
+      const client = getDocumentsClient(strapi, REGISTRATION_CONTENT_TYPE_UID);
+      const fresh = await client.findOne({ documentId: regDocId });
+      if (!fresh || !verifyTokenHashConstantTime(initialMatch.tokenHash, fresh.checkInToken)) {
+        throw new PluginValidationError(
+          "Invalid or already used cancellation token."
+        );
+      }
+      if (fresh.status === "cancelled") {
+        throw new PluginValidationError(
+          "Registration has already been cancelled."
+        );
+      }
+      if (fresh.status === "checked_in") {
+        throw new PluginValidationError(
+          "Checked-in registrations cannot be cancelled."
+        );
+      }
+      const wasConfirmed = fresh.status === "confirmed";
+      const updated = await client.update({
+        documentId: regDocId,
+        data: { status: "cancelled", checkInToken: null }
+      });
+      const promo = wasConfirmed ? await promoteFromWaitlistUnlocked(strapi, {
+        eventUid,
+        eventDocumentId: eventDocId,
+        occurrenceDate: occDate,
+        targetEventOverride: targetEvent
+      }) : { promoted: [], emails: [] };
+      return {
+        cancelledRecord: formatRegistrationRecord(updated),
+        promotedCount: promo.promoted.length,
+        emails: promo.emails
+      };
+    }
+  );
+  for (const email of emails) {
+    await trySendNotificationEmail(strapi, email);
+  }
+  return {
+    cancelled: cancelledRecord,
+    promotedCount
+  };
+}
+async function executeUpdateRegistrationStatus(strapi, registrationDocumentId, newStatus) {
+  const validStatuses = [
+    "confirmed",
+    "waitlisted",
+    "cancelled",
+    "checked_in"
+  ];
+  if (!validStatuses.includes(newStatus)) {
+    throw new PluginValidationError(`Invalid status: ${String(newStatus)}`);
+  }
+  const client = getDocumentsClient(strapi, REGISTRATION_CONTENT_TYPE_UID);
+  const initial = await client.findOne({
+    documentId: registrationDocumentId
+  });
+  if (!initial) {
+    throw new PluginNotFoundError(
+      `Registration ${registrationDocumentId} not found.`
+    );
+  }
+  const eventDocId = String(initial.eventDocumentId);
+  const occDate = String(initial.occurrenceDate);
+  const eventUid = String(initial.eventUid ?? EVENT_CONTENT_TYPE_UID);
+  const { registration, promotedCount, emails } = await withOccurrenceLock(
+    strapi,
+    eventDocId,
+    occDate,
+    async () => {
+      const existing = await client.findOne({
+        documentId: registrationDocumentId
+      });
+      if (!existing) {
+        throw new PluginNotFoundError(
+          `Registration ${registrationDocumentId} not found.`
+        );
+      }
+      const wasOccupyingSeat = existing.status === "confirmed" || existing.status === "checked_in";
+      const nowOccupyingSeat = newStatus === "confirmed" || newStatus === "checked_in";
+      const targetEvent = await resolveTargetEvent(
+        strapi,
+        eventDocId,
+        eventUid,
+        { includeDrafts: true }
+      );
+      if (nowOccupyingSeat && targetEvent?.eventStatus === "cancelled") {
+        throw new PluginValidationError(
+          "Cannot confirm or check in registration for a cancelled event."
+        );
+      }
+      if (!wasOccupyingSeat && nowOccupyingSeat && targetEvent && targetEvent.capacity !== null) {
+        const slotRecords = await fetchRegistrationRecordsSafe(
+          strapi,
+          eventDocId,
+          occDate
+        );
+        const counts = aggregateRsvpCounts(slotRecords);
+        const neededSeats = readStoredGuestsCount(existing.guestsCount);
+        if (counts.confirmedSeats + neededSeats > targetEvent.capacity) {
+          throw new PluginValidationError(
+            "Cannot confirm registration: event has reached maximum capacity."
+          );
+        }
+      }
+      const dataPatch = {
+        status: newStatus,
+        ...newStatus === "checked_in" && !existing.checkedInAt ? { checkedInAt: (/* @__PURE__ */ new Date()).toISOString() } : {},
+        ...newStatus === "cancelled" ? { checkInToken: null } : {}
+      };
+      const updated = await client.update({
+        documentId: registrationDocumentId,
+        data: dataPatch
+      });
+      const promo = wasOccupyingSeat && !nowOccupyingSeat ? await promoteFromWaitlistUnlocked(strapi, {
+        eventUid,
+        eventDocumentId: eventDocId,
+        occurrenceDate: occDate,
+        targetEventOverride: targetEvent
+      }) : { promoted: [], emails: [] };
+      return {
+        registration: formatRegistrationRecord(updated),
+        promotedCount: promo.promoted.length,
+        emails: promo.emails
+      };
+    }
+  );
+  for (const email of emails) {
+    await trySendNotificationEmail(strapi, email);
+  }
+  return { registration, promotedCount };
+}
+async function executeCheckInAttendee(strapi, identifier) {
+  let targetDocId = identifier.documentId?.trim();
+  let providedTokenHash = null;
+  if (identifier.token !== void 0) {
+    const cleanedToken = String(identifier.token).trim();
+    if (cleanedToken.length < 16 || cleanedToken.length > 256) {
+      throw new PluginValidationError("Invalid check-in token.");
+    }
+    providedTokenHash = hashRsvpToken(cleanedToken);
+    if (!targetDocId) {
+      const match = await findRegistrationByRawToken(strapi, cleanedToken);
+      if (!match) {
+        throw new PluginValidationError("Invalid check-in token.");
+      }
+      targetDocId = String(match.record.documentId);
+    }
+  }
+  if (!targetDocId) {
+    throw new PluginNotFoundError("Registration not found for check-in.");
+  }
+  const client = getDocumentsClient(strapi, REGISTRATION_CONTENT_TYPE_UID);
+  const initial = await client.findOne({ documentId: targetDocId });
+  if (!initial) {
+    throw new PluginNotFoundError("Registration not found for check-in.");
+  }
+  const eventDocId = String(initial.eventDocumentId);
+  const occDate = String(initial.occurrenceDate);
+  const eventUid = String(initial.eventUid ?? EVENT_CONTENT_TYPE_UID);
+  return withOccurrenceLock(strapi, eventDocId, occDate, async () => {
+    const existing = await client.findOne({ documentId: targetDocId });
+    if (!existing) {
+      throw new PluginNotFoundError("Registration not found for check-in.");
+    }
+    if (providedTokenHash !== null && !verifyTokenHashConstantTime(providedTokenHash, existing.checkInToken)) {
+      throw new PluginValidationError("Invalid check-in token.");
+    }
+    const targetEvent = await resolveTargetEvent(strapi, eventDocId, eventUid, {
+      includeDrafts: true
+    });
+    if (targetEvent?.eventStatus === "cancelled") {
+      throw new PluginValidationError(
+        "Cannot check in attendee for a cancelled event."
+      );
+    }
+    if (existing.status === "checked_in") {
+      return formatRegistrationRecord(existing);
+    }
+    if (existing.status !== "confirmed") {
+      throw new PluginValidationError(
+        `Cannot check in attendee with status "${String(existing.status)}": only confirmed registrations can be checked in.`
+      );
+    }
+    const updated = await client.update({
+      documentId: targetDocId,
+      data: {
+        status: "checked_in",
+        checkedInAt: existing.checkedInAt || (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    return formatRegistrationRecord(updated);
+  });
+}
+function buildListRegistrationsQueryFilters(filters) {
+  const queryFilters = {};
+  if (filters?.eventDocumentId) {
+    queryFilters.eventDocumentId = { $eq: filters.eventDocumentId };
+  }
+  if (filters?.occurrenceDate) {
+    queryFilters.occurrenceDate = { $eq: filters.occurrenceDate };
+  }
+  if (filters?.status) {
+    queryFilters.status = { $eq: filters.status };
+  }
+  const q = filters?.search?.trim();
+  if (q) {
+    queryFilters.$or = [
+      { attendeeName: { $containsi: q } },
+      { attendeeEmail: { $containsi: q } },
+      { eventTitle: { $containsi: q } }
+    ];
+  }
+  return queryFilters;
+}
+async function resolveStatsEventConfig(strapi, params) {
+  if (params.capacityOverride === void 0) {
+    const resolved = await resolveTargetEvent(
+      strapi,
+      params.eventDocumentId,
+      params.eventUid,
+      { includeDrafts: params.includeDrafts ?? false }
+    );
+    if (resolved) {
+      return {
+        eventUid: resolved.uid,
+        capacity: resolved.capacity,
+        waitlistEnabled: resolved.waitlistEnabled,
+        rsvpEnabled: resolved.rsvpEnabled
+      };
+    }
+  }
+  return {
+    eventUid: params.eventUid ?? EVENT_CONTENT_TYPE_UID,
+    capacity: params.capacityOverride ?? null,
+    waitlistEnabled: params.waitlistOverride ?? true,
+    rsvpEnabled: params.rsvpEnabledOverride ?? false
+  };
+}
+const rsvp = ({ strapi }) => {
+  return {
+    async getEventStats(params) {
+      const { eventDocumentId, occurrenceDate = null } = params;
+      const { eventUid, capacity, waitlistEnabled, rsvpEnabled } = await resolveStatsEventConfig(strapi, params);
+      const records = await fetchRegistrationRecordsSafe(
+        strapi,
+        eventDocumentId,
+        occurrenceDate
+      );
+      const counts = aggregateRsvpCounts(records);
+      const remainingSeats = capacity !== null ? Math.max(0, capacity - counts.confirmedSeats) : null;
+      const isFull = capacity !== null ? counts.confirmedSeats >= capacity : false;
+      return {
+        eventUid,
+        eventDocumentId,
+        occurrenceDate,
+        rsvpEnabled,
+        capacity,
+        waitlistEnabled,
+        ...counts,
+        remainingSeats,
+        isFull
+      };
+    },
+    async registerAttendee(eventDocumentId, input) {
+      const docId = (eventDocumentId ?? "").trim();
+      if (!docId) {
+        throw new PluginValidationError("Event documentId is required.");
+      }
+      const targetEvent = await resolveTargetEvent(
+        strapi,
+        docId,
+        input.eventUid,
+        { includeDrafts: false }
+      );
+      if (!targetEvent) {
+        throw new PluginNotFoundError(
+          `Event not found for documentId: ${docId}`
+        );
+      }
+      const { attendeeName, attendeeEmail, guestsCount } = validateRegistrationInputAndEvent(input, targetEvent);
+      const occurrenceDate = resolveValidatedOccurrenceDate(
+        input.occurrenceDate,
+        targetEvent
+      );
+      const rawToken = generateRawRsvpToken();
+      const tokenHash = hashRsvpToken(rawToken);
+      const { formatted, assignedStatus } = await withOccurrenceLock(
+        strapi,
+        docId,
+        occurrenceDate,
+        async () => {
+          const client = getDocumentsClient(
+            strapi,
+            REGISTRATION_CONTENT_TYPE_UID
+          );
+          const existing = await client.findMany({
+            filters: {
+              eventDocumentId: { $eq: docId },
+              occurrenceDate: { $eq: occurrenceDate },
+              attendeeEmail: { $eq: attendeeEmail },
+              status: { $in: ["confirmed", "waitlisted", "checked_in"] }
+            },
+            limit: 1
+          });
+          if (existing.length > 0) {
+            throw new PluginValidationError(
+              "An active registration already exists for this email and date."
+            );
+          }
+          const slotRecords = await fetchRegistrationRecordsSafe(
+            strapi,
+            docId,
+            occurrenceDate
+          );
+          const counts = aggregateRsvpCounts(slotRecords);
+          const status = resolveAssignedRsvpStatus(
+            targetEvent,
+            counts.confirmedSeats,
+            guestsCount
+          );
+          const created = await client.create({
+            data: buildRegistrationCreateData({
+              targetEvent,
+              eventDocumentId: docId,
+              occurrenceDate,
+              attendeeName,
+              attendeeEmail,
+              guestsCount,
+              assignedStatus: status,
+              tokenHash,
+              input
+            })
+          });
+          return {
+            assignedStatus: status,
+            formatted: formatRegistrationRecord({
+              ...created,
+              eventUid: targetEvent.uid,
+              eventDocumentId: docId,
+              eventTitle: targetEvent.title,
+              occurrenceDate,
+              attendeeName,
+              attendeeEmail,
+              guestsCount,
+              status
+            })
+          };
+        }
+      );
+      await trySendNotificationEmail(strapi, {
+        to: attendeeEmail,
+        attendeeName,
+        eventTitle: targetEvent.title,
+        occurrenceDate,
+        guestsCount,
+        status: assignedStatus
+      });
+      return {
+        ...formatted,
+        attendeePhone: formatted.attendeePhone ?? "",
+        notes: formatted.notes ?? "",
+        cancellationToken: rawToken
+      };
+    },
+    async promoteFromWaitlist(params) {
+      const { promoted, emails } = await withOccurrenceLock(
+        strapi,
+        params.eventDocumentId,
+        params.occurrenceDate,
+        () => promoteFromWaitlistUnlocked(strapi, params)
+      );
+      for (const email of emails) {
+        await trySendNotificationEmail(strapi, email);
+      }
+      return promoted;
+    },
+    cancelByToken(token) {
+      return executeCancelByToken(strapi, token);
+    },
+    updateRegistrationStatus(registrationDocumentId, newStatus) {
+      return executeUpdateRegistrationStatus(
+        strapi,
+        registrationDocumentId,
+        newStatus
+      );
+    },
+    checkInAttendee(identifier) {
+      return executeCheckInAttendee(strapi, identifier);
+    },
+    async listRegistrations(filters) {
+      const rows = await getDocumentsClient(
+        strapi,
+        REGISTRATION_CONTENT_TYPE_UID
+      ).findMany({
+        filters: buildListRegistrationsQueryFilters(filters),
+        sort: "createdAt:desc",
+        limit: 1e3
+      });
+      const formatted = rows.map((r) => formatRegistrationRecord(r));
+      return clampPaginatedSlice(formatted, {
+        limit: filters?.limit,
+        page: filters?.page,
+        pageSize: filters?.pageSize,
+        defaultLimit: 1e3,
+        maxLimit: 1e3
+      });
+    },
+    async exportRegistrationsCsv(filters) {
+      const records = await this.listRegistrations(filters);
+      return generateRegistrationsCsv(records);
+    },
+    formatRegistrationRecord
+  };
+};
+const STORE_KEY = "settings";
+function sanitizeStringRecord(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return void 0;
+  }
+  const clean = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (isSafeObjectKey(k) && typeof v === "string") {
+      clean[k] = v;
+    }
+  }
+  return Object.keys(clean).length > 0 ? clean : void 0;
+}
+function sanitizeTimeSlotMap(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return void 0;
+  }
+  const clean = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (isSafeObjectKey(k) && v && typeof v === "object" && typeof v.start === "string" && typeof v.end === "string") {
+      clean[k] = { start: v.start, end: v.end };
+    }
+  }
+  return Object.keys(clean).length > 0 ? clean : void 0;
+}
+function sanitizeSourceFields(fields) {
+  const safeFields = {
+    title: typeof fields?.title === "string" && isSafeObjectKey(fields.title) ? fields.title : "title",
+    startDate: typeof fields?.startDate === "string" && isSafeObjectKey(fields.startDate) ? fields.startDate : "startDate"
+  };
+  const optionalKeys = [
+    "endDate",
+    "rrule",
+    "location",
+    "category",
+    "status",
+    "summary",
+    "slug",
+    "capacity",
+    "rsvpEnabled",
+    "timeSlot",
+    "poster",
+    "actionLinks",
+    "spotlightConfig"
+  ];
+  for (const key of optionalKeys) {
+    const val = fields?.[key];
+    if (typeof val === "string" && isSafeObjectKey(val)) {
+      safeFields[key] = val;
+    }
+  }
+  const altFields = sanitizeStringRecord(fields?.alternateDateFields);
+  if (altFields) {
+    safeFields.alternateDateFields = altFields;
+  }
+  if (Array.isArray(fields?.customFields)) {
+    safeFields.customFields = fields.customFields.filter(isSafeObjectKey);
+  }
+  return safeFields;
+}
+function sanitizeSourceMapping(src) {
+  if (!src || typeof src !== "object") return null;
+  if (!isSafeObjectKey(src.id) || !isAllowedEventSourceUid(src.uid)) {
+    return null;
+  }
+  return {
+    id: src.id.trim(),
+    label: typeof src.label === "string" && src.label ? src.label : src.id,
+    uid: src.uid.trim(),
+    color: typeof src.color === "string" && src.color.startsWith("#") ? src.color : "#0D9488",
+    enabled: typeof src.enabled === "boolean" ? src.enabled : true,
+    fields: sanitizeSourceFields(src.fields),
+    ...sanitizeTimeSlotMap(src.timeSlotMap) ? { timeSlotMap: sanitizeTimeSlotMap(src.timeSlotMap) } : {},
+    ...sanitizeStringRecord(src.categoryColors) ? { categoryColors: sanitizeStringRecord(src.categoryColors) } : {},
+    ...typeof src.defaultAllDay === "boolean" ? { defaultAllDay: src.defaultAllDay } : {}
+  };
+}
+function mergeSourcesList(defaults, userSources) {
+  const merged = defaults.map((d) => sanitizeSourceMapping(d)).filter((d) => d !== null);
+  if (!Array.isArray(userSources)) return merged;
+  for (const rawSrc of userSources) {
+    const src = sanitizeSourceMapping(rawSrc);
+    if (!src) continue;
+    const existingIdx = merged.findIndex(
+      (s) => s.id === src.id || s.uid === src.uid
+    );
+    if (existingIdx >= 0) {
+      merged[existingIdx] = {
+        ...merged[existingIdx],
+        ...src,
+        fields: { ...merged[existingIdx].fields, ...src.fields }
+      };
+    } else {
+      merged.push(src);
+    }
+  }
+  return merged;
+}
+function sanitizeCalendarConfig(cal) {
+  if (!cal || typeof cal !== "object") return null;
+  if (!isSafeObjectKey(cal.id) || typeof cal.intlCalendar !== "string") {
+    return null;
+  }
+  const intlCal = cal.intlCalendar.trim();
+  if (!intlCal) return null;
+  return {
+    id: cal.id.trim(),
+    label: typeof cal.label === "string" && cal.label ? cal.label : cal.id,
+    intlCalendar: intlCal,
+    ...typeof cal.locale === "string" && cal.locale ? { locale: cal.locale } : {},
+    ...typeof cal.dayOffset === "number" && Number.isFinite(cal.dayOffset) ? { dayOffset: Math.max(-2, Math.min(2, Math.round(cal.dayOffset))) } : {},
+    ...isSafeObjectKey(cal.overrideField) ? { overrideField: cal.overrideField } : {},
+    enabled: Boolean(cal.enabled)
+  };
+}
+function mergeCalendarsList(defaults, userCalendars) {
+  const merged = (defaults ?? []).map((c) => sanitizeCalendarConfig(c)).filter((c) => c !== null);
+  if (!Array.isArray(userCalendars)) return merged;
+  for (const rawCal of userCalendars) {
+    const cal = sanitizeCalendarConfig(rawCal);
+    if (!cal) continue;
+    const idx = merged.findIndex((c) => c.id === cal.id);
+    if (idx >= 0) {
+      merged[idx] = { ...merged[idx], ...cal };
+    } else {
+      merged.push(cal);
+    }
+  }
+  return merged;
+}
+function sanitizeRecurrencePreset(item) {
+  if (!item || typeof item !== "object") return null;
+  if (!isSafeObjectKey(item.id) || typeof item.rrule !== "string") {
+    return null;
+  }
+  const cleanRule = normalizeRRuleString(item.rrule);
+  if (!cleanRule) return null;
+  return {
+    id: item.id.trim(),
+    label: typeof item.label === "string" && item.label ? item.label : item.id,
+    rrule: cleanRule
+  };
+}
+function mergePresetLists(defaults, stored) {
+  const result = (defaults ?? []).map((p) => sanitizeRecurrencePreset(p)).filter((p) => p !== null);
+  if (!Array.isArray(stored)) return result;
+  for (const rawItem of stored) {
+    const item = sanitizeRecurrencePreset(rawItem);
+    if (!item) 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 resolveNonEmptyString(patchVal, fallback, maxLen) {
+  if (typeof patchVal === "string" && patchVal.trim()) {
+    const trimmed = patchVal.trim();
+    return maxLen ? trimmed.slice(0, maxLen) : trimmed;
+  }
+  return fallback;
+}
+function resolvePositiveInt(patchVal, fallback, maxLimit) {
+  if (typeof patchVal === "number" && Number.isFinite(patchVal) && patchVal >= 1) {
+    const floored = Math.floor(patchVal);
+    return maxLimit ? Math.min(maxLimit, floored) : floored;
+  }
+  return fallback;
+}
+function resolveBoolean(patchVal, fallback) {
+  return typeof patchVal === "boolean" ? patchVal : fallback;
+}
+function validateAndSanitizeSourcesPatch(patchSources, fallback) {
+  if (patchSources === void 0) return fallback;
+  if (!Array.isArray(patchSources)) {
+    throw new PluginValidationError("Invalid sources: must be an array.");
+  }
+  const validated = [];
+  for (const rawItem of patchSources) {
+    const rawObj = rawItem;
+    if (!rawObj || !isAllowedEventSourceUid(rawObj.uid)) {
+      throw new PluginValidationError(
+        `Disallowed event source UID "${String(rawObj?.uid ?? "")}". Only api::* and plugin::events.event are permitted.`
+      );
+    }
+    const sanitized = sanitizeSourceMapping(rawObj);
+    if (!sanitized) {
+      throw new PluginValidationError("Invalid event source configuration.");
+    }
+    validated.push(sanitized);
+  }
+  return validated;
+}
+const settings = ({ strapi }) => {
+  const getStore = () => strapi.store({
+    type: "plugin",
+    name: PLUGIN_ID
+  });
+  const getConfigDefaults = () => {
+    const userConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+    return {
+      ...DEFAULT_PLUGIN_SETTINGS,
+      ...userConfig,
+      sources: mergeSourcesList(
+        DEFAULT_PLUGIN_SETTINGS.sources,
+        userConfig.sources
+      ),
+      secondaryCalendars: mergeCalendarsList(
+        DEFAULT_PLUGIN_SETTINGS.secondaryCalendars,
+        userConfig.secondaryCalendars
+      ),
+      recurrencePresets: mergePresetLists(
+        DEFAULT_PLUGIN_SETTINGS.recurrencePresets,
+        userConfig.recurrencePresets
+      )
+    };
+  };
+  return {
+    async ensureInitialized() {
+      const store = getStore();
+      const existing = await store.get({
+        key: STORE_KEY
+      });
+      const defaults = getConfigDefaults();
+      if (!existing) {
+        await store.set({ key: STORE_KEY, value: defaults });
+        return defaults;
+      }
+      const storedSources = Array.isArray(existing.sources) ? existing.sources.map((s) => sanitizeSourceMapping(s)).filter((s) => s !== null) : [];
+      for (const defSource of defaults.sources) {
+        if (!storedSources.some(
+          (s) => s.id === defSource.id || s.uid === defSource.uid
+        )) {
+          storedSources.push(defSource);
+        }
+      }
+      const storedCalendars = Array.isArray(existing.secondaryCalendars) ? existing.secondaryCalendars.map((c) => sanitizeCalendarConfig(c)).filter((c) => c !== null) : [];
+      for (const defCal of defaults.secondaryCalendars ?? []) {
+        if (!storedCalendars.some((c) => c.id === defCal.id)) {
+          storedCalendars.push(defCal);
+        }
+      }
+      const merged = {
+        ...defaults,
+        ...existing,
+        sources: storedSources,
+        secondaryCalendars: storedCalendars,
+        recurrencePresets: mergePresetLists(
+          defaults.recurrencePresets,
+          existing.recurrencePresets
+        )
+      };
+      await store.set({ key: STORE_KEY, value: merged });
+      return merged;
+    },
+    async getSettings() {
+      const store = getStore();
+      const stored = await store.get({
+        key: STORE_KEY
+      });
+      const defaults = getConfigDefaults();
+      if (!stored) {
+        return defaults;
+      }
+      const cleanSources = Array.isArray(stored.sources) ? stored.sources.map((s) => sanitizeSourceMapping(s)).filter((s) => s !== null) : [];
+      const cleanCalendars = Array.isArray(stored.secondaryCalendars) ? stored.secondaryCalendars.map((c) => sanitizeCalendarConfig(c)).filter((c) => c !== null) : [];
+      return {
+        ...defaults,
+        ...stored,
+        sources: cleanSources.length > 0 ? cleanSources : defaults.sources,
+        secondaryCalendars: cleanCalendars.length > 0 ? cleanCalendars : defaults.secondaryCalendars ?? [],
+        recurrencePresets: mergePresetLists(
+          defaults.recurrencePresets,
+          stored.recurrencePresets
+        )
+      };
+    },
+    async updateSettings(patch) {
+      const current = await this.getSettings();
+      const nextSources = validateAndSanitizeSourcesPatch(
+        patch.sources,
+        current.sources
+      );
+      const nextCalendars = Array.isArray(patch.secondaryCalendars) ? patch.secondaryCalendars.map((c) => sanitizeCalendarConfig(c)).filter((c) => c !== null) : current.secondaryCalendars ?? [];
+      const nextPresets = Array.isArray(patch.recurrencePresets) ? patch.recurrencePresets.map((p) => sanitizeRecurrencePreset(p)).filter((p) => p !== null) : current.recurrencePresets ?? [];
+      const next = {
+        ...current,
+        defaultTimezone: resolveNonEmptyString(
+          patch.defaultTimezone,
+          current.defaultTimezone
+        ),
+        defaultCapacity: resolvePositiveInt(
+          patch.defaultCapacity,
+          current.defaultCapacity
+        ),
+        waitlistEnabledByDefault: resolveBoolean(
+          patch.waitlistEnabledByDefault,
+          current.waitlistEnabledByDefault
+        ),
+        defaultMaxGuestsPerRegistration: resolvePositiveInt(
+          patch.defaultMaxGuestsPerRegistration,
+          current.defaultMaxGuestsPerRegistration,
+          50
+        ),
+        sendRsvpEmails: resolveBoolean(
+          patch.sendRsvpEmails,
+          current.sendRsvpEmails
+        ),
+        feedTitle: resolveNonEmptyString(
+          patch.feedTitle,
+          current.feedTitle,
+          140
+        ),
+        sources: nextSources,
+        secondaryCalendars: nextCalendars,
+        recurrencePresets: nextPresets
+      };
+      const store = getStore();
+      await store.set({ key: STORE_KEY, value: next });
+      return next;
+    }
+  };
+};
+const services = {
+  settings,
+  occurrence,
+  rsvp,
+  ical
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+Object.defineProperty(exports, "parseRRule", {
+  enumerable: true,
+  get: () => shared.parseRRule
+});
+exports.buildCalendarLinks = buildCalendarLinks;
+exports.buildRRule = buildRRule;
+exports.default = index;
+exports.describeRRule = describeRRule;
+exports.expandRuleSlots = expandRuleSlots;
+exports.generateIcsCalendar = generateIcsCalendar;
+exports.generateRegistrationsCsv = generateRegistrationsCsv;
+exports.parseRRuleFieldValue = parseRRuleFieldValue;
+exports.sanitizeCsvCell = sanitizeCsvCell;