LotusGuild/element-call
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(lotus): soundboard refuses while muted (replies reason:"muted"); one shared AudioContext

Browse Source 
- Injection is gated on localParticipant.isMicrophoneEnabled and replies
  { played:false, reason:"muted" } (host UI follow-up in cinny) (#13).
- One lazily created module-level AudioContext/destination for all
  clips, ref-counted and closed on last teardown; per clip only a
  BufferSource + Gain. The replace-mode race handling is preserved and
  three latent dangling-placeholder paths are closed (#14).

Fixes #13
Fixes #14

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PPmy3tPq869XDW4njjVaKA
This commit is contained in:
Lotus CI
2026-09-13 01:22:20 -04:00
co-authored by Claude Opus 5
parent dcba5b6b7e
commit 68eafcb9a8
2 changed files with 306 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lotus/lotusAudioInject.ts
+81 -20
View File
@@ -17,6 +17,30 @@ import { lotusFlag } from "./lotusWidget";
/** Hard cap so a malformed/huge clip can't hold a published track open forever. */
const MAX_CLIP_MS = 30_000;
// [lotus] One shared module-level AudioContext + MediaStreamAudioDestinationNode
// for ALL injected clips (#14), instead of `new AudioContext()` per clip. An
// in-call page already sits close to Chrome's per-document AudioContext limit
// (~6) between useAudioContext, MatrixAudioRenderer, LiveKit's own Room
// context and LotusDenoiseProcessor; rapid clip replacement (replace-mode
// closing the previous clip's context in the background) could transiently
// exceed the cap and make `new AudioContext()` throw. Lazily created on first
// use, ref-counted by the number of active `startLotusAudioInject` instances,
// and closed only when the last one tears down.
let sharedCtx: AudioContext | undefined;
let sharedDest: MediaStreamAudioDestinationNode | undefined;
let handlerCount = 0;
function acquireSharedAudio(): {
ctx: AudioContext;
dest: MediaStreamAudioDestinationNode;
} {
if (!sharedCtx || sharedCtx.state === "closed") {
sharedCtx = new AudioContext();
sharedDest = sharedCtx.createMediaStreamDestination();
}
return { ctx: sharedCtx, dest: sharedDest! };
}
/**
* Handle the host's `io.lotus.inject_audio` toWidget action (#3): mix a
* soundboard clip into the call so other participants hear it.
@@ -38,6 +62,10 @@ export function startLotusAudioInject(vm: CallViewModel): () => void {
const w = widget;
if (!w) return () => undefined;
// [lotus] Count this instance toward the shared AudioContext's lifetime
// (#14) — closed only once the last active instance tears down.
handlerCount++;
// Track the set of connected LiveKit rooms to publish into. Drive off the
// LOCAL participant's connection(s), not `livekitRoomItems$` — that stream
// omits rooms with no remote members, so inject would no-op while you're
@@ -52,16 +80,19 @@ export function startLotusAudioInject(vm: CallViewModel): () => void {
const activeClips = new Set<() => void>();
const handler = (ev: CustomEvent<IWidgetApiRequest>): void => {
// Always ack so the transport doesn't hang, but only act when the host has
// explicitly opted in: audio-inject publishes under the local user's
// identity, so it must not be silently armed for every call.
w.api.transport.reply(ev.detail, {});
if (!lotusFlag("lotusAudioInject")) return;
if (!lotusFlag("lotusAudioInject")) {
// Always ack so the transport doesn't hang, but only act when the host
// has explicitly opted in: audio-inject publishes under the local
// user's identity, so it must not be silently armed for every call.
w.api.transport.reply(ev.detail, {});
return;
}
const data = ev.detail.data as
| { url?: unknown; volume?: unknown }
| undefined;
const url = typeof data?.url === "string" ? safeMediaUrl(data.url) : null;
if (!url) {
w.api.transport.reply(ev.detail, {});
logger.warn("[lotus] inject_audio: missing/invalid url");
return;
}
@@ -69,6 +100,21 @@ export function startLotusAudioInject(vm: CallViewModel): () => void {
typeof data?.volume === "number" && data.volume >= 0 && data.volume <= 1
? data.volume
: 1;
// [lotus] Gate on the local mic being enabled (#13): the clip is
// published as an independent track, fully decoupled from the mic
// publication's mute state, so without this a muted (or push-to-talk
// idle) user could still transmit soundboard audio under their own
// identity — breaking the "I am muted, nothing I do makes noise" mental
// model. Reply with a machine-readable reason so cinny's soundboard UI
// can surface a hint instead of the click silently doing nothing.
const micEnabled = rooms[0]?.localParticipant.isMicrophoneEnabled ?? true;
if (!micEnabled) {
w.api.transport.reply(ev.detail, { played: false, reason: "muted" });
return;
}
w.api.transport.reply(ev.detail, {});
void playInjectedClip(url, volume, rooms, activeClips).catch((e) =>
logger.warn("[lotus] inject_audio failed", e),
);
@@ -86,6 +132,15 @@ export function startLotusAudioInject(vm: CallViewModel): () => void {
// activeClips while we iterate it.
// eslint-disable-next-line unicorn/no-useless-spread
for (const abort of [...activeClips]) abort();
// [lotus] Close the shared AudioContext only when the last active
// instance tears down (#14).
handlerCount--;
if (handlerCount === 0 && sharedCtx) {
const ctx = sharedCtx;
sharedCtx = undefined;
sharedDest = undefined;
void ctx.close().catch(() => undefined);
}
};
}
@@ -146,23 +201,25 @@ async function playInjectedClip(
throw e;
}
if (aborted) return;
if (!resp.ok) throw new Error(`fetch ${url} -> ${resp.status}`);
if (!resp.ok) {
activeClips.delete(placeholder);
throw new Error(`fetch ${url} -> ${resp.status}`);
}
const arrayBuffer = await resp.arrayBuffer();
if (aborted) return;
const ctx = new AudioContext();
// [lotus] Reuse the shared module-level context/destination (#14) rather
// than `new AudioContext()` per clip — see the declaration above.
const { ctx, dest } = acquireSharedAudio();
// The action arrives via host postMessage, not a gesture in this iframe, so
// the context may start suspended — resume it or the clip is silent and
// `onended` never fires.
// `onended` never fires. A no-op if an earlier clip already resumed it.
try {
await ctx.resume();
} catch {
/* best effort */
}
if (aborted) {
void ctx.close();
return;
}
if (aborted) return;
if (ctx.state !== "running")
logger.warn(`[lotus] inject_audio: AudioContext is ${ctx.state}`);
@@ -170,15 +227,13 @@ async function playInjectedClip(
try {
buffer = await ctx.decodeAudioData(arrayBuffer);
} catch (e) {
void ctx.close();
activeClips.delete(placeholder);
throw e;
}
if (aborted) {
void ctx.close();
return;
}
if (aborted) return;
const dest = ctx.createMediaStreamDestination();
// Per clip, only the BufferSource/GainNode are created (#14) — the shared
// context/destination are reused across every clip.
const gain = ctx.createGain();
gain.gain.value = volume;
const source = ctx.createBufferSource();
@@ -187,7 +242,9 @@ async function playInjectedClip(
const mst = dest.stream.getAudioTracks()[0];
if (!mst) {
void ctx.close();
source.disconnect();
gain.disconnect();
activeClips.delete(placeholder);
throw new Error("no audio track from destination");
}
@@ -221,13 +278,17 @@ async function playInjectedClip(
} catch {
/* already stopped */
}
// [lotus] Dispose only this clip's own nodes (#14) — the shared
// AudioContext/destination outlive it and are closed separately, only
// when the last startLotusAudioInject instance tears down.
source.disconnect();
gain.disconnect();
for (const entry of publications) {
if (entry?.pub.track)
void entry.room.localParticipant
.unpublishTrack(entry.pub.track, true)
.catch(() => undefined);
}
void ctx.close().catch(() => undefined);
};
// Swap the synchronous placeholder for the real cleanup: from here an abort
// (teardown or a newer clip) must unpublish the LIVE track, not just cancel a