@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.3-beta.3

package/src/services/voice/__tests__/prefix-preserving-queue.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Tests for `PrefixPreservingQueue` — prefix-preserving TTS barge-in rollback.
+ *
+ * Core invariant: given a divergencePoint N, after `rollbackAt(N)`:
+ *   - chunks with tokenRange[1] <= N  are RETAINED
+ *   - chunks with tokenRange[0] >  N  are DROPPED
+ *   - chunks that straddle N           are RETAINED (best-effort, phrase granularity)
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+	PrefixPreservingQueue,
+	type TaggedAudioChunk,
+} from "../prefix-preserving-queue";
+
+function chunk(start: number, end: number, durationMs = 50): TaggedAudioChunk {
+	const pcm = new Float32Array(Math.ceil((durationMs / 1000) * 24_000));
+	return { pcm, tokenRange: [start, end], durationMs };
+}
+
+describe("PrefixPreservingQueue — basic queue operations", () => {
+	it("starts empty", () => {
+		const q = new PrefixPreservingQueue();
+		expect(q.size).toBe(0);
+		expect(q.snapshot()).toHaveLength(0);
+	});
+
+	it("size tracks enqueued chunks", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 2));
+		expect(q.size).toBe(1);
+		q.enqueue(chunk(3, 5));
+		expect(q.size).toBe(2);
+	});
+
+	it("clear() empties the queue and returns all chunks", () => {
+		const q = new PrefixPreservingQueue();
+		const c1 = chunk(0, 2);
+		const c2 = chunk(3, 5);
+		q.enqueue(c1);
+		q.enqueue(c2);
+		const cleared = q.clear();
+		expect(cleared).toHaveLength(2);
+		expect(cleared[0]).toBe(c1);
+		expect(cleared[1]).toBe(c2);
+		expect(q.size).toBe(0);
+	});
+
+	it("snapshot() does not mutate the queue", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 4));
+		const snap = q.snapshot();
+		expect(snap).toHaveLength(1);
+		expect(q.size).toBe(1);
+	});
+});
+
+describe("PrefixPreservingQueue — rollbackAt", () => {
+	it("retains chunks whose tokenRange[1] <= divergencePoint", () => {
+		const q = new PrefixPreservingQueue();
+		const c0 = chunk(0, 3); // end=3, fully before N=5
+		const c1 = chunk(4, 5); // end=5, exactly at N=5
+		q.enqueue(c0);
+		q.enqueue(c1);
+		const result = q.rollbackAt(5);
+		expect(result.retained).toContain(c0);
+		expect(result.retained).toContain(c1);
+		expect(result.dropped).toHaveLength(0);
+		expect(result.straddled).toHaveLength(0);
+	});
+
+	it("drops chunks whose tokenRange[0] > divergencePoint", () => {
+		const q = new PrefixPreservingQueue();
+		const c0 = chunk(0, 3); // retained
+		const c1 = chunk(6, 10); // start=6 > N=5 → dropped
+		q.enqueue(c0);
+		q.enqueue(c1);
+		const result = q.rollbackAt(5);
+		expect(result.retained).toContain(c0);
+		expect(result.dropped).toContain(c1);
+		expect(result.straddled).toHaveLength(0);
+	});
+
+	it("keeps straddling chunks (start<=N, end>N) and records them separately", () => {
+		const q = new PrefixPreservingQueue();
+		const c0 = chunk(0, 2); // fully before N=4 → retained
+		const c1 = chunk(3, 7); // straddles N=4 (start=3<=4, end=7>4) → retained+straddled
+		const c2 = chunk(8, 12); // fully after N=4 → dropped
+		q.enqueue(c0);
+		q.enqueue(c1);
+		q.enqueue(c2);
+		const result = q.rollbackAt(4);
+		expect(result.retained).toContain(c0);
+		expect(result.retained).toContain(c1);
+		expect(result.straddled).toContain(c1);
+		expect(result.dropped).toContain(c2);
+		expect(result.straddled).not.toContain(c0);
+	});
+
+	it("clears the queue after rollback", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 3));
+		q.enqueue(chunk(4, 8));
+		q.rollbackAt(5);
+		expect(q.size).toBe(0);
+	});
+
+	it("empty queue returns empty result", () => {
+		const q = new PrefixPreservingQueue();
+		const result = q.rollbackAt(10);
+		expect(result.retained).toHaveLength(0);
+		expect(result.dropped).toHaveLength(0);
+		expect(result.straddled).toHaveLength(0);
+		expect(result.retainedDurationMs).toBe(0);
+		expect(result.droppedDurationMs).toBe(0);
+	});
+
+	it("divergencePoint=0 retains only chunks ending at 0, drops the rest", () => {
+		const q = new PrefixPreservingQueue();
+		const c0 = chunk(0, 0, 20); // end=0, retained
+		const c1 = chunk(1, 5, 40); // start=1 > 0, dropped
+		q.enqueue(c0);
+		q.enqueue(c1);
+		const result = q.rollbackAt(0);
+		expect(result.retained).toContain(c0);
+		expect(result.dropped).toContain(c1);
+	});
+
+	it("sums durations correctly", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 2, 100)); // retained
+		q.enqueue(chunk(3, 5, 80)); // retained
+		q.enqueue(chunk(6, 9, 60)); // dropped
+		const result = q.rollbackAt(5);
+		expect(result.retainedDurationMs).toBe(180);
+		expect(result.droppedDurationMs).toBe(60);
+	});
+
+	it("all chunks retained when divergencePoint is very large", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 5));
+		q.enqueue(chunk(6, 10));
+		q.enqueue(chunk(11, 20));
+		const result = q.rollbackAt(999);
+		expect(result.retained).toHaveLength(3);
+		expect(result.dropped).toHaveLength(0);
+	});
+
+	it("all chunks dropped when divergencePoint is -1", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 5));
+		q.enqueue(chunk(6, 10));
+		const result = q.rollbackAt(-1);
+		// tokenRange[0]=0 > -1 → both dropped
+		expect(result.retained).toHaveLength(0);
+		expect(result.dropped).toHaveLength(2);
+	});
+
+	it("multiple rollbacks each clear the queue independently", () => {
+		const q = new PrefixPreservingQueue();
+		q.enqueue(chunk(0, 3));
+		q.enqueue(chunk(4, 7));
+		const r1 = q.rollbackAt(5);
+		expect(r1.retained).toHaveLength(2); // both at or straddle N=5
+		expect(q.size).toBe(0);
+
+		// Second rollback with fresh chunks.
+		q.enqueue(chunk(0, 2));
+		q.enqueue(chunk(10, 15));
+		const r2 = q.rollbackAt(8);
+		expect(r2.retained).toHaveLength(1);
+		expect(r2.dropped).toHaveLength(1);
+	});
+});
+
+describe("PrefixPreservingQueue — token-range boundary conditions", () => {
+	it("chunk ending exactly at N is retained (boundary inclusive)", () => {
+		const q = new PrefixPreservingQueue();
+		const c = chunk(3, 7);
+		q.enqueue(c);
+		const result = q.rollbackAt(7);
+		expect(result.retained).toContain(c);
+		expect(result.dropped).toHaveLength(0);
+	});
+
+	it("chunk starting exactly at N+1 is dropped (post-divergence)", () => {
+		const q = new PrefixPreservingQueue();
+		const c = chunk(8, 12);
+		q.enqueue(c);
+		const result = q.rollbackAt(7);
+		expect(result.dropped).toContain(c);
+		expect(result.retained).toHaveLength(0);
+	});
+
+	it("single-token chunk at exactly N is retained", () => {
+		const q = new PrefixPreservingQueue();
+		const c = chunk(5, 5);
+		q.enqueue(c);
+		expect(q.rollbackAt(5).retained).toContain(c);
+	});
+
+	it("single-token chunk one past N is dropped", () => {
+		const q = new PrefixPreservingQueue();
+		const c = chunk(6, 6);
+		q.enqueue(c);
+		expect(q.rollbackAt(5).dropped).toContain(c);
+	});
+});

