@rapidmx/meet-plugin 0.9.3 → 0.11.0

package/dist/apps/meet/_ParticipantsDrawer.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * The participants drawer, opened from the header's participant-count chip: a right-side panel listing everyone in
+ * the call, "you" first. The same mic-muted/hand-raised/transport-badge information `_ParticipantTile.tsx` already
+ * shows on a tile, as plain rows instead (a list reads better than tiles once there's a reason to scan for one
+ * name).
+ *
+ * Closes on Escape, on a click on the backdrop behind it, or its own close button - never on a click inside the
+ * drawer itself, matching `_CallControls.tsx`'s menus.
+ *
+ * A "Host" tag marks the host's own row (`isSelfHost`/`isParticipantHost` - see `_CallView.tsx`'s doc comment on
+ * `hostUid` for what that identity is and isn't). Only while `isSelfHost` does every *other* row also get a "Mute"
+ * button (hidden once that participant is already muted - there is no useful "unmute someone else" action to
+ * offer) and a "Remove" button (a native `confirm()` first, since removal can't be undone by the participant the
+ * way a mute request can) - never on the local participant's own row, and never shown to anyone but the host.
+ *
+ * The header also gets a host-only "Mute on join" checkbox (`forceMuteOnJoin`/`onToggleForceMuteOnJoin`) - a
+ * setting for whoever joins *next*, not an action on anyone already here (muting someone already in the call is
+ * what each row's own "Mute" button is for) - a host-only password section (`hasPassword`/`onSetPassword`), the
+ * same "next joiner" scope: setting or changing it never affects anyone already in the call - and a host-only
+ * waiting-room toggle plus list (`waitingRoomEnabled`/`onToggleWaitingRoomEnabled`,
+ * `waitingParticipants`/`onAdmit`/`onDeny`): `_CallView.tsx` polls the list while this drawer is open and the
+ * caller is the host (there is no push signal for a newly filed admission request), so it stays current without
+ * the host needing to close and reopen the drawer.
+ *
+ * While talking-stick mode is on (`talkingStickActive`), every row - including the host's own - shows a "Give
+ * stick" button, host-only, hidden on whichever row currently holds it (`talkingStickHolder`); everyone (not just
+ * the host) sees a badge on that row instead, same visibility as the "Host" tag. See `_CallView.tsx`'s doc comment
+ * on talking-stick mode for what granting it actually does to the recipient's microphone.
+ */
+import { useEffect, useState } from "react";
+import { TRANSPORT_BADGES } from "./_ParticipantTile.js";
+import { MicOffIcon } from "./_icons.js";
+/** The host-only password form: one text input plus a Set/Change button, and a Remove button once one is set.
+ * Owns its own input/error/busy state locally - `_CallView.tsx` only needs to know whether a password exists, not
+ * what a half-typed one currently says. */
+function PasswordSection({ hasPassword, onSetPassword }) {
+    const [input, setInput] = useState("");
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    async function submit(password) {
+        setBusy(true);
+        setError(null);
+        try {
+            await onSetPassword(password);
+            setInput("");
+        }
+        catch {
+            setError("Could not save - try again.");
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    return (_jsxs("div", { className: "px-3 py-2 border-b border-white/10 text-sm", children: [_jsx("p", { className: "text-white/70 mb-1.5", children: hasPassword ? "Password protection is on." : "No password required to join." }), _jsxs("form", { className: "flex gap-2", onSubmit: (event) => {
+                    event.preventDefault();
+                    if (input) {
+                        void submit(input);
+                    }
+                }, children: [_jsx("input", { type: "password", "aria-label": hasPassword ? "New password" : "Set a password", placeholder: hasPassword ? "New password" : "Set a password", className: "flex-1 min-w-0 px-2 py-1 rounded bg-white/10 text-white placeholder:text-white/50 focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", value: input, onChange: (event) => setInput(event.target.value), disabled: busy }), _jsx("button", { type: "submit", className: "px-2 py-1 rounded text-xs whitespace-nowrap bg-white/10 hover:bg-white/20 focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80 disabled:opacity-50", disabled: busy || !input, children: hasPassword ? "Change" : "Set" })] }), hasPassword && (_jsx("button", { type: "button", className: "mt-1.5 text-xs text-[#f2b8b5] underline focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80 disabled:opacity-50", disabled: busy, onClick: () => void submit(null), children: "Remove password" })), error && _jsx("p", { className: "text-[#f2b8b5] text-xs mt-1.5", children: error })] }));
+}
+/** The host-only "who's waiting" list - shown only while `waitingRoomEnabled` is on, since there is otherwise never
+ * anyone to list. Says so explicitly when the list is empty, rather than rendering nothing (silence here would be
+ * indistinguishable from the list just not having loaded yet). */
+function WaitingSection({ waitingParticipants, onAdmit, onDeny, }) {
+    return (_jsxs("div", { className: "px-3 py-2 border-b border-white/10 text-sm", children: [_jsx("p", { className: "text-xs font-semibold uppercase tracking-wide text-white/60 mb-1.5", children: "Waiting to join" }), waitingParticipants.length === 0 ? (_jsx("p", { className: "text-white/70", children: "Nobody is waiting right now." })) : (_jsx("ul", { children: waitingParticipants.map((p) => (_jsxs("li", { className: "flex items-center gap-2 py-1", children: [_jsx("span", { className: "flex-1 min-w-0 truncate", children: p.name }), _jsx("button", { type: "button", className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-[#a8c7fa] text-[#062e6f] hover:bg-[#8ab4f8] focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", "aria-label": `Admit ${p.name}`, onClick: () => onAdmit(p.uid), children: "Admit" }), _jsx("button", { type: "button", className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-white/10 hover:bg-white/20 focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", "aria-label": `Deny ${p.name}`, onClick: () => onDeny(p.uid), children: "Deny" })] }, p.uid))) }))] }));
+}
+function Row({ name, isSelf, isHost, micMuted, handRaised, transport, canModerate, onMute, onKick, hasStick, canGiveStick, onGiveStick, }) {
+    const badge = transport ? TRANSPORT_BADGES[transport] : undefined;
+    return (_jsxs("li", { className: "flex items-center gap-2 px-3 py-2 rounded-lg hover:bg-white/5", children: [_jsxs("span", { className: "flex-1 min-w-0 truncate", children: [name, isSelf ? " (you)" : ""] }), isHost && _jsx("span", { className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-[#a8c7fa] text-[#062e6f]", children: "Host" }), hasStick && (_jsx("span", { className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-[#a8c7fa] text-[#062e6f]", role: "img", "aria-label": "Holding the talking stick", children: "\uD83C\uDF99\uFE0F" })), handRaised && (_jsx("span", { role: "img", "aria-label": "Hand raised", children: "\u270B" })), micMuted && (_jsx("span", { className: "w-4 h-4 text-white/70 [&>svg]:w-4 [&>svg]:h-4", role: "img", "aria-label": "Muted", children: _jsx(MicOffIcon, {}) })), badge && (_jsx("span", { className: `px-2 py-0.5 rounded text-xs whitespace-nowrap ${transport === "failed" ? "bg-[#601410] text-[#f9dedc]" : "bg-black/40 text-white"}`, title: badge.title, children: badge.label })), canGiveStick && !hasStick && (_jsx("button", { type: "button", className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-white/10 hover:bg-white/20 focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", "aria-label": `Give the talking stick to ${name}`, onClick: onGiveStick, children: "Give stick" })), canModerate && !micMuted && (_jsx("button", { type: "button", className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-white/10 hover:bg-white/20 focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", "aria-label": `Mute ${name}`, onClick: onMute, children: "Mute" })), canModerate && (_jsx("button", { type: "button", className: "px-2 py-0.5 rounded text-xs whitespace-nowrap bg-[#601410] text-[#f9dedc] hover:bg-[#7a1b16] focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", "aria-label": `Remove ${name}`, onClick: () => {
+                    if (window.confirm(`Remove ${name} from the call?`)) {
+                        onKick?.();
+                    }
+                }, children: "Remove" }))] }));
+}
+export default function ParticipantsDrawer({ selfName, micOn, handRaised, participants, isSelfHost, isParticipantHost, onMute, onKick, forceMuteOnJoin, onToggleForceMuteOnJoin, hasPassword, onSetPassword, waitingRoomEnabled, onToggleWaitingRoomEnabled, waitingParticipants, onAdmit, onDeny, talkingStickActive, selfPeerId, talkingStickHolder, onGiveTalkingStick, onClose, }) {
+    useEffect(() => {
+        const onKeyDown = (event) => {
+            if (event.key === "Escape") {
+                onClose();
+            }
+        };
+        document.addEventListener("keydown", onKeyDown);
+        return () => document.removeEventListener("keydown", onKeyDown);
+    }, [onClose]);
+    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "absolute inset-0 z-20 bg-black/40", onClick: onClose, "aria-hidden": "true" }), _jsxs("aside", { role: "dialog", "aria-label": "Participants", className: "absolute z-20 inset-y-0 right-0 w-72 max-w-[85vw] flex flex-col bg-[#2b2d30] text-white shadow-xl", onClick: (event) => event.stopPropagation(), children: [_jsxs("div", { className: "flex items-center justify-between gap-2 px-3 py-3 border-b border-white/10", children: [_jsxs("h2", { className: "text-sm font-medium", children: ["Participants (", participants.length + 1, ")"] }), _jsx("button", { type: "button", className: "w-8 h-8 flex items-center justify-center rounded-full hover:bg-white/10 focus:outline-none focus-visible:ring-2 focus-visible:ring-white/80", "aria-label": "Close participants", onClick: onClose, children: "\u2715" })] }), isSelfHost && (_jsxs("label", { className: "flex items-center gap-2 px-3 py-2 border-b border-white/10 text-sm", children: [_jsx("input", { type: "checkbox", checked: forceMuteOnJoin, onChange: onToggleForceMuteOnJoin, className: "w-4 h-4" }), "Mute new participants on join"] })), isSelfHost && _jsx(PasswordSection, { hasPassword: hasPassword, onSetPassword: onSetPassword }), isSelfHost && (_jsxs("label", { className: "flex items-center gap-2 px-3 py-2 border-b border-white/10 text-sm", children: [_jsx("input", { type: "checkbox", checked: waitingRoomEnabled, onChange: onToggleWaitingRoomEnabled, className: "w-4 h-4" }), "Require the host to admit participants"] })), isSelfHost && waitingRoomEnabled && (_jsx(WaitingSection, { waitingParticipants: waitingParticipants, onAdmit: onAdmit, onDeny: onDeny })), _jsxs("ul", { className: "flex-1 min-h-0 overflow-y-auto p-2 text-sm", children: [_jsx(Row, { name: selfName, isSelf: true, isHost: isSelfHost, micMuted: !micOn, handRaised: handRaised, hasStick: talkingStickActive && talkingStickHolder === selfPeerId, canGiveStick: isSelfHost && talkingStickActive, onGiveStick: () => onGiveTalkingStick(selfPeerId) }), participants.map((p) => (_jsx(Row, { name: p.name, isHost: isParticipantHost(p.uid), micMuted: !p.audioOn, handRaised: p.handRaised, transport: p.transport, canModerate: isSelfHost, onMute: () => onMute(p.uid), onKick: () => onKick(p.uid), hasStick: talkingStickActive && talkingStickHolder === p.uid, canGiveStick: isSelfHost && talkingStickActive, onGiveStick: () => onGiveTalkingStick(p.uid) }, p.uid)))] })] })] }));
+}

package/dist/apps/meet/_icons.d.ts

@@ -14,3 +14,6 @@ export declare const ChevronUpIcon: () => React.JSX.Element;
 /** A raised hand, as an emoji glyph - Material's own "back hand" path isn't among the ones bundled here. */
 export declare const HandIcon: () => React.JSX.Element;
 export declare const EffectsIcon: () => React.JSX.Element;
+export declare const RotateIcon: () => React.JSX.Element;
+export declare const FlipIcon: () => React.JSX.Element;
+export declare const DiagnosticsIcon: () => React.JSX.Element;

package/dist/apps/meet/_icons.js

@@ -15,3 +15,6 @@ export const ChevronUpIcon = () => _jsx(Icon, { path: "M12 8l-6 6 1.41 1.41L12 1
 /** A raised hand, as an emoji glyph - Material's own "back hand" path isn't among the ones bundled here. */
 export const HandIcon = () => (_jsx("span", { className: "text-xl leading-none", "aria-hidden": "true", children: "\u270B" }));
 export const EffectsIcon = () => (_jsx(Icon, { path: "M19 9l1.25-2.75L23 5l-2.75-1.25L19 1l-1.25 2.75L15 5l2.75 1.25L19 9zm-7.5.5L9 4 6.5 9.5 1 12l5.5 2.5L9 20l2.5-5.5L17 12l-5.5-2.5zM19 15l-1.25 2.75L15 19l2.75 1.25L19 23l1.25-2.75L23 19l-2.75-1.25L19 15z" }));
+export const RotateIcon = () => (_jsx(Icon, { path: "M12 6V2L7 7l5 5V8c3.31 0 6 2.69 6 6s-2.69 6-6 6-6-2.69-6-6H4c0 4.42 3.58 8 8 8s8-3.58 8-8-3.58-8-8-8z" }));
+export const FlipIcon = () => (_jsx(Icon, { path: "M15 21h2v-2h-2v2zm4-12h2V7h-2v2zM3 5v14c0 1.1.9 2 2 2h4v-2H5V5h4V3H5c-1.1 0-2 .9-2 2zm16-2v2h2c0-1.1-.9-2-2-2zm-8 20h2V1h-2v22zm8-6h2v-2h-2v2zM15 5h2V3h-2v2zm4 8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2z" }));
+export const DiagnosticsIcon = () => (_jsx(Icon, { path: "M22 12h-4l-3 9L9 3l-3 9H2v2h5.6l1.4-4.2L13.4 21 17 12h5v-2z" }));

package/dist/apps/meet/_meetApi.d.ts

@@ -14,6 +14,19 @@ export interface PublicVideoMeeting {
     visibility: VideoMeetingVisibility;
     status: VideoMeetingStatus;
     hostDisplayName?: string;
+    /** The account uid that owns the meeting - the sole source of a "host" identity on the client. Absent when the
+     * server can't resolve one (an orphaned mailbox, or a server that predates this field), in which case no host
+     * controls are shown to anyone. */
+    hostUid?: string;
+    /** When `true`, a joining participant's microphone starts muted - see `useLocalMedia`'s `forceMuteOnJoin`
+     * option, which this is threaded into. Absent reads as `false`. */
+    forceMuteOnJoin?: boolean;
+    /** Whether this meeting currently requires a password - never the password or its hash, just whether one is
+     * set. Absent reads as `false`. */
+    hasPassword?: boolean;
+    /** Whether this meeting currently requires the host to admit each participant before they join - see
+     * `requestAdmission()`. Absent reads as `false`. */
+    waitingRoomEnabled?: boolean;
 }
 /**
  * Mirrors `BaseVideoMeetingRoute.ts`'s `VideoMeetingJoinResult`. `authenticated: true` means the visiting browser
@@ -42,6 +55,31 @@ export interface VideoMeetingJoinResult {
      * hosts them (`mail:videoconf:effects:assets_url`). Absent means the public CDN defaults. */
     effectsAssetsUrl?: string;
 }
+/** Mirrors `BaseVideoMeetingRoute.ts`'s `VideoMeetingPasswordRequiredResult` - returned by `joinMeeting()` in place
+ * of a `VideoMeetingJoinResult` when the meeting requires a password that hasn't been submitted yet. Carries only
+ * enough to show a password prompt (the meeting's title/host); nothing here grants anything. Narrow on
+ * `"requiresPassword" in result && result.requiresPassword`. */
+export interface VideoMeetingPasswordRequiredResult {
+    meeting: PublicVideoMeeting;
+    requiresPassword: true;
+}
+/** Mirrors `BaseVideoMeetingRoute.ts`'s `VideoMeetingAdmissionRequiredResult` - returned by `requestAdmission()`
+ * (and re-returned by `pollAdmission()`) while a `waitingRoomEnabled` meeting's admission request is still
+ * pending. Unlike `VideoMeetingPasswordRequiredResult`, this carries `selfUid` (and, for a guest, `token`) - a
+ * caller needs a stable, authenticated identity to poll with. `joinMeeting()` itself also answers this shape, with
+ * none of those fields, when a waiting room applies and no request has been filed yet. Narrow on
+ * `"requiresAdmission" in result`. */
+export interface VideoMeetingAdmissionRequiredResult {
+    meeting: PublicVideoMeeting;
+    requiresAdmission: true;
+    authenticated?: boolean;
+    selfUid?: string;
+    token?: string;
+    expiresAt?: string;
+}
+/** `joinMeeting()`'s actual return type - see `VideoMeetingPasswordRequiredResult`'s and
+ * `VideoMeetingAdmissionRequiredResult`'s own doc comments. */
+export type VideoMeetingJoinResponse = VideoMeetingJoinResult | VideoMeetingPasswordRequiredResult | VideoMeetingAdmissionRequiredResult;
 /** Resolves a join token (an invitee's own link) or a public meeting's slug to its meeting info, ICE servers, and
  * either a short-lived guest signaling token (the common anonymous case) or confirmation that the caller's own
  * existing session already grants them signaling access (`authenticated: true` - see
@@ -50,4 +88,58 @@ export interface VideoMeetingJoinResult {
  * private/public token shape for what it's being used against - the caller (`[token].tsx`) shows a single,
  * friendly "this meeting link isn't valid" state for all of those rather than trying to distinguish them, matching
  * `BaseVideoMeetingRoute.requireMeetingByToken()`'s own explicit "never leak which almost-matched" posture. */
-export declare function joinMeeting(token: string): Promise<VideoMeetingJoinResult>;
+export declare function joinMeeting(token: string): Promise<VideoMeetingJoinResponse>;
+/** Submits a password for a meeting `joinMeeting()` reported `requiresPassword` for. On success, returns an
+ * ordinary granted `VideoMeetingJoinResult` - the same shape and same meaning as `joinMeeting()`'s own non-password
+ * case. Rejects with `ApiRequestError` (status `403`) for a wrong or missing password. */
+export declare function verifyMeetingPassword(token: string, password: string): Promise<VideoMeetingJoinResult>;
+/** Sets, replaces, or removes (`password: null`) the meeting's join password - host only, enforced the same way
+ * as every other owner-side video-meeting update. Hashed server-side; the plaintext is never stored or returned. */
+export declare function setMeetingPassword(meetingUid: string, password: string | null): Promise<void>;
+/** Files an admission request for a meeting `joinMeeting()` reported `requiresAdmission` for - `password` only
+ * when `meeting.hasPassword` is also set (both are checked together on this one call, never in two steps). On
+ * success returns `VideoMeetingAdmissionRequiredResult` with a `selfUid` (and, for a guest, `token`) to poll with
+ * via `pollAdmission()` - nothing is granted yet. Rejects with `ApiRequestError` (status `403`) for a wrong
+ * password, or `400` if `meeting.hasPassword` and no password was given. */
+export declare function requestAdmission(token: string, body: {
+    name: string;
+    password?: string;
+}): Promise<VideoMeetingAdmissionRequiredResult>;
+/** Polls whether the host has responded to a pending admission request - authenticated as whichever identity
+ * `requestAdmission()` (or a previous poll) returned: `guestToken`, when given, is sent as an `Authorization`
+ * header (a guest has no session cookie of their own); omitted for an already-authenticated real caller, whose
+ * existing session cookie already identifies them. Resolves to a granted `VideoMeetingJoinResult` once admitted,
+ * or re-resolves to `VideoMeetingAdmissionRequiredResult` while still pending. Rejects with `ApiRequestError`
+ * (status `403`) once denied, or `404` if this identity never requested admission (or already polled past a final
+ * answer). */
+export declare function pollAdmission(token: string, guestToken?: string): Promise<VideoMeetingJoinResult | VideoMeetingAdmissionRequiredResult>;
+/** One pending admission request, as `listWaitingParticipants()` returns it. */
+export interface WaitingParticipant {
+    uid: string;
+    name: string;
+    requestedAt: string;
+}
+/** Lists a meeting's pending admission requests, oldest first - host only. */
+export declare function listWaitingParticipants(meetingUid: string): Promise<WaitingParticipant[]>;
+/** Admits a pending admission request - host only. The requester's own next `pollAdmission()` call completes
+ * their join; this alone does not notify them of anything. A no-op if `uid` has no pending request. */
+export declare function admitParticipant(meetingUid: string, uid: string): Promise<void>;
+/** Denies a pending admission request - host only. The requester's own next `pollAdmission()` call then rejects
+ * with a 403. A no-op if `uid` has no pending request. */
+export declare function denyParticipant(meetingUid: string, uid: string): Promise<void>;
+/** Sets whether the meeting requires the host to admit each participant (`PublicVideoMeeting.waitingRoomEnabled`) -
+ * host only, enforced the same way as every other owner-side video-meeting update. Takes effect for anyone who
+ * joins (or reloads the join link and joins again) after this call resolves. */
+export declare function setWaitingRoomEnabled(meetingUid: string, waitingRoomEnabled: boolean): Promise<void>;
+/** Removes a participant from the meeting - host only, enforced server-side with the caller's own authenticated
+ * session (the same mailbox-ACL check every other owner-side video-meeting route uses), not by anything the
+ * client claims. Revokes `uid`'s grant on the meeting's own push channel, so they can no longer signal or relay
+ * media even if their client ignores the cooperative "kicked" signal a host's UI sends alongside this
+ * (`MeshConnectionManager.sendKick()`). `uid` is the participant's real account uid (`MeshParticipant.uid` minus
+ * its tab-scoped suffix - see `_CallView.tsx`'s `accountUidOf()`), not their tab-scoped peer id. */
+export declare function kickParticipant(meetingUid: string, uid: string): Promise<void>;
+/** Sets whether a newly joining participant starts muted (`PublicVideoMeeting.forceMuteOnJoin`) - host only,
+ * enforced the same way as every other owner-side video-meeting update. Takes effect for anyone who joins (or
+ * reloads the join link and joins again) after this call resolves; it does not retroactively mute anyone already
+ * in the call - the host's own "Mute" button (see `kickParticipant()`) is the tool for that. */
+export declare function setForceMuteOnJoin(meetingUid: string, forceMuteOnJoin: boolean): Promise<void>;

package/dist/apps/meet/_meetApi.js

@@ -21,3 +21,85 @@ import { apiFetch } from "@rapidmx/web-client/lib/util/api.js";
 export function joinMeeting(token) {
     return apiFetch(`/mail/video-meetings/join/${encodeURIComponent(token)}`);
 }
+/** Submits a password for a meeting `joinMeeting()` reported `requiresPassword` for. On success, returns an
+ * ordinary granted `VideoMeetingJoinResult` - the same shape and same meaning as `joinMeeting()`'s own non-password
+ * case. Rejects with `ApiRequestError` (status `403`) for a wrong or missing password. */
+export function verifyMeetingPassword(token, password) {
+    return apiFetch(`/mail/video-meetings/join/${encodeURIComponent(token)}/verify`, {
+        method: "POST",
+        body: JSON.stringify({ password }),
+    });
+}
+/** Sets, replaces, or removes (`password: null`) the meeting's join password - host only, enforced the same way
+ * as every other owner-side video-meeting update. Hashed server-side; the plaintext is never stored or returned. */
+export function setMeetingPassword(meetingUid, password) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}`, {
+        method: "PUT",
+        body: JSON.stringify({ password }),
+    });
+}
+/** Files an admission request for a meeting `joinMeeting()` reported `requiresAdmission` for - `password` only
+ * when `meeting.hasPassword` is also set (both are checked together on this one call, never in two steps). On
+ * success returns `VideoMeetingAdmissionRequiredResult` with a `selfUid` (and, for a guest, `token`) to poll with
+ * via `pollAdmission()` - nothing is granted yet. Rejects with `ApiRequestError` (status `403`) for a wrong
+ * password, or `400` if `meeting.hasPassword` and no password was given. */
+export function requestAdmission(token, body) {
+    return apiFetch(`/mail/video-meetings/join/${encodeURIComponent(token)}/verify`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+/** Polls whether the host has responded to a pending admission request - authenticated as whichever identity
+ * `requestAdmission()` (or a previous poll) returned: `guestToken`, when given, is sent as an `Authorization`
+ * header (a guest has no session cookie of their own); omitted for an already-authenticated real caller, whose
+ * existing session cookie already identifies them. Resolves to a granted `VideoMeetingJoinResult` once admitted,
+ * or re-resolves to `VideoMeetingAdmissionRequiredResult` while still pending. Rejects with `ApiRequestError`
+ * (status `403`) once denied, or `404` if this identity never requested admission (or already polled past a final
+ * answer). */
+export function pollAdmission(token, guestToken) {
+    return apiFetch(`/mail/video-meetings/join/${encodeURIComponent(token)}/status`, {
+        headers: guestToken ? { Authorization: `jwt ${guestToken}` } : undefined,
+    });
+}
+/** Lists a meeting's pending admission requests, oldest first - host only. */
+export function listWaitingParticipants(meetingUid) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}/waiting`);
+}
+/** Admits a pending admission request - host only. The requester's own next `pollAdmission()` call completes
+ * their join; this alone does not notify them of anything. A no-op if `uid` has no pending request. */
+export function admitParticipant(meetingUid, uid) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}/admit/${encodeURIComponent(uid)}`, { method: "POST" });
+}
+/** Denies a pending admission request - host only. The requester's own next `pollAdmission()` call then rejects
+ * with a 403. A no-op if `uid` has no pending request. */
+export function denyParticipant(meetingUid, uid) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}/deny/${encodeURIComponent(uid)}`, { method: "POST" });
+}
+/** Sets whether the meeting requires the host to admit each participant (`PublicVideoMeeting.waitingRoomEnabled`) -
+ * host only, enforced the same way as every other owner-side video-meeting update. Takes effect for anyone who
+ * joins (or reloads the join link and joins again) after this call resolves. */
+export function setWaitingRoomEnabled(meetingUid, waitingRoomEnabled) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}`, {
+        method: "PUT",
+        body: JSON.stringify({ waitingRoomEnabled }),
+    });
+}
+/** Removes a participant from the meeting - host only, enforced server-side with the caller's own authenticated
+ * session (the same mailbox-ACL check every other owner-side video-meeting route uses), not by anything the
+ * client claims. Revokes `uid`'s grant on the meeting's own push channel, so they can no longer signal or relay
+ * media even if their client ignores the cooperative "kicked" signal a host's UI sends alongside this
+ * (`MeshConnectionManager.sendKick()`). `uid` is the participant's real account uid (`MeshParticipant.uid` minus
+ * its tab-scoped suffix - see `_CallView.tsx`'s `accountUidOf()`), not their tab-scoped peer id. */
+export function kickParticipant(meetingUid, uid) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}/kick/${encodeURIComponent(uid)}`, { method: "POST" });
+}
+/** Sets whether a newly joining participant starts muted (`PublicVideoMeeting.forceMuteOnJoin`) - host only,
+ * enforced the same way as every other owner-side video-meeting update. Takes effect for anyone who joins (or
+ * reloads the join link and joins again) after this call resolves; it does not retroactively mute anyone already
+ * in the call - the host's own "Mute" button (see `kickParticipant()`) is the tool for that. */
+export function setForceMuteOnJoin(meetingUid, forceMuteOnJoin) {
+    return apiFetch(`/mail/video-meetings/${encodeURIComponent(meetingUid)}`, {
+        method: "PUT",
+        body: JSON.stringify({ forceMuteOnJoin }),
+    });
+}

package/dist/apps/shared/media/filters/ScreenTransform.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Rotates and/or flips a screen-share track before it's sent, so everyone - the presenter included, since their own
+ * preview is this same processor's output - sees it the right way round, rather than however the browser's own
+ * window/screen capture happened to hand it back. Window capture in particular has a known, driver/compositor-
+ * dependent history of occasionally returning upside-down or sideways frames for a specific captured window; this
+ * is the presenter's own manual correction for that, not an automatic fix (there's no reliable way to detect it
+ * from pixels alone).
+ *
+ * Reuses `VideoFilterProcessor.ts`'s own shape (a hidden `<video>` playing the source track, a canvas redrawn on a
+ * timer, `captureStream()` exposing the result) but far simpler: no models to load, no per-frame throttling to
+ * worry about, just a transform applied on each draw. Entirely independent of the camera pipeline - `useLocalMedia`'s
+ * filters never see the screen-share track, and this never touches the camera's.
+ */
+/** A rotation in degrees clockwise. */
+export type ScreenRotation = 0 | 90 | 180 | 270;
+export interface ScreenTransformState {
+    rotation: ScreenRotation;
+    /** Mirrored left-right, applied before the rotation (so "flip, then turn" - the usual photo-editing order). */
+    flipped: boolean;
+}
+export declare const NO_SCREEN_TRANSFORM: ScreenTransformState;
+/** The next rotation clockwise, wrapping back to 0 after 270. */
+export declare function rotateClockwise(state: ScreenTransformState): ScreenTransformState;
+export interface ScreenTransformDeps {
+    createCanvas(): HTMLCanvasElement;
+    createVideo(): HTMLVideoElement;
+    now(): number;
+}
+export interface ScreenTransformOptions {
+    /** The screen-share track. Only ever read - stopping it stays with whoever owns it (`_CallView.tsx`). */
+    source: MediaStreamTrack;
+    state?: ScreenTransformState;
+    frameRate?: number;
+    deps?: Partial<ScreenTransformDeps>;
+}
+export declare class ScreenTransformProcessor {
+    /** The transformed video - what to send in place of the screen track's own. */
+    readonly track: MediaStreamTrack;
+    private readonly deps;
+    private readonly interval;
+    private readonly video;
+    private readonly canvas;
+    private readonly ctx;
+    private state;
+    private stopped;
+    private timer;
+    constructor(options: ScreenTransformOptions);
+    /** Changes the rotation/flip without interrupting the video. */
+    setState(state: ScreenTransformState): void;
+    stop(): void;
+    private tick;
+    private render;
+}

