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

package/dist/server/index.mjs

@@ -0,0 +1,3545 @@
+import { formatDateInCalendarSystem, extractCalendarParts, registerCalendarSystemFormatter, unregisterCalendarSystemFormatter } from "@vicacha-devs/strapi-plugin-calendar/shared";
+import crypto from "node:crypto";
+function formatSecondaryCalendars(date, systems, locale = "en") {
+  const result = {};
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+    return result;
+  }
+  const dateStr = date.toISOString().slice(0, 10);
+  for (const sys of systems) {
+    if (!sys || !sys.enabled || !sys.id) continue;
+    const formatted = formatDateInCalendarSystem(dateStr, sys, locale, {
+      compact: false
+    });
+    const compact = formatDateInCalendarSystem(dateStr, sys, locale, {
+      compact: true
+    });
+    const parts = extractCalendarParts(
+      date,
+      sys.intlCalendar,
+      sys.dayOffset ?? 0
+    );
+    if (formatted) {
+      result[sys.id] = {
+        calendarId: sys.id,
+        label: sys.label || sys.id,
+        formatted,
+        compact: compact || formatted,
+        intlCalendar: sys.intlCalendar,
+        year: parts?.year,
+        month: parts?.month,
+        day: parts?.day,
+        isOverridden: false
+      };
+    }
+  }
+  return result;
+}
+const PLUGIN_ID = "bookings";
+const UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isSafeObjectKey(key) {
+  return typeof key === "string" && key.length > 0 && !UNSAFE_OBJECT_KEYS.has(key);
+}
+function sanitizePlainRecord(val, depth = 0) {
+  if (!val || typeof val !== "object" || Array.isArray(val) || depth > 6) {
+    return void 0;
+  }
+  const clean = {};
+  for (const [key, entry] of Object.entries(val)) {
+    if (!isSafeObjectKey(key)) continue;
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+      clean[key] = sanitizePlainRecord(entry, depth + 1);
+    } else {
+      clean[key] = entry;
+    }
+  }
+  return clean;
+}
+class BookingValidationError extends Error {
+  statusCode = 400;
+  constructor(message) {
+    super(message);
+    this.name = "BookingValidationError";
+  }
+}
+class BookingForbiddenError extends Error {
+  statusCode = 403;
+  constructor(message) {
+    super(message);
+    this.name = "BookingForbiddenError";
+  }
+}
+class BookingNotFoundError extends Error {
+  statusCode = 404;
+  constructor(message) {
+    super(message);
+    this.name = "BookingNotFoundError";
+  }
+}
+const strapiResourceLocks = /* @__PURE__ */ new WeakMap();
+async function withResourceLock(strapi, lockKey, fn) {
+  let locks = strapiResourceLocks.get(strapi);
+  if (!locks) {
+    locks = /* @__PURE__ */ new Map();
+    strapiResourceLocks.set(strapi, locks);
+  }
+  const prev = locks.get(lockKey) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = prev.then(
+    () => current,
+    () => current
+  );
+  locks.set(lockKey, tail);
+  await prev.catch(() => void 0);
+  try {
+    if (typeof strapi.db?.transaction === "function") {
+      return await strapi.db.transaction(async () => fn());
+    }
+    return await fn();
+  } finally {
+    release();
+    if (locks.get(lockKey) === tail) {
+      locks.delete(lockKey);
+    }
+  }
+}
+function clearResourceLocks(strapi) {
+  strapiResourceLocks.delete(strapi);
+}
+const registeredFormattersByStrapi = /* @__PURE__ */ new WeakMap();
+function cleanupBootstrapState(strapi) {
+  const ids = registeredFormattersByStrapi.get(strapi);
+  if (ids) {
+    for (const id of ids) {
+      unregisterCalendarSystemFormatter(id);
+    }
+    registeredFormattersByStrapi.delete(strapi);
+  }
+}
+const BOOKING_CALENDAR_SOURCE = {
+  id: "bookings",
+  label: "Bookings & Reservations",
+  uid: "plugin::bookings.booking",
+  color: "#0D9488",
+  enabled: true,
+  fields: {
+    title: "title",
+    startDate: "startDate",
+    endDate: "endDate",
+    status: "status",
+    location: "assignedHost",
+    summary: "notes",
+    category: "status"
+  }
+};
+async function registerCalendarCompanion(strapi) {
+  const calendarPlugin = strapi.plugin("calendar");
+  try {
+    const calendarRegistry = calendarPlugin?.service?.("registry");
+    if (typeof calendarRegistry?.registerSource === "function") {
+      await calendarRegistry.registerSource(BOOKING_CALENDAR_SOURCE);
+    }
+    const calendarSettingsSvc = calendarPlugin?.service?.("settings");
+    if (typeof calendarSettingsSvc?.registerCompanionSource === "function") {
+      calendarSettingsSvc.registerCompanionSource(BOOKING_CALENDAR_SOURCE);
+    }
+  } catch {
+  }
+}
+const bootstrap = async ({ strapi }) => {
+  const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+  if (pluginConfig.calendarSystems && typeof pluginConfig.calendarSystems === "object") {
+    const registeredIds = [];
+    for (const [systemId, formatter] of Object.entries(
+      pluginConfig.calendarSystems
+    )) {
+      if (isSafeObjectKey(systemId) && Object.hasOwn(pluginConfig.calendarSystems, systemId) && typeof formatter === "function") {
+        registerCalendarSystemFormatter(systemId, formatter);
+        registeredIds.push(systemId);
+      }
+    }
+    if (registeredIds.length > 0) {
+      registeredFormattersByStrapi.set(strapi, registeredIds);
+    }
+  }
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Access the Bookings & Availability Workspace",
+      uid: "read",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Manage Bookings, Resources & Approvals",
+      uid: "manage",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Configure Bookings Settings",
+      uid: "settings",
+      pluginName: PLUGIN_ID
+    }
+  ];
+  const actionProvider = strapi.admin?.services?.permission?.actionProvider;
+  if (actionProvider?.registerMany) {
+    await actionProvider.registerMany(actions);
+  }
+  await registerCalendarCompanion(strapi);
+};
+const defaultConfig = {
+  defaultTimezone: "America/Bogota",
+  defaultLocale: "es",
+  theme: "breeze",
+  secondaryCalendarLanguage: "local",
+  defaultSlotDurationMinutes: 60,
+  defaultBufferBeforeMinutes: 0,
+  defaultBufferAfterMinutes: 0,
+  defaultCapacityPerSlot: 1,
+  defaultMinLeadTimeHours: 2,
+  defaultMaxAdvanceDays: 90,
+  defaultRequiresApproval: false,
+  sendEmailNotifications: true,
+  secondaryCalendars: [],
+  sources: [],
+  calendarSystems: {},
+  schemaExtensions: {},
+  customFields: []
+};
+const config = {
+  default: defaultConfig,
+  validator(config2) {
+    if (config2 && typeof config2 !== "object") {
+      throw new Error(
+        "@vicacha-devs/strapi-plugin-bookings config must be an object"
+      );
+    }
+  }
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "bookings";
+const info$1 = { "singularName": "booking", "pluralName": "bookings", "displayName": "Booking", "description": "Reservation, appointment, or resource slot booking" };
+const options$1 = { "draftAndPublish": false };
+const pluginOptions$1 = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes$1 = { "bookingCode": { "type": "string", "required": true, "unique": true, "maxLength": 48 }, "title": { "type": "string", "maxLength": 200 }, "resource": { "type": "relation", "relation": "manyToOne", "target": "plugin::bookings.resource", "inversedBy": "bookings" }, "customerName": { "type": "string", "required": true, "maxLength": 120 }, "customerEmail": { "type": "email", "required": true }, "customerPhone": { "type": "string", "maxLength": 40 }, "organization": { "type": "string", "maxLength": 160 }, "startDate": { "type": "datetime", "required": true }, "endDate": { "type": "datetime", "required": true }, "slotLabel": { "type": "string", "maxLength": 80 }, "timezone": { "type": "string", "default": "UTC", "maxLength": 64 }, "partySize": { "type": "integer", "required": true, "default": 1, "min": 1 }, "status": { "type": "enumeration", "enum": ["pending", "confirmed", "completed", "cancelled", "no_show"], "default": "pending", "required": true }, "preferredLanguage": { "type": "string", "maxLength": 16 }, "assignedHost": { "type": "string", "maxLength": 120 }, "notes": { "type": "text", "maxLength": 2e3 }, "internalNotes": { "type": "text", "maxLength": 2e3, "private": true }, "cancelTokenHash": { "type": "string", "maxLength": 128, "private": true }, "sourceCollection": { "type": "string", "default": "plugin::bookings.booking" }, "metadata": { "type": "json" } };
+const bookingSchema = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const kind = "collectionType";
+const collectionName = "booking_resources";
+const info = { "singularName": "resource", "pluralName": "resources", "displayName": "Booking Resource", "description": "Bookable service, appointment type, room, staff member, or equipment schedule" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": true }, "content-type-builder": { "visible": true } };
+const attributes = { "name": { "type": "string", "required": true, "maxLength": 160 }, "slug": { "type": "uid", "targetField": "name", "required": true }, "resourceType": { "type": "enumeration", "enum": ["service", "appointment", "room", "staff", "equipment", "other"], "default": "service", "required": true }, "description": { "type": "text" }, "color": { "type": "string", "default": "#0d9488", "maxLength": 32 }, "timezone": { "type": "string", "default": "UTC", "maxLength": 64 }, "slotDurationMinutes": { "type": "integer", "default": 60, "min": 5, "max": 1440, "required": true }, "bufferBeforeMinutes": { "type": "integer", "default": 0, "min": 0, "max": 720 }, "bufferAfterMinutes": { "type": "integer", "default": 0, "min": 0, "max": 720 }, "capacityPerSlot": { "type": "integer", "default": 1, "min": 1, "required": true }, "maxPartySize": { "type": "integer", "default": 50, "min": 1 }, "minLeadTimeHours": { "type": "integer", "default": 2, "min": 0 }, "maxAdvanceDays": { "type": "integer", "default": 90, "min": 1 }, "requiresApproval": { "type": "boolean", "default": false }, "weeklySchedule": { "type": "json" }, "seasonalSchedules": { "type": "json" }, "holidayRules": { "type": "json" }, "blackoutDates": { "type": "json" }, "recurrenceRule": { "type": "string" }, "supportedLanguages": { "type": "json" }, "assignedHosts": { "type": "json" }, "location": { "type": "string", "maxLength": 240 }, "price": { "type": "decimal", "default": 0, "min": 0 }, "currency": { "type": "string", "default": "USD", "maxLength": 10 }, "isActive": { "type": "boolean", "default": true }, "metadata": { "type": "json" }, "bookings": { "type": "relation", "relation": "oneToMany", "target": "plugin::bookings.booking", "mappedBy": "resource" } };
+const resourceSchema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  resource: { schema: resourceSchema },
+  booking: { schema: bookingSchema }
+};
+function respondControllerError(ctx, strapi, err, fallbackMessage) {
+  if (err instanceof BookingNotFoundError) {
+    if (typeof ctx.notFound === "function") {
+      return ctx.notFound(err.message);
+    }
+    ctx.status = 404;
+    ctx.body = {
+      error: { status: 404, name: "NotFoundError", message: err.message }
+    };
+    return void 0;
+  }
+  if (err instanceof BookingForbiddenError) {
+    if (typeof ctx.forbidden === "function") {
+      return ctx.forbidden(err.message);
+    }
+    ctx.status = 403;
+    ctx.body = {
+      error: { status: 403, name: "ForbiddenError", message: err.message }
+    };
+    return void 0;
+  }
+  if (err instanceof BookingValidationError) {
+    return ctx.badRequest(err.message);
+  }
+  strapi.log?.error?.(
+    `[bookings] ${fallbackMessage}: ${err instanceof Error ? err.message : "unknown error"}`
+  );
+  return ctx.badRequest(fallbackMessage);
+}
+const admin = ({ strapi }) => {
+  const getSettingsService = () => strapi.plugin(PLUGIN_ID).service("settings");
+  const getAvailabilityService = () => strapi.plugin(PLUGIN_ID).service("availability");
+  const getReservationService = () => strapi.plugin(PLUGIN_ID).service("reservation");
+  return {
+    async getSettings(ctx) {
+      const settings2 = await getSettingsService().getSettings();
+      ctx.body = { data: settings2 };
+    },
+    async updateSettings(ctx) {
+      try {
+        const payload = ctx.request.body ?? {};
+        const updated = await getSettingsService().updateSettings(payload);
+        ctx.body = { data: updated };
+      } catch (err) {
+        return respondControllerError(
+          ctx,
+          strapi,
+          err,
+          "Failed to update bookings settings"
+        );
+      }
+    },
+    async discoverSchemas(ctx) {
+      const schemas = await getSettingsService().discoverSchemas();
+      ctx.body = { data: schemas };
+    },
+    async listResources(ctx) {
+      const activeOnly = ctx.query.activeOnly === "true";
+      const resources = await getAvailabilityService().listResources(activeOnly);
+      ctx.body = { data: resources };
+    },
+    async saveResource(ctx) {
+      try {
+        const body = ctx.request.body ?? {};
+        if (typeof body.name !== "string" || !body.name.trim()) {
+          return ctx.badRequest("Resource name is required");
+        }
+        const saved = await getAvailabilityService().saveResource({
+          ...body,
+          name: body.name
+        });
+        ctx.body = { data: saved };
+      } catch (err) {
+        return respondControllerError(
+          ctx,
+          strapi,
+          err,
+          "Failed to save booking resource"
+        );
+      }
+    },
+    async getCalendar(ctx) {
+      const query = {
+        from: ctx.query.from,
+        to: ctx.query.to,
+        resourceDocumentId: ctx.query.resourceDocumentId,
+        resourceSlug: ctx.query.resourceSlug,
+        status: ctx.query.status ?? "",
+        preferredLanguage: ctx.query.preferredLanguage,
+        search: ctx.query.search,
+        source: ctx.query.source
+      };
+      const [calendarData, resources, settings2] = await Promise.all([
+        getAvailabilityService().getCalendarOccurrences(query),
+        getAvailabilityService().listResources(false),
+        getSettingsService().getSettings()
+      ]);
+      const { icalFeedToken: _omit, ...safeSettings } = settings2;
+      ctx.body = {
+        data: {
+          ...calendarData,
+          resources,
+          settings: safeSettings
+        }
+      };
+    },
+    async createBooking(ctx) {
+      try {
+        const body = ctx.request.body ?? {};
+        const result = await getReservationService().createReservation(body, {
+          isAdmin: true,
+          skipLeadTimeCheck: true
+        });
+        ctx.body = { data: result };
+      } catch (err) {
+        return respondControllerError(
+          ctx,
+          strapi,
+          err,
+          "Invalid booking payload"
+        );
+      }
+    },
+    async updateBookingStatus(ctx) {
+      try {
+        const documentId = ctx.params.documentId;
+        if (!documentId) {
+          return ctx.badRequest("documentId parameter is required");
+        }
+        const body = ctx.request.body ?? {};
+        if (!body.status) {
+          return ctx.badRequest("status is required");
+        }
+        const updated = await getReservationService().updateBookingStatus(
+          documentId,
+          body.status,
+          {
+            assignedHost: body.assignedHost,
+            internalNotes: body.internalNotes
+          }
+        );
+        ctx.body = { data: updated };
+      } catch (err) {
+        return respondControllerError(ctx, strapi, err, "Status update failed");
+      }
+    },
+    async rescheduleBooking(ctx) {
+      try {
+        const body = ctx.request.body ?? {};
+        if (!body.newStartDate) {
+          return ctx.badRequest("newStartDate is required");
+        }
+        const updated = await getReservationService().rescheduleBooking(
+          {
+            bookingDocumentId: body.bookingDocumentId ?? ctx.params.documentId,
+            bookingCode: body.bookingCode,
+            newStartDate: body.newStartDate,
+            newEndDate: body.newEndDate,
+            newSlotLabel: body.newSlotLabel,
+            partySize: body.partySize
+          },
+          { isAdmin: true }
+        );
+        ctx.body = { data: updated };
+      } catch (err) {
+        return respondControllerError(ctx, strapi, err, "Reschedule failed");
+      }
+    },
+    async exportCsv(ctx) {
+      const csv = await getReservationService().exportCsv({
+        from: ctx.query.from,
+        to: ctx.query.to,
+        resourceDocumentId: ctx.query.resourceDocumentId,
+        status: ctx.query.status ?? "",
+        search: ctx.query.search
+      });
+      ctx.set("Content-Type", "text/csv; charset=utf-8");
+      ctx.set("Content-Disposition", 'attachment; filename="bookings.csv"');
+      ctx.set("X-Content-Type-Options", "nosniff");
+      ctx.body = csv;
+    },
+    async exportICal(ctx) {
+      const ics = await getReservationService().exportICal(
+        {
+          from: ctx.query.from,
+          to: ctx.query.to,
+          resourceDocumentId: ctx.query.resourceDocumentId,
+          status: ctx.query.status ?? ""
+        },
+        { anonymize: false }
+      );
+      ctx.set("Content-Type", "text/calendar; charset=utf-8");
+      ctx.set("Content-Disposition", 'attachment; filename="bookings.ics"');
+      ctx.set("X-Content-Type-Options", "nosniff");
+      ctx.body = ics;
+    }
+  };
+};
+const DEFAULT_WEEKLY_SCHEDULE = {
+  mode: "interval",
+  days: {
+    "1": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "2": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "3": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "4": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "5": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }]
+  }
+};
+const WEEKDAY_TO_KEY = {
+  Sun: "0",
+  Mon: "1",
+  Tue: "2",
+  Wed: "3",
+  Thu: "4",
+  Fri: "5",
+  Sat: "6"
+};
+const formatterCache = /* @__PURE__ */ new Map();
+function getZonedFormatter(timeZone) {
+  const cached = formatterCache.get(timeZone);
+  if (cached) return cached;
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  });
+  if (formatterCache.size > 128) {
+    formatterCache.clear();
+  }
+  formatterCache.set(timeZone, dtf);
+  return dtf;
+}
+function normalizeTimeZone(tz) {
+  const trimmed = typeof tz === "string" ? tz.trim() : "";
+  if (!trimmed) return "UTC";
+  try {
+    getZonedFormatter(trimmed);
+    return trimmed;
+  } catch {
+    return "UTC";
+  }
+}
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function extractZonedWallClock(epochMs, rawTimeZone) {
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const dtf = getZonedFormatter(timeZone);
+  const parts = dtf.formatToParts(new Date(epochMs));
+  let year = 1970;
+  let month = 1;
+  let day = 1;
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  let dayKey = "4";
+  for (const part of parts) {
+    if (part.type === "year") year = Number.parseInt(part.value, 10);
+    else if (part.type === "month") month = Number.parseInt(part.value, 10);
+    else if (part.type === "day") day = Number.parseInt(part.value, 10);
+    else if (part.type === "hour") {
+      const h = Number.parseInt(part.value, 10);
+      hours = h === 24 ? 0 : h;
+    } else if (part.type === "minute") {
+      minutes = Number.parseInt(part.value, 10);
+    } else if (part.type === "second") {
+      seconds = Number.parseInt(part.value, 10);
+    } else if (part.type === "weekday") {
+      dayKey = WEEKDAY_TO_KEY[part.value] ?? "0";
+    }
+  }
+  const dateStr = `${String(year).padStart(4, "0")}-${pad2(month)}-${pad2(day)}`;
+  const ms = (epochMs % 1e3 + 1e3) % 1e3;
+  return {
+    year,
+    month,
+    day,
+    dateStr,
+    dayKey,
+    hours,
+    minutes,
+    seconds,
+    ms,
+    minutesOfDay: hours * 60 + minutes
+  };
+}
+function getTimeZoneOffsetMs(instantMs, timeZone) {
+  const parts = extractZonedWallClock(instantMs, timeZone);
+  const zonedAsUtcMs = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hours,
+    parts.minutes,
+    parts.seconds,
+    0
+  );
+  const truncatedInstant = Math.floor(instantMs / 1e3) * 1e3;
+  return zonedAsUtcMs - truncatedInstant;
+}
+function parseIsoDateYmd(dateStr) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr.trim());
+  if (!match) return null;
+  const year = Number.parseInt(match[1], 10);
+  const month = Number.parseInt(match[2], 10);
+  const day = Number.parseInt(match[3], 10);
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  const check = new Date(Date.UTC(year, month - 1, day));
+  if (check.getUTCFullYear() !== year || check.getUTCMonth() !== month - 1 || check.getUTCDate() !== day) {
+    return null;
+  }
+  return { year, month, day };
+}
+function wallClockToUtcMs(dateStr, totalMinutes, rawTimeZone, strictGap = false) {
+  const ymd = parseIsoDateYmd(dateStr);
+  if (!ymd) return null;
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const extraDays = Math.floor(totalMinutes / 1440);
+  const remMins = (totalMinutes % 1440 + 1440) % 1440;
+  const targetUtcMidnight = Date.UTC(
+    ymd.year,
+    ymd.month - 1,
+    ymd.day + extraDays,
+    0,
+    0,
+    0,
+    0
+  );
+  const naiveUtcMs = targetUtcMidnight + remMins * 6e4;
+  const offset1 = getTimeZoneOffsetMs(naiveUtcMs, timeZone);
+  const guess1 = naiveUtcMs - offset1;
+  const offset2 = getTimeZoneOffsetMs(guess1, timeZone);
+  const guess2 = naiveUtcMs - offset2;
+  const targetDateObj = new Date(targetUtcMidnight);
+  const expectedDateStr = targetDateObj.toISOString().slice(0, 10);
+  const check2 = extractZonedWallClock(guess2, timeZone);
+  if (check2.dateStr === expectedDateStr && check2.minutesOfDay === remMins) {
+    return guess2;
+  }
+  const check1 = extractZonedWallClock(guess1, timeZone);
+  if (check1.dateStr === expectedDateStr && check1.minutesOfDay === remMins) {
+    return guess1;
+  }
+  return strictGap ? null : guess1;
+}
+function parsePeriodTimestampInZone(raw, endOfDay, rawTimeZone) {
+  const trimmed = raw.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    const ms = wallClockToUtcMs(
+      trimmed,
+      endOfDay ? 1440 : 0,
+      rawTimeZone,
+      false
+    );
+    if (ms === null) return Number.NaN;
+    return endOfDay ? ms - 1 : ms;
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    if (!parseIsoDateYmd(trimmed.slice(0, 10))) {
+      return Number.NaN;
+    }
+  }
+  return Date.parse(trimmed);
+}
+function enumerateLocalDatesInRange(rangeStartMs, rangeEndMs, rawTimeZone, maxDays = 366) {
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const startWall = extractZonedWallClock(rangeStartMs, timeZone);
+  const endWall = extractZonedWallClock(rangeEndMs, timeZone);
+  const startUtcDay = Date.UTC(
+    startWall.year,
+    startWall.month - 1,
+    startWall.day
+  );
+  const endUtcDay = Date.UTC(endWall.year, endWall.month - 1, endWall.day);
+  const results = [];
+  for (let cursorUtc = startUtcDay, count = 0; cursorUtc <= endUtcDay && count < maxDays; cursorUtc += 864e5, count += 1) {
+    const d = new Date(cursorUtc);
+    results.push({
+      dateStr: d.toISOString().slice(0, 10),
+      dayKey: String(d.getUTCDay())
+    });
+  }
+  return results;
+}
+function parseTimeMinutes(hhmm) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(hhmm.trim());
+  if (!match) return 9 * 60;
+  const hours = Number.parseInt(match[1], 10);
+  const minutes = Number.parseInt(match[2], 10);
+  if (hours === 24 && minutes === 0) return 1440;
+  const clampedH = Math.min(23, Math.max(0, hours));
+  const clampedM = Math.min(59, Math.max(0, minutes));
+  return clampedH * 60 + clampedM;
+}
+function formatTimeMinutes(totalMinutes) {
+  const clamped = Math.max(0, Math.min(24 * 60, totalMinutes));
+  const hours = Math.floor(clamped / 60);
+  const mins = clamped % 60;
+  return `${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`;
+}
+function extractMonthDay(dateOrMmDd) {
+  const trimmed = dateOrMmDd.trim();
+  const isoDay = trimmed.length >= 10 ? trimmed.slice(0, 10) : trimmed;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(isoDay)) return isoDay.slice(5, 10);
+  if (/^\d{2}-\d{2}$/.test(isoDay)) return isoDay;
+  return "";
+}
+function matchesYearlessRange(dateStr, startStr, endStr) {
+  const [t, s, e] = [dateStr, startStr, endStr].map(extractMonthDay);
+  if (!t || !s || !e) return false;
+  return s <= e ? t >= s && t <= e : t >= s || t <= e;
+}
+function matchesDateOrYearlessRange(dateStr, startStr, endStr, yearless = false) {
+  if (!dateStr || !startStr || !endStr) return false;
+  if (yearless) return matchesYearlessRange(dateStr, startStr, endStr);
+  const [t, s, e] = [dateStr, startStr, endStr].map(
+    (d) => d.trim().slice(0, 10)
+  );
+  return t >= s && t <= e;
+}
+function matchesSingleDateOrYearless(dateStr, ruleDateStr, yearless = false) {
+  return matchesDateOrYearlessRange(
+    dateStr,
+    ruleDateStr,
+    ruleDateStr,
+    yearless
+  );
+}
+function isSlotBlackedOut(slotStartMs, slotEndMs, blackoutDates, rawTimeZone) {
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const slotDateStr = extractZonedWallClock(slotStartMs, timeZone).dateStr;
+  return blackoutDates.some((period) => {
+    if (!period?.start || !period?.end) return false;
+    if (period.yearless) {
+      return matchesDateOrYearlessRange(
+        slotDateStr,
+        period.start,
+        period.end,
+        true
+      );
+    }
+    const startMs = parsePeriodTimestampInZone(period.start, false, timeZone);
+    const endMs = parsePeriodTimestampInZone(period.end, true, timeZone);
+    return !Number.isNaN(startMs) && !Number.isNaN(endMs) && slotStartMs < endMs && slotEndMs > startMs;
+  });
+}
+function findMatchingHoliday(dateStr, globalHolidays = [], resourceHolidays = []) {
+  return [
+    ...Array.isArray(globalHolidays) ? globalHolidays : [],
+    ...Array.isArray(resourceHolidays) ? resourceHolidays : []
+  ].filter(
+    (r) => Boolean(r?.date) && matchesSingleDateOrYearless(dateStr, r.date, Boolean(r.yearless))
+  ).pop();
+}
+function findWinningSeasonalSchedule(dateStr, globalSeasonalSchedules = [], resourceSeasonals = []) {
+  return [
+    ...Array.isArray(globalSeasonalSchedules) ? globalSeasonalSchedules : [],
+    ...Array.isArray(resourceSeasonals) ? resourceSeasonals : []
+  ].filter(
+    (s) => s?.schedule && matchesDateOrYearlessRange(
+      dateStr,
+      s.startDate,
+      s.endDate,
+      Boolean(s.yearless)
+    )
+  ).sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)).pop();
+}
+function resolveDailyScheduleForDate(dateStr, dayKey, resource, globalSeasonalSchedules = [], globalHolidays = []) {
+  const baseSchedule = resource.weeklySchedule?.days ? resource.weeklySchedule : DEFAULT_WEEKLY_SCHEDULE;
+  const baseMode = baseSchedule.mode ?? "interval";
+  const baseDurationMins = Math.max(5, resource.slotDurationMinutes || 60);
+  const holiday = findMatchingHoliday(
+    dateStr,
+    globalHolidays,
+    resource.holidayRules
+  );
+  if (holiday) {
+    const hasCustom = Array.isArray(holiday.windows) && holiday.windows.length > 0;
+    const isClosed = (holiday.isClosed ?? !hasCustom) || !hasCustom;
+    return {
+      mode: isClosed ? baseMode : holiday.mode ?? baseMode,
+      durationMins: baseDurationMins,
+      windows: isClosed ? [] : holiday.windows ?? [],
+      scheduleLabel: holiday.name
+    };
+  }
+  const seasonal = findWinningSeasonalSchedule(
+    dateStr,
+    globalSeasonalSchedules,
+    resource.seasonalSchedules
+  );
+  if (seasonal) {
+    return {
+      mode: seasonal.schedule.mode ?? baseMode,
+      durationMins: Math.max(
+        5,
+        seasonal.slotDurationMinutes ?? baseDurationMins
+      ),
+      windows: seasonal.schedule.days?.[dayKey] ?? [],
+      scheduleLabel: seasonal.label
+    };
+  }
+  return {
+    mode: baseMode,
+    durationMins: baseDurationMins,
+    windows: baseSchedule.days?.[dayKey] ?? []
+  };
+}
+function asStr$1(val, fallback = "") {
+  return val !== void 0 && val !== null ? String(val) : fallback;
+}
+function asOptStr$1(val) {
+  return val !== void 0 && val !== null && String(val) !== "" ? String(val) : void 0;
+}
+function resolveExternalSlotWindow(dateStr, slotLabel, initialEndIso, source) {
+  if (dateStr.length === 10) {
+    const defaultWindows = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      {
+        morning: { start: "09:00", end: "12:00" },
+        afternoon: { start: "14:00", end: "17:00" },
+        evening: { start: "18:00", end: "20:00" }
+      }
+    );
+    if (source.slotWindows && typeof source.slotWindows === "object") {
+      for (const [wKey, wVal] of Object.entries(source.slotWindows)) {
+        if (isSafeObjectKey(wKey) && Object.hasOwn(source.slotWindows, wKey) && wVal && typeof wVal.start === "string" && typeof wVal.end === "string") {
+          defaultWindows[wKey.toLowerCase()] = {
+            start: wVal.start,
+            end: wVal.end
+          };
+        }
+      }
+    }
+    const key = slotLabel.toLowerCase();
+    const windowSpec = slotLabel && isSafeObjectKey(key) && Object.hasOwn(defaultWindows, key) ? defaultWindows[key] : { start: "09:00", end: "10:00" };
+    return {
+      startIso: `${dateStr}T${windowSpec.start}:00.000Z`,
+      endIso: initialEndIso || `${dateStr}T${windowSpec.end}:00.000Z`
+    };
+  }
+  if (!initialEndIso) {
+    const parsedStart = Date.parse(dateStr);
+    const endIso = Number.isNaN(parsedStart) ? dateStr : new Date(parsedStart + 36e5).toISOString();
+    return { startIso: dateStr, endIso };
+  }
+  return { startIso: dateStr, endIso: initialEndIso };
+}
+function readMappedField(row, fieldName) {
+  if (!isSafeObjectKey(fieldName) || !Object.hasOwn(row, fieldName)) {
+    return void 0;
+  }
+  const value = row[fieldName];
+  return value !== void 0 && value !== null && String(value) !== "" ? String(value) : void 0;
+}
+function resolveExternalPartyAndStatus(row, source) {
+  const rawParty = readMappedField(row, source.partySizeField);
+  const parsed = rawParty ? Number(rawParty) : 1;
+  const partySize = Number.isFinite(parsed) ? Math.max(1, Math.trunc(parsed)) : 1;
+  const statusField = source.statusField;
+  const status = isSafeObjectKey(statusField) && Object.hasOwn(row, statusField) ? normalizeStatus(row[statusField]) : "confirmed";
+  return { partySize, status };
+}
+function mapExternalSourceRowToBooking(row, source) {
+  if (!isSafeObjectKey(source.dateField) || !Object.hasOwn(row, source.dateField)) {
+    return null;
+  }
+  const rawDate = row[source.dateField];
+  if (!rawDate) return null;
+  const dateStr = String(rawDate).trim();
+  const slotLabel = readMappedField(row, source.slotLabelField) ?? "";
+  const initialEndIso = readMappedField(row, source.endDateField) ?? "";
+  const { startIso, endIso } = resolveExternalSlotWindow(
+    dateStr,
+    slotLabel,
+    initialEndIso,
+    source
+  );
+  const documentId = asStr$1(row.documentId ?? row.id);
+  const customerName = readMappedField(row, source.customerNameField) ?? "Guest";
+  const { partySize, status } = resolveExternalPartyAndStatus(row, source);
+  return {
+    documentId,
+    bookingCode: `EXT-${documentId.slice(0, 8).toUpperCase()}`,
+    title: formatBookingDefaultTitle(customerName, source.label, partySize),
+    resourceDocumentId: source.id,
+    resourceName: source.label,
+    resourceColor: asStr$1(source.color, "#0d9488"),
+    customerName,
+    customerEmail: readMappedField(row, source.customerEmailField) ?? "",
+    customerPhone: readMappedField(row, source.customerPhoneField),
+    organization: readMappedField(row, source.organizationField),
+    startDate: startIso,
+    endDate: endIso,
+    slotLabel: asOptStr$1(slotLabel),
+    timezone: "UTC",
+    partySize,
+    status,
+    preferredLanguage: readMappedField(row, source.languageField),
+    notes: readMappedField(row, source.notesField),
+    sourceCollection: source.uid
+  };
+}
+function parseBoundaryMs(isoOrDate, endOfDay) {
+  if (!isoOrDate) return null;
+  const trimmed = isoOrDate.trim();
+  if (!trimmed) return null;
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    if (!parseIsoDateYmd(trimmed.slice(0, 10))) {
+      return null;
+    }
+  }
+  const normalized = trimmed.length === 10 ? `${trimmed}T${endOfDay ? "23:59:59.999Z" : "00:00:00.000Z"}` : trimmed;
+  const ms = Date.parse(normalized);
+  return Number.isNaN(ms) ? null : ms;
+}
+function isWithinDateBoundaries(booking, fromMs, toMs) {
+  if (fromMs !== null) {
+    const endMs = Date.parse(booking.endDate);
+    if (!Number.isNaN(endMs) && endMs < fromMs) return false;
+  }
+  if (toMs !== null) {
+    const startMs = Date.parse(booking.startDate);
+    if (!Number.isNaN(startMs) && startMs > toMs) return false;
+  }
+  return true;
+}
+function matchesBookingAttributes(booking, targetResourceId, query) {
+  if (targetResourceId && booking.resourceDocumentId !== targetResourceId) {
+    return false;
+  }
+  if (query.activeOnly && booking.status !== "pending" && booking.status !== "confirmed") {
+    return false;
+  }
+  if (query.status && booking.status !== query.status) {
+    return false;
+  }
+  if (query.preferredLanguage && booking.preferredLanguage?.toLowerCase() !== query.preferredLanguage.toLowerCase()) {
+    return false;
+  }
+  return !query.source || booking.sourceCollection === query.source;
+}
+function matchesBookingSearch(booking, searchLower) {
+  if (!searchLower) return true;
+  const haystack = [
+    booking.bookingCode,
+    booking.customerName,
+    booking.customerEmail,
+    booking.organization,
+    booking.assignedHost,
+    booking.resourceName,
+    booking.notes
+  ].filter(Boolean).join(" ").toLowerCase();
+  return haystack.includes(searchLower);
+}
+function filterAndSortBookings(allBookings, resources, query) {
+  const fromMs = parseBoundaryMs(query.from, false);
+  const toMs = parseBoundaryMs(query.to, true);
+  const matchedResource = !query.resourceDocumentId && query.resourceSlug ? resources.find((r) => r.slug === query.resourceSlug) : void 0;
+  const targetResourceId = query.resourceDocumentId ?? matchedResource?.documentId;
+  const searchLower = query.search?.trim().toLowerCase();
+  const sorted = allBookings.filter(
+    (b) => isWithinDateBoundaries(b, fromMs, toMs) && matchesBookingAttributes(b, targetResourceId, query) && matchesBookingSearch(b, searchLower)
+  ).sort((a, b) => Date.parse(a.startDate) - Date.parse(b.startDate));
+  if (typeof query.limit === "number" && Number.isFinite(query.limit) && query.limit > 0) {
+    return sorted.slice(0, Math.trunc(query.limit));
+  }
+  return sorted;
+}
+const VALID_BOOKING_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "confirmed",
+  "completed",
+  "cancelled",
+  "no_show"
+]);
+function parseStrictBookingStatus(raw) {
+  if (typeof raw !== "string") {
+    throw new BookingValidationError("A valid booking status is required");
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (!VALID_BOOKING_STATUSES.has(normalized)) {
+    throw new BookingValidationError(`Invalid booking status: '${raw}'`);
+  }
+  return normalized;
+}
+function normalizeStatus(raw) {
+  const str = String(raw ?? "pending").toLowerCase().trim();
+  return VALID_BOOKING_STATUSES.has(str) ? str : "pending";
+}
+function hashCancelToken(token) {
+  return crypto.createHash("sha256").update(token, "utf8").digest("hex");
+}
+function verifyCancelToken(token, expectedHash) {
+  if (typeof token !== "string" || !token.trim() || typeof expectedHash !== "string" || !expectedHash.trim()) {
+    return false;
+  }
+  const actualHash = hashCancelToken(token);
+  const aBuf = Buffer.from(actualHash, "utf8");
+  const bBuf = Buffer.from(expectedHash, "utf8");
+  if (aBuf.length !== bBuf.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(aBuf, bBuf);
+}
+function verifySecretToken(provided, expected) {
+  if (typeof provided !== "string" || !provided.trim() || typeof expected !== "string" || !expected.trim()) {
+    return false;
+  }
+  const aBuf = Buffer.from(hashCancelToken(provided.trim()), "utf8");
+  const bBuf = Buffer.from(hashCancelToken(expected.trim()), "utf8");
+  return aBuf.length === bBuf.length && crypto.timingSafeEqual(aBuf, bBuf);
+}
+function computeOpaqueBookingUid(booking) {
+  const seed = `ical-feed:${booking.documentId}:${booking.bookingCode}:${booking.startDate}`;
+  return crypto.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, 24);
+}
+function generateRawCancelToken() {
+  return crypto.randomBytes(24).toString("hex");
+}
+function generateBookingCode(now = /* @__PURE__ */ new Date()) {
+  const safeNow = now instanceof Date && !Number.isNaN(now.getTime()) ? now : /* @__PURE__ */ new Date();
+  const datePart = safeNow.toISOString().slice(0, 10).replace(/-/g, "");
+  const randomSuffix = crypto.randomBytes(3).toString("hex").toUpperCase();
+  return `BKG-${datePart}-${randomSuffix}`;
+}
+function asOptStr(val) {
+  return val !== void 0 && val !== null && String(val) !== "" ? String(val) : void 0;
+}
+function asObjRecord(val) {
+  return val && typeof val === "object" && !Array.isArray(val) ? val : void 0;
+}
+function asStr(val, fallback = "") {
+  return val !== void 0 && val !== null ? String(val) : fallback;
+}
+function resolveBookingResourceRef(raw, resourceMap) {
+  const relResource = asObjRecord(raw.resource);
+  const rawResourceStr = typeof raw.resource === "string" ? raw.resource : "";
+  const resourceDocumentId = String(
+    relResource?.documentId ?? relResource?.id ?? raw.resourceDocumentId ?? rawResourceStr
+  );
+  const mappedResource = resourceDocumentId ? resourceMap.get(resourceDocumentId) : void 0;
+  const resourceName = mappedResource?.name ?? asOptStr(relResource?.name);
+  return {
+    resourceDocumentId: resourceDocumentId || void 0,
+    mappedResource,
+    resourceName
+  };
+}
+function formatBookingDefaultTitle(customerName, resourceName, partySize) {
+  const resourceSuffix = resourceName ? ` — ${resourceName}` : "";
+  const sizeSuffix = partySize > 1 ? ` (${partySize})` : "";
+  return `${customerName}${resourceSuffix}${sizeSuffix}`;
+}
+function normalizeBookingOptionals(raw) {
+  return {
+    customerPhone: asOptStr(raw.customerPhone),
+    organization: asOptStr(raw.organization),
+    slotLabel: asOptStr(raw.slotLabel),
+    preferredLanguage: asOptStr(raw.preferredLanguage),
+    assignedHost: asOptStr(raw.assignedHost),
+    notes: asOptStr(raw.notes),
+    internalNotes: asOptStr(raw.internalNotes),
+    metadata: sanitizePlainRecord(raw.metadata),
+    createdAt: asOptStr(raw.createdAt),
+    updatedAt: asOptStr(raw.updatedAt)
+  };
+}
+function normalizeBookingRecord(raw, resourceMap) {
+  const { resourceDocumentId, mappedResource, resourceName } = resolveBookingResourceRef(raw, resourceMap);
+  const customerName = asStr(raw.customerName, "Guest");
+  const rawParty = Number(raw.partySize ?? 1);
+  const partySize = Number.isFinite(rawParty) ? Math.max(1, Math.trunc(rawParty)) : 1;
+  const documentId = asStr(raw.documentId ?? raw.id);
+  const startDate = asStr(raw.startDate);
+  const defaultTitle = formatBookingDefaultTitle(
+    customerName,
+    resourceName,
+    partySize
+  );
+  return {
+    documentId,
+    bookingCode: asStr(raw.bookingCode, `BKG-${documentId}`),
+    title: asOptStr(raw.title) ?? defaultTitle,
+    resourceDocumentId,
+    resourceName,
+    resourceColor: mappedResource?.color,
+    customerName,
+    customerEmail: asStr(raw.customerEmail),
+    startDate,
+    endDate: asStr(raw.endDate, startDate),
+    timezone: normalizeTimeZone(
+      asStr(raw.timezone ?? mappedResource?.timezone, "UTC")
+    ),
+    partySize,
+    status: normalizeStatus(raw.status),
+    sourceCollection: asStr(raw.sourceCollection, "plugin::bookings.booking"),
+    ...normalizeBookingOptionals(raw)
+  };
+}
+function trimOrUndefined(val) {
+  if (typeof val !== "string") return void 0;
+  const trimmed = val.trim();
+  return trimmed ? trimmed : void 0;
+}
+function buildBookingCreatePayload(params) {
+  const {
+    bookingCode,
+    customerName,
+    customerEmail,
+    startMs,
+    endMs,
+    partySize,
+    status,
+    assignedHost,
+    cancelTokenHash,
+    resource,
+    settings: settings2,
+    input
+  } = params;
+  return {
+    bookingCode,
+    title: formatBookingDefaultTitle(customerName, resource?.name, partySize),
+    resource: resource?.documentId ?? void 0,
+    customerName,
+    customerEmail,
+    customerPhone: trimOrUndefined(input.customerPhone),
+    organization: trimOrUndefined(input.organization),
+    startDate: new Date(startMs).toISOString(),
+    endDate: new Date(endMs).toISOString(),
+    slotLabel: trimOrUndefined(input.slotLabel),
+    timezone: normalizeTimeZone(
+      asStr(
+        input.timezone || resource?.timezone || settings2.defaultTimezone,
+        "UTC"
+      )
+    ),
+    partySize,
+    status,
+    preferredLanguage: trimOrUndefined(input.preferredLanguage),
+    assignedHost,
+    notes: trimOrUndefined(input.notes),
+    cancelTokenHash,
+    sourceCollection: "plugin::bookings.booking",
+    metadata: sanitizePlainRecord(input.metadata)
+  };
+}
+const CAPACITY_WINDOW_PAD_MS = 864e5;
+function buildCapacityWindowQuery(resourceDocumentId, startMs, endMs) {
+  return {
+    resourceDocumentId,
+    from: new Date(startMs - CAPACITY_WINDOW_PAD_MS).toISOString(),
+    to: new Date(endMs + CAPACITY_WINDOW_PAD_MS).toISOString(),
+    activeOnly: true,
+    limit: 1e3
+  };
+}
+function assertNonRolloverDatePrefix(raw, errorMessage) {
+  const trimmed = raw.trim();
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    if (!parseIsoDateYmd(trimmed.slice(0, 10))) {
+      throw new BookingValidationError(errorMessage);
+    }
+  }
+}
+function computeRescheduleWindow(targetRaw, input) {
+  if (typeof input.newStartDate !== "string" || !input.newStartDate.trim()) {
+    throw new BookingValidationError("A valid newStartDate is required");
+  }
+  assertNonRolloverDatePrefix(
+    input.newStartDate,
+    "A valid newStartDate is required"
+  );
+  const newStartMs = Date.parse(input.newStartDate);
+  if (Number.isNaN(newStartMs)) {
+    throw new BookingValidationError("A valid newStartDate is required");
+  }
+  const oldStartMs = Date.parse(String(targetRaw.startDate));
+  const oldEndMs = Date.parse(String(targetRaw.endDate));
+  const hasValidOldRange = !Number.isNaN(oldStartMs) && !Number.isNaN(oldEndMs) && oldEndMs > oldStartMs;
+  const defaultDurationMs = hasValidOldRange ? oldEndMs - oldStartMs : 36e5;
+  if (typeof input.newEndDate === "string" && input.newEndDate.trim()) {
+    assertNonRolloverDatePrefix(
+      input.newEndDate,
+      "newEndDate must be a valid ISO date"
+    );
+  }
+  const newEndMs = input.newEndDate ? Date.parse(input.newEndDate) : newStartMs + defaultDurationMs;
+  if (Number.isNaN(newEndMs) || newEndMs <= newStartMs) {
+    throw new BookingValidationError("newEndDate must be after newStartDate");
+  }
+  return { newStartMs, newEndMs };
+}
+const MAX_PUBLIC_SLOTS_RANGE_MS = 90 * 864e5;
+const MAX_PUBLIC_FEED_RANGE_MS = 366 * 864e5;
+function sanitizePublicHost(host) {
+  return {
+    id: host.id,
+    name: host.name,
+    ...Array.isArray(host.languages) ? { languages: host.languages } : {},
+    ...host.role !== void 0 ? { role: host.role } : {}
+  };
+}
+function sanitizePublicResource(resource) {
+  const hosts = Array.isArray(resource.assignedHosts) ? resource.assignedHosts.filter(
+    (h) => Boolean(h) && typeof h.id === "string" && typeof h.name === "string"
+  ).map(sanitizePublicHost) : [];
+  return {
+    documentId: resource.documentId,
+    name: resource.name,
+    slug: resource.slug,
+    resourceType: resource.resourceType,
+    ...resource.description !== void 0 ? { description: resource.description } : {},
+    color: resource.color,
+    timezone: resource.timezone,
+    slotDurationMinutes: resource.slotDurationMinutes,
+    bufferBeforeMinutes: resource.bufferBeforeMinutes,
+    bufferAfterMinutes: resource.bufferAfterMinutes,
+    capacityPerSlot: resource.capacityPerSlot,
+    maxPartySize: resource.maxPartySize,
+    minLeadTimeHours: resource.minLeadTimeHours,
+    maxAdvanceDays: resource.maxAdvanceDays,
+    requiresApproval: resource.requiresApproval,
+    weeklySchedule: resource.weeklySchedule,
+    ...resource.seasonalSchedules !== void 0 ? { seasonalSchedules: resource.seasonalSchedules } : {},
+    ...resource.holidayRules !== void 0 ? { holidayRules: resource.holidayRules } : {},
+    blackoutDates: resource.blackoutDates,
+    ...resource.recurrenceRule !== void 0 ? { recurrenceRule: resource.recurrenceRule } : {},
+    supportedLanguages: resource.supportedLanguages,
+    assignedHosts: hosts,
+    ...resource.location !== void 0 ? { location: resource.location } : {},
+    ...resource.price !== void 0 ? { price: resource.price } : {},
+    ...resource.currency !== void 0 ? { currency: resource.currency } : {},
+    isActive: resource.isActive
+  };
+}
+function sanitizePublicSlot(slot) {
+  return {
+    ...slot,
+    availableHosts: (slot.availableHosts ?? []).map(sanitizePublicHost)
+  };
+}
+function sanitizePublicBooking(booking) {
+  return {
+    documentId: booking.documentId,
+    bookingCode: booking.bookingCode,
+    title: booking.title,
+    ...booking.resourceDocumentId !== void 0 ? { resourceDocumentId: booking.resourceDocumentId } : {},
+    ...booking.resourceName !== void 0 ? { resourceName: booking.resourceName } : {},
+    ...booking.resourceColor !== void 0 ? { resourceColor: booking.resourceColor } : {},
+    customerName: booking.customerName,
+    customerEmail: booking.customerEmail,
+    ...booking.customerPhone !== void 0 ? { customerPhone: booking.customerPhone } : {},
+    ...booking.organization !== void 0 ? { organization: booking.organization } : {},
+    startDate: booking.startDate,
+    endDate: booking.endDate,
+    ...booking.slotLabel !== void 0 ? { slotLabel: booking.slotLabel } : {},
+    timezone: booking.timezone,
+    partySize: booking.partySize,
+    status: booking.status,
+    ...booking.preferredLanguage !== void 0 ? { preferredLanguage: booking.preferredLanguage } : {},
+    ...booking.assignedHost !== void 0 ? { assignedHost: booking.assignedHost } : {},
+    ...booking.notes !== void 0 ? { notes: booking.notes } : {},
+    ...booking.secondaryDates !== void 0 ? { secondaryDates: booking.secondaryDates } : {},
+    ...booking.createdAt !== void 0 ? { createdAt: booking.createdAt } : {},
+    ...booking.updatedAt !== void 0 ? { updatedAt: booking.updatedAt } : {}
+  };
+}
+function clampQueryLimit(raw, fallback, max) {
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) return fallback;
+  return Math.min(max, parsed);
+}
+function respondPublicError(ctx, strapi, err, fallbackMessage) {
+  if (err instanceof BookingNotFoundError) {
+    if (typeof ctx.notFound === "function") {
+      return ctx.notFound(err.message);
+    }
+    ctx.status = 404;
+    ctx.body = {
+      error: { status: 404, name: "NotFoundError", message: err.message }
+    };
+    return void 0;
+  }
+  if (err instanceof BookingForbiddenError) {
+    if (typeof ctx.forbidden === "function") {
+      return ctx.forbidden(err.message);
+    }
+    ctx.status = 403;
+    ctx.body = {
+      error: { status: 403, name: "ForbiddenError", message: err.message }
+    };
+    return void 0;
+  }
+  if (err instanceof BookingValidationError) {
+    return ctx.badRequest(err.message);
+  }
+  strapi.log?.error?.(
+    `[bookings] ${fallbackMessage}: ${err instanceof Error ? err.message : "unknown error"}`
+  );
+  return ctx.badRequest(fallbackMessage);
+}
+function extractFeedTokenFromContext(ctx) {
+  if (typeof ctx.query.token === "string" && ctx.query.token.trim()) {
+    return ctx.query.token.trim();
+  }
+  const authHeader = ctx.request?.headers?.authorization ?? ctx.request?.headers?.Authorization;
+  if (typeof authHeader === "string" && authHeader.startsWith("Bearer ")) {
+    return authHeader.slice(7).trim() || void 0;
+  }
+  return void 0;
+}
+const contentApi = ({ strapi }) => {
+  const getAvailabilityService = () => strapi.plugin(PLUGIN_ID).service("availability");
+  const getReservationService = () => strapi.plugin(PLUGIN_ID).service("reservation");
+  const getSettingsService = () => strapi.plugin(PLUGIN_ID).service("settings");
+  return {
+    async listPublicResources(ctx) {
+      const limit = clampQueryLimit(ctx.query.limit, 100, 100);
+      const resources = await getAvailabilityService().listResources(
+        true,
+        limit
+      );
+      ctx.body = { data: resources.map(sanitizePublicResource) };
+    },
+    async getAvailableSlots(ctx) {
+      const now = /* @__PURE__ */ new Date();
+      const fromRaw = ctx.query.from || now.toISOString().slice(0, 10);
+      const defaultTo = new Date(now.getTime() + 14 * 864e5).toISOString().slice(0, 10);
+      const toRaw = ctx.query.to || defaultTo;
+      const fromMs = parseBoundaryMs(fromRaw, false);
+      const toMs = parseBoundaryMs(toRaw, true);
+      if (fromMs === null || toMs === null || toMs < fromMs) {
+        return ctx.badRequest("Invalid from or to date range");
+      }
+      const clampedTo = toMs - fromMs > MAX_PUBLIC_SLOTS_RANGE_MS ? new Date(fromMs + MAX_PUBLIC_SLOTS_RANGE_MS).toISOString().slice(0, 10) : toRaw;
+      let partySize = 1;
+      if (ctx.query.partySize !== void 0 && ctx.query.partySize !== "") {
+        const rawParty = ctx.query.partySize.trim();
+        if (!/^[1-9]\d*$/.test(rawParty)) {
+          return ctx.badRequest(
+            "partySize must be an integer greater than or equal to 1"
+          );
+        }
+        const parsed = Number(rawParty);
+        if (!Number.isSafeInteger(parsed) || parsed < 1) {
+          return ctx.badRequest(
+            "partySize must be an integer greater than or equal to 1"
+          );
+        }
+        partySize = parsed;
+      }
+      const limit = clampQueryLimit(ctx.query.limit, 500, 500);
+      const slots = await getAvailabilityService().getAvailableSlots({
+        resourceDocumentId: ctx.query.resourceDocumentId,
+        resourceSlug: ctx.query.resourceSlug,
+        from: fromRaw,
+        to: clampedTo,
+        partySize,
+        preferredLanguage: ctx.query.preferredLanguage,
+        referenceNow: now
+      });
+      ctx.body = { data: slots.slice(0, limit).map(sanitizePublicSlot) };
+    },
+    async createReservation(ctx) {
+      try {
+        const body = ctx.request.body ?? {};
+        const result = await getReservationService().createReservation(body, {
+          isAdmin: false,
+          referenceNow: /* @__PURE__ */ new Date()
+        });
+        ctx.body = {
+          data: {
+            booking: sanitizePublicBooking(result.booking),
+            cancelToken: result.cancelToken,
+            waitlisted: result.waitlisted
+          }
+        };
+      } catch (err) {
+        return respondPublicError(
+          ctx,
+          strapi,
+          err,
+          "Unable to complete reservation"
+        );
+      }
+    },
+    async rescheduleReservation(ctx) {
+      try {
+        const body = ctx.request.body ?? {};
+        const updated = await getReservationService().rescheduleBooking(body, {
+          isAdmin: false,
+          referenceNow: /* @__PURE__ */ new Date()
+        });
+        ctx.body = { data: sanitizePublicBooking(updated) };
+      } catch (err) {
+        return respondPublicError(
+          ctx,
+          strapi,
+          err,
+          "Unable to reschedule booking"
+        );
+      }
+    },
+    async cancelReservation(ctx) {
+      try {
+        const body = ctx.request.body ?? {};
+        const cancelled = await getReservationService().cancelBooking(body, {
+          isAdmin: false,
+          referenceNow: /* @__PURE__ */ new Date()
+        });
+        ctx.body = { data: sanitizePublicBooking(cancelled) };
+      } catch (err) {
+        return respondPublicError(ctx, strapi, err, "Unable to cancel booking");
+      }
+    },
+    async getICalFeed(ctx) {
+      const now = /* @__PURE__ */ new Date();
+      const defaultFrom = new Date(now.getTime() - 30 * 864e5).toISOString().slice(0, 10);
+      const defaultTo = new Date(now.getTime() + 180 * 864e5).toISOString().slice(0, 10);
+      const fromRaw = ctx.query.from || defaultFrom;
+      const toRaw = ctx.query.to || defaultTo;
+      const fromMs = parseBoundaryMs(fromRaw, false);
+      const toMs = parseBoundaryMs(toRaw, true);
+      if (fromMs === null || toMs === null || toMs < fromMs) {
+        return ctx.badRequest("Invalid from or to date range");
+      }
+      const clampedTo = toMs - fromMs > MAX_PUBLIC_FEED_RANGE_MS ? new Date(fromMs + MAX_PUBLIC_FEED_RANGE_MS).toISOString().slice(0, 10) : toRaw;
+      const limit = clampQueryLimit(ctx.query.limit, 250, 500);
+      const settings2 = await getSettingsService().getSettings();
+      const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+      const configuredToken = settings2.icalFeedToken ?? pluginConfig.icalFeedToken;
+      const providedToken = extractFeedTokenFromContext(ctx);
+      const authorizedFullFeed = verifySecretToken(
+        providedToken,
+        configuredToken
+      );
+      const ics = await getReservationService().exportICal(
+        {
+          from: fromRaw,
+          to: clampedTo,
+          resourceDocumentId: ctx.query.resourceDocumentId,
+          resourceSlug: ctx.query.resourceSlug,
+          status: "confirmed",
+          limit
+        },
+        { anonymize: !authorizedFullFeed }
+      );
+      ctx.set("Content-Type", "text/calendar; charset=utf-8");
+      ctx.set("Content-Disposition", 'inline; filename="bookings.ics"');
+      ctx.set("X-Content-Type-Options", "nosniff");
+      ctx.body = ics;
+    }
+  };
+};
+const controllers = {
+  admin,
+  "content-api": contentApi
+};
+const STORE_KEY = "settings";
+const runtimeSourcesByStrapi = /* @__PURE__ */ new WeakMap();
+function getRuntimeSourceMap(strapi) {
+  let map = runtimeSourcesByStrapi.get(strapi);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    runtimeSourcesByStrapi.set(strapi, map);
+  }
+  return map;
+}
+function clearRuntimeSettingsState(strapi) {
+  runtimeSourcesByStrapi.delete(strapi);
+}
+const VALID_THEMES = /* @__PURE__ */ new Set([
+  "breeze",
+  "emerald",
+  "sand",
+  "midnight",
+  "classic"
+]);
+const VALID_SECONDARY_LANGS = /* @__PURE__ */ new Set(["local", "ar", "off"]);
+const IGNORED_SYSTEM_UIDS = /* @__PURE__ */ new Set([
+  "plugin::upload.file",
+  "plugin::upload.folder",
+  "plugin::i18n.locale",
+  "plugin::content-releases.release",
+  "plugin::review-workflows.workflow"
+]);
+const BLOCKED_UID_PREFIXES = [
+  "admin::",
+  "strapi::",
+  "plugin::users-permissions."
+];
+const STRING_ATTR_TYPES = /* @__PURE__ */ new Set(["string", "text", "email", "uid"]);
+const NUMBER_ATTR_TYPES = /* @__PURE__ */ new Set([
+  "integer",
+  "biginteger",
+  "float",
+  "decimal"
+]);
+function isDiscoverableCollectionUid(uid, kind2) {
+  if (!isSafeObjectKey(uid)) return false;
+  if (kind2 && kind2 !== "collectionType") return false;
+  if (BLOCKED_UID_PREFIXES.some((prefix) => uid.startsWith(prefix))) {
+    return false;
+  }
+  return !IGNORED_SYSTEM_UIDS.has(uid);
+}
+function sanitizeSourceMapping(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const src = raw;
+  if (!isDiscoverableCollectionUid(src.uid)) {
+    return null;
+  }
+  let cleanSlotWindows;
+  if (src.slotWindows && typeof src.slotWindows === "object") {
+    cleanSlotWindows = {};
+    for (const [k, v] of Object.entries(src.slotWindows)) {
+      if (isSafeObjectKey(k) && v && typeof v.start === "string" && typeof v.end === "string") {
+        cleanSlotWindows[k] = { start: v.start, end: v.end };
+      }
+    }
+  }
+  return {
+    ...src,
+    uid: src.uid,
+    slotWindows: cleanSlotWindows
+  };
+}
+function sanitizeSourceArray(val) {
+  if (!Array.isArray(val)) return [];
+  return val.map(sanitizeSourceMapping).filter((item) => item !== null);
+}
+function asArrayOr(val, fallback) {
+  if (Array.isArray(val)) return val;
+  return Array.isArray(fallback) ? fallback : [];
+}
+function finiteIntOr(val, fallback, min, max) {
+  const num = typeof val === "number" ? val : Number(val);
+  const safe = Number.isFinite(num) ? Math.trunc(num) : fallback;
+  const clamped = Math.max(min, safe);
+  return max !== void 0 ? Math.min(max, clamped) : clamped;
+}
+function buildDefaultSlotSettings(pluginConfig) {
+  return {
+    defaultTimezone: pluginConfig.defaultTimezone ?? "UTC",
+    defaultSlotDurationMinutes: finiteIntOr(
+      pluginConfig.defaultSlotDurationMinutes,
+      60,
+      5,
+      1440
+    ),
+    defaultBufferBeforeMinutes: finiteIntOr(
+      pluginConfig.defaultBufferBeforeMinutes,
+      0,
+      0,
+      720
+    ),
+    defaultBufferAfterMinutes: finiteIntOr(
+      pluginConfig.defaultBufferAfterMinutes,
+      0,
+      0,
+      720
+    ),
+    defaultCapacityPerSlot: finiteIntOr(
+      pluginConfig.defaultCapacityPerSlot,
+      1,
+      1
+    ),
+    defaultMinLeadTimeHours: finiteIntOr(
+      pluginConfig.defaultMinLeadTimeHours,
+      2,
+      0
+    ),
+    defaultMaxAdvanceDays: finiteIntOr(
+      pluginConfig.defaultMaxAdvanceDays,
+      90,
+      1
+    )
+  };
+}
+function buildDefaultSettings(strapi) {
+  const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+  return {
+    theme: pluginConfig.theme ?? "breeze",
+    defaultLocale: pluginConfig.defaultLocale ?? "es",
+    secondaryCalendarLanguage: pluginConfig.secondaryCalendarLanguage ?? "local",
+    ...buildDefaultSlotSettings(pluginConfig),
+    defaultRequiresApproval: pluginConfig.defaultRequiresApproval ?? false,
+    sendEmailNotifications: pluginConfig.sendEmailNotifications ?? true,
+    icalFeedToken: typeof pluginConfig.icalFeedToken === "string" && pluginConfig.icalFeedToken.trim() ? pluginConfig.icalFeedToken.trim() : void 0,
+    secondaryCalendars: asArrayOr(pluginConfig.secondaryCalendars, []),
+    defaultSeasonalSchedules: asArrayOr(
+      pluginConfig.defaultSeasonalSchedules,
+      []
+    ),
+    holidays: asArrayOr(pluginConfig.holidays, []),
+    sources: sanitizeSourceArray(pluginConfig.sources)
+  };
+}
+function mergeConfiguredSources(strapi, defaults, stored) {
+  const mergedSources = /* @__PURE__ */ new Map();
+  for (const src of defaults.sources) {
+    mergedSources.set(src.uid, src);
+  }
+  for (const [uid, src] of getRuntimeSourceMap(strapi).entries()) {
+    if (isDiscoverableCollectionUid(uid)) {
+      mergedSources.set(uid, src);
+    }
+  }
+  for (const src of sanitizeSourceArray(stored?.sources)) {
+    mergedSources.set(src.uid, src);
+  }
+  return Array.from(mergedSources.values());
+}
+function resolveSlotSettings(primary, fallback) {
+  const defaultTimezone = typeof primary?.defaultTimezone === "string" && primary.defaultTimezone.trim() ? primary.defaultTimezone.trim() : fallback.defaultTimezone;
+  return {
+    defaultTimezone,
+    defaultSlotDurationMinutes: finiteIntOr(
+      primary?.defaultSlotDurationMinutes,
+      fallback.defaultSlotDurationMinutes,
+      5,
+      1440
+    ),
+    defaultBufferBeforeMinutes: finiteIntOr(
+      primary?.defaultBufferBeforeMinutes,
+      fallback.defaultBufferBeforeMinutes,
+      0,
+      720
+    ),
+    defaultBufferAfterMinutes: finiteIntOr(
+      primary?.defaultBufferAfterMinutes,
+      fallback.defaultBufferAfterMinutes,
+      0,
+      720
+    ),
+    defaultCapacityPerSlot: finiteIntOr(
+      primary?.defaultCapacityPerSlot,
+      fallback.defaultCapacityPerSlot,
+      1
+    ),
+    defaultMinLeadTimeHours: finiteIntOr(
+      primary?.defaultMinLeadTimeHours,
+      fallback.defaultMinLeadTimeHours,
+      0
+    ),
+    defaultMaxAdvanceDays: finiteIntOr(
+      primary?.defaultMaxAdvanceDays,
+      fallback.defaultMaxAdvanceDays,
+      1
+    )
+  };
+}
+function resolveUpdatedAppearance(partial, current) {
+  const theme = partial.theme && VALID_THEMES.has(partial.theme) ? partial.theme : current.theme ?? "breeze";
+  const defaultLocale = typeof partial.defaultLocale === "string" && partial.defaultLocale.trim() ? partial.defaultLocale.trim() : current.defaultLocale ?? "es";
+  const secondaryCalendarLanguage = partial.secondaryCalendarLanguage && VALID_SECONDARY_LANGS.has(partial.secondaryCalendarLanguage) ? partial.secondaryCalendarLanguage : current.secondaryCalendarLanguage ?? "local";
+  return { theme, defaultLocale, secondaryCalendarLanguage };
+}
+function classifySchemaAttributes(attributes2) {
+  const fields = [];
+  const dateFields = [];
+  const stringFields = [];
+  const numberFields = [];
+  const enumFields = [];
+  for (const [attrName, attrDef] of Object.entries(attributes2)) {
+    if (!isSafeObjectKey(attrName) || !Object.hasOwn(attributes2, attrName)) {
+      continue;
+    }
+    const attrType = String(attrDef?.type ?? "string");
+    fields.push({ name: attrName, type: attrType });
+    if (attrType === "date" || attrType === "datetime") {
+      dateFields.push(attrName);
+    } else if (STRING_ATTR_TYPES.has(attrType)) {
+      stringFields.push(attrName);
+    } else if (NUMBER_ATTR_TYPES.has(attrType)) {
+      numberFields.push(attrName);
+    } else if (attrType === "enumeration") {
+      enumFields.push(attrName);
+      stringFields.push(attrName);
+    }
+  }
+  return { fields, dateFields, stringFields, numberFields, enumFields };
+}
+const settings = ({ strapi }) => ({
+  registerSource(source) {
+    const clean = sanitizeSourceMapping(source);
+    if (!clean) return;
+    getRuntimeSourceMap(strapi).set(clean.uid, clean);
+  },
+  async getSettings() {
+    const defaults = buildDefaultSettings(strapi);
+    const store = strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID
+    });
+    const stored = await store.get({ key: STORE_KEY });
+    return {
+      theme: stored?.theme ?? defaults.theme ?? "breeze",
+      defaultLocale: stored?.defaultLocale ?? defaults.defaultLocale ?? "es",
+      secondaryCalendarLanguage: stored?.secondaryCalendarLanguage ?? defaults.secondaryCalendarLanguage ?? "local",
+      ...resolveSlotSettings(stored, defaults),
+      defaultRequiresApproval: stored?.defaultRequiresApproval ?? defaults.defaultRequiresApproval,
+      sendEmailNotifications: stored?.sendEmailNotifications ?? defaults.sendEmailNotifications,
+      icalFeedToken: typeof stored?.icalFeedToken === "string" && stored.icalFeedToken.trim() ? stored.icalFeedToken.trim() : defaults.icalFeedToken,
+      secondaryCalendars: asArrayOr(
+        stored?.secondaryCalendars,
+        defaults.secondaryCalendars
+      ),
+      defaultSeasonalSchedules: asArrayOr(
+        stored?.defaultSeasonalSchedules,
+        defaults.defaultSeasonalSchedules
+      ),
+      holidays: asArrayOr(stored?.holidays, defaults.holidays),
+      sources: mergeConfiguredSources(strapi, defaults, stored)
+    };
+  },
+  async updateSettings(partial) {
+    const current = await this.getSettings();
+    const sources = partial.sources !== void 0 ? sanitizeSourceArray(partial.sources) : current.sources;
+    const icalFeedToken = partial.icalFeedToken !== void 0 ? typeof partial.icalFeedToken === "string" && partial.icalFeedToken.trim() ? partial.icalFeedToken.trim() : void 0 : current.icalFeedToken;
+    const updated = {
+      ...resolveUpdatedAppearance(partial, current),
+      ...resolveSlotSettings(partial, current),
+      defaultRequiresApproval: typeof partial.defaultRequiresApproval === "boolean" ? partial.defaultRequiresApproval : current.defaultRequiresApproval,
+      sendEmailNotifications: typeof partial.sendEmailNotifications === "boolean" ? partial.sendEmailNotifications : current.sendEmailNotifications,
+      icalFeedToken,
+      secondaryCalendars: asArrayOr(
+        partial.secondaryCalendars,
+        current.secondaryCalendars
+      ),
+      defaultSeasonalSchedules: asArrayOr(
+        partial.defaultSeasonalSchedules,
+        current.defaultSeasonalSchedules
+      ),
+      holidays: asArrayOr(partial.holidays, current.holidays),
+      sources
+    };
+    const store = strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID
+    });
+    await store.set({
+      key: STORE_KEY,
+      value: updated
+    });
+    return updated;
+  },
+  async discoverSchemas() {
+    const contentTypes2 = strapi.contentTypes ?? {};
+    const result = [];
+    for (const [key, ct] of Object.entries(contentTypes2)) {
+      if (!isSafeObjectKey(key)) continue;
+      const uid = ct?.uid || key;
+      if (!isDiscoverableCollectionUid(uid, ct?.kind)) continue;
+      const classified = classifySchemaAttributes(ct?.attributes ?? {});
+      result.push({
+        uid,
+        displayName: ct.info?.displayName || uid,
+        singularName: ct.info?.singularName || uid,
+        pluralName: ct.info?.pluralName || uid,
+        ...classified
+      });
+    }
+    return result;
+  }
+});
+const destroy = ({ strapi }) => {
+  clearRuntimeSettingsState(strapi);
+  clearResourceLocks(strapi);
+  cleanupBootstrapState(strapi);
+};
+function mergeAttributeIntoTarget(attributes2, attrName, attrDef) {
+  if (!attributes2 || !isSafeObjectKey(attrName)) return;
+  const existing = Object.hasOwn(attributes2, attrName) ? attributes2[attrName] : void 0;
+  attributes2[attrName] = {
+    ...existing && typeof existing === "object" ? existing : {},
+    ...attrDef
+  };
+}
+const register = ({ strapi }) => {
+  const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+  if (Array.isArray(pluginConfig.customFields)) {
+    for (const field of pluginConfig.customFields) {
+      if (field?.name && isSafeObjectKey(field.name) && field?.type) {
+        strapi.customFields.register({
+          name: field.name,
+          plugin: PLUGIN_ID,
+          type: field.type
+        });
+      }
+    }
+  }
+  const contentTypes2 = strapi.contentTypes ?? {};
+  const applyExtensions = (uid, extra) => {
+    const schema = extra && typeof extra === "object" && Object.hasOwn(contentTypes2, uid) ? contentTypes2[uid] : void 0;
+    if (!schema || !extra) return;
+    for (const [attrName, attrDef] of Object.entries(extra)) {
+      if (!isSafeObjectKey(attrName) || !Object.hasOwn(extra, attrName)) {
+        continue;
+      }
+      const cleanDef = sanitizePlainRecord(attrDef);
+      if (!cleanDef) continue;
+      mergeAttributeIntoTarget(schema.attributes, attrName, cleanDef);
+      mergeAttributeIntoTarget(
+        schema.__schema__?.attributes,
+        attrName,
+        cleanDef
+      );
+    }
+  };
+  applyExtensions(
+    "plugin::bookings.resource",
+    pluginConfig.schemaExtensions?.resource
+  );
+  applyExtensions(
+    "plugin::bookings.booking",
+    pluginConfig.schemaExtensions?.booking
+  );
+};
+const READ_POLICIES = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::bookings.read"] }
+  }
+];
+const MANAGE_POLICIES = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::bookings.manage"] }
+  }
+];
+const SETTINGS_POLICIES = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::bookings.settings"] }
+  }
+];
+const adminRoutes = [
+  {
+    method: "GET",
+    path: "/settings",
+    handler: "admin.getSettings",
+    config: {
+      policies: SETTINGS_POLICIES
+    }
+  },
+  {
+    method: "PUT",
+    path: "/settings",
+    handler: "admin.updateSettings",
+    config: {
+      policies: SETTINGS_POLICIES
+    }
+  },
+  {
+    method: "GET",
+    path: "/schemas",
+    handler: "admin.discoverSchemas",
+    config: {
+      policies: SETTINGS_POLICIES
+    }
+  },
+  {
+    method: "GET",
+    path: "/resources",
+    handler: "admin.listResources",
+    config: {
+      policies: READ_POLICIES
+    }
+  },
+  {
+    method: "POST",
+    path: "/resources",
+    handler: "admin.saveResource",
+    config: {
+      policies: MANAGE_POLICIES
+    }
+  },
+  {
+    method: "GET",
+    path: "/calendar",
+    handler: "admin.getCalendar",
+    config: {
+      policies: READ_POLICIES
+    }
+  },
+  {
+    method: "POST",
+    path: "/bookings",
+    handler: "admin.createBooking",
+    config: {
+      policies: MANAGE_POLICIES
+    }
+  },
+  {
+    method: "PUT",
+    path: "/bookings/:documentId/status",
+    handler: "admin.updateBookingStatus",
+    config: {
+      policies: MANAGE_POLICIES
+    }
+  },
+  {
+    method: "POST",
+    path: "/bookings/reschedule",
+    handler: "admin.rescheduleBooking",
+    config: {
+      policies: MANAGE_POLICIES
+    }
+  },
+  {
+    method: "GET",
+    path: "/export.csv",
+    handler: "admin.exportCsv",
+    config: {
+      policies: READ_POLICIES
+    }
+  },
+  {
+    method: "GET",
+    path: "/export.ics",
+    handler: "admin.exportICal",
+    config: {
+      policies: READ_POLICIES
+    }
+  }
+];
+const contentApiRoutes = [
+  {
+    method: "GET",
+    path: "/resources",
+    handler: "content-api.listPublicResources",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/available-slots",
+    handler: "content-api.getAvailableSlots",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/reserve",
+    handler: "content-api.createReservation",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/reschedule",
+    handler: "content-api.rescheduleReservation",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/cancel",
+    handler: "content-api.cancelReservation",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/feed.ics",
+    handler: "content-api.getICalFeed",
+    config: {
+      policies: []
+    }
+  }
+];
+const routes = {
+  "admin": {
+    type: "admin",
+    routes: adminRoutes
+  },
+  "content-api": {
+    type: "content-api",
+    routes: contentApiRoutes
+  }
+};
+function trimEdgeChars(value, char) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && value[start] === char)
+    start++;
+  while (end > start && value[end - 1] === char)
+    end--;
+  return value.slice(start, end);
+}
+function slugify(input, options2 = {}) {
+  const { separator = "-", maxLength, normalization = "NFD" } = options2;
+  let text = input.toLowerCase();
+  if (normalization) {
+    text = text.normalize(normalization).replace(/[̀-ͯ]/g, "");
+  }
+  const slug = trimEdgeChars(text.replace(/[^a-z0-9]+/g, separator), separator);
+  return maxLength === void 0 ? slug : slug.slice(0, maxLength);
+}
+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)" }
+]);
+function isActiveBookingStatus(status) {
+  return status === "pending" || status === "confirmed";
+}
+function doesBookingOverlapSlot(booking, slotStartMs, slotEndMs, bufferBeforeMinutes = 0, bufferAfterMinutes = 0) {
+  if (!isActiveBookingStatus(booking.status)) return false;
+  const bStart = Date.parse(booking.startDate);
+  const bEnd = Date.parse(booking.endDate);
+  if (Number.isNaN(bStart) || Number.isNaN(bEnd)) return false;
+  return slotStartMs < bEnd + bufferAfterMinutes * 6e4 && slotEndMs > bStart - bufferBeforeMinutes * 6e4;
+}
+function selectAvailableHostsForSlot(resource, overlappingBookings, preferredLanguage) {
+  const rawHosts = Array.isArray(resource.assignedHosts) ? resource.assignedHosts : [];
+  const hosts = rawHosts.filter(
+    (h) => Boolean(h) && typeof h.id === "string" && h.id.trim().length > 0 && typeof h.name === "string" && h.name.trim().length > 0
+  );
+  if (hosts.length === 0) return [];
+  const busy = new Set(
+    overlappingBookings.map(
+      (b) => typeof b.assignedHost === "string" ? b.assignedHost.trim().toLowerCase() : ""
+    ).filter((v) => Boolean(v))
+  );
+  const freeHosts = hosts.filter(
+    (h) => !busy.has(h.id.trim().toLowerCase()) && !busy.has(h.name.trim().toLowerCase())
+  );
+  if (!preferredLanguage) return freeHosts;
+  const lang = preferredLanguage.trim().toLowerCase();
+  const matching = freeHosts.filter(
+    (h) => Array.isArray(h.languages) && h.languages.some(
+      (l) => typeof l === "string" && l.trim().toLowerCase() === lang
+    )
+  );
+  return matching.length > 0 ? matching : freeHosts;
+}
+function buildWindowCandidateBlocks(win, mode, durationMins, bufferBefore, bufferAfter, defaultCapacity) {
+  const winStartMins = parseTimeMinutes(win.start);
+  const winEndMins = parseTimeMinutes(win.end);
+  if (winEndMins <= winStartMins) return [];
+  const cap = win.capacity ?? defaultCapacity;
+  if (mode === "window") {
+    return [
+      {
+        startMins: winStartMins,
+        endMins: winEndMins,
+        label: win.label || `${win.start}-${win.end}`,
+        capacity: cap
+      }
+    ];
+  }
+  const blocks = [];
+  const stepMins = Math.max(5, durationMins + bufferBefore + bufferAfter);
+  for (let cursorMins = winStartMins; cursorMins + durationMins <= winEndMins; cursorMins += stepMins) {
+    const blockEndMins = cursorMins + durationMins;
+    const isExactMatch = Boolean(
+      win.label && winStartMins + durationMins === winEndMins
+    );
+    blocks.push({
+      startMins: cursorMins,
+      endMins: blockEndMins,
+      label: isExactMatch ? String(win.label) : `${formatTimeMinutes(cursorMins)}-${formatTimeMinutes(blockEndMins)}`,
+      capacity: cap
+    });
+  }
+  return blocks;
+}
+function evaluateCandidateBlockToSlot(block, slotStartMs, slotEndMs, dateStr, scheduleLabel, params, resourceBookings) {
+  const {
+    resource,
+    partySize = 1,
+    preferredLanguage,
+    secondaryCalendars = []
+  } = params;
+  const bufferBefore = Math.max(0, resource.bufferBeforeMinutes || 0);
+  const bufferAfter = Math.max(0, resource.bufferAfterMinutes || 0);
+  const overlapping = resourceBookings.filter(
+    (b) => doesBookingOverlapSlot(b, slotStartMs, slotEndMs, bufferBefore, bufferAfter)
+  );
+  const bookedCount = overlapping.reduce(
+    (sum, b) => sum + Math.max(1, Number(b.partySize) || 1),
+    0
+  );
+  const capacity = Math.max(1, block.capacity || resource.capacityPerSlot || 1);
+  const remainingCapacity = Math.max(0, capacity - bookedCount);
+  const maxParty = resource.maxPartySize > 0 ? Math.min(capacity, resource.maxPartySize) : capacity;
+  const validParty = typeof partySize === "number" && Number.isInteger(partySize) && partySize >= 1;
+  return {
+    slotId: `${resource.documentId}:${dateStr}:${block.label}`,
+    resourceDocumentId: resource.documentId,
+    resourceName: resource.name,
+    resourceSlug: resource.slug,
+    start: new Date(slotStartMs).toISOString(),
+    end: new Date(slotEndMs).toISOString(),
+    date: dateStr,
+    slotLabel: block.label,
+    scheduleLabel,
+    capacity,
+    bookedCount,
+    remainingCapacity,
+    isAvailable: validParty && remainingCapacity >= partySize && partySize <= maxParty,
+    availableHosts: selectAvailableHostsForSlot(
+      resource,
+      overlapping,
+      preferredLanguage
+    ),
+    secondaryDates: secondaryCalendars.length > 0 ? formatSecondaryCalendars(new Date(slotStartMs), secondaryCalendars) : void 0
+  };
+}
+function computeAvailableSlots(params) {
+  const {
+    resource,
+    from,
+    to,
+    existingBookings,
+    globalSeasonalSchedules = [],
+    globalHolidays = [],
+    referenceNow
+  } = params;
+  const timeZone = normalizeTimeZone(resource.timezone);
+  const rangeStartMs = parsePeriodTimestampInZone(from, false, timeZone);
+  const rangeEndMs = parsePeriodTimestampInZone(to, true, timeZone);
+  if (!resource.isActive || Number.isNaN(rangeStartMs) || Number.isNaN(rangeEndMs) || rangeEndMs < rangeStartMs) {
+    return [];
+  }
+  const bufferBefore = Math.max(0, resource.bufferBeforeMinutes || 0);
+  const bufferAfter = Math.max(0, resource.bufferAfterMinutes || 0);
+  const resourceBookings = existingBookings.filter(
+    (b) => b.resourceDocumentId === resource.documentId && isActiveBookingStatus(b.status)
+  );
+  const nowMs = referenceNow instanceof Date && !Number.isNaN(referenceNow.getTime()) ? referenceNow.getTime() : null;
+  const minAllowedMs = nowMs !== null ? nowMs + Math.max(0, resource.minLeadTimeHours || 0) * 36e5 : null;
+  const maxAllowedMs = nowMs !== null && resource.maxAdvanceDays > 0 ? nowMs + resource.maxAdvanceDays * 864e5 : null;
+  const blackoutDates = resource.blackoutDates ?? [];
+  const slots = [];
+  const localDates = enumerateLocalDatesInRange(
+    rangeStartMs,
+    rangeEndMs,
+    timeZone,
+    366
+  );
+  for (const { dateStr, dayKey } of localDates) {
+    const { mode, durationMins, windows, scheduleLabel } = resolveDailyScheduleForDate(
+      dateStr,
+      dayKey,
+      resource,
+      globalSeasonalSchedules,
+      globalHolidays
+    );
+    const dayBlocks = windows.flatMap(
+      (win) => buildWindowCandidateBlocks(
+        win,
+        mode,
+        durationMins,
+        bufferBefore,
+        bufferAfter,
+        resource.capacityPerSlot
+      )
+    );
+    for (const block of dayBlocks) {
+      const slotStartMs = wallClockToUtcMs(
+        dateStr,
+        block.startMins,
+        timeZone,
+        true
+      );
+      const slotEndMs = wallClockToUtcMs(
+        dateStr,
+        block.endMins,
+        timeZone,
+        false
+      );
+      if (slotStartMs === null || slotEndMs === null || slotEndMs <= slotStartMs) {
+        continue;
+      }
+      const permitted = slotEndMs > rangeStartMs && slotStartMs <= rangeEndMs && (minAllowedMs === null || slotStartMs >= minAllowedMs) && (maxAllowedMs === null || slotStartMs <= maxAllowedMs) && !isSlotBlackedOut(slotStartMs, slotEndMs, blackoutDates, timeZone);
+      if (permitted) {
+        slots.push(
+          evaluateCandidateBlockToSlot(
+            block,
+            slotStartMs,
+            slotEndMs,
+            dateStr,
+            scheduleLabel,
+            params,
+            resourceBookings
+          )
+        );
+      }
+    }
+  }
+  return slots;
+}
+const RESOURCE_UID = "plugin::bookings.resource";
+const STATUS_COLORS = {
+  confirmed: "#059669",
+  pending: "#d97706",
+  completed: "#4f46e5",
+  cancelled: "#64748b",
+  no_show: "#e11d48"
+};
+function slugifyName(value) {
+  return slugify(value, { normalization: false });
+}
+function asArray(val) {
+  return Array.isArray(val) ? val : [];
+}
+function asOptionalString(val) {
+  return val ? String(val) : void 0;
+}
+function clampNumber(val, fallback, min, max) {
+  const num = typeof val === "number" ? val : Number(val);
+  const safe = Number.isFinite(num) ? Math.trunc(num) : fallback;
+  const clampedMin = Math.max(min, safe);
+  return max !== void 0 ? Math.min(max, clampedMin) : clampedMin;
+}
+function resolveWeeklySchedule(val) {
+  if (val && typeof val === "object" && !Array.isArray(val) && "days" in val) {
+    return val;
+  }
+  return DEFAULT_WEEKLY_SCHEDULE;
+}
+function normalizeResourceLimits(raw) {
+  return {
+    slotDurationMinutes: clampNumber(raw.slotDurationMinutes, 60, 5, 1440),
+    bufferBeforeMinutes: clampNumber(raw.bufferBeforeMinutes, 0, 0, 720),
+    bufferAfterMinutes: clampNumber(raw.bufferAfterMinutes, 0, 0, 720),
+    capacityPerSlot: clampNumber(raw.capacityPerSlot, 1, 1),
+    maxPartySize: clampNumber(raw.maxPartySize, 50, 1),
+    minLeadTimeHours: clampNumber(raw.minLeadTimeHours, 2, 0),
+    maxAdvanceDays: clampNumber(raw.maxAdvanceDays, 90, 1),
+    requiresApproval: Boolean(raw.requiresApproval ?? false)
+  };
+}
+function normalizeResourceDetails(raw) {
+  const supportedLanguages = asArray(raw.supportedLanguages).map(
+    (l) => String(l)
+  );
+  const metadata = sanitizePlainRecord(raw.metadata);
+  const rawPrice = raw.price !== void 0 ? Number(raw.price) : void 0;
+  const price = rawPrice !== void 0 && Number.isFinite(rawPrice) ? Math.max(0, rawPrice) : void 0;
+  return {
+    description: asOptionalString(raw.description),
+    recurrenceRule: asOptionalString(raw.recurrenceRule),
+    supportedLanguages,
+    assignedHosts: asArray(raw.assignedHosts),
+    location: asOptionalString(raw.location),
+    price,
+    currency: raw.currency ? String(raw.currency) : "USD",
+    isActive: raw.isActive !== void 0 ? Boolean(raw.isActive) : true,
+    metadata
+  };
+}
+function normalizeResourceRecord(raw) {
+  const name = String(raw.name ?? "Unnamed Resource");
+  return {
+    documentId: String(raw.documentId ?? raw.id ?? ""),
+    name,
+    slug: String(raw.slug ?? slugifyName(String(raw.name ?? "resource"))),
+    resourceType: raw.resourceType ?? "service",
+    color: String(raw.color ?? "#0d9488"),
+    timezone: normalizeTimeZone(
+      raw.timezone !== void 0 ? String(raw.timezone) : "UTC"
+    ),
+    ...normalizeResourceLimits(raw),
+    weeklySchedule: resolveWeeklySchedule(raw.weeklySchedule),
+    seasonalSchedules: asArray(raw.seasonalSchedules),
+    holidayRules: asArray(raw.holidayRules),
+    blackoutDates: asArray(raw.blackoutDates),
+    ...normalizeResourceDetails(raw)
+  };
+}
+function buildResourceScheduleData(payload, settings2) {
+  return {
+    timezone: normalizeTimeZone(payload.timezone ?? settings2.defaultTimezone),
+    slotDurationMinutes: clampNumber(
+      payload.slotDurationMinutes,
+      settings2.defaultSlotDurationMinutes,
+      5,
+      1440
+    ),
+    bufferBeforeMinutes: clampNumber(
+      payload.bufferBeforeMinutes,
+      settings2.defaultBufferBeforeMinutes,
+      0,
+      720
+    ),
+    bufferAfterMinutes: clampNumber(
+      payload.bufferAfterMinutes,
+      settings2.defaultBufferAfterMinutes,
+      0,
+      720
+    ),
+    capacityPerSlot: clampNumber(
+      payload.capacityPerSlot,
+      settings2.defaultCapacityPerSlot,
+      1
+    ),
+    maxPartySize: clampNumber(payload.maxPartySize, 50, 1),
+    minLeadTimeHours: clampNumber(
+      payload.minLeadTimeHours,
+      settings2.defaultMinLeadTimeHours,
+      0
+    ),
+    maxAdvanceDays: clampNumber(
+      payload.maxAdvanceDays,
+      settings2.defaultMaxAdvanceDays,
+      1
+    ),
+    requiresApproval: payload.requiresApproval ?? settings2.defaultRequiresApproval
+  };
+}
+function buildResourceMetaData(payload) {
+  return {
+    name: payload.name.trim(),
+    slug: payload.slug || slugifyName(payload.name),
+    resourceType: payload.resourceType ?? "service",
+    description: payload.description ?? "",
+    color: payload.color ?? "#0d9488",
+    weeklySchedule: payload.weeklySchedule ?? DEFAULT_WEEKLY_SCHEDULE,
+    seasonalSchedules: payload.seasonalSchedules ?? [],
+    holidayRules: payload.holidayRules ?? [],
+    blackoutDates: payload.blackoutDates ?? []
+  };
+}
+function buildResourceExtrasData(payload) {
+  return {
+    recurrenceRule: payload.recurrenceRule ?? void 0,
+    supportedLanguages: payload.supportedLanguages ?? [],
+    assignedHosts: payload.assignedHosts ?? [],
+    location: payload.location ?? void 0,
+    price: payload.price ?? 0,
+    currency: payload.currency ?? "USD",
+    isActive: payload.isActive ?? true,
+    metadata: sanitizePlainRecord(payload.metadata)
+  };
+}
+function resolveOccurrenceTitle(booking) {
+  if (booking.title) return booking.title;
+  const suffix = booking.partySize > 1 ? ` (${booking.partySize})` : "";
+  return `${booking.customerName}${suffix}`;
+}
+function resolveOccurrenceStatus(status) {
+  return status === "cancelled" || status === "no_show" ? "cancelled" : "scheduled";
+}
+function mapBookingToOccurrence(booking, settings2) {
+  const secondaryDates = settings2.secondaryCalendars.length > 0 ? formatSecondaryCalendars(
+    new Date(booking.startDate),
+    settings2.secondaryCalendars
+  ) : void 0;
+  const uid = booking.sourceCollection || "plugin::bookings.booking";
+  const datePart = booking.startDate.slice(0, 10);
+  return {
+    occurrenceId: `${uid}:${booking.documentId}:${datePart}`,
+    documentId: booking.documentId,
+    uid,
+    sourceId: booking.resourceDocumentId || "bookings",
+    sourceLabel: booking.resourceName || "Bookings",
+    occurrenceDate: datePart,
+    startDate: booking.startDate,
+    endDate: booking.endDate,
+    allDay: false,
+    timezone: booking.timezone || settings2.defaultTimezone || "UTC",
+    title: resolveOccurrenceTitle(booking),
+    color: STATUS_COLORS[booking.status] || booking.resourceColor || "#0d9488",
+    category: booking.status,
+    status: resolveOccurrenceStatus(booking.status),
+    location: booking.assignedHost ? `Host: ${booking.assignedHost}` : booking.organization,
+    summary: booking.notes,
+    isRecurring: false,
+    calendarLinks: {
+      google: "",
+      outlook: "",
+      yahoo: "",
+      icsPath: `/api/bookings/feed.ics`
+    },
+    alternateDates: secondaryDates,
+    customFields: {
+      bookingCode: booking.bookingCode,
+      customerName: booking.customerName,
+      customerEmail: booking.customerEmail,
+      customerPhone: booking.customerPhone,
+      organization: booking.organization,
+      partySize: booking.partySize,
+      status: booking.status,
+      preferredLanguage: booking.preferredLanguage,
+      assignedHost: booking.assignedHost,
+      slotLabel: booking.slotLabel,
+      resourceDocumentId: booking.resourceDocumentId,
+      resourceName: booking.resourceName
+    }
+  };
+}
+const availability = ({ strapi }) => ({
+  async listResources(activeOnly = false, limit = 200) {
+    const safeLimit = clampNumber(limit, 200, 1, 500);
+    const filters = activeOnly ? { isActive: { $eq: true } } : void 0;
+    const rows = await strapi.documents(RESOURCE_UID).findMany({
+      filters,
+      sort: "name:asc",
+      limit: safeLimit
+    });
+    const normalized = (Array.isArray(rows) ? rows : []).map(
+      normalizeResourceRecord
+    );
+    const filtered = activeOnly ? normalized.filter((r) => r.isActive) : normalized;
+    return filtered.slice(0, safeLimit);
+  },
+  async getResource(idOrSlug) {
+    const trimmed = typeof idOrSlug === "string" ? idOrSlug.trim() : "";
+    if (!trimmed) return null;
+    const rows = await strapi.documents(RESOURCE_UID).findMany({
+      filters: {
+        $or: [{ documentId: { $eq: trimmed } }, { slug: { $eq: trimmed } }]
+      },
+      limit: 50
+    });
+    const normalized = (Array.isArray(rows) ? rows : []).map(
+      normalizeResourceRecord
+    );
+    const match = normalized.find(
+      (r) => r.documentId === trimmed || r.slug === trimmed
+    );
+    return match ?? null;
+  },
+  async saveResource(payload) {
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const settings2 = await settingsService.getSettings();
+    const data = {
+      ...buildResourceMetaData(payload),
+      ...buildResourceScheduleData(payload, settings2),
+      ...buildResourceExtrasData(payload)
+    };
+    if (payload.documentId) {
+      const updated = await strapi.documents(RESOURCE_UID).update({
+        documentId: payload.documentId,
+        data
+      });
+      if (!updated) {
+        throw new BookingNotFoundError("Booking resource not found");
+      }
+      return normalizeResourceRecord(updated);
+    }
+    const created = await strapi.documents(RESOURCE_UID).create({
+      data
+    });
+    return normalizeResourceRecord(created);
+  },
+  async getAvailableSlots(params) {
+    const {
+      resourceDocumentId,
+      resourceSlug,
+      from,
+      to,
+      partySize = 1,
+      preferredLanguage,
+      referenceNow
+    } = params;
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const reservationService = strapi.plugin(PLUGIN_ID).service("reservation");
+    const settings2 = await settingsService.getSettings();
+    let targetResources = [];
+    if (resourceDocumentId || resourceSlug) {
+      const single = await this.getResource(
+        resourceDocumentId || resourceSlug
+      );
+      if (single && single.isActive) {
+        targetResources = [single];
+      }
+    } else {
+      targetResources = await this.listResources(true);
+    }
+    if (targetResources.length === 0) {
+      return [];
+    }
+    const fromMs = parseBoundaryMs(from, false);
+    const toMs = parseBoundaryMs(to, true);
+    if (fromMs === null || toMs === null || toMs < fromMs) {
+      return [];
+    }
+    const existingBookings = await reservationService.listBookings({
+      from: new Date(fromMs - 864e5).toISOString(),
+      to: new Date(toMs + 864e5).toISOString(),
+      activeOnly: true,
+      limit: 1e3,
+      resourceDocumentId: targetResources.length === 1 ? targetResources[0].documentId : void 0
+    });
+    const allSlots = [];
+    for (const resource of targetResources) {
+      const resourceSlots = computeAvailableSlots({
+        resource,
+        from,
+        to,
+        existingBookings,
+        partySize,
+        preferredLanguage,
+        secondaryCalendars: settings2.secondaryCalendars,
+        globalSeasonalSchedules: settings2.defaultSeasonalSchedules,
+        globalHolidays: settings2.holidays,
+        referenceNow
+      });
+      allSlots.push(...resourceSlots);
+    }
+    return allSlots.sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
+  },
+  async getCalendarOccurrences(query) {
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const reservationService = strapi.plugin(PLUGIN_ID).service("reservation");
+    const [settings2, resources, bookings] = await Promise.all([
+      settingsService.getSettings(),
+      this.listResources(false),
+      reservationService.listBookings(query)
+    ]);
+    const occurrences = bookings.map(
+      (booking) => mapBookingToOccurrence(booking, settings2)
+    );
+    const stats = {
+      totalBookings: bookings.length,
+      confirmedBookings: bookings.filter((b) => b.status === "confirmed").length,
+      pendingBookings: bookings.filter((b) => b.status === "pending").length,
+      cancelledBookings: bookings.filter(
+        (b) => b.status === "cancelled" || b.status === "no_show"
+      ).length,
+      completedBookings: bookings.filter((b) => b.status === "completed").length,
+      totalGuests: bookings.filter((b) => b.status !== "cancelled" && b.status !== "no_show").reduce((sum, b) => sum + Math.max(1, b.partySize), 0),
+      activeResources: resources.filter((r) => r.isActive).length
+    };
+    return {
+      occurrences,
+      bookings,
+      stats
+    };
+  }
+});
+function escapeICalText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\r\n|\r|\n/g, "\\n");
+}
+function formatICalDateUtc(isoDate) {
+  const date = new Date(isoDate);
+  if (Number.isNaN(date.getTime())) {
+    return "19700101T000000Z";
+  }
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function computeFallbackOpaqueUid(seed) {
+  let h1 = 3735928559 ^ seed.length;
+  let h2 = 1103547991 ^ seed.length;
+  for (let i = 0; i < seed.length; i += 1) {
+    const ch = seed.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const hex1 = (h1 >>> 0).toString(16).padStart(8, "0");
+  const hex2 = (h2 >>> 0).toString(16).padStart(8, "0");
+  return `opaque-${hex1}${hex2}`;
+}
+function foldICalLine(line) {
+  const encoder = new TextEncoder();
+  const maxOctets = 75;
+  if (encoder.encode(line).length <= maxOctets) {
+    return line;
+  }
+  const chunks = [];
+  let current = "";
+  for (const char of line) {
+    const candidate = current + char;
+    const limit = chunks.length === 0 ? maxOctets : maxOctets - 1;
+    if (encoder.encode(candidate).length > limit) {
+      chunks.push(current);
+      current = char;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks.join("\r\n ");
+}
+function buildBookingVEventLines(booking, nowStamp, options2) {
+  const anonymize = Boolean(options2?.anonymize);
+  const dtStart = formatICalDateUtc(booking.startDate);
+  const dtEnd = formatICalDateUtc(booking.endDate);
+  const statusMap = {
+    confirmed: "CONFIRMED",
+    completed: "CONFIRMED",
+    pending: "TENTATIVE",
+    cancelled: "CANCELLED",
+    no_show: "CANCELLED"
+  };
+  const uidLocal = anonymize ? options2?.opaqueUids?.[booking.documentId] ?? computeFallbackOpaqueUid(`${booking.documentId}:${booking.startDate}`) : booking.bookingCode || booking.documentId;
+  const uid = `${uidLocal}@strapi-plugin-bookings`;
+  const summary = anonymize ? "Reserved" : booking.title || booking.customerName;
+  const descriptionParts = anonymize ? [
+    "Status: Busy",
+    ...booking.resourceName ? [`Resource: ${booking.resourceName}`] : []
+  ] : [
+    `Booking Code: ${booking.bookingCode}`,
+    `Customer: ${booking.customerName}`,
+    `Party Size: ${booking.partySize}`,
+    `Status: ${booking.status}`,
+    ...booking.resourceName ? [`Resource: ${booking.resourceName}`] : [],
+    ...booking.assignedHost ? [`Assigned Staff/Host: ${booking.assignedHost}`] : [],
+    ...booking.notes ? [`Notes: ${booking.notes}`] : []
+  ];
+  return [
+    "BEGIN:VEVENT",
+    foldICalLine(`UID:${escapeICalText(uid)}`),
+    `DTSTAMP:${nowStamp}`,
+    `DTSTART:${dtStart}`,
+    `DTEND:${dtEnd}`,
+    foldICalLine(`SUMMARY:${escapeICalText(summary)}`),
+    foldICalLine(`DESCRIPTION:${escapeICalText(descriptionParts.join("\n"))}`),
+    `STATUS:${statusMap[booking.status] || "TENTATIVE"}`,
+    "END:VEVENT"
+  ];
+}
+function generateBookingsICalFeed(bookings, calendarName = "Strapi Bookings & Reservations", options2) {
+  const nowStamp = formatICalDateUtc((/* @__PURE__ */ new Date()).toISOString());
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Vicacha Devs//Strapi Plugin Bookings//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    foldICalLine(`X-WR-CALNAME:${escapeICalText(calendarName)}`)
+  ];
+  for (const booking of bookings) {
+    lines.push(...buildBookingVEventLines(booking, nowStamp, options2));
+  }
+  lines.push("END:VCALENDAR");
+  return `${lines.join("\r\n")}\r
+`;
+}
+function sanitizeCsvCell(value) {
+  if (value === null || value === void 0) {
+    return '""';
+  }
+  let str = String(value);
+  if (/^[\s\u0085\u2028\u2029]*[=+\-@|]|^[\t\r\n]/.test(str)) {
+    str = `'${str}`;
+  }
+  const escaped = str.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+function generateBookingsCsv(bookings) {
+  const headers = [
+    "Booking Code",
+    "Resource",
+    "Customer Name",
+    "Customer Email",
+    "Customer Phone",
+    "Organization",
+    "Start Date",
+    "End Date",
+    "Slot Label",
+    "Party Size",
+    "Status",
+    "Preferred Language",
+    "Assigned Host",
+    "Notes"
+  ];
+  const rows = bookings.map(
+    (b) => [
+      b.bookingCode,
+      b.resourceName ?? "",
+      b.customerName,
+      b.customerEmail,
+      b.customerPhone ?? "",
+      b.organization ?? "",
+      b.startDate,
+      b.endDate,
+      b.slotLabel ?? "",
+      b.partySize,
+      b.status,
+      b.preferredLanguage ?? "",
+      b.assignedHost ?? "",
+      b.notes ?? ""
+    ].map(sanitizeCsvCell).join(",")
+  );
+  return [headers.map(sanitizeCsvCell).join(","), ...rows].join("\r\n");
+}
+function getValidResourceHosts(resource) {
+  if (!resource || !Array.isArray(resource.assignedHosts)) return [];
+  return resource.assignedHosts.filter(
+    (h) => Boolean(h) && typeof h.id === "string" && h.id.trim().length > 0 && typeof h.name === "string" && h.name.trim().length > 0
+  );
+}
+function findConfiguredHost(hosts, idOrName) {
+  const target = idOrName.trim().toLowerCase();
+  return hosts.find(
+    (h) => h.id.trim().toLowerCase() === target || h.name.trim().toLowerCase() === target
+  );
+}
+function isHostBusy(host, busySet) {
+  return busySet.has(host.id.trim().toLowerCase()) || busySet.has(host.name.trim().toLowerCase());
+}
+function verifySlotCapacityAndResolveHost(params) {
+  const {
+    existing,
+    startMs,
+    endMs,
+    partySize,
+    resource,
+    settings: settings2,
+    preferredLanguage,
+    explicitHostRaw,
+    isAdmin = false,
+    hostResolutionMode = "strict",
+    windowCapacityOverride,
+    excludeDocumentId
+  } = params;
+  const bufferBefore = resource?.bufferBeforeMinutes ?? settings2.defaultBufferBeforeMinutes ?? 0;
+  const bufferAfter = resource?.bufferAfterMinutes ?? settings2.defaultBufferAfterMinutes ?? 0;
+  const scopedBookings = existing.filter((b) => {
+    if (excludeDocumentId && b.documentId === excludeDocumentId) return false;
+    if (resource) return b.resourceDocumentId === resource.documentId;
+    return !b.resourceDocumentId;
+  });
+  const overlapping = scopedBookings.filter(
+    (b) => doesBookingOverlapSlot(b, startMs, endMs, bufferBefore, bufferAfter)
+  );
+  const capacity = windowCapacityOverride ?? resource?.capacityPerSlot ?? settings2.defaultCapacityPerSlot ?? 1;
+  const bookedCount = overlapping.reduce(
+    (sum, b) => sum + Math.max(1, b.partySize),
+    0
+  );
+  if (bookedCount + partySize > capacity) {
+    throw new BookingValidationError(
+      `Insufficient slot capacity: ${Math.max(0, capacity - bookedCount)} remaining, ${partySize} requested`
+    );
+  }
+  const busyHosts = new Set(
+    overlapping.map((b) => b.assignedHost?.trim().toLowerCase()).filter((v) => Boolean(v))
+  );
+  const configuredHosts = getValidResourceHosts(resource);
+  const explicitHost = trimOrUndefined(explicitHostRaw);
+  if (hostResolutionMode === "reschedule") {
+    if (explicitHost) {
+      const configured = findConfiguredHost(configuredHosts, explicitHost);
+      if (configured && !isHostBusy(configured, busyHosts)) {
+        return configured.name;
+      }
+      if (isAdmin && !configured && configuredHosts.length === 0 && !busyHosts.has(explicitHost.toLowerCase())) {
+        return explicitHost;
+      }
+    }
+    if (!resource) return void 0;
+    const fallback = selectAvailableHostsForSlot(
+      resource,
+      overlapping,
+      preferredLanguage
+    );
+    return fallback[0]?.name;
+  }
+  if (explicitHost) {
+    if (!isAdmin) {
+      if (!resource) {
+        throw new BookingValidationError(
+          "Cannot request a specific host without a target resource"
+        );
+      }
+      const freeHosts = selectAvailableHostsForSlot(resource, overlapping);
+      const matched = findConfiguredHost(freeHosts, explicitHost);
+      if (!matched) {
+        throw new BookingValidationError(
+          "Requested host is unavailable or not assigned to this resource"
+        );
+      }
+      return matched.name;
+    }
+    const configured = findConfiguredHost(configuredHosts, explicitHost);
+    if (configured) {
+      if (isHostBusy(configured, busyHosts)) {
+        throw new BookingValidationError(
+          `Assigned host '${configured.name}' is already booked for this time slot`
+        );
+      }
+      return configured.name;
+    }
+    if (busyHosts.has(explicitHost.toLowerCase())) {
+      throw new BookingValidationError(
+        `Assigned host '${explicitHost}' is already booked for this time slot`
+      );
+    }
+    return explicitHost;
+  }
+  if (!resource) return void 0;
+  const candidates = selectAvailableHostsForSlot(
+    resource,
+    overlapping,
+    preferredLanguage
+  );
+  return candidates[0]?.name;
+}
+function hasInvalidRolloverPrefix(raw) {
+  const trimmed = raw.trim();
+  return /^\d{4}-\d{2}-\d{2}/.test(trimmed) && parseIsoDateYmd(trimmed.slice(0, 10)) === null;
+}
+function parseStrictPartySize(val, defaultValue = 1) {
+  if (val === void 0) {
+    return defaultValue;
+  }
+  if (typeof val !== "number" || !Number.isInteger(val) || val < 1) {
+    throw new BookingValidationError(
+      "partySize must be an integer greater than or equal to 1"
+    );
+  }
+  return val;
+}
+function resolveEffectiveMaxPartySize(resource, settings2) {
+  const capacity = resource?.capacityPerSlot ?? settings2.defaultCapacityPerSlot ?? 1;
+  if (resource) {
+    return resource.maxPartySize > 0 ? Math.min(capacity, resource.maxPartySize) : capacity;
+  }
+  return 50;
+}
+function validateReservationCustomerAndStart(input) {
+  const customerName = trimOrUndefined(input.customerName);
+  const customerEmail = trimOrUndefined(input.customerEmail)?.toLowerCase();
+  if (!customerName) {
+    throw new BookingValidationError("customerName is required");
+  }
+  if (!customerEmail || !isValidEmail(customerEmail)) {
+    throw new BookingValidationError("A valid customerEmail is required");
+  }
+  if (typeof input.startDate !== "string" || !input.startDate.trim() || hasInvalidRolloverPrefix(input.startDate)) {
+    throw new BookingValidationError("A valid ISO startDate is required");
+  }
+  const startMs = Date.parse(input.startDate);
+  if (Number.isNaN(startMs)) {
+    throw new BookingValidationError("A valid ISO startDate is required");
+  }
+  return { customerName, customerEmail, startMs };
+}
+function resolveDefaultBookingEndMs(startMs, resource, settings2) {
+  if (!resource) {
+    const mins = settings2.defaultSlotDurationMinutes ?? 60;
+    return startMs + mins * 6e4;
+  }
+  const timeZone = normalizeTimeZone(resource.timezone);
+  const startWall = extractZonedWallClock(startMs, timeZone);
+  const schedule = resolveDailyScheduleForDate(
+    startWall.dateStr,
+    startWall.dayKey,
+    resource,
+    settings2.defaultSeasonalSchedules,
+    settings2.holidays
+  );
+  if (schedule.mode === "window") {
+    const matchingWin = schedule.windows.find(
+      (w) => parseTimeMinutes(w.start) === startWall.minutesOfDay
+    );
+    if (matchingWin) {
+      const winEndMs = wallClockToUtcMs(
+        startWall.dateStr,
+        parseTimeMinutes(matchingWin.end),
+        timeZone,
+        false
+      );
+      if (winEndMs !== null && winEndMs > startMs) {
+        return winEndMs;
+      }
+    }
+  }
+  const zonedEndMs = wallClockToUtcMs(
+    startWall.dateStr,
+    startWall.minutesOfDay + schedule.durationMins,
+    timeZone,
+    false
+  );
+  return zonedEndMs !== null && zonedEndMs > startMs ? zonedEndMs : startMs + schedule.durationMins * 6e4;
+}
+function computeReservationTimingAndParty(input, startMs, resource, settings2) {
+  if (typeof input.endDate === "string" && input.endDate.trim() && hasInvalidRolloverPrefix(input.endDate)) {
+    throw new BookingValidationError("endDate must be a valid ISO date");
+  }
+  const endMs = input.endDate ? Date.parse(input.endDate) : resolveDefaultBookingEndMs(startMs, resource, settings2);
+  if (Number.isNaN(endMs) || endMs <= startMs) {
+    throw new BookingValidationError("endDate must be after startDate");
+  }
+  const partySize = parseStrictPartySize(input.partySize, 1);
+  const maxParty = resolveEffectiveMaxPartySize(resource, settings2);
+  if (partySize > maxParty) {
+    throw new BookingValidationError(
+      `Requested partySize (${partySize}) exceeds maximum allowed (${maxParty})`
+    );
+  }
+  return { endMs, partySize };
+}
+function isNextCalendarDay(startDateStr, endDateStr) {
+  const startDayMs = Date.parse(`${startDateStr}T00:00:00.000Z`);
+  const endDayMs = Date.parse(`${endDateStr}T00:00:00.000Z`);
+  return !Number.isNaN(startDayMs) && !Number.isNaN(endDayMs) && endDayMs - startDayMs === 864e5;
+}
+function validateBookingOperatingWindow(params) {
+  const {
+    resource,
+    settings: settings2,
+    startMs,
+    endMs,
+    isAdmin = false,
+    skipLeadTimeCheck = false,
+    referenceNow
+  } = params;
+  if (!resource) return void 0;
+  const timeZone = normalizeTimeZone(resource.timezone);
+  const blackouts = resource.blackoutDates || [];
+  if (isSlotBlackedOut(startMs, endMs, blackouts, timeZone)) {
+    throw new BookingValidationError(
+      "Requested time slot falls on a blackout period"
+    );
+  }
+  if (isAdmin) {
+    return void 0;
+  }
+  if (!skipLeadTimeCheck) {
+    const now = referenceNow instanceof Date && !Number.isNaN(referenceNow.getTime()) ? referenceNow : /* @__PURE__ */ new Date();
+    const nowMs = now.getTime();
+    const minLeadMs = nowMs + Math.max(0, resource.minLeadTimeHours || 0) * 36e5;
+    if (startMs < minLeadMs) {
+      throw new BookingValidationError(
+        `Bookings require at least ${resource.minLeadTimeHours} hours advance notice`
+      );
+    }
+    if (resource.maxAdvanceDays > 0) {
+      const maxAdvanceMs = nowMs + resource.maxAdvanceDays * 864e5;
+      if (startMs > maxAdvanceMs) {
+        throw new BookingValidationError(
+          `Bookings cannot be scheduled more than ${resource.maxAdvanceDays} days in advance`
+        );
+      }
+    }
+  }
+  const startWall = extractZonedWallClock(startMs, timeZone);
+  const endWall = extractZonedWallClock(endMs, timeZone);
+  if (startWall.seconds !== 0 || startWall.ms !== 0 || endWall.seconds !== 0 || endWall.ms !== 0) {
+    throw new BookingValidationError(
+      "Booking start and end times must align to exact minute boundaries"
+    );
+  }
+  let endMinsOfStartDay = endWall.minutesOfDay;
+  if (endWall.dateStr !== startWall.dateStr) {
+    if (endWall.minutesOfDay === 0 && isNextCalendarDay(startWall.dateStr, endWall.dateStr)) {
+      endMinsOfStartDay = 1440;
+    } else {
+      throw new BookingValidationError(
+        "Booking must start and end on the same operating day"
+      );
+    }
+  }
+  const schedule = resolveDailyScheduleForDate(
+    startWall.dateStr,
+    startWall.dayKey,
+    resource,
+    settings2.defaultSeasonalSchedules,
+    settings2.holidays
+  );
+  if (schedule.windows.length === 0) {
+    throw new BookingValidationError(
+      "Requested resource is closed on the selected date"
+    );
+  }
+  const containingWindows = schedule.windows.filter((win) => {
+    const winStart = parseTimeMinutes(win.start);
+    const winEnd = parseTimeMinutes(win.end);
+    return winEnd > winStart && startWall.minutesOfDay >= winStart && endMinsOfStartDay <= winEnd;
+  });
+  if (containingWindows.length === 0) {
+    throw new BookingValidationError(
+      "Requested time slot falls outside operating hours"
+    );
+  }
+  if (schedule.mode === "window") {
+    const exactWin = containingWindows.find(
+      (win) => startWall.minutesOfDay === parseTimeMinutes(win.start) && endMinsOfStartDay === parseTimeMinutes(win.end)
+    );
+    if (!exactWin) {
+      throw new BookingValidationError(
+        "Requested time must match an exact configured booking window"
+      );
+    }
+    return exactWin.capacity;
+  }
+  const wallDurationMins = endMinsOfStartDay - startWall.minutesOfDay;
+  if (wallDurationMins > schedule.durationMins) {
+    throw new BookingValidationError(
+      `Requested booking duration exceeds maximum slot duration (${schedule.durationMins} minutes)`
+    );
+  }
+  const bufferBefore = Math.max(0, resource.bufferBeforeMinutes || 0);
+  const bufferAfter = Math.max(0, resource.bufferAfterMinutes || 0);
+  const stepMins = Math.max(
+    5,
+    schedule.durationMins + bufferBefore + bufferAfter
+  );
+  const alignedWindow = containingWindows.find((win) => {
+    const winStart = parseTimeMinutes(win.start);
+    return wallDurationMins === schedule.durationMins && (startWall.minutesOfDay - winStart) % stepMins === 0;
+  });
+  if (!alignedWindow) {
+    throw new BookingValidationError(
+      "Requested time slot must align with an exact configured interval slot"
+    );
+  }
+  return alignedWindow.capacity;
+}
+const BOOKING_UID$1 = "plugin::bookings.booking";
+function resolveBookingLockKey(resourceDocumentId) {
+  return `resource:${resourceDocumentId || "__unassigned__"}`;
+}
+async function findRawBookingOrThrow(strapi, key) {
+  const trimmedKey = trimOrUndefined(key);
+  if (!trimmedKey) {
+    throw new BookingValidationError(
+      "bookingDocumentId or bookingCode is required"
+    );
+  }
+  const rawRows = await strapi.documents(BOOKING_UID$1).findMany({
+    filters: {
+      $or: [
+        { documentId: { $eq: trimmedKey } },
+        { bookingCode: { $eq: trimmedKey } }
+      ]
+    },
+    populate: ["resource"],
+    limit: 20
+  });
+  const targetRaw = (Array.isArray(rawRows) ? rawRows : []).find(
+    (r) => String(r.documentId ?? r.id) === trimmedKey || String(r.bookingCode) === trimmedKey
+  );
+  if (!targetRaw) {
+    throw new BookingNotFoundError("Booking not found");
+  }
+  return targetRaw;
+}
+function assertBookingActiveAndNotEnded(raw, action, isAdmin, referenceNow) {
+  const currentStatus = normalizeStatus(raw.status);
+  if (currentStatus !== "pending" && currentStatus !== "confirmed") {
+    throw new BookingValidationError(
+      `Cannot ${action} a booking with status '${currentStatus}'`
+    );
+  }
+  if (!isAdmin) {
+    const now = referenceNow instanceof Date && !Number.isNaN(referenceNow.getTime()) ? referenceNow : /* @__PURE__ */ new Date();
+    const endMs = Date.parse(String(raw.endDate ?? raw.startDate ?? ""));
+    if (!Number.isNaN(endMs) && endMs <= now.getTime()) {
+      throw new BookingValidationError(
+        `Cannot ${action} a booking that has already ended`
+      );
+    }
+  }
+}
+async function executeUpdateBookingStatus(params) {
+  const { strapi, reservationService, documentId, status, options: options2 } = params;
+  const normalizedStatus = parseStrictBookingStatus(status);
+  const availabilityService = strapi.plugin(PLUGIN_ID).service("availability");
+  const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+  const [resources, settings2, initialRaw] = await Promise.all([
+    availabilityService.listResources(false),
+    settingsService.getSettings(),
+    findRawBookingOrThrow(strapi, documentId)
+  ]);
+  const resourceMap = new Map(resources.map((r) => [r.documentId, r]));
+  const initialBooking = normalizeBookingRecord(initialRaw, resourceMap);
+  const lockKey = resolveBookingLockKey(initialBooking.resourceDocumentId);
+  return withResourceLock(strapi, lockKey, async () => {
+    const freshRaw = await findRawBookingOrThrow(strapi, documentId);
+    const currentBooking = normalizeBookingRecord(freshRaw, resourceMap);
+    const prevStatus = currentBooking.status;
+    const isReactivating = (prevStatus === "cancelled" || prevStatus === "no_show") && (normalizedStatus === "confirmed" || normalizedStatus === "pending");
+    let resolvedReactivationHost;
+    if (isReactivating) {
+      const resource = currentBooking.resourceDocumentId ? resourceMap.get(currentBooking.resourceDocumentId) ?? null : null;
+      const startMs = Date.parse(currentBooking.startDate);
+      const endMs = Date.parse(currentBooking.endDate);
+      const existing = await reservationService.listBookings(
+        buildCapacityWindowQuery(resource?.documentId, startMs, endMs)
+      );
+      resolvedReactivationHost = verifySlotCapacityAndResolveHost({
+        existing,
+        startMs,
+        endMs,
+        partySize: currentBooking.partySize,
+        resource,
+        settings: settings2,
+        explicitHostRaw: options2?.assignedHost ?? currentBooking.assignedHost,
+        isAdmin: true,
+        excludeDocumentId: currentBooking.documentId
+      });
+    }
+    const data = { status: normalizedStatus };
+    if (normalizedStatus === "cancelled") {
+      data.cancelTokenHash = null;
+    }
+    if (options2?.assignedHost !== void 0) {
+      data.assignedHost = resolvedReactivationHost ?? options2.assignedHost;
+    }
+    if (options2?.internalNotes !== void 0) {
+      data.internalNotes = options2.internalNotes;
+    }
+    const updated = await strapi.documents(BOOKING_UID$1).update({
+      documentId: currentBooking.documentId,
+      data,
+      populate: ["resource"]
+    });
+    if (!updated) {
+      throw new BookingNotFoundError("Booking not found");
+    }
+    const booking = normalizeBookingRecord(
+      { ...updated, resource: updated.resource ?? freshRaw.resource },
+      resourceMap
+    );
+    strapi.eventHub?.emit(`bookings.${normalizedStatus}`, { booking });
+    return booking;
+  });
+}
+async function executeRescheduleBooking(params) {
+  const { strapi, reservationService, input, options: options2 } = params;
+  const isAdmin = Boolean(options2?.isAdmin);
+  const key = input.bookingDocumentId || input.bookingCode;
+  const availabilityService = strapi.plugin(PLUGIN_ID).service("availability");
+  const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+  const [resources, settings2, initialRaw] = await Promise.all([
+    availabilityService.listResources(false),
+    settingsService.getSettings(),
+    findRawBookingOrThrow(strapi, key)
+  ]);
+  const resourceMap = new Map(resources.map((r) => [r.documentId, r]));
+  const initialBooking = normalizeBookingRecord(initialRaw, resourceMap);
+  const lockKey = resolveBookingLockKey(initialBooking.resourceDocumentId);
+  return withResourceLock(strapi, lockKey, async () => {
+    const targetRaw = await findRawBookingOrThrow(strapi, key);
+    if (!isAdmin && !verifyCancelToken(
+      input.cancelToken,
+      String(targetRaw.cancelTokenHash ?? "")
+    )) {
+      throw new BookingForbiddenError(
+        "Invalid or missing cancelToken for rescheduling"
+      );
+    }
+    assertBookingActiveAndNotEnded(
+      targetRaw,
+      "reschedule",
+      isAdmin,
+      options2?.referenceNow
+    );
+    const { newStartMs, newEndMs } = computeRescheduleWindow(targetRaw, input);
+    const currentBooking = normalizeBookingRecord(targetRaw, resourceMap);
+    const documentId = currentBooking.documentId;
+    const resource = currentBooking.resourceDocumentId ? resourceMap.get(currentBooking.resourceDocumentId) ?? null : null;
+    if (!isAdmin && resource && !resource.isActive) {
+      throw new BookingValidationError(
+        "Requested booking resource is inactive"
+      );
+    }
+    const partySize = parseStrictPartySize(
+      input.partySize,
+      currentBooking.partySize
+    );
+    const maxParty = resolveEffectiveMaxPartySize(
+      resource,
+      settings2
+    );
+    if (partySize > maxParty) {
+      throw new BookingValidationError(
+        `Requested partySize (${partySize}) exceeds maximum allowed (${maxParty})`
+      );
+    }
+    const windowCapacityOverride = validateBookingOperatingWindow({
+      resource,
+      settings: settings2,
+      startMs: newStartMs,
+      endMs: newEndMs,
+      isAdmin,
+      referenceNow: options2?.referenceNow
+    });
+    const existing = await reservationService.listBookings(
+      buildCapacityWindowQuery(resource?.documentId, newStartMs, newEndMs)
+    );
+    const resolvedHost = verifySlotCapacityAndResolveHost({
+      existing,
+      startMs: newStartMs,
+      endMs: newEndMs,
+      partySize,
+      resource,
+      settings: settings2,
+      preferredLanguage: currentBooking.preferredLanguage,
+      explicitHostRaw: currentBooking.assignedHost,
+      isAdmin,
+      hostResolutionMode: "reschedule",
+      windowCapacityOverride,
+      excludeDocumentId: documentId
+    });
+    const updated = await strapi.documents(BOOKING_UID$1).update({
+      documentId,
+      data: {
+        startDate: new Date(newStartMs).toISOString(),
+        endDate: new Date(newEndMs).toISOString(),
+        slotLabel: input.newSlotLabel ?? currentBooking.slotLabel,
+        partySize,
+        assignedHost: resolvedHost ?? null
+      },
+      populate: ["resource"]
+    });
+    if (!updated) {
+      throw new BookingNotFoundError("Booking not found");
+    }
+    const booking = normalizeBookingRecord(
+      { ...updated, resource: updated.resource ?? targetRaw.resource },
+      resourceMap
+    );
+    strapi.eventHub?.emit("bookings.rescheduled", { booking });
+    return booking;
+  });
+}
+async function executeCancelBooking(params) {
+  const { strapi, input, options: options2 } = params;
+  const isAdmin = Boolean(options2?.isAdmin);
+  const key = input.bookingDocumentId || input.bookingCode;
+  const availabilityService = strapi.plugin(PLUGIN_ID).service("availability");
+  const [resources, initialRaw] = await Promise.all([
+    availabilityService.listResources(false),
+    findRawBookingOrThrow(strapi, key)
+  ]);
+  const resourceMap = new Map(resources.map((r) => [r.documentId, r]));
+  const initialBooking = normalizeBookingRecord(initialRaw, resourceMap);
+  const lockKey = resolveBookingLockKey(initialBooking.resourceDocumentId);
+  return withResourceLock(strapi, lockKey, async () => {
+    const targetRaw = await findRawBookingOrThrow(strapi, key);
+    if (!isAdmin && !verifyCancelToken(
+      input.cancelToken,
+      String(targetRaw.cancelTokenHash ?? "")
+    )) {
+      throw new BookingForbiddenError(
+        "Invalid or missing cancelToken for cancellation"
+      );
+    }
+    assertBookingActiveAndNotEnded(
+      targetRaw,
+      "cancel",
+      isAdmin,
+      options2?.referenceNow
+    );
+    const documentId = String(targetRaw.documentId ?? targetRaw.id);
+    const existingNotes = trimOrUndefined(targetRaw.internalNotes);
+    const reason = trimOrUndefined(input.reason);
+    const cancelNote = reason ? `Cancelled: ${reason}` : void 0;
+    const mergedNotes = cancelNote ? existingNotes ? `${existingNotes}
+${cancelNote}` : cancelNote : existingNotes;
+    const updated = await strapi.documents(BOOKING_UID$1).update({
+      documentId,
+      data: {
+        status: "cancelled",
+        cancelTokenHash: null,
+        ...mergedNotes !== void 0 ? { internalNotes: mergedNotes } : {}
+      },
+      populate: ["resource"]
+    });
+    if (!updated) {
+      throw new BookingNotFoundError("Booking not found");
+    }
+    const booking = normalizeBookingRecord(
+      { ...updated, resource: updated.resource ?? targetRaw.resource },
+      resourceMap
+    );
+    strapi.eventHub?.emit("bookings.cancelled", { booking });
+    return booking;
+  });
+}
+const BOOKING_UID = "plugin::bookings.booking";
+function buildDbBookingFilters(query) {
+  const clauses = {};
+  const fromMs = parseBoundaryMs(query.from, false);
+  const toMs = parseBoundaryMs(query.to, true);
+  if (fromMs !== null) {
+    clauses.endDate = { $gte: new Date(fromMs).toISOString() };
+  }
+  if (toMs !== null) {
+    clauses.startDate = { $lte: new Date(toMs).toISOString() };
+  }
+  if (query.activeOnly) {
+    clauses.status = { $in: ["pending", "confirmed"] };
+  } else if (query.status) {
+    clauses.status = { $eq: query.status };
+  }
+  if (query.resourceDocumentId) {
+    clauses.resource = { documentId: { $eq: query.resourceDocumentId } };
+  }
+  return Object.keys(clauses).length > 0 ? clauses : void 0;
+}
+function buildExternalDateFilters(dateField, query) {
+  if (!isSafeObjectKey(dateField)) return void 0;
+  const fromMs = parseBoundaryMs(query.from, false);
+  const toMs = parseBoundaryMs(query.to, true);
+  if (fromMs === null && toMs === null) return void 0;
+  const bounds = {};
+  if (fromMs !== null) {
+    bounds.$gte = new Date(fromMs - 864e5).toISOString().slice(0, 10);
+  }
+  if (toMs !== null) {
+    bounds.$lte = new Date(toMs + 864e5).toISOString();
+  }
+  return { [dateField]: bounds };
+}
+async function loadExternalSourceBookings(strapi, sources, query) {
+  const results = [];
+  for (const source of sources) {
+    if (!source?.enabled || !isDiscoverableCollectionUid(source.uid) || source.uid === BOOKING_UID) {
+      continue;
+    }
+    try {
+      const filters = buildExternalDateFilters(source.dateField, query);
+      const extRows = await strapi.documents(source.uid).findMany({
+        filters,
+        limit: 500
+      });
+      for (const extRow of Array.isArray(extRows) ? extRows : []) {
+        const mapped = mapExternalSourceRowToBooking(extRow, source);
+        if (mapped) results.push(mapped);
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+async function resolveTargetBookingResource(availabilityService, input, isAdmin) {
+  const key = trimOrUndefined(input.resourceDocumentId) || trimOrUndefined(input.resourceSlug);
+  if (!key) {
+    if (!isAdmin) {
+      throw new BookingValidationError(
+        "resourceDocumentId or resourceSlug is required"
+      );
+    }
+    return null;
+  }
+  const resource = await availabilityService.getResource(key);
+  if (!resource || !resource.isActive) {
+    throw new BookingNotFoundError(
+      "Requested booking resource is not found or inactive"
+    );
+  }
+  return resource;
+}
+const reservation = ({ strapi }) => ({
+  async listBookings(query = {}) {
+    const availabilityService = strapi.plugin(PLUGIN_ID).service("availability");
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const rawLimit = typeof query.limit === "number" && Number.isFinite(query.limit) ? Math.min(1e3, Math.max(1, Math.trunc(query.limit))) : 500;
+    const filters = buildDbBookingFilters(query);
+    const [resources, settings2, rawRows] = await Promise.all([
+      availabilityService.listResources(false),
+      settingsService.getSettings(),
+      strapi.documents(BOOKING_UID).findMany({
+        filters,
+        populate: ["resource"],
+        sort: "startDate:asc",
+        limit: rawLimit
+      })
+    ]);
+    const resourceMap = new Map(resources.map((res) => [res.documentId, res]));
+    const rows = Array.isArray(rawRows) ? rawRows : [];
+    const allBookings = rows.map(
+      (row) => normalizeBookingRecord(row, resourceMap)
+    );
+    const extBookings = await loadExternalSourceBookings(
+      strapi,
+      settings2.sources,
+      query
+    );
+    allBookings.push(...extBookings);
+    return filterAndSortBookings(allBookings, resources, query);
+  },
+  async getBooking(documentIdOrCode) {
+    const trimmed = trimOrUndefined(documentIdOrCode);
+    if (!trimmed) return null;
+    try {
+      const raw = await findRawBookingOrThrow(strapi, trimmed);
+      const availabilityService = strapi.plugin(PLUGIN_ID).service("availability");
+      const resources = await availabilityService.listResources(false);
+      const resourceMap = new Map(resources.map((r) => [r.documentId, r]));
+      return normalizeBookingRecord(raw, resourceMap);
+    } catch (err) {
+      if (err instanceof BookingNotFoundError) return null;
+      throw err;
+    }
+  },
+  async createReservation(input, options2) {
+    const isAdmin = Boolean(options2?.isAdmin);
+    const { customerName, customerEmail, startMs } = validateReservationCustomerAndStart(input);
+    const availabilityService = strapi.plugin(PLUGIN_ID).service("availability");
+    const settingsService = strapi.plugin(PLUGIN_ID).service("settings");
+    const settings2 = await settingsService.getSettings();
+    const resource = await resolveTargetBookingResource(
+      availabilityService,
+      input,
+      isAdmin
+    );
+    const lockKey = resolveBookingLockKey(resource?.documentId);
+    return withResourceLock(strapi, lockKey, async () => {
+      const { endMs, partySize } = computeReservationTimingAndParty(
+        input,
+        startMs,
+        resource,
+        settings2
+      );
+      const windowCapacityOverride = validateBookingOperatingWindow({
+        resource,
+        settings: settings2,
+        startMs,
+        endMs,
+        isAdmin,
+        skipLeadTimeCheck: options2?.skipLeadTimeCheck,
+        referenceNow: options2?.referenceNow
+      });
+      const existing = await this.listBookings(
+        buildCapacityWindowQuery(resource?.documentId, startMs, endMs)
+      );
+      const assignedHost = verifySlotCapacityAndResolveHost({
+        existing,
+        startMs,
+        endMs,
+        partySize,
+        resource,
+        settings: settings2,
+        preferredLanguage: input.preferredLanguage,
+        explicitHostRaw: input.assignedHost,
+        isAdmin,
+        windowCapacityOverride
+      });
+      const requiresApproval = resource?.requiresApproval ?? settings2.defaultRequiresApproval ?? false;
+      const status = requiresApproval ? "pending" : "confirmed";
+      const bookingCode = generateBookingCode(options2?.referenceNow);
+      const cancelToken = generateRawCancelToken();
+      const cancelTokenHash = hashCancelToken(cancelToken);
+      const createdRaw = await strapi.documents(BOOKING_UID).create({
+        data: buildBookingCreatePayload({
+          bookingCode,
+          customerName,
+          customerEmail,
+          startMs,
+          endMs,
+          partySize,
+          status,
+          assignedHost,
+          cancelTokenHash,
+          resource,
+          settings: settings2,
+          input
+        }),
+        populate: ["resource"]
+      });
+      const resourceMap = /* @__PURE__ */ new Map();
+      if (resource) resourceMap.set(resource.documentId, resource);
+      const booking = normalizeBookingRecord(
+        {
+          ...createdRaw,
+          resource: createdRaw.resource ?? resource?.documentId
+        },
+        resourceMap
+      );
+      strapi.eventHub?.emit("bookings.created", { booking });
+      return {
+        booking,
+        cancelToken,
+        waitlisted: false
+      };
+    });
+  },
+  async updateBookingStatus(documentId, status, options2) {
+    return executeUpdateBookingStatus({
+      strapi,
+      reservationService: this,
+      documentId,
+      status,
+      options: options2
+    });
+  },
+  async rescheduleBooking(input, options2) {
+    return executeRescheduleBooking({
+      strapi,
+      reservationService: this,
+      input,
+      options: options2
+    });
+  },
+  async cancelBooking(input, options2) {
+    return executeCancelBooking({
+      strapi,
+      input,
+      options: options2
+    });
+  },
+  async exportCsv(query = {}) {
+    const bookings = await this.listBookings(query);
+    return generateBookingsCsv(bookings);
+  },
+  async exportICal(query = {}, options2) {
+    const bookings = await this.listBookings(query);
+    if (options2?.anonymize) {
+      const opaqueUids = {};
+      for (const b of bookings) {
+        opaqueUids[b.documentId] = computeOpaqueBookingUid(b);
+      }
+      return generateBookingsICalFeed(bookings, void 0, {
+        anonymize: true,
+        opaqueUids
+      });
+    }
+    return generateBookingsICalFeed(bookings);
+  }
+});
+const services = {
+  settings,
+  availability,
+  reservation
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes
+};
+export {
+  index as default
+};