@tribe-nest/forge 3.42.1 → 3.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tribe-nest/forge",
-  "version": "3.42.1",
+  "version": "3.50.0",
   "publishConfig": {
     "access": "public"
   },
@@ -31,7 +31,7 @@
     "@stripe/react-stripe-js": "^3.8.0",
     "@stripe/stripe-js": "^7.6.1",
     "@tanstack/react-query": "^5.62.7",
-    "@tribe-nest/media-client": "^0.2.1",
+    "@tribe-nest/media-client": "^0.4.0",
     "@tribe-nest/media-protocol": "^1.0.0",
     "axios": "^1.7.9",
     "lucide-react": "^0.510.0",

package/src/data/queries/useCallChat.ts

@@ -0,0 +1,162 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+import type { CallChatMessage, CallStageChat } from "../../ui/media/callChat";
+import { usePublicAuth } from "../../contexts/PublicAuthContext";
+import { useForge } from "../../provider/ForgeProvider";
+import { useChatSocket, type ChatMessage } from "./useChat";
+
+/**
+ * The PUBLIC lane's `CallStageChat` adapter: the reference implementation of
+ * the shape the stage renders.
+ *
+ * One GET to the CALL's address (`/video-calls/:id/chat`) resolves the seat
+ * and the channel in one move; everything after that is the ordinary chat
+ * socket. Admin composes its own adapter against the dashboard lane; the
+ * SHAPE is the seam, so neither surface knows how the other authenticates.
+ */
+
+type CallChatChannel = { channelId: string; role: string; title: string; unreadCount: number };
+
+type ReactionRow = { emoji: string; count: number; reactedByMe: boolean };
+type MessageWithReactions = ChatMessage & { reactions?: ReactionRow[] };
+
+const senderName = (message: MessageWithReactions): string =>
+  [message.senderFirstName, message.senderLastName].filter(Boolean).join(" ").trim() || message.senderAccountId;
+
+export function useCallChat(callId: string | undefined): CallStageChat | undefined {
+  const { client, profileId } = useForge();
+  const { user } = usePublicAuth();
+  const queryClient = useQueryClient();
+  const socket = useChatSocket(!!callId);
+  const [typingNames, setTypingNames] = useState<readonly string[]>([]);
+  const typingTimer = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+
+  const channelQuery = useQuery<CallChatChannel>({
+    queryKey: ["call-chat-channel", callId],
+    queryFn: async () => {
+      const res = await client.get(`/video-calls/${callId}/chat`);
+      return res.data;
+    },
+    enabled: !!callId && !!client,
+  });
+  const channelId = channelQuery.data?.channelId;
+
+  const messagesKey = useMemo(() => ["call-chat-messages", channelId] as const, [channelId]);
+  const messagesQuery = useQuery<MessageWithReactions[]>({
+    queryKey: messagesKey,
+    queryFn: async () => {
+      // The schema wants a profileId like every member-lane read; ACCESS is
+      // the seat's (`canAccessChannel`), so the value only satisfies zod.
+      const res = await client.get(`/public/chat/channels/${channelId}/messages`, {
+        params: { profileId, page: 1, limit: 100 },
+      });
+      // The endpoint answers newest first; the panel renders oldest first.
+      return [...(res.data.data as MessageWithReactions[])].reverse();
+    },
+    enabled: !!channelId && !!client,
+  });
+
+  // Join the socket room and follow it: new messages append, reactions
+  // replace one message's aggregate, typing decays after two seconds.
+  useEffect(() => {
+    if (!socket || !channelId) return undefined;
+    socket.emit("chatJoinChannel", { channelId });
+
+    const onMessage = (envelope: { event: string; data: Record<string, unknown> }) => {
+      if ((envelope.data as { channelId?: string }).channelId !== channelId) return;
+      if (envelope.event === "chatNewMessage") {
+        const message = envelope.data.message as MessageWithReactions | undefined;
+        if (!message || message.parentMessageId) return;
+        queryClient.setQueryData<MessageWithReactions[]>(messagesKey, (current = []) =>
+          current.some((m) => m.id === message.id) ? current : [...current, message],
+        );
+        return;
+      }
+      if (envelope.event === "chatMessageReaction") {
+        const { messageId, reactions, accountId, emoji, action } = envelope.data as {
+          messageId: string;
+          reactions: ReactionRow[];
+          accountId: string;
+          emoji: string;
+          action: "added" | "removed";
+        };
+        queryClient.setQueryData<MessageWithReactions[]>(messagesKey, (current = []) =>
+          current.map((message) => {
+            if (message.id !== messageId) return message;
+            // The broadcast aggregate is neutral; our OWN toggle is folded
+            // back in so reactedByMe stays true across everyone's updates.
+            const mine = accountId === user?.id;
+            return {
+              ...message,
+              reactions: reactions.map((row) => ({
+                ...row,
+                reactedByMe:
+                  (mine && row.emoji === emoji && action === "added") ||
+                  (!(mine && row.emoji === emoji && action === "removed") &&
+                    (message.reactions?.find((r) => r.emoji === row.emoji)?.reactedByMe ?? false)),
+              })),
+            };
+          }),
+        );
+        return;
+      }
+      if (envelope.event === "chatUserTyping") {
+        const { accountId, name } = envelope.data as { accountId: string; name: string };
+        if (accountId === user?.id) return;
+        setTypingNames([name]);
+        if (typingTimer.current) clearTimeout(typingTimer.current);
+        typingTimer.current = setTimeout(() => setTypingNames([]), 2000);
+      }
+    };
+
+    socket.on("message", onMessage);
+    return () => {
+      socket.off("message", onMessage);
+      socket.emit("chatLeaveChannel", { channelId });
+      if (typingTimer.current) clearTimeout(typingTimer.current);
+    };
+  }, [socket, channelId, messagesKey, queryClient, user?.id]);
+
+  const sendMessage = useCallback(
+    (text: string) => {
+      if (!socket || !channelId) return;
+      socket.emit("chatSendMessage", { channelId, content: text });
+    },
+    [socket, channelId],
+  );
+
+  const reactToMessage = useCallback(
+    (messageId: string, emoji: string) => {
+      if (!socket || !channelId) return;
+      socket.emit("chatReactMessage", { channelId, messageId, emoji });
+    },
+    [socket, channelId],
+  );
+
+  const onTyping = useCallback(() => {
+    if (!socket || !channelId) return;
+    socket.emit("chatTyping", { channelId });
+  }, [socket, channelId]);
+
+  return useMemo<CallStageChat | undefined>(() => {
+    if (!callId) return undefined;
+    const messages: CallChatMessage[] = (messagesQuery.data ?? []).map((message) => ({
+      id: message.id,
+      content: message.content,
+      senderName: senderName(message),
+      senderKey: message.senderAccountId,
+      at: message.createdAt,
+      reactions: message.reactions ?? [],
+    }));
+    return {
+      ready: !!channelId && !messagesQuery.isLoading,
+      messages,
+      sendMessage,
+      reactToMessage,
+      typingNames,
+      onTyping,
+      currentSenderKey: user?.id ?? null,
+    };
+  }, [callId, channelId, messagesQuery.data, messagesQuery.isLoading, sendMessage, reactToMessage, typingNames, onTyping, user?.id]);
+}

