Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
import { afterEach, describe, expect, it, vi } from 'vitest';
import {
claimVoiceCapture,
deleteMapValueIfCurrent,
isVoiceControlDisabled,
prewarmVoiceCapture,
VOICE_CAPTURE_STOP_TIMEOUT_MS,
VOICE_MIN_SEGMENT_MS,
voicePcmDeliverySamples,
voicePcmWorkletSource,
voiceWavMaxSamples,
VoiceRecordingPipeline,
} from './voiceRecording';
const initialNavigatorLocks = Object.getOwnPropertyDescriptor(navigator, 'locks');
type CaptureHandlers = {
onSamples: (samples: Int16Array) => void;
onStopped: () => void;
onError: (error: unknown) => void;
};
class FakeCapture {
private readonly handlers: CaptureHandlers;
readonly start = vi.fn(async () => undefined);
readonly stop = vi.fn();
constructor(handlers: CaptureHandlers) {
this.handlers = handlers;
}
emit(...samples: number[]): void {
this.handlers.onSamples(Int16Array.from(samples));
}
settle(): void {
this.handlers.onStopped();
}
fail(error: unknown): void {
this.handlers.onError(error);
this.handlers.onStopped();
}
}
const setup = (options: {
maxFileBytes?: number;
overlapMs?: number;
segmentMs?: number;
} = {}) => {
const track = {
stop: vi.fn(),
};
const stream = {
getTracks: () => [track],
} as unknown as MediaStream;
const onSegment = vi.fn<(blob: Blob, metadata: { durationMs: number }) => void>();
const onPcm = vi.fn<(samples: Int16Array) => void>();
const onError = vi.fn();
const onStopRequested = vi.fn();
const onStopped = vi.fn();
let capture: FakeCapture | null = null;
const pipeline = new VoiceRecordingPipeline({
stream,
sampleRate: 4,
segmentMs: options.segmentMs ?? 1000,
maxFileBytes: options.maxFileBytes,
overlapMs: options.overlapMs ?? 0,
onSegment,
onPcm,
onError,
onStopRequested,
onStopped,
createCapture: (_stream, sampleRate, segmentSamples, handlers) => {
expect(sampleRate).toBe(4);
expect(segmentSamples).toBe(
Math.min(
Math.round(4 * (options.segmentMs ?? 1000) / 1000),
voiceWavMaxSamples(options.maxFileBytes) ?? Number.POSITIVE_INFINITY,
),
);
capture = new FakeCapture(handlers);
return capture;
},
});
return {
capture: () => capture!,
onError,
onSegment,
onPcm,
onStopRequested,
onStopped,
pipeline,
track,
};
};
const wavDataBytes = async (blob: Blob): Promise<number> => {
const buffer = await blob.arrayBuffer();
return new DataView(buffer).getUint32(40, true);
};
const wavSamples = async (blob: Blob): Promise<number[]> => {
const buffer = await blob.arrayBuffer();
const view = new DataView(buffer);
const samples: number[] = [];
for (let offset = 44; offset < buffer.byteLength; offset += 2) {
samples.push(view.getInt16(offset, true));
}
return samples;
};
afterEach(() => {
Reflect.deleteProperty(navigator, 'locks');
if (initialNavigatorLocks) Object.defineProperty(navigator, 'locks', initialNavigatorLocks);
vi.useRealTimers();
vi.restoreAllMocks();
vi.unstubAllGlobals();
});
describe('VoiceRecordingPipeline', () => {
it('delivers short PCM frames independently of WAV segmentation', async () => {
const { capture, onPcm, onSegment, pipeline } = setup();
await pipeline.start();
capture().emit(1, 2, 3);
expect(onPcm).toHaveBeenCalledTimes(1);
expect(Array.from(onPcm.mock.calls[0]?.[0] ?? [])).toEqual([1, 2, 3]);
expect(onSegment).not.toHaveBeenCalled();
});
it('frames delayed PCM delivery into provider-safe segments by sample count', async () => {
const { capture, onSegment, pipeline } = setup();
await pipeline.start();
// This represents audio-render-thread messages delivered after a long main
// thread stall. No emitted file may grow with the delayed wall time.
capture().emit(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
expect(onSegment).toHaveBeenCalledTimes(2);
expect(onSegment.mock.calls.map(([, metadata]) => metadata.durationMs)).toEqual([
1000,
1000,
]);
expect(await Promise.all(onSegment.mock.calls.map(([blob]) => wavDataBytes(blob)))).toEqual([
8,
8,
]);
expect(await Promise.all(onSegment.mock.calls.map(([blob]) => wavSamples(blob)))).toEqual([
[1, 2, 3, 4],
[5, 6, 7, 8],
]);
expect(onSegment.mock.calls.every(([blob]) => blob.type === 'audio/wav')).toBe(true);
});
it('keeps every WAV within the configured ASR byte limit', async () => {
const { capture, onSegment, pipeline } = setup({
maxFileBytes: 52,
overlapMs: 250,
});
await pipeline.start();
capture().emit(1, 2, 3, 4, 5, 6, 7, 8);
pipeline.finish();
capture().settle();
expect(onSegment).toHaveBeenCalledTimes(3);
expect(onSegment.mock.calls.map(([blob]) => blob.size)).toEqual([52, 52, 48]);
expect(await Promise.all(onSegment.mock.calls.map(([blob]) => wavSamples(blob)))).toEqual([
[1, 2, 3, 4],
[4, 5, 6, 7],
[7, 8],
]);
});
it('rejects a file limit below one practical segment', () => {
const minimumSamples = Math.round(4 * VOICE_MIN_SEGMENT_MS / 1000);
const belowMinimumBytes = 44 + ((minimumSamples - 1) * 2);
expect(() => setup({
maxFileBytes: belowMinimumBytes,
segmentMs: VOICE_MIN_SEGMENT_MS + 1000,
})).toThrow(
'configured ASR file limit is too small for a practical WAV segment',
);
});
it('overlaps adjacent segments without emitting an overlap-only tail', async () => {
const { capture, onSegment, pipeline } = setup({ overlapMs: 500 });
await pipeline.start();
capture().emit(1, 2, 3, 4, 5, 6);
pipeline.finish();
capture().settle();
expect(onSegment).toHaveBeenCalledTimes(2);
expect(await Promise.all(onSegment.mock.calls.map(([blob]) => wavSamples(blob)))).toEqual([
[1, 2, 3, 4],
[3, 4, 5, 6],
]);
expect(onSegment.mock.calls.map(([, metadata]) => metadata)).toEqual([
{ durationMs: 1000, final: false },
{ durationMs: 1000, overlapMs: 500, final: false },
]);
});
it('flushes the final partial segment after the user stops', async () => {
vi.setSystemTime(new Date('2026-07-29T17:00:00Z'));
const {
capture,
onSegment,
onStopRequested,
onStopped,
pipeline,
track,
} = setup();
await pipeline.start();
capture().emit(1, 2);
pipeline.finish();
expect(capture().stop).toHaveBeenCalledTimes(1);
expect(track.stop).toHaveBeenCalledTimes(1);
expect(onStopRequested).toHaveBeenCalledWith('finish', {
requestedAt: Date.now(),
});
expect(onStopped).not.toHaveBeenCalled();
capture().settle();
expect(onSegment).toHaveBeenCalledTimes(1);
expect(onSegment.mock.calls[0]?.[1]).toEqual({ durationMs: 500, final: true });
expect(await wavDataBytes(onSegment.mock.calls[0]![0])).toBe(4);
expect(onStopped).toHaveBeenCalledWith('finish', { pendingSegmentCount: 1 });
expect(track.stop).toHaveBeenCalledTimes(1);
});
it('discards buffered PCM when aborted', async () => {
const { capture, onSegment, onStopped, pipeline } = setup();
await pipeline.start();
capture().emit(1, 2);
pipeline.abort();
capture().settle();
expect(onSegment).not.toHaveBeenCalled();
expect(onStopped).toHaveBeenCalledWith('abort', { pendingSegmentCount: 0 });
});
it('finishes before a hidden page can suspend audio processing', async () => {
const visibilityDocument = new EventTarget() as EventTarget & {
visibilityState: DocumentVisibilityState;
};
visibilityDocument.visibilityState = 'visible';
vi.stubGlobal('document', visibilityDocument);
const { capture, pipeline } = setup();
await pipeline.start();
visibilityDocument.visibilityState = 'hidden';
visibilityDocument.dispatchEvent(new Event('visibilitychange'));
expect(capture().stop).toHaveBeenCalledTimes(1);
});
it('does not become active when the page hides during capture startup', async () => {
const visibilityDocument = new EventTarget() as EventTarget & {
visibilityState: DocumentVisibilityState;
};
visibilityDocument.visibilityState = 'visible';
vi.stubGlobal('document', visibilityDocument);
const { capture, onStopped, pipeline, track } = setup();
let resolveStart!: () => void;
capture().start.mockImplementationOnce(() => new Promise<void>((resolve) => {
resolveStart = resolve;
}));
const starting = pipeline.start();
await vi.waitFor(() => expect(capture().start).toHaveBeenCalledOnce());
visibilityDocument.visibilityState = 'hidden';
visibilityDocument.dispatchEvent(new Event('visibilitychange'));
expect(track.stop).toHaveBeenCalledTimes(1);
resolveStart();
await expect(starting).resolves.toBe(false);
expect(capture().stop).toHaveBeenCalledTimes(1);
capture().settle();
expect(onStopped).toHaveBeenCalledWith('finish', { pendingSegmentCount: 0 });
});
it('retains captured audio as failed after the processor stops unexpectedly', async () => {
const {
capture,
onError,
onSegment,
onStopRequested,
onStopped,
pipeline,
} = setup();
await pipeline.start();
capture().emit(1, 2);
const error = new Error('processor stopped');
capture().fail(error);
expect(onStopRequested).toHaveBeenCalledWith('error', {
requestedAt: expect.any(Number),
});
expect(onError).toHaveBeenCalledWith(error);
expect(onSegment).toHaveBeenCalledTimes(1);
expect(onStopped).toHaveBeenCalledWith('error', { pendingSegmentCount: 1 });
});
it('upgrades a user stop to failure when the processor crashes while flushing', async () => {
const {
capture,
onError,
onStopRequested,
onStopped,
pipeline,
} = setup();
await pipeline.start();
capture().emit(1, 2);
pipeline.finish();
const error = new Error('processor stopped while flushing');
capture().fail(error);
expect(onStopRequested).toHaveBeenCalledOnce();
expect(onStopRequested).toHaveBeenCalledWith('finish', {
requestedAt: expect.any(Number),
});
expect(onError).toHaveBeenCalledWith(error);
expect(onStopped).toHaveBeenCalledWith('error', { pendingSegmentCount: 1 });
});
it('reports inactive when capture stops before asynchronous startup completes', async () => {
const { capture, onStopped, pipeline } = setup();
let resolveStart!: () => void;
capture().start.mockImplementationOnce(() => new Promise<void>((resolve) => {
resolveStart = resolve;
}));
const starting = pipeline.start();
await vi.waitFor(() => expect(capture().start).toHaveBeenCalledOnce());
capture().settle();
resolveStart();
await expect(starting).resolves.toBe(false);
expect(onStopped).toHaveBeenCalledWith('finish', { pendingSegmentCount: 0 });
});
it('reuses a prewarmed audio context and retries gesture-gated resume', async () => {
const addModule = vi.fn(async () => undefined);
class FakeAudioContext {
static instance: FakeAudioContext | null = null;
state = 'suspended';
readonly audioWorklet = { addModule };
readonly destination = {};
readonly close = vi.fn(async () => {
this.state = 'closed';
});
readonly resume = vi.fn(async () => undefined);
readonly createMediaStreamSource = vi.fn(() => ({
connect: vi.fn(),
disconnect: vi.fn(),
}));
constructor() {
FakeAudioContext.instance = this;
}
}
class FakeAudioWorkletNode {
static instance: FakeAudioWorkletNode | null = null;
readonly port = {
onmessage: null as ((event: {
data: { type?: string; samples?: ArrayBuffer };
}) => void) | null,
postMessage: vi.fn(),
close: vi.fn(),
};
onprocessorerror: (() => void) | null = null;
readonly connect = vi.fn();
readonly disconnect = vi.fn();
constructor() {
FakeAudioWorkletNode.instance = this;
}
}
const track = new EventTarget() as EventTarget & {
readyState: MediaStreamTrackState;
stop: ReturnType<typeof vi.fn>;
};
track.readyState = 'live';
track.stop = vi.fn();
const stream = { getTracks: () => [track] } as unknown as MediaStream;
const onStopped = vi.fn();
vi.stubGlobal('AudioContext', FakeAudioContext);
vi.stubGlobal('AudioWorkletNode', FakeAudioWorkletNode);
vi.stubGlobal('URL', {
createObjectURL: vi.fn(() => 'blob:voice-worklet'),
revokeObjectURL: vi.fn(),
});
await prewarmVoiceCapture();
expect(FakeAudioContext.instance?.resume).toHaveBeenCalledOnce();
await prewarmVoiceCapture();
expect(FakeAudioContext.instance?.resume).toHaveBeenCalledTimes(2);
const pipeline = new VoiceRecordingPipeline({
stream,
segmentMs: 1000,
onSegment: vi.fn(),
onStopped,
});
await pipeline.start();
expect(FakeAudioContext.instance).not.toBeNull();
expect(addModule).toHaveBeenCalledOnce();
expect(FakeAudioContext.instance?.createMediaStreamSource).toHaveBeenCalledOnce();
pipeline.abort();
FakeAudioWorkletNode.instance?.port.onmessage?.({ data: { type: 'stopped' } });
expect(onStopped).toHaveBeenCalledWith('abort', { pendingSegmentCount: 0 });
// The real worklet acknowledges stop through its message port. The test
// drives that boundary so the shared context can be closed cleanly.
await FakeAudioContext.instance?.close();
});
it('observes a microphone track ending while the worklet module loads', async () => {
let resolveModule!: () => void;
const addModule = vi.fn(() => new Promise<void>((resolve) => {
resolveModule = resolve;
}));
class FakeAudioContext {
state = 'running';
readonly audioWorklet = { addModule };
readonly destination = {};
readonly close = vi.fn(async () => {
this.state = 'closed';
});
readonly resume = vi.fn(async () => undefined);
readonly createMediaStreamSource = vi.fn(() => ({
connect: vi.fn(),
disconnect: vi.fn(),
}));
}
class FakeAudioWorkletNode {
readonly port = {
onmessage: null,
postMessage: vi.fn(),
close: vi.fn(),
};
onprocessorerror: (() => void) | null = null;
readonly connect = vi.fn();
readonly disconnect = vi.fn();
}
class FakeTrack extends EventTarget {
readyState: MediaStreamTrackState = 'live';
readonly stop = vi.fn();
end(): void {
this.readyState = 'ended';
this.dispatchEvent(new Event('ended'));
}
}
const track = new FakeTrack();
const stream = {
getTracks: () => [track],
} as unknown as MediaStream;
const onError = vi.fn();
const onStopRequested = vi.fn();
const onStopped = vi.fn();
vi.stubGlobal('AudioContext', FakeAudioContext);
vi.stubGlobal('AudioWorkletNode', FakeAudioWorkletNode);
vi.stubGlobal('URL', {
createObjectURL: vi.fn(() => 'blob:voice-worklet'),
revokeObjectURL: vi.fn(),
});
const pipeline = new VoiceRecordingPipeline({
stream,
segmentMs: 1000,
onSegment: vi.fn(),
onError,
onStopRequested,
onStopped,
});
const starting = pipeline.start();
await vi.waitFor(() => expect(addModule).toHaveBeenCalledOnce());
track.end();
resolveModule();
await expect(starting).resolves.toBe(false);
expect(onError).toHaveBeenCalledWith(expect.any(Error));
expect(onStopRequested).toHaveBeenCalledWith('error', {
requestedAt: expect.any(Number),
});
expect(onStopped).toHaveBeenCalledWith('error', { pendingSegmentCount: 0 });
});
it('retains delivered PCM when the worklet does not acknowledge stop', async () => {
vi.useFakeTimers();
class FakeAudioContext {
state = 'running';
readonly audioWorklet = { addModule: vi.fn(async () => undefined) };
readonly destination = {};
readonly close = vi.fn(async () => {
this.state = 'closed';
});
readonly resume = vi.fn(async () => undefined);
readonly createMediaStreamSource = vi.fn(() => ({
connect: vi.fn(),
disconnect: vi.fn(),
}));
}
class FakeAudioWorkletNode {
static instance: FakeAudioWorkletNode | null = null;
readonly port = {
onmessage: null as ((event: {
data: { type?: string; samples?: ArrayBuffer };
}) => void) | null,
postMessage: vi.fn(),
close: vi.fn(),
};
onprocessorerror: (() => void) | null = null;
readonly connect = vi.fn();
readonly disconnect = vi.fn();
constructor() {
FakeAudioWorkletNode.instance = this;
}
}
const track = new EventTarget() as EventTarget & {
readyState: MediaStreamTrackState;
stop: ReturnType<typeof vi.fn>;
};
track.readyState = 'live';
track.stop = vi.fn();
const stream = {
getTracks: () => [track],
} as unknown as MediaStream;
const onError = vi.fn();
const onSegment = vi.fn();
const onStopped = vi.fn();
vi.stubGlobal('AudioContext', FakeAudioContext);
vi.stubGlobal('AudioWorkletNode', FakeAudioWorkletNode);
vi.stubGlobal('URL', {
createObjectURL: vi.fn(() => 'blob:voice-worklet'),
revokeObjectURL: vi.fn(),
});
const pipeline = new VoiceRecordingPipeline({
stream,
sampleRate: 4,
segmentMs: 1000,
overlapMs: 0,
stopTimeoutMs: VOICE_CAPTURE_STOP_TIMEOUT_MS,
onSegment,
onError,
onStopped,
});
await pipeline.start();
const workletNode = FakeAudioWorkletNode.instance;
expect(workletNode).not.toBeNull();
workletNode.port.onmessage?.({
data: { type: 'samples', samples: Int16Array.from([1, 2]).buffer },
});
pipeline.finish();
await vi.advanceTimersByTimeAsync(VOICE_CAPTURE_STOP_TIMEOUT_MS);
expect(onError).toHaveBeenCalledWith(expect.any(Error));
expect(onSegment).toHaveBeenCalledOnce();
expect(await wavSamples(onSegment.mock.calls[0]![0])).toEqual([1, 2]);
expect(onStopped).toHaveBeenCalledWith('error', { pendingSegmentCount: 1 });
});
it('reports no queued segment when stopping exactly at a segment boundary', async () => {
const { capture, onStopped, pipeline } = setup();
await pipeline.start();
capture().emit(1, 2, 3, 4);
pipeline.finish();
capture().settle();
expect(onStopped).toHaveBeenCalledWith('finish', { pendingSegmentCount: 0 });
});
it('counts every file segment delivered after the stop request', async () => {
const { capture, onSegment, onStopped, pipeline } = setup();
await pipeline.start();
pipeline.finish();
capture().emit(1, 2, 3, 4, 5, 6, 7, 8);
capture().settle();
expect(onSegment).toHaveBeenCalledTimes(2);
expect(onStopped).toHaveBeenCalledWith('finish', { pendingSegmentCount: 2 });
});
});
describe('voice PCM worklet', () => {
it('delivers PCM before a full file segment has accumulated', () => {
const oneMinute = 60 * 16_000;
expect(voicePcmDeliverySamples(16_000, oneMinute)).toBe(4_000);
expect(voicePcmDeliverySamples(16_000, 2_000)).toBe(2_000);
});
it('loads and emits bounded downsampled buffers on the rendering thread', () => {
const postMessage = vi.fn();
class FakeAudioWorkletProcessor {
readonly port = {
onmessage: null as ((event: { data: { type?: string } }) => void) | null,
postMessage,
};
}
let Processor: (new (options: {
processorOptions: {
targetSampleRate: number;
chunkSamples: number;
};
}) => {
port: FakeAudioWorkletProcessor['port'];
process: (inputs: Float32Array[][]) => boolean;
}) | null = null;
const loadModule = new Function(
'AudioWorkletProcessor',
'registerProcessor',
'sampleRate',
voicePcmWorkletSource,
);
loadModule(
FakeAudioWorkletProcessor,
(_name: string, constructor: typeof Processor) => {
Processor = constructor;
},
8,
);
const processor = new Processor!({
processorOptions: {
targetSampleRate: 4,
chunkSamples: 4,
},
});
expect(processor.process([[
Float32Array.from([0, 0.25, 0.5, 0.75, 1, 0.75, 0.5, 0.25]),
]])).toBe(true);
const sampleMessage = postMessage.mock.calls[0]?.[0] as {
type: string;
samples: ArrayBuffer;
};
expect(sampleMessage.type).toBe('samples');
expect(new Int16Array(sampleMessage.samples)).toHaveLength(4);
processor.port.onmessage?.({ data: { type: 'stop' } });
expect(postMessage.mock.calls.at(-1)?.[0]).toEqual({ type: 'stopped' });
});
it('upsamples low-rate input before emitting target-rate PCM', () => {
const postMessage = vi.fn();
class FakeAudioWorkletProcessor {
readonly port = {
onmessage: null as ((event: { data: { type?: string } }) => void) | null,
postMessage,
};
}
let Processor: (new (options: {
processorOptions: {
targetSampleRate: number;
chunkSamples: number;
};
}) => {
port: FakeAudioWorkletProcessor['port'];
process: (inputs: Float32Array[][]) => boolean;
}) | null = null;
const loadModule = new Function(
'AudioWorkletProcessor',
'registerProcessor',
'sampleRate',
voicePcmWorkletSource,
);
loadModule(
FakeAudioWorkletProcessor,
(_name: string, constructor: typeof Processor) => {
Processor = constructor;
},
4,
);
const processor = new Processor!({
processorOptions: {
targetSampleRate: 8,
chunkSamples: 8,
},
});
expect(processor.process([[
Float32Array.from([0, 1, 0, -1]),
]])).toBe(true);
processor.port.onmessage?.({ data: { type: 'stop' } });
const sampleMessage = postMessage.mock.calls[0]?.[0] as {
type: string;
samples: ArrayBuffer;
};
expect(sampleMessage.type).toBe('samples');
expect(Array.from(new Int16Array(sampleMessage.samples))).toEqual([
0,
16384,
32767,
16384,
0,
-16384,
-32768,
-32768,
]);
expect(postMessage.mock.calls.at(-1)?.[0]).toEqual({ type: 'stopped' });
});
});
describe('deleteMapValueIfCurrent', () => {
it('cannot let an old finalizer delete a replacement session', () => {
const oldSession = {};
const replacement = {};
const sessions = new Map([['session', replacement]]);
expect(deleteMapValueIfCurrent(sessions, 'session', oldSession)).toBe(false);
expect(sessions.get('session')).toBe(replacement);
expect(deleteMapValueIfCurrent(sessions, 'session', replacement)).toBe(true);
});
});
describe('voice capture ownership', () => {
// One lock manager shared by independently loaded JS realms. Callbacks are
// asynchronous, as in Web Locks; stealing rejects the previous request.
const installLocks = () => {
let current: { reject: (error: unknown) => void } | null = null;
const locks = {
request: vi.fn((_name: string, options: { steal?: boolean }, callback: () => Promise<void>) =>
new Promise<void>((resolve, reject) => {
queueMicrotask(() => {
if (options.steal) current?.reject(new DOMException('lock stolen', 'AbortError'));
const owner = { reject };
current = owner;
void callback().then(() => {
if (current === owner) current = null;
resolve();
}, reject);
});
})),
};
Object.defineProperty(navigator, 'locks', { configurable: true, value: locks });
return locks;
};
const anotherRealm = async () => {
vi.resetModules();
return import('./voiceRecording');
};
it('preserves captured samples when another realm steals the lock', async () => {
installLocks();
const main = await anotherRealm();
const pet = await anotherRealm();
const recording = setup();
await recording.pipeline.start();
recording.capture().emit(123, 456);
const finish = vi.fn(() => recording.pipeline.finish());
const oldOwner = main.claimVoiceCapture(finish);
await oldOwner.ready;
const newOwner = pet.claimVoiceCapture(vi.fn());
await newOwner.ready;
await vi.waitFor(() => expect(finish).toHaveBeenCalledOnce());
expect(oldOwner.isCurrent()).toBe(false);
expect(newOwner.isCurrent()).toBe(true);
recording.capture().settle();
expect(recording.onSegment).toHaveBeenCalledOnce();
expect(await wavSamples(recording.onSegment.mock.calls[0][0])).toEqual([123, 456]);
oldOwner.release();
expect(newOwner.isCurrent()).toBe(true);
newOwner.release();
});
it('orders simultaneous independent-realm claims with the newest owning capture', async () => {
installLocks();
const main = await anotherRealm();
const pet = await anotherRealm();
const finishMain = vi.fn();
const first = main.claimVoiceCapture(finishMain);
const last = pet.claimVoiceCapture(vi.fn());
await Promise.allSettled([first.ready, last.ready]);
await vi.waitFor(() => expect(finishMain).toHaveBeenCalledOnce());
expect(first.isCurrent()).toBe(false);
expect(last.isCurrent()).toBe(true);
first.release();
expect(last.isCurrent()).toBe(true);
last.release();
});
it('finishes the previous surface and ignores its stale release', () => {
const finishChat = vi.fn();
const finishShowPage = vi.fn();
const chat = claimVoiceCapture(finishChat);
const showPage = claimVoiceCapture(finishShowPage);
expect(finishChat).toHaveBeenCalledOnce();
expect(chat.isCurrent()).toBe(false);
expect(showPage.isCurrent()).toBe(true);
chat.release();
expect(showPage.isCurrent()).toBe(true);
showPage.release();
const next = claimVoiceCapture(vi.fn());
expect(finishShowPage).not.toHaveBeenCalled();
next.release();
});
it('keeps local replacement semantics when Web Locks is unavailable', () => {
const previousDescriptor = Object.getOwnPropertyDescriptor(navigator, 'locks');
Reflect.deleteProperty(navigator, 'locks');
const previousFinish = vi.fn();
const nextFinish = vi.fn();
const previous = claimVoiceCapture(previousFinish);
const next = claimVoiceCapture(nextFinish);
expect(previous.isCurrent()).toBe(false);
expect(next.isCurrent()).toBe(true);
expect(previousFinish).toHaveBeenCalledOnce();
previous.release();
expect(next.isCurrent()).toBe(true);
next.release();
expect(next.isCurrent()).toBe(false);
if (previousDescriptor) Object.defineProperty(navigator, 'locks', previousDescriptor);
});
it('finishes an old owner through the Web Lock steal path without double finishing', async () => {
installLocks();
const previousFinish = vi.fn();
const nextFinish = vi.fn();
const previous = claimVoiceCapture(previousFinish);
await previous.ready;
const next = claimVoiceCapture(nextFinish);
await expect(next.ready).resolves.toBeUndefined();
await Promise.resolve();
expect(previousFinish).toHaveBeenCalledOnce();
expect(next.isCurrent()).toBe(true);
next.release();
});
it('makes the newest simultaneous claim the owner', async () => {
installLocks();
const firstFinish = vi.fn();
const secondFinish = vi.fn();
const first = claimVoiceCapture(firstFinish);
const second = claimVoiceCapture(secondFinish);
await expect(second.ready).resolves.toBeUndefined();
await Promise.resolve();
expect(first.isCurrent()).toBe(false);
expect(second.isCurrent()).toBe(true);
expect(firstFinish).toHaveBeenCalledOnce();
second.release();
});
});
describe('isVoiceControlDisabled', () => {
it('requires explicit discard before a retained recording can be replaced', () => {
expect(isVoiceControlDisabled(false, false, false, true)).toBe(true);
expect(isVoiceControlDisabled(false, true, false, true)).toBe(false);
});
});