@tribe-nest/forge 3.42.1 → 3.50.0

package/src/i18n/en.json

@@ -201,23 +201,83 @@
   "forge.bundle_confirmation.view_orders": "View your orders",
   "forge.call_stage.camera_start": "Start camera",
   "forge.call_stage.camera_stop": "Stop camera",
+  "forge.call_stage.chat": "Chat",
+  "forge.call_stage.chat_empty": "No messages yet. Say hello.",
+  "forge.call_stage.chat_loading": "Opening the chat…",
+  "forge.call_stage.chat_placeholder": "Message everyone…",
+  "forge.call_stage.chat_send": "Send",
+  "forge.call_stage.chat_typing": "{name} is typing…",
+  "forge.call_stage.close_panel": "Close panel",
+  "forge.call_stage.dismiss": "Dismiss",
+  "forge.call_stage.everyone_left": "Everyone else has left the call",
+  "forge.call_stage.hand_raised_by": "{name} raised their hand",
+  "forge.call_stage.hands_raised_named": "{name} +{count}",
+  "forge.call_stage.hands_raised_open": "Raised hands: {count}. Open the people panel.",
   "forge.call_stage.head_count": "In this call: {count}",
+  "forge.call_stage.health_close": "Close call health",
+  "forge.call_stage.health_estimate": "Bandwidth estimate",
+  "forge.call_stage.health_measuring": "Measuring...",
+  "forge.call_stage.health_no_video": "No video tiles to measure.",
+  "forge.call_stage.health_sending": "Sending",
+  "forge.call_stage.health_title": "Call health",
+  "forge.call_stage.health_toggle": "Call health",
   "forge.call_stage.help_camera_stop": "It stops sending your picture: the others see your name instead. The browser keeps the camera open so that starting it again is instant and does not ask for permission a second time, which means its indicator light can stay on until you leave the call.",
   "forge.call_stage.help_camera_stop_label": "What does Stop camera do?",
+  "forge.call_stage.help_health": "Each line shows a tile: the quality asked for and the quality being received (q quarter, h half, f full), then the decoded picture. A RED line is receiving less than it asked for. The bandwidth estimate is what the server believes this connection can carry; when it sits low, every tile is kept small. Under Sending, each of your own outgoing quality layers has a score; 0 means that layer is not reaching the server at all.",
+  "forge.call_stage.help_health_label": "How do I read this?",
   "forge.call_stage.help_hear_not_see": "A tile with a name and no picture means that person has their camera off, or the call is busy enough that only the people currently speaking are sent in full. Both are normal, and their audio is unaffected.",
   "forge.call_stage.help_hear_not_see_label": "Why can I hear someone but not see them?",
+  "forge.call_stage.help_record": "Recording starts now and captures everyone in the call. It is assembled into one video after the call ends, which takes a few minutes, and then appears for the people who could join this call.",
+  "forge.call_stage.help_record_label": "Who can see the recording?",
   "forge.call_stage.help_screen": "Whatever you pick in the browser prompt, live, to everyone in the call. Your camera keeps running alongside it rather than being replaced, so people can still see you while you present.",
   "forge.call_stage.help_screen_label": "What does sharing my screen send?",
+  "forge.call_stage.hide_self_view": "Hide self view",
   "forge.call_stage.leave": "Leave",
+  "forge.call_stage.leave_recording_body": "This call is being recorded. If you leave without stopping, the recording keeps running until everybody has left.",
+  "forge.call_stage.leave_recording_cancel": "Stay on the call",
+  "forge.call_stage.leave_recording_keep": "Leave, keep recording",
+  "forge.call_stage.leave_recording_stop": "Stop recording and leave",
+  "forge.call_stage.leave_recording_title": "You are still recording",
   "forge.call_stage.listening": "(listening)",
   "forge.call_stage.lost_camera": "Your camera was turned off when the connection dropped. Start it again to be seen.",
   "forge.call_stage.lost_microphone": "Your microphone was turned off when the connection dropped. Unmute to be heard again.",
   "forge.call_stage.lost_screen": "Your screen share ended when the connection dropped. Share it again to continue.",
+  "forge.call_stage.lower_all_hands": "Lower all hands",
+  "forge.call_stage.lower_hand": "Lower hand",
+  "forge.call_stage.lower_hand_of": "Lower",
+  "forge.call_stage.many_joined": "{count} people joined or left",
   "forge.call_stage.mute": "Mute",
