@burdenoff/fe-libs 2026.1013.13 → 2026.1013.14

package/dist/shared/assistant/avatar/live/liveAvatarController.d.ts

@@ -0,0 +1,133 @@
+import { SpeechEngine, SpeechSpeakOptions } from '../../speech/types';
+import { AvatarProblem } from '../useAvatarCopy';
+import { AvatarMeterHandle } from './avatarAudioMeter';
+import { AvatarRoom, AvatarScheduler } from './avatarPorts';
+import { AvatarTrackerConfig } from './avatarPlaybackTracker';
+import { AvatarDecodedPiece, AvatarNotice, AvatarReplyOutputs } from './avatarReplyOutputs';
+import { AvatarClientEndReason, AvatarSessionClient } from './avatarSessionClient';
+import { AvatarReadinessProbeOptions } from './avatarTransport';
+/** End after this long without a reply on the avatar while it is on (OD8, BACKEND-DESIGN §8.7). */
+export declare const LIVE_AVATAR_IDLE_MS = 120000;
+/** End gracefully, between replies, this long before the server's hard end (`endsAt`, §3.6). */
+export declare const LIVE_AVATAR_END_BEFORE_DEADLINE_MS = 10000;
+/** The longest the availability and status questions may take: a hung request never leaves the toggle disabled. */
+export declare const LIVE_AVATAR_REQUEST_TIMEOUT_MS = 8000;
+/** The longest a connect may take (the avatar's own wait for its video, 8 s, plus the readiness probe, 6 s, plus slack). */
+export declare const LIVE_AVATAR_CONNECT_TIMEOUT_MS = 20000;
+export type LiveAvatarPhase = 
+/** Nothing running. */
+'off'
+/** Asking the server whether the avatar is offered here. */
+ | 'checking'
+/** Offered: the person chooses an avatar and confirms the disclosure. */
+ | 'choosing'
+/** The server is starting a session. */
+ | 'starting'
+/** Joining the session's room and waiting for the avatar. */
+ | 'connecting'
+/** Replies may play on the avatar. */
+ | 'ready'
+/** Ending the session. */
+ | 'ending';
+export type LiveAvatarNotice = 'interrupted' | 'voice-only' | 'time-limit';
+export interface LiveAvatarSnapshot {
+    /** A voice conversation is live: the only time the avatar is offered (P2). */
+    readonly voiceLive: boolean;
+    /** The toggle may be shown: the browser can show the avatar, it was not refused on this page, and a voice conversation is live. */
+    readonly offered: boolean;
+    readonly phase: LiveAvatarPhase;
+    /** The avatars the server offers, from the last availability answer. */
+    readonly avatars: readonly string[];
+    /** The avatar the next session starts with. */
+    readonly selectedAvatarId: string | null;
+    /** What the person must read before the avatar starts; null until the server said which version. */
+    readonly consentVersion: string | null;
+    readonly problem: AvatarProblem | null;
+    readonly notice: LiveAvatarNotice | null;
+    /** The browser blocks the avatar's sound; a tap on the stage (`resumeAudio`) lifts it. */
+    readonly audioBlocked: boolean;
+    /** The avatar's video has arrived. */
+    readonly videoReady: boolean;
+}
+/** The person's stored choices (P4), read and written through this narrow port so tests need no storage. */
+export interface LiveAvatarPreferences {
+    getState(): {
+        readonly avatarEnabled: boolean;
+        readonly avatarId: string | null;
+    };
+    setAvatarEnabled(enabled: boolean): void;
+    setAvatarId(avatarId: string | null): void;
+    subscribe(listener: () => void): () => void;
+}
+/** A diagnostic event for the host's logs: never a token, an id of the person, or text of a reply. */
+export type LiveAvatarLogEvent = {
+    readonly event: 'notice';
+    readonly notice: AvatarNotice;
+} | {
+    readonly event: 'refused';
+    readonly status: number;
+    readonly code: string;
+} | {
+    readonly event: 'session-ended';
+    readonly reason: AvatarClientEndReason | 'server';
+} | {
+    readonly event: 'connect-failed';
+    readonly error: string;
+};
+export interface LiveAvatarControllerDeps {
+    /** The session API, or null when the host configured no hosted TTS (the avatar then has nothing to animate). */
+    readonly client: () => AvatarSessionClient | null;
+    /** Loads the media SDK (lazily) and opens a room: called only after a session started. */
+    readonly openRoom: () => Promise<AvatarRoom>;
+    readonly scheduler: AvatarScheduler;
+    readonly preferences: LiveAvatarPreferences;
+    readonly decode: (bytes: Uint8Array, signal: AbortSignal) => Promise<AvatarDecodedPiece>;
+    /** The element the avatar's audio plays in, kept outside the stage so a collapse never cuts a reply; null without a DOM. */
+    readonly createAudioElement: () => HTMLAudioElement | null;
+    readonly releaseAudioElement: (element: HTMLAudioElement) => void;
+    /** A level meter on the avatar's received audio; null when none can be built (the output then cannot prove silence). */
+    readonly startMeter: (track: MediaStreamTrack, onChange: (audible: boolean) => void) => AvatarMeterHandle | null;
+    /** The browser can show the avatar at all (desktop Chromium first: GATE1B §10). */
+    readonly browserSupported: () => boolean;
+    /** Wall-clock milliseconds: only the fallback for `endsAt` when the server announced no session length (the server's clock may differ). */
+    readonly now: () => number;
+    readonly newIdempotencyKey: () => string;
+    readonly subscribeWorkspaceChange?: (listener: () => void) => () => void;
+    readonly subscribePageHide?: (listener: () => void) => () => void;
+    readonly idleMs?: number;
+    readonly endBeforeDeadlineMs?: number;
+    readonly connectTimeoutMs?: number;
+    readonly requestTimeoutMs?: number;
+    readonly trackerConfig?: AvatarTrackerConfig;
+    readonly maxDrainMs?: number;
+    readonly stallMs?: number;
+    readonly readinessProbe?: AvatarReadinessProbeOptions | false;
+    readonly onLog?: (event: LiveAvatarLogEvent) => void;
+}
+export interface LiveAvatarController {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): LiveAvatarSnapshot;
+    /** From the seam (P2): a voice conversation is live, or over. */
+    setVoiceLive(live: boolean): void;
+    /** The person asked for the avatar: ask the server whether it is offered, then show the chooser and the disclosure. */
+    requestOn(): void;
+    /** The person confirmed the disclosure: start a session with the chosen avatar. */
+    confirm(): void;
+    /** The person declined the disclosure. */
+    cancelChoice(): void;
+    selectAvatar(avatarId: string): void;
+    /** Avatar OFF: the toggle, the compact view's stop, the end of the voice conversation (P2). Idempotent. */
+    switchOff(): void;
+    /** A user gesture: let the avatar's sound play (autoplay) and wake the level meter. */
+    resumeAudio(): void;
+    /** The stage that shows the avatar mounted (or unmounted): replies go to the avatar only while it is shown (D4). */
+    setStageMounted(mounted: boolean): void;
+    /** The stage's video element, or null when it goes. */
+    attachVideo(element: HTMLVideoElement | null): void;
+    /** Where one reply goes: the avatar, or the speakers (untouched). */
+    route(options: SpeechSpeakOptions, base: SpeechEngine): 'avatar' | 'speakers';
+    /** A fresh audio output for one reply routed to the avatar. */
+    createOutput(): ReturnType<AvatarReplyOutputs['createOutput']>;
+    dispose(): void;
+}
+export declare function createLiveAvatarController(deps: LiveAvatarControllerDeps): LiveAvatarController;