package/dist/apps/shared/media/filters/ScreenTransform.js

@@ -0,0 +1,100 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Rotates and/or flips a screen-share track before it's sent, so everyone - the presenter included, since their own
+ * preview is this same processor's output - sees it the right way round, rather than however the browser's own
+ * window/screen capture happened to hand it back. Window capture in particular has a known, driver/compositor-
+ * dependent history of occasionally returning upside-down or sideways frames for a specific captured window; this
+ * is the presenter's own manual correction for that, not an automatic fix (there's no reliable way to detect it
+ * from pixels alone).
+ *
+ * Reuses `VideoFilterProcessor.ts`'s own shape (a hidden `<video>` playing the source track, a canvas redrawn on a
+ * timer, `captureStream()` exposing the result) but far simpler: no models to load, no per-frame throttling to
+ * worry about, just a transform applied on each draw. Entirely independent of the camera pipeline - `useLocalMedia`'s
+ * filters never see the screen-share track, and this never touches the camera's.
+ */
+export const NO_SCREEN_TRANSFORM = { rotation: 0, flipped: false };
+/** The next rotation clockwise, wrapping back to 0 after 270. */
+export function rotateClockwise(state) {
+    const next = { 0: 90, 90: 180, 180: 270, 270: 0 };
+    return { ...state, rotation: next[state.rotation] };
+}
+/** Screen share doesn't need the camera's 30fps - matches `VIDEO_FPS`, what the relay's own `VideoSender` already
+ * encodes a shared screen at. */
+const DEFAULT_FRAME_RATE = 15;
+const DEFAULT_DEPS = {
+    createCanvas: () => document.createElement("canvas"),
+    createVideo: () => document.createElement("video"),
+    now: () => performance.now(),
+};
+export class ScreenTransformProcessor {
+    constructor(options) {
+        this.stopped = false;
+        this.tick = () => {
+            if (this.stopped) {
+                return;
+            }
+            const started = this.deps.now();
+            if (this.video.readyState >= 2 && this.video.videoWidth > 0) {
+                this.render();
+            }
+            this.timer = setTimeout(this.tick, Math.max(0, this.interval - (this.deps.now() - started)));
+        };
+        this.deps = { ...DEFAULT_DEPS, ...options.deps };
+        this.state = options.state ?? NO_SCREEN_TRANSFORM;
+        const frameRate = options.frameRate ?? DEFAULT_FRAME_RATE;
+        this.interval = 1000 / frameRate;
+        this.canvas = this.deps.createCanvas();
+        const ctx = this.canvas.getContext("2d");
+        if (!ctx) {
+            throw new Error("This browser can't rotate the shared screen.");
+        }
+        this.ctx = ctx;
+        this.track = this.canvas.captureStream(frameRate).getVideoTracks()[0];
+        this.video = this.deps.createVideo();
+        this.video.muted = true;
+        this.video.playsInline = true;
+        this.video.srcObject = new MediaStream([options.source]);
+        void this.video.play().catch(() => undefined);
+        this.tick();
+    }
+    /** Changes the rotation/flip without interrupting the video. */
+    setState(state) {
+        this.state = state;
+    }
+    stop() {
+        this.stopped = true;
+        clearTimeout(this.timer);
+        this.video.pause();
+        this.video.srcObject = null;
+        this.track.stop();
+    }
+    render() {
+        const { video, canvas, ctx, state } = this;
+        const sourceWidth = video.videoWidth;
+        const sourceHeight = video.videoHeight;
+        // A quarter turn swaps which way is "wide" - the canvas (and so the track everyone actually receives) must
+        // match, or the picture is squashed into the untransformed aspect ratio.
+        const swapped = state.rotation === 90 || state.rotation === 270;
+        const width = swapped ? sourceHeight : sourceWidth;
+        const height = swapped ? sourceWidth : sourceHeight;
+        if (canvas.width !== width || canvas.height !== height) {
+            canvas.width = width;
+            canvas.height = height;
+        }
+        if (state.rotation === 0 && !state.flipped) {
+            ctx.drawImage(video, 0, 0, sourceWidth, sourceHeight);
+            return;
+        }
+        ctx.save();
+        ctx.translate(width / 2, height / 2);
+        ctx.rotate((state.rotation * Math.PI) / 180);
+        if (state.flipped) {
+            ctx.scale(-1, 1);
+        }
+        ctx.drawImage(video, -sourceWidth / 2, -sourceHeight / 2, sourceWidth, sourceHeight);
+        ctx.restore();
+    }
+}