+  "forge.call_stage.muted_talking": "You appear to be talking while muted.",
+  "forge.call_stage.no_devices": "No devices found",
+  "forge.call_stage.page_next": "Next page",
+  "forge.call_stage.page_of": "{page} / {pages}",
+  "forge.call_stage.page_prev": "Previous page",
+  "forge.call_stage.peer_joined": "{name} joined",
+  "forge.call_stage.peer_left": "{name} left",
+  "forge.call_stage.people": "People",
+  "forge.call_stage.pick_camera": "Choose a camera",
+  "forge.call_stage.pick_microphone": "Choose a microphone",
+  "forge.call_stage.pin": "Pin this tile",
+  "forge.call_stage.prejoin_camera_off": "Your camera is off",
+  "forge.call_stage.prejoin_camera_off_toggle": "Camera off",
+  "forge.call_stage.prejoin_camera_on": "Camera on",
+  "forge.call_stage.prejoin_join": "Join the call",
+  "forge.call_stage.prejoin_mic_off": "Mic off",
+  "forge.call_stage.prejoin_mic_on": "Mic on",
+  "forge.call_stage.prejoin_permission": "The browser did not grant access to your devices:",
+  "forge.call_stage.presenting_name": "{name} is presenting",
+  "forge.call_stage.raise_hand": "Raise hand",
+  "forge.call_stage.react_to_message": "React to this message",
+  "forge.call_stage.reactions": "Send a reaction",
+  "forge.call_stage.record_start": "Record",
+  "forge.call_stage.record_stop": "Stop recording",
   "forge.call_stage.recording": "This call is being recorded",
+  "forge.call_stage.recording_live": "Recording",
   "forge.call_stage.retry": "Try again",
+  "forge.call_stage.screen_of": "{name}'s screen",
   "forge.call_stage.screen_start": "Share screen",
   "forge.call_stage.screen_stop": "Stop sharing",
+  "forge.call_stage.speaking_off_page": "Speaking: {names}",
   "forge.call_stage.status_connected": "Connected",
   "forge.call_stage.status_connecting": "Connecting to the call",
   "forge.call_stage.status_ended": "The call has ended",
@@ -231,11 +291,23 @@
   "forge.call_stage.status_reconnecting": "Connection lost, reconnecting",
   "forge.call_stage.status_reconnecting_detail": "Everyone else is still in the call.",
   "forge.call_stage.status_refused": "Could not join this call",
+  "forge.call_stage.stop_presenting": "Stop presenting",
+  "forge.call_stage.tab_chat": "Chat",
+  "forge.call_stage.tab_people": "People",
   "forge.call_stage.unmute": "Unmute",
+  "forge.call_stage.unnamed_device": "Device {number}",
+  "forge.call_stage.unpin": "Unpin this tile",
+  "forge.call_stage.view_gallery": "Gallery view",
+  "forge.call_stage.view_speaker": "Speaker view",
+  "forge.call_stage.waiting_for_others": "Waiting for others to join",
+  "forge.call_stage.waiting_for_others_detail": "You are the first one here. The call starts when somebody else arrives.",
   "forge.call_stage.you": "You",
+  "forge.call_stage.you_are_presenting": "You are presenting your screen",
+  "forge.call_stage.you_joining": "You (joining…)",
   "forge.call_stage.you_not_connected": "You (not connected yet)",
+  "forge.call_stage.you_suffix": "(you)",
   "forge.call_window.ended": "This call has ended",
-  "forge.call_window.ended_detail": "The room for this session is closed. If you think that is wrong, contact whoever you booked with.",
+  "forge.call_window.ended_detail": "The room is closed, so nobody can join it now. If you think that is wrong, ask the host.",
   "forge.call_window.not_started": "This call has not started yet",
   "forge.call_window.opens_at": "You can join from {datetime}. Come back then and this page will let you in.",
   "forge.cancellation_terms.title": "Cancellation policy",
@@ -500,6 +572,7 @@
   "forge.course_access.secure_prompt_lead": "Anyone with this link can open your course. Create an account with",
   "forge.course_access.secure_prompt_tail": "to keep it to yourself.",
   "forge.course_access.signed_in_as": "Signed in as",
