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,6 +86,7 @@ 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;
@@ -793,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);

src/app/features/shortcuts/KeyboardShortcutsDialog.tsx

@@ -25,9 +25,6 @@ import { settingsAtom } from '../../state/settings';
 import { isMacOS } from '../../utils/user-agent';
 import { KeySymbol } from '../../utils/key-symbol';
 import * as css from './KeyboardShortcutsDialog.css';
-import { BLOCK_HOTKEYS, INLINE_HOTKEYS } from '../../components/editor/keyboard';
-import { MarkType } from '../../components/editor/types';
-import { BLOCK_LABELS, MARK_LABELS, hotkeyKeys, keyCodeLabel } from './shortcutLabels';
 
 /** Global open-state for the keyboard shortcuts help dialog. */
 export const keyboardShortcutsDialogAtom = atom<boolean>(false);
@@ -101,9 +98,6 @@ export function KeyboardShortcutsDialog() {
   const { open, closeDialog } = useKeyboardShortcutsDialog();
   const modalStyle = useModalStyle(480);
   const [enterForNewline] = useSetting(settingsAtom, 'enterForNewline');
-  const [pttMode] = useSetting(settingsAtom, 'pttMode');
-  const [pttKey] = useSetting(settingsAtom, 'pttKey');
-  const [deafenKey] = useSetting(settingsAtom, 'deafenKey');
 
   const modKey = isMacOS() ? KeySymbol.Command : 'Ctrl';
 
@@ -115,8 +109,6 @@ export function KeyboardShortcutsDialog() {
       rows: [
         { description: 'Show keyboard shortcuts', keys: ['?'] },
         { description: 'Close open panel, otherwise mark room as read', keys: [KeySymbol.Escape] },
-        // [Gitea #334] the quick switcher / search was missing
-        { description: 'Quick switcher: jump to a room or person', keys: [modKey, 'K'] },
       ],
     },
     {
@@ -132,26 +124,6 @@ export function KeyboardShortcutsDialog() {
           keys: enterForNewline ? ['Enter'] : [KeySymbol.Shift, 'Enter'],
         },
         { description: 'Send message (always)', keys: [modKey, 'Enter'] },
-        { description: 'Edit your last message (empty composer)', keys: ['↑'] },
-      ],
-    },
-    {
-      // [Gitea #334] generated from the editor's own bindings so they can't drift
-      title: 'Composer formatting',
-      rows: [
-        ...Object.entries(INLINE_HOTKEYS).map(([hotkey, mark]) => ({
-          description:
-            mark === MarkType.StrikeThrough
-              ? `${MARK_LABELS[mark]} (not the browser's Save)`
-              : MARK_LABELS[mark],
-          keys: hotkeyKeys(hotkey, modKey),
-        })),
-        { description: 'Heading 1 / 2 / 3', keys: [modKey, '1 / 2 / 3'] },
-        ...Object.entries(BLOCK_HOTKEYS).map(([hotkey, block]) => ({
-          description: BLOCK_LABELS[block] ?? block,
-          keys: hotkeyKeys(hotkey, modKey),
-        })),
-        { description: 'Clear formatting', keys: [modKey, 'E'] },
       ],
     },
     {
@@ -160,19 +132,6 @@ export function KeyboardShortcutsDialog() {
         { description: 'Reveal message actions (react, reply, more)', keys: ['Hover / focus'] },
       ],
     },
-    {
-      // [Gitea #334] the user's own bindings (Settings → Calls)
-      title: 'Calls',
-      rows: [
-        {
-          description: pttMode
-            ? 'Push to talk (hold)'
-            : 'Push to talk (hold; turn on in Settings → Calls)',
-          keys: [keyCodeLabel(pttKey)],
-        },
-        { description: 'Deafen / undeafen', keys: [keyCodeLabel(deafenKey)] },
-      ],
-    },
   ];
 
   return (

src/app/features/shortcuts/shortcutLabels.test.ts

@@ -1,16 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { hotkeyKeys, keyCodeLabel } from './shortcutLabels';
-
-test('hotkeyKeys (#334)', () => {
-  assert.deepEqual(hotkeyKeys('mod+b', 'Ctrl'), ['Ctrl', 'B']);
-  assert.deepEqual(hotkeyKeys("mod+'", '⌘'), ['⌘', "'"]);
-  assert.deepEqual(hotkeyKeys('mod+[', 'Ctrl'), ['Ctrl', '[']);
-});
-
-test('keyCodeLabel (#334)', () => {
-  assert.equal(keyCodeLabel('KeyM'), 'M');
-  assert.equal(keyCodeLabel('Digit1'), '1');
-  assert.equal(keyCodeLabel('Space'), 'Space');
-  assert.equal(keyCodeLabel(''), 'Not set');
-});

src/app/features/shortcuts/shortcutLabels.ts

@@ -1,29 +0,0 @@
-import { BlockType, MarkType } from '../../components/editor/types';
-
-/** Pure: an is-hotkey string ('mod+b', "mod+'") as keycap labels. */
-export const hotkeyKeys = (hotkey: string, modKey: string): string[] =>
-  hotkey.split('+').map((k) => (k === 'mod' ? modKey : k.length === 1 ? k.toUpperCase() : k));
-
-/** Pure: a KeyboardEvent.code ('KeyM', 'Digit1', 'Space') as a keycap label. */
-export const keyCodeLabel = (code: string | undefined): string => {
-  if (!code) return 'Not set';
-  if (/^Key[A-Z]$/.test(code)) return code.slice(3);
-  if (/^Digit\d$/.test(code)) return code.slice(5);
-  return code;
-};
-
-export const MARK_LABELS: Record<MarkType, string> = {
-  [MarkType.Bold]: 'Bold',
-  [MarkType.Italic]: 'Italic',
-  [MarkType.Underline]: 'Underline',
-  [MarkType.StrikeThrough]: 'Strikethrough',
-  [MarkType.Code]: 'Inline code',
-  [MarkType.Spoiler]: 'Spoiler',
-};
-
-export const BLOCK_LABELS: Partial<Record<BlockType, string>> = {
-  [BlockType.OrderedList]: 'Numbered list',
-  [BlockType.UnorderedList]: 'Bulleted list',
-  [BlockType.BlockQuote]: 'Quote',
-  [BlockType.CodeBlock]: 'Code block',
-};

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;
+}