Merge branch 'lotus' into fix/pip-minimise

# Conflicts:
#	src/app/components/CallEmbedProvider.tsx

src/app/components/CallEmbedProvider.tsx

@@ -90,6 +90,9 @@ import { useDenoiseNotices } from '../hooks/useDenoiseNotices';
 
 const PIP_MIN_W = 200;
 const PIP_MIN_H = 112;
+/** [Gitea #323] Minimised PiP bar size. */
+const PIP_MINI_W = 220;
+const PIP_MINI_H = 40;
 /** Default PiP top: just below the 64px-ish room header. */
 const PIP_DEFAULT_TOP = 72;
 
@@ -1003,6 +1006,28 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
   );
 
   const [pipIsFullscreen, setPipIsFullscreen] = useState(false);
+  // [Gitea #323] Minimised PiP: a small draggable bar (room name + expand)
+  // instead of the video. Remembered; phones start minimised.
+  const [pipMinimized, setPipMinimized] = useState<boolean>(() => {
+    try {
+      const v = localStorage.getItem('pip-minimized');
+      if (v !== null) return v === '1';
+    } catch {
+      /* storage unavailable */
+    }
+    return window.innerWidth < 600;
+  });
+  const pipFullSizeRef = React.useRef({ width: 280, height: 158 });
+  const togglePipMinimized = useCallback(() => {
+    setPipMinimized((m) => {
+      try {
+        localStorage.setItem('pip-minimized', m ? '0' : '1');
+      } catch {
+        /* storage unavailable */
+      }
+      return !m;
+    });
+  }, []);
   useEffect(() => {
     const onFsChange = () => setPipIsFullscreen(!!document.fullscreenElement);
     document.addEventListener('fullscreenchange', onFsChange);
@@ -1103,6 +1128,26 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
     }
   }, [pipMode, callVisible]);
 
