fix(lotus): a homeserver stall shorter than the delayed-leave window no longer ends the call (#46)

maximumNetworkErrorRetryCount was sized to min(sync grace period,
leave delay), i.e. 10 s, so the membership manager gave up 20-35 s into
a homeserver stall and showed "Connection lost", even when the server
would keep the membership for 60 s (prod config). Size it to the leave
delay instead: the embedded call has no /sync loop for the grace period
to describe, and the server's delayed leave is what actually ends the
membership.

Fixes #46

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

src/lotus/lotusMicLevel.test.ts

@@ -7,7 +7,7 @@ Please see LICENSE in the repository root for full details.
 
 import { describe, expect, it } from "vitest";
 
-import { MicLevelQuantizer, sameRooms } from "./lotusMicLevel";
+import { MicLevelQuantizer } from "./lotusMicLevel";
 
 describe("MicLevelQuantizer", () => {
   it("maps RMS to 0–3 bars", () => {
@@ -35,14 +35,3 @@ describe("MicLevelQuantizer", () => {
     expect(q.push(0)).toBe(0);
   });
 });
-
-describe("sameRooms (EC #45)", () => {
-  it("compares rooms by identity and order", () => {
-    const a = {};
-    const b = {};
-    expect(sameRooms([a, b], [a, b])).toBe(true);
-    expect(sameRooms([a], [a, b])).toBe(false);
-    expect(sameRooms([a, b], [b, a])).toBe(false);
-    expect(sameRooms([{}], [{}])).toBe(false);
-  });
-});

src/lotus/lotusMicLevel.ts

@@ -46,10 +46,6 @@ const micPublication = (
     : null;
 };
 
-/** Pure: the same LiveKit rooms, in the same order (by identity). */
-export const sameRooms = <T>(a: readonly T[], b: readonly T[]): boolean =>
-  a.length === b.length && a.every((r, i) => r === b[i]);
-
 const samplers = new WeakMap<
   CallViewModel,
   Observable<LocalMicSample | null>
@@ -66,15 +62,10 @@ export function observeLocalMicSample$(
   const cached = samplers.get(vm);
   if (cached) return cached;
   const sampler$ = vm.allConnections$.pipe(
-    map((data) => data.getConnections().map((c) => c.livekitRoom)),
-    // [EC #45] allConnections$ re-emits far more often than the set of
-    // LiveKit rooms changes; restarting the tap each time closed the
-    // AudioContext ~1×/s and emitted null, which reset the muted-speech
-    // gate so the "You're muted" nudge could never fire.
-    distinctUntilChanged(sameRooms),
     switchMap(
-      (rooms) =>
+      (data) =>
         new Observable<LocalMicSample | null>((subscriber) => {
+          const rooms = data.getConnections().map((c) => c.livekitRoom);
           let ctx: AudioContext | null = null;
           let clone: MediaStreamTrack | null = null;
           let timer: ReturnType<typeof setInterval> | undefined;

src/state/CallViewModel/localMember/LocalMember.ts

@@ -868,16 +868,19 @@ export function enterRTCSession(
     };
   }
 
-  // Calculates `maximumNetworkErrorRetryCount`. The connection is failed if EITHER:
-  // - The /sync loop is unresponsive for > `gracePeriod` ms, or
-  // - A delayed leave event is emitted (after `leaveDelay` ms period).
-  // Note: Use leaveDelay >> gracePeriod for delegated leave events.
+  // Calculates `maximumNetworkErrorRetryCount`: enough retries to outlast the
+  // server's delayed-leave window (see [lotus #46] below).
   const gracePeriod = Config.get().sync_disconnect_grace_period_ms;
   const leaveDelay = matrixRtcSessionConfig?.delayed_leave_event_delay_ms;
   const retryInterval = matrixRtcSessionConfig?.network_error_retry_ms;
 
-  // Math.min is used to account for the respective worst case: /sync not available or leave event emitted.
-  const maxWaitTime = Math.min(gracePeriod, leaveDelay);
+  // [lotus #46] Keep retrying for as long as the homeserver itself would keep
+  // our membership: until its delayed leave fires (`leaveDelay`). Capping at
+  // the 10 s sync grace period made a ~20–35 s homeserver stall end everyone's
+  // call ("Connection lost") even with a 60 s server-side leave delay. The
+  // embedded call has no /sync loop of its own, so the grace period doesn't
+  // describe anything it can observe.
+  const maxWaitTime = Math.max(gracePeriod, leaveDelay);
   const maximumNetworkErrorRetryCount =
     Math.ceil(maxWaitTime / retryInterval) + 1;