@burdenoff/fe-libs 2026.1013.13 → 2026.1013.14

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

@@ -0,0 +1,15 @@
+import { FC, ReactNode } from 'react';
+import { LiveAvatarController } from './liveAvatarController';
+export interface LiveAvatarStageViewProps {
+    readonly controller: LiveAvatarController;
+    /** Full-screen (true) or the in-panel stage (false). */
+    readonly expanded: boolean;
+    /** The waveform: what the stage shows while there is no avatar to show. */
+    readonly fallback: ReactNode;
+    /**
+     * Display names for avatar ids. The server sends ids only (names and pictures are the client's, BACKEND-DESIGN §3.3); without one the
+     * chooser numbers them.
+     */
+    readonly avatarNames?: Readonly<Record<string, string>>;
+}
+export declare const LiveAvatarStageView: FC<LiveAvatarStageViewProps>;

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

@@ -0,0 +1,139 @@
+import { useAvatarCopy as e } from "../useAvatarCopy.js";
+import { liveAvatarStatusText as t } from "./liveAvatarStatus.js";
+import { useCallback as n, useEffect as r, useId as i, useRef as a, useSyncExternalStore as o } from "react";
+import { Video as s, VideoOff as c, Volume2 as l } from "lucide-react";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+//#region src/shared/assistant/avatar/live/LiveAvatarStage.tsx
+var f = "inline-flex h-8 items-center gap-1.5 rounded-full border border-border-default bg-bg-elevated px-3 text-xs font-medium text-text-secondary transition-colors hover:bg-bg-raised hover:text-text-primary focus:outline-none focus-visible:ring-2 focus-visible:ring-border-strong aria-disabled:cursor-default aria-disabled:opacity-60", p = "inline-flex h-8 cursor-pointer items-center gap-1.5 rounded-full border px-3 text-xs font-medium transition-colors focus-within:ring-2 focus-within:ring-border-strong", m = "inline-flex h-8 items-center rounded-full bg-action-primary-bg px-3 text-xs font-medium text-action-primary-text transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-border-strong", h = ({ controller: h, expanded: g, fallback: _, avatarNames: v }) => {
+	let y = e(), b = i(), x = i(), S = a(null), C = a(null), w = n((e) => {
+		e?.focus();
+	}, []), T = n((e) => (C.current = e, () => {
+		C.current = null, document.activeElement === e && S.current?.focus();
+	}), []), E = o(h.subscribe, h.getSnapshot, h.getSnapshot);
+	r(() => (h.setStageMounted(!0), () => h.setStageMounted(!1)), [h]);
+	let { phase: D } = E, O = D === "starting" || D === "connecting" || D === "ready" || D === "ending", k = D === "checking" || D === "ending", A = t(E, y), j = (e, t) => v?.[e] ?? `${y.chooserLabel} ${t + 1}`;
+	return /* @__PURE__ */ d("div", {
+		ref: S,
+		tabIndex: -1,
+		className: "flex flex-col items-center gap-2 focus:outline-none",
+		"data-testid": "assistant-live-avatar",
+		children: [
+			O ? /* @__PURE__ */ d("div", {
+				className: `relative overflow-hidden rounded-2xl border border-border-subtle bg-bg-sunken ${g ? "size-64" : "size-40"}`,
+				"data-testid": "assistant-live-avatar-frame",
+				"data-phase": D,
+				children: [
+					/* @__PURE__ */ u("video", {
+						ref: h.attachVideo,
+						className: `size-full object-cover ${E.videoReady ? "" : "invisible"}`,
+						"aria-label": y.stageLabel,
+						autoPlay: !0,
+						muted: !0,
+						playsInline: !0,
+						"data-testid": "assistant-live-avatar-video"
+					}),
+					E.videoReady ? null : /* @__PURE__ */ u("p", {
+						className: "absolute inset-0 flex items-center justify-center p-3 text-center text-xs text-text-muted",
+						children: D === "ending" ? y.stateEnding : D === "connecting" ? y.stageWaiting : y.stateStarting
+					}),
+					E.audioBlocked ? /* @__PURE__ */ d("button", {
+						type: "button",
+						onClick: () => h.resumeAudio(),
+						className: "absolute inset-x-2 bottom-2 inline-flex items-center justify-center gap-1.5 rounded-xl bg-bg-elevated px-2 py-1.5 text-xs font-medium text-text-primary focus:outline-none focus-visible:ring-2 focus-visible:ring-border-strong",
+						"data-testid": "assistant-live-avatar-sound",
+						children: [/* @__PURE__ */ u(l, {
+							className: "size-4 shrink-0",
+							"aria-hidden": "true"
+						}), /* @__PURE__ */ u("span", { children: y.problem("playback-blocked") })]
+					}) : null
+				]
+			}) : _,
+			E.offered || O ? /* @__PURE__ */ d("button", {
+				ref: T,
+				type: "button",
+				onClick: () => {
+					k || (O ? h.switchOff() : D === "choosing" ? h.cancelChoice() : h.requestOn());
+				},
+				className: f,
+				"aria-pressed": O,
+				title: y.toggleHint,
+				"aria-disabled": k,
+				"data-testid": "assistant-live-avatar-toggle",
+				children: [u(O ? c : s, {
+					className: "size-4",
+					"aria-hidden": "true"
+				}), /* @__PURE__ */ u("span", { children: y.toggle })]
+			}) : null,
+			D === "choosing" ? /* @__PURE__ */ d("fieldset", {
+				className: "flex max-w-xs flex-col gap-2 rounded-xl border border-border-default bg-bg-elevated p-3 text-start",
+				"data-testid": "assistant-live-avatar-consent",
+				children: [
+					/* @__PURE__ */ u("legend", {
+						className: "sr-only",
+						children: y.toggle
+					}),
+					E.avatars.length > 1 ? /* @__PURE__ */ d("fieldset", {
+						className: "flex flex-wrap gap-1.5",
+						"data-testid": "assistant-live-avatar-chooser",
+						children: [/* @__PURE__ */ u("legend", {
+							className: "sr-only",
+							children: y.chooserTitle
+						}), E.avatars.map((e, t) => {
+							let n = e === E.selectedAvatarId, r = j(e, t);
+							return /* @__PURE__ */ d("label", {
+								className: `${p} ${n ? "border-transparent bg-action-primary-bg text-action-primary-text" : "border-border-default bg-bg-elevated text-text-secondary hover:bg-bg-raised hover:text-text-primary"}`,
+								title: n ? y.chooserSelected(r) : y.chooserOption(r),
+								children: [/* @__PURE__ */ u("input", {
+									type: "radio",
+									name: x,
+									value: e,
+									checked: n,
+									onChange: () => h.selectAvatar(e),
+									className: "sr-only",
+									"data-avatar-id": e
+								}), r]
+							}, e);
+						})]
+					}) : null,
+					/* @__PURE__ */ u("p", {
+						ref: w,
+						id: b,
+						tabIndex: -1,
+						className: "text-xs text-text-secondary focus:outline-none",
+						"data-testid": "assistant-live-avatar-disclosure",
+						children: y.consent
+					}),
+					/* @__PURE__ */ d("div", {
+						className: "flex justify-end gap-2",
+						children: [/* @__PURE__ */ u("button", {
+							type: "button",
+							onClick: () => {
+								C.current?.focus(), h.cancelChoice();
+							},
+							className: f,
+							children: y.consentCancel
+						}), /* @__PURE__ */ u("button", {
+							type: "button",
+							onClick: () => {
+								C.current?.focus(), h.confirm();
+							},
+							"aria-describedby": b,
+							className: m,
+							disabled: E.selectedAvatarId === null,
+							"data-testid": "assistant-live-avatar-confirm",
+							children: y.consentConfirm
+						})]
+					})
+				]
+			}) : null,
+			/* @__PURE__ */ u("p", {
+				className: A === null ? "sr-only" : "max-w-xs text-center text-xs text-text-muted",
+				role: "status",
+				"data-testid": "assistant-live-avatar-status",
+				children: A ?? ""
+			})
+		]
+	});
+};
+//#endregion
+export { h as LiveAvatarStageView };

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

