Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, it, expect, vi, beforeAll, beforeEach, afterEach, afterAll } from 'vitest';
const { socket, listeners, audio, FakeAudioContext } = vi.hoisted(() => {
const listeners = new Map();
const audio = {
decodeCalls: 0,
decodeImpl: () => Promise.resolve({}),
sources: [],
};
const socket = {
connected: false,
on: vi.fn((event, handler) => {
const handlers = listeners.get(event) || [];
handlers.push(handler);
listeners.set(event, handlers);
return socket;
}),
off: vi.fn((event, handler) => {
listeners.set(event, (listeners.get(event) || []).filter((fn) => fn !== handler));
return socket;
}),
emit: vi.fn(),
};
class FakeAudioContext {
constructor() {
this.destination = {};
this.state = 'running';
this.sampleRate = 48_000;
this.audioWorklet = { addModule: vi.fn(() => Promise.resolve()) };
}
resume() {
return Promise.resolve();
}
decodeAudioData(bytes) {
audio.decodeCalls++;
return audio.decodeImpl(bytes);
}
createBufferSource() {
const source = {
buffer: null,
connect: vi.fn(),
onended: null,
start: vi.fn(),
stop: vi.fn(),
};
audio.sources.push(source);
return source;
}
createMediaStreamSource() {
return { connect: vi.fn((target) => target), disconnect: vi.fn() };
}
createGain() {
return { gain: { value: 1 }, connect: vi.fn((target) => target) };
}
close() {
this.state = 'closed';
return Promise.resolve();
}
}
return { socket, listeners, audio, FakeAudioContext };
});
const audioRecorderStub = vi.hoisted(() => ({ blobToWav16k: null, float32ToWav16k: null }));
vi.mock('../lib/audioRecorder.js', async (importOriginal) => {
const actual = await importOriginal();
return {
...actual,
float32ToWav16k: (...args) => audioRecorderStub.float32ToWav16k
? audioRecorderStub.float32ToWav16k(...args)
: actual.float32ToWav16k(...args),
blobToWav16k: (...args) => audioRecorderStub.blobToWav16k
? audioRecorderStub.blobToWav16k(...args)
: actual.blobToWav16k(...args),
};
});
vi.mock('./socket', () => ({ default: socket }));
let voiceClient;
let recognition;
class FakeSpeechRecognition {
constructor() {
recognition = this;
this.startCalls = 0;
this.stopCalls = 0;
}
start() { this.startCalls += 1; }
stop() { this.stopCalls += 1; }
abort() { this.stop(); }
}
class FakeAudioWorkletNode {
constructor() {
this.port = { onmessage: null };
this.disconnect = vi.fn();
FakeAudioWorkletNode.last = this;
}
connect(target) { return target; }
}
class FakeMediaRecorder {
static isTypeSupported() { return true; }
constructor(stream, { mimeType }) {
this.stream = stream;
this.mimeType = mimeType;
this.handlers = new Map();
this.state = 'inactive';
FakeMediaRecorder.last = this;
}
addEventListener(event, handler) {
const handlers = this.handlers.get(event) || [];
handlers.push(handler);
this.handlers.set(event, handlers);
}
dispatch(event, payload) {
for (const handler of this.handlers.get(event) || []) handler(payload);
}
start() { this.state = 'recording'; }
stop() {
this.state = 'inactive';
this.dispatch('dataavailable', { data: { size: 1_000 } });
this.dispatch('stop');
}
}
const recognizeFinal = (text) => recognition.onresult({
resultIndex: 0,
results: [Object.assign([{ transcript: text }], { isFinal: true })],
});
const trigger = (event, payload) => {
for (const handler of listeners.get(event) || []) handler(payload);
};
const emitTtsAudio = (sentence) => trigger('voice:tts:audio', {
sentence,
wav: new ArrayBuffer(8),
});
describe('voice playback cancellation', () => {
beforeAll(async () => {
vi.stubGlobal('AudioContext', FakeAudioContext);
vi.stubGlobal('SpeechRecognition', FakeSpeechRecognition);
vi.stubGlobal('AudioWorkletNode', FakeAudioWorkletNode);
window.AudioContext = FakeAudioContext;
window.SpeechRecognition = FakeSpeechRecognition;
voiceClient = await import('./voiceClient.js');
});
beforeEach(() => {
trigger('voice:tts:cancel');
audio.decodeCalls = 0;
audio.decodeImpl = () => Promise.resolve({});
audio.sources.length = 0;
socket.emit.mockClear();
audioRecorderStub.blobToWav16k = null;
audioRecorderStub.float32ToWav16k = null;
voiceClient.disposeCaptureOwner();
});
afterEach(() => {
voiceClient.disposeCaptureOwner();
voiceClient.stopWebSpeechCapture();
trigger('voice:output:detached');
vi.restoreAllMocks();
});
afterAll(() => {
vi.unstubAllGlobals();
});
it('stops active and queued audio when a provider timeout is signaled', async () => {
trigger('voice:transcript');
emitTtsAudio('first sentence');
emitTtsAudio('second sentence');
await vi.waitFor(() => expect(audio.sources).toHaveLength(1));
const activeSource = audio.sources[0];
trigger('voice:tts:cancel');
expect(activeSource.stop).toHaveBeenCalledTimes(1);
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
// The old queue can finish after cancellation. It must not decrement the
// newly reset depth or create the queued stale source.
activeSource.onended?.();
await new Promise((resolve) => setTimeout(resolve, 0));
expect(audio.sources).toHaveLength(1);
});
it('drops a frame whose decode finishes after cancellation', async () => {
let resolveDecode;
audio.decodeImpl = () => new Promise((resolve) => { resolveDecode = resolve; });
trigger('voice:transcript');
emitTtsAudio('late sentence');
await vi.waitFor(() => expect(audio.decodeCalls).toBe(1));
trigger('voice:tts:cancel');
resolveDecode({});
await vi.waitFor(() => expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true));
expect(audio.sources).toHaveLength(0);
});
it('drops canceled-turn frames until the next transcript starts a turn', async () => {
trigger('voice:tts:cancel');
emitTtsAudio('stale sentence');
await Promise.resolve();
expect(audio.decodeCalls).toBe(0);
trigger('voice:idle');
emitTtsAudio('still stale after server idle');
expect(audio.decodeCalls).toBe(0);
trigger('voice:transcript');
emitTtsAudio('fresh sentence');
await vi.waitFor(() => expect(audio.sources).toHaveLength(1));
});
it('plays proactive speech after cancellation and ownership detach without admitting server chunks', async () => {
const onSpeech = vi.fn();
const unsubscribe = voiceClient.onProactiveSpeech(onSpeech);
trigger('voice:output:primary');
trigger('voice:speak', { sentence: 'first alert', wav: new ArrayBuffer(8), ts: 123 });
await vi.waitFor(() => expect(audio.sources).toHaveLength(1));
expect(onSpeech).toHaveBeenCalledWith({
sentence: 'first alert', priority: 'normal', source: 'cos', ts: 123,
});
trigger('voice:output:detached');
expect(audio.sources[0].stop).toHaveBeenCalledTimes(1);
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
audio.sources[0].onended();
trigger('voice:output:primary');
trigger('voice:speak', { sentence: 'next alert', wav: new ArrayBuffer(8) });
await vi.waitFor(() => expect(audio.sources).toHaveLength(2));
emitTtsAudio('canceled server chunk');
expect(audio.decodeCalls).toBe(2);
audio.sources[1].onended();
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
unsubscribe();
});
it('queues preview audio after cancellation without reopening server admission', async () => {
await expect(voiceClient.playWav(new ArrayBuffer(8))).resolves.toBeUndefined();
expect(audio.sources).toHaveLength(1);
emitTtsAudio('canceled server chunk');
expect(audio.decodeCalls).toBe(1);
audio.sources[0].onended();
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
});
it('reopens server admission for a synthetic reply and drops a superseded fetch', async () => {
let resolveOldWav;
const oldWav = new Promise((resolve) => { resolveOldWav = resolve; });
vi.spyOn(globalThis, 'fetch')
.mockResolvedValueOnce({ ok: true, arrayBuffer: () => oldWav })
.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
const oldReply = voiceClient.speakSynthesized('old reply');
await expect(voiceClient.speakSynthesized('new reply')).resolves.toBe(true);
expect(audio.sources).toHaveLength(1);
emitTtsAudio('admitted without transcript');
await vi.waitFor(() => expect(audio.decodeCalls).toBe(2));
resolveOldWav(new ArrayBuffer(8));
await expect(oldReply).resolves.toBe(false);
expect(audio.decodeCalls).toBe(2);
audio.sources[0].onended();
await vi.waitFor(() => expect(audio.sources).toHaveLength(2));
audio.sources[1].onended();
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
});
it('cancels a pending synthetic fetch even when a transcript reopens admission', async () => {
let resolveResponse;
vi.spyOn(globalThis, 'fetch').mockImplementationOnce(() => new Promise((resolve) => { resolveResponse = resolve; }));
const reply = voiceClient.speakSynthesized('pending reply');
voiceClient.interrupt();
trigger('voice:transcript');
resolveResponse({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
await expect(reply).resolves.toBe(false);
expect(audio.decodeCalls).toBe(0);
emitTtsAudio('fresh server reply');
await vi.waitFor(() => expect(audio.sources).toHaveLength(1));
});
it('keeps already-decoding synthetic audio when only the synthesis generation advances', async () => {
let resolveDecode;
audio.decodeImpl = vi.fn()
.mockImplementationOnce(() => new Promise((resolve) => { resolveDecode = resolve; }))
.mockResolvedValue({});
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true, arrayBuffer: async () => new ArrayBuffer(8),
});
const decodingReply = voiceClient.speakSynthesized('already fetched');
await vi.waitFor(() => expect(audio.decodeCalls).toBe(1));
await expect(voiceClient.speakSynthesized('new fetch')).resolves.toBe(true);
resolveDecode({});
await expect(decodingReply).resolves.toBe(true);
// Fetch invalidation leaves decode/queue work intact: the later-decoded
// audio follows the playing reply even though its fetch began first.
audio.sources[0].onended();
await vi.waitFor(() => expect(audio.sources).toHaveLength(2));
audio.sources[1].onended();
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
});
it('drains the captured queue after playback ends, independently of server idle and decoding', async () => {
let resolveDecode;
audio.decodeImpl = () => new Promise((resolve) => { resolveDecode = resolve; });
const preview = voiceClient.playWav(new ArrayBuffer(8));
await expect(voiceClient.whenPlaybackDrained()).resolves.toBe(true);
resolveDecode({});
await preview;
const drained = vi.fn();
const drain = voiceClient.whenPlaybackDrained().then(drained);
trigger('voice:idle');
await Promise.resolve();
expect(drained).not.toHaveBeenCalled();
audio.sources[0].onended();
await drain;
expect(drained).toHaveBeenCalledWith(true);
});
it('suppresses Web Speech during playback and the 700ms tail, and clears the tail on cancellation', async () => {
let now = 1000;
vi.spyOn(performance, 'now').mockImplementation(() => now);
const routeFinal = vi.fn();
voiceClient.startWebSpeechCapture({ routeFinal });
trigger('voice:transcript');
emitTtsAudio('spoken response');
await vi.waitFor(() => expect(audio.sources).toHaveLength(1));
recognizeFinal('wait');
expect(routeFinal).not.toHaveBeenCalled();
audio.sources[0].onended();
await voiceClient.whenPlaybackDrained();
now = 1699;
recognizeFinal('wait');
expect(routeFinal).not.toHaveBeenCalled();
now = 1700;
recognizeFinal('wait');
expect(routeFinal).toHaveBeenCalledTimes(1);
emitTtsAudio('another response');
await vi.waitFor(() => expect(audio.sources).toHaveLength(2));
audio.sources[1].onended();
trigger('voice:tts:cancel');
recognizeFinal('stop');
expect(routeFinal).toHaveBeenLastCalledWith('stop');
expect(routeFinal).toHaveBeenCalledTimes(2);
});
it('does not arm an echo tail for proactive audio while server admission remains canceled', async () => {
const routeFinal = vi.fn();
voiceClient.startWebSpeechCapture({ routeFinal });
trigger('voice:speak', { sentence: 'proactive alert', wav: new ArrayBuffer(8) });
await vi.waitFor(() => expect(audio.sources).toHaveLength(1));
recognizeFinal('wait');
expect(routeFinal).not.toHaveBeenCalled();
audio.sources[0].onended();
await voiceClient.whenPlaybackDrained();
recognizeFinal('wait');
expect(routeFinal).toHaveBeenCalledWith('wait');
});
it('drops recorder callbacks and releases the mic when its owner is disposed', async () => {
const previousRecorder = window.MediaRecorder;
const previousGlobalRecorder = globalThis.MediaRecorder;
const previousMediaDevices = navigator.mediaDevices;
const track = { stop: vi.fn() };
const getUserMedia = vi.fn().mockResolvedValue({ getTracks: () => [track] });
window.MediaRecorder = FakeMediaRecorder;
globalThis.MediaRecorder = FakeMediaRecorder;
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia },
});
await voiceClient.startCapture();
const activeRecorder = FakeMediaRecorder.last;
voiceClient.disposeCaptureOwner();
activeRecorder.dispatch('dataavailable', { data: { size: 1_000 } });
expect(track.stop).toHaveBeenCalledOnce();
expect(voiceClient.isCapturing()).toBe(false);
expect(socket.emit).not.toHaveBeenCalledWith('voice:turn', expect.anything());
window.MediaRecorder = previousRecorder;
if (previousGlobalRecorder === undefined) delete globalThis.MediaRecorder;
else globalThis.MediaRecorder = previousGlobalRecorder;
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: previousMediaDevices,
});
});
it('sends capped screenshots and resolves oversized captures as unavailable', async () => {
const { MAX_VOICE_AUDIO_BYTES } = await import('../lib/audioRecorder.js');
const prefix = 'data:image/jpeg;base64,';
const capped = prefix + 'A'.repeat(MAX_VOICE_AUDIO_BYTES - prefix.length);
voiceClient.sendScreenshotResult('example-capture', capped);
expect(socket.emit).toHaveBeenLastCalledWith('voice:screenshot:result', { requestId: 'example-capture', dataUrl: capped });
voiceClient.sendScreenshotResult('example-capture', capped + 'A');
expect(socket.emit).toHaveBeenLastCalledWith('voice:screenshot:result', { requestId: 'example-capture', dataUrl: null });
});
it('refuses an over-cap WAV locally through the voice error subscription and accepts the cap', async () => {
const previousMediaDevices = Object.getOwnPropertyDescriptor(navigator, 'mediaDevices');
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
});
const previousGlobalRecorder = globalThis.MediaRecorder;
globalThis.MediaRecorder = FakeMediaRecorder;
const previousRecorder = window.MediaRecorder;
window.MediaRecorder = FakeMediaRecorder;
const onError = vi.fn();
const unsubscribe = voiceClient.onVoiceEvent('voice:error', onError);
try {
const { MAX_VOICE_AUDIO_BYTES, RECORDING_TOO_LONG_MESSAGE } = await import('../lib/audioRecorder.js');
for (const size of [MAX_VOICE_AUDIO_BYTES + 1, MAX_VOICE_AUDIO_BYTES]) {
audioRecorderStub.blobToWav16k = vi.fn(async () => ({ wav: new ArrayBuffer(size), peak: 0.5 }));
await voiceClient.startCapture();
FakeMediaRecorder.last.dispatch('dataavailable', { data: new Blob(['x'.repeat(1000)]) });
const result = await voiceClient.stopCapture();
if (size > MAX_VOICE_AUDIO_BYTES) {
expect(result).toBeNull();
expect(socket.emit).not.toHaveBeenCalledWith('voice:turn', expect.anything());
expect(onError).toHaveBeenCalledWith({ stage: 'turn', message: RECORDING_TOO_LONG_MESSAGE });
} else {
expect(result.size).toBe(size);
expect(socket.emit).toHaveBeenCalledWith('voice:turn', expect.objectContaining({ audio: expect.any(ArrayBuffer) }));
}
}
expect(track.stop).toHaveBeenCalledTimes(2);
} finally {
unsubscribe();
window.MediaRecorder = previousRecorder;
if (previousGlobalRecorder === undefined) delete globalThis.MediaRecorder;
else globalThis.MediaRecorder = previousGlobalRecorder;
if (previousMediaDevices) Object.defineProperty(navigator, 'mediaDevices', previousMediaDevices);
else delete navigator.mediaDevices;
}
});
it('does not emit captured audio when the owner is disposed during WAV conversion', async () => {
const previousMediaDevices = Object.getOwnPropertyDescriptor(navigator, 'mediaDevices');
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }), enumerateDevices: vi.fn().mockResolvedValue([]) },
});
let resolveConversion;
audioRecorderStub.blobToWav16k = vi.fn(() => new Promise((resolve) => { resolveConversion = resolve; }));
const previousRecorder = window.MediaRecorder;
const previousGlobalRecorder = globalThis.MediaRecorder;
window.MediaRecorder = FakeMediaRecorder;
globalThis.MediaRecorder = FakeMediaRecorder;
try {
await voiceClient.startCapture();
FakeMediaRecorder.last.dispatch('dataavailable', { data: new Blob(['x'.repeat(1_000)]) });
const pending = voiceClient.stopCapture();
await vi.waitFor(() => expect(audioRecorderStub.blobToWav16k).toHaveBeenCalledOnce());
voiceClient.disposeCaptureOwner();
resolveConversion({ wav: new ArrayBuffer(16), peak: 0.5 });
await expect(pending).resolves.toBeNull();
expect(socket.emit).not.toHaveBeenCalledWith('voice:turn', expect.anything());
expect(track.stop).toHaveBeenCalledOnce();
} finally {
window.MediaRecorder = previousRecorder;
if (previousGlobalRecorder === undefined) delete globalThis.MediaRecorder;
else globalThis.MediaRecorder = previousGlobalRecorder;
if (previousMediaDevices) Object.defineProperty(navigator, 'mediaDevices', previousMediaDevices);
else delete navigator.mediaDevices;
}
});
it.each(['push-to-talk', 'continuous'])('keeps a newer %s permission request guarded when an older request rejects', async (mode) => {
const previousMediaDevices = Object.getOwnPropertyDescriptor(navigator, 'mediaDevices');
const oldRequest = (() => {
let resolve;
let reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
})();
const currentRequest = (() => {
let resolve;
const promise = new Promise((yes) => { resolve = yes; });
return { promise, resolve };
})();
const getUserMedia = vi.fn().mockReturnValueOnce(oldRequest.promise).mockReturnValueOnce(currentRequest.promise);
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia, enumerateDevices: vi.fn().mockResolvedValue([]) },
});
const previousRecorder = window.MediaRecorder;
const previousGlobalRecorder = globalThis.MediaRecorder;
window.MediaRecorder = FakeMediaRecorder;
globalThis.MediaRecorder = FakeMediaRecorder;
const start = mode === 'continuous' ? voiceClient.startContinuous : voiceClient.startCapture;
try {
const staleStart = start();
const staleRejected = expect(staleStart).rejects.toMatchObject({ message: 'old permission denied' });
voiceClient.disposeCaptureOwner();
const currentStart = start();
oldRequest.reject(new Error('old permission denied'));
await staleRejected;
await start();
expect(getUserMedia).toHaveBeenCalledTimes(2);
const track = { stop: vi.fn() };
currentRequest.resolve({ getTracks: () => [track] });
await currentStart;
expect(getUserMedia).toHaveBeenCalledTimes(2);
if (mode === 'continuous') expect(voiceClient.isContinuous()).toBe(true);
else expect(voiceClient.isCapturing()).toBe(true);
} finally {
voiceClient.disposeCaptureOwner();
await voiceClient.stopContinuous();
window.MediaRecorder = previousRecorder;
if (previousGlobalRecorder === undefined) delete globalThis.MediaRecorder;
else globalThis.MediaRecorder = previousGlobalRecorder;
if (previousMediaDevices) Object.defineProperty(navigator, 'mediaDevices', previousMediaDevices);
else delete navigator.mediaDevices;
}
});
it('settles a continuous turn locally when its converted WAV exceeds the cap', async () => {
const { MAX_VOICE_AUDIO_BYTES, RECORDING_TOO_LONG_MESSAGE } = await import('../lib/audioRecorder.js');
const previousMediaDevices = Object.getOwnPropertyDescriptor(navigator, 'mediaDevices');
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [{ stop: vi.fn() }] }) },
});
let now = 1000;
vi.spyOn(performance, 'now').mockImplementation(() => now);
audioRecorderStub.float32ToWav16k = vi.fn(async () => ({ wav: new ArrayBuffer(MAX_VOICE_AUDIO_BYTES + 1), peak: 0.5 }));
const onError = vi.fn();
const onSubmit = vi.fn();
const unsubscribe = voiceClient.onVoiceEvent('voice:error', onError);
try {
await voiceClient.startContinuous({ onSubmit });
const frame = FakeAudioWorkletNode.last.port.onmessage;
now = 1700;
frame({ data: new Float32Array(128) });
for (let i = 0; i < 40; i++) frame({ data: new Float32Array(128).fill(0.5) });
now = 18000;
frame({ data: new Float32Array(128).fill(0.5) });
await vi.waitFor(() => expect(onSubmit).toHaveBeenCalledWith({ submitted: false, peak: 0.5 }));
expect(onError).toHaveBeenCalledWith({ stage: 'turn', message: RECORDING_TOO_LONG_MESSAGE });
expect(socket.emit).not.toHaveBeenCalledWith('voice:turn', expect.anything());
} finally {
unsubscribe();
if (previousMediaDevices) Object.defineProperty(navigator, 'mediaDevices', previousMediaDevices);
else delete navigator.mediaDevices;
}
});
it('ignores VAD worklet frames and async submissions after owner disposal', async () => {
const previousMediaDevices = navigator.mediaDevices;
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
});
const onSpeechStart = vi.fn();
const onSubmit = vi.fn();
await voiceClient.startContinuous({ onSpeechStart, onSubmit });
const lateFrame = FakeAudioWorkletNode.last.port.onmessage;
voiceClient.disposeCaptureOwner();
lateFrame?.({ data: new Float32Array([1, 1, 1, 1]) });
expect(track.stop).toHaveBeenCalledOnce();
expect(voiceClient.isContinuous()).toBe(false);
expect(onSpeechStart).not.toHaveBeenCalled();
expect(onSubmit).not.toHaveBeenCalled();
expect(socket.emit).not.toHaveBeenCalledWith('voice:turn', expect.anything());
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: previousMediaDevices,
});
});
describe('continuous startup rollback', () => {
let previousMediaDevices;
let previousAudioSession;
let tracks;
let getUserMedia;
beforeEach(() => {
previousMediaDevices = Object.getOwnPropertyDescriptor(navigator, 'mediaDevices');
previousAudioSession = Object.getOwnPropertyDescriptor(navigator, 'audioSession');
tracks = [{ stop: vi.fn() }, { stop: vi.fn() }];
getUserMedia = vi.fn().mockResolvedValue({ getTracks: () => tracks });
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia },
});
Object.defineProperty(navigator, 'audioSession', {
configurable: true,
value: { type: 'auto' },
});
});
afterEach(async () => {
await voiceClient.stopContinuous();
if (previousMediaDevices) Object.defineProperty(navigator, 'mediaDevices', previousMediaDevices);
else delete navigator.mediaDevices;
if (previousAudioSession) Object.defineProperty(navigator, 'audioSession', previousAudioSession);
else delete navigator.audioSession;
});
it('keeps a remounted capture active while the previous context is still closing', async () => {
const oldContext = new FakeAudioContext();
let finishClose;
vi.spyOn(oldContext, 'close').mockImplementation(() => new Promise((resolve) => { finishClose = resolve; }));
vi.spyOn(window, 'AudioContext').mockImplementationOnce(function () { return oldContext; });
await voiceClient.startContinuous();
const oldFrame = FakeAudioWorkletNode.last.port.onmessage;
const stopping = voiceClient.stopContinuous();
expect(voiceClient.isContinuous()).toBe(false);
await vi.waitFor(() => expect(finishClose).toBeTypeOf('function'));
const newTrack = { stop: vi.fn() };
getUserMedia.mockResolvedValueOnce({ getTracks: () => [newTrack] });
await voiceClient.startContinuous();
oldFrame?.({ data: new Float32Array([1, 1, 1, 1]) });
finishClose();
await stopping;
expect(tracks.every((track) => track.stop.mock.calls.length === 1)).toBe(true);
expect(newTrack.stop).not.toHaveBeenCalled();
expect(voiceClient.isContinuous()).toBe(true);
expect(navigator.audioSession.type).toBe('play-and-record');
});
it('starts synchronous owner disposal before releasing its audio session', async () => {
const context = new FakeAudioContext();
const close = vi.spyOn(context, 'close').mockImplementation(() => {
expect(navigator.audioSession.type).toBe('play-and-record');
return Promise.resolve();
});
vi.spyOn(window, 'AudioContext').mockImplementationOnce(function () { return context; });
await voiceClient.startContinuous();
voiceClient.disposeCaptureOwner();
expect(close).toHaveBeenCalledOnce();
expect(navigator.audioSession.type).toBe('auto');
tracks.forEach((track) => expect(track.stop).toHaveBeenCalledOnce());
});
// Each stage leaves a different set of acquired resources to unwind.
it.each(['constructor', 'source', 'worklet node', 'connection', 'resume', 'module'])(
'releases the microphone and permits retry after a %s failure', async (stage) => {
const error = new Error(`${stage} failed`);
const fail = () => { throw error; };
const context = new FakeAudioContext();
const close = vi.spyOn(context, 'close');
vi.spyOn(window, 'AudioContext').mockImplementationOnce(function () {
if (stage === 'constructor') throw error;
return context;
});
if (stage === 'source') vi.spyOn(context, 'createMediaStreamSource').mockImplementationOnce(fail);
if (stage === 'worklet node') {
vi.spyOn(globalThis, 'AudioWorkletNode').mockImplementationOnce(function () { throw error; });
}
if (stage === 'connection') vi.spyOn(FakeAudioWorkletNode.prototype, 'connect').mockImplementationOnce(fail);
if (stage === 'resume') {
context.state = 'suspended';
vi.spyOn(context, 'resume').mockRejectedValueOnce(error);
}
if (stage === 'module') context.audioWorklet.addModule.mockRejectedValueOnce(error);
const createUrl = vi.spyOn(URL, 'createObjectURL');
const revokeUrl = vi.spyOn(URL, 'revokeObjectURL');
await expect(voiceClient.startContinuous()).rejects.toBe(error);
tracks.forEach((track) => expect(track.stop).toHaveBeenCalledOnce());
expect(navigator.audioSession.type).toBe('auto');
expect(voiceClient.isContinuous()).toBe(false);
expect(close).toHaveBeenCalledTimes(stage === 'constructor' ? 0 : 1);
createUrl.mock.results.forEach(({ value }) => expect(revokeUrl).toHaveBeenCalledWith(value));
await voiceClient.stopContinuous();
tracks.forEach((track) => expect(track.stop).toHaveBeenCalledOnce());
const retryTrack = { stop: vi.fn() };
getUserMedia.mockResolvedValueOnce({ getTracks: () => [retryTrack] });
await voiceClient.startContinuous();
expect(getUserMedia).toHaveBeenCalledTimes(2);
expect(voiceClient.isContinuous()).toBe(true);
expect(navigator.audioSession.type).toBe('play-and-record');
expect(retryTrack.stop).not.toHaveBeenCalled();
await voiceClient.stopContinuous();
expect(retryTrack.stop).toHaveBeenCalledOnce();
expect(navigator.audioSession.type).toBe('auto');
},
);
it('starts a restarted capture calibrating and idle after the previous one stopped mid-speech', async () => {
let now = 1000;
vi.spyOn(performance, 'now').mockImplementation(() => now);
const loud = () => new Float32Array(128).fill(0.5);
const onFirstSpeech = vi.fn();
await voiceClient.startContinuous({ onSpeechStart: onFirstSpeech });
const firstFrame = FakeAudioWorkletNode.last.port.onmessage;
now = 1700;
firstFrame({ data: new Float32Array(128) });
for (let i = 0; i < 40; i++) firstFrame({ data: loud() });
expect(onFirstSpeech).toHaveBeenCalledOnce();
await voiceClient.stopContinuous();
const onSpeechStart = vi.fn();
await voiceClient.startContinuous({ onSpeechStart });
const frame = FakeAudioWorkletNode.last.port.onmessage;
// Still inside the new capture's calibration window: loud frames only
// feed the noise-floor estimate, never a speech onset.
for (let i = 0; i < 40; i++) frame({ data: loud() });
expect(onSpeechStart).not.toHaveBeenCalled();
// Past the window the detector is live again, starting from idle.
now = 1700 + 700;
frame({ data: new Float32Array(128) });
for (let i = 0; i < 40; i++) frame({ data: loud() });
expect(onSpeechStart).toHaveBeenCalledOnce();
});
it.each(['resolve', 'reject'])('does not stop a retry when a disposed startup later %ss', async (outcome) => {
let resolveModule;
let rejectModule;
const context = new FakeAudioContext();
context.audioWorklet.addModule.mockImplementationOnce(() => new Promise((resolve, reject) => {
resolveModule = resolve;
rejectModule = reject;
}));
vi.spyOn(window, 'AudioContext').mockImplementationOnce(function () { return context; });
const pending = voiceClient.startContinuous();
await vi.waitFor(() => expect(context.audioWorklet.addModule).toHaveBeenCalledOnce());
voiceClient.disposeCaptureOwner();
const retryTrack = { stop: vi.fn() };
getUserMedia.mockResolvedValueOnce({ getTracks: () => [retryTrack] });
await voiceClient.startContinuous();
if (outcome === 'reject') {
const error = new Error('old module failed');
const rejection = expect(pending).rejects.toBe(error);
rejectModule(error);
await rejection;
} else {
resolveModule();
await expect(pending).resolves.toBeNull();
}
expect(voiceClient.isContinuous()).toBe(true);
expect(navigator.audioSession.type).toBe('play-and-record');
expect(retryTrack.stop).not.toHaveBeenCalled();
});
});
it('ignores Web Speech results and restart errors after owner disposal', () => {
const routeFinal = vi.fn();
const onError = vi.fn();
voiceClient.startWebSpeechCapture({ routeFinal, onError });
const oldRecognition = recognition;
voiceClient.disposeCaptureOwner();
oldRecognition.onresult?.({
resultIndex: 0,
results: [Object.assign([{ transcript: 'late result' }], { isFinal: true })],
});
oldRecognition.onerror?.({ error: 'not-allowed' });
expect(oldRecognition.stopCalls).toBe(1);
expect(routeFinal).not.toHaveBeenCalled();
expect(onError).not.toHaveBeenCalled();
expect(voiceClient.isWebSpeechCapturing()).toBe(false);
});
});