package/src/data/queries/useCallRecording.ts

@@ -0,0 +1,80 @@
+import { useCallback, useState } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useForge } from "../../provider/ForgeProvider";
+
+/**
+ * The host's recording control for ONE call, whatever that call is attached to.
+ *
+ * Recording lives on the call address (`/video-calls/:publicId`), not on any
+ * domain, because a coaching booking, a consultation and a scheduled call all
+ * reach the same screen and `call_recordings` is keyed on the media room. So
+ * this hook works for every kind of call there will ever be, and nothing here
+ * knows what a membership or a cohort is.
+ *
+ * ## What the server owns
+ *
+ * - **Whether this viewer may control it.** `canControl` comes back from the
+ *   call read and is a RENDERING hint; the server resolves the seat again on
+ *   every start and stop and is what actually refuses. A non-host asking gets
+ *   the same 404 every other refusal on this address gives.
+ * - **Deduplication.** A second start returns `already_recording` rather than an
+ *   error, and two hosts pressing Record in the same instant are settled by a
+ *   unique index. So this does not need to guard against double-clicks for
+ *   correctness - `pending` is only so the button does not look dead.
+ */
+
+export type CallRecordingState = {
+  /** `recording` while the egress runs, `processing` while it is composed, else null. */
+  status: "recording" | "processing" | null;
+  isRecording: boolean;
+  startedAt: string | null;
+  canControl: boolean;
+};
+
+export function useCallRecording(callPublicId: string | undefined) {
+  const { client } = useForge();
+  const queryClient = useQueryClient();
+  const [pending, setPending] = useState(false);
+
+  const queryKey = ["video-call", callPublicId, "recording"] as const;
+
+  const query = useQuery<CallRecordingState>({
+    queryKey,
+    queryFn: async () => (await client.get(`/video-calls/${callPublicId}`)).data.recording,
+    enabled: !!callPublicId && !!client,
+    /**
+     * A host who started a recording wants to see it start; everybody else wants
+     * to know one is running. The room's own signal drives the participant-facing
+     * indicator, so this is only keeping the BUTTON honest - a slow poll is
+     * enough, and a fast one on every call page would be a request per viewer
+     * per few seconds for the whole call.
+     */
+    refetchInterval: 30_000,
+  });
+
+  const act = useCallback(
+    async (path: string) => {
+      if (!callPublicId) return;
+      setPending(true);
+      try {
+        const res = await client.post(`/video-calls/${callPublicId}${path}`, {});
+        // The response IS the new state, so the button flips without waiting for
+        // the poll. A refetch as well would race it.
+        queryClient.setQueryData(queryKey, res.data);
+      } finally {
+        setPending(false);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [callPublicId, client, queryClient],
+  );
+
+  return {
+    status: query.data?.status ?? null,
+    isRecording: query.data?.isRecording ?? false,
+    canControl: query.data?.canControl ?? false,
+    pending,
+    start: useCallback(() => void act("/recording"), [act]),
+    stop: useCallback(() => void act("/recording/stop"), [act]),
+  };
+}

package/src/data/queries/useMembershipCalls.ts

@@ -0,0 +1,212 @@
+import { useQuery } from "@tanstack/react-query";
+import { useForge } from "../../provider/ForgeProvider";
+
+/**
+ * The viewer's own call calendar (`GET /public/scheduled-calls/mine`).
+ *
+ * Lives in Forge rather than in either app because BOTH rendering surfaces need
+ * exactly this - the site-starter's `/i/members/calendar` and the client app's
+ * `/i/members/calendar`, and now the classroom and cohort pages on both - and a
+ * second copy is how the two drift, as `useMyTickets` and `useMyBookings`
+ * already document.
+ *
+ * ## It was never only memberships
+ *
+ * The server resolves the caller through every registered audience kind, so a
+ * course enrolment and a cohort seat come back alongside membership tiers. The
+ * endpoint answered on `/public/membership-calls/mine` for a year while doing
+ * exactly that; that path is kept as an alias for sites published against older
+ * Forge builds, and this file now calls the honest one. The names here keep the
+ * `MembershipCall` spelling because they are PUBLISHED exports that a code site
+ * may import; `useMyScheduledCalls` is the alias to write new code against.
+ *
+ * ## What the server owns and this file does not mirror
+ *
+ * - **Who may see a call.** Resolved from the SESSION against the artist's
+ *   membership; `profileId` here names the artist, never the viewer. A call the
+ *   member cannot join does not appear, so there is no client-side filter to get
+ *   wrong. An empty list is the honest answer for a lapsed member.
+ * - **Whether the room is open.** `isOpen`, `opensAt` and `closesAt` come back
+ *   on every row and are computed from the same window the JOIN enforces.
+ *   Re-deriving "has it started yet" here would give two answers to one
+ *   question, and the wrong one is the one the member acts on.
+ * - **Where the call happens.** `callPublicId` addresses the generic
+ *   `/i/video-calls/:id` page. The id addresses a CALL; the server decides what
+ *   it is attached to and what seat this viewer holds in it.
+ */
+
+export type MembershipCallParticipation = "open" | "host_only";
+
+export interface MyMembershipCall {
+  id: string;
+  title: string;
+  description: string | null;
+  /** ISO. */
+  startsAt: string;
+  endsAt: string;
+  /** The creator's IANA zone, when they set one. Render the time in it, not the viewer's guess. */
+  timezone: string | null;
+  participation: MembershipCallParticipation;
+  /**
+   * Which side of the call this viewer is on. Derived by the server, never
+   * claimed.
+   *
+   * `attendee`, not `member`: the seat-layer vocabulary is closed across every
+   * call kind, because the participant identity is built from it and the seat
+   * cap reads that grammar. The UI is free to say "member".
+   */
+  role: "host" | "attendee";
+  /**
+   * Who the call is for, already labelled by the server.
+   *
+   * Generic `(audienceType, audienceId, label)` rows rather than tiers, because
+   * one call can be addressed to a tier, to every member, or later to a course
+   * or a cohort. Render `label`; a client never has to know which table an
+   * `audienceId` points at.
+   */
+  audiences: { id: string; audienceType: string; audienceId: string | null; label: string }[];
+  /** The window a ticket may be minted in. Only NEW joins are refused after `closesAt`. */
+  opensAt: string;
+  closesAt: string;
+  isOpen: boolean;
+  /** The `/i/video-calls/:id` address. Null only if the room row is missing, which is a bug. */
+  callPublicId: string | null;
+  /**
+   * What there is to rewatch, if anything. Null for a call with no recording.
+   *
+   * `processing` means "come back shortly", NOT an error: the video is assembled
+   * after the call ends, one call at a time, so a member looking straight
+   * afterwards sees it for a few minutes.
+   */
+  recording: {
+    id: string;
+    status: "processing" | "ready";
+    durationSeconds: number | null;
+    /** Signed per request and short-lived. Null while `processing`. */
+    watchUrl: string | null;
+  } | null;
+}
+
+export const membershipCallKeys = {
+  mine: (profileId: string | undefined) => ["membership-calls", "mine", profileId] as const,
+};
+
+/**
+ * @param options.from Inclusive lower bound. Absent means "from now on", which is
+ * what a caller wanting only the next few calls sends.
+ * @param options.to Inclusive upper bound. Absent means "however far ahead".
+ * @param options.courseId Show only calls addressed to this course. See below.
+ * @param options.cohortId Show only calls addressed to this cohort. See below.
+ *
+ * ## `courseId` / `cohortId` narrow, they do not unlock
+ *
+ * Absent, this is the viewer's whole calendar and behaves as it always has.
+ * Present, the server INTERSECTS them with the audience keys it resolved for
+ * this caller, so they can only remove rows. Passing a course the viewer has no
+ * access to returns nothing, which is the same answer a stranger gets.
+ *
+ * The classroom and the cohort page pass them because a student enrolled in two
+ * cohorts opening one of them must not be shown the other's sessions.
+ */
+export function useMyMembershipCalls(options?: {
+  from?: Date;
+  to?: Date;
+  limit?: number;
+  enabled?: boolean;
+  courseId?: string | null;
+  cohortId?: string | null;
+}) {
+  const { client, profileId } = useForge();
+  const from = options?.from?.toISOString();
+  const to = options?.to?.toISOString();
+  const courseId = options?.courseId || undefined;
+  const cohortId = options?.cohortId || undefined;
+  return useQuery<MyMembershipCall[]>({
+    // The WINDOW is part of the key: paging back a month is a different question
+    // with a different answer, and sharing one cache entry would show February's
+    // calls in March until a refetch landed. The SCOPE is in it for the same
+    // reason - the classroom's answer and the members calendar's answer are two
+    // different lists, and sharing one entry would put one course's sessions on
+    // another course's page for as long as the cache held.
+    queryKey: [
+      ...membershipCallKeys.mine(profileId),
+      from ?? "now",
+      to ?? "open",
+      courseId ?? "any-course",
+      cohortId ?? "any-cohort",
+    ],
+    queryFn: async () => {
+      const res = await client.get("/public/scheduled-calls/mine", {
+        params: { profileId, from, to, limit: options?.limit, courseId, cohortId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && options?.enabled !== false,
+    /**
+     * A call opens fifteen minutes before it starts, and the member watching
+     * this page is waiting for exactly that. Without a refetch the Join button
+     * appears only when they happen to reload, which on the one page whose whole
+     * job is "can I get in yet" is the wrong behaviour.
+     */
+    refetchInterval: 60_000,
+  });
+}
+
+/** One past call the viewer could attend, and what has become of its video. */
+export interface MyMembershipCallRecording {
+  callId: string;
+  title: string;
+  description: string | null;
+  /** ISO. */
+  startsAt: string;
+  endsAt: string;
+  timezone: string | null;
+  recordingId: string;
+  /**
+   * `processing` is not an error and must not be rendered as one. The video is
+   * assembled from every participant's stream after the call ends, one call at a
+   * time, so a member who looks straight afterwards sees this for a few minutes.
+   * A `failed` recording never reaches the client at all.
+   */
+  status: "processing" | "ready";
+  durationSeconds: number | null;
+  /**
+   * Signed per request and short-lived, so it is not stored and not shareable
+   * for long. Null while `status` is `processing`.
+   */
+  watchUrl: string | null;
+}
+
+export function useMyMembershipCallRecordings(options?: { limit?: number; enabled?: boolean }) {
+  const { client, profileId } = useForge();
+  return useQuery<MyMembershipCallRecording[]>({
+    queryKey: ["membership-calls", "recordings", profileId],
+    queryFn: async () => {
+      const res = await client.get("/public/scheduled-calls/mine/recordings", {
+        params: { profileId, limit: options?.limit },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && options?.enabled !== false,
+    /**
+     * Slower than the upcoming list: nothing here changes on a fifteen-minute
+     * boundary, and the only transition worth catching is `processing` ->
+     * `ready`, which takes minutes rather than seconds.
+     */
+    refetchInterval: 120_000,
+  });
+}
+
+/**
+ * The honest names for the two hooks above.
+ *
+ * Aliases rather than renames: `useMyMembershipCalls` and its types are
+ * PUBLISHED exports that a code-built site may already import, and breaking
+ * those to fix a word would cost a site owner a build for nothing. New code
+ * should reach for these; the old names stay for as long as anything imports
+ * them.
+ */
+export const useMyScheduledCalls = useMyMembershipCalls;
+export const useMyScheduledCallRecordings = useMyMembershipCallRecordings;
+export type MyScheduledCall = MyMembershipCall;
+export type MyScheduledCallRecording = MyMembershipCallRecording;

package/src/i18n/de.json

@@ -201,23 +201,83 @@
   "forge.bundle_confirmation.view_orders": "Bestellungen ansehen",
   "forge.call_stage.camera_start": "Kamera starten",
   "forge.call_stage.camera_stop": "Kamera stoppen",
+  "forge.call_stage.chat": "Chat",
+  "forge.call_stage.chat_empty": "Noch keine Nachrichten. Sag hallo.",
+  "forge.call_stage.chat_loading": "Chat wird geöffnet…",
+  "forge.call_stage.chat_placeholder": "Nachricht an alle…",
+  "forge.call_stage.chat_send": "Senden",
+  "forge.call_stage.chat_typing": "{name} schreibt…",
+  "forge.call_stage.close_panel": "Leiste schließen",
+  "forge.call_stage.dismiss": "Ausblenden",
+  "forge.call_stage.everyone_left": "Alle anderen haben den Anruf verlassen",
+  "forge.call_stage.hand_raised_by": "{name} hat die Hand gehoben",
+  "forge.call_stage.hands_raised_named": "{name} +{count}",
+  "forge.call_stage.hands_raised_open": "Erhobene Hände: {count}. Personenpanel öffnen.",
   "forge.call_stage.head_count": "In diesem Anruf: {count}",
+  "forge.call_stage.health_close": "Anrufqualität schließen",
+  "forge.call_stage.health_estimate": "Bandbreitenschätzung",
+  "forge.call_stage.health_measuring": "Wird gemessen...",
+  "forge.call_stage.health_no_video": "Keine Videokacheln zum Messen.",
+  "forge.call_stage.health_sending": "Senden",
+  "forge.call_stage.health_title": "Anrufqualität",
+  "forge.call_stage.health_toggle": "Anrufqualität",
   "forge.call_stage.help_camera_stop": "Dein Bild wird nicht mehr gesendet: Die anderen sehen stattdessen deinen Namen. Der Browser hält die Kamera geöffnet, damit das erneute Starten sofort geht und nicht ein zweites Mal um Erlaubnis fragt. Deshalb kann die Kameraleuchte anbleiben, bis du den Anruf verlässt.",
   "forge.call_stage.help_camera_stop_label": "Was macht „Kamera stoppen“?",
+  "forge.call_stage.help_health": "Jede Zeile zeigt eine Kachel: die angefragte und die empfangene Qualität (q Viertel, h Hälfte, f voll), danach das dekodierte Bild. Eine ROTE Zeile empfängt weniger als angefragt. Die Bandbreitenschätzung ist, was der Server dieser Verbindung zutraut; bleibt sie niedrig, bleiben alle Kacheln klein. Unter Senden hat jede eigene ausgehende Qualitätsstufe einen Wert; 0 bedeutet, dass diese Stufe den Server gar nicht erreicht.",
+  "forge.call_stage.help_health_label": "Wie lese ich das?",
   "forge.call_stage.help_hear_not_see": "Eine Kachel mit Namen, aber ohne Bild bedeutet, dass diese Person ihre Kamera ausgeschaltet hat oder dass der Anruf so voll ist, dass nur die gerade sprechenden Personen in voller Größe übertragen werden. Beides ist normal, und der Ton ist davon nicht betroffen.",
   "forge.call_stage.help_hear_not_see_label": "Warum höre ich jemanden, sehe ihn aber nicht?",
+  "forge.call_stage.help_record": "Die Aufzeichnung startet jetzt und erfasst alle im Gespräch. Nach dem Ende wird daraus ein Video erstellt, das einige Minuten dauert, und erscheint dann für alle, die an diesem Gespräch teilnehmen konnten.",
+  "forge.call_stage.help_record_label": "Wer kann die Aufzeichnung sehen?",
   "forge.call_stage.help_screen": "Was auch immer du im Browser-Dialog auswählst, live an alle im Anruf. Deine Kamera läuft dabei weiter, statt ersetzt zu werden, sodass dich die anderen weiterhin sehen können, während du präsentierst.",
   "forge.call_stage.help_screen_label": "Was wird beim Teilen meines Bildschirms gesendet?",
+  "forge.call_stage.hide_self_view": "Eigenes Bild ausblenden",
   "forge.call_stage.leave": "Verlassen",
+  "forge.call_stage.leave_recording_body": "Dieses Gespräch wird aufgezeichnet. Wenn Sie gehen, ohne zu stoppen, läuft die Aufzeichnung weiter, bis alle gegangen sind.",
+  "forge.call_stage.leave_recording_cancel": "Im Gespräch bleiben",
+  "forge.call_stage.leave_recording_keep": "Gehen, Aufzeichnung weiterlaufen lassen",
+  "forge.call_stage.leave_recording_stop": "Aufzeichnung beenden und gehen",
+  "forge.call_stage.leave_recording_title": "Sie zeichnen noch auf",
   "forge.call_stage.listening": "(hört zu)",
   "forge.call_stage.lost_camera": "Deine Kamera wurde ausgeschaltet, als die Verbindung abbrach. Starte sie erneut, um wieder gesehen zu werden.",
   "forge.call_stage.lost_microphone": "Dein Mikrofon wurde ausgeschaltet, als die Verbindung abbrach. Hebe die Stummschaltung auf, um wieder gehört zu werden.",
   "forge.call_stage.lost_screen": "Deine Bildschirmfreigabe wurde beendet, als die Verbindung abbrach. Teile ihn erneut, um fortzufahren.",
+  "forge.call_stage.lower_all_hands": "Alle Hände senken",
+  "forge.call_stage.lower_hand": "Hand senken",
+  "forge.call_stage.lower_hand_of": "Senken",
+  "forge.call_stage.many_joined": "{count} Personen kamen oder gingen",
   "forge.call_stage.mute": "Stummschalten",
+  "forge.call_stage.muted_talking": "Du scheinst zu sprechen, bist aber stummgeschaltet.",
+  "forge.call_stage.no_devices": "Keine Geräte gefunden",
+  "forge.call_stage.page_next": "Nächste Seite",
+  "forge.call_stage.page_of": "{page} / {pages}",
+  "forge.call_stage.page_prev": "Vorherige Seite",
+  "forge.call_stage.peer_joined": "{name} ist beigetreten",
+  "forge.call_stage.peer_left": "{name} hat verlassen",
+  "forge.call_stage.people": "Personen",
+  "forge.call_stage.pick_camera": "Kamera wählen",
+  "forge.call_stage.pick_microphone": "Mikrofon wählen",
+  "forge.call_stage.pin": "Kachel anheften",
+  "forge.call_stage.prejoin_camera_off": "Deine Kamera ist aus",
+  "forge.call_stage.prejoin_camera_off_toggle": "Kamera aus",
+  "forge.call_stage.prejoin_camera_on": "Kamera an",
+  "forge.call_stage.prejoin_join": "Anruf beitreten",
+  "forge.call_stage.prejoin_mic_off": "Mikro aus",
+  "forge.call_stage.prejoin_mic_on": "Mikro an",
+  "forge.call_stage.prejoin_permission": "Der Browser hat den Zugriff auf deine Geräte nicht erlaubt:",
+  "forge.call_stage.presenting_name": "{name} präsentiert",
+  "forge.call_stage.raise_hand": "Hand heben",
+  "forge.call_stage.react_to_message": "Auf diese Nachricht reagieren",
+  "forge.call_stage.reactions": "Reaktion senden",
+  "forge.call_stage.record_start": "Aufzeichnen",
+  "forge.call_stage.record_stop": "Aufzeichnung beenden",
   "forge.call_stage.recording": "Dieser Anruf wird aufgezeichnet",
+  "forge.call_stage.recording_live": "Aufzeichnung läuft",
   "forge.call_stage.retry": "Erneut versuchen",
+  "forge.call_stage.screen_of": "Bildschirm von {name}",
   "forge.call_stage.screen_start": "Bildschirm teilen",
   "forge.call_stage.screen_stop": "Teilen beenden",
+  "forge.call_stage.speaking_off_page": "Es spricht: {names}",
   "forge.call_stage.status_connected": "Verbunden",
   "forge.call_stage.status_connecting": "Verbindung zum Anruf wird hergestellt",
   "forge.call_stage.status_ended": "Der Anruf ist beendet",
@@ -231,11 +291,23 @@
   "forge.call_stage.status_reconnecting": "Verbindung unterbrochen, wird wiederhergestellt",
   "forge.call_stage.status_reconnecting_detail": "Alle anderen sind weiterhin im Anruf.",
   "forge.call_stage.status_refused": "Beitritt zu diesem Anruf nicht möglich",
+  "forge.call_stage.stop_presenting": "Präsentation beenden",
+  "forge.call_stage.tab_chat": "Chat",
+  "forge.call_stage.tab_people": "Personen",
   "forge.call_stage.unmute": "Stummschaltung aufheben",
+  "forge.call_stage.unnamed_device": "Gerät {number}",
+  "forge.call_stage.unpin": "Kachel lösen",
+  "forge.call_stage.view_gallery": "Galerieansicht",
+  "forge.call_stage.view_speaker": "Sprecheransicht",
+  "forge.call_stage.waiting_for_others": "Warten auf weitere Teilnehmer",
+  "forge.call_stage.waiting_for_others_detail": "Du bist als Erste(r) hier. Der Anruf beginnt, sobald jemand dazukommt.",
   "forge.call_stage.you": "Du",
+  "forge.call_stage.you_are_presenting": "Du präsentierst deinen Bildschirm",
+  "forge.call_stage.you_joining": "Du (trittst bei…)",
   "forge.call_stage.you_not_connected": "Du (noch nicht verbunden)",
+  "forge.call_stage.you_suffix": "(du)",
   "forge.call_window.ended": "Dieser Anruf ist beendet",
-  "forge.call_window.ended_detail": "Der Raum für diese Session ist geschlossen. Wenn das nicht stimmt, wenden Sie sich an die Person, bei der Sie gebucht haben.",
+  "forge.call_window.ended_detail": "Der Raum ist geschlossen, niemand kann jetzt beitreten. Wenn das falsch erscheint, wenden Sie sich an die gastgebende Person.",
   "forge.call_window.not_started": "Dieser Anruf hat noch nicht begonnen",
   "forge.call_window.opens_at": "Sie können ab {datetime} beitreten. Kommen Sie dann zurück, und diese Seite lässt Sie hinein.",
   "forge.cancellation_terms.title": "Stornobedingungen",
@@ -500,6 +572,7 @@
   "forge.course_access.secure_prompt_lead": "Jeder mit diesem Link kann deinen Kurs öffnen. Erstelle ein Konto mit",
   "forge.course_access.secure_prompt_tail": "damit er nur dir gehört.",
   "forge.course_access.signed_in_as": "Angemeldet als",
+  "forge.course_calls.title": "Live-Calls",
   "forge.course_checkout.aria_close": "Schließen",
   "forge.course_checkout.back": "Zurück",
   "forge.course_checkout.confirm_email_placeholder": "E-Mail bestätigen",