@burdenoff/fe-libs 2026.1013.13 → 2026.1013.14

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

@@ -0,0 +1,170 @@
+import { SpeechAudioOutput, SpeechOutputRefusal } from '../../speech/types';
+import { AvatarScheduler, AvatarUnsubscribe } from './avatarPorts';
+import { AvatarBeforeAudioReason, AvatarTrackerConfig, AvatarUncertainReason } from './avatarPlaybackTracker';
+import { AvatarClearOptions, AvatarClearOutcome, AvatarSegmentWriter, AvatarTransportEvent } from './avatarTransport';
+export type AvatarPortEvent = AvatarTransportEvent | {
+    readonly type: 'meter';
+    readonly audible: boolean;
+};
+/** What the outputs need from the live avatar session. Faked in tests. */
+export interface AvatarOutputPort {
+    /** Avatar switched ON and ready. Evaluated when a reply starts writing, and before a retry. */
+    isActive(): boolean;
+    /** The browser currently blocks the avatar's audio (autoplay policy). */
+    isAudioBlocked(): boolean;
+    /** Identifies the current avatar connection. Only the first avatar reply of a connection can be hit by a first-stream race. */
+    connectionId(): number;
+    /**
+     * True while the level meter can really hear the avatar (it exists and its AudioContext is running). Without it, "nothing was
+     * heard" cannot be proven, so no-start detection (and with it the speakers fallback and the one-time retry) is switched off.
+     */
+    isMeterHealthy(): boolean;
+    /**
+     * The level meter's current reading: true while it hears audio on the avatar's received track. Provisional, and meaningful only while
+     * isMeterHealthy(). The meter reports changes only, so this is where a wait for the avatar's audio to drain starts from.
+     */
+    isMeterAudible(): boolean;
+    openSegment(): Promise<AvatarSegmentWriter>;
+    /**
+     * Interrupt the avatar and wait (bounded) until it reports finished(interrupted); resolves with what the clear achieved. `options` says
+     * whether the avatar's report of the segment it ends is already overdue (AvatarClearOptions in avatarTransport.ts).
+     */
+    clearBuffer(options?: AvatarClearOptions): Promise<AvatarClearOutcome>;
+    /** Instantly mute or unmute the avatar's audio element. */
+    setOutputMuted(muted: boolean): void;
+    subscribe(handler: (event: AvatarPortEvent) => void): AvatarUnsubscribe;
+}
+export type AvatarNotice = {
+    readonly kind: 'voice-fallback';
+    readonly reason: AvatarBeforeAudioReason;
+} | {
+    readonly kind: 'interrupted';
+    readonly reason: AvatarUncertainReason;
+} | {
+    readonly kind: 'audio-blocked';
+}
+/** The chosen voice is a device voice: it produces no audio data, so the avatar cannot speak it. The normal voice speaks instead. */
+ | {
+    readonly kind: 'needs-hosted-voice';
+}
+/** The first reply of a connection played nothing; it is being written to the avatar once more from the same audio. */
+ | {
+    readonly kind: 'first-reply-retry';
+    readonly attempt: number;
+}
+/**
+ * The avatar's earlier output could not be established as stopped (see `outputDrained`), so this reply was not started anywhere: nothing
+ * was written or unmuted, the speakers did not play it, and it is not retried. The hosted engine ends it with
+ * onError('output-not-cleared'), and the voice session shows its "reply not heard" notice (P1c); the reply's text stays where it is.
+ */
+ | {
+    readonly kind: 'output-not-cleared';
+}
+/**
+ * Nothing could establish that the avatar's earlier output stopped (no meter could hear it, and the avatar did not confirm the clear), but
+ * everything written to the avatar must have played out by now (the time-based release, see `playedOutAt`): that output counts as played
+ * out, and avatar replies go ahead again. Sent once, when the release is decided, whether or not a reply is waiting for it.
+ * `sincePlayedOutMs`: how long ago that moment passed.
+ */
+ | {
+    readonly kind: 'output-released';
+    readonly sincePlayedOutMs: number;
+}
+/**
+ * The avatar reported a reply played out (its own lk.playback_finished), but a meter that can hear still heard audio when the tail wait
+ * after that report ran out: the output was muted BEFORE the reply was reported ended, so the microphone never reopens on audible avatar
+ * audio, and the next reply waits for that audio to drain as after any clear (see `outputDrained`). The reply is still reported
+ * completed, which is what the avatar confirmed; nothing claims that its audio ended by itself.
+ */
+ | {
+    readonly kind: 'output-muted-at-end';
+};
+/** One piece of a reply, decoded for the avatar: PCM16 little-endian, mono, 16 kHz. */
+export interface AvatarDecodedPiece {
+    readonly pcm: Uint8Array;
+    readonly durationSec: number;
+}
+export interface AvatarReplyOutputsDeps {
+    readonly port: AvatarOutputPort;
+    readonly scheduler: AvatarScheduler;
+    /** The hosted proxy's MP3 bytes to PCM16 16 kHz mono (`decodeMp3ToPcm16k` in production). Must honour the signal. */
+    readonly decode: (bytes: Uint8Array, signal: AbortSignal) => Promise<AvatarDecodedPiece>;
+    readonly trackerConfig?: AvatarTrackerConfig;
+    /**
+     * The next piece takes longer than this to be ready while the avatar may need it: a stall. Counted from the moment the engine could hand
+     * the next piece over, which (writes resolve when a piece begins) is when the previous piece began; for a piece already handed over,
+     * from the moment its decode is awaited.
+     */
+    readonly stallMs?: number;
+    /** Writes are cut into slices of this duration so a cancel between slices drops the rest. */
+    readonly writeSliceMs?: number;
+    /**
+     * After a clear, the next reply unmutes only once the avatar's audio on the received track has drained (see `outputDrained`). This caps
+     * that wait, counted from the clear's settlement (from its own start for a reply that measures again after a failed wait). It is a
+     * safety bound, not the expected wait: it ends a wait in which the meter never reads quiet (an avatar that ignores the clear, a meter
+     * stuck on noise), and the wait for a stopped reply's first words while no start latency has been measured on the connection. The real
+     * worker's audio went quiet 1149 ms after a Stop (contract test, 2026-10-09, the meter's own hangover included), so the default leaves
+     * well over twice that before a tail could be cut short. A meter that can hear when the bound runs out decides: audio, or quiet that has
+     * not yet held for the tracker's tail, means the earlier output was NOT established as stopped, and the next reply is then refused
+     * instead of unmuting (operator decision 7, 2026-10-09). Without a meter that can hear, only the avatar's confirmation of the clear plus
+     * this whole bound since it lets the next reply unmute, and a confirmation that a failed wait disproved no longer counts. Without that
+     * confirmation either, only the time-based release can (see `playedOutAt`).
+     */
+    readonly maxDrainMs?: number;
+    readonly onNotice?: (notice: AvatarNotice) => void;
+    /** A reply starts using the avatar (true) or is over (false): the session's idle and time-limit rules read it. */
+    readonly onActivity?: (busy: boolean) => void;
+}
+export interface AvatarReplyOutputs {
+    /** A fresh output for ONE reply. It does nothing until the hosted engine writes or drains it. */
+    createOutput(): SpeechAudioOutput;
+    /**
+     * The avatar was switched off while a reply plays on it (its toggle, the compact view's stop, the end of the voice conversation, a
+     * session that ended): that reply LEAVES. Its sound stops at once, what may have been heard counts as begun, and the rest plays on the
+     * speakers from the same bytes (R4). Never the engine's `cancel()`, which would silence the reply.
+     */
+    leave(): void;
+    /** A reply is using the avatar right now. */
+    isBusy(): boolean;
+}
+/**
+ * The start latency the time-based release counts on a connection where none was measured (see `playedOutAt`): a stand-in, not a measured
+ * value, and never less than the tracker's own start allowance. The paid contract test (2026-10-09) measured 0.89–0.95 s from our write to
+ * audible avatar audio, so this is more than three times that. A test pins the floor set for the release: never below 2 s.
+ */
+export declare const UNMEASURED_START_LATENCY_MS = 3000;
+/**
+ * Added to the time-based release's moment (see `playedOutAt`) for what the start latency and the pushed duration leave out: jitter in the
+ * avatar's start and in the received track's buffering. In the paid contract test (2026-10-09) the start latency varied by 0.06 s. The
+ * meter went quiet 0.32 s after the avatar's own lk.playback_finished, but that includes the meter's 400 ms hangover
+ * (DEFAULT_AVATAR_LEVEL_CONFIG), so the audio itself ended about when that finished came (some 0.08 s before it). 1 s is more than ten
+ * times either figure.
+ */
+export declare const RELEASE_MARGIN_MS = 1000;
+/**
+ * When a reply may have been heard and stops early (uncertain, or a leave), a piece already handed to the avatar counts as begun when its
+ * place in the stream (the reply's observed start plus the pieces before it) is less than this far ahead. The observed start can lag the
+ * audible one by the meter's attack or the start signal's trip (tens of milliseconds); one second more than covers it, on the side that
+ * never repeats a word: a piece counted begun is never played again on the speakers. New with P8: the harness never replayed after audio
+ * may have been heard, and the speakers fallback (R4) needs the line drawn somewhere.
+ */
+export declare const MAY_HAVE_BEGUN_MARGIN_MS = 1000;
+/** How a reply that stops before its end reaches the hosted engine (SpeechAudioOutput). Its reason is never read beyond these. */
+export declare class AvatarOutputFailure extends Error {
+    readonly outcome: string;
+    readonly reason: "avatar-output-failed";
+    constructor(outcome: string);
+}
+/** The avatar was switched off while the reply goes on (SPEECH_OUTPUT_LEFT): the rest plays on the speakers. */
+export declare class AvatarOutputLeft extends Error {
+    readonly reason = "left";
+    constructor();
+}
+/** The avatar's earlier output could not be shown stopped (SPEECH_OUTPUT_REFUSE_AUDIBLE): the reply is heard nowhere. */
+export declare class AvatarOutputRefusal extends Error implements SpeechOutputRefusal {
+    readonly reason = "refuse-audible";
+    constructor();
+}
+/** Whole-sample slices of about `ms` of PCM16 16 kHz mono. */
+export declare function sliceAvatarPcm(pcm: Uint8Array, ms: number): Uint8Array[];
+export declare function createAvatarReplyOutputs(deps: AvatarReplyOutputsDeps): AvatarReplyOutputs;

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