package/dist/apps/shared/media/useLocalMedia.d.ts

@@ -49,5 +49,9 @@ export interface LocalMedia {
 export interface LocalMediaOptions {
     /** Where the filters' models are hosted, when not on the default CDN - see `filters/mlModels.ts`. */
     effectsAssetsUrl?: string;
+    /** The host's `VideoMeeting.forceMuteOnJoin` setting - when `true`, this call's microphone starts muted
+     * regardless of what was remembered from a previous call, overriding (but never overwriting) that preference -
+     * see `ensurePrefs()`. `undefined`/`false` changes nothing. */
+    forceMuteOnJoin?: boolean;
 }
-export declare function useLocalMedia({ effectsAssetsUrl }?: LocalMediaOptions): LocalMedia;
+export declare function useLocalMedia({ effectsAssetsUrl, forceMuteOnJoin }?: LocalMediaOptions): LocalMedia;

package/dist/apps/shared/media/useLocalMedia.js

@@ -77,7 +77,7 @@ function combineErrors(audio, video) {
 function preferring(base, preferredId) {
     return preferredId ? { ...base, deviceId: { ideal: preferredId } } : base;
 }
-export function useLocalMedia({ effectsAssetsUrl } = {}) {
+export function useLocalMedia({ effectsAssetsUrl, forceMuteOnJoin } = {}) {
     const [supported, setSupported] = useState(true);
     const [requesting, setRequesting] = useState(false);
     const [error, setError] = useState(null);
@@ -114,7 +114,7 @@ export function useLocalMedia({ effectsAssetsUrl } = {}) {
         }
         const prefs = loadPreferences();
         prefsRef.current = prefs;
-        if (prefs.micEnabled === false) {
+        if (prefs.micEnabled === false || forceMuteOnJoin) {
             micEnabledRef.current = false;
             setMicEnabled(false);
         }
@@ -129,7 +129,7 @@ export function useLocalMedia({ effectsAssetsUrl } = {}) {
             }, () => undefined);
         }
         return prefs;
-    }, [applyBackground, applyFilters]);
+    }, [applyBackground, applyFilters, forceMuteOnJoin]);
     /** Saves a change to the remembered settings. */
     const remember = useCallback((patch) => {
         prefsRef.current = { ...ensurePrefs(), ...patch };

package/dist/apps/shared/webrtc/MeshConnectionManager.d.ts

@@ -58,6 +58,28 @@
  *
  * Sharing a screen is `setLocalTrack("video", screenTrack)`; stopping is `setLocalTrack("video", cameraTrack)`.
  *
+ * ## Host moderation (`mute-request`, `kicked`)
+ *
+ * `sendMuteRequest()`/`sendKick()` send a point-to-point signal to one peer; the manager itself does not decide who
+ * may send one - a "host" identity exists only in `_CallView.tsx`, which shows the controls that call these
+ * methods to nobody but the host (see `types.ts`'s `SignalMessage` doc comment for why this is cooperative, not
+ * enforced, at the signaling layer). Receiving one emits `mute-requested`/`kicked` for the caller to act on; this
+ * manager takes no action of its own beyond that - it doesn't mute a track or tear itself down, since a kicked
+ * participant's actual departure is `stop()`, which the caller decides to call.
+ *
+ * ## Talking stick (`talking-stick`)
+ *
+ * One exclusive "floor" - at most one participant may be unmuted at a time, host-assigned - but unlike presenter,
+ * there is no claim race to resolve: only the host's own client ever calls `setTalkingStick()` (same trust level as
+ * `sendMuteRequest()`/`sendKick()` - nothing here checks that), so the manager carries no state of its own and
+ * simply relays the latest message it sees as `talking-stick-changed`, applying it to itself too via an immediate
+ * local emit (the same "optimistic, no round trip" shape `claimPresenter()`/`releasePresenter()` use). A holder who
+ * leaves the call is not specially reassigned - every other participant's existing `participant-left` handling
+ * already drops them from the roster, and "the stick's holder is no longer in the call" is simply "nobody is holder
+ * right now" without any manager needing to say so, until the host picks someone (or themselves) again. There is no
+ * backend route or persisted field for this at all: like `mute-request`/`kicked`, it only matters while people are
+ * actually in the call together.
+ *
  * ## Three media paths, tried in order
  *
  * Each pair of participants reaches for the best path that works, and `MeshParticipant.transport` says which one it
@@ -88,6 +110,10 @@ export declare function isOfferer(selfId: string, peerId: string): boolean;
 export declare const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
 /** How long a connection may stay `disconnected` (ICE lost the path but may still recover) before giving up on it. */
 export declare const DEFAULT_DISCONNECTED_GRACE_MS = 8000;
+/** How often a connected pair's quality stats (the diagnostics panel) are refreshed - low frequency on purpose:
+ * this is for a participant occasionally checking why a call feels off, not a live chart, and `getStats()` is not
+ * free to call every frame. */
+export declare const DEFAULT_DIAGNOSTICS_POLL_MS = 3000;
 type MediaKind = "audio" | "video";
 export interface MeshConnectionManagerOptions {
     /** The authenticated uid - what `from` must be on the wire (see `SignalMessage.from`). */
@@ -115,6 +141,8 @@ export interface MeshConnectionManagerOptions {
     connectTimeoutMs?: number;
     /** Defaults to `DEFAULT_DISCONNECTED_GRACE_MS`. */
     disconnectedGraceMs?: number;
+    /** Defaults to `DEFAULT_DIAGNOSTICS_POLL_MS`. */
+    diagnosticsPollMs?: number;
 }
 export declare class MeshConnectionManager {
     private readonly options;
@@ -153,6 +181,20 @@ export declare class MeshConnectionManager {
     claimPresenter(): boolean;
     /** Releases presenter status - a no-op unless the local participant currently holds it. */
     releasePresenter(): void;
+    /** Asks `peerUid`'s participant to mute - a cooperative signal (see this module's doc comment on host
+     * moderation), not enforcement. Nothing here checks that the local participant is actually the host; the caller
+     * is responsible for only offering this to one. */
+    sendMuteRequest(peerUid: string): void;
+    /** Tells `peerUid`'s participant they have been removed from the call. Sends only the cooperative signal - it
+     * does not itself revoke `peerUid`'s server-side channel grant (see `BaseVideoMeetingRoute.revokeChannelGrant()`,
+     * which the caller is expected to call alongside this for an enforced removal). */
+    sendKick(peerUid: string): void;
+    /** Turns talking-stick mode on (naming `holder`, the initial speaker) or off (`active: false`, `holder`
+     * omitted), or hands an already-active stick to a different `holder` - see this module's doc comment on why
+     * there is no collision to resolve here, unlike presenter. Broadcasts and applies locally at once, trusting
+     * there is only ever one sender; the caller (`_CallView.tsx`) is responsible for only offering this to the
+     * host. */
+    setTalkingStick(active: boolean, holder?: string): void;
     private sendHello;
     private send;
     private emit;
@@ -168,8 +210,14 @@ export declare class MeshConnectionManager {
     /** Reacts to the peer connection's state: notes which path a connected pair got, and gives up on WebRTC for a
      * pair that failed or stays disconnected - see `fallBack()`. Ignores a pair that already left WebRTC. */
     private handleConnectionState;
-    /** Records whether a connected pair is direct or relayed through TURN, from the candidate pair ICE selected. */
+    /** Records whether a connected pair is direct, relayed through TURN, or relayed through TURN over TCP (see
+     * `MediaTransport`'s doc comment), from the candidate pair ICE selected. */
     private detectTransport;
+    /** Idempotent - a pair that reconnects without ever leaving WebRTC (`connected` -> `disconnected` -> `connected`
+     * again) does not get a second timer. */
+    private startDiagnosticsPolling;
+    private stopDiagnosticsPolling;
+    private pollDiagnostics;
     private setTransport;
     private clearTimers;
     /**