@burdenoff/fe-libs 2026.1005.1 → 2026.1005.3

package/dist/shared/assistant/voice/handsfree/audioTrackTransport.js

@@ -0,0 +1,98 @@
+//#region src/shared/assistant/voice/handsfree/audioTrackTransport.ts
+var e = .3, t = 1500;
+function n(t) {
+	let n = t.now ?? (() => Date.now()), r = null, i = null, a = null, o = null, s = "en-US", c = null, l = !1, u = null, d = 0, f = null, p = (e) => {
+		!i || !a || (i.gain.cancelScheduledValues(a.currentTime), i.gain.setTargetAtTime(e, a.currentTime, .005));
+	}, m = () => {
+		if (!l || !c) return;
+		let e = t.createRecognition();
+		if (!e) {
+			o?.onError({
+				code: "unavailable",
+				retryable: !1
+			});
+			return;
+		}
+		r = e, e.lang = s, e.continuous = !0, e.interimResults = !0, e.onresult = (e) => {
+			let t = u ?? (f && n() - d <= 1500 ? f : null);
+			if (t) for (let n = e.resultIndex; n < e.results.length; n += 1) {
+				let r = e.results[n], i = r?.[0]?.transcript?.trim() ?? "";
+				!r || !i || o?.onTranscript({
+					text: i,
+					final: r.isFinal,
+					utteranceId: t.utteranceId,
+					epoch: t.epoch,
+					language: s
+				});
+			}
+		}, e.onerror = (e) => {
+			(e.error === "not-allowed" || e.error === "service-not-allowed") && (l = !1, o?.onError({
+				code: "not-allowed",
+				retryable: !1
+			}));
+		}, e.onend = () => {
+			l && r === e && m();
+		};
+		try {
+			e.start(c);
+		} catch {
+			o?.onError({
+				code: "unavailable",
+				retryable: !1
+			});
+		}
+	};
+	return {
+		kind: "audio-track",
+		recognitionOwner: "transport",
+		keepsOpeningWords: !0,
+		async start(t, n, r) {
+			if (!t) {
+				r.onError({
+					code: "unavailable",
+					retryable: !1
+				});
+				return;
+			}
+			o = r, s = n, a = t.context;
+			let u = t.context.createDelay(1);
+			u.delayTime.value = e, i = t.context.createGain(), i.gain.value = 0;
+			let d = t.context.createMediaStreamDestination();
+			t.micSource.connect(u), u.connect(i), i.connect(d), c = d.stream.getAudioTracks()[0] ?? null, l = !0, m();
+		},
+		openUtterance(e) {
+			u = {
+				utteranceId: e.utteranceId,
+				epoch: e.epoch
+			}, f = u, p(1);
+		},
+		pushFrame() {},
+		closeUtterance(e) {
+			if (u?.utteranceId !== e) return;
+			d = n(), u = null;
+			let t = e;
+			setTimeout(() => {
+				u === null && f?.utteranceId === t && p(0);
+			}, 400);
+		},
+		cancelUtterance(e) {
+			u?.utteranceId === e && (u = null), f?.utteranceId === e && (f = null), p(0);
+		},
+		stop() {
+			l = !1, u = null, f = null;
+			let e = r;
+			if (r = null, e) {
+				e.onresult = null, e.onend = null, e.onerror = null;
+				try {
+					e.abort();
+				} catch {}
+			}
+			try {
+				i?.disconnect();
+			} catch {}
+			c?.stop(), c = null;
+		}
+	};
+}
+//#endregion
+export { e as BRANCH_DELAY_S, t as TRAILING_RESULT_MS, n as createAudioTrackTransport };

package/dist/shared/assistant/voice/handsfree/backendStreamTransport.d.ts

