@burdenoff/fe-libs 2026.1013.13 → 2026.1013.14

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

@@ -0,0 +1,333 @@
+import { AVATAR_AUDIO_STREAM_TOPIC as e, AVATAR_RPC_CLEAR_BUFFER as t, AVATAR_RPC_PLAYBACK_FINISHED as n, AVATAR_RPC_PLAYBACK_STARTED as r, avatarPcmDurationSec as i, avatarSegmentAttributes as a, parseAvatarPlaybackFinished as o } from "./avatarProtocol.js";
+import { AvatarRpcRejectedError as s } from "./avatarPorts.js";
+//#region src/shared/assistant/avatar/live/avatarTransport.ts
+var c = class extends Error {
+	missing;
+	constructor(e) {
+		super(`avatar not ready: ${e}`), this.missing = e, this.name = "AvatarNotReadyError";
+	}
+}, l = class extends Error {
+	constructor() {
+		super("a previous segment is still open or not yet reported finished"), this.name = "AvatarSegmentBusyError";
+	}
+}, u = class extends Error {
+	constructor() {
+		super("segment ended"), this.name = "AvatarSegmentEndedError";
+	}
+}, d = class extends Error {
+	constructor() {
+		super("transport closed"), this.name = "AvatarTransportClosedError";
+	}
+};
+function f(e) {
+	let t = typeof e == "object" && e && "code" in e ? e.code : null;
+	return t === 1400 ? "unsupported" : t === 1502 ? "timeout" : t === 1503 ? "recipient-disconnected" : "error";
+}
+var p = class {
+	id;
+	writer;
+	owner;
+	state = "open";
+	pushedBytes = 0;
+	constructor(e, t, n) {
+		this.id = e, this.writer = t, this.owner = n;
+	}
+	get pushedSec() {
+		return i(this.pushedBytes);
+	}
+	async write(e) {
+		if (this.state !== "open" || e.byteLength !== 0 && (this.pushedBytes += e.byteLength, await this.writer.write(e), this.state !== "open")) throw new u();
+	}
+	async close() {
+		this.state === "open" && (this.state = "closed", await this.writer.close(), this.owner.segmentClosed(this));
+	}
+	discard() {
+		this.end(), this.owner.segmentDiscarded(this);
+	}
+	end() {
+		if (this.state === "ended") return;
+		let e = this.state === "open";
+		this.state = "ended", e && this.writer.close().catch(() => void 0);
+	}
+}, m = class i {
+	options;
+	static nextInstanceId = 1;
+	instanceId = i.nextInstanceId++;
+	state = "idle";
+	listeners = /* @__PURE__ */ new Set();
+	unsubscribes = [];
+	nextSegmentId = 1;
+	current = null;
+	awaiting = [];
+	clearInFlight = null;
+	clearSettle = null;
+	avatarPresent = !1;
+	videoPresent = !1;
+	degraded = !1;
+	audioElement = null;
+	disposed = !1;
+	rejectReady = null;
+	mediaReady = !1;
+	resolveMediaReady = null;
+	readinessStatus = null;
+	wakeProbe = null;
+	strayFinishDeadline = null;
+	strayAnswers = 0;
+	owedFinishes = 0;
+	avatarDepartures = 0;
+	constructor(e) {
+		this.options = e;
+	}
+	get transportState() {
+		return this.state;
+	}
+	get readiness() {
+		return this.readinessStatus;
+	}
+	get audioBlocked() {
+		return this.state === "ready" && !this.options.room.canPlaybackAudio();
+	}
+	subscribe(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	emit(e) {
+		for (let t of [...this.listeners]) try {
+			t(e);
+		} catch {}
+	}
+	async resumeAudio() {
+		await this.options.room.startAudio();
+	}
+	setOutputMuted(e) {
+		this.audioElement && (this.audioElement.muted = e);
+	}
+	async connect(e) {
+		if (this.state !== "idle") throw Error("transport already used");
+		this.state = "connecting";
+		let { room: t, avatarIdentity: i } = this.options;
+		this.audioElement = e.audioElement ?? null, t.registerRpc(n, (e, t) => this.handleFinished(e, t)), t.registerRpc(r, (e) => this.handleStarted(e)), this.unsubscribes.push(t.onParticipantConnected((e) => {
+			e === i && (this.avatarPresent = !0, this.checkReady());
+		}), t.onParticipantDisconnected((e) => {
+			e === i && (this.avatarPresent = !1, this.videoPresent = !1, this.avatarDepartures += 1, this.owedFinishes = 0, this.endAllSegments(), this.emit({ type: "avatarLeft" }));
+		}), t.onTrackSubscribed((t) => {
+			t.identity === i && (t.kind === "video" ? (e.videoElement && t.attach(e.videoElement), e.onAvatarVideo?.(t), this.videoPresent = !0, this.checkReady()) : (e.audioElement && t.attach(e.audioElement), e.onAvatarAudio?.(t)));
+		}), t.onDisconnected(() => {
+			this.endAllSegments(), this.state !== "closed" && (this.state = "closed"), this.emit({ type: "disconnected" });
+		}), t.onReconnecting(() => {
+			this.degraded = !0, this.emit({ type: "reconnecting" });
+		}), t.onReconnected(() => {
+			this.degraded = !1, this.emit({ type: "reconnected" });
+		}), t.onAudioPlaybackChanged((e) => this.emit({
+			type: "audioPlayback",
+			canPlay: e
+		})));
+		try {
+			await t.connect(e.url, e.token);
+		} catch (e) {
+			throw await this.teardown(), this.disposed ? new d() : e;
+		}
+		if (this.disposed) throw await t.disconnect().catch(() => void 0), new d();
+		this.avatarPresent = t.hasParticipant(i), this.videoPresent = t.hasVideoTrack(i);
+		let a;
+		try {
+			if (await this.waitMediaReady(), a = await this.probeReadiness(), this.disposed) throw new d();
+			if (this.state !== "connecting") throw new c("connection");
+		} catch (e) {
+			throw await this.teardown(), this.disposed ? new d() : e;
+		}
+		if (this.state = "ready", this.emit(a), this.disposed || this.state !== "ready") throw await this.teardown(), new d();
+		this.emit({ type: "ready" });
+	}
+	armStrayWindow(e) {
+		this.strayAnswers += 1, this.strayFinishDeadline = this.options.scheduler.now() + e;
+	}
+	expectLateAnswer(e, t, n, r) {
+		!e || t === "rejected" || t === "unsupported" || (t === "ok" || n ? this.armStrayWindow(r) : this.owedFinishes += 1);
+	}
+	checkReady() {
+		this.state === "connecting" && !this.mediaReady && this.avatarPresent && this.videoPresent && (this.mediaReady = !0, this.resolveMediaReady?.());
+	}
+	waitMediaReady() {
+		return this.checkReady(), this.mediaReady ? Promise.resolve() : new Promise((e, t) => {
+			let n = this.options.scheduler.setTimeout(() => {
+				r(), this.resolveMediaReady = null, this.teardown().finally(() => {
+					t(new c(this.avatarPresent ? "video" : "participant"));
+				});
+			}, this.options.readyTimeoutMs ?? 8e3), r = this.subscribe((e) => {
+				e.type === "disconnected" && (n(), r(), this.resolveMediaReady = null, t(new c("connection")));
+			});
+			this.resolveMediaReady = () => {
+				n(), r(), this.resolveMediaReady = null, e();
+			}, this.rejectReady = (e) => {
+				n(), r(), this.resolveMediaReady = null, t(e);
+			};
+		});
+	}
+	async probeReadiness() {
+		let e = this.options.readinessProbe, { scheduler: n, room: r, avatarIdentity: i } = this.options;
+		if (e === !1) return this.readinessStatus = "skipped", {
+			type: "readiness",
+			status: "skipped",
+			attempts: 0,
+			ms: 0,
+			lastReason: null
+		};
+		let a = e?.timeoutMs ?? 6e3, o = e?.rpcTimeoutMs ?? 1500, s = e?.maxBackoffMs ?? 1e3, l = this.options.clearTimeoutMs ?? 2e3, u = e?.initialBackoffMs ?? 150, p = n.now(), m = 0, h = null, g = () => {
+			if (this.disposed) throw new d();
+			if (this.state !== "connecting") throw new c("connection");
+			if (!this.avatarPresent) throw new c("participant");
+		}, _ = (e) => (this.readinessStatus = e, {
+			type: "readiness",
+			status: e,
+			attempts: m,
+			ms: Math.round(n.now() - p),
+			lastReason: h
+		});
+		for (;;) {
+			g(), m += 1;
+			let e = Math.max(1, a - (n.now() - p)), d = Math.min(o, e), v, y = () => void 0;
+			try {
+				v = await Promise.race([r.performRpc(i, t, "", d).then((e) => ({ reply: e }), (e) => ({ reason: f(e) })), new Promise((e) => {
+					y = n.setTimeout(() => e({ reason: "timeout" }), d);
+				})]);
+			} finally {
+				y();
+			}
+			if (("reply" in v ? v.reply.trim().toLowerCase() === "reject" : v.reason === "unsupported") || this.armStrayWindow(l), g(), "reply" in v) return v.reply.trim().toLowerCase() === "reject" ? (h = "rejected", _("unconfirmed")) : _("confirmed");
+			if (h = v.reason, v.reason === "recipient-disconnected") throw new c("participant");
+			if (n.now() - p + u >= a) return _("unconfirmed");
+			await new Promise((e) => {
+				let t = n.setTimeout(() => {
+					this.wakeProbe = null, e();
+				}, u);
+				this.wakeProbe = () => {
+					t(), this.wakeProbe = null, e();
+				};
+			}), u = Math.min(u * 2, s);
+		}
+	}
+	assertReady() {
+		if (this.state !== "ready" || !this.avatarPresent || this.degraded) throw new c(this.state === "ready" && this.avatarPresent ? "connection" : "participant");
+	}
+	async openSegment() {
+		if (this.assertReady(), this.current !== null || this.awaiting.length > 0 || this.clearInFlight !== null) throw new l();
+		let t = this.nextSegmentId++, n = await this.options.room.openByteStream({
+			topic: e,
+			name: `AUDIO_${t}`,
+			destinationIdentity: this.options.avatarIdentity,
+			attributes: a()
+		});
+		if (this.state !== "ready") throw await n.close().catch(() => void 0), new d();
+		let r = new p(t, n, this);
+		return this.current = r, r;
+	}
+	segmentClosed(e) {
+		this.current === e && (this.current = null), e.state === "closed" && this.awaiting.push({
+			id: e.id,
+			durationSec: e.pushedSec
+		});
+	}
+	segmentDiscarded(e) {
+		this.current === e && (this.current = null);
+		let t = this.awaiting.findIndex((t) => t.id === e.id);
+		t >= 0 && this.awaiting.splice(t, 1);
+	}
+	endAllSegments() {
+		this.current &&= (this.current.end(), null), this.awaiting.length = 0;
+	}
+	handleStarted(e) {
+		if (e !== this.options.avatarIdentity) throw this.emit({
+			type: "error",
+			message: "lk.playback_started from an unexpected participant"
+		}), new s("unexpected caller");
+		return this.current === null && this.awaiting.length === 0 ? (this.emit({ type: "unmatchedStarted" }), "ok") : (this.emit({ type: "playbackStarted" }), "ok");
+	}
+	handleFinished(e, t) {
+		if (e !== this.options.avatarIdentity) throw this.emit({
+			type: "error",
+			message: "lk.playback_finished from an unexpected participant"
+		}), new s("unexpected caller");
+		let n = o(t);
+		n || this.emit({
+			type: "error",
+			message: "lk.playback_finished payload was not the documented shape"
+		});
+		let r = n ? n.positionSec : null, i = n ? n.interrupted : null;
+		if (this.owedFinishes > 0) return --this.owedFinishes, this.emit({
+			type: "owedFinished",
+			positionSec: r,
+			interrupted: i
+		}), "ok";
+		if (this.strayFinishDeadline !== null) {
+			if (this.options.scheduler.now() > this.strayFinishDeadline) this.strayFinishDeadline = null, this.strayAnswers = 0;
+			else if (i === !0 && this.clearSettle === null && this.strayAnswers > 0) return --this.strayAnswers, this.emit({ type: "unmatchedFinished" }), "ok";
+		}
+		return this.clearSettle ? (this.clearSettle(r, i, !1), "ok") : this.awaiting.length > 0 ? (this.awaiting.shift(), this.emit({
+			type: "playbackFinished",
+			positionSec: r,
+			interrupted: i,
+			synthetic: !1
+		}), "ok") : this.current ? (this.current.end(), this.current = null, this.emit({
+			type: "playbackFinished",
+			positionSec: r,
+			interrupted: i,
+			synthetic: !1
+		}), "ok") : (this.emit({ type: "unmatchedFinished" }), "ok");
+	}
+	clearBuffer(e = {}) {
+		if (this.clearInFlight) return this.clearInFlight;
+		if (this.state !== "ready") return Promise.resolve({
+			positionSec: null,
+			synthetic: !0,
+			rpc: "none"
+		});
+		let n = this.current !== null || this.awaiting.length > 0, r = this.current ? this.current.pushedSec : this.awaiting.reduce((e, t) => e + t.durationSec, 0);
+		if (this.endAllSegments(), !n) return Promise.resolve({
+			positionSec: null,
+			synthetic: !0,
+			rpc: "none"
+		});
+		let { scheduler: i } = this.options, a = this.options.clearTimeoutMs ?? 2e3, o = e.finishOverdue === !0, s = this.avatarPresent ? this.avatarDepartures : null;
+		return this.clearInFlight = new Promise((e) => {
+			let n = null, c = null, l = !1, u = () => {
+				l || n === null || c === null || (l = !0, p(), s === this.avatarDepartures && this.expectLateAnswer(n.synthetic, c, o, a), e({
+					...n,
+					rpc: c
+				}));
+			}, d = (e, t, r) => {
+				n === null && (n = {
+					positionSec: e,
+					synthetic: r
+				}, this.clearSettle = null, this.emit({
+					type: "playbackFinished",
+					positionSec: e,
+					interrupted: t,
+					synthetic: r
+				}), u());
+			}, p = i.setTimeout(() => {
+				d(r, !0, !0), c === null && (c = "timeout"), u();
+			}, a);
+			this.clearSettle = d, this.options.room.performRpc(this.options.avatarIdentity, t, "", a).then((e) => {
+				c === null && (c = e.trim().toLowerCase() === "reject" ? "rejected" : "ok"), c === "rejected" && d(r, !0, !0), u();
+			}, (e) => {
+				c === null && (c = f(e)), this.emit({
+					type: "error",
+					message: `lk.clear_buffer failed: ${e instanceof Error ? e.name : "error"}`
+				}), d(r, !0, !0), u();
+			});
+		}).finally(() => {
+			this.clearInFlight = null;
+		}), this.clearInFlight;
+	}
+	async dispose() {
+		this.disposed || (this.disposed = !0, this.rejectReady?.(new d()), this.wakeProbe?.(), this.endAllSegments(), await this.teardown());
+	}
+	async teardown() {
+		for (let e of this.unsubscribes.splice(0)) e();
+		this.options.room.unregisterRpc(n), this.options.room.unregisterRpc(r), this.state !== "closed" && (this.state = "closed", await this.options.room.disconnect().catch(() => void 0));
+	}
+};
+//#endregion
+export { c as AvatarNotReadyError, l as AvatarSegmentBusyError, u as AvatarSegmentEndedError, d as AvatarTransportClosedError, m as LiveKitAvatarTransport };

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

@@ -0,0 +1,17 @@
+import { AvatarOutputPort } from './avatarReplyOutputs';
+import { LiveKitAvatarTransport } from './avatarTransport';
+import { AvatarUnsubscribe } from './avatarPorts';
+export interface AvatarTransportPortDeps {
+    readonly transport: LiveKitAvatarTransport;
+    /** The user's "Avatar" toggle. The port is active only while this is true AND the transport is ready. */
+    readonly isEnabled: () => boolean;
+    /**
+     * Provisional audibility from a meter on the avatar's received audio, changes only; optional. Whoever replaces or stops a meter whose last
+     * reading was audible reports false: that track can no longer be heard, and a stale "audible" would hold every drain to its bound and
+     * make the next reply's tracker ignore the meter (no meter start, and no no-start, so neither the retry nor the voice fallback).
+     */
+    readonly subscribeMeter?: (handler: (audible: boolean) => void) => AvatarUnsubscribe;
+    /** Whether that meter can really hear right now (AvatarMeterHandle.isRunning). Without it the meter is treated as unable to prove silence. */
+    readonly isMeterHealthy?: () => boolean;
+}
+export declare function createAvatarTransportPort(deps: AvatarTransportPortDeps): AvatarOutputPort;

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

@@ -0,0 +1,27 @@
+//#region src/shared/assistant/avatar/live/avatarTransportPort.ts
+function e(e) {
+	let t = !1;
+	return e.subscribeMeter?.((e) => {
+		t = e;
+	}), {
+		isActive: () => e.isEnabled() && e.transport.transportState === "ready",
+		isAudioBlocked: () => e.transport.audioBlocked,
+		connectionId: () => e.transport.instanceId,
+		isMeterHealthy: () => e.subscribeMeter !== void 0 && e.isMeterHealthy !== void 0 ? e.isMeterHealthy() : !1,
+		isMeterAudible: () => t,
+		openSegment: () => e.transport.openSegment(),
+		clearBuffer: (t) => e.transport.clearBuffer(t),
+		setOutputMuted: (t) => e.transport.setOutputMuted(t),
+		subscribe(t) {
+			let n = [e.transport.subscribe(t)];
+			return e.subscribeMeter && n.push(e.subscribeMeter((e) => t({
+				type: "meter",
+				audible: e
+			}))), () => {
+				for (let e of n) e();
+			};
+		}
+	};
+}
+//#endregion
+export { e as createAvatarTransportPort };

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

@@ -0,0 +1,44 @@
+import { ComponentType } from 'react';
+import { SpeechEngine } from '../../speech/types';
+import { AssistantLiveAvatarSeam, LiveAvatarEnabledStore, LiveAvatarStageProps } from '../../ui/assistantLiveAvatarSeam';
+import { AvatarRoom, AvatarScheduler } from './avatarPorts';
+import { AvatarSessionClient } from './avatarSessionClient';
+import { LiveAvatarController, LiveAvatarControllerDeps, LiveAvatarLogEvent, LiveAvatarPreferences } from './liveAvatarController';
+export interface LiveAvatarSeamOptions {
+    /** Display names for the avatar ids the server offers (it sends ids only); without one the chooser numbers them. */
+    readonly avatarNames?: Readonly<Record<string, string>>;
+    readonly onLog?: (event: LiveAvatarLogEvent) => void;
+    /** Overrides, for tests and for hosts with their own plumbing. Each defaults to the assistant's own. */
+    readonly client?: () => AvatarSessionClient | null;
+    readonly openRoom?: () => Promise<AvatarRoom>;
+    readonly preferences?: LiveAvatarPreferences;
+    readonly scheduler?: AvatarScheduler;
+    readonly browserSupported?: () => boolean;
+    readonly controller?: Partial<Pick<LiveAvatarControllerDeps, 'createAudioElement' | 'releaseAudioElement' | 'startMeter' | 'decode' | 'now' | 'newIdempotencyKey' | 'subscribeWorkspaceChange' | 'subscribePageHide' | 'idleMs' | 'endBeforeDeadlineMs' | 'connectTimeoutMs' | 'trackerConfig' | 'maxDrainMs' | 'stallMs' | 'readinessProbe'>>;
+}
+/** The seam, plus what a host or a test may need of it. */
+export interface LiveAvatarSeamHandle extends AssistantLiveAvatarSeam {
+    readonly decorateSpeechEngine: (base: SpeechEngine) => SpeechEngine;
+    readonly Stage: ComponentType<LiveAvatarStageProps>;
+    readonly enabled: LiveAvatarEnabledStore;
+    readonly controller: LiveAvatarController;
+    /** Ends any session and stops listening. The handle is unusable afterwards. */
+    dispose(): void;
+}
+/**
+ * Whether this browser may show the avatar. Desktop Chrome first (GATE1B §10: no other browser or phone is offered until it is tested,
+ * Chromium builds included, other Chromium-based browsers not), with the platform pieces the avatar needs: WebRTC, Web Audio (the level
+ * meter and the MP3 decode) and MediaStream.
+ */
+export declare function isLiveAvatarBrowserSupported(scope?: typeof globalThis): boolean;
+/** The `Authorization` the hosted TTS requests carry (the host's `getHeaders`), else the stored access token. Nothing else is read. */
+export declare function liveAvatarAuthorization(): string | null;
+/**
+ * The workspace token, as the assistant's own calls mint it (`ensureWorkspaceToken`, the workspace gateway): the stored one while it is
+ * valid for the active context (workspace, organisation, project), else a new one. Null when there is no active workspace or no sign-in.
+ * A retry after a 401 (`fresh`) asks again the same way: the client can see a token's expiry and context, not a revocation.
+ */
+export declare function liveAvatarWorkspaceAuthorization(_options: {
+    readonly fresh: boolean;
+}): Promise<string | null>;
+export declare function createLiveAvatarSeam(options?: LiveAvatarSeamOptions): LiveAvatarSeamHandle;

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

@@ -0,0 +1,124 @@
+import { ensureWorkspaceToken as e, getStoredAuthToken as t, getStoredWorkspaceId as n, resolveGatewayUrl as r } from "../../../graphql/fetch.js";
+import { readSpeechEngineConfig as i } from "../../speech/createSpeechEngine.js";
+import { useAvatarPreferencesStore as a } from "../avatarPreferences.js";
+import { realAvatarScheduler as o } from "./avatarPorts.js";
+import { startAvatarAudioMeter as s } from "./avatarAudioMeter.js";
+import { decodeMp3ToPcm16k as c } from "./avatarAudioDecode.js";
+import { avatarApiBaseFromTtsEndpoint as l, avatarIdempotencyKey as u, createAvatarSessionClient as d } from "./avatarSessionClient.js";
+import { createLiveAvatarController as f } from "./liveAvatarController.js";
+import { openLiveKitAvatarRoom as p } from "./liveKitAvatarRoom.js";
+import { LiveAvatarStageView as m } from "./LiveAvatarStage.js";
+import { jsx as h } from "react/jsx-runtime";
+//#region src/shared/assistant/avatar/live/createLiveAvatarSeam.tsx
+function g(e = globalThis) {
+	let t = e;
+	if (typeof t.RTCPeerConnection != "function" || typeof t.OfflineAudioContext != "function" || typeof t.AudioContext != "function" || typeof t.MediaStream != "function") return !1;
+	let n = t.navigator, r = n?.userAgentData;
+	if (r?.brands !== void 0) {
+		let e = r.brands.map((e) => e.brand);
+		return r.mobile === !1 && e.some((e) => e === "Google Chrome" || e === "Chromium") && !e.some((e) => /Edge|Opera|Brave|Vivaldi|Samsung/i.test(e));
+	}
+	let i = n?.userAgent ?? "";
+	return /\b(?:Chrome|Chromium)\//.test(i) && !/\b(?:Edg|OPR|SamsungBrowser)\/|Mobile|Android|iPhone|iPad/.test(i);
+}
+function _() {
+	let e = i().getHeaders?.() ?? {};
+	for (let [t, n] of Object.entries(e)) if (t.toLowerCase() === "authorization" && typeof n == "string" && n.trim() !== "") return n.trim();
+	let n = t();
+	return n ? `Bearer ${n}` : null;
+}
+async function v(t) {
+	let i = n(), a = _()?.replace(/^Bearer\s+/i, "") ?? null;
+	if (!i || !a) return null;
+	let o = await e({
+		url: r("workspace"),
+		authToken: a,
+		workspaceId: i,
+		currentQuery: "liveAvatarSession"
+	});
+	return o ? `Bearer ${o}` : null;
+}
+function y() {
+	let e = null;
+	return () => {
+		let t = typeof location > "u" ? void 0 : location.href, n = l(i().endpoint, t);
+		return n === null ? null : (e?.base !== n && (e = {
+			base: n,
+			client: d({
+				baseUrl: n,
+				getAuthorization: _,
+				getWorkspaceAuthorization: v
+			})
+		}), e.client);
+	};
+}
+var b = {
+	getState: () => a.getState(),
+	setAvatarEnabled: (e) => a.getState().setAvatarEnabled(e),
+	setAvatarId: (e) => a.getState().setAvatarId(e),
+	subscribe: (e) => a.subscribe(() => e())
+};
+function x() {
+	if (typeof document > "u") return null;
+	let e = document.createElement("audio");
+	return e.autoplay = !0, e.hidden = !0, e.setAttribute("data-testid", "assistant-live-avatar-audio"), document.body.appendChild(e), e;
+}
+function S(e) {
+	if (!(typeof window > "u")) return (t) => (window.addEventListener(e, t), () => window.removeEventListener(e, t));
+}
+function C(e = {}) {
+	let t = e.preferences ?? b, n = e.controller ?? {}, r = n.subscribeWorkspaceChange ?? S("burdenoff:workspace-changed"), i = n.subscribePageHide ?? S("pagehide"), a = f({
+		client: e.client ?? y(),
+		openRoom: e.openRoom ?? p,
+		scheduler: e.scheduler ?? o,
+		preferences: t,
+		decode: n.decode ?? ((e, t) => c(e, { signal: t })),
+		createAudioElement: n.createAudioElement ?? x,
+		releaseAudioElement: n.releaseAudioElement ?? ((e) => {
+			e.srcObject = null, e.remove();
+		}),
+		startMeter: n.startMeter ?? ((e, t) => typeof MediaStream > "u" ? null : s(new MediaStream([e]), t)),
+		browserSupported: e.browserSupported ?? (() => g()),
+		now: n.now ?? (() => Date.now()),
+		newIdempotencyKey: n.newIdempotencyKey ?? (() => u()),
+		...r ? { subscribeWorkspaceChange: r } : {},
+		...i ? { subscribePageHide: i } : {},
+		...n.idleMs === void 0 ? {} : { idleMs: n.idleMs },
+		...n.endBeforeDeadlineMs === void 0 ? {} : { endBeforeDeadlineMs: n.endBeforeDeadlineMs },
+		...n.connectTimeoutMs === void 0 ? {} : { connectTimeoutMs: n.connectTimeoutMs },
+		...n.trackerConfig === void 0 ? {} : { trackerConfig: n.trackerConfig },
+		...n.maxDrainMs === void 0 ? {} : { maxDrainMs: n.maxDrainMs },
+		...n.stallMs === void 0 ? {} : { stallMs: n.stallMs },
+		...n.readinessProbe === void 0 ? {} : { readinessProbe: n.readinessProbe },
+		...e.onLog ? { onLog: e.onLog } : {}
+	});
+	return {
+		decorateSpeechEngine: (e) => ({
+			id: e.id,
+			isSupported: () => e.isSupported(),
+			listVoices: () => e.listVoices(),
+			subscribeVoices: (t) => e.subscribeVoices(t),
+			speak: (t, n, r) => e.speak(t, a.route(n, e) === "avatar" ? {
+				...n,
+				audioOutput: a.createOutput()
+			} : n, r),
+			cancel: () => e.cancel()
+		}),
+		Stage: ({ expanded: t, fallback: n }) => /* @__PURE__ */ h(m, {
+			controller: a,
+			expanded: t,
+			fallback: n,
+			...e.avatarNames ? { avatarNames: e.avatarNames } : {}
+		}),
+		enabled: {
+			subscribe: (e) => t.subscribe(e),
+			getSnapshot: () => t.getState().avatarEnabled,
+			switchOff: () => a.switchOff(),
+			voiceLive: (e) => a.setVoiceLive(e)
+		},
+		controller: a,
+		dispose: () => a.dispose()
+	};
+}
+//#endregion
+export { C as createLiveAvatarSeam, g as isLiveAvatarBrowserSupported, _ as liveAvatarAuthorization, v as liveAvatarWorkspaceAuthorization };