@burdenoff/fe-libs 2026.1013.13 → 2026.1013.14

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

@@ -0,0 +1,86 @@
+import { AvatarRpcRejectedError as e } from "./avatarPorts.js";
+//#region src/shared/assistant/avatar/live/liveKitAvatarRoom.ts
+async function t() {
+	let t = await import("livekit-client"), n = new t.Room({
+		adaptiveStream: !0,
+		dynacast: !1,
+		disconnectOnPageLeave: !0
+	}), r = (e, t) => (n.on(e, t), () => {
+		n.off(e, t);
+	}), i = (e, n) => ({
+		identity: n,
+		kind: e.kind === t.Track.Kind.Video ? "video" : "audio",
+		attach: (t) => {
+			e.attach(t);
+		},
+		detach: () => {
+			e.detach();
+		},
+		mediaStreamTrack: e.mediaStreamTrack ?? null
+	});
+	return {
+		async connect(e, t) {
+			await n.connect(e, t);
+		},
+		async disconnect() {
+			await n.disconnect();
+		},
+		isConnected: () => n.state === t.ConnectionState.Connected,
+		hasParticipant: (e) => n.remoteParticipants.has(e),
+		hasVideoTrack: (e) => {
+			let t = n.remoteParticipants.get(e);
+			if (!t) return !1;
+			for (let e of t.videoTrackPublications.values()) if (e.isSubscribed) return !0;
+			return !1;
+		},
+		onParticipantConnected: (e) => r(t.RoomEvent.ParticipantConnected, (t) => e(t.identity)),
+		onParticipantDisconnected: (e) => r(t.RoomEvent.ParticipantDisconnected, (t) => e(t.identity)),
+		onTrackSubscribed: (e) => r(t.RoomEvent.TrackSubscribed, (t, n, r) => e(i(t, r.identity))),
+		onDisconnected: (e) => r(t.RoomEvent.Disconnected, () => e()),
+		onReconnecting: (e) => r(t.RoomEvent.Reconnecting, () => e()),
+		onReconnected: (e) => r(t.RoomEvent.Reconnected, () => e()),
+		onAudioPlaybackChanged: (e) => r(t.RoomEvent.AudioPlaybackStatusChanged, (t) => e(t)),
+		registerRpc(r, i) {
+			try {
+				n.unregisterRpcMethod(r);
+			} catch {}
+			n.registerRpcMethod(r, async (n) => {
+				try {
+					return i(n.callerIdentity, n.payload);
+				} catch (n) {
+					throw n instanceof e ? new t.RpcError(t.RpcError.ErrorCode.APPLICATION_ERROR, "rejected") : n;
+				}
+			});
+		},
+		unregisterRpc(e) {
+			try {
+				n.unregisterRpcMethod(e);
+			} catch {}
+		},
+		performRpc: (e, t, r, i) => n.localParticipant.performRpc({
+			destinationIdentity: e,
+			method: t,
+			payload: r,
+			responseTimeout: i
+		}),
+		async openByteStream({ topic: e, name: t, destinationIdentity: r, attributes: i }) {
+			let a = await n.localParticipant.streamBytes({
+				name: t,
+				topic: e,
+				attributes: i,
+				destinationIdentities: [r],
+				mimeType: "audio/pcm"
+			});
+			return {
+				write: (e) => a.write(e),
+				close: () => a.close()
+			};
+		},
+		async startAudio() {
+			await n.startAudio();
+		},
+		canPlaybackAudio: () => n.canPlaybackAudio
+	};
+}
+//#endregion
+export { t as openLiveKitAvatarRoom };

package/dist/shared/assistant/avatar/useAvatarCopy.d.ts