package/dist/shared/assistant/avatar/live/liveAvatarController.js

@@ -0,0 +1,488 @@
+import { AvatarNotReadyError as e, LiveKitAvatarTransport as t } from "./avatarTransport.js";
+import { createAvatarTransportPort as n } from "./avatarTransportPort.js";
+import { createAvatarReplyOutputs as r } from "./avatarReplyOutputs.js";
+import { AvatarApiError as i, avatarRefusalFor as a } from "./avatarSessionClient.js";
+//#region src/shared/assistant/avatar/live/liveAvatarController.ts
+var o = 12e4, s = 1e4, c = 8e3, l = 5e3, u = 2e4, d = {
+	voiceLive: !1,
+	offered: !1,
+	phase: "off",
+	avatars: [],
+	selectedAvatarId: null,
+	consentVersion: null,
+	problem: null,
+	notice: null,
+	audioBlocked: !1,
+	videoReady: !1
+};
+function f(e) {
+	switch (e) {
+		case "start_superseded": return {
+			problem: "already-running",
+			notice: null
+		};
+		case "deadline": return {
+			problem: null,
+			notice: "time-limit"
+		};
+		case "kill_switch":
+		case "disabled":
+		case "shutdown": return {
+			problem: "paused",
+			notice: null
+		};
+		case "provider_ended":
+		case "provider_failed":
+		case "worker_absent":
+		case "no_show":
+		case "terms_mismatch":
+		case "start_timeout": return {
+			problem: "provider",
+			notice: null
+		};
+		default: return {
+			problem: "connection",
+			notice: null
+		};
+	}
+}
+var p = new Set(["playback-blocked", "needs-hosted-voice"]);
+function m(o) {
+	let { scheduler: s, preferences: c } = o, u = o.idleMs ?? 12e4, m = o.endBeforeDeadlineMs ?? 1e4, h = o.connectTimeoutMs ?? 2e4, g = o.requestTimeoutMs ?? 8e3, _ = d, v = /* @__PURE__ */ new Set(), y = !1, b = null, x = 0, S = !1, C = !1, w = 0, T = null, E = null, D = null, O = 0, k = !1, A = null, j = null, M = !1;
+	function N(e) {
+		try {
+			o.onLog?.(e);
+		} catch {}
+	}
+	function P(e) {
+		return e && !y && o.browserSupported();
+	}
+	function F(e) {
+		let t = {
+			..._,
+			...e
+		}, n = P(t.voiceLive), r = {
+			...t,
+			offered: n
+		};
+		if (!Object.keys(r).every((e) => r[e] === _[e])) {
+			_ = r;
+			for (let e of [...v]) try {
+				e();
+			} catch {}
+		}
+	}
+	function I() {
+		c.getState().avatarEnabled !== S && c.setAvatarEnabled(S);
+	}
+	let L = {
+		positionSec: null,
+		synthetic: !0,
+		rpc: "none"
+	}, R = r({
+		port: {
+			isActive: () => E !== null && E.port.isActive(),
+			isAudioBlocked: () => E?.port.isAudioBlocked() ?? !1,
+			connectionId: () => E?.port.connectionId() ?? 0,
+			isMeterHealthy: () => E?.port.isMeterHealthy() ?? !1,
+			isMeterAudible: () => E?.port.isMeterAudible() ?? !1,
+			openSegment: () => E ? E.port.openSegment() : Promise.reject(new e("connection")),
+			clearBuffer: (e) => E ? E.port.clearBuffer(e) : Promise.resolve(L),
+			setOutputMuted: (e) => E?.port.setOutputMuted(e),
+			subscribe: (e) => E ? E.port.subscribe(e) : () => void 0
+		},
+		scheduler: s,
+		decode: o.decode,
+		...o.trackerConfig ? { trackerConfig: o.trackerConfig } : {},
+		...o.maxDrainMs === void 0 ? {} : { maxDrainMs: o.maxDrainMs },
+		...o.stallMs === void 0 ? {} : { stallMs: o.stallMs },
+		onNotice: (e) => {
+			switch (N({
+				event: "notice",
+				notice: e
+			}), e.kind) {
+				case "interrupted":
+					F({ notice: "interrupted" });
+					return;
+				case "voice-fallback":
+					S && F({ notice: "voice-only" });
+					return;
+				case "audio-blocked":
+					F({
+						audioBlocked: !0,
+						problem: "playback-blocked"
+					});
+					return;
+				default: return;
+			}
+		},
+		onActivity: (e) => {
+			if (e) {
+				A?.(), A = null;
+				return;
+			}
+			if (C) {
+				H("user", { notice: "time-limit" });
+				return;
+			}
+			z();
+		}
+	});
+	function z() {
+		A?.(), A = null, _.phase === "ready" && (A = s.setTimeout(() => {
+			A = null, _.phase === "ready" && !R.isBusy() && H("idle", {});
+		}, u));
+	}
+	function B() {
+		A?.(), A = null, j?.(), j = null;
+	}
+	function V() {
+		R.leave();
+		let e = E;
+		if (E = null, e !== null) {
+			if (e.unsubscribe?.(), e.meter !== null) {
+				if (e.meterAudible) {
+					e.meterAudible = !1;
+					for (let t of [...e.meterListeners]) t(!1);
+				}
+				e.meter.stop();
+			}
+			e.videoTrack?.detach(), e.transport.dispose(), e.audioElement !== null && o.releaseAudioElement(e.audioElement);
+		}
+	}
+	function H(e, t) {
+		w += 1, S = !1, C = !1, V(), B();
+		let n = T;
+		T = null, I(), n !== null && (N({
+			event: "session-ended",
+			reason: e
+		}), o.client()?.end(n, {
+			reason: e,
+			keepalive: t.keepalive === !0
+		}).catch(() => void 0)), F({
+			phase: "off",
+			audioBlocked: !1,
+			videoReady: !1,
+			...t.problem === void 0 ? _.problem !== null && p.has(_.problem) ? { problem: null } : {} : { problem: t.problem },
+			...t.notice === void 0 ? {} : { notice: t.notice }
+		});
+	}
+	function U(e) {
+		let t = a(e);
+		t.hide && (y = !0), e instanceof i && N({
+			event: "refused",
+			status: e.status,
+			code: e.code
+		}), S = !1, I(), F({
+			phase: "off",
+			problem: t.problem
+		});
+	}
+	function W() {
+		y = !0, S = !1, I(), F({
+			phase: "off",
+			problem: "unavailable",
+			avatars: []
+		});
+	}
+	function G(e) {
+		switch (e.type) {
+			case "audioPlayback":
+				e.canPlay ? _.problem === "playback-blocked" ? F({
+					audioBlocked: !1,
+					problem: null
+				}) : F({ audioBlocked: !1 }) : F({
+					audioBlocked: !0,
+					problem: "playback-blocked"
+				});
+				return;
+			case "avatarLeft":
+			case "disconnected":
+				K();
+				return;
+			default: return;
+		}
+	}
+	async function K() {
+		let e = T;
+		if (e === null || _.phase === "ending" || _.phase === "off") return;
+		let t = w;
+		F({ phase: "ending" });
+		let n = null, r = !1;
+		try {
+			let t = o.client(), i = t === null ? void 0 : await J((n) => t.status(e, n));
+			n = i?.endedReason ?? null, r = i !== void 0 && [
+				"ended",
+				"failed",
+				"canceled"
+			].includes(i.state);
+		} catch {}
+		if (w !== t) return;
+		let i = f(n);
+		r && (T = null, N({
+			event: "session-ended",
+			reason: "server"
+		})), H("client_error", i);
+	}
+	async function q(e, r) {
+		let i = o.client();
+		if (i === null) {
+			W();
+			return;
+		}
+		let a = ++w;
+		F({
+			phase: "starting",
+			problem: null,
+			notice: null
+		});
+		let c;
+		try {
+			c = await o.openRoom();
+		} catch {
+			w === a && W();
+			return;
+		}
+		let u = () => {
+			c.disconnect().catch(() => void 0);
+		};
+		if (w !== a) {
+			u();
+			return;
+		}
+		let d = s.now(), f;
+		try {
+			f = await i.create({
+				avatarId: e,
+				consentVersion: r,
+				idempotencyKey: o.newIdempotencyKey()
+			});
+		} catch (e) {
+			u(), w === a && U(e);
+			return;
+		}
+		if (w !== a) {
+			u(), i.end(f.sessionId, { reason: k ? "voice_end" : "user" }).catch(() => void 0);
+			return;
+		}
+		T = f.sessionId, F({ phase: "connecting" });
+		let p = new t({
+			room: c,
+			avatarIdentity: f.avatarIdentity,
+			scheduler: s,
+			...o.readinessProbe === void 0 ? {} : { readinessProbe: o.readinessProbe }
+		}), g = /* @__PURE__ */ new Set(), _ = {
+			session: f,
+			transport: p,
+			audioElement: o.createAudioElement(),
+			meter: null,
+			meterAudible: !1,
+			meterListeners: g,
+			videoTrack: null,
+			unsubscribe: null,
+			port: n({
+				transport: p,
+				isEnabled: () => S && !C,
+				subscribeMeter: (e) => (g.add(e), () => {
+					g.delete(e);
+				}),
+				isMeterHealthy: () => _.meter?.isRunning() ?? !1
+			})
+		};
+		E = _, _.unsubscribe = p.subscribe(G);
+		try {
+			await Y(p.connect({
+				url: f.livekitUrl,
+				token: f.participantToken,
+				audioElement: _.audioElement,
+				onAvatarAudio: (e) => {
+					if (!(e.mediaStreamTrack === null || _.meter !== null)) try {
+						_.meter = o.startMeter(e.mediaStreamTrack, (e) => {
+							_.meterAudible = e;
+							for (let t of [...g]) t(e);
+						});
+					} catch {
+						_.meter = null;
+					}
+				},
+				onAvatarVideo: (e) => {
+					_.videoTrack = e, D !== null && e.attach(D), E === _ && F({ videoReady: !0 });
+				}
+			}), h);
+		} catch (e) {
+			if (w !== a) return;
+			N({
+				event: "connect-failed",
+				error: e instanceof Error ? e.name : "error"
+			}), H("client_error", { problem: "connection" });
+			return;
+		}
+		if (w !== a || E !== _) return;
+		F({
+			phase: "ready",
+			audioBlocked: p.audioBlocked,
+			...p.audioBlocked ? { problem: "playback-blocked" } : {}
+		}), z();
+		let v = x > 0 ? d + x - l - s.now() : f.endsAt - o.now(), y = Math.max(0, v - m);
+		j = s.setTimeout(() => {
+			j = null, w === a && (C = !0, R.isBusy() || H("user", { notice: "time-limit" }));
+		}, y);
+	}
+	function J(t) {
+		let n = new AbortController();
+		return new Promise((r, i) => {
+			let a = s.setTimeout(() => {
+				n.abort(), i(new e("connection"));
+			}, g);
+			t(n.signal).then((e) => {
+				a(), r(e);
+			}, (e) => {
+				a(), i(e);
+			});
+		});
+	}
+	function Y(t, n) {
+		return new Promise((r, i) => {
+			let a = s.setTimeout(() => i(new e("connection")), n);
+			t.then((e) => {
+				a(), r(e);
+			}, (e) => {
+				a(), i(e);
+			});
+		});
+	}
+	let X = [];
+	X.push(c.subscribe(() => {
+		let e = c.getState().avatarEnabled;
+		if (e !== S) {
+			if (e) {
+				c.setAvatarEnabled(!1);
+				return;
+			}
+			_.phase !== "off" && _.phase !== "checking" && _.phase !== "choosing" ? H(k ? "voice_end" : "user", {}) : S = !1;
+		}
+	})), o.subscribeWorkspaceChange && X.push(o.subscribeWorkspaceChange(() => {
+		if (y = !1, _.phase === "off") {
+			F({
+				problem: null,
+				avatars: [],
+				consentVersion: null
+			});
+			return;
+		}
+		H("workspace_switch", { problem: null }), F({
+			avatars: [],
+			consentVersion: null
+		});
+	})), o.subscribePageHide && X.push(o.subscribePageHide(() => {
+		(T !== null || _.phase !== "off") && H("page_hide", { keepalive: !0 });
+	}));
+	let Z = {
+		subscribe(e) {
+			return v.add(e), () => {
+				v.delete(e);
+			};
+		},
+		getSnapshot: () => _,
+		setVoiceLive(e) {
+			if (k = !e, e) {
+				F({
+					voiceLive: !0,
+					problem: y ? _.problem : null,
+					notice: null
+				});
+				return;
+			}
+			(T !== null || _.phase !== "off") && (_.phase === "checking" || _.phase === "choosing" ? (w += 1, F({ phase: "off" })) : H("voice_end", {})), F({
+				voiceLive: !1,
+				notice: null
+			});
+		},
+		requestOn() {
+			if (M || !_.offered || _.phase !== "off") return;
+			let e = o.client();
+			if (e === null) {
+				W();
+				return;
+			}
+			let t = ++w;
+			F({
+				phase: "checking",
+				problem: null,
+				notice: null
+			}), J((t) => e.availability(t)).then((e) => {
+				if (w !== t) return;
+				if (!e.available) {
+					W();
+					return;
+				}
+				x = e.maxSessionSeconds * 1e3;
+				let n = c.getState().avatarId, r = n !== null && e.avatars.includes(n) ? n : e.avatars[0] ?? null;
+				F({
+					phase: "choosing",
+					avatars: e.avatars,
+					selectedAvatarId: r,
+					consentVersion: e.consentVersion
+				}), b === e.consentVersion && e.avatars.length === 1 && Z.confirm();
+			}, (e) => {
+				w === t && U(e);
+			});
+		},
+		confirm() {
+			if (_.phase !== "choosing" || !_.voiceLive) return;
+			let e = _.selectedAvatarId, t = _.consentVersion;
+			e === null || t === null || (b = t, c.setAvatarId(e), S = !0, I(), q(e, t));
+		},
+		cancelChoice() {
+			_.phase === "choosing" && (w += 1, F({ phase: "off" }));
+		},
+		selectAvatar(e) {
+			_.avatars.includes(e) && F({ selectedAvatarId: e });
+		},
+		switchOff() {
+			if (_.phase === "checking" || _.phase === "choosing") {
+				w += 1, F({ phase: "off" });
+				return;
+			}
+			if (_.phase === "off" && !S) {
+				I();
+				return;
+			}
+			H(k ? "voice_end" : "user", {});
+		},
+		resumeAudio() {
+			let e = E;
+			e !== null && (e.transport.resumeAudio().catch(() => void 0), e.meter?.resume().catch(() => void 0));
+		},
+		setStageMounted(e) {
+			O = Math.max(0, O + (e ? 1 : -1));
+		},
+		attachVideo(e) {
+			let t = E?.videoTrack ?? null;
+			if (e === null) {
+				D !== null && t?.detach(), D = null;
+				return;
+			}
+			D = e, t?.attach(e);
+		},
+		route(e, t) {
+			if (_.phase !== "ready" || C || !S || O === 0 || E === null || E.port.isAudioBlocked() || e.fallback === !1) return "speakers";
+			let n = e.voice;
+			return n !== null && n.source !== "hosted" || !t.listVoices().some((e) => e.source === "hosted") ? (N({
+				event: "notice",
+				notice: { kind: "needs-hosted-voice" }
+			}), F({ problem: "needs-hosted-voice" }), "speakers") : (_.problem === "needs-hosted-voice" && F({ problem: null }), "avatar");
+		},
+		createOutput: () => R.createOutput(),
+		dispose() {
+			if (!M) {
+				M = !0, (T !== null || _.phase !== "off") && H("user", {});
+				for (let e of X.splice(0)) e();
+				v.clear();
+			}
+		}
+	};
+	return Z;
+}
+//#endregion
+export { u as LIVE_AVATAR_CONNECT_TIMEOUT_MS, s as LIVE_AVATAR_END_BEFORE_DEADLINE_MS, o as LIVE_AVATAR_IDLE_MS, c as LIVE_AVATAR_REQUEST_TIMEOUT_MS, m as createLiveAvatarController };