+  // [Gitea #323] Apply the minimised / full PiP size (after the entry effect
+  // below has positioned and sized it). Keeps the bar on screen.
+  React.useEffect(() => {
+    const el = callEmbedRef.current;
+    if (!el || !pipMode) return;
+    if (pipMinimized) {
+      if (el.offsetHeight > PIP_MINI_H) {
+        pipFullSizeRef.current = { width: el.offsetWidth, height: el.offsetHeight };
+      }
+      el.style.width = `${PIP_MINI_W}px`;
+      el.style.height = `${PIP_MINI_H}px`;
+    } else {
+      el.style.width = `${pipFullSizeRef.current.width}px`;
+      el.style.height = `${pipFullSizeRef.current.height}px`;
+    }
+    const rect = el.getBoundingClientRect();
+    el.style.left = `${Math.max(0, Math.min(rect.left, window.innerWidth - el.offsetWidth))}px`;
+    el.style.top = `${Math.max(0, Math.min(rect.top, window.innerHeight - el.offsetHeight))}px`;
+  }, [pipMode, pipMinimized, callEmbedRef]);
+
   React.useEffect(() => {
     if (!pipMode) return;
     const onPipWindowResize = (): void => {
@@ -1421,19 +1466,50 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
                 position: 'absolute',
                 inset: 0,
                 zIndex: 1,
-                background: 'transparent',
+                // Minimised: cover the frame so only the bar shows.
+                background: pipMinimized ? color.Surface.Container : 'transparent',
                 cursor: 'grab',
                 // [Gitea #43] The call's "Share your screen?" prompt is drawn
                 // inside the frame: let the click reach its Share button.
                 pointerEvents: pipPromptOpen ? 'none' : undefined,
                 display: 'flex',
-                alignItems: 'flex-start',
                 justifyContent: 'flex-end',
+                alignItems: pipMinimized ? 'center' : 'flex-start',
                 padding: '6px',
               }}
             >
-              <div style={{ display: 'flex', gap: config.space.S100, alignItems: 'center' }}>
-                {document.fullscreenEnabled && (
+              <div
+                style={{
+                  display: 'flex',
+                  gap: config.space.S100,
+                  alignItems: 'center',
+                  ...(pipMinimized ? { width: '100%' } : {}),
+                }}
+              >
+                {/* Leftmost: the top-right corner is a resize handle. */}
+                <IconButton
+                  type="button"
+                  size="300"
+                  radii="300"
+                  variant="Surface"
+                  fill="None"
+                  aria-label={pipMinimized ? 'Expand call' : 'Minimise call'}
+                  aria-pressed={pipMinimized}
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    togglePipMinimized();
+                  }}
+                  onMouseDown={(e) => e.stopPropagation()}
+                  onTouchStart={(e) => e.stopPropagation()}
+                  style={{
+                    background: 'rgba(0,0,0,0.65)',
+                    backdropFilter: 'blur(4px)',
+                    color: '#fff',
+                  }}
+                >
+                  <Icon size="100" src={pipMinimized ? Icons.ChevronTop : Icons.Minus} />
+                </IconButton>
+                {!pipMinimized && document.fullscreenEnabled && (
                   <IconButton
                     type="button"
                     size="300"
@@ -1465,14 +1541,23 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
                     fontSize: '11px',
                     fontWeight: 600,
                     pointerEvents: 'none',
+                    ...(pipMinimized
+                      ? {
+                          flexGrow: 1,
+                          minWidth: 0,
+                          overflow: 'hidden',
+                          textOverflow: 'ellipsis',
+                          whiteSpace: 'nowrap',
+                        }
+                      : {}),
                   }}
                 >
-                  ↗ Return to call
+                  {pipMinimized ? `↗ ${callEmbed.room.name ?? 'Call'}` : '↗ Return to call'}
                 </div>
               </div>
             </div>
-            <PipMuteOverlay callEmbed={callEmbed} />
-            {(['se', 'sw', 'ne', 'nw'] as Corner[]).map((corner) => {
+            {!pipMinimized && <PipMuteOverlay callEmbed={callEmbed} />}
+            {(pipMinimized ? [] : (['se', 'sw', 'ne', 'nw'] as Corner[])).map((corner) => {
               const s = corner.includes('s');
               const e2 = corner.includes('e');
               const dots = [

src/app/components/presence/Presence.tsx

@@ -13,13 +13,11 @@ import {
 import React, { ReactNode } from 'react';
 import * as css from './styles.css';
 import { Presence, usePresenceLabel } from '../../hooks/useUserPresence';
-import { isDndPresence } from '../../utils/busyPresence';
 
 const PresenceToColor: Record<Presence, MainColor> = {
   [Presence.Online]: 'Success',
   [Presence.Unavailable]: 'Warning',
   [Presence.Offline]: 'Secondary',
-  [Presence.Busy]: 'Critical',
 };
 
 type PresenceBadgeProps = {
@@ -33,11 +31,9 @@ export function PresenceBadge({ presence, status, size }: PresenceBadgeProps) {
   // Disturb" to match PresenceRingAvatar and the settings picker (which both
   // special-case 'dnd' → Critical) — the badge was the lone outlier showing a
   // yellow "Idle". The 'dnd' sentinel isn't surfaced as a status line.
-  // [Gitea #283] or MSC3026 busy, which keeps a real status line.
-  const isDnd = isDndPresence(presence, status);
-  const legacyDnd = isDnd && status === 'dnd';
+  const isDnd = presence === Presence.Unavailable && status === 'dnd';
   const displayLabel = isDnd ? 'Do Not Disturb' : label[presence];
-  const displayStatus = legacyDnd ? undefined : status;
+  const displayStatus = isDnd ? undefined : status;
   const ariaLabel = displayStatus ? `${displayLabel} — ${displayStatus}` : displayLabel;
 
   return (

src/app/components/presence/PresenceRingAvatar.tsx

@@ -4,7 +4,6 @@ import { Presence, useUserPresence } from '../../hooks/useUserPresence';
 
 function presenceRingColor(presence: Presence | undefined, status?: string): string | null {
   if (!presence || presence === Presence.Offline) return null;
-  if (presence === Presence.Busy) return color.Critical.Main; // [Gitea #283] DND
   if (presence === Presence.Unavailable) {
     return status === 'dnd' ? color.Critical.Main : color.Warning.Main;
   }

src/app/features/settings/account/Profile.tsx

@@ -38,11 +38,7 @@ import { SettingTile } from '../../../components/setting-tile';
 import { useMatrixClient } from '../../../hooks/useMatrixClient';
 import { getAccountData, setAccountData } from '../../../utils/accountData';
 import { presenceStateFromSetting } from '../../../hooks/usePresenceUpdater';
-import {
-  describePresenceError,
-  setPresenceWithRetry,
-  writePresence,
-} from '../../../utils/presenceWrite';
+import { describePresenceError, setPresenceWithRetry } from '../../../utils/presenceWrite';
 import { useSetting } from '../../../state/hooks/settings';
 import { settingsAtom } from '../../../state/settings';
 import { UserProfile, useUserProfile } from '../../../hooks/useUserProfile';
@@ -558,7 +554,7 @@ function ProfileStatus() {
     localStorage.removeItem(STATUS_MSG_KEY(userId));
     localStorage.removeItem(STATUS_EXPIRY_KEY(userId));
     // Preserve the user's chosen presence when clearing the status message.
-    writePresence(mx, {
+    mx.setPresence({
       presence: presenceStateFromSetting(presenceStatus, hidePresence),
       status_msg: '',
     }).catch(() => undefined);

src/app/hooks/usePresenceUpdater.ts

@@ -1,27 +1,20 @@
 import { useEffect, useRef } from 'react';
 import { SetPresence } from 'matrix-js-sdk';
-import { PresenceDeduper, PresenceWrite, writePresence } from '../utils/presenceWrite';
+import { PresenceDeduper, PresenceWrite } from '../utils/presenceWrite';
 import { useMatrixClient } from './useMatrixClient';
 import { getLastLocalStatusWrite, pickHeartbeatStatus } from '../utils/ownStatusSync';
 import { useSetting } from '../state/hooks/settings';
 import { settingsAtom } from '../state/settings';
-import {
-  BUSY_PRESENCE,
-  BUSY_PRESENCE_FEATURE,
-  isBusyPresenceSupported,
-  setBusyPresenceSupported,
-} from '../utils/busyPresence';
 
 const IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 const ACTIVITY_THROTTLE_MS = 1000;
 
 export type PresenceSetting = 'auto' | 'online' | 'idle' | 'dnd' | 'invisible';
-export type PresenceState = 'online' | 'unavailable' | 'offline' | typeof BUSY_PRESENCE;
+export type PresenceState = 'online' | 'unavailable' | 'offline';
 
 /**
  * Single source of truth for mapping the user's presence preference to the
- * Matrix presence value: auto/online → 'online', idle → 'unavailable', dnd →
- * MSC3026 busy (or 'unavailable' where the server lacks it),
+ * Matrix presence value: auto/online → 'online', idle/dnd → 'unavailable',
  * invisible (or the hidePresence override) → 'offline'. Shared with the Profile
  * status writer so setting/clearing a status message never overrides the user's
  * chosen presence (e.g. outing an Invisible user as online).
@@ -31,10 +24,7 @@ export function presenceStateFromSetting(
   hidePresence: boolean,
 ): PresenceState {
   if (hidePresence || presenceStatus === 'invisible') return 'offline';
-  // [Gitea #283] DND is MSC3026 busy where the server supports it, so status
-  // writes (save / clear / auto-clear) don't downgrade it to "unavailable".
-  if (presenceStatus === 'dnd') return isBusyPresenceSupported() ? BUSY_PRESENCE : 'unavailable';
-  if (presenceStatus === 'idle') return 'unavailable';
+  if (presenceStatus === 'idle' || presenceStatus === 'dnd') return 'unavailable';
   return 'online';
 }
 
@@ -72,7 +62,8 @@ export function usePresenceUpdater() {
     // by a heartbeat that changed nothing.
     const send = (write: PresenceWrite, label: string) => {
       if (!deduper.shouldSend(write)) return Promise.resolve();
-      return writePresence(mx, write)
+      return mx
+        .setPresence(write)
         .then(() => deduper.sent(write))
         .catch((err) => warnPresenceFailure(label, err));
     };
@@ -143,22 +134,7 @@ export function usePresenceUpdater() {
       return undefined;
     }
     if (presenceStatus === 'dnd') {
-      // [Gitea #283] Real "busy" presence where supported: the status text
-      // stays yours. /sync reporting "online" doesn't override busy on
-      // Synapse, so the sync loop can stay online. Older servers keep the
-      // legacy unavailable + "dnd" text encoding.
-      mx.doesServerSupportUnstableFeature(BUSY_PRESENCE_FEATURE)
-        .catch(() => false)
-        .then(async (busy) => {
-          setBusyPresenceSupported(busy);
-          if (!busy) {
-            setUnavailable('dnd');
-            return;
-          }
-          syncPresence(SetPresence.Online);
-          const status = await resolveStatus();
-          send({ presence: BUSY_PRESENCE, ...(status ? { status_msg: status } : {}) }, 'busy');
-        });
+      setUnavailable('dnd');
       return undefined;
     }
 

src/app/hooks/useUserPresence.ts

@@ -6,8 +6,6 @@ export enum Presence {
   Online = 'online',
   Unavailable = 'unavailable',
   Offline = 'offline',
-  // [Gitea #283] MSC3026 busy: Lotus's Do Not Disturb.
-  Busy = 'org.matrix.msc3026.busy',
 }
 
 export type UserPresence = {
@@ -131,7 +129,6 @@ export const usePresenceLabel = (): Record<Presence, string> =>
       [Presence.Online]: 'Online',
       [Presence.Unavailable]: 'Idle',
       [Presence.Offline]: 'Offline',
-      [Presence.Busy]: 'Do Not Disturb',
     }),
     [],
   );

src/app/utils/busyPresence.test.ts

@@ -1,11 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { BUSY_PRESENCE, isDndPresence } from './busyPresence';
-
-test('isDndPresence: busy, or the legacy unavailable + "dnd" text (#283)', () => {
-  assert.equal(isDndPresence(BUSY_PRESENCE, '🎮 Gaming'), true);
-  assert.equal(isDndPresence(BUSY_PRESENCE, undefined), true);
-  assert.equal(isDndPresence('unavailable', 'dnd'), true);
-  assert.equal(isDndPresence('unavailable', 'lunch'), false);
-  assert.equal(isDndPresence('online', 'dnd'), false);
-});

src/app/utils/busyPresence.ts

@@ -1,21 +0,0 @@
-/**
- * [Gitea #283] Do Not Disturb as a real presence state: MSC3026 "busy"
- * (Synapse `experimental_features.msc3026_enabled`). Before, DND was sent as
- * presence `unavailable` with the literal status text "dnd", which replaced
- * your status and showed as "dnd" in other clients.
- */
-export const BUSY_PRESENCE = 'org.matrix.msc3026.busy';
-export const BUSY_PRESENCE_FEATURE = 'org.matrix.msc3026.busy_presence';
-
-let busySupported = false;
-
-/** Recorded by the presence updater from the server's unstable_features. */
-export const setBusyPresenceSupported = (supported: boolean): void => {
-  busySupported = supported;
-};
-
-export const isBusyPresenceSupported = (): boolean => busySupported;
-
-/** Pure: whether a presence means Do Not Disturb (busy, or the legacy "dnd" text). */
-export const isDndPresence = (presence: string | undefined, status: string | undefined): boolean =>
-  presence === BUSY_PRESENCE || (presence === 'unavailable' && status === 'dnd');

src/app/utils/presenceWrite.ts

@@ -1,5 +1,4 @@
-import { MatrixClient, MatrixError, IPresenceOpts, Method } from 'matrix-js-sdk';
-import { BUSY_PRESENCE } from './busyPresence';
+import { MatrixClient, MatrixError } from 'matrix-js-sdk';
 
 /**
  * Synapse rate-limits `PUT /presence/{user}/status` to ONE request per 10 s per
@@ -11,29 +10,7 @@ import { BUSY_PRESENCE } from './busyPresence';
  * and `PresenceDeduper` lets the heartbeat skip writes that would not change
  * anything, so it stops spending the budget in the first place.
  */
-export type PresenceWrite = {
-  // [Gitea #283] or MSC3026 busy (Do Not Disturb)
-  presence: 'online' | 'offline' | 'unavailable' | typeof BUSY_PRESENCE;
-  status_msg?: string;
-};
-
-/**
- * `mx.setPresence` for a PresenceWrite. The SDK refuses anything but the three
- * spec presences ("Bad presence value"), so MSC3026 busy (#283) goes straight
- * to the same endpoint.
- */
-export const writePresence = async (
-  mx: Pick<MatrixClient, 'setPresence'> & Partial<Pick<MatrixClient, 'getSafeUserId' | 'http'>>,
-  write: PresenceWrite,
-): Promise<void> => {
-  if (write.presence !== BUSY_PRESENCE) {
-    await mx.setPresence(write as IPresenceOpts);
-    return;
-  }
-  if (!mx.getSafeUserId || !mx.http) throw new Error('busy presence needs a full MatrixClient');
-  const path = `/presence/${encodeURIComponent(mx.getSafeUserId())}/status`;
-  await mx.http.authedRequest(Method.Put, path, undefined, write);
-};
+export type PresenceWrite = { presence: 'online' | 'offline' | 'unavailable'; status_msg?: string };
 
 const sleep = (ms: number) =>
   new Promise<void>((r) => {
@@ -51,7 +28,7 @@ export async function setPresenceWithRetry(
   for (;;) {
     try {
       // eslint-disable-next-line no-await-in-loop
-      await writePresence(mx, write);
+      await mx.setPresence(write);
       return;
     } catch (e) {
       if (!(e instanceof MatrixError) || e.httpStatus !== 429) throw e;