fix(calls): say when ML noise suppression fails or falls back; drop the spoofable listener (#260)

The fork reports what actually runs as io.lotus.denoise_state, but the
host never listened ("unsupported action"), so a failed ML denoiser
silently published the raw mic. Handle it: toast when ML did not start
or fell back to another model. Remove LotusDenoiseFeature, which waited
for a postMessage nothing sends any more and accepted it from any frame.

Refs #260

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5

src/app/components/CallEmbedProvider.tsx

@@ -86,12 +86,10 @@ import { CallAvatarAnimation } from '../styles/Animations.css';
 import { webRTCSupported } from '../utils/rtc';
 import { CallsUnavailableMessage } from '../features/call/CallsUnavailable';
 import { zIndices } from '../styles/zIndex';
+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;
 
 type Corner = 'se' | 'sw' | 'ne' | 'nw';
 
@@ -796,6 +794,7 @@ function CallUtils({ embed, joined }: { embed: CallEmbed; joined: boolean }) {
   useCallPolicyRevokedToast(embed, joined);
   useCallEndedToast(embed);
   useScreenshareNotices(embed);
+  useDenoiseNotices(embed);
   // [Gitea #43] The in-frame screenshare button follows the same room policy
   // as the host bar's (hidden where the server would refuse the share).
   const { allowScreenshare } = useRoomCallPolicy(embed.room);
@@ -984,28 +983,6 @@ 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,26 +1080,6 @@ 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 => {
@@ -1441,50 +1398,19 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
                 position: 'absolute',
                 inset: 0,
                 zIndex: 1,
-                // Minimised: cover the frame so only the bar shows.
-                background: pipMinimized ? color.Surface.Container : 'transparent',
+                background: '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',
-                  ...(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 && (
+              <div style={{ display: 'flex', gap: config.space.S100, alignItems: 'center' }}>
+                {document.fullscreenEnabled && (
                   <IconButton
                     type="button"
                     size="300"
@@ -1516,23 +1442,14 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
                     fontSize: '11px',
                     fontWeight: 600,
                     pointerEvents: 'none',
-                    ...(pipMinimized
-                      ? {
-                          flexGrow: 1,
-                          minWidth: 0,
-                          overflow: 'hidden',
-                          textOverflow: 'ellipsis',
-                          whiteSpace: 'nowrap',
-                        }
-                      : {}),
                   }}
                 >
-                  {pipMinimized ? `↗ ${callEmbed.room.name ?? 'Call'}` : '↗ Return to call'}
+                  ↗ Return to call
                 </div>
               </div>
             </div>
-            {!pipMinimized && <PipMuteOverlay callEmbed={callEmbed} />}
-            {(pipMinimized ? [] : (['se', 'sw', 'ne', 'nw'] as Corner[])).map((corner) => {
+            <PipMuteOverlay callEmbed={callEmbed} />
+            {(['se', 'sw', 'ne', 'nw'] as Corner[]).map((corner) => {
               const s = corner.includes('s');
               const e2 = corner.includes('e');
               const dots = [

src/app/hooks/useDenoiseNotices.ts

@@ -0,0 +1,38 @@
+import { useEffect, useRef } from 'react';
+import { useSetAtom } from 'jotai';
+import { Icons } from 'folds';
+import { CallEmbed } from '../plugins/call';
+import { toastQueueAtom } from '../state/toast';
+import { useSetting } from '../state/hooks/settings';
+import { settingsAtom } from '../state/settings';
+import { denoiseNotice, DenoiseStateReport } from '../utils/denoiseNotice';
+
+/**
+ * [Gitea #260] Tell the user when ML noise suppression didn't attach (raw mic)
+ * or fell back to another model. The fork's `io.lotus.denoise_state` used to
+ * go unanswered ("unsupported action"), so failures were silent.
+ */
+export function useDenoiseNotices(embed: CallEmbed): void {
+  const setToast = useSetAtom(toastQueueAtom);
+  const [mode] = useSetting(settingsAtom, 'callNoiseSuppression');
+  const [model] = useSetting(settingsAtom, 'callDenoiseModel');
+  const latest = useRef({ mode, model });
+  latest.current = { mode, model };
+  useEffect(
+    () =>
+      embed.listenAction<{ data?: DenoiseStateReport }>('io.lotus.denoise_state', (evt) => {
+        if (latest.current.mode !== 'ml') return;
+        const body = denoiseNotice(latest.current.model, evt.detail?.data);
+        if (!body) return;
+        setToast({
+          id: `denoise-state-${Date.now()}`,
+          iconSrc: Icons.Mic,
+          displayName: 'Noise suppression',
+          body,
+          roomName: embed.room.name ?? 'Voice call',
+          roomId: embed.roomId,
+        });
+      }),
+    [embed, setToast],
+  );
+}

src/app/pages/client/ClientNonUIFeatures.tsx

@@ -1060,32 +1060,6 @@ function TauriUpdateFeature() {
   return null;
 }
 
-function LotusDenoiseFeature() {
-  const setToast = useSetAtom(toastQueueAtom);
-
-  useEffect(() => {
-    const handleMessage = (event: MessageEvent) => {
-      if (event.data?.type === 'lotus-denoise-status') {
-        const { active, error } = event.data;
-        if (!active) {
-          setToast({
-            id: `denoise-fail-${Date.now()}`,
-            displayName: 'Audio Quality',
-            body: `ML Noise Suppression failed: ${error || 'Unknown error'}. Falling back to raw mic.`,
-            roomName: 'System',
-            roomId: '',
-          });
-        }
-      }
-    };
-
-    window.addEventListener('message', handleMessage);
-    return () => window.removeEventListener('message', handleMessage);
-  }, [setToast]);
-
-  return null;
-}
-
 // Registers the global `?` shortcut (ignored while typing) and renders the
 // keyboard-shortcuts help dialog. Headless — the dialog self-gates on its atom.
 function KeyboardShortcutsFeature() {
@@ -1167,7 +1141,6 @@ export function ClientNonUIFeatures({ children }: ClientNonUIFeaturesProps) {
       <CloseBehaviorPrompt />
       <ConsentRequiredPrompt />
       <OutboxFeature />
-      <LotusDenoiseFeature />
       <DeepLinkNavigator />
       <KeyboardShortcutsFeature />
       {children}

src/app/utils/denoiseNotice.test.ts

@@ -0,0 +1,17 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { denoiseNotice } from './denoiseNotice';
+
+test('denoiseNotice: says when ML is off or fell back (#260)', () => {
+  assert.equal(denoiseNotice('deepfilternet', { active: true, model: 'deepfilternet' }), undefined);
+  assert.match(
+    denoiseNotice('deepfilternet', { active: true, model: 'rnnoise' }) ?? '',
+    /^DeepFilterNet 3 couldn't start, so noise suppression is using RNNoise instead\.$/,
+  );
+  assert.match(
+    denoiseNotice('rnnoise', { active: false, error: 'boom' }) ?? '',
+    /unfiltered audio/,
+  );
+  assert.equal(denoiseNotice('rnnoise', undefined), undefined);
+  assert.equal(denoiseNotice('rnnoise', { model: 'x' }), undefined);
+});

src/app/utils/denoiseNotice.ts

@@ -0,0 +1,29 @@
+/**
+ * [Gitea #260] The fork reports what noise suppression actually runs as
+ * `io.lotus.denoise_state { active, model, error? }`. Pure: the toast text for
+ * a report, or undefined when what runs is what the user picked.
+ */
+export type DenoiseStateReport = { active?: unknown; model?: unknown; error?: unknown };
+
+const MODEL_NAMES: Record<string, string> = {
+  rnnoise: 'RNNoise',
+  speex: 'Speex',
+  dtln: 'DTLN',
+  deepfilternet: 'DeepFilterNet 3',
+};
+const modelName = (m: unknown): string =>
+  typeof m === 'string' ? (MODEL_NAMES[m] ?? m) : 'the selected model';
+
+export function denoiseNotice(
+  requestedModel: string,
+  report: DenoiseStateReport | undefined,
+): string | undefined {
+  if (!report || typeof report.active !== 'boolean') return undefined;
+  if (!report.active) {
+    return `ML noise suppression couldn't start, so your microphone is sending unfiltered audio. You can pick another model in Settings → Calls.`;
+  }
+  if (typeof report.model === 'string' && report.model !== requestedModel) {
+    return `${modelName(requestedModel)} couldn't start, so noise suppression is using ${modelName(report.model)} instead.`;
+  }
+  return undefined;
+}