package/dist/shared/assistant/avatar/live/liveAvatarStatus.d.ts

@@ -0,0 +1,4 @@
+import { AvatarCopy } from '../useAvatarCopy';
+import { LiveAvatarSnapshot } from './liveAvatarController';
+/** The words for the avatar's state line: what went wrong, what it is doing, or null. */
+export declare function liveAvatarStatusText(snapshot: LiveAvatarSnapshot, copy: AvatarCopy): string | null;

package/dist/shared/assistant/avatar/live/liveAvatarStatus.js

@@ -0,0 +1,14 @@
+//#region src/shared/assistant/avatar/live/liveAvatarStatus.ts
+function e(e, t) {
+	if (e.problem === "playback-blocked" && e.audioBlocked) return null;
+	if (e.problem !== null) return t.problem(e.problem);
+	if (e.phase === "checking") return t.chooserLoading;
+	switch (e.notice) {
+		case "interrupted": return t.stateInterrupted;
+		case "voice-only": return t.stateVoiceOnly;
+		case "time-limit": return t.stateTimeLimit;
+		default: return null;
+	}
+}
+//#endregion
+export { e as liveAvatarStatusText };

package/dist/shared/assistant/avatar/live/liveKitAvatarRoom.d.ts

@@ -0,0 +1,6 @@
+import { AvatarRoom } from './avatarPorts';
+/**
+ * Loads the SDK and returns a new room behind the `AvatarRoom` port. Rejects when the host does not ship the optional peer (the caller
+ * treats any rejection as "the avatar is unavailable here").
+ */
+export declare function openLiveKitAvatarRoom(): Promise<AvatarRoom>;