@@ -0,0 +1,34 @@
+import { SttErrorCode, SttTransport } from './sttTransport';
+/** What the transport needs of a WebSocket; `handsFreeRuntime` adapts the real one. */
+export interface SocketLike {
+    readonly readyState: number;
+    send(data: string | ArrayBufferLike | ArrayBufferView): void;
+    close(code?: number): void;
+    listen(handlers: SocketHandlers): void;
+}
+export interface SocketHandlers {
+    open(): void;
+    message(data: unknown): void;
+    close(code: number): void;
+    error(): void;
+}
+export interface StreamTicket {
+    ticket: string;
+    wsUrl: string;
+}
+export interface BackendStreamDeps {
+    fetchTicket: () => Promise<StreamTicket>;
+    createSocket: (url: string, protocols: string[]) => SocketLike;
+    /** Languages sent with each utterance: the user's input language, then en-IN. */
+    languages: (language: string) => string[];
+}
+/** The gateway's frame cap is 8 KB; stay well under it. */
+export declare const MAX_SEND_BYTES = 6400;
+export declare const CLOSE_CODE_ERRORS: Readonly<Record<number, {
+    code: SttErrorCode;
+    retryable: boolean;
+}>>;
+/** Concatenate frames into chunks of at most `MAX_SEND_BYTES`. */
+export declare function chunkFrames(frames: readonly Int16Array[]): Int16Array[];
+export declare function createBackendStreamTransport(deps: BackendStreamDeps): SttTransport;
+//# sourceMappingURL=backendStreamTransport.d.ts.map

package/dist/shared/assistant/voice/handsfree/backendStreamTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backendStreamTransport.d.ts","sourceRoot":"","sources":["../../../../../src/shared/assistant/voice/handsfree/backendStreamTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAEV,YAAY,EACZ,YAAY,EAEb,MAAM,gBAAgB,CAAC;AAExB,uFAAuF;AACvF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,eAAe,GAAG,IAAI,CAAC;IAC7D,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,IAAI,CAAC;IACb,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC;IACzC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,UAAU,CAAC;IAC/D,iFAAiF;IACjF,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;CAC3C;AAED,2DAA2D;AAC3D,eAAO,MAAM,cAAc,OAAO,CAAC;AAGnC,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CACtC,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAO3D,CAAC;AASF,kEAAkE;AAClE,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,CAgBvE;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,iBAAiB,GACtB,YAAY,CAyId"}

package/dist/shared/assistant/voice/handsfree/backendStreamTransport.js

