fix(lotus): soundboard says "not permitted" in audio-only rooms instead of failing silently (#47)

Clips publish as an Unknown-source track. In audio-only rooms the guard
signs a microphone-only token, LiveKit refuses the publish, and since
the fork had already replied {} the host never heard. Check the grants
up front and reply { played: false, reason: "not_permitted" }.

Refs #47

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

src/lotus/lotusAudioInject.test.ts

@@ -11,6 +11,7 @@ import { of } from "rxjs";
 
 import { type CallViewModel } from "../state/CallViewModel/CallViewModel";
 import {
+  canPublishSoundboard,
   MAX_INJECT_BYTES,
   parseInjectSource,
   startLotusAudioInject,
@@ -258,3 +259,17 @@ test("parseInjectSource rejects oversized or non-buffer audio", () => {
   expect(parseInjectSource({ audio: "not bytes" })).toBeNull();
   expect(parseInjectSource({ audio: new Uint8Array(4) })).toBeNull();
 });
+
+test("canPublishSoundboard: refused by a microphone-only grant (EC #47)", () => {
+  expect(canPublishSoundboard(undefined)).toBe(true);
+  expect(
+    canPublishSoundboard({ canPublish: true, canPublishSources: [] }),
+  ).toBe(true);
+  expect(
+    canPublishSoundboard({ canPublish: true, canPublishSources: [2] }),
+  ).toBe(false);
+  expect(
+    canPublishSoundboard({ canPublish: true, canPublishSources: [2, 0] }),
+  ).toBe(true);
+  expect(canPublishSoundboard({ canPublish: false })).toBe(false);
+});

src/lotus/lotusAudioInject.ts

@@ -60,6 +60,22 @@ function acquireSharedAudio(): {
  * No effect unless the host sends the action. Returns a teardown function that
  * also aborts any clip still playing.
  */
+/**
+ * Pure: whether these LiveKit permissions allow publishing the soundboard's
+ * Unknown-source track (EC #47). No permissions or an empty source list
+ * means unrestricted; otherwise UNKNOWN (TrackSource 0) must be allowed.
+ */
+export function canPublishSoundboard(
+  perm:
+    | { canPublish?: boolean; canPublishSources?: readonly number[] }
+    | undefined,
+): boolean {
+  if (!perm) return true;
+  if (perm.canPublish === false) return false;
+  const sources = perm.canPublishSources ?? [];
+  return sources.length === 0 || sources.includes(0);
+}
+
 export function startLotusAudioInject(vm: CallViewModel): () => void {
   const w = widget;
   if (!w) return () => undefined;
@@ -116,6 +132,19 @@ export function startLotusAudioInject(vm: CallViewModel): () => void {
       return;
     }
 
+    // [EC #47] Clips publish as an Unknown-source track. Audio-only rooms get
+    // a token limited to the microphone source, where LiveKit refuses that
+    // publish *after* we replied; say so up front instead of failing silently.
+    if (
+      rooms.some((r) => !canPublishSoundboard(r.localParticipant.permissions))
+    ) {
+      w.api.transport.reply(ev.detail, {
+        played: false,
+        reason: "not_permitted",
+      });
+      return;
+    }
+
     w.api.transport.reply(ev.detail, {});
     void playInjectedClip(clip, volume, rooms, activeClips).catch((e) =>
       logger.warn("[lotus] inject_audio failed", e),

src/state/CallViewModel/localMember/LocalMember.ts

@@ -868,19 +868,16 @@ export function enterRTCSession(
     };
   }
 
-  // Calculates `maximumNetworkErrorRetryCount`: enough retries to outlast the
-  // server's delayed-leave window (see [lotus #46] below).
+  // 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.
   const gracePeriod = Config.get().sync_disconnect_grace_period_ms;
   const leaveDelay = matrixRtcSessionConfig?.delayed_leave_event_delay_ms;
   const retryInterval = matrixRtcSessionConfig?.network_error_retry_ms;
 
-  // [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);
+  // Math.min is used to account for the respective worst case: /sync not available or leave event emitted.
+  const maxWaitTime = Math.min(gracePeriod, leaveDelay);
   const maximumNetworkErrorRetryCount =
     Math.ceil(maxWaitTime / retryInterval) + 1;