@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.11-beta.7

package/src/services/voice/audio-frame-consumer.ts

@@ -0,0 +1,491 @@
+/**
+ * AudioFrameConsumer — turn the Android `audioFrame` PCM stream into live,
+ * VAD-segmented, speaker-attributed voice turns.
+ *
+ * The Android native capture path (`plugin-native-talkmode`) streams an
+ * `audioFrame` Capacitor event: base64 little-endian s16 mono PCM at 16 kHz,
+ * 20 ms per frame, plus `{ sampleRate, channels, samples, rms, timestamp,
+ * frameIndex }`. This module is the platform-agnostic consumer that subscribes
+ * to that stream (wherever the bun:ffi voice libs are present) and runs:
+ *
+ *   audioFrame (base64 LE-s16) → decode → VadDetector (turn segmentation)
+ *     → on speech-end: VoiceAttributionPipeline.attribute(turn PCM)
+ *       → handleLiveVoiceAttribution → VOICE_TURN_OBSERVED + voiceTurnSignal
+ *
+ * Design notes:
+ *  - It does NOT reinvent VAD: it drives the existing `VadDetector` state
+ *    machine (`speech-start` / `speech-pause` / `speech-end`), reusing its
+ *    Silero onset/offset/hangover logic. It buffers the turn's PCM between
+ *    `speech-start` and `speech-end`, then attributes the whole utterance.
+ *  - Every native dependency (`VadDetector`, `VoiceAttributionPipeline`, the
+ *    runtime) is INJECTED, so the consumer is fully unit-testable with fakes
+ *    and has no static import of bun:ffi. A `build*` factory in the smoke
+ *    harness wires the real ggml-backed deps.
+ *  - The decode boundary (`decodeAudioFramePcm`) is the ONLY place that knows
+ *    the wire format (base64 LE-s16). Internally everything is Float32 [-1,1].
+ *
+ * What this module does NOT do: it does not transcribe (ASR text is the
+ * separate streaming-ASR path) and it does not own the WebView→agent
+ * transport — see `android/AUDIO_FRAMES.md` and `LIVE_PIPELINE.md` for the
+ * remaining device wiring.
+ */
+
+import {
+	type EmitVoiceTurnObservedArgs,
+	type HandleLiveVoiceAttributionOptions,
+	handleLiveVoiceAttribution,
+} from "../../runtime/voice-entity-binding.js";
+import type { VoiceTurnSignal } from "./eot-classifier.js";
+import type {
+	VoiceAttributionOutput,
+	VoiceAttributionPipeline,
+} from "./speaker/attribution-pipeline.js";
+import type { PcmFrame, VadEvent, VoiceInputSource } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Wire format → Float32 boundary
+// ---------------------------------------------------------------------------
+
+/**
+ * The `audioFrame` event payload, mirroring `TalkModeAudioFrameEvent` in
+ * `@elizaos/capacitor-talkmode`. Re-declared structurally here so this
+ * package does not take a build dep on the Capacitor plugin.
+ */
+export interface AudioFrameEvent {
+	/** Base64-encoded little-endian signed 16-bit mono PCM for this frame. */
+	pcm16: string;
+	/** Sample rate of the captured PCM in Hz (e.g. 16000). */
+	sampleRate: number;
+	/** Channel count (always 1 — mono). */
+	channels: number;
+	/** Number of PCM samples in this frame (`pcm16` byte length / 2). */
+	samples: number;
+	/** RMS amplitude of this frame, normalized 0..1. */
+	rms: number;
+	/** Monotonic capture timestamp for this frame, ms. */
+	timestamp: number;
+	/** Running index of this frame since capture started (0-based). */
+	frameIndex: number;
+}
+
+/** The sample rate every voice model in this pipeline is dimensioned for. */
+export const AUDIO_FRAME_PIPELINE_SAMPLE_RATE = 16_000;
+
+export class AudioFrameDecodeError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "AudioFrameDecodeError";
+	}
+}
+
+/**
+ * Decode an `audioFrame` payload into a Float32 [-1, 1] window. This is the
+ * single boundary that understands the base64 LE-s16 wire format.
+ *
+ * The native capture path only ever produces 16 kHz mono; this asserts that
+ * invariant rather than resampling silently (the downstream Silero/WeSpeaker
+ * graphs are 16 kHz-only — a wrong rate is a bug to surface, not paper over).
+ */
+export function decodeAudioFramePcm(frame: AudioFrameEvent): Float32Array {
+	if (frame.channels !== 1) {
+		throw new AudioFrameDecodeError(
+			`[audio-frame-consumer] expected mono (channels=1); got channels=${frame.channels}`,
+		);
+	}
+	if (frame.sampleRate !== AUDIO_FRAME_PIPELINE_SAMPLE_RATE) {
+		throw new AudioFrameDecodeError(
+			`[audio-frame-consumer] expected ${AUDIO_FRAME_PIPELINE_SAMPLE_RATE} Hz; got ${frame.sampleRate} Hz. Capture at 16 kHz (startAudioFrames default).`,
+		);
+	}
+	const bytes = base64ToBytes(frame.pcm16);
+	if (bytes.length % 2 !== 0) {
+		throw new AudioFrameDecodeError(
+			`[audio-frame-consumer] PCM byte length ${bytes.length} is odd — not a whole number of s16 samples`,
+		);
+	}
+	const sampleCount = bytes.length >> 1;
+	// Read LE-s16 over the decoded bytes. A DataView reads the bytes regardless
+	// of the host's native endianness, so this is correct on any platform.
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const out = new Float32Array(sampleCount);
+	for (let i = 0; i < sampleCount; i += 1) {
+		out[i] = view.getInt16(i * 2, true) / 32_768;
+	}
+	return out;
+}
+
+/**
+ * Decode base64 → bytes without assuming a runtime global. Prefers Node/Bun
+ * `Buffer`; falls back to `atob` (browsers / web workers).
+ */
+function base64ToBytes(b64: string): Uint8Array {
+	const maybeBuffer = (
+		globalThis as { Buffer?: { from(s: string, enc: string): Uint8Array } }
+	).Buffer;
+	if (maybeBuffer) {
+		const buf = maybeBuffer.from(b64, "base64");
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	}
+	const atobFn = (globalThis as { atob?: (s: string) => string }).atob;
+	if (!atobFn) {
+		throw new AudioFrameDecodeError(
+			"[audio-frame-consumer] no base64 decoder available (neither Buffer nor atob)",
+		);
+	}
+	const binary = atobFn(b64);
+	const out = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i);
+	return out;
+}
+
+// ---------------------------------------------------------------------------
+// VadDetector structural view (injectable)
+// ---------------------------------------------------------------------------
+
+/**
+ * The structural slice of `VadDetector` the consumer needs. Taking the
+ * structural view (not the concrete class) keeps the consumer testable with a
+ * fake VAD and avoids pulling the optional native VAD surface into callers
+ * that only want to feed frames.
+ */
+export interface VadSegmenter {
+	/** True while a speech segment (incl. its pause hangover) is open. */
+	readonly inSpeech: boolean;
+	/** Subscribe to the authoritative VAD timeline. Returns an unsubscribe fn. */
+	onVadEvent(listener: (event: VadEvent) => void): () => void;
+	/** Feed one mic frame; resolves once its windows are processed. */
+	pushFrame(frame: PcmFrame): Promise<void>;
+	/** Flush trailing samples and finalize any open segment. */
+	flush(): Promise<void>;
+	/** Clear all state at a hard boundary. */
+	reset(): void;
+}
+
+/**
+ * The structural slice of `VoiceAttributionPipeline` the consumer needs.
+ */
+export interface AttributionPipelineLike {
+	attribute(
+		req: Parameters<VoiceAttributionPipeline["attribute"]>[0],
+	): Promise<VoiceAttributionOutput>;
+}
+
+/**
+ * The structural slice of `IAgentRuntime` the consumer needs:
+ * `handleLiveVoiceAttribution` calls `emitEvent`.
+ */
+export interface RuntimeEventSink {
+	emitEvent(type: unknown, payload: Record<string, unknown>): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Consumer
+// ---------------------------------------------------------------------------
+
+export interface AudioFrameConsumerDeps {
+	/** Turn-segmentation VAD (drives speech-start/pause/end). */
+	vad: VadSegmenter;
+	/** Diarization + speaker-attribution pipeline. */
+	pipeline: AttributionPipelineLike;
+	/** Runtime event sink for VOICE_TURN_OBSERVED. */
+	runtime: RuntimeEventSink;
+}
+
+export interface AudioFrameConsumerConfig {
+	/** Source metadata stamped onto every attributed turn. */
+	source?: VoiceInputSource;
+	/** Gating options forwarded to `handleLiveVoiceAttribution` per turn. */
+	attributionOptions?: HandleLiveVoiceAttributionOptions;
+	/**
+	 * Hard cap on a single buffered turn, in seconds. A speaker who never
+	 * triggers `speech-end` (e.g. continuous noise) must not grow the buffer
+	 * without bound. When exceeded the turn is force-finalized. Default 30 s.
+	 */
+	maxTurnSeconds?: number;
+	/**
+	 * Pre-roll seconds of audio kept before `speech-start` so the onset of the
+	 * first word (which the VAD only confirms a window or two in) is not clipped
+	 * out of the attribution buffer. Default 0.3 s.
+	 */
+	preRollSeconds?: number;
+}
+
+/** A finalized, attributed turn the consumer surfaces to its caller. */
+export interface AttributedTurn {
+	turnId: string;
+	output: VoiceAttributionOutput;
+	signal: VoiceTurnSignal;
+	/** Turn span in the mic-clock (frame `timestamp`) domain. */
+	startedAtMs: number;
+	endedAtMs: number;
+	/** Total buffered turn samples that were attributed. */
+	samples: number;
+}
+
+export type AttributedTurnListener = (turn: AttributedTurn) => void;
+
+/**
+ * Drives the `audioFrame` → VAD turn-segmentation → attribution → signal
+ * pipeline. One instance per capture session.
+ *
+ * Frame ingestion is serialized through the injected VAD's `pushFrame`
+ * (which itself serializes the Silero forward pass), so `onAudioFrame` is
+ * safe to fire-and-forget from a Capacitor event listener; turns surface in
+ * order via `onTurn`.
+ */
+export class AudioFrameConsumer {
+	private readonly vad: VadSegmenter;
+	private readonly pipeline: AttributionPipelineLike;
+	private readonly runtime: RuntimeEventSink;
+	private readonly source: VoiceInputSource | undefined;
+	private readonly attributionOptions: HandleLiveVoiceAttributionOptions;
+	private readonly maxTurnSamples: number;
+	private readonly preRollSamples: number;
+	private readonly unsubscribeVad: () => void;
+	private readonly turnListeners = new Set<AttributedTurnListener>();
+
+	/** Float32 chunks of the in-flight turn, oldest first. */
+	private turnChunks: Float32Array[] = [];
+	private turnSamples = 0;
+	/** Rolling pre-roll ring (frames captured before speech-start). */
+	private preRoll: Float32Array[] = [];
+	private preRollSampleCount = 0;
+	private capturing = false;
+	private turnSeq = 0;
+	private turnStartedAtMs = 0;
+	private lastFrameEndMs = 0;
+	/** Serialized attribution chain so turns finalize one at a time, in order. */
+	private attributing: Promise<void> = Promise.resolve();
+	private closed = false;
+
+	/** Count of frames that failed to decode (surfaced via getters, not thrown). */
+	droppedFrames = 0;
+
+	constructor(
+		deps: AudioFrameConsumerDeps,
+		config: AudioFrameConsumerConfig = {},
+	) {
+		this.vad = deps.vad;
+		this.pipeline = deps.pipeline;
+		this.runtime = deps.runtime;
+		this.source = config.source;
+		this.attributionOptions = config.attributionOptions ?? {};
+		const sr = AUDIO_FRAME_PIPELINE_SAMPLE_RATE;
+		this.maxTurnSamples = Math.max(
+			sr,
+			Math.round((config.maxTurnSeconds ?? 30) * sr),
+		);
+		this.preRollSamples = Math.max(
+			0,
+			Math.round((config.preRollSeconds ?? 0.3) * sr),
+		);
+		this.unsubscribeVad = this.vad.onVadEvent((event) =>
+			this.onVadEvent(event),
+		);
+	}
+
+	/** True while a turn is being buffered (between speech-start and speech-end). */
+	get inTurn(): boolean {
+		return this.capturing;
+	}
+
+	/** Subscribe to finalized attributed turns. Returns an unsubscribe fn. */
+	onTurn(listener: AttributedTurnListener): () => void {
+		this.turnListeners.add(listener);
+		return () => this.turnListeners.delete(listener);
+	}
+
+	/**
+	 * Feed one decoded-or-raw `audioFrame`. Accepts either the wire-format
+	 * `AudioFrameEvent` (decoded here) or a pre-decoded Float32 window with the
+	 * frame's mic-clock timestamp. Resolves once the frame's VAD windows are
+	 * processed.
+	 */
+	async onAudioFrame(frame: AudioFrameEvent): Promise<void> {
+		if (this.closed) return;
+		let pcm: Float32Array;
+		try {
+			pcm = decodeAudioFramePcm(frame);
+		} catch (err) {
+			this.droppedFrames += 1;
+			throw err instanceof AudioFrameDecodeError
+				? err
+				: new AudioFrameDecodeError(
+						`[audio-frame-consumer] frame decode failed: ${
+							err instanceof Error ? err.message : String(err)
+						}`,
+					);
+		}
+		await this.pushDecodedFrame(pcm, frame.timestamp);
+	}
+
+	/**
+	 * Feed a pre-decoded Float32 16 kHz window with its mic-clock timestamp
+	 * (ms). The decode boundary already ran; used by transports that decode
+	 * upstream and by the host harness.
+	 */
+	async pushDecodedFrame(
+		pcm: Float32Array,
+		timestampMs: number,
+	): Promise<void> {
+		if (this.closed) return;
+		this.lastFrameEndMs =
+			timestampMs + (pcm.length / AUDIO_FRAME_PIPELINE_SAMPLE_RATE) * 1000;
+		if (this.capturing) {
+			this.appendTurnChunk(pcm);
+		} else {
+			this.appendPreRoll(pcm);
+		}
+		await this.vad.pushFrame({
+			pcm,
+			sampleRate: AUDIO_FRAME_PIPELINE_SAMPLE_RATE,
+			timestampMs,
+		});
+	}
+
+	/**
+	 * Flush the VAD (finalize any open segment) and await all pending
+	 * attribution. Call at end-of-capture so a trailing utterance is not lost.
+	 */
+	async flush(): Promise<void> {
+		if (this.closed) return;
+		await this.vad.flush();
+		await this.attributing;
+	}
+
+	/** Release listeners and clear all buffers. Idempotent. */
+	async close(): Promise<void> {
+		if (this.closed) return;
+		this.closed = true;
+		this.unsubscribeVad();
+		await this.attributing;
+		this.turnListeners.clear();
+		this.turnChunks = [];
+		this.preRoll = [];
+		this.turnSamples = 0;
+		this.preRollSampleCount = 0;
+	}
+
+	// ---- VAD event handling ------------------------------------------------
+
+	private onVadEvent(event: VadEvent): void {
+		switch (event.type) {
+			case "speech-start":
+				this.beginTurn(event.timestampMs);
+				break;
+			case "speech-end":
+				this.finalizeTurn(event.timestampMs);
+				break;
+			// speech-active / speech-pause / blip do not alter buffering: PCM
+			// keeps accumulating through pauses (mid-utterance micro-silences are
+			// part of the turn), and a `blip` never opened a turn.
+			default:
+				break;
+		}
+	}
+
+	private beginTurn(startedAtMs: number): void {
+		if (this.capturing) return;
+		this.capturing = true;
+		this.turnStartedAtMs = startedAtMs;
+		// Seed the turn with the pre-roll so the leading word isn't clipped.
+		this.turnChunks = this.preRoll;
+		this.turnSamples = this.preRollSampleCount;
+		this.preRoll = [];
+		this.preRollSampleCount = 0;
+	}
+
+	private finalizeTurn(endedAtMs: number): void {
+		if (!this.capturing) return;
+		this.capturing = false;
+		const chunks = this.turnChunks;
+		const total = this.turnSamples;
+		this.turnChunks = [];
+		this.turnSamples = 0;
+		if (total === 0) return;
+		const pcm = concatFloat32(chunks, total);
+		const turnId = `aframe_${this.turnSeq++}`;
+		const startedAtMs = this.turnStartedAtMs;
+		// Serialize attribution so turns surface in order and a slow turn can't
+		// interleave with the next one's buffer.
+		this.attributing = this.attributing.then(() =>
+			this.attributeTurn({ turnId, pcm, startedAtMs, endedAtMs }),
+		);
+	}
+
+	private async attributeTurn(args: {
+		turnId: string;
+		pcm: Float32Array;
+		startedAtMs: number;
+		endedAtMs: number;
+	}): Promise<void> {
+		const output = await this.pipeline.attribute({
+			turnId: args.turnId,
+			pcm: args.pcm,
+			startedAtMs: args.startedAtMs,
+			endedAtMs: args.endedAtMs,
+			...(this.source ? { source: this.source } : {}),
+		});
+		const signal = await handleLiveVoiceAttribution(
+			this.runtime as Parameters<typeof handleLiveVoiceAttribution>[0],
+			output,
+			this.attributionOptions,
+		);
+		const turn: AttributedTurn = {
+			turnId: args.turnId,
+			output,
+			signal,
+			startedAtMs: args.startedAtMs,
+			endedAtMs: args.endedAtMs,
+			samples: args.pcm.length,
+		};
+		for (const listener of this.turnListeners) listener(turn);
+	}
+
+	// ---- buffering ---------------------------------------------------------
+
+	private appendTurnChunk(pcm: Float32Array): void {
+		this.turnChunks.push(pcm);
+		this.turnSamples += pcm.length;
+		// Hard cap: force-finalize a runaway turn at the current frame edge.
+		if (this.turnSamples >= this.maxTurnSamples) {
+			this.finalizeTurn(this.lastFrameEndMs);
+			this.vad.reset();
+		}
+	}
+
+	private appendPreRoll(pcm: Float32Array): void {
+		if (this.preRollSamples === 0) return;
+		this.preRoll.push(pcm);
+		this.preRollSampleCount += pcm.length;
+		// Drop oldest pre-roll chunks once over the pre-roll budget.
+		while (
+			this.preRoll.length > 1 &&
+			this.preRollSampleCount - this.preRoll[0].length >= this.preRollSamples
+		) {
+			const dropped = this.preRoll.shift();
+			if (dropped) this.preRollSampleCount -= dropped.length;
+		}
+	}
+}
+
+/** Concatenate Float32 chunks into a single buffer of known total length. */
+function concatFloat32(
+	chunks: readonly Float32Array[],
+	total: number,
+): Float32Array {
+	const out = new Float32Array(total);
+	let cursor = 0;
+	for (const c of chunks) {
+		out.set(c, cursor);
+		cursor += c.length;
+	}
+	return out;
+}
+
+/**
+ * Re-export of the producer's emit args, so a consumer caller can construct a
+ * VOICE_TURN_OBSERVED payload directly when wiring a custom transport without
+ * importing the runtime subpath twice.
+ */
+export type { EmitVoiceTurnObservedArgs };

package/src/services/voice/barge-in.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Barge-in controller — distinguishes a blip from real speech while the
+ * agent is talking, and turns that into TTS pause/resume/hard-stop plus an
+ * LLM-generation abort.
+ *
+ * Inputs:
+ *   - the `VadEvent` stream from `VadDetector` (subscribe via `bindVad()`),
+ *   - W2's ASR word-confirm callback (`onWordsDetected()` — the
+ *     `WordsDetectedSink` contract).
+ *
+ * Behaviour while the agent is speaking (`agentSpeaking === true`):
+ *   - `speech-active`  → emit `pause-tts`. (Provisional — could still be a
+ *                        blip; the energy-duration heuristic guesses, ASR
+ *                        confirms.)
+ *   - `blip` (or a short `speech-end` before any words)
+ *                      → emit `resume-tts`. The agent keeps talking.
+ *   - `onWordsDetected({wordCount ≥ 1})` → emit `hard-stop` with a fresh
+ *                        `BargeInCancelToken`. Hard-stop means: cancel TTS
+ *                        *and* abort the in-flight LLM / MTP drafter
+ *                        generation. The engine layer (W9) threads
+ *                        `token.signal` into `dispatcher.generate` and polls
+ *                        `token.cancelled` at kernel boundaries.
+ *   - `speech-end` with a long-enough segment but no ASR words yet →
+ *                        treated as words-pending: emit `hard-stop` only
+ *                        once ASR confirms; if ASR never confirms within
+ *                        `wordsGraceMs`, resume TTS (it was non-speech the
+ *                        Silero VAD let through).
+ *
+ * Legacy API (still used by `VoiceScheduler` and `EngineVoiceBridge`):
+ *   `attach({onCancel})`, `onMicActive()`, `cancelSignal()`, `reset()` — a
+ *   thin "everything cancelled" path. `onMicActive()` is now equivalent to
+ *   `hardStop("manual")`.
+ *
+ * No fallback sludge: a `hard-stop` always carries a real `AbortSignal`; the
+ * controller never swallows a VAD event.
+ */
+import type { BargeInCancelToken, BargeInSignalListener, VadEventListener, WordsDetectedSink } from "./types";
+/** Minimal structural view of `VadDetector` — avoids a module dependency on
+ *  `vad.ts` (which pulls in the fused `libelizainference` VAD FFI surface). */
+interface VadEventSource {
+    onVadEvent(listener: VadEventListener): () => void;
+}
+export interface BargeInListener {
+    onCancel(): void;
+}
+export interface CancelSignal {
+    cancelled: boolean;
+}
+export interface BargeInControllerConfig {
+    /**
+     * After a `speech-active` (TTS paused) with no ASR word confirmation,
+     * resume TTS if ASR has not reported ≥1 word within this window. Default
+     * 600 ms. Long enough for a streaming ASR partial; short enough that a
+     * cough doesn't keep the agent muted.
+     */
+    wordsGraceMs?: number;
+}
+export declare class BargeInController implements WordsDetectedSink {
+    private readonly listeners;
+    private readonly signalListeners;
+    private readonly wordsGraceMs;
+    /** Legacy single-shot cancel flag, reset by `reset()`. */
+    private signal;
+    /** True while the agent's TTS is playing. The turn controller / scheduler
+     *  flips this via `setAgentSpeaking()`. Barge-in logic only acts while
+     *  this is true. */
+    private agentSpeaking;
+    /** True while we have emitted `pause-tts` and are waiting on the
+     *  blip-vs-words decision. */
+    private awaitingWordConfirm;
+    private wordConfirmDeadlineTimer;
+    private wordConfirmExpiresAtMs;
+    private lastEventTimestampMs;
+    private vadUnsub;
+    constructor(config?: BargeInControllerConfig);
+    /** Subscribe to `pause-tts` / `resume-tts` / `hard-stop`. */
+    onSignal(listener: BargeInSignalListener): () => void;
+    /** Wire this controller to a `VadDetector`. Returns an unsubscribe fn. */
+    bindVad(detector: VadEventSource): () => void;
+    unbindVad(): void;
+    /** The turn controller flips this when TTS starts/stops playing. */
+    setAgentSpeaking(speaking: boolean): void;
+    get isAgentSpeaking(): boolean;
+    private onVadEvent;
+    onWordsDetected(args: {
+        wordCount: number;
+        partialText: string;
+        timestampMs: number;
+    }): void;
+    /**
+     * Cancel TTS + abort the in-flight LLM / drafter generation. Returns the
+     * `BargeInCancelToken` whose `signal` the engine layer aborts on. Idempotent
+     * within a single barge-in episode — calling it again returns the same
+     * token until `reset()`.
+     */
+    hardStop(reason?: NonNullable<BargeInCancelToken["reason"]>, timestampMs?: number): BargeInCancelToken;
+    private activeToken;
+    /** The cancel token for the current barge-in episode (null until a
+     *  `hard-stop`). The engine threads `.signal` into generation. */
+    currentCancelToken(): BargeInCancelToken | null;
+    /** @deprecated Use `currentCancelToken()`; kept for `VoiceScheduler`. */
+    cancelSignal(): CancelSignal;
+    attach(listener: BargeInListener): () => void;
+    /** @deprecated Equivalent to `hardStop("manual")`; kept for the bridge. */
+    onMicActive(): void;
+    reset(): void;
+    private emitSignal;
+    private armWordConfirmDeadline;
+    private clearWordConfirm;
+}
+export {};
+//# sourceMappingURL=barge-in.d.ts.map