+  "forge.course_calls.title": "Live calls",
   "forge.course_checkout.aria_close": "Close",
   "forge.course_checkout.back": "Back",
   "forge.course_checkout.confirm_email_placeholder": "Confirm email",

package/src/index.ts

@@ -120,6 +120,12 @@ export * from "./data/queries/useAccount";
 export * from "./data/queries/useMyTickets";
 export * from "./data/queries/usePassTransfers";
 export * from "./data/queries/useMyBookings";
+// The member's own call calendar. Beside `useMyBookings` and `useMyTickets`
+// because it answers the same shape of question: what have I got coming up
+// with this artist, and where do I go for it.
+export * from "./data/queries/useMembershipCalls";
+// The host's recording control, for ANY call: it addresses the call, not a domain.
+export * from "./data/queries/useCallRecording";
 export * from "./data/queries/useEventWaitlist";
 export * from "./data/queries/useWalletPass";
 export * from "./data/queries/useFinalize";
@@ -137,6 +143,7 @@ export * from "./data/queries/useWebsite";
 export * from "./data/queries/useWebsiteAgent";
 export * from "./data/queries/useCurrencies";
 export * from "./data/queries/useChat";
+export * from "./data/queries/useCallChat";
 export * from "./data/queries/useAnalytics";
 export * from "./data/queries/useCommunity";
 export * from "./data/queries/useReviews";

package/src/types/models.ts

