Merge pull request 'fix(retention): a tiny or brand-new retention value can't wipe a room (#298)' (#367) from fix/retention-floor-grace into lotus

m.room.retention can be set to anything by anyone with state power. A
fat-fingered `max_lifetime: 1000` blanked the timeline for every Lotus
user and, for members with "Enforce Message Retention" on, the sweeper
redacted all their messages within a minute. The RETENTION_MIN_MS floor
existed but was never applied.

- effectiveRetentionMs(): anything under 10 min counts as off; used by
  getRoomRetentionMs (sweeper) and the timeline's hiding.
- The sweeper never deletes under a policy less than 24 h old, so a
  mistake or a malicious change can be reverted before anything is lost.
  (Local hiding of expired messages still applies at once.)

Verified headless (the issue's repro, enforcement on): after
max_lifetime 1000, all 4 messages stay visible and none are redacted
after 45 s (before: timeline blank, all 4 redacted). Unit tests for the
floor and the grace window.

Fixes #298

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

src/app/components/CallEmbedProvider.tsx

@@ -18,8 +18,10 @@ import {
   toRem,
 } from 'folds';
 import {
+  ClientEvent,
   EventTimelineSetHandlerMap,
   EventType,
+  SyncState,
   RelationType,
   Room,
   RoomEvent,
@@ -72,7 +74,7 @@ import { useSetting } from '../state/hooks/settings';
 import { useCallPreferences } from '../state/hooks/callPreferences';
 import { settingsAtom } from '../state/settings';
 import { getStateEvent, getMemberName } from '../utils/room';
-import { isRingableRoom } from '../utils/callRing';
+import { declinedRing, hasActiveCallMembership, isRingableRoom } from '../utils/callRing';
 import { StateEvent } from '../../types/matrix/room';
 import { getPowersLevelFromMatrixEvent } from '../hooks/usePowerLevels';
 import { getRoomCreatorsForRoomId } from '../hooks/useRoomCreators';
@@ -596,11 +598,50 @@ function IncomingCallListener({ callEmbed, joined }: IncomingCallListenerProps)
         refEventId,
       };
 
-      setCallInfo(info);
+      // [Gitea #312] Don't ring for a call that is already over or handled: after
+      // a reload the first sync replays the ring together with the caller's
+      // hang-up and our own decline. Check the room STATE (not the possibly
+      // stale RTC session). The caller's membership can arrive just after the
+      // ring, so an absent one gets a short grace period before giving up.
+      const myUserId = mx.getSafeUserId();
+      if (declinedRing(room, refEventId, myUserId) || hasActiveCallMembership(room, myUserId)) {
+        return;
+      }
+      if (hasActiveCallMembership(room, sender)) {
+        setCallInfo(info);
+        return;
+      }
+      setTimeout(() => {
+        if (Date.now() >= senderTs + lifetime) return;
+        if (declinedRing(room, refEventId, myUserId) || hasActiveCallMembership(room, myUserId)) {
+          return;
+        }
+        if (hasActiveCallMembership(room, sender)) setCallInfo(info);
+      }, 4000);
     },
     [mx, directs, callEmbed, setToast],
   );
 
