@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/client/{EventCombined.client-BWVNlXTx.mjs → EventCombined.client-a02TXUgg.mjs}

@@ -1,142 +1,14 @@
 "use client";
 import { D as clsx } from "./colorStyles-CrxJrPjJ.mjs";
-import { At as assertNever, B as formatEventPrice, G as getContainerClass, Gt as getLocalScheduleDate, H as formatEventTeacherLine, J as resolveEventLinkProps, K as groupEventsByDate, L as formatDate, M as buildEventRuntimeFilters, N as getEventRuntimeFiltersKey, Rt as buildBookingUtcDateWindow, U as formatTime, Ut as formatLocalScheduleDate, W as getCardOrientation, X as getEventAvailability, st as themeButtonClassName } from "./propsDecoder-pzBeCh14.mjs";
-import { a as EventCardClient, i as EventPaginatedListView, n as useEventPagination, o as EventFilters, r as toError, t as useEventFilters } from "./useEventFilters-DeeyGYuk.mjs";
-import { n as useBlockApi } from "./context-BImarOAq.mjs";
+import { $ as getOrderedDayNames, B as buildEventRuntimeFilters, F as calendarWindowBounds, G as getCardOrientation, I as calendarWindowMonths$1, Jt as formatLocalScheduleDate, K as getContainerClass, M as calendarMonthDate, N as calendarPageResponseError, P as calendarQueryKey, Q as getDayOfWeek, R as planCalendarMonthRanges, V as getEventRuntimeFiltersKey, X as buildCalendarViewport, Xt as getLocalScheduleDate, Y as addMonths, Z as formatDateKey, nt as isToday, q as MONTH_NAMES, rt as shiftCalendarAnchorDate, ut as themeButtonClassName } from "./propsDecoder-CY9gGEF7.mjs";
+import { a as EventCardClient, i as EventPaginatedListView, n as useEventPagination, o as EventFilters, r as toError, s as formatEventTeacherLine, t as useEventFilters } from "./useEventFilters-1a1by4c8.mjs";
+import { o as formatEventRemainingPlaces, p as isEventFull, t as formatEventPrice } from "./pricing-xj7MPZlK.mjs";
+import { a as groupEventsByDate, i as formatTime, l as resolveEventLinkProps, t as formatDate } from "./dates-DCYhZBlW.mjs";
+import { n as useBlockApi } from "./context-DBzX85Xc.mjs";
 import { t as createBodyThemePortalRoot } from "./themePortalRoot-AGs4cE7t.mjs";
 import { t as ModalShell } from "./ModalShell-CqkBvBIC.mjs";