@@ -0,0 +1,130 @@
+//#region src/shared/assistant/voice/handsfree/backendStreamTransport.ts
+var e = 6400, t = 1, n = {
+	4401: {
+		code: "auth",
+		retryable: !1
+	},
+	4408: {
+		code: "closed",
+		retryable: !0
+	},
+	4413: {
+		code: "upstream",
+		retryable: !1
+	},
+	4429: {
+		code: "quota",
+		retryable: !1
+	},
+	4500: {
+		code: "upstream",
+		retryable: !0
+	}
+}, r = (e) => typeof e == "object" && e && !Array.isArray(e) ? e : null;
+function i(t) {
+	let n = Math.floor(e / 2), r = [], i = [], a = () => {
+		i.length > 0 && r.push(Int16Array.from(i)), i = [];
+	};
+	for (let e of t) for (let t of e) i.push(t), i.length === n && a();
+	return a(), r;
+}
+function a(e) {
+	let a = null, o = null, s = "en-IN", c = null, l = null, u = null, d = (e, t) => {
+		o?.onError({
+			code: e,
+			retryable: t
+		});
+	}, f = () => new Promise((t) => {
+		e.fetchTicket().then(({ ticket: i, wsUrl: c }) => {
+			let f = e.createSocket(c, [`bearer.${i}`]);
+			a = f, f.listen({
+				open: () => t(!0),
+				error: () => t(!1),
+				close: (e) => {
+					a === f && (a = null), t(!1);
+					let r = n[e];
+					r ? d(r.code, r.retryable) : l && d("closed", !0);
+				},
+				message: (e) => {
+					if (typeof e != "string") return;
+					let t;
+					try {
+						t = r(JSON.parse(e));
+					} catch {
+						return;
+					}
+					if (t) if (t.t === "partial" || t.t === "final") {
+						if (typeof t.text != "string" || typeof t.utteranceId != "string" || typeof t.epoch != "number") return;
+						t.t === "final" && u === t.utteranceId && (u = null), o?.onTranscript({
+							text: t.text,
+							final: t.t === "final",
+							utteranceId: t.utteranceId,
+							epoch: t.epoch,
+							language: typeof t.lang == "string" ? t.lang : s
+						});
+					} else t.t === "error" && d(t.code === "quota" ? "quota" : t.code === "auth" ? "auth" : "upstream", t.retryable === !0);
+				}
+			});
+		}).catch(() => {
+			d("auth", !1), t(!1);
+		});
+	}), p = (e) => {
+		a && a.readyState === t && a.send(e);
+	};
+	return {
+		kind: "backend-stream",
+		recognitionOwner: "transport",
+		keepsOpeningWords: !0,
+		async start(e, t, n) {
+			o = n, s = t, c = f(), await c || d("unavailable", !1);
+		},
+		openUtterance(t) {
+			l = {
+				utteranceId: t.utteranceId,
+				epoch: t.epoch
+			};
+			let n = t.preRoll;
+			(c ?? Promise.resolve(!1)).then((r) => {
+				if (!(!r || l?.utteranceId !== t.utteranceId)) {
+					p(JSON.stringify({
+						t: "config",
+						v: 1,
+						utteranceId: t.utteranceId,
+						epoch: t.epoch,
+						langs: e.languages(s),
+						sampleRate: 16e3,
+						encoding: "s16le"
+					}));
+					for (let e of i(n)) p(e);
+				}
+			});
+		},
+		pushFrame(e) {
+			l && p(e);
+		},
+		closeUtterance(e) {
+			l?.utteranceId === e && (p(JSON.stringify({
+				t: "end",
+				utteranceId: e
+			})), u = e, l = null);
+		},
+		cancelUtterance(e) {
+			if (l?.utteranceId === e) l = null;
+			else if (u !== e) return;
+			u = null, p(JSON.stringify({
+				t: "cancel",
+				utteranceId: e
+			}));
+		},
+		stop() {
+			l = null;
+			let e = a;
+			a = null, c = null;
+			try {
+				e?.close(1e3);
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { n as CLOSE_CODE_ERRORS, e as MAX_SEND_BYTES, i as chunkFrames, a as createBackendStreamTransport };

package/dist/shared/assistant/voice/handsfree/bargeIn.d.ts

@@ -0,0 +1,43 @@
+import { VoiceSessionPhase } from '../voiceSession';
+export interface OnsetContext {
+    /** The viewer's "Hands-free interrupt (beta)" setting (or the test override). */
+    enabled: boolean;
+    muted: boolean;
+    phase: VoiceSessionPhase;
+    /** Sound from the assistant is coming out of the speaker right now. */
+    playbackAudible: boolean;
+}
+export type OnsetPlan = {
+    kind: "ignore";
+    reason: "disabled" | "muted" | "not-in-session";
+} | {
+    kind: "open-utterance";
+} | {
+    kind: "correction";
+} | {
+    kind: "barge-in";
+};
+export declare function planOnset(context: OnsetContext): OnsetPlan;
+/**
+ * Epoch guard. Every utterance opened at an onset gets a new epoch; every
+ * transcript carries the epoch of the utterance it came from. A transcript
+ * whose epoch is not the current one is a transport artifact (a late result of
+ * an utterance that was superseded) and is discarded BY EPOCH, never by looking
+ * at its words.
+ */
+export interface EpochGuard {
+    current(): number;
+    /** A new utterance opened: everything older is stale from now on. */
+    open(): number;
+    accepts(epoch: number): boolean;
+    /** Session ended or muted: nothing in flight may be delivered. */
+    invalidate(): void;
+}
+export declare function createEpochGuard(): EpochGuard;
+/** Nothing heard this long after a barge-in: show "say that again, or tap to replay". */
+export declare const NOTHING_HEARD_MS = 1500;
+/** Phantom barge-ins (nothing heard afterwards) in one session before falling back to tap-first. */
+export declare const PHANTOM_BARGE_INS_BEFORE_FALLBACK = 3;
+/** Whether a barge-in that produced no words counts against the session. */
+export declare function shouldFallBackToTap(phantomBargeIns: number): boolean;
+//# sourceMappingURL=bargeIn.d.ts.map

package/dist/shared/assistant/voice/handsfree/bargeIn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bargeIn.d.ts","sourceRoot":"","sources":["../../../../../src/shared/assistant/voice/handsfree/bargeIn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,WAAW,YAAY;IAC3B,iFAAiF;IACjF,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,iBAAiB,CAAC;IACzB,uEAAuE;IACvE,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,OAAO,GAAG,gBAAgB,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAEzB,wBAAgB,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAU1D;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,MAAM,CAAC;IAClB,qEAAqE;IACrE,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,kEAAkE;IAClE,UAAU,IAAI,IAAI,CAAC;CACpB;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAgB7C;AAED,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC,oGAAoG;AACpG,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAEnD,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAEpE"}

package/dist/shared/assistant/voice/handsfree/bargeIn.js

@@ -0,0 +1,32 @@
+//#region src/shared/assistant/voice/handsfree/bargeIn.ts
+function e(e) {
+	return e.enabled ? e.muted ? {
+		kind: "ignore",
+		reason: "muted"
+	} : e.phase === "idle" || e.phase === "ended" ? {
+		kind: "ignore",
+		reason: "not-in-session"
+	} : e.phase === "speaking" || e.playbackAudible ? { kind: "barge-in" } : e.phase === "thinking" ? { kind: "correction" } : { kind: "open-utterance" } : {
+		kind: "ignore",
+		reason: "disabled"
+	};
+}
+function t() {
+	let e = 0, t = !0;
+	return {
+		current: () => e,
+		open() {
+			return e += 1, t = !0, e;
+		},
+		accepts: (n) => t && n === e,
+		invalidate() {
+			e += 1, t = !1;
+		}
+	};
+}
+var n = 1500, r = 3;
+function i(e) {
+	return e >= 3;
+}
+//#endregion
+export { n as NOTHING_HEARD_MS, r as PHANTOM_BARGE_INS_BEFORE_FALLBACK, t as createEpochGuard, e as planOnset, i as shouldFallBackToTap };

package/dist/shared/assistant/voice/handsfree/captureWorklet.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The AudioWorklet that turns the microphone into 16 kHz PCM (BOFF-8613, H3).
+ *
+ * A worklet module is loaded from a URL, and this package cannot assume a
+ * bundler that emits a second entry file for it, so the processor is a SOURCE
+ * STRING that `micCapture` loads through a Blob URL. It has no imports and no
+ * access to this file's scope; everything it needs is inside the string.
+ *
+ * What it does, per render quantum (128 samples at the device rate):
+ *  - input 0 is the microphone, input 1 is the PLAYBACK REFERENCE bus (every
+ *    sound the assistant makes is also sent there). Both are measured over the
+ *    SAME samples, so the mic envelope and the reference envelope sit on one
+ *    clock and only a fixed room lag separates them;
+ *  - the microphone is decimated to 16 kHz with a windowed-sinc low-pass
+ *    (cutoff 7.2 kHz). Forcing `sampleRate: 16000` on the context is not
+ *    reliable across browsers, so the context runs at the device rate;
+ *  - 320-sample (20 ms) frames are posted as s16le with their RMS (dBFS), zero-
+ *    crossing rate and the reference RMS.
+ *
+ * The input buffer is preallocated; nothing is allocated per quantum.
+ *
+ * ★ The string is the SHIPPED code. The unit tests evaluate it with fake
+ * `AudioWorkletProcessor` / `registerProcessor` / `sampleRate` globals
+ * (`runCaptureWorkletForTest`) instead of testing a TypeScript copy of the
+ * maths, because a copy can be right while the string is wrong.
+ */
+/** Samples per frame at 16 kHz: 20 ms. */
+export declare const CAPTURE_FRAME_SAMPLES = 320;
+export declare const CAPTURE_SAMPLE_RATE = 16000;
+export declare const CAPTURE_FRAME_MS = 20;
+export declare const CAPTURE_PROCESSOR_NAME = "boff-handsfree-capture";
+/** What the worklet posts for each frame. */
+export interface CaptureFrameMessage {
+    /** s16le mono 16 kHz, `CAPTURE_FRAME_SAMPLES` samples. */
+    pcm: ArrayBuffer;
+    /** Microphone level over the frame, dBFS. */
+    rmsDb: number;
+    /** Reference-bus level over the same samples, dBFS (about -90 when silent). */
+    refDb: number;
+    /** Zero crossings per sample. */
+    zcr: number;
+    /** AudioContext time at the end of the frame, seconds. */
+    ctxTime: number;
+    seq: number;
+}
+export declare const CAPTURE_WORKLET_SOURCE = "\n\"use strict\";\nconst FRAME = 320;\nclass BoffHandsfreeCapture extends AudioWorkletProcessor {\n  constructor() {\n    super();\n    this.step = sampleRate / 16000;\n    this.half = 6 * this.step;\n    this.fc = 7200 / sampleRate;\n    this.buf = new Float32Array(Math.ceil(this.half * 2) + 4096);\n    this.len = 0;\n    this.pos = 0;\n    this.frame = new Float32Array(FRAME);\n    this.n = 0;\n    this.seq = 0;\n    this.refEnergy = 0;\n    this.refCount = 0;\n    this.stopped = false;\n    this.port.onmessage = (e) => { if (e.data && e.data.type === \"stop\") this.stopped = true; };\n  }\n  tap(d) {\n    const x = 2 * this.fc * d;\n    const s = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);\n    return 2 * this.fc * s * 0.5 * (1 + Math.cos(Math.PI * d / this.half));\n  }\n  emit() {\n    const pcm = new Int16Array(FRAME);\n    let energy = 0;\n    let crossings = 0;\n    for (let i = 0; i < FRAME; i++) {\n      const v = Math.max(-1, Math.min(1, this.frame[i]));\n      pcm[i] = Math.round(v * 32767);\n      energy += v * v;\n      if (i > 0 && (v >= 0) !== (this.frame[i - 1] >= 0)) crossings++;\n    }\n    const refMean = this.refCount > 0 ? this.refEnergy / this.refCount : 0;\n    this.port.postMessage({\n      pcm: pcm.buffer,\n      rmsDb: 10 * Math.log10(energy / FRAME + 1e-9),\n      refDb: 10 * Math.log10(refMean + 1e-9),\n      zcr: crossings / FRAME,\n      ctxTime: currentTime,\n      seq: this.seq++,\n    }, [pcm.buffer]);\n    this.n = 0;\n    this.refEnergy = 0;\n    this.refCount = 0;\n  }\n  process(inputs) {\n    if (this.stopped) return false;\n    const mic = inputs[0] && inputs[0][0];\n    if (!mic) return true;\n    const ref = inputs[1] && inputs[1][0];\n    if (ref) { for (let i = 0; i < ref.length; i++) this.refEnergy += ref[i] * ref[i]; }\n    this.refCount += mic.length;\n    if (this.len + mic.length > this.buf.length) {\n      const grown = new Float32Array((this.len + mic.length) * 2);\n      grown.set(this.buf.subarray(0, this.len));\n      this.buf = grown;\n    }\n    this.buf.set(mic, this.len);\n    this.len += mic.length;\n    while (this.pos + this.half < this.len) {\n      const from = Math.max(0, Math.ceil(this.pos - this.half));\n      const to = Math.floor(this.pos + this.half);\n      let acc = 0;\n      for (let i = from; i <= to; i++) acc += this.buf[i] * this.tap(i - this.pos);\n      this.frame[this.n++] = acc;\n      this.pos += this.step;\n      if (this.n === FRAME) this.emit();\n    }\n    const drop = Math.max(0, Math.floor(this.pos - this.half));\n    if (drop > 0) {\n      this.buf.copyWithin(0, drop, this.len);\n      this.len -= drop;\n      this.pos -= drop;\n    }\n    return true;\n  }\n}\nregisterProcessor(\"boff-handsfree-capture\", BoffHandsfreeCapture);\n";
+//# sourceMappingURL=captureWorklet.d.ts.map

package/dist/shared/assistant/voice/handsfree/captureWorklet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureWorklet.d.ts","sourceRoot":"","sources":["../../../../../src/shared/assistant/voice/handsfree/captureWorklet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,0CAA0C;AAC1C,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AACzC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAE/D,6CAA6C;AAC7C,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,GAAG,EAAE,WAAW,CAAC;IACjB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,sBAAsB,0tFAiFlC,CAAC"}

package/dist/shared/assistant/voice/handsfree/captureWorklet.js

@@ -0,0 +1,85 @@
+//#region src/shared/assistant/voice/handsfree/captureWorklet.ts
+var e = 320, t = 16e3, n = 20, r = "boff-handsfree-capture", i = `
+"use strict";
+const FRAME = 320;
+class BoffHandsfreeCapture extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.step = sampleRate / ${t};
+    this.half = 6 * this.step;
+    this.fc = 7200 / sampleRate;
+    this.buf = new Float32Array(Math.ceil(this.half * 2) + 4096);
+    this.len = 0;
+    this.pos = 0;
+    this.frame = new Float32Array(FRAME);
+    this.n = 0;
+    this.seq = 0;
+    this.refEnergy = 0;
+    this.refCount = 0;
+    this.stopped = false;
+    this.port.onmessage = (e) => { if (e.data && e.data.type === "stop") this.stopped = true; };
+  }
+  tap(d) {
+    const x = 2 * this.fc * d;
+    const s = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+    return 2 * this.fc * s * 0.5 * (1 + Math.cos(Math.PI * d / this.half));
+  }
+  emit() {
+    const pcm = new Int16Array(FRAME);
+    let energy = 0;
+    let crossings = 0;
+    for (let i = 0; i < FRAME; i++) {
+      const v = Math.max(-1, Math.min(1, this.frame[i]));
+      pcm[i] = Math.round(v * 32767);
+      energy += v * v;
+      if (i > 0 && (v >= 0) !== (this.frame[i - 1] >= 0)) crossings++;
+    }
+    const refMean = this.refCount > 0 ? this.refEnergy / this.refCount : 0;
+    this.port.postMessage({
+      pcm: pcm.buffer,
+      rmsDb: 10 * Math.log10(energy / FRAME + 1e-9),
+      refDb: 10 * Math.log10(refMean + 1e-9),
+      zcr: crossings / FRAME,
+      ctxTime: currentTime,
+      seq: this.seq++,
+    }, [pcm.buffer]);
+    this.n = 0;
+    this.refEnergy = 0;
+    this.refCount = 0;
+  }
+  process(inputs) {
+    if (this.stopped) return false;
+    const mic = inputs[0] && inputs[0][0];
+    if (!mic) return true;
+    const ref = inputs[1] && inputs[1][0];
+    if (ref) { for (let i = 0; i < ref.length; i++) this.refEnergy += ref[i] * ref[i]; }
+    this.refCount += mic.length;
+    if (this.len + mic.length > this.buf.length) {
+      const grown = new Float32Array((this.len + mic.length) * 2);
+      grown.set(this.buf.subarray(0, this.len));
+      this.buf = grown;
+    }
+    this.buf.set(mic, this.len);
+    this.len += mic.length;
+    while (this.pos + this.half < this.len) {
+      const from = Math.max(0, Math.ceil(this.pos - this.half));
+      const to = Math.floor(this.pos + this.half);
+      let acc = 0;
+      for (let i = from; i <= to; i++) acc += this.buf[i] * this.tap(i - this.pos);
+      this.frame[this.n++] = acc;
+      this.pos += this.step;
+      if (this.n === FRAME) this.emit();
+    }
+    const drop = Math.max(0, Math.floor(this.pos - this.half));
+    if (drop > 0) {
+      this.buf.copyWithin(0, drop, this.len);
+      this.len -= drop;
+      this.pos -= drop;
+    }
+    return true;
+  }
+}
+registerProcessor("${r}", BoffHandsfreeCapture);
+`;
+//#endregion
+export { n as CAPTURE_FRAME_MS, e as CAPTURE_FRAME_SAMPLES, r as CAPTURE_PROCESSOR_NAME, t as CAPTURE_SAMPLE_RATE, i as CAPTURE_WORKLET_SOURCE };

package/dist/shared/assistant/voice/handsfree/echoGate.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The playback-reference echo gate (BOFF-8613, H3).
+ *
+ * Browser echo cancellation is best effort: it varies by handset, output route
+ * and volume. So the app adds its own ACOUSTIC evidence, and never decides by
+ * text: whether a stretch of audio is the user is settled BEFORE any transcript
+ * exists. (Dropping words because they resemble the assistant's sentence is
+ * what made "keep 50, not 15" vanish; a genuine correction that repeats the
+ * assistant's words or quantities must be kept.)
+ *
+ * ★ WHY COHERENCE AND NOT A LEVEL RATIO. The first version of this gate compared
+ * the microphone LEVEL with the assistant's level plus a calibrated offset. The
+ * headless-browser test showed why that cannot work with the processing the
+ * capture asks for: automatic gain control pumps a quiet echo up to the same
+ * loudness as a person (a -44 dBFS echo came back at -18 dBFS, the level of a
+ * real talker), so "louder than the expected echo" fired on the assistant's own
+ * voice. The ratio is not stable; the SHAPE is. An echo is a delayed copy of the
+ * reference: its loudness envelope rises and falls with the assistant's, one
+ * fixed room lag later, whatever gain the processing applied. A person talking
+ * over the assistant does not follow it.
+ *
+ * Per playback:
+ *  1. CALIBRATE the lag (0-500 ms) over the first second: the lag at which the
+ *     mic envelope is most correlated with the reference envelope. Kept as a
+ *     PRIOR, so the next reply is gated from its first frame. With no prior yet,
+ *     onsets inside the first second of the very first reply cannot be
+ *     attributed and are refused (fail closed: a false barge-in is the most
+ *     visible failure, tap-to-interrupt is the fallback).
+ *  2. A frame is UNEXPLAINED by the reference when the correlation of the last
+ *     `windowFrames` mic levels with the lagged reference levels is below
+ *     `lowCorr`. The gate PASSES a frame after `lowRunFrames` consecutive
+ *     unexplained frames (a single dip is not enough: echo-only audio dips to
+ *     about 0.5 now and then). A reference that is silent over the window passes:
+ *     there is no echo to confuse the user with. A reference that is audible but
+ *     flat gives no shape to compare: refused.
+ *  3. With NO reference (the device `speechSynthesis` voice does not pass
+ *     through the browser's output graph) nothing can be attributed: refused
+ *     while it speaks. Tap-to-interrupt is the fallback there, and it is said so.
+ *
+ * Known limit, measured in the browser test and the design spike: this is
+ * envelope evidence, not an adaptive filter. A person who speaks in lock-step
+ * with the assistant's loudness pattern for a second is indistinguishable from
+ * an echo; the device kit is where handsets are measured.
+ */
+export interface EchoGateParams {
+    /** Frames the coherence is measured over (12 x 20 ms = 240 ms). */
+    windowFrames: number;
+    /** Correlation below this is "not following the reference". */
+    lowCorr: number;
+    /** Consecutive unexplained frames before a frame passes. */
+    lowRunFrames: number;
+    /** The same, with a headset hint (the echo path is usually absent). */
+    headsetLowRunFrames: number;
+    /** Frames of evidence before the lag can be estimated (50 x 20 ms = 1 s). */
+    calibFrames: number;
+    /** Longest lag searched, in frames (25 x 20 ms = 500 ms). */
+    maxLagFrames: number;
+    /** The best lag must correlate at least this well to be believed. */
+    minCalibCorr: number;
+    /** Frames the gate stays armed after playback stops (the room tail and the lag). */
+    tailFrames: number;
+    /** Levels are clamped to [floorDb, 0] before comparing envelopes. */
+    floorDb: number;
+    /** A reference at or below this over the window is silence. */
+    referenceSilentDb: number;
+    /** Mic p90 at or below this while the reference plays means no echo path. */
+    quietMicDb: number;
+    /** Envelope standard deviation (dB) below which a signal is "flat". */
+    flatStdDb: number;
+    /**
+     * The room rings after the assistant stops, and gain control lifts that tail, so the
+     * echo of a word outlasts the word: the reference is compared with a copy that falls
+     * by at most this many dB per frame (a tail model), not with the bare envelope.
+     */
+    tailDecayDbPerFrame: number;
+}
+export declare const DEFAULT_ECHO_GATE_PARAMS: Readonly<EchoGateParams>;
+export type GateReason = "no-playback" | "calibrating"
+/** The assistant is on the device voice: no reference exists, so nothing can be attributed. */
+ | "no-reference" | "reference-silent"
+/** No echo reaches the microphone (headphones, or a very good canceller). */
+ | "no-echo-path"
+/** The microphone follows the reference: this is the assistant, not the user. */
+ | "follows-reference"
+/** Audible reference without enough shape to compare. */
+ | "flat-reference"
+/** The microphone does not follow the reference: this may be the user. */
+ | "uncorrelated";
+export interface GateVerdict {
+    pass: boolean;
+    reason: GateReason;
+    /** Correlation of the last window with the lagged reference, when measured. */
+    coherence: number | null;
+}
+export declare class EchoGate {
+    private readonly params;
+    /** Clamped dBFS history, absolute index = `base` + position. */
+    private mic;
+    private ref;
+    /** `ref` with the room tail: falls by at most `tailDecayDbPerFrame` per frame. */
+    private tail;
+    private base;
+    private total;
+    private playing;
+    private hasReference;
+    private playStart;
+    private armedUntil;
+    private current;
+    private prior;
+    /** The reference plays but no echo reaches the microphone (this playback only). */
+    private noEchoPath;
+    private lowRun;
+    private headset;
+    constructor(params?: Partial<EchoGateParams>);
+    get isPlaying(): boolean;
+    /** True once a lag is known, i.e. the next reply is gated from its first frame. */
+    get hasPrior(): boolean;
+    /** What the last calibration found, for telemetry and the device kit. */
+    get calibration(): {
+        lagMs: number;
+        corr: number;
+    } | null;
+    setHeadset(headset: boolean): void;
+    /** The assistant started making sound. `withReference`: it passes through the reference bus. */
+    playbackStarted(withReference: boolean): void;
+    playbackStopped(): void;
+    /** Feed one frame; returns whether THIS frame may be the user's. */
+    pushFrame(micDb: number, refDb: number): GateVerdict;
+    private at;
+    /** The loudest of `array` over [absolute - span, absolute], ignoring what history no longer holds. */
+    private windowMax;
+    /** Correlation of mic[idx-w+1..idx] with the reference one lag earlier; null when history is short. */
+    private coherence;
+    /** Estimate the lag from the frames since playback began; sets `current` and `prior` when believable. */
+    private calibrate;
+    private trim;
+    /** Forget everything, including the prior (a new session, or the output route changed). */
+    reset(): void;
+}
+//# sourceMappingURL=echoGate.d.ts.map

package/dist/shared/assistant/voice/handsfree/echoGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echoGate.d.ts","sourceRoot":"","sources":["../../../../../src/shared/assistant/voice/handsfree/echoGate.ts"],"names":[],"mappings":"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"}