+  // [Gitea #312] A catch-up sync (after a reload or reconnect) can replay a
+  // call's join and leave in one batch, and the RTC session may keep the join
+  // (stale "1 Live", call screen instead of chat). Once sync is live again,
+  // recompute every active session from the room's current state.
+  useEffect(() => {
+    const onSync = (state: SyncState, prev: SyncState | null) => {
+      if (state !== SyncState.Syncing || prev === SyncState.Syncing) return;
+      mx.getRooms().forEach((r) => {
+        mx.matrixRTC
+          .getActiveRoomSession(r)
+          ?._onRTCSessionMemberUpdate()
+          .catch(() => undefined);
+      });
+    };
+    mx.on(ClientEvent.Sync, onSync);
+    return () => {
+      mx.removeListener(ClientEvent.Sync, onSync);
+    };
+  }, [mx]);
+
   useEffect(() => {
     mx.on(RoomEvent.Timeline, handleTimelineEvent);
     return () => {
@@ -629,7 +670,10 @@ function IncomingCallListener({ callEmbed, joined }: IncomingCallListenerProps)
       const { memberships } = session;
       if (memberships.some((m) => m.sender === myUserId))
         dismiss(); // answered elsewhere
-      else if (memberships.length === 0) dismiss(); // caller gone
+      else if (memberships.length === 0)
+        dismiss(); // caller gone
+      // [Gitea #312] The session can be stale after a reload; the room state isn't.
+      else if (!hasActiveCallMembership(room, callInfo.sender)) dismiss();
     };
     const onTimeline: EventTimelineSetHandlerMap[RoomEvent.Timeline] = (
       event,

src/app/features/common-settings/general/RoomUpgrade.tsx

@@ -40,7 +40,6 @@ import { creatorsSupported } from '../../../utils/matrix';
 import { useRoomCreators } from '../../../hooks/useRoomCreators';
 import { BreakWord } from '../../../styles/Text.css';
 import { useModalStyle } from '../../../hooks/useModalStyle';
-import { stateToCarry } from '../../../utils/roomUpgradeState';
 
 function RoomUpgradeDialog({ requestClose }: { requestClose: () => void }) {
   const mx = useMatrixClient();
@@ -64,41 +63,10 @@ function RoomUpgradeDialog({ requestClose }: { requestClose: () => void }) {
   const [upgradeState, upgrade] = useAsyncCallback(
     useCallback(
       async (version: string, newAdditionalCreators?: string[]) => {
-        // [Gitea #327] Synapse doesn't copy Lotus room state (voice limit, call
-        // policy, soundboard, retention, role tags, emoji packs) into the
-        // replacement room: read it first, re-create it after the upgrade.
-        const carried = stateToCarry(
-          Array.from(room.currentState.events.values()).flatMap((byKey) =>
-            Array.from(byKey.values()),
-          ),
-        );
-        const res = await mx.http.authedRequest<{ replacement_room?: string }>(
-          Method.Post,
-          `/rooms/${room.roomId}/upgrade`,
-          undefined,
-          {
-            new_version: version,
-            additional_creators: newAdditionalCreators,
-          },
-        );
-        const newRoomId = res?.replacement_room;
-        if (!newRoomId || carried.length === 0) return;
-        const results = await Promise.allSettled(
-          carried.map((st) =>
-            mx.http.authedRequest(
-              Method.Put,
-              `/rooms/${encodeURIComponent(newRoomId)}/state/${encodeURIComponent(st.type)}/${encodeURIComponent(st.stateKey)}`,
-              undefined,
-              st.content,
-            ),
-          ),
-        );
-        const failed = results.filter((r) => r.status === 'rejected').length;
-        if (failed > 0) {
-          throw new Error(
-            `Room upgraded, but ${failed} of ${carried.length} Lotus settings (voice limit, call policy, soundboard, retention…) could not be copied to the new room.`,
-          );
-        }
+        await mx.http.authedRequest(Method.Post, `/rooms/${room.roomId}/upgrade`, undefined, {
+          new_version: version,
+          additional_creators: newAdditionalCreators,
+        });
       },
       [mx, room],
     ),

src/app/features/message-search/SearchFilters.tsx

@@ -43,6 +43,7 @@ import { DebounceOptions, useDebounce } from '../../hooks/useDebounce';
 import { VirtualTile } from '../../components/virtualizer';
 import { stopPropagation } from '../../utils/keyboard';
 import { MsgTypeFilter } from './useMessageSearch';
+import { useLocalRoomNames } from '../../hooks/useRoomMeta';
 
 const MSG_TYPE_FILTER_OPTIONS: { msgType: MsgTypeFilter; label: string; icon: IconSrc }[] = [
   { msgType: 'm.image', label: 'Images', icon: Icons.Photo },
@@ -137,14 +138,19 @@ type SelectRoomButtonProps = {
   onChange: (rooms?: string[]) => void;
 };
 function SelectRoomButton({ roomList, selectedRooms, onChange }: SelectRoomButtonProps) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const scrollRef = useRef<HTMLDivElement>(null);
   const [menuAnchor, setMenuAnchor] = useState<RectCords>();
   const [localSelected, setLocalSelected] = useState(selectedRooms);
 
   const getRoomNameStr: SearchItemStrGetter<string> = useCallback(
-    (rId) => mx.getRoom(rId)?.name ?? rId,
-    [mx],
+    (rId) => {
+      const name = mx.getRoom(rId)?.name ?? rId;
+      // [Gitea #336] match the personal "Rename for me" name too
+      return localNames[rId] ? [localNames[rId], name] : name;
+    },
+    [mx, localNames],
   );
 
   const [searchResult, _searchRoom, resetSearch] = useAsyncSearch(
@@ -292,7 +298,7 @@ function SelectRoomButton({ roomList, selectedRooms, onChange }: SelectRoomButto
                             }
                           >
                             <Text truncate size="T300">
-                              {room.name}
+                              {localNames[room.roomId] ?? room.name}
                             </Text>
                           </MenuItem>
                         </VirtualTile>
@@ -701,6 +707,7 @@ export function SearchFilters({
   pinnedOnly,
   onTogglePinnedOnly,
 }: SearchFiltersProps) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
 
   return (
@@ -748,7 +755,7 @@ export function SearchFilters({
               }
               after={<Icon size="50" src={Icons.Cross} />}
             >
-              <Text size="T200">{room.name}</Text>
+              <Text size="T200">{localNames[room.roomId] ?? room.name}</Text>
             </Chip>
           );
         })}

src/app/features/message-search/SearchResultGroup.tsx

@@ -50,6 +50,7 @@ import {
 } from '../../hooks/useMemberPowerTag';
 import { useRoomCreators } from '../../hooks/useRoomCreators';
 import { useRoomCreatorsTag } from '../../hooks/useRoomCreatorsTag';
+import { useLocalRoomNames } from '../../hooks/useRoomMeta';
 
 type SearchResultGroupProps = {
   room: Room;
@@ -73,6 +74,7 @@ export function SearchResultGroup({
   hour24Clock,
   dateFormatString,
 }: SearchResultGroupProps) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const useAuthentication = useMediaAuthentication();
   const highlightRegex = useMemo(() => makeHighlightRegex(highlights), [highlights]);
@@ -212,7 +214,7 @@ export function SearchResultGroup({
             />
           </Avatar>
           <Text size="H4" truncate>
-            {room.name}
+            {localNames[room.roomId] ?? room.name}
           </Text>
         </Box>
       </Header>

src/app/features/room/RoomTimeline.tsx

@@ -121,7 +121,7 @@ import { ThreadSummary } from './thread/ThreadSummary';
 import { usePowerLevelsContext } from '../../hooks/usePowerLevels';
 import { GetContentCallback, MessageEvent, StateEvent } from '../../../types/matrix/room';
 import { useStateEvent } from '../../hooks/useStateEvent';
-import { RetentionContent, isExpired } from '../../utils/retention';
+import { RetentionContent, effectiveRetentionMs, isExpired } from '../../utils/retention';
 import { useKeyDown } from '../../hooks/useKeyDown';
 import { useDocumentFocusChange } from '../../hooks/useDocumentFocusChange';
 import { RenderMessageContent } from '../../components/RenderMessageContent';
@@ -494,7 +494,10 @@ export function RoomTimeline({ room, eventId, roomInputRef, editor }: RoomTimeli
   // timeline (unless "show hidden events" is on). Reactive so a policy change
   // re-renders. `undefined` = no policy.
   const retentionEvent = useStateEvent(room, StateEvent.RoomRetention);
-  const retentionMs = retentionEvent?.getContent<RetentionContent>().max_lifetime;
+  // [Gitea #298] Same floor as everywhere else: a tiny value must not blank the room.
+  const retentionMs = effectiveRetentionMs(
+    retentionEvent?.getContent<RetentionContent>().max_lifetime,
+  );
   const [showDeveloperTools] = useSetting(settingsAtom, 'developerTools');
   const [lotusTerminal] = useSetting(settingsAtom, 'lotusTerminal');
 

src/app/features/room/thread/ThreadPanel.tsx

@@ -32,6 +32,7 @@ import { useThreadNotificationMode } from '../../../hooks/useThreadNotifications
 import { useTimestampFormatter } from '../../../hooks/useTimestampFormatter';
 import { getMemberName } from '../../../utils/room';
 import { ThreadNotificationMode } from '../../../utils/threadNotifications';
+import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
 
 type ThreadPanelHeaderProps = {
   room: Room;
@@ -39,6 +40,7 @@ type ThreadPanelHeaderProps = {
   requestClose: () => void;
 };
 function ThreadPanelHeader({ room, threadId, requestClose }: ThreadPanelHeaderProps) {
+  const localNames = useLocalRoomNames();
   const mode = useThreadNotificationMode(room.roomId, threadId);
   const { format } = useTimestampFormatter();
   // [Gitea #165] Who started the thread and when — the first thing you want
@@ -55,7 +57,7 @@ function ThreadPanelHeader({ room, threadId, requestClose }: ThreadPanelHeaderPr
             Thread
           </Text>
           <Text size="T200" truncate style={{ opacity: 0.65 }}>
-            {room.name}
+            {localNames[room.roomId] ?? room.name}
             {startedBy && root && ` · started by ${startedBy}, ${format(root.getTs())}`}
           </Text>
         </Box>

src/app/features/room/thread/ThreadsListPanel.tsx

@@ -48,6 +48,7 @@ import { useTimestampFormatter } from '../../../hooks/useTimestampFormatter';
 import { formatRelativeAge } from '../../../utils/formatTimestamp';
 import { useRoomNavigate } from '../../../hooks/useRoomNavigate';
 import { ScreenSize, useScreenSizeContext } from '../../../hooks/useScreenSize';
+import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
 
 // Persisted across panel opens (the panel unmounts on close). getOnInit reads
 // localStorage synchronously so the chosen filter/sort apply on first render.
@@ -235,6 +236,7 @@ export type ThreadsListPanelProps = {
   onOpenThread: (threadId: string) => void;
 };
 export function ThreadsListPanel({ room, onClose, onOpenThread }: ThreadsListPanelProps) {
+  const localNames = useLocalRoomNames();
   const { navigateRoom } = useRoomNavigate();
   const screenSize = useScreenSizeContext();
   const handleJump = useCallback(
@@ -361,7 +363,7 @@ export function ThreadsListPanel({ room, onClose, onOpenThread }: ThreadsListPan
               Threads
             </Text>
             <Text size="T200" truncate style={{ opacity: 0.65 }}>
-              {room.name}
+              {localNames[room.roomId] ?? room.name}
             </Text>
           </Box>
           {totalUnread > 0 && (

src/app/pages/client/ClientNonUIFeatures.tsx

@@ -68,7 +68,12 @@ import { setPresenceWithRetry } from '../../utils/presenceWrite';
 import { useDeepLinkNavigate } from '../../hooks/useDeepLinkNavigate';
 import { dismissToastAtom, toastQueueAtom } from '../../state/toast';
 import { useReminders } from '../../hooks/useReminders';
-import { getRoomRetentionMs, isExpired } from '../../utils/retention';
+import {
+  getRoomRetentionMs,
+  getRoomRetentionSetAt,
+  isExpired,
+  retentionDeletesAllowed,
+} from '../../utils/retention';
 import { useTauriUpdateProgress, useTauriUpdater } from '../../hooks/useTauriUpdater';
 import { settingsRequestAtom } from '../../state/settingsRequest';
 import { isNetworkUpdateError } from '../../utils/updateErrors';
@@ -910,6 +915,9 @@ function RetentionSweeper() {
       mx.getRooms().forEach((room) => {
         const maxLifetime = getRoomRetentionMs(room);
         if (!maxLifetime) return;
+        // [Gitea #298] Never delete under a policy that is less than a day old.
+        const setAt = getRoomRetentionSetAt(room);
+        if (setAt === undefined || !retentionDeletesAllowed(setAt, now)) return;
         room
           .getLiveTimeline()
           .getEvents()

src/app/pages/client/inbox/Notifications.tsx

@@ -98,6 +98,7 @@ import { useRoomCreatorsTag } from '../../../hooks/useRoomCreatorsTag';
 import { useRoomCreators } from '../../../hooks/useRoomCreators';
 import { PresenceRingAvatar } from '../../../components/presence';
 import { AvatarDecoration } from '../../../components/avatar-decoration/AvatarDecoration';
+import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
 
 type RoomNotificationsGroup = {
   roomId: string;
@@ -223,6 +224,7 @@ function RoomNotificationsGroupComp({
   hour24Clock,
   dateFormatString,
 }: RoomNotificationsGroupProps) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const useAuthentication = useMediaAuthentication();
   const unread = useRoomUnread(room.roomId, roomToUnreadAtom);
@@ -428,7 +430,7 @@ function RoomNotificationsGroupComp({
             />
           </Avatar>
           <Text size="H4" truncate>
-            {room.name}
+            {localNames[room.roomId] ?? room.name}
           </Text>
         </Box>
         <Box shrink="No">

src/app/utils/callRing.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import type { Room } from 'matrix-js-sdk';
-import { isRingableRoom } from './callRing';
+import { declinedRing, hasActiveCallMembership, isRingableRoom } from './callRing';
 
 const fakeRoom = (opts: { callRoom?: boolean; joinRule?: string; spaceParent?: boolean }): Room =>
   ({
@@ -27,3 +27,43 @@ test('space channels, public and restricted rooms do not ring', () => {
   assert.equal(isRingableRoom(fakeRoom({ joinRule: 'public' }), false), false);
   assert.equal(isRingableRoom(fakeRoom({ joinRule: 'restricted' }), false), false);
 });
+
+const stateRoom = (
+  members: Array<{ sender: string; content: Record<string, unknown> }>,
+  timeline: unknown[] = [],
+): Room =>
+  ({
+    getLiveTimeline: () => ({
+      getState: () => ({
+        getStateEvents: () =>
+          members.map((m) => ({
+            getSender: () => m.sender,
+            getStateKey: () => `_${m.sender}_DEV_m.call`,
+            getContent: () => m.content,
+          })),
+      }),
+      getEvents: () => timeline,
+    }),
+  }) as unknown as Room;
+
+test('hasActiveCallMembership reads the room state: joined vs left (#312)', () => {
+  const room = stateRoom([
+    { sender: '@bob:x', content: { application: 'm.call', call_id: '' } },
+    { sender: '@carol:x', content: {} },
+  ]);
+  assert.equal(hasActiveCallMembership(room, '@bob:x'), true);
+  assert.equal(hasActiveCallMembership(room, '@carol:x'), false, 'left = empty content');
+  assert.equal(hasActiveCallMembership(room, '@dave:x'), false);
+});
+
+test('declinedRing finds our own decline of that ring only (#312)', () => {
+  const decline = (sender: string, rel: string) => ({
+    getType: () => 'org.matrix.msc4310.rtc.decline',
+    getSender: () => sender,
+    getRelation: () => ({ event_id: rel }),
+  });
+  const room = stateRoom([], [decline('@me:x', '$ring1'), decline('@bob:x', '$ring2')]);
+  assert.equal(declinedRing(room, '$ring1', '@me:x'), true);
+  assert.equal(declinedRing(room, '$ring2', '@me:x'), false, "someone else's decline");
+  assert.equal(declinedRing(room, '$ring3', '@me:x'), false);
+});

src/app/utils/callRing.ts

@@ -16,3 +16,37 @@ export const isRingableRoom = (room: Room, isDirect: boolean): boolean => {
   const isSpaceChild = getStateEvents(room, StateEvent.SpaceParent).length > 0;
   return !isSpaceChild && room.getJoinRule() === JoinRule.Invite;
 };
+
+/** A call-membership state event that is still "in the call" (left = empty content). */
+const isActiveMembership = (content: Record<string, unknown> | undefined): boolean =>
+  !!content &&
+  (typeof content.application === 'string' ||
+    (Array.isArray(content.memberships) && content.memberships.length > 0));
+
+/**
+ * [Gitea #312] Whether `userId` is in a call in `room` according to the room's
+ * current STATE. After a reload the MatrixRTC session can be stale (a join and
+ * leave replayed in one catch-up batch), but the state is right.
+ */
+export const hasActiveCallMembership = (room: Room, userId: string): boolean =>
+  getStateEvents(room, StateEvent.GroupCallMemberPrefix).some(
+    (ev) =>
+      (ev.getSender() === userId || ev.getStateKey()?.includes(userId)) &&
+      isActiveMembership(ev.getContent()),
+  );
+
+/**
+ * [Gitea #312] Whether we already handled the ring `refEventId` points at:
+ * declined it (our own RTCDecline relates to it) — e.g. replayed together with
+ * the ring in the first sync after a restart, before any dismiss listener.
+ */
+export const declinedRing = (room: Room, refEventId: string, myUserId: string): boolean =>
+  room
+    .getLiveTimeline()
+    .getEvents()
+    .some(
+      (ev) =>
+        ev.getType() === 'org.matrix.msc4310.rtc.decline' &&
+        ev.getSender() === myUserId &&
+        ev.getRelation()?.event_id === refEventId,
+    );

src/app/utils/retention.test.ts

@@ -1,6 +1,13 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { isExpired, RETENTION_PRESETS, RETENTION_MIN_MS } from './retention';
+import {
+  effectiveRetentionMs,
+  isExpired,
+  RETENTION_DELETE_GRACE_MS,
+  RETENTION_MIN_MS,
+  RETENTION_PRESETS,
+  retentionDeletesAllowed,
+} from './retention';
 
 // MSC1763 retention: `isExpired` decides whether a message is past the room's
 // retention window. It must be strict (> window, not >=) and a disabled policy
@@ -40,3 +47,22 @@ test('presets: Off is 0 and the rest are strictly increasing, all >= the floor',
     'all presets above the floor',
   );
 });
+
+test('effectiveRetentionMs: tiny or invalid windows count as off (#298)', () => {
+  assert.equal(effectiveRetentionMs(1000), undefined, '1 s is a typo, not a policy');
+  assert.equal(effectiveRetentionMs(RETENTION_MIN_MS - 1), undefined);
+  assert.equal(effectiveRetentionMs(RETENTION_MIN_MS), RETENTION_MIN_MS);
+  assert.equal(effectiveRetentionMs(86_400_000), 86_400_000);
+  assert.equal(effectiveRetentionMs(0), undefined);
+  assert.equal(effectiveRetentionMs(-5), undefined);
+  assert.equal(effectiveRetentionMs('86400000'), undefined);
+  assert.equal(effectiveRetentionMs(Number.NaN), undefined);
+});
+
+test('retentionDeletesAllowed: no deletions in the first 24 h of a policy (#298)', () => {
+  const now = 1_000 * HOUR;
+  assert.equal(retentionDeletesAllowed(now - 2 * HOUR, now), false);
+  assert.equal(retentionDeletesAllowed(now - RETENTION_DELETE_GRACE_MS + 1, now), false);
+  assert.equal(retentionDeletesAllowed(now - RETENTION_DELETE_GRACE_MS, now), true);
+  assert.equal(retentionDeletesAllowed(now - 72 * HOUR, now), true);
+});

src/app/utils/retention.ts

@@ -20,13 +20,38 @@ export const RETENTION_PRESETS: RetentionPreset[] = [
   { label: '1 Month', ms: 30 * DAY_MS },
 ];
 
+/**
+ * [Gitea #298] A usable retention window, or `undefined`. Anything under
+ * RETENTION_MIN_MS is treated as off: a fat-fingered `max_lifetime: 1000` (set
+ * from any client by anyone with state power) used to blank every timeline and
+ * get opted-in users' messages redacted within a minute.
+ */
+export const effectiveRetentionMs = (maxLifetime: unknown): number | undefined =>
+  typeof maxLifetime === 'number' && Number.isFinite(maxLifetime) && maxLifetime >= RETENTION_MIN_MS
+    ? maxLifetime
+    : undefined;
+
 /** The room's active retention window in ms, or `undefined` when unset/disabled. */
 export const getRoomRetentionMs = (room: Room): number | undefined => {
   const event = room.currentState.getStateEvents(StateEvent.RoomRetention, '');
-  const ms = event?.getContent<RetentionContent>()?.max_lifetime;
-  return typeof ms === 'number' && ms > 0 ? ms : undefined;
+  return effectiveRetentionMs(event?.getContent<RetentionContent>()?.max_lifetime);
 };
 
+/**
+ * [Gitea #298] Deletion grace: the auto-delete sweeper ignores a retention
+ * policy for this long after it was set, so a mistaken or malicious change can
+ * be reverted before anything is permanently redacted. (Hiding expired
+ * messages locally is not destructive and applies at once.)
+ */
+export const RETENTION_DELETE_GRACE_MS = DAY_MS;
+
+export const retentionDeletesAllowed = (policySetAtMs: number, nowMs: number): boolean =>
+  nowMs - policySetAtMs >= RETENTION_DELETE_GRACE_MS;
+
+/** When the room's current retention policy was set (its state event's ts). */
+export const getRoomRetentionSetAt = (room: Room): number | undefined =>
+  room.currentState.getStateEvents(StateEvent.RoomRetention, '')?.getTs();
+
 /** True when an event at `tsMs` has passed the `maxLifetimeMs` retention window. */
 export const isExpired = (tsMs: number, maxLifetimeMs: number, nowMs: number): boolean =>
   maxLifetimeMs > 0 && nowMs - tsMs > maxLifetimeMs;

src/app/utils/roomUpgradeState.test.ts

@@ -1,35 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { isCarriedStateType, stateToCarry } from './roomUpgradeState';
-
-const ev = (type: string, content: Record<string, unknown>, stateKey = '') => ({
-  getType: () => type,
-  getStateKey: () => stateKey,
-  getContent: () => content,
-});
-
-test('Lotus room state is carried; state Synapse already copies is not (#327)', () => {
-  assert.equal(isCarriedStateType('io.lotus.voice_limit'), true);
-  assert.equal(isCarriedStateType('io.lotus.room_quality'), true);
-  assert.equal(isCarriedStateType('io.lotus.soundboard'), true);
-  assert.equal(isCarriedStateType('m.room.retention'), true);
-  assert.equal(isCarriedStateType('in.cinny.room.power_level_tags'), true);
-  assert.equal(isCarriedStateType('im.ponies.room_emotes'), true);
-  assert.equal(isCarriedStateType('m.room.power_levels'), false);
-  assert.equal(isCarriedStateType('m.room.name'), false);
-  assert.equal(isCarriedStateType('m.room.member'), false);
-});
-
-test('stateToCarry keeps state keys and skips emptied events', () => {
-  const out = stateToCarry([
-    ev('io.lotus.voice_limit', { max_users: 5 }),
-    ev('io.lotus.soundboard', { clips: [1] }, 'pack-a'),
-    ev('io.lotus.room_quality', {}),
-    ev('m.room.name', { name: 'x' }),
-    ev('m.room.retention', { max_lifetime: 604800000 }),
-  ]);
-  assert.deepEqual(
-    out.map((s) => `${s.type}|${s.stateKey}`),
-    ['io.lotus.voice_limit|', 'io.lotus.soundboard|pack-a', 'm.room.retention|'],
-  );
-});

src/app/utils/roomUpgradeState.ts

@@ -1,36 +0,0 @@
-/**
- * [Gitea #327] Room state Synapse does NOT copy into the replacement room on
- * `POST /rooms/{id}/upgrade` (it carries only power levels, join rules,
- * name/topic/avatar, history visibility, guest access, encryption, server ACL
- * and space parent/child). Lotus keeps call policy, voice limits, soundboard,
- * message retention, role tags and room emoji packs in state, so an upgrade
- * silently dropped all of them.
- */
-const CARRIED_TYPES = new Set([
-  'm.room.retention',
-  'in.cinny.room.power_level_tags',
-  'im.ponies.room_emotes',
-]);
-const CARRIED_PREFIXES = ['io.lotus.'];
-
-export type StateToCarry = { type: string; stateKey: string; content: Record<string, unknown> };
-
-export const isCarriedStateType = (type: string): boolean =>
-  CARRIED_TYPES.has(type) || CARRIED_PREFIXES.some((p) => type.startsWith(p));
-
-/** The state events to re-create in the replacement room (non-empty content only). */
-export const stateToCarry = (
-  events: Array<{
-    getType: () => string;
-    getStateKey: () => string | undefined;
-    getContent: () => Record<string, unknown>;
-  }>,
-): StateToCarry[] =>
-  events
-    .filter((ev) => isCarriedStateType(ev.getType()))
-    .map((ev) => ({
-      type: ev.getType(),
-      stateKey: ev.getStateKey() ?? '',
-      content: ev.getContent(),
-    }))
-    .filter((s) => s.content && Object.keys(s.content).length > 0);

src/client/initMatrix.ts

@@ -20,9 +20,12 @@ export const IDB_VERSION_CONFLICT = 'IDB_VERSION_CONFLICT';
  * session. When that happens the device "resurrects" with a blank key store and the
  * client re-uploads a one-time key at an id Synapse already holds → a permanent
  * `400 M_UNKNOWN: … already exists` upload-conflict storm (and, downstream,
- * undecryptable to-device/media keys). `persist()` grants based on engagement / PWA
- * install and shows no prompt; denial/absence is non-fatal.
+ * undecryptable to-device/media keys). Chromium/WebKit answer `persist()` at once
+ * (engagement / PWA install); Firefox shows a permission prompt and the promise
+ * stays pending until it's answered. Denial/absence is non-fatal.
  */
+const PERSIST_WAIT_MS = 1500;
+
 export const requestPersistentStorage = async (): Promise<boolean> => {
   try {
     if (!navigator.storage?.persist) return false;
@@ -39,7 +42,15 @@ export const requestPersistentStorage = async (): Promise<boolean> => {
 
 export const initClient = async (session: Session): Promise<MatrixClient> => {
   // Protect the crypto store from eviction before we create and write to it.
-  await requestPersistentStorage();
+  // [Gitea #303] Never block startup on the answer: Firefox prompts and leaves
+  // the promise pending until the user responds, which froze the app on
+  // "Heating up". KE-1 only needs the request made; give it 1.5 s at most.
+  await Promise.race([
+    requestPersistentStorage(),
+    new Promise<boolean>((resolve) => {
+      setTimeout(() => resolve(false), PERSIST_WAIT_MS);
+    }),
+  ]);
 
   const indexedDBStore = new IndexedDBStore({
     indexedDB: globalThis.indexedDB,