@@ -0,0 +1,40 @@
+export interface AudioBufferLike {
+    readonly sampleRate: number;
+    readonly length: number;
+    readonly numberOfChannels: number;
+    getChannelData(channel: number): Float32Array;
+}
+/** The two browser operations this module needs, injectable so the logic is testable without a browser. */
+export interface AudioDecodeEnv {
+    /** decodeAudioData on a fresh OfflineAudioContext of `contextRate` Hz (the browser resamples the result to that rate). */
+    decode(data: ArrayBuffer, contextRate: number): Promise<AudioBufferLike>;
+    /** Render `buffer` through a mono OfflineAudioContext of `rate` Hz (graph resample + downmix). */
+    renderMono(buffer: AudioBufferLike, rate: number): Promise<Float32Array>;
+}
+export type AvatarDecodeStrategy = 'decode-at-target' | 'render';
+export declare const DEFAULT_AVATAR_DECODE_STRATEGY: AvatarDecodeStrategy;
+/** Refuse inputs larger than this before touching the decoder (a hosted TTS sentence is a few hundred KB). */
+export declare const DEFAULT_AVATAR_DECODE_MAX_BYTES: number;
+export interface AvatarDecodeOptions {
+    signal?: AbortSignal | undefined;
+    strategy?: AvatarDecodeStrategy | undefined;
+    maxBytes?: number | undefined;
+    env?: AudioDecodeEnv | undefined;
+}
+export interface DecodedPcm16 {
+    /** PCM16 little-endian mono at 16 kHz. */
+    pcm: Uint8Array;
+    durationSec: number;
+    sampleCount: number;
+}
+/** The real browser environment. Throws a typed error (not a TypeError) when there is no Web Audio. */
+export declare function browserAvatarAudioEnv(): AudioDecodeEnv;
+/**
+ * Decode MP3 bytes to PCM16 LE mono 16 kHz.
+ *  - invalid / empty / non-MP3          -> InvalidAudioError
+ *  - last frame cut                      -> TruncatedAudioError (decodeAudioData alone would silently return the partial audio)
+ *  - browser decoder rejects             -> AudioDecodeError('decode_failed')
+ *  - signal aborted before or during     -> AudioDecodeAbortedError, and no result is ever delivered afterwards
+ * The caller's `bytes` are never detached: decodeAudioData transfers its buffer, so a copy is handed to it.
+ */
+export declare function decodeMp3ToPcm16k(bytes: Uint8Array, options?: AvatarDecodeOptions): Promise<DecodedPcm16>;

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