package/src/services/voice/barge-in.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barge-in.d.ts","sourceRoot":"","sources":["barge-in.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EACX,kBAAkB,EAElB,qBAAqB,EAErB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,SAAS,CAAC;AAEjB;+EAC+E;AAC/E,UAAU,cAAc;IACvB,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI,CAAC;CACnD;AAID,MAAM,WAAW,eAAe;IAC/B,QAAQ,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC5B,SAAS,EAAE,OAAO,CAAC;CACnB;AAmCD,MAAM,WAAW,uBAAuB;IACvC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,iBAAkB,YAAW,iBAAiB;IAC1D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IACxD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IACpE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC,0DAA0D;IAC1D,OAAO,CAAC,MAAM,CAAsC;IAEpD;;wBAEoB;IACpB,OAAO,CAAC,aAAa,CAAS;IAC9B;kCAC8B;IAC9B,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAuB;IACrD,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,MAAM,GAAE,uBAA4B;IAMhD,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAKrD,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,IAAI;IAM7C,SAAS,IAAI,IAAI;IAOjB,oEAAoE;IACpE,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAUzC,IAAI,eAAe,IAAI,OAAO,CAE7B;IAID,OAAO,CAAC,UAAU;IA8ClB,eAAe,CAAC,IAAI,EAAE;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACpB,GAAG,IAAI;IAiBR;;;;;OAKG;IACH,QAAQ,CACP,MAAM,GAAE,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAY,EAC5D,WAAW,GAAE,MAAgD,GAC3D,kBAAkB;IAkBrB,OAAO,CAAC,WAAW,CAAmC;IAEtD;sEACkE;IAClE,kBAAkB,IAAI,kBAAkB,GAAG,IAAI;IAM/C,yEAAyE;IACzE,YAAY,IAAI,YAAY;IAI5B,MAAM,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAK7C,2EAA2E;IAC3E,WAAW,IAAI,IAAI;IAInB,KAAK,IAAI,IAAI;IASb,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,sBAAsB;IA0B9B,OAAO,CAAC,gBAAgB;CASxB"}