@@ -0,0 +1,525 @@
+import { SPEECH_OUTPUT_LEFT as e, SPEECH_OUTPUT_REFUSE_AUDIBLE as t } from "../../speech/types.js";
+import { AVATAR_PCM_BYTES_PER_SECOND as n } from "./avatarProtocol.js";
+import { AvatarSegmentEndedError as r } from "./avatarTransport.js";
+import { DEFAULT_AVATAR_TRACKER_CONFIG as i, ReplyPlaybackTracker as a } from "./avatarPlaybackTracker.js";
+//#region src/shared/assistant/avatar/live/avatarReplyOutputs.ts
+var o = 2, s = .1, c = 3e3, l = 1e3, u = 1e3, d = class extends Error {
+	outcome;
+	reason = "avatar-output-failed";
+	constructor(e) {
+		super(`avatar output failed: ${e}`), this.outcome = e, this.name = "AvatarOutputFailure";
+	}
+}, f = class extends Error {
+	reason = e;
+	constructor() {
+		super("avatar output left the reply"), this.name = "AvatarOutputLeft";
+	}
+}, p = class extends Error {
+	reason = t;
+	constructor() {
+		super("avatar refused the reply: earlier audio may still be playing"), this.name = "AvatarOutputRefusal";
+	}
+};
+function m(e) {
+	return !e.synthetic || e.rpc === "ok" || e.rpc === "none";
+}
+function h(e, t) {
+	let r = Math.max(2, Math.floor(n * t / 1e3 / 2) * 2), i = [];
+	for (let t = 0; t < e.byteLength; t += r) i.push(e.subarray(t, Math.min(e.byteLength, t + r)));
+	return i;
+}
+function g(e) {
+	let { port: t, scheduler: n } = e, u = e.trackerConfig ?? i, g = e.stallMs ?? 6e3, _ = e.writeSliceMs ?? 200, v = e.maxDrainMs ?? 3e3, y = null, b = null, x = null, S = null, C = null, w = null, T = (e) => y === e && e.end === null, E = (e) => T(e.reply) && e.reply.attempt === e, D = () => u.meterSupported && t.isMeterHealthy();
+	function O(t) {
+		try {
+			e.onNotice?.(t);
+		} catch {}
+	}
+	function k(t) {
+		try {
+			e.onActivity?.(t);
+		} catch {}
+	}
+	function A(e) {
+		return C !== null && C.connection === e ? C.ms : u.startLatencyAllowanceMs;
+	}
+	function ee(e) {
+		let t = e.tracker.audibleAfterMs;
+		if (t === null) return;
+		let { connection: n } = e.reply;
+		(C === null || C.connection !== n || t > C.ms) && (C = {
+			connection: n,
+			ms: t
+		});
+	}
+	function j(e) {
+		return C !== null && C.connection === e ? C.ms : Math.max(c, u.startLatencyAllowanceMs);
+	}
+	function M(e, t, n) {
+		let r = t + n * 1e3;
+		w === null || w.connection !== e ? w = {
+			connection: e,
+			writtenUntil: r,
+			heardAt: null
+		} : r > w.writtenUntil && (w = {
+			...w,
+			writtenUntil: r
+		});
+	}
+	function N(e) {
+		w !== null && w.connection === e && (w = {
+			...w,
+			heardAt: n.now()
+		});
+	}
+	function P(e) {
+		return w === null || w.connection !== e ? null : w.writtenUntil + j(e) + l;
+	}
+	function F(e) {
+		let t = P(e), r = w?.heardAt ?? null;
+		return t === null || n.now() < t || r !== null && r >= t ? !1 : (O({
+			kind: "output-released",
+			sincePlayedOutMs: n.now() - t
+		}), !0);
+	}
+	function I(e, r, i) {
+		let a = D(), o = a && t.isMeterAudible();
+		return o && N(e), !a && !i ? Promise.resolve(F(e)) : new Promise((s) => {
+			let c = !1, l = null, d = null, f = () => void 0, p = a && !t.isMeterAudible() ? n.now() : null, m = (e) => {
+				c || (c = !0, f(), l?.(), d?.(), s(e));
+			}, h = () => {
+				if (!a) return;
+				let e = Math.max(0, r - n.now()) + u.tailMs;
+				l ??= n.setTimeout(() => {
+					l = null, D() && m(!0);
+				}, e);
+			};
+			d = t.subscribe((t) => {
+				if (t.type === "meter") {
+					if ((o || t.audible && D()) && N(e), o = t.audible && D(), !t.audible) return p ??= n.now(), h();
+					p = null, l?.(), l = null;
+				}
+			}), p !== null && h();
+			let g = () => D() ? t.isMeterAudible() ? (N(e), !1) : p === null ? i : n.now() - p >= u.tailMs : i || F(e);
+			f = n.setTimeout(() => m(g()), v);
+		});
+	}
+	function L(e) {
+		b = e, e.then((t) => {
+			b === e && (b = null, x = t);
+		});
+	}
+	function R(e) {
+		if (b === null && x !== null) {
+			let t = x;
+			t.connection === e ? L(I(e, t.surfaceBy, !1).then((e) => e ? null : t)) : x = null;
+		}
+		let t = b;
+		return t === null ? null : t.then((t) => t === null || t.connection !== e);
+	}
+	function te(e, r) {
+		if (e.outputStopped) return;
+		e.outputStopped = !0, t.setOutputMuted(!0);
+		let i = e.segment;
+		if (i) if (i.pushedSec > 0) {
+			let a = t.clearBuffer({ finishOverdue: r }).catch(() => ({
+				positionSec: null,
+				synthetic: !0,
+				rpc: "error"
+			}));
+			e.clear = a;
+			let { connection: o } = e.reply, s = e.lastWriteAt ?? n.now();
+			M(o, s, i.pushedSec);
+			let c = s + A(o), l = {
+				connection: o,
+				surfaceBy: c
+			};
+			L((b ?? Promise.resolve(null)).then(() => a).then((e) => I(o, c, m(e))).then((e) => e ? null : l));
+		} else i.discard();
+	}
+	function z(e) {
+		for (let t of [...e.waiters]) t();
+	}
+	function B(e, t) {
+		if (!(t.begun || t.retracted)) {
+			t.begun = !0;
+			try {
+				t.began();
+			} catch {}
+			t.pending?.resolve(), t.pending = null, z(e);
+		}
+	}
+	function V(e) {
+		let t = e.attempt;
+		if (t === null || e.startedAt === null && t.tracker.nothingHeard) return;
+		let r = n.now(), i = 0;
+		for (let n = 0; n < e.pieces.length; n += 1) {
+			let a = e.pieces[n];
+			if (!(a === void 0 || a.retracted)) {
+				if (n > t.pushedThrough) return;
+				if (!a.begun) {
+					if (!(e.startedAt === null || e.startedAt + i - 1e3 <= r)) return;
+					B(e, a);
+				}
+				i += (a.durationSec ?? 0) * 1e3;
+			}
+		}
+	}
+	function H(e, t) {
+		if (e.end !== null) return;
+		e.end = t;
+		let n = y === e;
+		if (n && (y = null), e.abort.abort(), t.kind === "completed") for (let t of e.pieces) B(e, t);
+		for (let n of e.pieces) {
+			let e = n.pending;
+			n.pending = null, e !== null && (t.kind === "completed" || t.kind === "cancelled" ? e.resolve() : e.reject(t.error));
+		}
+		let r = e.pendingDrain;
+		e.pendingDrain = null, r !== null && (t.kind === "completed" || t.kind === "cancelled" ? r.resolve() : r.reject(t.error)), z(e), n && e.activated && k(!1);
+	}
+	function U(e, t) {
+		return e.kind === "cancelled" ? Promise.resolve() : e.kind === "completed" ? t === "drain" ? Promise.resolve() : Promise.reject(new d("written-after-end")) : Promise.reject(e.error);
+	}
+	function W(e) {
+		return e.firstOnConnection && e.attempts < o && t.isActive() && !t.isAudioBlocked();
+	}
+	function G(e, t) {
+		if (e.unsubscribe?.(), e.unsubscribe = null, !E(e)) return;
+		let n = e.reply;
+		if (t.kind === "failed-before-audio" && t.reason === "no-start" && W(n)) {
+			q(e);
+			return;
+		}
+		K(n, t);
+	}
+	function K(e, n) {
+		switch (n.kind) {
+			case "completed":
+				n.mutedAtEnd === !0 && O({ kind: "output-muted-at-end" }), H(e, { kind: "completed" });
+				return;
+			case "cancelled":
+				H(e, { kind: "cancelled" });
+				return;
+			case "failed-before-audio":
+				O({
+					kind: "voice-fallback",
+					reason: n.reason
+				}), H(e, n.reason === "not-ready" && !t.isActive() ? {
+					kind: "left",
+					error: new f()
+				} : {
+					kind: "failed",
+					error: new d(n.reason)
+				});
+				return;
+			case "uncertain":
+				O({
+					kind: "interrupted",
+					reason: n.reason
+				}), V(e), H(e, {
+					kind: "failed",
+					error: new d(n.reason)
+				});
+				return;
+			case "output-not-cleared":
+				O({ kind: "output-not-cleared" }), H(e, {
+					kind: "refused",
+					error: new p()
+				});
+				return;
+		}
+	}
+	async function q(e) {
+		let n = e.reply, r = e.clear ? await e.clear : null;
+		if (E(e)) {
+			if (r !== null && !r.synthetic && r.positionSec !== null && r.positionSec > s) {
+				K(n, {
+					kind: "uncertain",
+					reason: "played-before-retry",
+					heardAudio: !0,
+					cause: "unknown"
+				});
+				return;
+			}
+			if (t.isAudioBlocked()) {
+				O({ kind: "audio-blocked" }), K(n, {
+					kind: "failed-before-audio",
+					reason: "audio-blocked",
+					cause: "unknown"
+				});
+				return;
+			}
+			if (!t.isActive()) {
+				K(n, {
+					kind: "failed-before-audio",
+					reason: "not-ready",
+					cause: "unknown"
+				});
+				return;
+			}
+			if (r !== null && (r.rpc === "rejected" || r.rpc === "unsupported")) {
+				K(n, {
+					kind: "failed-before-audio",
+					reason: "not-accepted",
+					cause: "unknown"
+				});
+				return;
+			}
+			O({
+				kind: "first-reply-retry",
+				attempt: n.attempts + 1
+			}), Q(n);
+		}
+	}
+	function J(e, t) {
+		if (!E(e)) return;
+		let { tracker: n } = e;
+		switch (t.type) {
+			case "playbackStarted":
+				n.providerStarted();
+				return;
+			case "playbackFinished":
+				if (e.outputStopped) return;
+				n.providerFinished(t.positionSec, t.interrupted);
+				return;
+			case "avatarLeft":
+				n.avatarLeft();
+				return;
+			case "disconnected":
+				n.disconnected();
+				return;
+			case "audioPlayback":
+				t.canPlay || (O({ kind: "audio-blocked" }), n.audioBlocked());
+				return;
+			case "meter":
+				n.meter(t.audible), t.audible && ee(e);
+				return;
+			default: return;
+		}
+	}
+	function Y(e, t) {
+		let r = e.reply;
+		return new Promise((i) => {
+			let a = null, o = !1, s = (e) => {
+				o || (o = !0, a?.(), r.waiters.delete(c), i(e));
+			};
+			function c() {
+				if (!E(e)) return s("gone");
+				let i = r.pieces[t];
+				if (i !== void 0) return s(i);
+				if (r.drained) return s("end");
+				let o = r.pieces[t - 1], c = o === void 0 || o.begun || o.retracted;
+				a === null && c && (a = n.setTimeout(() => {
+					a = () => void 0, e.tracker.stalled(), s("stalled");
+				}, g));
+			}
+			r.waiters.add(c), c();
+		});
+	}
+	function X(e, t) {
+		return new Promise((r, i) => {
+			let a = n.setTimeout(() => {
+				t.tracker.stalled(), r(null);
+			}, g);
+			e.then((e) => {
+				a(), r(e);
+			}, (e) => {
+				a(), i(e);
+			});
+		});
+	}
+	async function Z(e) {
+		let { reply: i, tracker: a } = e, o = () => E(e) && !a.isDone;
+		try {
+			let r = R(i.connection), s = r === null || await r;
+			if (!E(e)) return;
+			if (!t.isActive()) {
+				a.failed("not-ready");
+				return;
+			}
+			if (t.isAudioBlocked()) {
+				O({ kind: "audio-blocked" }), a.audioBlocked();
+				return;
+			}
+			if (!s) {
+				a.outputNotCleared();
+				return;
+			}
+			t.setOutputMuted(!1), e.unsubscribe = t.subscribe((t) => J(e, t)), a.meter(t.isMeterAudible());
+			try {
+				e.segment = await t.openSegment();
+			} catch {
+				E(e) && a.failed("not-ready");
+				return;
+			}
+			if (!E(e)) {
+				e.segment.discard();
+				return;
+			}
+			let c = 0;
+			for (let t = 0;; t += 1) {
+				let r = await Y(e, t);
+				if (!o() || r === "stalled" || r === "gone") return;
+				if (r === "end") break;
+				if (r.retracted || r.decoded === null) continue;
+				let s = await X(r.decoded, e);
+				if (!o() || s === null) return;
+				if (!r.retracted) {
+					r.durationSec = s.durationSec, c += s.durationSec, a.chunkReady(r.index, s.durationSec);
+					for (let r of h(s.pcm, _)) {
+						if (!o()) return;
+						a.firstWrite(), e.lastWriteAt = n.now(), e.pushedThrough = t, await e.segment.write(r), a.delivered(), S = i.connection;
+					}
+					i.firstOnConnection || (r.decoded = null);
+				}
+			}
+			if (!o()) return;
+			if (e.pushedThrough < 0) {
+				e.segment.discard(), e.unsubscribe?.(), e.unsubscribe = null, K(i, { kind: "completed" });
+				return;
+			}
+			a.streamEnding(c), await e.segment.close();
+		} catch (e) {
+			if (!o()) return;
+			if (e instanceof r) return a.failed("stream-error");
+			a.failed("synth-failed");
+		}
+	}
+	function Q(e) {
+		e.attempts += 1, e.startedAt = null;
+		let r = null, i = () => r !== null && E(r);
+		r = {
+			reply: e,
+			tracker: new a({
+				onStart: () => {
+					i() && e.startedAt === null && (e.startedAt = n.now());
+				},
+				onChunkStart: (t) => {
+					if (!i()) return;
+					e.startedAt === null && (e.startedAt = n.now());
+					let r = e.pieces.find((e) => e.index === t);
+					r !== void 0 && B(e, r);
+				},
+				onEnd: () => void 0,
+				stopOutput: (e) => {
+					r !== null && te(r, e);
+				},
+				onOutcome: (e) => {
+					r !== null && G(r, e);
+				}
+			}, n, u.meterSupported && !t.isMeterHealthy() ? {
+				...u,
+				meterSupported: !1
+			} : u),
+			segment: null,
+			unsubscribe: null,
+			outputStopped: !1,
+			clear: null,
+			lastWriteAt: null,
+			pushedThrough: -1
+		}, e.attempt = r, Z(r);
+	}
+	function $(e) {
+		let t = e.attempt;
+		t?.tracker.cancel(), t?.unsubscribe?.(), e.abort.abort();
+	}
+	function ne(e) {
+		if (e.activated) return;
+		e.activated = !0;
+		let n = y;
+		n !== null && n !== e && (H(n, { kind: "cancelled" }), $(n)), e.connection = t.connectionId(), e.firstOnConnection = e.connection !== S, y = e, k(!0);
+	}
+	function re(e) {
+		let n = R(t.connectionId());
+		return n === null ? Promise.resolve() : n.then((n) => {
+			if (e.end !== null) return U(e.end, "drain");
+			if (n || !t.isActive() || t.isAudioBlocked()) return;
+			O({ kind: "output-not-cleared" });
+			let r = {
+				kind: "refused",
+				error: new p()
+			};
+			throw e.end = r, r.error;
+		});
+	}
+	function ie() {
+		let t = {
+			connection: -1,
+			firstOnConnection: !1,
+			activated: !1,
+			abort: new AbortController(),
+			pieces: [],
+			drained: !1,
+			pendingDrain: null,
+			attempts: 0,
+			attempt: null,
+			end: null,
+			startedAt: null,
+			waiters: /* @__PURE__ */ new Set()
+		};
+		return {
+			write(n, r, i) {
+				if (t.end !== null) return U(t.end, "write");
+				ne(t);
+				let a = e.decode(n, t.abort.signal);
+				a.catch(() => void 0);
+				let o = {
+					index: r,
+					began: i,
+					decoded: a,
+					durationSec: null,
+					begun: !1,
+					retracted: !1,
+					pending: null
+				}, s = new Promise((e, t) => {
+					o.pending = {
+						resolve: e,
+						reject: t
+					};
+				});
+				return t.pieces.push(o), t.attempt === null && Q(t), z(t), s;
+			},
+			drain() {
+				if (t.end !== null) return U(t.end, "drain");
+				if (!t.activated) return re(t);
+				t.drained = !0;
+				let e = new Promise((e, n) => {
+					t.pendingDrain = {
+						resolve: e,
+						reject: n
+					};
+				});
+				return z(t), e;
+			},
+			retract(e) {
+				if (t.end !== null) return;
+				let n = t.attempt?.pushedThrough ?? -1;
+				t.pieces.forEach((r, i) => {
+					if (!(r.index < e || r.begun || r.retracted)) {
+						if (i <= n) {
+							B(t, r);
+							return;
+						}
+						r.retracted = !0, r.pending?.resolve(), r.pending = null;
+					}
+				}), z(t);
+			},
+			cancel() {
+				t.end === null && (H(t, { kind: "cancelled" }), $(t));
+			}
+		};
+	}
+	return {
+		createOutput: ie,
+		leave() {
+			let e = y;
+			e === null || e.end !== null || (t.setOutputMuted(!0), V(e), H(e, {
+				kind: "left",
+				error: new f()
+			}), $(e));
+		},
+		isBusy: () => y !== null
+	};
+}
+//#endregion
+export { d as AvatarOutputFailure, f as AvatarOutputLeft, p as AvatarOutputRefusal, u as MAY_HAVE_BEGUN_MARGIN_MS, l as RELEASE_MARGIN_MS, c as UNMEASURED_START_LATENCY_MS, g as createAvatarReplyOutputs, h as sliceAvatarPcm };