@tribe-nest/forge 3.42.0 → 3.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tribe-nest/forge",
-  "version": "3.42.0",
+  "version": "3.48.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,162 @@
+import { useQuery } from "@tanstack/react-query";
+import { useForge } from "../../provider/ForgeProvider";
+
+/**
+ * The member's own call calendar (`GET /public/membership-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 a second copy is how the two drift, as
+ * `useMyTickets` and `useMyBookings` already document.
+ *
+ * ## 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".
+ */
+export function useMyMembershipCalls(options?: {
+  from?: Date;
+  to?: Date;
+  limit?: number;
+  enabled?: boolean;
+}) {
+  const { client, profileId } = useForge();
+  const from = options?.from?.toISOString();
+  const to = options?.to?.toISOString();
+  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.
+    queryKey: [...membershipCallKeys.mine(profileId), from ?? "now", to ?? "open"],
+    queryFn: async () => {
+      const res = await client.get("/public/membership-calls/mine", {
+        params: { profileId, from, to, limit: options?.limit },
+      });
+      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/membership-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,
+  });
+}

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",

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",