-import React, { createContext, useCallback, useContext, useEffect, useId, useMemo, useReducer, useRef, useState } from "react";
+import React, { createContext, useCallback, useContext, useEffect, useId, useMemo, useRef, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-//#region ../calendar/src/grid.ts
-const DAY_NAMES = [
-	"Sun",
-	"Mon",
-	"Tue",
-	"Wed",
-	"Thu",
-	"Fri",
-	"Sat"
-];
-const MONTH_NAMES = [
-	"January",
-	"February",
-	"March",
-	"April",
-	"May",
-	"June",
-	"July",
-	"August",
-	"September",
-	"October",
-	"November",
-	"December"
-];
-function formatDateKey(date) {
-	return `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}`;
-}
-function isToday(date, today) {
-	return isSameCalendarDay(date, today);
-}
-function isSameCalendarDay(left, right) {
-	return left.year === right.year && left.month === right.month && left.day === right.day;
-}
-function getStartOfMonth(date) {
-	return {
-		year: date.year,
-		month: date.month,
-		day: 1
-	};
-}
-function getEndOfMonth(date) {
-	return addDays(addMonths(getStartOfMonth(date), 1), -1);
-}
-function addMonths(date, months) {
-	const target = new Date(Date.UTC(date.year, date.month - 1 + months, 1, 12));
-	const year = target.getUTCFullYear();
-	const month = target.getUTCMonth() + 1;
-	const lastDay = new Date(Date.UTC(year, month, 0, 12)).getUTCDate();
-	return {
-		year,
-		month,
-		day: Math.min(date.day, lastDay)
-	};
-}
-function addDays(date, days) {
-	const result = new Date(Date.UTC(date.year, date.month - 1, date.day + days, 12));
-	return {
-		year: result.getUTCFullYear(),
-		month: result.getUTCMonth() + 1,
-		day: result.getUTCDate()
-	};
-}
-function shiftCalendarAnchorDate(date, view, steps) {
-	return view === "week" ? addDays(date, steps * 7) : addMonths(date, steps);
-}
-function getMonthCalendarDays(year, month, startOfWeek) {
-	const firstDay = {
-		year,
-		month,
-		day: 1
-	};
-	const dayOfWeek = getDayOfWeek(firstDay);
-	const gridStart = addDays(firstDay, -(startOfWeek === "monday" ? dayOfWeek === 0 ? 6 : dayOfWeek - 1 : dayOfWeek));
-	return Array.from({ length: 42 }, (_, index) => addDays(gridStart, index));
-}
-function getWeekCalendarDays(baseDate, startOfWeek) {
-	const dayOfWeek = getDayOfWeek(baseDate);
-	const weekStart = addDays(baseDate, -(startOfWeek === "monday" ? dayOfWeek === 0 ? 6 : dayOfWeek - 1 : dayOfWeek));
-	return Array.from({ length: 7 }, (_, index) => addDays(weekStart, index));
-}
-function getDayOfWeek(date) {
-	return new Date(Date.UTC(date.year, date.month - 1, date.day, 12)).getUTCDay();
-}
-function getWeekCalendarDayTuple(baseDate, startOfWeek) {
-	const days = getWeekCalendarDays(baseDate, startOfWeek);
-	assertWeekCalendarDays(days);
-	return days;
-}
-function assertWeekCalendarDays(days) {
-	if (days.length !== 7) throw new Error("Expected exactly 7 calendar days");
-}
-function getOrderedDayNames(startOfWeek, dayNames = DAY_NAMES) {
-	if (startOfWeek === "monday") {
-		const sunday = dayNames[0] ?? "Sun";
-		return [...dayNames.slice(1), sunday];
-	}
-	return [...dayNames];
-}
-function formatCalendarTitle(viewDate, view, days, monthNames = MONTH_NAMES) {
-	if (view === "week") {
-		const weekStart = days[0];
-		const weekEnd = days[6];
-		if (weekStart === void 0 || weekEnd === void 0) return `${monthNames[viewDate.month - 1] ?? ""} ${viewDate.year}`;
-		const startMonth = monthNames[weekStart.month - 1] ?? "";
-		const endMonth = monthNames[weekEnd.month - 1] ?? "";
-		if (weekStart.month === weekEnd.month) return `${startMonth} ${weekStart.day} - ${weekEnd.day}, ${weekEnd.year}`;
-		return `${startMonth} ${weekStart.day} - ${endMonth} ${weekEnd.day}, ${weekEnd.year}`;
-	}
-	return `${monthNames[viewDate.month - 1] ?? ""} ${viewDate.year}`;
-}
-function buildCalendarViewport(input) {
-	const monthNames = input.monthNames ?? MONTH_NAMES;
-	if (input.view === "week") {
-		const days = getWeekCalendarDayTuple(input.anchorDate, input.startOfWeek);
-		return {
-			kind: "week",
-			anchorDate: input.anchorDate,
-			days,
-			title: formatCalendarTitle(input.anchorDate, "week", days, monthNames)
-		};
-	}
-	const days = getMonthCalendarDays(input.anchorDate.year, input.anchorDate.month, input.startOfWeek);
-	return {
-		kind: "month",
-		anchorDate: input.anchorDate,
-		days,
-		title: formatCalendarTitle(input.anchorDate, "month", days, monthNames)
-	};
-}
-//#endregion
 //#region ../blocks/src/system/runtime/shared/components/TabBarFragment.tsx
 function clampIndex(idx, len) {
 	if (len <= 0) return 0;
@@ -207,34 +79,126 @@ const TabBar = ({ tabs, activeTab, onTabChange, className }) => {
 };
 //#endregion
 //#region ../blocks/src/system/runtime/hooks/useCalendarEvents.state.ts
-function calendarEventCacheLoadReducer(state, action) {
-	switch (action.type) {
-		case "started": return {
-			kind: "loading",
-			scope: action.scope
-		};
-		case "succeeded": return sameCalendarLoadScope(state, action.scope) ? { kind: "idle" } : state;
-		case "failed": return sameCalendarLoadScope(state, action.scope) ? {
-			kind: "error",
-			scope: action.scope,
-			error: action.error
-		} : state;
-		default: return assertNever(action);
+function calendarMonthKey(date) {
+	return `${date.year}-${String(date.month).padStart(2, "0")}`;
+}
+function calendarWindowMonths(date, radius) {
+	const months = [];
+	for (let offset = -radius; offset <= radius; offset++) months.push(calendarMonthKey(addMonths(date, offset)));
+	return months;
+}
+function groupEvents(events, timeZone) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const key = calendarMonthKey(getLocalScheduleDate(new Date(event.startsAt), timeZone));
+		const month = grouped.get(key) ?? [];
+		if (!month.some((existing) => existing.occurrenceId === event.occurrenceId)) month.push(event);
+		grouped.set(key, month);
 	}
+	return grouped;
 }
-function projectCalendarLoadState(state, scope) {
-	if (state.kind === "idle" || !sameCalendarLoadScope(state, scope)) return { kind: "idle" };
-	return state.kind === "loading" ? { kind: "loading" } : {
-		kind: "error",
-		error: state.error
+function seedCalendarWindow(page) {
+	const request = {
+		months: calendarWindowMonths$1(page.window),
+		window: page.window
 	};
+	const applied = applyCalendarPage(startCalendarRequest(/* @__PURE__ */ new Map(), request), request, page);
+	if (page.kind === "complete") return applied;
+	return new Map([...applied].map(([key, month]) => [key, month.kind === "loading" ? {
+		kind: "partial",
+		events: month.events,
+		continuation: {
+			...request,
+			cursor: page.nextCursor
+		}
+	} : month]));
 }
-function sameCalendarLoadScope(state, scope) {
-	if (state.kind === "idle") return false;
-	return state.scope.filtersKey === scope.filtersKey && state.scope.anchorDate.year === scope.anchorDate.year && state.scope.anchorDate.month === scope.anchorDate.month && state.scope.anchorDate.day === scope.anchorDate.day;
+function planCalendarRequest(state, months, retry) {
+	const missing = months.filter((key) => {
+		const month = state.get(key);
+		return !month || month.kind === "partial" || retry && month.kind === "failed";
+	});
+	const first = missing[0];
+	if (!first) return null;
+	const month = state.get(first);
+	const continuation = month && (month.kind === "partial" || month.kind === "failed") ? month.continuation : void 0;
+	if (continuation) return {
+		...continuation,
+		months: continuation.months.filter((key) => state.get(key)?.kind !== "ready")
+	};
+	const monthWindow = planCalendarMonthRanges(missing)[0];
+	return monthWindow ? {
+		months: calendarWindowMonths$1(monthWindow),
+		"window": monthWindow
+	} : null;
 }
-function toCalendarEventCacheLoadError(error) {
-	return toError(error, "Unknown error");
+function applyCalendarPage(state, request, page) {
+	const next = new Map(state);
+	const grouped = groupEvents(page.events, page.scope.timeZone);
+	for (const key of request.months) {
+		const month = state.get(key);
+		if (month?.kind !== "loading" || month.request !== request) continue;
+		const events = [...new Map([...month.events, ...grouped.get(key) ?? []].map((event) => [event.occurrenceId, event])).values()];
+		const end = calendarWindowBounds({
+			startMonth: key,
+			endMonthExclusive: calendarMonthKey(addMonths(calendarMonthDate(key), 1))
+		}, page.scope.timeZone).endExclusive;
+		const covered = page.kind === "complete" || Date.parse(end) <= Date.parse(page.nextCursor.startsAt);
+		next.set(key, covered ? {
+			kind: "ready",
+			events
+		} : {
+			kind: "loading",
+			events,
+			request
+		});
+	}
+	return next;
+}
+function startCalendarRequest(state, request) {
+	const next = new Map(state);
+	for (const key of request.months) {
+		const month = state.get(key);
+		if (month?.kind === "loading" || month?.kind === "ready") continue;
+		next.set(key, {
+			kind: "loading",
+			request,
+			events: month?.events ?? []
+		});
+	}
+	return next;
+}
+function calendarCacheReducer(state, action) {
+	if (action.kind === "started") return startCalendarRequest(state, action.request);
+	if (action.kind === "page") return applyCalendarPage(state, action.request, action.page);
+	const next = new Map(state);
+	for (const key of action.request.months) {
+		const month = state.get(key);
+		if (month?.kind === "loading" && month.request === action.request) next.set(key, {
+			kind: "failed",
+			error: action.error,
+			events: month.events,
+			continuation: {
+				...action.request,
+				cursor: action.cursor ?? action.request.cursor
+			}
+		});
+	}
+	return next;
+}
+function selectCalendarEvents(state, months) {
+	const events = /* @__PURE__ */ new Map();
+	for (const key of months) for (const event of state.get(key)?.events ?? []) events.set(event.occurrenceId, event);
+	return [...events.values()].sort((a, b) => new Date(a.startsAt).getTime() - new Date(b.startsAt).getTime());
+}
+function projectCalendarLoadState(state, months) {
+	const entries = months.map((key) => state.get(key));
+	const failed = entries.find((entry) => entry?.kind === "failed");
+	if (failed?.kind === "failed") return {
+		kind: "error",
+		error: failed.error
+	};
+	return entries.some((entry) => !entry || entry.kind === "partial" || entry.kind === "loading") ? { kind: "loading" } : { kind: "idle" };
 }
 //#endregion
 //#region ../blocks/src/system/runtime/hooks/useCalendarEvents.ts
@@ -244,35 +208,6 @@ function toCalendarEventCacheLoadError(error) {
 * Uses the Block API Client for type-safe API calls.
 * Must be used within a BlockApiProvider.
 */
-/** Maximum events to fetch per calendar request (covers 3 months of events) */
-const CALENDAR_FETCH_LIMIT = 200;
-async function loadCalendarEventPages(loadPage, request, isCurrent) {
-	const events = [];
-	let afterStartsAt;
-	let afterId;
-	for (;;) {
-		const page = await loadPage({
-			...request,
-			afterStartsAt,
-			afterId,
-			limit: CALENDAR_FETCH_LIMIT
-		});
-		if (!isCurrent()) return null;
-		events.push(...page);
-		if (page.length < CALENDAR_FETCH_LIMIT) return events;
-		const last = page[page.length - 1];
-		if (!last) return events;
-		if (last.startsAt === afterStartsAt && last.occurrenceId === afterId) throw new Error("Calendar event pagination cursor did not advance");
-		afterStartsAt = last.startsAt;
-		afterId = last.occurrenceId;
-	}
-}
-/**
-* Generate a cache key for a month
-*/
-function getMonthKey(date) {
-	return `${date.year}-${String(date.month).padStart(2, "0")}`;
-}
 function useCalendarViewport({ view = "month", startOfWeek = "monday", initialDate }) {
 	const [viewDate, setViewDate] = useState(initialDate);
 	const viewport = useMemo(() => buildCalendarViewport({
@@ -303,179 +238,134 @@ function useCalendarViewport({ view = "month", startOfWeek = "monday", initialDa
 		}, [initialDate])
 	};
 }
-function addEventsToCalendarCache(cache, events, timeZone) {
-	for (const event of events) {
-		const monthKey = getMonthKey(getLocalScheduleDate(new Date(event.startsAt), timeZone));
-		const existing = cache.get(monthKey) ?? [];
-		if (!existing.some((cachedEvent) => cachedEvent.id === event.id)) cache.set(monthKey, [...existing, event]);
-	}
-}
-function useInitiallySeededCalendarCache(initialEvents, timeZone) {
-	const cacheRef = useRef(/* @__PURE__ */ new Map());
-	const seededRef = useRef(false);
-	if (!seededRef.current) {
-		addEventsToCalendarCache(cacheRef.current, initialEvents, timeZone);
-		seededRef.current = true;
-	}
-	return cacheRef;
-}
-function readEventsFromCalendarCache(cache, viewDate) {
-	const allEvents = [];
-	for (let offset = -1; offset <= 1; offset += 1) {
-		const monthEvents = cache.get(getMonthKey(addMonths(viewDate, offset))) ?? [];
-		allEvents.push(...monthEvents);
-	}
-	const seen = /* @__PURE__ */ new Set();
-	return allEvents.filter((event) => {
-		if (seen.has(event.id)) return false;
-		seen.add(event.id);
-		return true;
-	}).sort((left, right) => new Date(left.startsAt).getTime() - new Date(right.startsAt).getTime());
-}
 /**
-* Owns event loading and month-window caching for a supplied viewport anchor.
-* It does not decide navigation semantics or visible calendar days.
+* The reducer owns month data and request ownership. The hook only performs I/O.
+* Requests for other months remain useful until the query context changes.
 */
-function useCalendarEventCache({ viewDate, initialEvents = [], preloadMonths = 1, filters, stage, timeZone }) {
-	const { getPublicEvents } = useBlockApi();
-	const [loadState, dispatchLoadState] = useReducer(calendarEventCacheLoadReducer, { kind: "idle" });
-	const [cacheVersion, setCacheVersion] = useState(0);
-	const filtersKey = useMemo(() => getEventRuntimeFiltersKey(filters), [
-		filters?.categoryIds,
-		filters?.eventPresets,
-		filters?.eventSurface,
-		filters?.scheduleScope,
-		filters?.staffMemberId,
-		filters?.venueId
-	]);
-	const cacheRef = useInitiallySeededCalendarCache(initialEvents, timeZone);
-	const loadedMonthsRef = useRef(/* @__PURE__ */ new Set());
-	const fetchingRef = useRef(/* @__PURE__ */ new Set());
-	const requestIdRef = useRef(0);
-	const initializedFiltersKeyRef = useRef(null);
-	useEffect(() => {
-		if (initializedFiltersKeyRef.current === filtersKey) return;
-		initializedFiltersKeyRef.current = filtersKey;
-		cacheRef.current = /* @__PURE__ */ new Map();
-		loadedMonthsRef.current = /* @__PURE__ */ new Set();
-		fetchingRef.current = /* @__PURE__ */ new Set();
-		requestIdRef.current += 1;
-		addEventsToCalendarCache(cacheRef.current, initialEvents, timeZone);
-		setCacheVersion((v) => v + 1);
-	}, [
+function useCalendarEventCache({ readProfile = "listing-card", viewDate, calendarWindow, preloadMonths = 1, filters, stage, timeZone }) {
+	const { getPublicEventCalendarWindow, config } = useBlockApi();
+	const filtersKey = getEventRuntimeFiltersKey(filters);
+	const context = useMemo(() => ({
+		getPublicEventCalendarWindow,
+		filters,
+		stage,
+		timeZone,
+		key: calendarQueryKey(config.siteId ?? "", stage, {
+			...filters,
+			readProfile
+		})
+	}), [
+		getPublicEventCalendarWindow,
+		config.siteId,
 		filtersKey,
-		initialEvents,
-		timeZone
+		stage,
+		timeZone,
+		readProfile
+	]);
+	const activeContext = useRef(context);
+	activeContext.current = context;
+	const seed = () => calendarWindow?.scope.key === context.key && calendarWindow.scope.timeZone === timeZone ? seedCalendarWindow(calendarWindow) : /* @__PURE__ */ new Map();
+	const [snapshot, setSnapshot] = useState(() => ({
+		context,
+		cache: seed()
+	}));
+	if (snapshot.context !== context) setSnapshot({
+		context,
+		cache: /* @__PURE__ */ new Map()
+	});
+	const months = useMemo(() => calendarWindowMonths(viewDate, preloadMonths), [
+		viewDate.year,
+		viewDate.month,
+		preloadMonths
+	]);
+	const displayMonths = useMemo(() => calendarWindowMonths(viewDate, 1), [viewDate.year, viewDate.month]);
+	const request = useMemo(() => snapshot.context === context ? planCalendarRequest(snapshot.cache, months, false) : null, [
+		snapshot,
+		context,
+		months
 	]);
-	const fetchEventsForRange = useCallback(async (from, to, targetMonths, scope) => {
-		const monthsToFetch = targetMonths.filter((m) => !loadedMonthsRef.current.has(m) && !fetchingRef.current.has(m));
-		if (monthsToFetch.length === 0) return;
-		monthsToFetch.forEach((m) => fetchingRef.current.add(m));
-		const currentRequestId = ++requestIdRef.current;
-		dispatchLoadState({
-			type: "started",
-			scope
+	const launched = useRef(/* @__PURE__ */ new WeakSet());
+	const runRequest = useCallback(async (planned) => {
+		if (launched.current.has(planned)) return;
+		launched.current.add(planned);
+		const apply = (action) => setSnapshot((current) => current.context === context ? {
+			context,
+			cache: calendarCacheReducer(current.cache, action)
+		} : current);
+		apply({
+			kind: "started",
+			request: planned
 		});
+		let cursor = planned.cursor;
 		try {
-			const result = await loadCalendarEventPages(getPublicEvents, {
-				from,
-				to,
-				stage,
-				detailLevel: "listing",
-				eventSurface: filters?.eventSurface,
-				eventPresets: filters?.eventPresets,
-				scheduleScope: filters?.scheduleScope,
-				categoryIds: filters?.categoryIds,
-				staffMemberId: filters?.staffMemberId,
-				venueId: filters?.venueId
-			}, () => currentRequestId === requestIdRef.current);
-			if (result === null) return;
-			for (const event of result) {
-				const monthKey = getMonthKey(getLocalScheduleDate(new Date(event.startsAt), timeZone));
-				const existing = cacheRef.current.get(monthKey) || [];
-				if (!existing.some((e) => e.id === event.id)) cacheRef.current.set(monthKey, [...existing, event]);
+			while (activeContext.current === context) {
+				const page = await context.getPublicEventCalendarWindow({
+					...context.filters,
+					readProfile,
+					stage: context.stage,
+					...planned.window,
+					afterStartsAt: cursor?.startsAt,
+					afterId: cursor?.occurrenceId,
+					limit: 200
+				});
+				if (activeContext.current !== context) return;
+				const invalid = calendarPageResponseError(page, {
+					key: context.key,
+					timeZone,
+					window: planned.window,
+					cursor
+				});
+				if (invalid) throw new Error(`Invalid calendar page: ${invalid}`);
+				apply({
+					kind: "page",
+					request: planned,
+					page
+				});
+				if (page.kind === "complete") return;
+				cursor = page.nextCursor;
 			}
-			for (const month of monthsToFetch) {
-				loadedMonthsRef.current.add(month);
-				if (!cacheRef.current.has(month)) cacheRef.current.set(month, []);
-			}
-			setCacheVersion((v) => v + 1);
-			dispatchLoadState({
-				type: "succeeded",
-				scope
-			});
-		} catch (err) {
-			monthsToFetch.forEach((m) => fetchingRef.current.delete(m));
-			if (currentRequestId === requestIdRef.current) dispatchLoadState({
-				type: "failed",
-				scope,
-				error: toCalendarEventCacheLoadError(err)
-			});
-		} finally {
-			monthsToFetch.forEach((m) => fetchingRef.current.delete(m));
-		}
-	}, [
-		getPublicEvents,
-		filters?.categoryIds,
-		filters?.eventPresets,
-		filters?.eventSurface,
-		filters?.scheduleScope,
-		filters?.staffMemberId,
-		filters?.venueId,
-		stage,
-		timeZone
-	]);
-	const ensureEventsLoaded = useCallback((date) => {
-		const targetMonths = [];
-		for (let i = -preloadMonths; i <= preloadMonths; i++) {
-			const targetDate = addMonths(date, i);
-			targetMonths.push(getMonthKey(targetDate));
-		}
-		const unloadedMonths = targetMonths.filter((m) => !loadedMonthsRef.current.has(m) && !fetchingRef.current.has(m));
-		if (unloadedMonths.length > 0) {
-			const startDate = getStartOfMonth(addMonths(date, -preloadMonths));
-			const endDate = getEndOfMonth(addMonths(date, preloadMonths));
-			const range = buildBookingUtcDateWindow({
-				startDate: formatLocalScheduleDate(startDate),
-				endDate: formatLocalScheduleDate(endDate),
-				timeZone
+		} catch (error) {
+			apply({
+				kind: "failed",
+				request: planned,
+				cursor,
+				error: toError(error, "Failed to load events")
 			});
-			const scope = {
-				anchorDate: date,
-				filtersKey
-			};
-			fetchEventsForRange(range.startAt.toISOString(), (/* @__PURE__ */ new Date(range.endExclusive.getTime() - 1)).toISOString(), unloadedMonths, scope);
 		}
 	}, [
-		preloadMonths,
-		fetchEventsForRange,
-		filtersKey,
-		timeZone
+		context,
+		timeZone,
+		readProfile
 	]);
 	useEffect(() => {
-		ensureEventsLoaded(viewDate);
-	}, [viewDate, ensureEventsLoaded]);
+		if (request) runRequest(request);
+	}, [request, runRequest]);
 	const retryCurrentView = useCallback(() => {
-		ensureEventsLoaded(viewDate);
-	}, [ensureEventsLoaded, viewDate]);
+		if (snapshot.context !== context) return;
+		const retry = planCalendarRequest(snapshot.cache, months, true);
+		if (retry) runRequest(retry);
+	}, [
+		snapshot,
+		context,
+		months,
+		runRequest
+	]);
 	return {
-		events: useMemo(() => readEventsFromCalendarCache(cacheRef.current, viewDate), [viewDate, cacheVersion]),
-		loadState: projectCalendarLoadState(loadState, useMemo(() => ({
-			anchorDate: viewDate,
-			filtersKey
-		}), [filtersKey, viewDate])),
+		events: selectCalendarEvents(snapshot.cache, displayMonths),
+		loadState: projectCalendarLoadState(snapshot.cache, months),
 		retryCurrentView
 	};
 }
-function useCalendarEvents({ siteId: _siteId, initialEvents = [], view = "month", startOfWeek = "monday", preloadMonths = 1, filters, stage, calendarContext }) {
+function useCalendarEvents({ readProfile, siteId: _siteId, calendarWindow, view = "month", startOfWeek = "monday", preloadMonths = 1, filters, stage, calendarContext }) {
 	const { viewDate, viewport, goToDate, goToPrevious, goToNext, goToToday } = useCalendarViewport({
 		view,
 		startOfWeek,
 		initialDate: calendarContext.initialToday
 	});
 	const { events, loadState, retryCurrentView } = useCalendarEventCache({
+		readProfile,
 		viewDate,
-		initialEvents,
+		calendarWindow,
 		preloadMonths,
 		filters,
 		stage,
@@ -623,8 +513,8 @@ const AgendaEventCard = ({ event, showCapacity, onClick }) => {
 	const eventLinkProps = resolveEventLinkProps(event);
 	const categoryColor = event.eventCategory?.color || "rgb(var(--tb-accent))";
 	const price = formatEventPrice(event);
-	const { available, isFull } = getEventAvailability(event);
-	const capacity = showCapacity && available != null ? isFull ? "Full" : `${available} spots left` : null;
+	const capacity = showCapacity ? formatEventRemainingPlaces(event) : null;
+	const isFull = isEventFull(event);
 	const title = event.title;
 	const timeZone = event.timeZone ?? null;
 	const teacherLine = formatEventTeacherLine(event);
@@ -966,7 +856,8 @@ function toEventCombinedControllerProps(props) {
 		buttonText: props.render.display.buttonText,
 		emptyMessage: props.render.display.emptyMessage,
 		className: props.render.display.className ?? void 0,
-		calendarContext: props.render.hydration.calendarContext
+		calendarContext: props.render.hydration.calendarContext,
+		calendarWindow: props.render.hydration.calendarWindow
 	};
 }
 /**
@@ -978,7 +869,7 @@ function toEventCombinedControllerProps(props) {
 const EventCombinedClient = ({ events: initialEvents, siteId, stage, listLayout = "stack", listColumns = "3", eventsPerPage = 12, paginationAction = {
 	kind: "loadMore",
 	label: "Load more events"
-}, startOfWeek = "monday", calendarTabViews = "both", defaultCalendarView, showFilters, showCategoryFilter = "auto", showVenueFilter, showStaffFilter, eventSurface, filterEventPresets, scheduleScope, filterCategoryIds, filterStaffMemberId, filterVenueId, showVenue, showMap, showCapacity, cardRole, buttonVariant = "primary", buttonText = "Book", emptyMessage = "No upcoming events scheduled.", className, calendarContext }) => {
+}, startOfWeek = "monday", calendarTabViews = "both", defaultCalendarView, showFilters, showCategoryFilter = "auto", showVenueFilter, showStaffFilter, eventSurface, filterEventPresets, scheduleScope, filterCategoryIds, filterStaffMemberId, filterVenueId, showVenue, showMap, showCapacity, cardRole, buttonVariant = "primary", buttonText = "Book", emptyMessage = "No upcoming events scheduled.", className, calendarContext, calendarWindow }) => {
 	const fetchInitialEventsOnMount = initialEvents == null;
 	const resolvedShowFilters = showFilters ?? true;
 	const resolvedShowVenueFilter = showVenueFilter ?? false;
@@ -1038,19 +929,13 @@ const EventCombinedClient = ({ events: initialEvents, siteId, stage, listLayout
 	});
 	const { events: calendarEventsRaw, viewDate, viewport, loadState: calendarLoadState, goToPrevious, goToNext, goToToday } = useCalendarEvents({
 		siteId,
-		initialEvents: useMemo(() => {
-			return getEventRuntimeFiltersKey(initialListFilters) === getEventRuntimeFiltersKey(listFilters) ? initialEvents ?? [] : [];
-		}, [
-			initialEvents,
-			initialListFilters,
-			listFilters
-		]),
 		view: calendarView,
 		startOfWeek,
 		preloadMonths: 1,
 		filters: listFilters,
 		stage,
-		calendarContext
+		calendarContext,
+		calendarWindow
 	});
 	const eventsByDate = useMemo(() => groupEventsByDate(calendarEventsRaw, calendarContext.timeZone), [calendarContext.timeZone, calendarEventsRaw]);
 	const dayNames = useMemo(() => getOrderedDayNames(startOfWeek), [startOfWeek]);
@@ -1233,4 +1118,4 @@ const EventCombinedClient = ({ events: initialEvents, siteId, stage, listLayout
 };
 const EventCombinedIslandClient = (props) => /* @__PURE__ */ jsx(EventCombinedClient, { ...toEventCombinedControllerProps(props) });
 //#endregion
-export { CalendarDayCell as a, useCalendarEvents as c, formatDateKey as d, getDayOfWeek as f, isToday as g, isSameCalendarDay as h, WeekAgendaView as i, MONTH_NAMES as l, getWeekCalendarDays as m, EventCombinedIslandClient as n, EventModalProvider as o, getOrderedDayNames as p, EventModals as r, useEventModal as s, EventCombinedClient as t, addDays as u };
+export { CalendarDayCell as a, useCalendarEvents as c, WeekAgendaView as i, EventCombinedIslandClient as n, EventModalProvider as o, EventModals as r, useEventModal as s, EventCombinedClient as t };