Merge remote-tracking branch 'origin/lotus' into fix/status-expiry-account-data

# Conflicts:
#	src/app/pages/client/ClientNonUIFeatures.tsx
#	src/types/matrix/accountData.ts

src/app/features/call/CallSoundboard.tsx

@@ -50,6 +50,14 @@ type FlatClip = {
  * A management toggle reveals the pack editors (personal + this room, if
  * permitted). Space-wide packs are managed from Space settings.
  */
+/** [EC#13, EC#47] Why the fork refused to play a clip, for the user. */
+export const soundboardRefusalText = (reason: string | undefined): string => {
+  if (reason === 'muted') return 'Unmute your microphone to play a soundboard clip.';
+  if (reason === 'not_permitted')
+    return "The soundboard isn't available in this voice channel (only microphone audio is allowed here).";
+  return 'Could not play that clip.';
+};
+
 export function CallSoundboard({ callEmbed }: CallSoundboardProps) {
   const mx = useMatrixClient();
   const { room } = callEmbed;
@@ -122,13 +130,10 @@ export function CallSoundboard({ callEmbed }: CallSoundboardProps) {
           .catch(() => undefined);
         const result = await callEmbed.control.injectAudio(url, vol, clipBytes);
         if (!result.played) {
-          // [EC#13] Refused fork-side (only reason today: local mic muted) —
+          // [EC#13, EC#47] Refused fork-side (mic muted, or the room's token
+          // only allows the microphone source, as in audio-only rooms) —
           // don't play it locally either, or the user would think it went out.
-          setError(
-            result.reason === 'muted'
-              ? 'Unmute your microphone to play a soundboard clip.'
-              : 'Could not play that clip.',
-          );
+          setError(soundboardRefusalText(result.reason));
           done();
           return;
         }

src/app/features/call/CallView.tsx

@@ -6,12 +6,13 @@ import {
   useCallJoined,
   useCallEmbedPlacementSync,
   useCallLoadError,
+  useCallStart,
 } from '../../hooks/useCallEmbed';
 import { callEmbedAtom } from '../../state/callEmbed';
 import { ContainerColor } from '../../styles/ContainerColor.css';
 import { PrescreenControls } from './PrescreenControls';
 import { usePowerLevelsContext } from '../../hooks/usePowerLevels';
-import { useRoom } from '../../hooks/useRoom';
+import { useIsDirectRoom, useRoom } from '../../hooks/useRoom';
 import { useRoomCreators } from '../../hooks/useRoomCreators';
 import { useRoomPermissions } from '../../hooks/useRoomPermissions';
 import { useMatrixClient } from '../../hooks/useMatrixClient';
@@ -160,6 +161,16 @@ function CallLoadErrorMessage() {
   // prescreen, where they can choose to join again.
   const dismiss = () => setCallEmbed(undefined);
 
+  // [Gitea #301] Try again: start a fresh embed for the same room with the
+  // same mic/camera/sound choices (starting one disposes the hung one).
+  const callEmbed = useCallEmbed();
+  const startCall = useCallStart(useIsDirectRoom());
+  const retry = () => {
+    if (!callEmbed) return;
+    const { room, control } = callEmbed;
+    startCall(room, { microphone: control.microphone, video: control.video, sound: control.sound });
+  };
+
   return (
     <Box
       className={css.CallViewContent}
@@ -173,6 +184,9 @@ function CallLoadErrorMessage() {
         The call failed to load. Check your connection and try again.
       </Text>
       <Box gap="200" alignItems="Center">
+        <Button variant="Primary" size="300" radii="400" onClick={retry} disabled={!callEmbed}>
+          <Text size="B400">Try again</Text>
+        </Button>
         <Button variant="Secondary" fill="Soft" size="300" radii="400" onClick={dismiss}>
           <Text size="B400">Back</Text>
         </Button>

src/app/features/common-settings/developer-tools/StateEventEditor.tsx

@@ -275,7 +275,7 @@ export function StateEventEditor({ type, stateKey, requestClose }: StateEventEdi
             </Chip>
           </Box>
           <Box shrink="No">
-            <IconButton onClick={requestClose} variant="Surface" aria-label="Close">
+            <IconButton type="button" onClick={requestClose} variant="Surface" aria-label="Close">
               <Icon src={Icons.Cross} />
             </IconButton>
           </Box>

src/app/features/common-settings/permissions/PowersEditor.tsx

@@ -40,7 +40,7 @@ import { useImagePackRooms } from '../../../hooks/useImagePackRooms';
 import { roomToParentsAtom } from '../../../state/room/roomToParents';
 import { useMediaAuthentication } from '../../../hooks/useMediaAuthentication';
 import { useMatrixClient } from '../../../hooks/useMatrixClient';
-import { useFilePicker } from '../../../hooks/useFilePicker';
+import { useStrippedFilePicker } from '../../../hooks/useStrippedFilePicker';
 import { CompactUploadCardRenderer } from '../../../components/upload-card';
 import { createUploadAtom, UploadSuccess } from '../../../state/upload';
 import { AsyncStatus, useAsyncCallback } from '../../../hooks/useAsyncCallback';
@@ -68,7 +68,7 @@ function EditPower({ maxPower, power, tag, onSave, onClose }: EditPowerProps) {
   const imagePackRooms = useImagePackRooms(room.roomId, roomToParents);
 
   const [iconFile, setIconFile] = useState<File>();
-  const pickFile = useFilePicker(setIconFile, false);
+  const pickFile = useStrippedFilePicker(setIconFile, false);
 
   const [tagColor, setTagColor] = useState<string | undefined>(tag?.color);
   const [tagIcon, setTagIcon] = useState<MemberPowerTagIcon | undefined>(tag?.icon);

src/app/features/message-search/useMessageSearch.test.ts

@@ -1,6 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
+  foldEdits,
   filterGroupsByDateRange,
   filterGroupsByMsgType,
   filterGroupsByPinned,
@@ -109,3 +110,47 @@ test('filterGroupsByPinned: keeps pinned items and drops empty groups', () => {
     ['$2'],
   );
 });
+
+const sr = (eventId: string, ts: number, content: Record<string, unknown>) =>
+  ({
+    rank: 1,
+    result: {
+      event_id: eventId,
+      room_id: '!r:x',
+      origin_server_ts: ts,
+      type: 'm.room.message',
+      content,
+    },
+  }) as unknown as Parameters<typeof foldEdits>[0][number];
+
+test('foldEdits: one row per message, showing the latest edit (#288)', () => {
+  const edit = (id: string, ts: number, body: string) =>
+    sr(id, ts, {
+      body: `* ${body}`,
+      'm.new_content': { body },
+      'm.relates_to': { rel_type: 'm.replace', event_id: '$orig' },
+    });
+  const out = foldEdits([
+    edit('$e2', 30, 'Tuesday 11am room B'),
+    sr('$orig', 10, { body: 'Monday 10am room A' }),
+    edit('$e1', 20, 'Tuesday 10am room A'),
+    sr('$other', 5, { body: 'meeting notes' }),
+  ]);
+  assert.deepEqual(
+    out.map((r) => r.result.event_id),
+    ['$orig', '$other'],
+  );
+  assert.deepEqual(out[0].result.content['m.new_content'], { body: 'Tuesday 11am room B' });
+  assert.equal(out[0].result.content.body, 'Monday 10am room A');
+});
+
+test('foldEdits: an edit whose original did not match stands in for it', () => {
+  const out = foldEdits([
+    sr('$e1', 20, {
+      'm.new_content': { body: 'x' },
+      'm.relates_to': { rel_type: 'm.replace', event_id: '$orig' },
+    }),
+  ]);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].result.event_id, '$orig');
+});

src/app/features/message-search/useMessageSearch.ts

@@ -96,10 +96,58 @@ export const filterGroupsByDateRange = (
     .filter((group) => group.items.length > 0);
 };
 
+/**
+ * [Gitea #288] Server search also returns `m.replace` events, so an edited
+ * message showed once per version. Fold each edit into its message: one row,
+ * at the first position any version ranked, showing the latest text and
+ * pointing at the original event (so "jump" lands on the real message).
+ */
+export const foldEdits = (results: ISearchResult[]): ISearchResult[] => {
+  const targetOf = (r: ISearchResult): string => {
+    const rel = r.result.content?.['m.relates_to'];
+    return rel?.rel_type === 'm.replace' && typeof rel.event_id === 'string'
+      ? rel.event_id
+      : r.result.event_id;
+  };
+  const isEdit = (r: ISearchResult) => targetOf(r) !== r.result.event_id;
+  const order: string[] = [];
+  const originals = new Map<string, ISearchResult>();
+  const latestEdit = new Map<string, ISearchResult>();
+  results.forEach((r) => {
+    const target = targetOf(r);
+    if (!originals.has(target) && !latestEdit.has(target)) order.push(target);
+    if (!isEdit(r)) {
+      originals.set(target, r);
+      return;
+    }
+    const prev = latestEdit.get(target);
+    if (!prev || r.result.origin_server_ts > prev.result.origin_server_ts)
+      latestEdit.set(target, r);
+  });
+  return order.map((target) => {
+    const original = originals.get(target);
+    const edit = latestEdit.get(target);
+    const newContent = edit?.result.content?.['m.new_content'];
+    if (original && !newContent) return original;
+    if (original) {
+      return {
+        ...original,
+        result: {
+          ...original.result,
+          content: { ...original.result.content, 'm.new_content': newContent },
+        },
+      };
+    }
+    // Only an edit matched: show it as its message.
+    const only = edit as ISearchResult;
+    return { ...only, result: { ...only.result, event_id: target } };
+  });
+};
+
 const groupSearchResult = (results: ISearchResult[]): ResultGroup[] => {
   const groups: ResultGroup[] = [];
 
-  results.forEach((item) => {
+  foldEdits(results).forEach((item) => {
     const roomId = item.result.room_id;
     const resultItem: ResultItem = {
       rank: item.rank,

src/app/features/room-nav/RoomNavItem.tsx

@@ -80,7 +80,7 @@ import {
   setRoomNotificationPreference,
 } from '../../hooks/useRoomsNotificationPreferences';
 import { RoomNotificationModeSwitcher } from '../../components/RoomNotificationSwitcher';
-import { scheduleMuteTimer, unmuteRoom } from './muteTimers';
+import { clearMuteTimer, scheduleMuteTimer } from './muteTimers';
 import { getRoomCreatorsForRoomId, useRoomCreators } from '../../hooks/useRoomCreators';
 import { getRoomPermissionsAPI, useRoomPermissions } from '../../hooks/useRoomPermissions';
 import { InviteUserPrompt } from '../../components/invite-user-prompt';
@@ -381,9 +381,10 @@ const RoomNavItemMenu = forwardRef<HTMLDivElement, RoomNavItemMenuProps>(
           prevMode,
         ).catch(() => {});
         if (durationMs !== null) {
-          scheduleMuteTimer(room.roomId, durationMs, () => {
-            unmuteRoom(mx, room.roomId);
-          });
+          await scheduleMuteTimer(mx, room.roomId, durationMs).catch(() => {});
+        } else {
+          // An indefinite mute replaces any timed one.
+          await clearMuteTimer(mx, room.roomId);
         }
         requestClose();
       },

src/app/features/room-nav/muteTimers.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { RoomNotificationMode } from '../../hooks/useRoomsNotificationPreferences';
-import { shouldResetMuteOnUnmute } from './muteTimers';
+import { muteTimersContent, parseMuteTimers, shouldResetMuteOnUnmute } from './muteTimers';
 
 test('resets to Unset when the room is still Mute at expiry', () => {
   assert.equal(shouldResetMuteOnUnmute(RoomNotificationMode.Mute), true);
@@ -18,3 +18,16 @@ test('does not reset when the user switched to Special messages during the mute
 test('does not reset when the mode is already Unset', () => {
   assert.equal(shouldResetMuteOnUnmute(RoomNotificationMode.Unset), false);
 });
+
+test('parseMuteTimers / muteTimersContent round-trip and tolerate garbage (#333)', () => {
+  const entries = [
+    { roomId: '!a:x', unmuteAt: 1000 },
+    { roomId: '!b:x', unmuteAt: 2000 },
+  ];
+  assert.deepEqual(parseMuteTimers(muteTimersContent(entries)), entries);
+  assert.deepEqual(parseMuteTimers({ timers: { '!a:x': 'soon', '!b:x': 5 } }), [
+    { roomId: '!b:x', unmuteAt: 5 },
+  ]);
+  assert.deepEqual(parseMuteTimers(undefined), []);
+  assert.deepEqual(parseMuteTimers({ timers: null }), []);
+});

src/app/features/room-nav/muteTimers.ts

@@ -7,7 +7,7 @@ import {
   setRoomNotificationPreference,
 } from '../../hooks/useRoomsNotificationPreferences';
 
-// localStorage key for timed mute timers
+// Legacy localStorage key (before #333); migrated into account data once.
 export const MUTE_TIMERS_KEY = 'io.lotus.mute_timers';
 
 // setTimeout's delay is a signed 32-bit int; larger values overflow and fire
@@ -16,17 +16,60 @@ export const MAX_MUTE_TIMEOUT_MS = 2_147_483_647;
 
 export type MuteTimerEntry = { roomId: string; unmuteAt: number };
 
-export function loadMuteTimers(): MuteTimerEntry[] {
-  try {
-    const parsed = JSON.parse(localStorage.getItem(MUTE_TIMERS_KEY) ?? '[]');
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
+/** Pure: the timers in an `io.lotus.mute_timers` account data content. */
+export function parseMuteTimers(content: unknown): MuteTimerEntry[] {
+  const timers = (content as { timers?: unknown } | undefined)?.timers;
+  if (!timers || typeof timers !== 'object') return [];
+  return Object.entries(timers as Record<string, unknown>)
+    .filter((e): e is [string, number] => typeof e[1] === 'number' && Number.isFinite(e[1]))
+    .map(([roomId, unmuteAt]) => ({ roomId, unmuteAt }));
 }
 
-export function saveMuteTimers(timers: MuteTimerEntry[]): void {
-  localStorage.setItem(MUTE_TIMERS_KEY, JSON.stringify(timers));
+/** Pure: account data content for `entries`. */
+export const muteTimersContent = (entries: MuteTimerEntry[]) => ({
+  timers: Object.fromEntries(entries.map((e) => [e.roomId, e.unmuteAt])),
+});
+
+/**
+ * [Gitea #333] Timed mutes live in account data: the mute itself is a
+ * server-side push rule on every device, so the timer must be too — kept in one
+ * browser's localStorage, only that device ever unmuted (and never after a
+ * logout there).
+ */
+export function loadMuteTimers(mx: MatrixClient): MuteTimerEntry[] {
+  return parseMuteTimers(getAccountData(mx, AccountDataEvent.LotusMuteTimers)?.getContent());
+}
+
+async function saveMuteTimers(mx: MatrixClient, entries: MuteTimerEntry[]): Promise<void> {
+  await mx.setAccountData(
+    AccountDataEvent.LotusMuteTimers as never,
+    muteTimersContent(entries) as never,
+  );
+}
+
+/** Move timers kept in this browser's localStorage (pre-#333) into account data. */
+export async function migrateLocalMuteTimers(mx: MatrixClient): Promise<void> {
+  let legacy: MuteTimerEntry[] = [];
+  try {
+    const parsed = JSON.parse(localStorage.getItem(MUTE_TIMERS_KEY) ?? '[]');
+    legacy = Array.isArray(parsed)
+      ? parsed.filter(
+          (e): e is MuteTimerEntry =>
+            !!e && typeof e.roomId === 'string' && typeof e.unmuteAt === 'number',
+        )
+      : [];
+  } catch {
+    legacy = [];
+  }
+  if (legacy.length === 0) return;
+  const current = loadMuteTimers(mx);
+  const merged = [...current, ...legacy.filter((l) => !current.some((c) => c.roomId === l.roomId))];
+  await saveMuteTimers(mx, merged);
+  try {
+    localStorage.removeItem(MUTE_TIMERS_KEY);
+  } catch {
+    /* ignore */
+  }
 }
 
 // Pure decision for the unmute guard: a timed mute should only be reset back to
@@ -77,12 +120,30 @@ export async function unmuteRoom(mx: MatrixClient, roomId: string): Promise<void
       RoomNotificationMode.Mute,
     ).catch(() => {});
   }
-  saveMuteTimers(loadMuteTimers().filter((e) => e.roomId !== roomId));
+  await clearMuteTimer(mx, roomId);
 }
 
-export function scheduleMuteTimer(roomId: string, durationMs: number, onUnmute: () => void): void {
-  const unmuteAt = Date.now() + durationMs;
-  const existing = loadMuteTimers().filter((e) => e.roomId !== roomId);
-  saveMuteTimers([...existing, { roomId, unmuteAt }]);
-  setTimeout(onUnmute, Math.min(durationMs, MAX_MUTE_TIMEOUT_MS));
+/** Drop a room's timer (e.g. it was muted indefinitely or unmuted by hand). */
+export async function clearMuteTimer(mx: MatrixClient, roomId: string): Promise<void> {
+  const timers = loadMuteTimers(mx);
+  if (!timers.some((e) => e.roomId === roomId)) return;
+  await saveMuteTimers(
+    mx,
+    timers.filter((e) => e.roomId !== roomId),
+  ).catch(() => {});
+}
+
+/**
+ * Record when a timed mute ends. MuteTimerRestore (on every Lotus device)
+ * schedules the unmute from account data, so whichever is online at expiry
+ * lifts it.
+ */
+export async function scheduleMuteTimer(
+  mx: MatrixClient,
+  roomId: string,
+  durationMs: number,
+): Promise<void> {
+  const unmuteAt = Date.now() + durationMs;
+  const existing = loadMuteTimers(mx).filter((e) => e.roomId !== roomId);
+  await saveMuteTimers(mx, [...existing, { roomId, unmuteAt }]);
 }

src/app/features/room-settings/PolicyListViewer.tsx

@@ -17,6 +17,7 @@ import { Page, PageContent, PageHeader } from '../../components/page';
 import { useMatrixClient } from '../../hooks/useMatrixClient';
 import { SequenceCard } from '../../components/sequence-card';
 import { SequenceCardStyle } from '../common-settings/styles.css';
+import { dedupePolicyEntries, PolicyEntry, recommendationLabel } from './policyEntries';
 
 // ── Policy event types ────────────────────────────────────────────────────────
 
@@ -38,13 +39,6 @@ type PolicyRuleContent = {
   recommendation?: string;
 };
 
-type PolicyEntry = {
-  entity: string;
-  reason: string;
-  recommendation: string;
-  stateKey: string;
-};
-
 type PolicyTab = 'users' | 'rooms' | 'servers';
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -53,13 +47,6 @@ function isGlob(entity: string): boolean {
   return entity.includes('*') || entity.includes('?');
 }
 
-function recommendationLabel(rec: string): string {
-  // `m.ban` is the stable value; `org.matrix.mjolnir.ban` is the legacy
-  // (pre-stabilization) recommendation still emitted by older bots.
-  if (rec === 'm.ban' || rec === 'org.matrix.mjolnir.ban') return 'Ban';
-  return rec;
-}
-
 /**
  * Fetch all state events of a given type from a room's live forward state.
  * Uses the raw matrix-js-sdk `getStateEvents` API which accepts any string type.
@@ -84,23 +71,6 @@ function extractPolicyEntries(events: MatrixEvent[]): PolicyEntry[] {
     .filter((entry) => entry.entity !== '');
 }
 
-/**
- * Merge policy entries from the stable and legacy event types for a rule
- * kind, de-duplicating by entity+recommendation so a room that emits both a
- * stable and a legacy rule for the same target isn't double-listed.
- */
-export function dedupePolicyEntries(entries: PolicyEntry[]): PolicyEntry[] {
-  const seen = new Set<string>();
-  const result: PolicyEntry[] = [];
-  entries.forEach((entry) => {
-    const key = `${entry.entity} ${entry.recommendation}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    result.push(entry);
-  });
-  return result;
-}
-
 // ── Entry row ─────────────────────────────────────────────────────────────────
 
 function PolicyEntryRow({ entry }: { entry: PolicyEntry }) {

src/app/features/room-settings/policyEntries.test.ts

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { dedupePolicyEntries, recommendationLabel } from './policyEntries';
+
+const e = (entity: string, recommendation: string, stateKey = entity) => ({
+  entity,
+  reason: 'spam waves',
+  recommendation,
+  stateKey,
+});
+
+test('dedupePolicyEntries: a stable rule and its legacy twin show once (#321)', () => {
+  const out = dedupePolicyEntries([
+    e('@spammer:evil.example', 'm.ban'),
+    e('@spammer:evil.example', 'org.matrix.mjolnir.ban'),
+    e('@*:spam.example', 'm.ban'),
+  ]);
+  assert.deepEqual(
+    out.map((x) => x.entity),
+    ['@spammer:evil.example', '@*:spam.example'],
+  );
+});
+
+test('dedupePolicyEntries: different recommendations stay separate', () => {
+  assert.equal(dedupePolicyEntries([e('@a:x', 'm.ban'), e('@a:x', 'org.example.mute')]).length, 2);
+});
+
+test('recommendationLabel', () => {
+  assert.equal(recommendationLabel('m.ban'), 'Ban');
+  assert.equal(recommendationLabel('org.matrix.mjolnir.ban'), 'Ban');
+  assert.equal(recommendationLabel('org.example.mute'), 'org.example.mute');
+});

src/app/features/room-settings/policyEntries.ts

@@ -0,0 +1,35 @@
+export type PolicyEntry = {
+  entity: string;
+  reason: string;
+  recommendation: string;
+  stateKey: string;
+};
+
+/**
+ * `m.ban` is the stable value; `org.matrix.mjolnir.ban` is the legacy
+ * (pre-stabilization) recommendation still emitted by older bots.
+ */
+export const normalizeRecommendation = (rec: string): string =>
+  rec === 'org.matrix.mjolnir.ban' ? 'm.ban' : rec;
+
+export function recommendationLabel(rec: string): string {
+  if (normalizeRecommendation(rec) === 'm.ban') return 'Ban';
+  return rec;
+}
+
+/**
+ * Merge stable and legacy rule lists, one entry per entity + recommendation.
+ * [Gitea #321] Keyed on the normalised recommendation: a bot publishing both
+ * `m.ban` and its `org.matrix.mjolnir.ban` twin showed the rule twice.
+ */
+export function dedupePolicyEntries(entries: PolicyEntry[]): PolicyEntry[] {
+  const seen = new Set<string>();
+  const result: PolicyEntry[] = [];
+  entries.forEach((entry) => {
+    const key = `${entry.entity} ${normalizeRecommendation(entry.recommendation)}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    result.push(entry);
+  });
+  return result;
+}

src/app/features/room/PollCreator.tsx

@@ -143,7 +143,7 @@ export function PollCreator({ roomId, threadRootId, onClose }: PollCreatorProps)
                   Create Poll
                 </Text>
               </Box>
-              <IconButton size="300" radii="300" onClick={onClose} aria-label="Close">
+              <IconButton type="button" size="300" radii="300" onClick={onClose} aria-label="Close">
                 <Icon src={Icons.Cross} />
               </IconButton>
             </Header>

src/app/features/room/ReportRoomModal.tsx

@@ -118,7 +118,7 @@ export function ReportRoomModal({ roomId, onClose }: ReportRoomModalProps) {
                   Report Room
                 </Text>
               </Box>
-              <IconButton size="300" onClick={onClose} radii="300" aria-label="Close">
+              <IconButton type="button" size="300" onClick={onClose} radii="300" aria-label="Close">
                 <Icon src={Icons.Cross} />
               </IconButton>
             </Header>

src/app/features/room/ReportUserModal.tsx

@@ -124,7 +124,7 @@ export function ReportUserModal({ userId, onClose }: ReportUserModalProps) {
                   Report User
                 </Text>
               </Box>
-              <IconButton size="300" onClick={onClose} radii="300" aria-label="Close">
+              <IconButton type="button" size="300" onClick={onClose} radii="300" aria-label="Close">
                 <Icon src={Icons.Cross} />
               </IconButton>
             </Header>

src/app/features/room/RoomTimeline.tsx

@@ -90,6 +90,7 @@ import {
   isMembershipChanged,
   reactionOrEditEvent,
   sendRoomEvent,
+  isFromFilteredTimelineSet,
 } from '../../utils/room';
 import { getLastEditDiff } from '../../utils/editDiff';
 import { tick } from '../../utils/haptics';
@@ -138,7 +139,7 @@ import { useMediaAuthentication } from '../../hooks/useMediaAuthentication';
 import { useIgnoredUsers } from '../../hooks/useIgnoredUsers';
 import { useImagePackRooms } from '../../hooks/useImagePackRooms';
 import { useIsDirectRoom } from '../../hooks/useRoom';
-import { isRingableRoom } from '../../utils/callRing';
+import { declinedRing, isRingableRoom } from '../../utils/callRing';
 import { useOpenUserRoomProfile } from '../../state/hooks/userRoomProfile';
 import { useSpaceOptionally } from '../../hooks/useSpace';
 import { useRoomCreators } from '../../hooks/useRoomCreators';
@@ -410,6 +411,9 @@ const useLiveEventArrive = (room: Room, onArrive: (mEvent: MatrixEvent) => void)
       data,
     ) => {
       if (eventRoom?.roomId !== room.roomId || !data.liveEvent) return;
+      // [Gitea #259] The media gallery / activity log register filtered timeline
+      // sets whose events the room re-emits as live: don't count them twice.
+      if (isFromFilteredTimelineSet(data)) return;
       onArrive(mEvent);
     };
     const handleRedaction: RoomEventHandlerMap[RoomEvent.Redaction] = (mEvent, eventRoom) => {
@@ -2037,6 +2041,9 @@ export function RoomTimeline({ room, eventId, roomInputRef, editor }: RoomTimeli
         // Same rule as ringing: no "Missed call" in voice rooms or space
         // channels, where starting a call is just joining the channel.
         if (!isRingableRoom(room, direct)) return null;
+        // [Gitea #313] A call we declined isn't a missed call.
+        const ringRef = mEvent.getRelation()?.event_id;
+        if (declinedRing(room, [mEventId, ringRef], mx.getSafeUserId())) return null;
         const content = mEvent.getContent();
         const mention =
           content['m.mentions']?.room ||

src/app/features/room/ScheduleMessageModal.tsx

@@ -202,7 +202,7 @@ export function ScheduleMessageModal({
                   {title}
                 </Text>
               </Box>
-              <IconButton size="300" radii="300" onClick={onClose} aria-label="Close">
+              <IconButton type="button" size="300" radii="300" onClick={onClose} aria-label="Close">
                 <Icon src={Icons.Cross} />
               </IconButton>
             </Header>

src/app/features/room/ScheduledMessagesTray.tsx

@@ -4,7 +4,12 @@ import { IContent } from 'matrix-js-sdk';
 import { Box, Button, Icon, IconButton, Icons, Text, color, config } from 'folds';
 import { useMatrixClient } from '../../hooks/useMatrixClient';
 import { scheduledMessagesAtom, ScheduledMessage } from '../../state/scheduledMessages';
-import { cancelScheduledMessage, sendScheduledMessageNow } from '../../utils/scheduledMessages';
+import {
+  cancelScheduledMessage,
+  fetchScheduledMessages,
+  groupScheduledByRoom,
+  sendScheduledMessageNow,
+} from '../../utils/scheduledMessages';
 import { ScheduleMessageModal } from './ScheduleMessageModal';
 import { useTimestampFormatter } from '../../hooks/useTimestampFormatter';
 import { formatFriendlyDateTime } from '../../utils/datetimeInput';
@@ -26,6 +31,26 @@ export function ScheduledMessagesTray({ roomId }: ScheduledMessagesTrayProps) {
 
   const messages = useMemo(() => scheduledMessages.get(roomId) ?? [], [scheduledMessages, roomId]);
 
+  // [Gitea #322] The server is the source of truth: messages scheduled on
+  // another device (or before a logout) show up here and can be cancelled.
+  // localStorage is only a cache for the first paint; on error we keep it.
+  useEffect(() => {
+    let alive = true;
+    const load = () => {
+      fetchScheduledMessages(mx)
+        .then((list) => {
+          if (alive) setScheduledMessages(groupScheduledByRoom(list));
+        })
+        .catch(() => undefined);
+    };
+    load();
+    window.addEventListener('focus', load);
+    return () => {
+      alive = false;
+      window.removeEventListener('focus', load);
+    };
+  }, [mx, roomId, setScheduledMessages]);
+
   // Remove scheduled messages whose time has passed
   useEffect(() => {
     if (messages.length === 0) return undefined;

src/app/features/room/message/ForwardMessageDialog.tsx

@@ -47,8 +47,12 @@ import {
   recentForwardTargetsAtom,
   addRecentForwardTarget,
 } from '../../../state/recentForwardTargets';
-import { buildForwardContent, buildPlaintextAttachmentContent } from './forwardContent';
-import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
+import {
+  buildForwardContent,
+  buildPlaintextAttachmentContent,
+  forwardEncryptionWarning,
+} from './forwardContent';
+import { useLocalRoomNames, getLocalRoomName } from '../../../hooks/useRoomMeta';
 
 type RoomRowProps = {
   room: Room;
@@ -275,6 +279,14 @@ export function ForwardMessageDialog({ mEvent, onClose }: Props) {
   // Selection persists across query changes: a room selected then filtered out
   // of the rendered slice stays selected.
   const [selectedRoomIds, setSelectedRoomIds] = useState<Set<string>>(new Set());
+  const encryptionWarning = forwardEncryptionWarning(
+    !!mx.getRoom(mEvent.getRoomId() ?? '')?.hasEncryptionStateEvent(),
+    [...selectedRoomIds]
+      .map((id) => mx.getRoom(id))
+      .filter((r): r is Room => !!r && !r.hasEncryptionStateEvent())
+      // The name the user sees (their own "Rename for me" name, if set).
+      .map((r) => getLocalRoomName(mx, r.roomId) ?? r.name),
+  );
 
   const toggleRoom = useCallback((roomId: string) => {
     setSelectedRoomIds((prev) => {
@@ -590,7 +602,13 @@ export function ForwardMessageDialog({ mEvent, onClose }: Props) {
                   shrink="No"
                   direction="Column"
                   style={{ padding: `${config.space.S200} ${config.space.S400}` }}
+                  gap="200"
                 >
+                  {encryptionWarning && (
+                    <Text size="T200" role="note" style={{ color: color.Warning.Main }}>
+                      {encryptionWarning}
+                    </Text>
+                  )}
                   <Button
                     variant="Primary"
                     size="400"

src/app/features/room/message/Message.tsx

@@ -725,7 +725,13 @@ export const MessageDeleteItem = as<
                     Delete Message
                   </Text>
                 </Box>
-                <IconButton size="300" onClick={handleClose} radii="300" aria-label="Close">
+                <IconButton
+                  type="button"
+                  size="300"
+                  onClick={handleClose}
+                  radii="300"
+                  aria-label="Close"
+                >
                   <Icon src={Icons.Cross} />
                 </IconButton>
               </Header>
@@ -865,7 +871,13 @@ export const MessageReportItem = as<
                     Report Message
                   </Text>
                 </Box>
-                <IconButton size="300" onClick={handleClose} radii="300" aria-label="Close">
+                <IconButton
+                  type="button"
+                  size="300"
+                  onClick={handleClose}
+                  radii="300"
+                  aria-label="Close"
+                >
                   <Icon src={Icons.Cross} />
                 </IconButton>
               </Header>

src/app/features/room/message/Reactions.tsx

@@ -69,8 +69,15 @@ export const Reactions = as<'div', ReactionsProps>(
     const measure = useCallback(() => {
       const container = containerRef.current;
       if (!container) return;
-      const rowWidth = container.getBoundingClientRect().width;
-      const gap = parseFloat(getComputedStyle(container).columnGap) || 8;
+      // [Gitea #305] The width the chips actually get (content box). The border
+      // box grows by 4 px while collapsed (margin -2 / padding 2), and measuring
+      // it made a row within 4 px of fitting flip collapsed↔expanded every frame.
+      const cs = getComputedStyle(container);
+      const rowWidth =
+        container.clientWidth -
+        (parseFloat(cs.paddingLeft) || 0) -
+        (parseFloat(cs.paddingRight) || 0);
+      const gap = parseFloat(cs.columnGap) || 8;
       const chips = keys ? keys.split('\u0000').map((k) => chipRefs.current.get(k)) : [];
       const widths = chips.map((el) => el?.getBoundingClientRect().width ?? 0);
       const moreWidth = moreRef.current?.getBoundingClientRect().width ?? 48;
@@ -110,8 +117,21 @@ export const Reactions = as<'div', ReactionsProps>(
         style={{
           ...props.style,
           ...(collapsed && rowHeight
-            ? // 2px breathing room so row-1 focus outlines are not clipped.
-              { maxHeight: rowHeight + 4, overflow: 'hidden', padding: 2, margin: -2 }
+            ? // 2px breathing room so row-1 focus outlines are not clipped. Longhand
+              // margins so the timeline's marginTop survives (Gitea #305: the
+              // `margin` shorthand overrode it and, once removed, cleared it).
+              {
+                maxHeight: rowHeight + 4,
+                overflow: 'hidden',
+                padding: 2,
+                marginLeft: -2,
+                marginRight: -2,
+                marginBottom: -2,
+                marginTop:
+                  props.style?.marginTop !== undefined
+                    ? `calc(${typeof props.style.marginTop === 'number' ? `${props.style.marginTop}px` : props.style.marginTop} - 2px)`
+                    : -2,
+              }
             : {}),
         }}
         ref={(el) => {

src/app/features/room/message/forwardContent.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { MatrixClient, MatrixEvent } from 'matrix-js-sdk';
-import { buildForwardContent, getForwardedMeta } from './forwardContent';
+import { buildForwardContent, forwardEncryptionWarning, getForwardedMeta } from './forwardContent';
 
 // Pure content builder buildForwardContent: refuses undecryptable events, forwards
 // the latest edit (`m.new_content`), and strips reply fallbacks + `m.relates_to`.
@@ -171,3 +171,16 @@ test('getForwardedMeta rejects malformed metadata', () => {
   assert.equal(getForwardedMeta({ 'io.lotus.forwarded': { sender: 1 } }), undefined);
   assert.equal(getForwardedMeta({}), undefined);
 });
+
+test('forwardEncryptionWarning: only from an encrypted room into unencrypted ones (#330)', () => {
+  assert.equal(forwardEncryptionWarning(false, ['general']), undefined);
+  assert.equal(forwardEncryptionWarning(true, []), undefined);
+  assert.match(
+    forwardEncryptionWarning(true, ['general']) ?? '',
+    /^general isn't encrypted\..*that room, along with who originally wrote it\.$/,
+  );
+  assert.match(
+    forwardEncryptionWarning(true, ['a', 'b']) ?? '',
+    /^2 of the rooms you picked aren't encrypted\..*those rooms/,
+  );
+});

src/app/features/room/message/forwardContent.ts

@@ -122,3 +122,23 @@ export async function buildPlaintextAttachmentContent(
 
   return plainContent;
 }
+
+/**
+ * [Gitea #330] The note shown when forwarding out of an encrypted room into
+ * rooms that aren't: the text (and a re-uploaded attachment) becomes readable
+ * by the server, and the original author is shown with it. Undefined when
+ * there's nothing to warn about.
+ */
+export function forwardEncryptionWarning(
+  sourceEncrypted: boolean,
+  unencryptedDestNames: string[],
+): string | undefined {
+  if (!sourceEncrypted || unencryptedDestNames.length === 0) return undefined;
+  const where =
+    unencryptedDestNames.length === 1
+      ? `${unencryptedDestNames[0]} isn't encrypted.`
+      : `${unencryptedDestNames.length} of the rooms you picked aren't encrypted.`;
+  return `${where} The forwarded message (and any attachment) will be readable by the server and everyone in ${
+    unencryptedDestNames.length === 1 ? 'that room' : 'those rooms'
+  }, along with who originally wrote it.`;
+}

src/app/features/room/widgets/RoomWidgetView.tsx

@@ -14,6 +14,7 @@ import { GeneralWidgetDriver } from './GeneralWidgetDriver';
 import { WidgetPermissionRequest, isWidgetUrlSafe } from './widgetUtils';
 import { restrictWidgetMessages } from '../../../plugins/widgetTransport';
 import { WidgetPermissionPrompt } from './WidgetPermissionPrompt';
+import { isFromFilteredTimelineSet } from '../../../utils/room';
 
 type PendingAsk = {
   requests: WidgetPermissionRequest[];
@@ -111,6 +112,7 @@ export function RoomWidgetView({ room, widget }: RoomWidgetViewProps) {
     };
     const onTimeline: RoomEventHandlerMap[RoomEvent.Timeline] = (ev, r, toStart, removed, data) => {
       if (toStart || removed || !data?.liveEvent) return;
+      if (isFromFilteredTimelineSet(data)) return; // [Gitea #259] don't feed widgets each event twice
       if (ev.isBeingDecrypted()) ev.once(MatrixEventEvent.Decrypted, feed);
       else feed(ev);
     };

src/app/features/security-nudge/SecurityBanner.tsx

@@ -14,7 +14,7 @@ import { useKeyBackupInfo, useKeyBackupStatusChange } from '../../hooks/useKeyBa
 import { useAlive } from '../../hooks/useAlive';
 import { useSyncState } from '../../hooks/useSyncState';
 import { settingsRequestAtom } from '../../state/settingsRequest';
-import { serverStatusAtom } from '../../state/serverStatus';
+import { serverStatusAtom, statusDismissedAtom } from '../../state/serverStatus';
 import { pickBanner } from '../../utils/kumaStatus';
 import {
   dismissNudge,
@@ -66,6 +66,7 @@ function SecurityBannerFor({ crypto }: { crypto: CryptoApi }) {
   const backupInfo = useKeyBackupInfo(crypto);
   const backupActive = useBackupActive(crypto);
   const { status: serverStatus, syncLost } = useAtomValue(serverStatusAtom);
+  const statusDismissed = useAtomValue(statusDismissedAtom);
   const requestSettings = useSetAtom(settingsRequestAtom);
   // Not urgent: wait until sync has settled (two SYNCING in a row), so it
   // never stacks under the "Connecting…" strip at startup.
@@ -91,7 +92,11 @@ function SecurityBannerFor({ crypto }: { crypto: CryptoApi }) {
   });
 
   // One strip at a time: outages, maintenance and a lost connection win.
-  const otherStrip = syncLost || !!pickBanner(serverStatus, { syncLost, where: 'client' });
+  // [Gitea #307] Pass what the user dismissed: a dismissed announcement isn't
+  // on screen and must not keep the nudge hidden for as long as it's posted.
+  const otherStrip =
+    syncLost ||
+    !!pickBanner(serverStatus, { syncLost, where: 'client', dismissed: new Set(statusDismissed) });
   if (!settled || !deviceId || !kind || otherStrip || !shouldShowNudge(kind, record, Date.now()))
     return null;
 

src/app/features/server-status/ServerStatusBanner.tsx

@@ -1,5 +1,5 @@
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useAtomValue, useSetAtom } from 'jotai';
+import { useAtom, useAtomValue, useSetAtom } from 'jotai';
 import { MatrixClient, SyncState } from 'matrix-js-sdk';
 import { Box, Button, config, Icon, IconButton, Icons, IconSrc, Line, Text } from 'folds';
 import { ContainerColor } from '../../styles/ContainerColor.css';
@@ -7,20 +7,9 @@ import { useClientConfig } from '../../hooks/useClientConfig';
 import { useSyncState } from '../../hooks/useSyncState';
 import { useServerStatus } from '../../hooks/useServerStatus';
 import { ScreenSize, useScreenSizeContext } from '../../hooks/useScreenSize';
-import { serverStatusAtom } from '../../state/serverStatus';
+import { serverStatusAtom, statusDismissedAtom } from '../../state/serverStatus';
 import { pickBanner, resolveStatusPage, StatusBanner } from '../../utils/kumaStatus';
-
-const DISMISS_KEY = 'lotus-status-banner-dismissed';
-const DISMISS_MAX = 50;
-
-const readDismissed = (): string[] => {
-  try {
-    const v = JSON.parse(localStorage.getItem(DISMISS_KEY) ?? '[]');
-    return Array.isArray(v) ? v.filter((k): k is string => typeof k === 'string') : [];
-  } catch {
-    return [];
-  }
-};
+import { homeserverStalledAtom, useHomeserverStall } from '../../hooks/useHomeserverStall';
 
 const bannerIcon = (b: StripContent): IconSrc => {
   if (b.kind === 'maintenance') return Icons.Setting;
@@ -163,7 +152,12 @@ export function ServerStatusFeature({ mx }: { mx: MatrixClient }) {
       });
     }, []),
   );
-  const syncLost = lostAt !== null;
+  // [Gitea #317] A hung server keeps sync "SYNCING" for up to 110 s; the stall
+  // watchdog flags it sooner, and Kuma is asked at once.
+  const stalled = useHomeserverStall(mx);
+  const setStalled = useSetAtom(homeserverStalledAtom);
+  useEffect(() => setStalled(stalled), [setStalled, stalled]);
+  const syncLost = lostAt !== null || stalled;
   const status = useServerStatus(page, syncLost);
   const setAtom = useSetAtom(serverStatusAtom);
   useEffect(() => setAtom({ status, syncLost, lostAt }), [setAtom, status, syncLost, lostAt]);
@@ -173,22 +167,14 @@ export function ServerStatusFeature({ mx }: { mx: MatrixClient }) {
 /** The logged-in app's status strip. */
 export function ServerStatusBanner() {
   const { status, syncLost } = useAtomValue(serverStatusAtom);
-  const [dismissed, setDismissed] = useState(readDismissed);
+  const [dismissed, dismissKey] = useAtom(statusDismissedAtom);
   const banner = pickBanner(status, {
     syncLost,
     where: 'client',
     dismissed: new Set(dismissed),
   });
   if (!banner) return null;
-  const dismiss = () => {
-    const next = [...dismissed.filter((k) => k !== banner.key), banner.key].slice(-DISMISS_MAX);
-    try {
-      localStorage.setItem(DISMISS_KEY, JSON.stringify(next));
-    } catch {
-      // storage unavailable — dismissed for this session only
-    }
-    setDismissed(next);
-  };
+  const dismiss = () => dismissKey(banner.key);
   return <StatusStrip banner={banner} onDismiss={dismiss} />;
 }
 

src/app/features/settings/general/General.tsx

@@ -596,10 +596,6 @@ function Appearance() {
         />
       </SequenceCard>
 
-      <DesktopChromeSetting />
-      <AutostartSetting />
-      <KeychainMirrorSetting />
-
       <SequenceCard className={SequenceCardStyle} variant="SurfaceVariant" direction="Column">
         <SettingTile
           title="Twitter Emoji"
@@ -2856,6 +2852,23 @@ function PackageUpdate({ help }: { help: NonNullable<ReturnType<typeof packageUp
   );
 }
 
+/**
+ * [Gitea #290] Desktop-only settings in their own section (they used to sit
+ * inside Appearance, between Monochrome Mode and Twitter Emoji). Renders
+ * nothing outside the desktop app.
+ */
+function DesktopSettings() {
+  if (!isTauriEnv()) return null;
+  return (
+    <Box direction="Column" gap="100">
+      <Text size="L400">Desktop</Text>
+      <AutostartSetting />
+      <KeychainMirrorSetting />
+      <DesktopChromeSetting />
+    </Box>
+  );
+}
+
 function AppUpdates() {
   const { isTauri, status, check, install, installKind } = useTauriUpdater();
   if (!isTauri) return null;
@@ -2964,6 +2977,7 @@ export function General({ requestClose }: GeneralProps) {
               <StorageUsage />
               <SettingsSyncSection />
               <Calls />
+              <DesktopSettings />
               <AppUpdates />
             </Box>
           </PageContent>

src/app/features/shortcuts/KeyboardShortcutsDialog.tsx

@@ -25,6 +25,9 @@ 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);
@@ -98,6 +101,9 @@ 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';
 
@@ -109,6 +115,8 @@ 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'] },
       ],
     },
     {
@@ -124,6 +132,26 @@ 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'] },
       ],
     },
     {
@@ -132,6 +160,19 @@ 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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,29 @@
+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',
+};