@@ -32,6 +32,8 @@ export interface AvatarCopy {
     stateEnding: string;
     stateInterrupted: string;
     stateVoiceOnly: string;
+    /** The session reached its time limit and ended between replies (BOFF-8822 P8); the voice goes on. */
+    stateTimeLimit: string;
     stageLabel: string;
     stageWaiting: string;
     chooserTitle: string;

package/dist/shared/assistant/avatar/useAvatarCopy.js

@@ -17,6 +17,7 @@ function n() {
 		stateEnding: n("avatar.stateEnding", "Stopping the avatar…"),
 		stateInterrupted: n("avatar.stateInterrupted", "The avatar was interrupted. You can keep talking."),
 		stateVoiceOnly: n("avatar.stateVoiceOnly", "The avatar is unavailable right now. Continuing with voice only."),
+		stateTimeLimit: n("avatar.stateTimeLimit", "The avatar reached its time limit. Continuing with voice only."),
 		stageLabel: n("avatar.stageLabel", "Live avatar"),
 		stageWaiting: n("avatar.stageWaiting", "Waiting for the avatar…"),
 		chooserTitle: n("avatar.chooserTitle", "Choose an avatar"),

package/dist/shared/assistant/i18nManifest.d.ts

@@ -246,6 +246,7 @@ export declare const ASSISTANT_I18N_LITERAL_COPY: {
     readonly "avatar.stateOn": "Avatar on";
     readonly "avatar.stateReady": "Avatar ready";
     readonly "avatar.stateStarting": "Starting the avatar…";
+    readonly "avatar.stateTimeLimit": "The avatar reached its time limit. Continuing with voice only.";
     readonly "avatar.stateVoiceOnly": "The avatar is unavailable right now. Continuing with voice only.";
     readonly "avatar.stop": "Turn off the avatar";
     readonly "avatar.toggle": "Live avatar";

package/dist/shared/assistant/i18nManifest.js

@@ -140,6 +140,7 @@ var m = {
 	"avatar.stateOn": "Avatar on",
 	"avatar.stateReady": "Avatar ready",
 	"avatar.stateStarting": "Starting the avatar…",
+	"avatar.stateTimeLimit": "The avatar reached its time limit. Continuing with voice only.",
 	"avatar.stateVoiceOnly": "The avatar is unavailable right now. Continuing with voice only.",
 	"avatar.stop": "Turn off the avatar",
 	"avatar.toggle": "Live avatar",

package/dist/shared/assistant/index.d.ts

@@ -313,3 +313,20 @@ export * from './workflowApi';
 export * from './ui/WorkflowAssistantPanel';
 export * from './speech/notifyCancellationSpeechEngine';
 export * from './avatar/avatarPreferences';
+export * from './avatar/live/avatarProtocol';
+export * from './avatar/live/avatarPorts';
+export * from './avatar/live/avatarTransport';
+export * from './avatar/live/avatarPlaybackTracker';
+export * from './avatar/live/avatarAudioMeter';
+export * from './avatar/live/avatarAudioErrors';
+export * from './avatar/live/avatarMp3Inspect';
+export * from './avatar/live/avatarPcm16';
+export * from './avatar/live/avatarAudioDecode';
+export * from './avatar/live/avatarTransportPort';
+export * from './avatar/live/avatarReplyOutputs';
+export * from './avatar/live/avatarSessionClient';
+export * from './avatar/live/liveAvatarController';
+export * from './avatar/live/liveKitAvatarRoom';
+export * from './avatar/live/LiveAvatarStage';
+export * from './avatar/live/liveAvatarStatus';
+export * from './avatar/live/createLiveAvatarSeam';

package/dist/shared/assistant/speech/hostedTtsSpeechEngine.d.ts

@@ -7,6 +7,11 @@ export interface HostedTtsOptions {
     fetchImpl?: typeof fetch;
     /** Test seam: the clock the disable window is measured against. */
     now?: () => number;
+    /**
+     * Test seam: the timer behind the audio output's no-progress watchdog
+     * (`hostedOutputStallMs`, BOFF-8822). Returns a function that cancels it.
+     */
+    setTimer?: (callback: () => void, ms: number) => () => void;
 }
 /**
  * The hosted engine, plus the one hook its owner needs beyond `SpeechEngine`.
@@ -23,4 +28,36 @@ export interface HostedSpeechEngine extends SpeechEngine {
 }
 /** `Retry-After` in seconds when the server sent a usable one, else backoff. */
 export declare function retryDelayMs(retryAfter: string | null, attempt: number): number;
+/**
+ * ★★ The backstop for an audio output that stops making progress (BOFF-8822,
+ * the voice owners' P1b note a, 2026-10-13).
+ *
+ * `speak()` waits for its output's `write()` and `drain()` before it fetches
+ * more or ends the reply, and the output contract says both settle in bounded
+ * time (`SpeechAudioOutput`). One that never did (a contract bug in an output)
+ * would leave the reply "speaking", and the voice conversation with it, until
+ * the user pressed Stop. So while the engine waits on its output, a watchdog
+ * runs, and every sign of progress starts it again: a piece beginning, on the
+ * output or replayed on the speakers, and every write or drain settling.
+ *
+ * ★ Not a fixed timeout. A write may resolve only when its piece BEGINS, so it
+ * can wait for every earlier piece to play out, and a drain waits for all the
+ * audio held: a fixed cap would end long, healthy replies. The window grows with
+ * the audio handed over, bounded from above by its bytes at the lowest MP3
+ * bitrate (8 kbit/s; the proxy sends 32), so it is never shorter than twice that
+ * audio plus a minute. The output's own bounds (the live avatar's start, stall
+ * and finish deadlines: its start allowance, 1.25 times the reply's audio and a
+ * few seconds of slack) run out well inside it, so the output always decides
+ * first, and this only catches an output that never does.
+ *
+ * On expiry the output and the speakers are silenced BEFORE the reply ends with
+ * `onError('unknown')`, which latches nothing; the output is not drained again.
+ */
+export declare const HOSTED_OUTPUT_STALL_BASE_MS = 60000;
+/** How many times the audio handed over the window adds on top of the base. */
+export declare const HOSTED_OUTPUT_STALL_AUDIO_RATIO = 2;
+/** 8 kbit/s, the lowest MP3 bitrate: bytes over this are at least the audio's seconds. */
+export declare const HOSTED_OUTPUT_MIN_AUDIO_BYTES_PER_SECOND = 1000;
+/** The watchdog's window once `bytesHanded` bytes of audio went to the output. */
+export declare function hostedOutputStallMs(bytesHanded: number): number;
 export declare function createHostedTtsEngine(options: HostedTtsOptions): HostedSpeechEngine;

package/dist/shared/assistant/speech/hostedTtsSpeechEngine.js

@@ -18,7 +18,53 @@ function _(e, t) {
 	let n = e === null ? NaN : Number(e);
 	return Math.min(Number.isFinite(n) && n >= 0 ? n * 1e3 : h * 2 ** (t - 1), g);
 }
-function v(e, t) {
+var v = 6e4, y = 2, b = 1e3;
+function x(e) {
+	return v + e / b * 2 * 1e3;
+}
+var S = class extends Error {
+	reason = "unknown";
+	constructor() {
+		super("audio output made no progress"), this.name = "OutputStalledError";
+	}
+};
+function C(e) {
+	let t = 0, n = !1, r = null, i = () => {
+		let n = r;
+		n !== null && (n.cancel(), n.cancel = e(() => {
+			r === n && (r = null, n.fail(new S()));
+		}, x(t)));
+	};
+	return {
+		handed(e) {
+			t += e;
+		},
+		progress: i,
+		guard(e) {
+			return n ? e : new Promise((t, n) => {
+				let a = {
+					fail: n,
+					cancel: () => void 0
+				};
+				r = a, i();
+				let o = () => {
+					r === a && (r = null, a.cancel());
+				};
+				e.then((e) => {
+					o(), t(e);
+				}, (e) => {
+					o(), n(e);
+				});
+			});
+		},
+		stop() {
+			n = !0;
+			let e = r;
+			r = null, e?.cancel();
+		}
+	};
+}
+function w(e, t) {
 	return new Promise((n) => {
 		if (t.aborted) {
 			n();
@@ -33,32 +79,35 @@ function v(e, t) {
 		t.addEventListener("abort", i, { once: !0 });
 	});
 }
-function y(h) {
-	let g = h.fetchImpl ?? ((...e) => fetch(...e)), y = h.now ?? (() => Date.now()), b = null, x = null, S = 0, C = null, w = null, T = 0, E = null, D = null, O = () => {
+function T(h) {
+	let g = h.fetchImpl ?? ((...e) => fetch(...e)), v = h.now ?? (() => Date.now()), y = h.setTimer ?? ((e, t) => {
+		let n = setTimeout(e, t);
+		return () => clearTimeout(n);
+	}), b = null, x = null, T = 0, E = null, D = null, O = null, k = 0, A = null, j = null, M = () => {
 		try {
 			return h.getHeaders?.() ?? {};
 		} catch {
 			return {};
 		}
-	}, k = () => y() >= T ? !1 : D === null ? !0 : f(O()) === D, A = /* @__PURE__ */ new Set(), j = () => {
-		for (let e of [...A]) e();
-	}, M = () => {
-		E !== null && clearTimeout(E), E = null;
-	}, N = (e) => {
-		M(), E = setTimeout(() => {
-			E = null;
-			let e = T - y();
+	}, N = () => v() >= k ? !1 : j === null ? !0 : f(M()) === j, P = /* @__PURE__ */ new Set(), F = () => {
+		for (let e of [...P]) e();
+	}, I = () => {
+		A !== null && clearTimeout(A), A = null;
+	}, L = (e) => {
+		I(), A = setTimeout(() => {
+			A = null;
+			let e = k - v();
 			if (e > 0) {
-				N(e);
+				L(e);
 				return;
 			}
-			j();
+			F();
 		}, e);
-	}, P = (e, t) => {
-		T = y() + e, D = t, N(e), j();
-	}, F = () => {
+	}, R = (e, t) => {
+		k = v() + e, j = t, L(e), F();
+	}, z = () => {
 		x &&= (URL.revokeObjectURL(x), null);
-	}, I = () => {
+	}, B = () => {
 		if (b) {
 			b.onended = null, b.onerror = null;
 			try {
@@ -66,9 +115,9 @@ function y(h) {
 			} catch {}
 			b = null;
 		}
-		F();
+		z();
 	};
-	async function L(e, n, s) {
+	async function V(e, n, s) {
 		let c = i(e, r(n.lang) ?? n.lang, t, n.voice?.name ?? null, n.rate), l = h.getHeaders?.() ?? {}, u;
 		for (let e = 1; u = await g(h.endpoint, {
 			method: "POST",
@@ -83,37 +132,37 @@ function y(h) {
 				let e = /* @__PURE__ */ Error(`hosted tts ${u.status}`);
 				throw e.reason = a(u.status), e.headers = f(l), e;
 			}
-			await v(_(u.headers.get("retry-after"), e), s);
+			await w(_(u.headers.get("retry-after"), e), s);
 		}
-		let d = u.headers.get("content-type"), y = o(d, d?.includes("json") ? await u.json() : await u.arrayBuffer());
-		if (!y) {
+		let d = u.headers.get("content-type"), v = o(d, d?.includes("json") ? await u.json() : await u.arrayBuffer());
+		if (!v) {
 			let e = /* @__PURE__ */ Error("hosted tts returned no audio");
 			throw e.reason = "unknown", e;
 		}
-		return y;
+		return v;
 	}
-	function R(t, n, r) {
+	function H(t, n, r) {
 		return new Promise((i, a) => {
-			if (n !== S) {
+			if (n !== T) {
 				i();
 				return;
 			}
 			let o = new Blob([t.slice().buffer], { type: "audio/mpeg" });
-			F(), x = URL.createObjectURL(o);
+			z(), x = URL.createObjectURL(o);
 			let s = new Audio(x);
 			e(s), b = s, s.onended = () => {
-				n === S && i();
+				n === T && i();
 			}, s.onerror = () => {
-				if (n !== S) {
+				if (n !== T) {
 					i();
 					return;
 				}
 				let e = /* @__PURE__ */ Error("audio playback failed");
 				e.reason = "unknown", a(e);
 			}, s.play().then(() => {
-				n === S && r?.();
+				n === T && r?.();
 			}, (e) => {
-				if (n !== S) {
+				if (n !== T) {
 					i();
 					return;
 				}
@@ -125,14 +174,14 @@ function y(h) {
 	return {
 		id: "hosted-tts",
 		isSupported() {
-			return k() ? !1 : typeof window < "u" && typeof window.Audio == "function" && typeof fetch == "function";
+			return N() ? !1 : typeof window < "u" && typeof window.Audio == "function" && typeof fetch == "function";
 		},
 		listVoices() {
-			return k() ? [] : [...n];
+			return N() ? [] : [...n];
 		},
 		subscribeVoices(e) {
-			return A.add(e), () => {
-				A.delete(e);
+			return P.add(e), () => {
+				P.delete(e);
 			};
 		},
 		speak(e, t, n = {}) {
@@ -141,66 +190,72 @@ function y(h) {
 				n.onEnd?.();
 				return;
 			}
-			S += 1;
-			let i = S;
-			I(), w?.cancel();
+			T += 1;
+			let i = T;
+			B(), D?.cancel(), O?.stop();
 			let a = new AbortController();
-			C = a;
+			E = a;
 			let o = !1, f = () => {
 				o || (o = !0, n.onStart?.());
 			}, p = (e) => {
-				let n = L(e, t, a.signal);
+				let n = V(e, t, a.signal);
 				return n.catch(() => {}), n;
-			}, m = t.audioOutput ? u(t.audioOutput, {
-				play: (e) => R(e, i, f),
-				isCurrent: () => i === S,
-				onChunkStart: (e) => n.onChunkStart?.(e),
+			}, m = t.audioOutput ? C(y) : null, h = t.audioOutput ? u(t.audioOutput, {
+				play: (e) => H(e, i, f),
+				isCurrent: () => i === T,
+				onChunkStart: (e) => {
+					m?.progress(), n.onChunkStart?.(e);
+				},
 				onStart: f
 			}) : null;
-			w = m, (async () => {
+			D = h, O = m;
+			let g = (e) => m ? m.guard(e) : e, _ = () => {
+				h && (m?.stop(), O === m && (O = null), D === h && (D = null));
+			};
+			(async () => {
 				try {
 					let e = p(r[0]);
 					for (let t = 0; t < r.length; t += 1) {
-						if (i !== S) return;
+						if (i !== T) return;
 						let a = await e;
-						if (i !== S) return;
+						if (i !== T) return;
 						let o = r[t + 1];
-						if (o !== void 0 && (e = p(o)), m) {
-							await m.write(a);
+						if (o !== void 0 && (e = p(o)), h) {
+							m?.handed(a.byteLength), await g(h.write(a));
 							continue;
 						}
-						n.onChunkStart?.(t), await R(a, i, f);
+						n.onChunkStart?.(t), await H(a, i, f);
 					}
-					if (m) {
-						let e = await m.drain();
-						if (i !== S) return;
+					if (h) {
+						let e = await g(h.drain());
+						if (i !== T) return;
 						if (!e) throw Object.assign(/* @__PURE__ */ Error("audio output did not finish"), { reason: "unknown" });
 					}
-					i === S && n.onEnd?.();
+					i === T && (_(), n.onEnd?.());
 				} catch (e) {
-					if (a.abort(), i !== S) return;
+					if (a.abort(), i !== T) return;
 					let t = null;
-					if (m) {
-						let n = await m.drain().then(() => null, (e) => e);
-						if (i !== S) return;
-						m.cancel(), d(e) ? t = e : d(n) && (t = n);
+					if (h) {
+						let n = e instanceof S ? null : await g(h.drain()).then(() => null, (e) => e);
+						if (i !== T) return;
+						h.cancel(), d(e) ? t = e : d(n) && (t = n);
 					}
-					if (S += 1, I(), t) {
+					if (T += 1, B(), _(), t) {
 						n.onError?.("output-not-cleared");
 						return;
 					}
 					let r = e?.reason;
-					c(r, e?.transient === !0) && P(s(r), r === "not-allowed" ? e.headers ?? null : null), n.onError?.(r === "not-allowed" || r === "unsupported" || r === "cancelled" ? r : "unknown");
+					c(r, e?.transient === !0) && R(s(r), r === "not-allowed" ? e.headers ?? null : null), n.onError?.(r === "not-allowed" || r === "unsupported" || r === "cancelled" ? r : "unknown");
 				}
 			})();
 		},
 		headersChanged() {
-			y() >= T || D === null || k() || (T = 0, D = null, M(), j());
+			v() >= k || j === null || N() || (k = 0, j = null, I(), F());
 		},
 		cancel() {
-			S += 1, C?.abort(), C = null, I(), w?.cancel(), w = null;
+			T += 1, E?.abort(), E = null, B(), D?.cancel(), D = null, O?.stop(), O = null;
 		}
 	};
 }
 //#endregion
-export { y as createHostedTtsEngine, _ as retryDelayMs };
+export { b as HOSTED_OUTPUT_MIN_AUDIO_BYTES_PER_SECOND, y as HOSTED_OUTPUT_STALL_AUDIO_RATIO, v as HOSTED_OUTPUT_STALL_BASE_MS, T as createHostedTtsEngine, x as hostedOutputStallMs, _ as retryDelayMs };

package/dist/shared/assistant/speech/types.d.ts

@@ -61,6 +61,16 @@ export interface SpeechSpeakOptions {
  *
  * One object serves exactly one reply: attach a fresh one to each, so neither
  * a leave, a refusal nor the hard stop carries over to the next reply.
+ *
+ * ★★ `write()` and `drain()` MUST settle in bounded time. The engine waits for
+ * each one before it fetches more, falls back, or ends the reply, so a call that
+ * never settles would leave the reply "speaking" until the user pressed Stop.
+ * Each output bounds its own waits (the live avatar: its start, stall and finish
+ * deadlines); an output that cannot tell what happened settles as uncertain, by
+ * the rules above, rather than wait. The engine keeps only a backstop: when its
+ * output makes no progress for far longer than any such bound
+ * (`hostedOutputStallMs`), it silences the output and ends the reply with
+ * `onError('unknown')`, which latches nothing.
  */
 export interface SpeechAudioOutput {
     /**
@@ -74,7 +84,8 @@ export interface SpeechAudioOutput {
      * before rejecting, for any piece that MAY have been heard: the speakers
      * resume after the last piece that began, so nothing is heard twice. A piece
      * retracted before it began resolves its `write` without `began()`. Writing
-     * may go on after a `drain()`, until `cancel()` or the reply's end.
+     * may go on after a `drain()`, until `cancel()` or the reply's end. MUST
+     * settle in bounded time, whatever the output hears or does not hear.
      */
     write(bytes: Uint8Array, index: number, began: () => void): Promise<void>;
     /**
@@ -82,7 +93,8 @@ export interface SpeechAudioOutput {
      * `write` does. Callable more than once: a queue may drain when its speech
      * pauses and write again afterwards, even before that drain settles (a piece
      * written meanwhile is not part of it). The reply's last drain follows its
-     * end and its last write.
+     * end and its last write. MUST settle in bounded time: when the end cannot be
+     * confirmed, reject, rather than wait for a signal that may never come.
      */
     drain(): Promise<void>;
     /**