@@ -0,0 +1,72 @@
+import { AudioDecodeAbortedError as e, AudioDecodeError as t, InvalidAudioError as n, TruncatedAudioError as r } from "./avatarAudioErrors.js";
+import { inspectMp3 as i } from "./avatarMp3Inspect.js";
+import { AVATAR_SAMPLE_RATE as a, downmixToMono as o, floatToPcm16Bytes as s } from "./avatarPcm16.js";
+//#region src/shared/assistant/avatar/live/avatarAudioDecode.ts
+var c = "decode-at-target", l = 16 * 1024 * 1024, u = 48e3;
+function d() {
+	let e = globalThis;
+	return e.OfflineAudioContext ?? e.webkitOfflineAudioContext ?? null;
+}
+function f() {
+	let e = d();
+	if (!e) throw new t("unsupported_environment", "OfflineAudioContext is not available in this environment");
+	return {
+		decode(t, n) {
+			return new e(1, 1, n).decodeAudioData(t);
+		},
+		async renderMono(t, n) {
+			let r = new e(1, Math.max(1, Math.ceil(t.length * (n / t.sampleRate))), n), i = r.createBufferSource();
+			return i.buffer = t, i.connect(r.destination), i.start(0), (await r.startRendering()).getChannelData(0);
+		}
+	};
+}
+function p(t) {
+	if (t?.aborted) throw new e();
+}
+function m(t, n) {
+	return n ? new Promise((r, i) => {
+		let a = () => i(new e());
+		if (n.aborted) {
+			a(), t.catch(() => void 0);
+			return;
+		}
+		n.addEventListener("abort", a, { once: !0 }), t.then((t) => {
+			n.removeEventListener("abort", a), n.aborted ? i(new e()) : r(t);
+		}, (t) => {
+			n.removeEventListener("abort", a), i(n.aborted ? new e() : t);
+		});
+	}) : t;
+}
+async function h(e, c = {}) {
+	let { signal: l } = c;
+	p(l);
+	let d = c.maxBytes ?? 16777216;
+	if (e.byteLength === 0) throw new n("empty audio");
+	if (e.byteLength > d) throw new t("too_large", `audio is ${e.byteLength} bytes, limit is ${d}`);
+	let h = i(e);
+	if (!h) throw new n("no MP3 frames found");
+	if (h.truncated) throw new r(h.danglingBytes, h.durationSec);
+	let g = c.env ?? f(), _ = c.strategy ?? "decode-at-target", v = e.slice().buffer, y = await m((async () => {
+		try {
+			if (_ === "render") {
+				let e = await g.decode(v, u);
+				return await g.renderMono(e, a);
+			}
+			let e = await g.decode(v, a);
+			if (e.sampleRate !== 16e3) throw new t("decode_failed", `browser returned ${e.sampleRate} Hz, expected ${a}`);
+			let n = [];
+			for (let t = 0; t < e.numberOfChannels; t += 1) n.push(e.getChannelData(t));
+			return o(n);
+		} catch (e) {
+			throw e instanceof t ? e : new t("decode_failed", `browser could not decode the audio: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+		}
+	})(), l);
+	if (p(l), y.length === 0) throw new n("decoder produced no samples");
+	return {
+		pcm: s(y),
+		durationSec: y.length / a,
+		sampleCount: y.length
+	};
+}
+//#endregion
+export { l as DEFAULT_AVATAR_DECODE_MAX_BYTES, c as DEFAULT_AVATAR_DECODE_STRATEGY, f as browserAvatarAudioEnv, h as decodeMp3ToPcm16k };

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

@@ -0,0 +1,25 @@
+export type AudioDecodeErrorCode = 'invalid_audio' | 'truncated_audio' | 'decode_failed' | 'too_large' | 'aborted' | 'unsupported_environment';
+export declare class AudioDecodeError extends Error {
+    readonly code: AudioDecodeErrorCode;
+    constructor(code: AudioDecodeErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class InvalidAudioError extends AudioDecodeError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class TruncatedAudioError extends AudioDecodeError {
+    /** Bytes of the incomplete last frame. */
+    readonly danglingBytes: number;
+    /** Duration of the complete frames that WERE present. */
+    readonly completeFramesDurationSec: number;
+    constructor(danglingBytes: number, completeFramesDurationSec: number);
+}
+export declare class AudioDecodeAbortedError extends AudioDecodeError {
+    constructor();
+}
+export declare class PcmFormatError extends Error {
+    constructor(message: string);
+}

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

@@ -0,0 +1,27 @@
+//#region src/shared/assistant/avatar/live/avatarAudioErrors.ts
+var e = class extends Error {
+	code;
+	constructor(e, t, n) {
+		super(t, n), this.name = "AudioDecodeError", this.code = e;
+	}
+}, t = class extends e {
+	constructor(e, t) {
+		super("invalid_audio", e, t), this.name = "InvalidAudioError";
+	}
+}, n = class extends e {
+	danglingBytes;
+	completeFramesDurationSec;
+	constructor(e, t) {
+		super("truncated_audio", `MP3 ends inside a frame (${e} dangling bytes after ${t.toFixed(3)} s of complete frames)`), this.name = "TruncatedAudioError", this.danglingBytes = e, this.completeFramesDurationSec = t;
+	}
+}, r = class extends e {
+	constructor() {
+		super("aborted", "audio decode aborted"), this.name = "AudioDecodeAbortedError";
+	}
+}, i = class extends Error {
+	constructor(e) {
+		super(e), this.name = "PcmFormatError";
+	}
+};
+//#endregion
+export { r as AudioDecodeAbortedError, e as AudioDecodeError, t as InvalidAudioError, i as PcmFormatError, n as TruncatedAudioError };

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

@@ -0,0 +1,37 @@
+export interface AvatarLevelDetectorConfig {
+    /** RMS (0..1) above which audio counts as audible (about -50 dBFS). */
+    readonly onThreshold: number;
+    /** RMS below which audio counts as quiet again (hysteresis, about -55 dBFS). */
+    readonly offThreshold: number;
+    /** Must stay above onThreshold this long before "audible" is reported. */
+    readonly attackMs: number;
+    /** Must stay below offThreshold this long before "quiet" is reported (bridges the gaps between words). */
+    readonly hangoverMs: number;
+}
+export declare const DEFAULT_AVATAR_LEVEL_CONFIG: AvatarLevelDetectorConfig;
+/** Pure hysteresis detector: feed it RMS samples with timestamps. */
+export declare class AvatarLevelDetector {
+    private readonly config;
+    private audible;
+    private aboveSince;
+    private belowSince;
+    constructor(config?: AvatarLevelDetectorConfig);
+    get isAudible(): boolean;
+    /** Returns the new state when it changed, otherwise null. */
+    push(rms: number, nowMs: number): boolean | null;
+    reset(): void;
+}
+export declare function rmsOfFloat32(samples: Float32Array): number;
+export interface AvatarMeterHandle {
+    stop(): void;
+    /** True while the meter can really hear: not stopped and its AudioContext is running (a suspended context reads silence). */
+    isRunning(): boolean;
+    /** Resume a suspended context. Call it from the same user gesture that resumes the avatar's audio. */
+    resume(): Promise<void>;
+}
+/**
+ * WebAudio tap: MediaStream -> AnalyserNode, polled at about 50 Hz. The tap is NOT connected to the destination,
+ * so it adds no second audible copy. Whether Chrome delivers non-zero samples for a REMOTE track depends on the
+ * track also being attached to a media element (Gate 1 package L, test f, measures this).
+ */
+export declare function startAvatarAudioMeter(stream: MediaStream, onChange: (audible: boolean) => void, config?: AvatarLevelDetectorConfig, pollMs?: number): AvatarMeterHandle;

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

@@ -0,0 +1,62 @@
+//#region src/shared/assistant/avatar/live/avatarAudioMeter.ts
+var e = {
+	onThreshold: .003,
+	offThreshold: .0018,
+	attackMs: 60,
+	hangoverMs: 400
+}, t = class {
+	config;
+	audible = !1;
+	aboveSince = null;
+	belowSince = null;
+	constructor(t = e) {
+		this.config = t;
+	}
+	get isAudible() {
+		return this.audible;
+	}
+	push(e, t) {
+		if (!this.audible) {
+			if (e >= this.config.onThreshold) {
+				if (this.aboveSince ??= t, t - this.aboveSince >= this.config.attackMs) return this.audible = !0, this.aboveSince = null, this.belowSince = null, !0;
+			} else this.aboveSince = null;
+			return null;
+		}
+		if (e <= this.config.offThreshold) {
+			if (this.belowSince ??= t, t - this.belowSince >= this.config.hangoverMs) return this.audible = !1, this.belowSince = null, this.aboveSince = null, !1;
+		} else this.belowSince = null;
+		return null;
+	}
+	reset() {
+		this.audible = !1, this.aboveSince = null, this.belowSince = null;
+	}
+};
+function n(e) {
+	if (e.length === 0) return 0;
+	let t = 0;
+	for (let n = 0; n < e.length; n += 1) {
+		let r = e[n] ?? 0;
+		t += r * r;
+	}
+	return Math.sqrt(t / e.length);
+}
+function r(r, i, a = e, o = 20) {
+	let s = globalThis.AudioContext, c = new s(), l = c.createMediaStreamSource(r), u = c.createAnalyser();
+	u.fftSize = 1024, l.connect(u);
+	let d = new Float32Array(u.fftSize), f = new t(a), p = setInterval(() => {
+		u.getFloatTimeDomainData(d);
+		let e = f.push(n(d), performance.now());
+		e !== null && i(e);
+	}, o), m = !1;
+	return {
+		isRunning: () => !m && c.state === "running",
+		resume: async () => {
+			!m && c.state === "suspended" && await c.resume().catch(() => void 0);
+		},
+		stop() {
+			m || (m = !0, clearInterval(p), l.disconnect(), c.state !== "closed" && c.close().catch(() => void 0));
+		}
+	};
+}
+//#endregion
+export { t as AvatarLevelDetector, e as DEFAULT_AVATAR_LEVEL_CONFIG, n as rmsOfFloat32, r as startAvatarAudioMeter };

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

@@ -0,0 +1,30 @@
+export interface Mp3Info {
+    frames: number;
+    sampleRate: number;
+    channels: number;
+    samplesPerFrame: number;
+    /** frames * samplesPerFrame / sampleRate: what a decoder without delay compensation outputs. */
+    durationSec: number;
+    firstFrameOffset: number;
+    /** The last frame is cut short. */
+    truncated: boolean;
+    /** Bytes of the incomplete last frame (0 unless truncated). */
+    danglingBytes: number;
+    /** Non-frame bytes after the last complete frame (ID3v1 tag, padding, junk), excluding the dangling frame. */
+    trailingBytes: number;
+}
+interface FrameHeader {
+    length: number;
+    sampleRate: number;
+    channels: number;
+    samplesPerFrame: number;
+}
+/** Parse the 4-byte header at `at`, or null when it is not a valid frame header. */
+export declare function parseFrameHeader(bytes: Uint8Array, at: number): FrameHeader | null;
+/**
+ * Walk the frames. Returns null when no valid MP3 frame sequence starts in the first 64 KiB (garbage, empty, wrong format).
+ * A candidate first frame is accepted only when the NEXT header also parses at the computed offset (or the file ends there),
+ * which makes a random 0xFF 0xFx byte pair in garbage vanishingly unlikely to be taken for MP3.
+ */
+export declare function inspectMp3(bytes: Uint8Array): Mp3Info | null;
+export {};

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

@@ -0,0 +1,168 @@
+//#region src/shared/assistant/avatar/live/avatarMp3Inspect.ts
+var e = [
+	0,
+	32,
+	64,
+	96,
+	128,
+	160,
+	192,
+	224,
+	256,
+	288,
+	320,
+	352,
+	384,
+	416,
+	448
+], t = [
+	0,
+	32,
+	48,
+	56,
+	64,
+	80,
+	96,
+	112,
+	128,
+	160,
+	192,
+	224,
+	256,
+	320,
+	384
+], n = [
+	0,
+	32,
+	40,
+	48,
+	56,
+	64,
+	80,
+	96,
+	112,
+	128,
+	160,
+	192,
+	224,
+	256,
+	320
+], r = [
+	0,
+	32,
+	48,
+	56,
+	64,
+	80,
+	96,
+	112,
+	128,
+	144,
+	160,
+	176,
+	192,
+	224,
+	256
+], i = [
+	0,
+	8,
+	16,
+	24,
+	32,
+	40,
+	48,
+	56,
+	64,
+	80,
+	96,
+	112,
+	128,
+	144,
+	160
+], a = {
+	3: [
+		44100,
+		48e3,
+		32e3
+	],
+	2: [
+		22050,
+		24e3,
+		16e3
+	],
+	0: [
+		11025,
+		12e3,
+		8e3
+	]
+};
+function o(o, s) {
+	if (s + 4 > o.length) return null;
+	let c = o[s] ?? 0, l = o[s + 1] ?? 0, u = o[s + 2] ?? 0, d = o[s + 3] ?? 0;
+	if (c !== 255 || (l & 224) != 224) return null;
+	let f = l >> 3 & 3, p = l >> 1 & 3;
+	if (f === 1 || p === 0) return null;
+	let m = u >> 4 & 15, h = u >> 2 & 3;
+	if (m === 0 || m === 15 || h === 3) return null;
+	let g = a[f]?.[h];
+	if (!g) return null;
+	let _ = u >> 1 & 1, v = f === 3, y, b;
+	p === 3 ? (y = v ? e : r, b = 384) : p === 2 ? (y = v ? t : i, b = 1152) : (y = v ? n : i, b = v ? 1152 : 576);
+	let x = y[m];
+	if (!x) return null;
+	let S = x * 1e3, C = p === 3 ? (Math.floor(12 * S / g) + _) * 4 : Math.floor(b / 8 * S / g) + _;
+	return C < 4 ? null : {
+		length: C,
+		sampleRate: g,
+		channels: (d >> 6 & 3) == 3 ? 1 : 2,
+		samplesPerFrame: b
+	};
+}
+function s(e) {
+	if (e.length >= 10 && e[0] === 73 && e[1] === 68 && e[2] === 51) {
+		let t = ((e[6] ?? 0) & 127) * 2097152 + ((e[7] ?? 0) & 127) * 16384 + ((e[8] ?? 0) & 127) * 128 + ((e[9] ?? 0) & 127), n = (e[5] ?? 0) & 16 ? 10 : 0;
+		return 10 + t + n;
+	}
+	return 0;
+}
+function c(e) {
+	let t = s(e), n = Math.min(e.length, t + 65536), r = -1, i = null;
+	for (let a = t; a < n; a += 1) {
+		let t = o(e, a);
+		if (!t) continue;
+		let n = a + t.length, s = n >= e.length, c = !s && o(e, n) !== null;
+		if (s || c) {
+			r = a, i = t;
+			break;
+		}
+	}
+	if (r < 0 || !i) return null;
+	let a = r, c = 0, l = !1, u = 0, { sampleRate: d, channels: f, samplesPerFrame: p } = i;
+	for (;;) {
+		let t = o(e, a);
+		if (!t || t.sampleRate !== d) {
+			let t = e.length - a;
+			t > 0 && t < 4 && (e[a] ?? 0) === 255 && (l = !0, u = t, a = e.length);
+			break;
+		}
+		if (a + t.length > e.length) {
+			l = !0, u = e.length - a, a = e.length;
+			break;
+		}
+		c += 1, a += t.length;
+	}
+	let m = l ? e.length - u : a;
+	return {
+		frames: c,
+		sampleRate: d,
+		channels: f,
+		samplesPerFrame: p,
+		durationSec: c * p / d,
+		firstFrameOffset: r,
+		truncated: l,
+		danglingBytes: u,
+		trailingBytes: l ? 0 : e.length - m
+	};
+}
+//#endregion
+export { c as inspectMp3, o as parseFrameHeader };

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

@@ -0,0 +1,21 @@
+export declare const AVATAR_SAMPLE_RATE = 16000;
+export declare const PCM16_BYTES_PER_SAMPLE = 2;
+/** float [-1, 1] -> int16, clamped. Negative scales by 32768 and positive by 32767 so +1.0 does not wrap; NaN becomes silence. */
+export declare function floatToInt16(samples: Float32Array): Int16Array;
+/** int16 samples -> little-endian bytes. Uses DataView so it is correct on any host byte order. */
+export declare function int16ToBytesLE(samples: Int16Array): Uint8Array;
+export declare function floatToPcm16Bytes(samples: Float32Array): Uint8Array;
+/** Bytes -> int16 samples (for tests and verification). Throws on an odd byte count. */
+export declare function bytesToInt16LE(pcm: Uint8Array): Int16Array;
+/** Seconds of audio in mono PCM16 bytes. Throws on an odd byte count rather than rounding it away. */
+export declare function pcm16DurationOf(pcm: Uint8Array | number, sampleRate?: number): number;
+/** Samples in one chunk of `ms` milliseconds (at least 1, so tiny `ms` still makes progress). */
+export declare function pcm16SamplesPerChunk(ms: number, sampleRate?: number): number;
+/**
+ * Cut mono PCM16 into slices of `ms` milliseconds on whole-sample boundaries. The slices are zero-copy views of `pcm`
+ * (callers that keep them past mutation of `pcm` must copy). Every slice but possibly the last has exactly
+ * pcm16SamplesPerChunk(ms) samples; the last holds the remainder. An odd byte length is rejected: a half sample is corruption.
+ */
+export declare function chunkPcm16(pcm: Uint8Array, ms: number, sampleRate?: number): Uint8Array[];
+/** Mean of channels into one mono channel. */
+export declare function downmixToMono(channels: readonly Float32Array[]): Float32Array;