package/src/services/voice/__tests__/streaming-asr.test.ts

@@ -0,0 +1,450 @@
+/**
+ * Streaming-ASR tests: LocalAgreement-2 word-level stabilization, sliding-window
+ * chunking (FfiBatchTranscriber mock), speech-pause → drafter wiring, and
+ * flush()-after-speech-end committed final.
+ *
+ * No real ASR model or native library is used. Tests that would require a live
+ * model are guarded with `it.skipIf(true, ...)` per the task spec (no models >2B).
+ */
+
+import { describe, expect, it } from "vitest";
+import { MockCheckpointManager } from "../checkpoint-manager";
+import type {
+	ElizaInferenceContextHandle,
+	ElizaInferenceFfi,
+	ElizaInferenceRegion,
+} from "../ffi-bindings";
+import { LocalAgreementBuffer } from "../streaming-asr/streaming-pipeline-adapter";
+import { ASR_SAMPLE_RATE, FfiBatchTranscriber } from "../transcriber";
+import type { PcmFrame, TranscriberEvent } from "../types";
+import type {
+	DrafterAbortReason,
+	DrafterHandle,
+	StartDrafterFn,
+} from "../voice-state-machine";
+import { VoiceStateMachine } from "../voice-state-machine";
+
+/* ======================================================================
+ * Helpers
+ * ====================================================================== */
+
+function makePcmFrame(samples: number, tsMs = 0): PcmFrame {
+	return {
+		pcm: new Float32Array(samples).fill(0.05),
+		sampleRate: ASR_SAMPLE_RATE,
+		timestampMs: tsMs,
+	};
+}
+
+/**
+ * Build a minimal fake `ElizaInferenceFfi` backed by a scripted batch
+ * transcriber. Only `asrTranscribe` is used by `FfiBatchTranscriber`;
+ * every other method throws or returns a sentinel so accidental calls
+ * are caught immediately.
+ */
+function makeBatchFfi(
+	transcribeFn: (pcm: Float32Array) => string,
+): ElizaInferenceFfi {
+	return {
+		libraryPath: "/tmp/fake-batch",
+		libraryAbiVersion: "1",
+		create: (): ElizaInferenceContextHandle => 1n,
+		destroy: () => {},
+		mmapAcquire: (
+			_c: ElizaInferenceContextHandle,
+			_r: ElizaInferenceRegion,
+		) => {},
+		mmapEvict: (
+			_c: ElizaInferenceContextHandle,
+			_r: ElizaInferenceRegion,
+		) => {},
+		ttsSynthesize: () => {
+			throw new Error("not used");
+		},
+		asrTranscribe: ({ pcm }) => transcribeFn(pcm),
+		ttsStreamSupported: () => false,
+		ttsSynthesizeStream: () => {
+			throw new Error("not used");
+		},
+		cancelTts: () => {},
+		setVerifierCallback: () => ({ close: () => {} }),
+		vadSupported: () => false,
+		vadOpen: () => {
+			throw new Error("not used");
+		},
+		vadProcess: () => {
+			throw new Error("not used");
+		},
+		vadReset: () => {},
+		vadClose: () => {},
+		asrStreamSupported: () => false,
+		asrStreamOpen: () => {
+			throw new Error("not used");
+		},
+		asrStreamFeed: () => {
+			throw new Error("not used");
+		},
+		asrStreamPartial: () => {
+			throw new Error("not used");
+		},
+		asrStreamFinish: () => {
+			throw new Error("not used");
+		},
+		asrStreamClose: () => {
+			throw new Error("not used");
+		},
+		close: () => {},
+	};
+}
+
+/* ======================================================================
+ * 1. LocalAgreement-2 word-level stabilization — unit tests
+ * ====================================================================== */
+
+describe("LocalAgreementBuffer (word-level LocalAgreement-2)", () => {
+	it("returns empty on the first hypothesis (need 2 consecutive matches)", () => {
+		const buf = new LocalAgreementBuffer();
+		const stable = buf.stable(["hello", "there"]);
+		expect(stable).toEqual([]);
+	});
+
+	it("commits the matching prefix when two consecutive hypotheses agree on leading words", () => {
+		const buf = new LocalAgreementBuffer();
+		buf.stable(["hello", "there", "world"]);
+		const stable = buf.stable(["hello", "there", "how"]);
+		// First two words match across consecutive hypotheses → committed.
+		expect(stable).toEqual(["hello", "there"]);
+	});
+
+	it("extends the committed prefix as additional words stabilize", () => {
+		const buf = new LocalAgreementBuffer();
+		buf.stable(["hello", "there"]);
+		buf.stable(["hello", "there", "world"]);
+		const stable = buf.stable(["hello", "there", "world"]);
+		// "world" appeared in the 2nd and 3rd hypotheses → now committed.
+		expect(stable).toEqual(["hello", "there", "world"]);
+	});
+
+	it("does NOT roll back a committed word if a later hypothesis diverges", () => {
+		const buf = new LocalAgreementBuffer();
+		buf.stable(["the", "cat"]);
+		buf.stable(["the", "cat", "sat"]); // commits ["the", "cat"]
+		// New hypothesis changes "cat" → but committed must stay
+		const stable = buf.stable(["the", "dog"]);
+		expect(stable).toEqual(["the", "cat"]);
+	});
+
+	it("returns empty array for empty hypotheses", () => {
+		const buf = new LocalAgreementBuffer();
+		buf.stable([]);
+		const stable = buf.stable([]);
+		expect(stable).toEqual([]);
+	});
+
+	it("reset() clears all committed state", () => {
+		const buf = new LocalAgreementBuffer();
+		buf.stable(["hi"]);
+		buf.stable(["hi", "there"]); // commits ["hi"]
+		expect(buf.getCommitted()).toEqual(["hi"]);
+		buf.reset();
+		expect(buf.getCommitted()).toEqual([]);
+		// After reset, single hypothesis again commits nothing.
+		expect(buf.stable(["hi"])).toEqual([]);
+	});
+
+	it("commits nothing when the two consecutive hypotheses share no common prefix", () => {
+		const buf = new LocalAgreementBuffer();
+		buf.stable(["apple", "banana"]);
+		const stable = buf.stable(["cherry", "date"]);
+		expect(stable).toEqual([]);
+	});
+
+	it("respects n=3: requires three consecutive identical leading words", () => {
+		const buf = new LocalAgreementBuffer(3);
+		buf.stable(["a", "b"]);
+		buf.stable(["a", "b", "c"]);
+		// Only two so far — still nothing.
+		expect(buf.getCommitted()).toEqual([]);
+		buf.stable(["a", "b", "d"]);
+		// Third hypothesis agrees on ["a", "b"] with the window.
+		expect(buf.getCommitted()).toEqual(["a", "b"]);
+	});
+
+	it("rejects invalid n values", () => {
+		expect(() => new LocalAgreementBuffer(0)).toThrow();
+		expect(() => new LocalAgreementBuffer(-1)).toThrow();
+		expect(() => new LocalAgreementBuffer(Number.NaN)).toThrow();
+	});
+});
+
+/* ======================================================================
+ * 2. Sliding-window chunking via FfiBatchTranscriber — incremental partials
+ * ====================================================================== */
+
+describe("FfiBatchTranscriber sliding-window — incremental partial emission", () => {
+	it("emits partial events incrementally and stays within the window bound per decode call", async () => {
+		const decodedWindowSizes: number[] = [];
+		let decodeCallCount = 0;
+
+		const ffi = makeBatchFfi((pcm) => {
+			decodedWindowSizes.push(pcm.length);
+			decodeCallCount++;
+			return `word${decodeCallCount}`;
+		});
+
+		const transcriber = new FfiBatchTranscriber({
+			ffi,
+			getContext: () => 1n,
+			// Tiny window so multiple commits are forced across a ~2.4 s audio feed.
+			windowSeconds: 0.8,
+			overlapSeconds: 0.15,
+			stepSeconds: 0.4,
+		});
+
+		const events: TranscriberEvent[] = [];
+		transcriber.on((e) => events.push(e));
+
+		// Feed ~2.4 s worth of audio in 0.6 s frames.
+		const frameSamples = Math.round(0.6 * ASR_SAMPLE_RATE);
+		for (let i = 0; i < 4; i++) {
+			transcriber.feed(makePcmFrame(frameSamples, i * 600));
+			// Let the serial decode chain drain.
+			// eslint-disable-next-line no-await-in-loop
+			await new Promise((r) => setTimeout(r, 0));
+		}
+
+		// At least one partial was emitted during the feed phase.
+		const partials = events.filter((e) => e.kind === "partial");
+		expect(partials.length).toBeGreaterThanOrEqual(1);
+		// Each partial has isFinal: false while the segment is still open.
+		for (const p of partials) {
+			expect(p.kind).toBe("partial");
+			if (p.kind === "partial") {
+				expect(p.update.isFinal).toBe(false);
+			}
+		}
+
+		// Every batch decode call was bounded by window+overlap (no full-buffer re-decode).
+		const maxWindow = Math.round((0.8 + 0.15) * ASR_SAMPLE_RATE) + 50; // +50 rounding slack
+		for (const n of decodedWindowSizes) {
+			expect(n).toBeLessThanOrEqual(maxWindow);
+		}
+
+		// flush() force-finalizes and emits a final event.
+		const final = await transcriber.flush();
+		expect(final.isFinal).toBe(true);
+		expect(typeof final.partial).toBe("string");
+
+		const finalEvents = events.filter((e) => e.kind === "final");
+		expect(finalEvents.length).toBe(1);
+
+		transcriber.dispose();
+	});
+
+	it("flush() without any prior feed returns an empty final transcript", async () => {
+		const ffi = makeBatchFfi(() => "");
+		const transcriber = new FfiBatchTranscriber({
+			ffi,
+			getContext: () => 1n,
+		});
+		const final = await transcriber.flush();
+		expect(final.isFinal).toBe(true);
+		expect(final.partial).toBe("");
+		transcriber.dispose();
+	});
+
+	it("multiple flush() calls each commit independently (segment reset between)", async () => {
+		let callIdx = 0;
+		const scripts = ["first utterance", "second utterance"];
+		const ffi = makeBatchFfi(() => scripts[callIdx++ % scripts.length] ?? "");
+		const transcriber = new FfiBatchTranscriber({
+			ffi,
+			getContext: () => 1n,
+			stepSeconds: 0.01,
+		});
+
+		// Feed and flush for utterance 1.
+		transcriber.feed(makePcmFrame(Math.round(0.5 * ASR_SAMPLE_RATE), 0));
+		const final1 = await transcriber.flush();
+		expect(final1.isFinal).toBe(true);
+
+		// Feed and flush for utterance 2 — the transcriber must reset between segments.
+		transcriber.feed(makePcmFrame(Math.round(0.5 * ASR_SAMPLE_RATE), 500));
+		const final2 = await transcriber.flush();
+		expect(final2.isFinal).toBe(true);
+		// The second flush should not carry state from the first segment.
+		expect(final2.partial.length).toBeGreaterThanOrEqual(0); // just verify no throw
+
+		transcriber.dispose();
+	});
+});
+
+/* ======================================================================
+ * 3. speech-pause with available partial starts the drafter immediately
+ * ====================================================================== */
+
+interface DrafterCall {
+	turnId: string;
+	partial: string;
+	aborted: DrafterAbortReason | null;
+}
+
+function fakeDrafter(): { fn: StartDrafterFn; calls: DrafterCall[] } {
+	const calls: DrafterCall[] = [];
+	const fn: StartDrafterFn = ({ turnId, partialTranscript }) => {
+		const record: DrafterCall = {
+			turnId,
+			partial: partialTranscript,
+			aborted: null,
+		};
+		calls.push(record);
+		const handle: DrafterHandle = {
+			abort(reason) {
+				if (record.aborted === null) record.aborted = reason;
+			},
+		};
+		return handle;
+	};
+	return { fn, calls };
+}
+
+describe("VoiceStateMachine — speech-pause feeds partial transcript to drafter", () => {
+	it("on speech-pause the drafter is started synchronously with the current partial transcript", async () => {
+		const drafter = fakeDrafter();
+		const machine = new VoiceStateMachine({
+			slotId: "test-slot",
+			checkpointManager: new MockCheckpointManager(),
+			startDrafter: drafter.fn,
+			pauseHangoverMs: 200,
+		});
+
+		await machine.dispatch({ type: "speech-start", timestampMs: 0 });
+		// Provide a partial transcript — this is what the streaming ASR adapter
+		// would have accumulated via LocalAgreementBuffer by speech-pause time.
+		const partialAtPause = "how do I configure the";
+		await machine.dispatch({
+			type: "speech-pause",
+			timestampMs: 1500,
+			partialTranscript: partialAtPause,
+		});
+
+		expect(machine.getState()).toBe("PAUSE_TENTATIVE");
+		// Drafter was started immediately with the streaming partial (not waiting for flush()).
+		expect(drafter.calls).toHaveLength(1);
+		expect(drafter.calls[0]?.partial).toBe(partialAtPause);
+	});
+
+	it("speech-pause with empty partial still starts the drafter (drafter handles empty input)", async () => {
+		const drafter = fakeDrafter();
+		const machine = new VoiceStateMachine({
+			slotId: "test-slot",
+			checkpointManager: new MockCheckpointManager(),
+			startDrafter: drafter.fn,
+			pauseHangoverMs: 200,
+		});
+
+		await machine.dispatch({ type: "speech-start", timestampMs: 0 });
+		await machine.dispatch({
+			type: "speech-pause",
+			timestampMs: 500,
+			partialTranscript: "",
+		});
+
+		expect(drafter.calls).toHaveLength(1);
+		expect(drafter.calls[0]?.partial).toBe("");
+	});
+
+	it("drafter is aborted if speech resumes within the rollback window (partial was premature)", async () => {
+		const drafter = fakeDrafter();
+		const machine = new VoiceStateMachine({
+			slotId: "test-slot",
+			checkpointManager: new MockCheckpointManager(),
+			startDrafter: drafter.fn,
+			pauseHangoverMs: 200,
+		});
+
+		await machine.dispatch({ type: "speech-start", timestampMs: 0 });
+		await machine.dispatch({
+			type: "speech-pause",
+			timestampMs: 1000,
+			partialTranscript: "I was going to",
+		});
+		// Speech-active within 2×hangover (400ms) → rollback: drafter aborted.
+		await machine.dispatch({ type: "speech-active", timestampMs: 1200 });
+
+		expect(machine.getState()).toBe("LISTENING");
+		expect(drafter.calls[0]?.aborted).toBe("resumed");
+	});
+});
+
+/* ======================================================================
+ * 4. flush() after speech-end returns the committed final transcript
+ * ====================================================================== */
+
+describe("FfiBatchTranscriber — flush() returns committed final on speech-end", () => {
+	it("flush() drains the pending tail into committed and returns it with isFinal: true", async () => {
+		const ffi = makeBatchFfi(() => "the quick brown fox");
+		const transcriber = new FfiBatchTranscriber({
+			ffi,
+			getContext: () => 1n,
+			stepSeconds: 0.01,
+		});
+
+		transcriber.feed(makePcmFrame(Math.round(0.5 * ASR_SAMPLE_RATE), 0));
+		const final = await transcriber.flush();
+
+		expect(final.isFinal).toBe(true);
+		// The decoder returned "the quick brown fox" → committed final contains it.
+		expect(final.partial).toContain("the quick brown fox");
+		transcriber.dispose();
+	});
+
+	it("flush() on an untouched transcriber returns empty string (no audio, no transcript)", async () => {
+		const ffi = makeBatchFfi(() => "should not be called");
+		const transcriber = new FfiBatchTranscriber({
+			ffi,
+			getContext: () => 1n,
+		});
+		const final = await transcriber.flush();
+		expect(final.isFinal).toBe(true);
+		expect(final.partial).toBe("");
+		transcriber.dispose();
+	});
+
+	it("flush() resolves in order even when multiple decode passes are enqueued (serial chain)", async () => {
+		let decodes = 0;
+		const ffi = makeBatchFfi((_pcm) => {
+			decodes++;
+			return `segment${decodes}`;
+		});
+		const transcriber = new FfiBatchTranscriber({
+			ffi,
+			getContext: () => 1n,
+			// Very small step so many decode passes queue up.
+			stepSeconds: 0.01,
+			windowSeconds: 0.5,
+			overlapSeconds: 0.1,
+		});
+
+		// Feed ~1.5 s to force multiple decode passes.
+		for (let i = 0; i < 3; i++) {
+			transcriber.feed(
+				makePcmFrame(Math.round(0.5 * ASR_SAMPLE_RATE), i * 500),
+			);
+		}
+		const final = await transcriber.flush();
+		expect(final.isFinal).toBe(true);
+		// All enqueued decodes ran before flush() resolved.
+		expect(decodes).toBeGreaterThan(0);
+		transcriber.dispose();
+	});
+
+	// Guard: real model tests are skipped — no models >2B are loaded.
+	it.skipIf(true)(
+		"SKIP — real Gemma ASR model: flush() of a live stream returns the full utterance",
+		async () => {
+			// This test requires a real libelizainference build with a bundled
+			// ASR model. It is always skipped in CI to avoid loading large models.
+		},
+	);
+});