@assistant-ui/react 0.15.32 → 0.15.33

package/src/adapters/gemini-live/audio.test.ts

@@ -0,0 +1,880 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  WORKLET_SOURCE,
+  createPcmPlayer,
+  createResampler,
+  decodePcm16,
+  encodePcm16,
+  openMicrophone,
+  readLevel,
+} from "./audio";
+
+class FakeTrack {
+  enabled = true;
+  stop = vi.fn();
+}
+
+class FakeSource {
+  buffer: unknown = null;
+  onended: (() => void) | null = null;
+  connect = vi.fn();
+  start = vi.fn();
+  stop = vi.fn();
+}
+
+class FakeWorklet {
+  static instances: FakeWorklet[] = [];
+  port: { onmessage: ((event: { data: unknown }) => void) | null } = {
+    onmessage: null,
+  };
+  connect = vi.fn();
+  disconnect = vi.fn();
+  options: unknown;
+  constructor(_context: unknown, _name: string, options?: unknown) {
+    this.options = options;
+    FakeWorklet.instances.push(this);
+  }
+}
+
+class FakeContext {
+  static instances: FakeContext[] = [];
+  static workletSupported = true;
+  currentTime = 0;
+  state = "running";
+  sampleRate: number;
+  sources: FakeSource[] = [];
+  destination = {};
+  static addModule: (url: string) => Promise<void> = async () => {};
+  audioWorklet = FakeContext.workletSupported
+    ? { addModule: vi.fn((url: string) => FakeContext.addModule(url)) }
+    : undefined;
+  mediaSource = { connect: vi.fn(), disconnect: vi.fn() };
+  processor = {
+    connect: vi.fn(),
+    disconnect: vi.fn(),
+    onaudioprocess: null as ((event: unknown) => void) | null,
+  };
+  analyser = { fftSize: 0, connect: vi.fn(), getByteTimeDomainData: vi.fn() };
+  constructor(options?: { sampleRate: number }) {
+    this.sampleRate = options?.sampleRate ?? 48000;
+    FakeContext.instances.push(this);
+  }
+  createAnalyser = vi.fn(() => this.analyser);
+  createMediaStreamSource = vi.fn(() => this.mediaSource);
+  createScriptProcessor = vi.fn(
+    (_bufferSize: number, _inputChannels: number, _outputChannels: number) =>
+      this.processor,
+  );
+  createBuffer = vi.fn((_channels: number, length: number, rate: number) => ({
+    duration: length / rate,
+    copyToChannel: vi.fn(),
+  }));
+  createBufferSource = vi.fn(() => {
+    const source = new FakeSource();
+    this.sources.push(source);
+    return source;
+  });
+  resume: () => Promise<void> = vi.fn(async () => {});
+  close = vi.fn(async () => {
+    if (this.state === "closed")
+      throw new DOMException(
+        "AudioContext is already closed",
+        "InvalidStateError",
+      );
+    this.state = "closed";
+  });
+}
+
+const installBrowser = () => {
+  const track = new FakeTrack();
+  const getUserMedia = vi.fn(async () => ({
+    getTracks: () => [track],
+    getAudioTracks: () => [track],
+  }));
+  const createObjectURL = vi.fn(() => "blob:worklet");
+  const revokeObjectURL = vi.fn();
+  vi.stubGlobal("AudioContext", FakeContext);
+  vi.stubGlobal("AudioWorkletNode", FakeWorklet);
+  vi.stubGlobal("URL", { createObjectURL, revokeObjectURL });
+  vi.stubGlobal("navigator", { mediaDevices: { getUserMedia } });
+  return { track, getUserMedia, createObjectURL, revokeObjectURL };
+};
+
+const chunk = (length: number) =>
+  encodePcm16(new Float32Array(length).fill(0.1));
+
+describe("pcm", () => {
+  it("round-trips samples through little-endian int16", () => {
+    const samples = Float32Array.from({ length: 1000 }, (_, i) =>
+      Math.sin(i / 10),
+    );
+    const decoded = decodePcm16(encodePcm16(samples));
+    expect(decoded.length).toBe(1000);
+    for (let i = 0; i < samples.length; i++) {
+      expect(Math.abs(decoded[i]! - samples[i]!)).toBeLessThan(2 / 32768);
+    }
+  });
+  it("clamps out-of-range samples", () => {
+    const decoded = decodePcm16(encodePcm16(Float32Array.from([2, -2])));
+    expect(decoded[0]).toBeCloseTo(1, 3);
+    expect(decoded[1]).toBe(-1);
+  });
+  it("round-trips an empty buffer", () => {
+    expect(encodePcm16(new Float32Array(0))).toBe("");
+    expect(decodePcm16("").length).toBe(0);
+  });
+  it("encodes buffers longer than one fromCharCode chunk", () => {
+    const samples = new Float32Array(40000).fill(0.5);
+    expect(decodePcm16(encodePcm16(samples)).length).toBe(40000);
+  });
+});
+describe("level", () => {
+  const analyser = (fill: (i: number) => number) =>
+    ({
+      fftSize: 256,
+      getByteTimeDomainData: (data: Uint8Array) => {
+        for (let i = 0; i < data.length; i++) data[i] = fill(i);
+      },
+    }) as unknown as AnalyserNode;
+  it("is 0 for silence", () => {
+    expect(readLevel(analyser(() => 128))).toBe(0);
+  });
+  it("is 1 for a full-swing square wave", () => {
+    expect(readLevel(analyser((i) => (i % 2 ? 255 : 0)))).toBe(1);
+  });
+  it("never exceeds 1", () => {
+    expect(readLevel(analyser(() => 255))).toBeLessThanOrEqual(1);
+  });
+});
+
+const ramp = (start: number, length: number, scale = 1) =>
+  Float32Array.from({ length }, (_, i) => (start + i) * scale);
+
+const tone = (
+  frequency: number,
+  sampleRate: number,
+  start: number,
+  length: number,
+) =>
+  Float32Array.from({ length }, (_, i) =>
+    Math.sin((2 * Math.PI * frequency * (start + i)) / sampleRate),
+  );
+
+const rms = (samples: number[]) =>
+  Math.sqrt(
+    samples.reduce((sum, sample) => sum + sample * sample, 0) / samples.length,
+  );
+
+const loadWorklet = (sampleRate: number, targetRate: number) => {
+  const posted: Float32Array[] = [];
+  class AudioWorkletProcessor {
+    port = { postMessage: (data: Float32Array) => posted.push(data) };
+  }
+  let Processor:
+    | (new (options: { processorOptions: { targetRate: number } }) => {
+        process: (inputs: Float32Array[][]) => boolean;
+      })
+    | undefined;
+  new Function(
+    "AudioWorkletProcessor",
+    "sampleRate",
+    "registerProcessor",
+    WORKLET_SOURCE,
+  )(AudioWorkletProcessor, sampleRate, (_: string, cls: typeof Processor) => {
+    Processor = cls;
+  });
+  const processor = new Processor!({ processorOptions: { targetRate } });
+  return {
+    process: (...channels: Float32Array[]) => processor.process([channels]),
+    posted,
+  };
+};
+
+const resampleWithWorklet = (frequency: number, sampleRate = 48000) => {
+  const worklet = loadWorklet(sampleRate, 16000);
+  const input = tone(frequency, sampleRate, 0, sampleRate);
+  for (let start = 0; start < input.length; start += 128)
+    worklet.process(input.subarray(start, start + 128));
+  return worklet.posted.flatMap((data) => [...data]);
+};
+
+describe("resampler", () => {
+  it.each([
+    [48000, 1365],
+    [44100, 1486],
+  ])(
+    "keeps phase and filter state across 2048-frame buffers at %i Hz",
+    (rate, count) => {
+      const ratio = rate / 16000;
+      const input = ramp(0, 4096);
+      const expected = [...createResampler(ratio)(input)];
+      const resample = createResampler(ratio);
+      const out = [...resample(ramp(0, 2048)), ...resample(ramp(2048, 2048))];
+      expect(out).toHaveLength(count);
+      expect(out).toEqual(expected);
+    },
+  );
+
+  it("interpolates across the boundary between buffers", () => {
+    const input = ramp(0, 6);
+    const expected = [...createResampler(2.5)(input)];
+    const resample = createResampler(2.5);
+    expect([...resample(ramp(0, 3)), ...resample(ramp(3, 3))]).toEqual(
+      expected,
+    );
+  });
+
+  it("ignores empty buffers", () => {
+    const resample = createResampler(3);
+    expect(resample(new Float32Array(0))).toHaveLength(0);
+    const out = [...resample(ramp(0, 5))];
+    expect(out).toHaveLength(2);
+    expect(out).toEqual([...createResampler(3)(ramp(0, 5))]);
+  });
+
+  it("attenuates tones above Nyquist while retaining speech-band tones in both paths", () => {
+    for (const sampleRate of [48000, 44100]) {
+      const ratio = sampleRate / 16000;
+      const scriptHigh = [
+        ...createResampler(ratio)(tone(12000, sampleRate, 0, sampleRate)),
+      ];
+      const scriptSpeech = [
+        ...createResampler(ratio)(tone(4000, sampleRate, 0, sampleRate)),
+      ];
+      const workletHigh = resampleWithWorklet(12000, sampleRate);
+      const workletSpeech = resampleWithWorklet(4000, sampleRate);
+
+      for (const { high, speech } of [
+        { high: scriptHigh, speech: scriptSpeech },
+        { high: workletHigh, speech: workletSpeech },
+      ]) {
+        expect(rms(high.slice(100))).toBeLessThan(0.05);
+        expect(rms(speech.slice(100))).toBeGreaterThan(0.65);
+      }
+    }
+  });
+
+  it("produces the same output in the worklet", () => {
+    const worklet = loadWorklet(44100, 16000);
+    const resample = createResampler(44100 / 16000);
+    const expected: number[] = [];
+    for (let block = 0; block < 32; block++) {
+      const input = ramp(block * 128, 128, 1 / 4096);
+      worklet.process(input);
+      expected.push(...resample(input));
+    }
+    const out = worklet.posted.flatMap((data) => [...data]);
+    expect(expected).toHaveLength(1486);
+    expect(out.length).toBeGreaterThan(1486 - 320);
+    expect(out.length).toBeLessThanOrEqual(1486);
+    expect(out).toEqual(expected.slice(0, out.length));
+  });
+
+  it("posts the worklet output in 20 ms chunks", () => {
+    const worklet = loadWorklet(48000, 16000);
+    for (let block = 0; block < 16; block++) worklet.process(ramp(0, 128));
+    expect(worklet.posted).toHaveLength(2);
+    for (const data of worklet.posted)
+      expect(data.length).toBeGreaterThanOrEqual(320);
+  });
+
+  it("downmixes every input channel in the worklet", () => {
+    const worklet = loadWorklet(16000, 16000);
+    for (let block = 0; block < 3; block++)
+      worklet.process(new Float32Array(128), new Float32Array(128).fill(0.5));
+    const out = worklet.posted.flatMap((data) => [...data]);
+    expect(out.length).toBeGreaterThan(0);
+    for (const value of out) expect(value).toBeCloseTo(0.25, 6);
+  });
+});
+
+describe("microphone", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    FakeContext.instances = [];
+    FakeContext.workletSupported = true;
+    FakeContext.addModule = async () => {};
+    FakeWorklet.instances = [];
+  });
+
+  it("requests the microphone and opens a context at the device rate", async () => {
+    const browser = installBrowser();
+    await openMicrophone({ sampleRate: 16000, onChunk: () => {} });
+    expect(browser.getUserMedia).toHaveBeenCalledWith({ audio: true });
+    expect(FakeContext.instances[0]?.sampleRate).toBe(48000);
+  });
+
+  it("resumes a suspended capture context", async () => {
+    installBrowser();
+    vi.stubGlobal(
+      "AudioContext",
+      class extends FakeContext {
+        override state = "suspended";
+      },
+    );
+    await openMicrophone({ sampleRate: 16000, onChunk: () => {} });
+    expect(FakeContext.instances[0]?.resume).toHaveBeenCalled();
+  });
+
+  it("passes the target rate to the worklet", async () => {
+    installBrowser();
+    await openMicrophone({ sampleRate: 16000, onChunk: () => {} });
+    expect(FakeWorklet.instances[0]?.options).toEqual({
+      processorOptions: { targetRate: 16000 },
+    });
+  });
+
+  it("loads the worklet from a blob url and revokes it", async () => {
+    const browser = installBrowser();
+    await openMicrophone({ sampleRate: 16000, onChunk: () => {} });
+    expect(
+      FakeContext.instances[0]?.audioWorklet?.addModule,
+    ).toHaveBeenCalledWith("blob:worklet");
+    expect(browser.revokeObjectURL).toHaveBeenCalledWith("blob:worklet");
+  });
+
+  it("forwards worklet chunks as base64", async () => {
+    installBrowser();
+    const onChunk = vi.fn();
+    await openMicrophone({ sampleRate: 16000, onChunk });
+    const samples = Float32Array.from([0.5, -0.5]);
+    FakeWorklet.instances[0]?.port.onmessage?.({ data: samples });
+    expect(onChunk).toHaveBeenCalledWith(encodePcm16(samples));
+  });
+
+  it("falls back to a script processor without worklet support", async () => {
+    FakeContext.workletSupported = false;
+    installBrowser();
+    const onChunk = vi.fn();
+    await openMicrophone({ sampleRate: 16000, onChunk });
+    const context = FakeContext.instances[0]!;
+    expect(context.createScriptProcessor).toHaveBeenCalledWith(1024, 1, 1);
+    expect(context.mediaSource.connect).toHaveBeenCalledWith(context.analyser);
+    expect(context.analyser.connect).toHaveBeenCalledWith(context.processor);
+    expect(context.processor.connect).toHaveBeenCalledWith(context.destination);
+    const samples = Float32Array.from([0, 0.3, 0.6, 0.9, 1.2, 1.5]);
+    context.processor.onaudioprocess?.({
+      inputBuffer: { getChannelData: () => samples },
+    });
+    expect(decodePcm16(onChunk.mock.calls[0]![0] as string)).toHaveLength(2);
+    expect(FakeWorklet.instances).toHaveLength(0);
+  });
+
+  it.each([
+    [48000, 3, 683],
+    [44100, 2.75625, 743],
+  ])(
+    "keeps fallback chunks below 25 ms at %i Hz without losing samples",
+    async (rate, ratio, count) => {
+      FakeContext.workletSupported = false;
+      installBrowser();
+      vi.stubGlobal(
+        "AudioContext",
+        class extends FakeContext {
+          constructor() {
+            super({ sampleRate: rate });
+          }
+        },
+      );
+      const onChunk = vi.fn();
+      await openMicrophone({ sampleRate: 16000, onChunk });
+      const context = FakeContext.instances[0]!;
+      const size = context.createScriptProcessor.mock.calls[0]![0];
+      expect(size / rate).toBeLessThan(0.025);
+      const inputs = [0, size].map((start) => ramp(start, size, 1 / 8192));
+      const resample = createResampler(ratio);
+      const expected = inputs.flatMap((input) => [...resample(input)]);
+      for (const input of inputs)
+        context.processor.onaudioprocess?.({
+          inputBuffer: { getChannelData: () => input },
+        });
+      const out = onChunk.mock.calls.flatMap(([base64]) => [
+        ...decodePcm16(base64 as string),
+      ]);
+      expect(out).toHaveLength(count);
+      for (const [k, value] of out.entries())
+        expect(value).toBeCloseTo(expected[k]!, 4);
+    },
+  );
+
+  it("captures with the fallback when the worklet module is blocked", async () => {
+    FakeContext.addModule = async () => {
+      throw new DOMException("Blocked by CSP", "SecurityError");
+    };
+    const browser = installBrowser();
+    const onChunk = vi.fn();
+    const microphone = await openMicrophone({ sampleRate: 16000, onChunk });
+    const context = FakeContext.instances[0]!;
+    const handler = context.processor.onaudioprocess!;
+    const samples = Float32Array.from([0, 0, 0, 0.5, 0, 0]);
+    const event = {
+      inputBuffer: {
+        getChannelData: () => samples,
+      },
+    };
+    handler(event);
+    expect(onChunk).toHaveBeenCalledWith(
+      encodePcm16(createResampler(3)(samples)),
+    );
+    expect(browser.track.stop).not.toHaveBeenCalled();
+    expect(browser.revokeObjectURL).toHaveBeenCalledWith("blob:worklet");
+    expect(FakeWorklet.instances).toHaveLength(0);
+    microphone.setMuted(true);
+    handler(event);
+    expect(onChunk).toHaveBeenCalledTimes(1);
+    microphone.setMuted(false);
+    await microphone.close();
+    handler(event);
+    expect(onChunk).toHaveBeenCalledTimes(1);
+    expect(context.processor.onaudioprocess).toBeNull();
+    expect(browser.track.stop).toHaveBeenCalled();
+    expect(context.close).toHaveBeenCalled();
+  });
+
+  it("stops the tracks and closes the context when both capture paths fail", async () => {
+    FakeContext.addModule = async () => {
+      throw new Error("bad module");
+    };
+    const browser = installBrowser();
+    vi.stubGlobal(
+      "AudioContext",
+      class extends FakeContext {
+        override createScriptProcessor = vi.fn(() => {
+          throw new Error("processor unavailable");
+        });
+      },
+    );
+    await expect(
+      openMicrophone({ sampleRate: 16000, onChunk: () => {} }),
+    ).rejects.toThrow("processor unavailable");
+    expect(browser.track.stop).toHaveBeenCalled();
+    expect(FakeContext.instances[0]?.close).toHaveBeenCalled();
+    expect(browser.revokeObjectURL).toHaveBeenCalledWith("blob:worklet");
+    expect(FakeWorklet.instances).toHaveLength(0);
+  });
+
+  it.each([false, true])(
+    "cleans up an aborted setup when the module rejects: %s",
+    async (rejectModule) => {
+      let finishModule!: () => void;
+      FakeContext.addModule = () =>
+        new Promise<void>((resolve, reject) => {
+          finishModule = rejectModule
+            ? () => reject(new Error("blocked module"))
+            : resolve;
+        });
+      const browser = installBrowser();
+      const controller = new AbortController();
+      const opening = openMicrophone({
+        sampleRate: 16000,
+        onChunk: () => {},
+        signal: controller.signal,
+      });
+      await vi.waitFor(() =>
+        expect(
+          FakeContext.instances[0]?.audioWorklet?.addModule,
+        ).toHaveBeenCalled(),
+      );
+      controller.abort(new Error("cancelled"));
+      finishModule();
+      await expect(opening).rejects.toThrow("cancelled");
+      expect(browser.track.stop).toHaveBeenCalled();
+      expect(FakeContext.instances[0]?.close).toHaveBeenCalled();
+      expect(
+        FakeContext.instances[0]?.createScriptProcessor,
+      ).not.toHaveBeenCalled();
+      expect(FakeWorklet.instances).toHaveLength(0);
+    },
+  );
+
+  it("mutes by disabling the track and dropping chunks", async () => {
+    const browser = installBrowser();
+    const onChunk = vi.fn();
+    const microphone = await openMicrophone({ sampleRate: 16000, onChunk });
+    const samples = Float32Array.from([0.5]);
+    microphone.setMuted(true);
+    expect(browser.track.enabled).toBe(false);
+    FakeWorklet.instances[0]?.port.onmessage?.({ data: samples });
+    expect(onChunk).not.toHaveBeenCalled();
+    microphone.setMuted(false);
+    expect(browser.track.enabled).toBe(true);
+    FakeWorklet.instances[0]?.port.onmessage?.({ data: samples });
+    expect(onChunk).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops worklet messages that arrive after close", async () => {
+    installBrowser();
+    const onChunk = vi.fn();
+    const microphone = await openMicrophone({ sampleRate: 16000, onChunk });
+    const worklet = FakeWorklet.instances[0]!;
+    const handler = worklet.port.onmessage;
+    await microphone.close();
+    expect(worklet.port.onmessage).toBeNull();
+    handler?.({ data: Float32Array.from([0.5]) });
+    expect(onChunk).not.toHaveBeenCalled();
+  });
+
+  it("closes the graph, the tracks, and the context", async () => {
+    const browser = installBrowser();
+    const microphone = await openMicrophone({
+      sampleRate: 16000,
+      onChunk: () => {},
+    });
+    await microphone.close();
+    const context = FakeContext.instances[0]!;
+    expect(FakeWorklet.instances[0]?.disconnect).toHaveBeenCalled();
+    expect(context.mediaSource.disconnect).toHaveBeenCalled();
+    expect(browser.track.stop).toHaveBeenCalled();
+    expect(context.close).toHaveBeenCalled();
+  });
+
+  it("rejects without requesting permission when already aborted", async () => {
+    const browser = installBrowser();
+    const controller = new AbortController();
+    controller.abort(new Error("cancelled"));
+    await expect(
+      openMicrophone({
+        sampleRate: 16000,
+        onChunk: () => {},
+        signal: controller.signal,
+      }),
+    ).rejects.toThrow("cancelled");
+    expect(browser.getUserMedia).not.toHaveBeenCalled();
+    expect(FakeContext.instances).toHaveLength(0);
+  });
+
+  it.each(["granted", "denied"])(
+    "cancels a pending permission request before it is %s",
+    async (permission) => {
+      const browser = installBrowser();
+      let grant!: (
+        stream: Awaited<ReturnType<typeof browser.getUserMedia>>,
+      ) => void;
+      let deny!: (reason: unknown) => void;
+      browser.getUserMedia.mockReturnValue(
+        new Promise((resolve, reject) => {
+          grant = resolve;
+          deny = reject;
+        }),
+      );
+      const controller = new AbortController();
+      const onError = vi.fn();
+      const opening = openMicrophone({
+        sampleRate: 16000,
+        onChunk: () => {},
+        signal: controller.signal,
+      }).catch(onError);
+      const reason = new Error("cancelled");
+      controller.abort(reason);
+      try {
+        await new Promise<void>((resolve) => setImmediate(resolve));
+        expect(onError).toHaveBeenCalledWith(reason);
+        expect(FakeContext.instances).toHaveLength(0);
+      } finally {
+        if (permission === "granted")
+          grant({
+            getTracks: () => [browser.track],
+            getAudioTracks: () => [browser.track],
+          });
+        else deny(new DOMException("Permission denied", "NotAllowedError"));
+        await opening;
+        await new Promise<void>((resolve) => setImmediate(resolve));
+      }
+      expect(onError).toHaveBeenCalledTimes(1);
+      expect(browser.track.stop).toHaveBeenCalledTimes(
+        permission === "granted" ? 1 : 0,
+      );
+      expect(FakeContext.instances).toHaveLength(0);
+    },
+  );
+
+  it("shares pending microphone cleanup across repeated close calls", async () => {
+    const browser = installBrowser();
+    const microphone = await openMicrophone({
+      sampleRate: 16000,
+      onChunk: () => {},
+    });
+    const context = FakeContext.instances[0]!;
+    let finishClose!: () => void;
+    context.close.mockImplementation(() => {
+      if (context.state === "closed")
+        return Promise.reject(
+          new DOMException("Already closed", "InvalidStateError"),
+        );
+      context.state = "closed";
+      return new Promise<void>((resolve) => {
+        finishClose = resolve;
+      });
+    });
+    const settled = vi.fn();
+    const first = microphone.close().then(settled);
+    const second = microphone.close().then(settled);
+    const both = Promise.allSettled([first, second]);
+    await Promise.resolve();
+    expect(settled).not.toHaveBeenCalled();
+    finishClose();
+    expect(await both).toEqual([
+      { status: "fulfilled", value: undefined },
+      { status: "fulfilled", value: undefined },
+    ]);
+    await expect(microphone.close()).resolves.toBeUndefined();
+    expect(context.close).toHaveBeenCalledTimes(1);
+    expect(browser.track.stop).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases a stream when cancellation wins just after permission resolves", async () => {
+    const browser = installBrowser();
+    let grant!: (
+      stream: Awaited<ReturnType<typeof browser.getUserMedia>>,
+    ) => void;
+    browser.getUserMedia.mockReturnValue(
+      new Promise((resolve) => {
+        grant = resolve;
+      }),
+    );
+    const controller = new AbortController();
+    const opening = openMicrophone({
+      sampleRate: 16000,
+      onChunk: () => {},
+      signal: controller.signal,
+    });
+    const reason = new Error("cancelled");
+    grant({
+      getTracks: () => [browser.track],
+      getAudioTracks: () => [browser.track],
+    });
+    queueMicrotask(() => controller.abort(reason));
+    await expect(opening).rejects.toBe(reason);
+    expect(browser.track.stop).toHaveBeenCalledTimes(1);
+  });
+
+  it.each(["resume", "worklet"])(
+    "releases the microphone without waiting for pending %s",
+    async (stage) => {
+      const browser = installBrowser();
+      let finish!: () => void;
+      const pending = new Promise<void>((resolve) => {
+        finish = resolve;
+      });
+      if (stage === "worklet") FakeContext.addModule = () => pending;
+      else
+        vi.stubGlobal(
+          "AudioContext",
+          class extends FakeContext {
+            override state = "suspended";
+            override resume = () => pending;
+          },
+        );
+      const controller = new AbortController();
+      const onError = vi.fn();
+      const opening = openMicrophone({
+        sampleRate: 16000,
+        onChunk: () => {},
+        signal: controller.signal,
+      }).catch(onError);
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      const context = FakeContext.instances[0]!;
+      const reason = new Error("cancelled");
+      controller.abort(reason);
+      try {
+        await new Promise<void>((resolve) => setImmediate(resolve));
+        expect(onError).toHaveBeenCalledWith(reason);
+        expect(browser.track.stop).toHaveBeenCalledTimes(1);
+        expect(context.state).toBe("closed");
+      } finally {
+        finish();
+        await opening;
+        await new Promise<void>((resolve) => setImmediate(resolve));
+      }
+      expect(FakeWorklet.instances).toHaveLength(0);
+      expect(context.createScriptProcessor).not.toHaveBeenCalled();
+      expect(context.close).toHaveBeenCalledTimes(1);
+      if (stage === "worklet")
+        expect(browser.revokeObjectURL).toHaveBeenCalledWith("blob:worklet");
+    },
+  );
+});
+
+describe("playback", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    FakeContext.instances = [];
+  });
+
+  const setup = (onIdle?: () => void) => {
+    vi.stubGlobal("AudioContext", FakeContext);
+    const player = createPcmPlayer(
+      onIdle ? { sampleRate: 24000, onIdle } : { sampleRate: 24000 },
+    );
+    return { player, context: FakeContext.instances[0]! };
+  };
+
+  it("copies the decoded samples into the buffer", () => {
+    const { player, context } = setup();
+    const samples = Float32Array.from([0.5, -0.25]);
+    player.enqueue(encodePcm16(samples));
+    const buffer = context.createBuffer.mock.results[0]!.value;
+    expect(context.createBuffer).toHaveBeenCalledWith(1, 2, 24000);
+    const copied = buffer.copyToChannel.mock.calls[0]![0] as Float32Array;
+    expect(copied[0]).toBeCloseTo(0.5, 3);
+    expect(copied[1]).toBeCloseTo(-0.25, 3);
+    expect(buffer.copyToChannel).toHaveBeenCalledWith(copied, 0);
+  });
+
+  it("schedules chunks back to back from the current time", () => {
+    const { player, context } = setup();
+    context.currentTime = 1;
+    player.enqueue(chunk(2400));
+    player.enqueue(chunk(2400));
+    expect(context.sources[0]?.start).toHaveBeenCalledWith(1);
+    expect(context.sources[1]?.start).toHaveBeenCalledWith(1.1);
+  });
+
+  it("never schedules in the past", () => {
+    const { player, context } = setup();
+    player.enqueue(chunk(2400));
+    context.currentTime = 5;
+    player.enqueue(chunk(2400));
+    expect(context.sources[1]?.start).toHaveBeenCalledWith(5);
+  });
+
+  it("reports playing until the last source ends", () => {
+    const { player, context } = setup();
+    player.enqueue(chunk(2400));
+    expect(player.isPlaying()).toBe(true);
+    context.sources[0]?.onended?.();
+    expect(player.isPlaying()).toBe(false);
+  });
+
+  it("calls onIdle once after the queue drains", () => {
+    vi.useFakeTimers();
+    const onIdle = vi.fn();
+    const { player, context } = setup(onIdle);
+    player.enqueue(chunk(2400));
+    player.enqueue(chunk(2400));
+    context.sources[0]?.onended?.();
+    vi.advanceTimersByTime(200);
+    expect(onIdle).not.toHaveBeenCalled();
+    context.sources[1]?.onended?.();
+    vi.advanceTimersByTime(200);
+    expect(onIdle).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not report idle across a short gap between chunks", () => {
+    vi.useFakeTimers();
+    const onIdle = vi.fn();
+    const { player, context } = setup(onIdle);
+    player.enqueue(chunk(2400));
+    context.sources[0]?.onended?.();
+    vi.advanceTimersByTime(50);
+    player.enqueue(chunk(2400));
+    vi.advanceTimersByTime(200);
+    expect(onIdle).not.toHaveBeenCalled();
+  });
+
+  it("clear stops every source and resets the cursor", () => {
+    vi.useFakeTimers();
+    const onIdle = vi.fn();
+    const { player, context } = setup(onIdle);
+    player.enqueue(chunk(2400));
+    player.enqueue(chunk(2400));
+    player.clear();
+    expect(context.sources[0]?.stop).toHaveBeenCalled();
+    expect(context.sources[1]?.stop).toHaveBeenCalled();
+    expect(player.isPlaying()).toBe(false);
+    vi.advanceTimersByTime(200);
+    expect(onIdle).not.toHaveBeenCalled();
+    context.currentTime = 0.05;
+    player.enqueue(chunk(2400));
+    expect(context.sources[2]?.start).toHaveBeenCalledWith(0.05);
+  });
+
+  it("skips empty chunks", () => {
+    const { player, context } = setup();
+    player.enqueue("");
+    expect(context.createBufferSource).not.toHaveBeenCalled();
+    expect(player.isPlaying()).toBe(false);
+  });
+
+  it("resumes a suspended context on enqueue", () => {
+    const { player, context } = setup();
+    context.state = "suspended";
+    player.enqueue(chunk(2400));
+    expect(context.resume).toHaveBeenCalled();
+  });
+
+  it("close stops sources and closes the context", async () => {
+    const { player, context } = setup();
+    player.enqueue(chunk(2400));
+    await player.close();
+    expect(context.sources[0]?.stop).toHaveBeenCalled();
+    expect(context.close).toHaveBeenCalled();
+  });
+
+  it("shares pending playback cleanup across repeated close calls", async () => {
+    const { player, context } = setup();
+    player.enqueue(chunk(2400));
+    let finishClose!: () => void;
+    context.close.mockImplementation(() => {
+      if (context.state === "closed")
+        return Promise.reject(
+          new DOMException("Already closed", "InvalidStateError"),
+        );
+      context.state = "closed";
+      return new Promise<void>((resolve) => {
+        finishClose = resolve;
+      });
+    });
+    const settled = vi.fn();
+    const first = player.close().then(settled);
+    const second = player.close().then(settled);
+    const both = Promise.allSettled([first, second]);
+    await Promise.resolve();
+    expect(settled).not.toHaveBeenCalled();
+    finishClose();
+    expect(await both).toEqual([
+      { status: "fulfilled", value: undefined },
+      { status: "fulfilled", value: undefined },
+    ]);
+    await expect(player.close()).resolves.toBeUndefined();
+    expect(context.close).toHaveBeenCalledTimes(1);
+    expect(context.sources[0]?.stop).toHaveBeenCalledTimes(1);
+  });
+
+  it("handles a pending resume rejected when playback closes", async () => {
+    vi.useFakeTimers();
+    const onIdle = vi.fn();
+    const { player, context } = setup(onIdle);
+    let rejectResume!: (reason: unknown) => void;
+    const resume = new Promise<void>((_resolve, reject) => {
+      rejectResume = reject;
+    });
+    context.state = "suspended";
+    context.resume = () => resume;
+    context.close.mockImplementation(async () => {
+      context.state = "closed";
+      rejectResume(
+        new DOMException("AudioContext closed", "InvalidStateError"),
+      );
+    });
+    player.enqueue(chunk(2400));
+    await player.close();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(context.state).toBe("closed");
+    expect(player.isPlaying()).toBe(false);
+    expect(onIdle).not.toHaveBeenCalled();
+  });
+
+  it("does not report idle for a source that ends after close", async () => {
+    vi.useFakeTimers();
+    const onIdle = vi.fn();
+    const { player, context } = setup(onIdle);
+    player.enqueue(chunk(2400));
+    await player.close();
+    expect(context.sources[0]?.onended).toBeNull();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(onIdle).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});