@@ -1385,8 +1385,21 @@ export type CohortPageData = {
     title: string;
     description: string | null;
     order: number;
-    releaseOffsetDays: number | null;
-    releaseAt: string | null;
+    /**
+     * The drip schedule and the answer it produces. Present only on the
+     * ENROLLED read: the marketing payload gives a browser the shape of the
+     * course, and a student its calendar.
+     *
+     * Render `locked` / `unlocksAt` / `lockReason`, not the raw offset. The
+     * server computes them with the same expression the classroom uses, so a
+     * renderer that re-derives the answer from `releaseOffsetDays` will
+     * eventually disagree with the screen the student opens next.
+     */
+    releaseOffsetDays?: number | null;
+    releaseAt?: string | null;
+    locked?: boolean;
+    unlocksAt?: string | null;
+    lockReason?: "scheduled" | "cohort_not_started" | null;
     lessons?: Array<{
       id: string;
       title: string;
@@ -1402,12 +1415,21 @@ export type CohortPageData = {
     publishedAt: string | null;
     createdAt: string;
   }>;
-  sessions: Array<{
+  /**
+   * The cohort's scheduled calls. Renamed from `sessions` when
+   * `cohort_sessions` was dropped for the unified `scheduled_calls` table.
+   *
+   * Carries NO join address on purpose. The endpoint behind this payload is
+   * anonymous, so a `callPublicId` here would be a door into a live paid room.
+   * A student joins from the classroom, where they are authenticated.
+   */
+  calls: Array<{
     id: string;
     title: string;
     description: string | null;
-    scheduledAt: string;
-    durationMinutes: number;
+    startsAt: string;
+    endsAt: string;
+    timezone: string | null;
     status: string;
   }>;
   pricingPlans: Array<{
@@ -1653,6 +1675,18 @@ export type CourseAccessRecord = {
    * value as legacy (see `isLegacyCourseAccess`).
    */
   accountId?: string | null;
+  /**
+   * The cohort this enrolment is for, or `null` for a self-paced buy.
+   *
+   * Decides which MODULES the payload carries (a cohort holds its own cloned
+   * copy) and, on the client, which live calls belong on this classroom page: a
+   * student enrolled in two cohorts of one course has two grants and two
+   * classrooms, and each must show only its own sessions.
+   *
+   * Optional on the type because sites built against an older API still get
+   * payloads without the field.
+   */
+  cohortId?: string | null;
 };
 
 export type CourseLessonProgress = {
@@ -1683,6 +1717,25 @@ export type CourseModule = {
   description: string | null;
   order: number;
   lessons: CourseLesson[];
+  /**
+   * Drip state, on a cohort course. Optional because a self-paced course never
+   * carries it and every site built before drip existed predates these fields.
+   *
+   * `locked` means the module has not been released to this student yet. The
+   * server already strips `content` and `media` from a locked module's lessons,
+   * so a renderer that ignores these fields is not a content leak. It is a
+   * BROKEN SCREEN: the lessons render as normal, clickable, and open to
+   * nothing. Render the lock.
+   *
+   * `unlocksAt` is the EFFECTIVE moment, after the cohort's start date and the
+   * module's offset have been applied. It is null when the answer is not known
+   * yet, which is what `lockReason: "cohort_not_started"` means: the creator
+   * laid out the weeks before picking a start date. Say "opens when the cohort
+   * starts" there rather than showing an empty date.
+   */
+  locked?: boolean;
+  unlocksAt?: string | null;
+  lockReason?: "scheduled" | "cohort_not_started" | null;
 };
 
 export type CourseAccessCourse = {

package/src/ui/headless/memberHome/index.ts

@@ -5,3 +5,7 @@ export {
   type MemberHomeNavKey,
   type UseMemberHomeNavOptions,
 } from "./useMemberHomeNav";
+
+// The member call calendar's model. Grouping lives here so the two rendering
+// surfaces cannot disagree about which calls are "today".
+export { useMemberCalls, type MemberCalendarDay, type UseMemberCallsOptions } from "./useMemberCalls";

package/src/ui/headless/memberHome/useMemberCalls.ts

@@ -0,0 +1,150 @@
+import { useMemo, useState } from "react";
+import { useMyMembershipCalls, type MyMembershipCall } from "../../../data/queries/useMembershipCalls";
+
+/**
+ * Headless model for the member CALENDAR: a month you can page through, with
+ * upcoming calls and past ones side by side.
+ *
+ * ## Why a month and not a list
+ *
+ * A list can only ever run forwards. A member who missed Tuesday has nowhere to
+ * go looking for it, and a member wondering what is on next month cannot ask.
+ * The month is the unit people already think in for "when is that call", and
+ * paging it is what makes both directions reachable.
+ *
+ * ## The zone
+ *
+ * A call carries the creator's `timezone` when they set one. When they did not,
+ * the fallback is the VIEWER's zone rather than UTC - the instant is absolute
+ * either way, and UTC is a time nobody is in. This deliberately differs from
+ * `EventDetail`, whose UTC fallback is about a published page that must read the
+ * same to everybody who links to it; a personal calendar has every reason to be
+ * local.
+ *
+ * The GRID, though, is laid out in one zone - the viewer's - because a month has
+ * to have one shape. A call at 1am Tokyo on the 1st is on the 1st in the grid if
+ * that is where the viewer's clock puts it, and its own row still prints the
+ * creator's time.
+ */
+
+export interface MemberCalendarDay {
+  /** `YYYY-MM-DD` in the viewer's zone. Stable key for a cell. */
+  key: string;
+  date: Date;
+  /** False for the leading and trailing days that pad the grid to whole weeks. */
+  inMonth: boolean;
+  isToday: boolean;
+  isPast: boolean;
+  calls: MyMembershipCall[];
+}
+
+export interface UseMemberCallsOptions {
+  limit?: number;
+  enabled?: boolean;
+  /**
+   * Injected so a test can pin it. Not a prop anybody passes in production -
+   * "today" is genuinely now, and a stale value would mark the wrong cell.
+   */
+  now?: Date;
+  /** Monday-first. The repo's `utils/recurrence` fixes the same convention. */
+  weekStartsOn?: 0 | 1;
+  /**
+   * Narrow the month to ONE course, for a calendar rendered inside a classroom
+   * rather than in the members area.
+   *
+   * Absent on the members calendar, which is the viewer's whole schedule and
+   * must stay so. Present, the server intersects it with the audience keys it
+   * already resolved for this caller, so it can only ever remove rows.
+   */
+  courseId?: string | null;
+  /** The same, for one cohort. A student in two cohorts of one course sees only this one's sessions. */
+  cohortId?: string | null;
+}
+
+const dayKey = (date: Date): string => date.toLocaleDateString("en-CA");
+
+/** Midnight local on the first of the month `offset` months from `from`. */
+const monthStart = (from: Date, offset = 0): Date =>
+  new Date(from.getFullYear(), from.getMonth() + offset, 1);
+
+export function useMemberCalls(options: UseMemberCallsOptions = {}) {
+  const now = options.now ?? new Date();
+  const weekStartsOn = options.weekStartsOn ?? 1;
+
+  /** Which month is on screen, as an offset from the one containing `now`. */
+  const [monthOffset, setMonthOffset] = useState(0);
+  const visibleMonth = monthStart(now, monthOffset);
+
+  /**
+   * The window fetched, which is the whole GRID rather than the month.
+   *
+   * A month view shows the tail of the previous month and the head of the next,
+   * and a call in one of those cells is a real call the member can act on.
+   * Fetching only the month would render those days permanently empty, which
+   * reads as "nothing on" rather than "not asked about".
+   */
+  const gridStart = useMemo(() => {
+    const first = new Date(visibleMonth);
+    const shift = (first.getDay() - weekStartsOn + 7) % 7;
+    return new Date(first.getFullYear(), first.getMonth(), first.getDate() - shift);
+  }, [visibleMonth.getTime(), weekStartsOn]);
+
+  // Six weeks always, so the grid does not change height as you page - a layout
+  // that jumps between months is one the eye has to re-find every click.
+  const gridEnd = useMemo(
+    () => new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + 42),
+    [gridStart.getTime()],
+  );
+
+  const query = useMyMembershipCalls({
+    from: gridStart,
+    to: gridEnd,
+    limit: options.limit,
+    enabled: options.enabled,
+    courseId: options.courseId,
+    cohortId: options.cohortId,
+  });
+
+  const days: MemberCalendarDay[] = useMemo(() => {
+    const byDay = new Map<string, MyMembershipCall[]>();
+    for (const call of query.data ?? []) {
+      // Bucketed by the VIEWER's day, which is the grid's zone. See the header.
+      const key = dayKey(new Date(call.startsAt));
+      const existing = byDay.get(key);
+      if (existing) existing.push(call);
+      else byDay.set(key, [call]);
+    }
+
+    const todayKey = dayKey(now);
+    return Array.from({ length: 42 }, (_, index) => {
+      const date = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + index);
+      const key = dayKey(date);
+      return {
+        key,
+        date,
+        inMonth: date.getMonth() === visibleMonth.getMonth() && date.getFullYear() === visibleMonth.getFullYear(),
+        isToday: key === todayKey,
+        isPast: key < todayKey,
+        calls: byDay.get(key) ?? [],
+      };
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [query.data, gridStart.getTime(), visibleMonth.getTime(), now.getTime()]);
+
+  return {
+    /** 42 cells, six whole weeks. */
+    days,
+    visibleMonth,
+    monthLabel: visibleMonth.toLocaleDateString("en-US", { month: "long", year: "numeric" }),
+    /** True when the grid is showing the month `now` falls in. */
+    isCurrentMonth: monthOffset === 0,
+    goToPreviousMonth: () => setMonthOffset((offset) => offset - 1),
+    goToNextMonth: () => setMonthOffset((offset) => offset + 1),
+    goToToday: () => setMonthOffset(0),
+    /** Every call in the fetched window, chronological. Drives the list beneath the grid. */
+    calls: query.data ?? [],
+    isLoading: query.isLoading,
+    error: query.error as Error | null,
+    refetch: query.refetch,
+  };
+}

package/src/ui/headless/memberHome/useMemberHomeNav.ts

@@ -2,15 +2,16 @@ import { useMemo } from "react";
 import { useGetPostCollections } from "../../../data/queries/usePostCollections";
 import { useCommunitySpaces } from "../../../data/queries/useCommunity";
 import { useChatChannels } from "../../../data/queries/useChat";
+import { useMyMembershipCalls } from "../../../data/queries/useMembershipCalls";
 
-export type MemberHomeNavKey = "posts" | "collections" | "spaces" | "chat" | "membership";
+export type MemberHomeNavKey = "posts" | "collections" | "spaces" | "calendar" | "chat" | "membership";
 
 export interface MemberHomeNavItem {
   key: MemberHomeNavKey;
   label: string;
   /** Absolute in-site href (already run through `buildHref` when supplied). */
   href: string;
-  /** Conditional tabs (Collections/Spaces/Chat) are hidden until the profile has content for them. */
+  /** Conditional tabs (Collections/Spaces/Calendar/Chat) are hidden until the profile has content for them. */
   visible: boolean;
   /** Whether `currentPath` falls inside this tab. */
   active: boolean;
@@ -52,10 +53,29 @@ export function useMemberHomeNav(opts: UseMemberHomeNavOptions = {}) {
   const collectionsQ = useGetPostCollections({ page: 1 });
   const spacesQ = useCommunitySpaces();
   const channelsQ = useChatChannels();
+  /**
+   * Upcoming calls this member may join. Already filtered by the server against
+   * their membership, so a non-empty list IS the visibility rule - there is no
+   * second "can they get in" check to make here, and no way for the tab to
+   * appear over an empty page.
+   */
+  /**
+   * ANY call this viewer may see, ever - not just an upcoming one.
+   *
+   * The Calendar is a month you can page backwards through, so it has something
+   * to show from the moment the creator has ever run a call. Keying the tab on
+   * upcoming calls alone hid the whole history the hour the last one ended,
+   * which is precisely when somebody goes looking for the recording.
+   *
+   * `limit: 1` because this is an existence check: the calendar fetches its own
+   * window, and the answer here is only "draw the tab or not".
+   */
+  const callsQ = useMyMembershipCalls({ from: new Date(0), limit: 1 });
 
   const hasCollections = (collectionsQ.data?.data?.length ?? 0) > 0;
   const hasSpaces = (spacesQ.data?.length ?? 0) > 0;
   const hasChannels = (channelsQ.data?.length ?? 0) > 0;
+  const hasCalls = (callsQ.data?.length ?? 0) > 0;
 
   const items: MemberHomeNavItem[] = useMemo(() => {
     const isUnder = (segment: string) =>
@@ -64,19 +84,23 @@ export function useMemberHomeNav(opts: UseMemberHomeNavOptions = {}) {
       { key: "posts", label: "Posts", path: basePath, visible: true, external: false, active: currentPath === normalize(basePath) },
       { key: "collections", label: "Collections", path: `${basePath}/collections`, visible: hasCollections, external: false, active: isUnder("collections") },
       { key: "spaces", label: "Spaces", path: `${basePath}/spaces`, visible: hasSpaces, external: false, active: isUnder("spaces") },
+      // Scheduled calls. Sits above Chat because a call has a TIME on it: it is
+      // the one tab whose content stops being useful if it is found late.
+      { key: "calendar", label: "Calendar", path: `${basePath}/calendar`, visible: hasCalls, external: false, active: isUnder("calendar") },
       { key: "chat", label: "Chat", path: `${basePath}/chat`, visible: hasChannels, external: false, active: isUnder("chat") },
       { key: "membership", label: "My membership", path: membershipHref, visible: true, external: true, active: false },
     ];
     return defs.map(({ path, ...d }) => ({ ...d, href: buildHref(path) }));
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [basePath, membershipHref, currentPath, hasCollections, hasSpaces, hasChannels]);
+  }, [basePath, membershipHref, currentPath, hasCollections, hasSpaces, hasCalls, hasChannels]);
 
   return {
     items,
     /** Visible items only — what a shell actually renders. */
     visibleItems: items.filter((i) => i.visible),
     activeKey: items.find((i) => i.active)?.key ?? null,
-    /** True once the three visibility queries have settled (avoids tab flash). */
-    isReady: !collectionsQ.isLoading && !spacesQ.isLoading && !channelsQ.isLoading,
+    /** True once every visibility query has settled (avoids tab flash). */
+    isReady:
+      !collectionsQ.isLoading && !spacesQ.isLoading && !callsQ.isLoading && !channelsQ.isLoading,
   };
 }

package/src/ui/index.ts

@@ -198,6 +198,9 @@ export { ConfirmSubscription, type ConfirmSubscriptionProps } from "./styled/Con
 export { LeadMagnet, type LeadMagnetProps } from "./styled/LeadMagnet";
 export { CohortPage, type CohortPageProps } from "./styled/CohortPage";
 export { CourseAccess, type CourseAccessProps } from "./styled/CourseAccess";
+// A student's live calls, scoped to the course or cohort the page is standing
+// on. A thin wrapper over `MemberCallsCalendar`, not a second calendar.
+export { CourseCallsSection, type CourseCallsSectionProps } from "./styled/CourseCallsSection";
 
 // Films and series (Tier 2). `FilmWatch` owns the entitlement gate, the viewer
 // overlay, the episode switcher and the clock; it takes a `renderPlayer` prop