@kuralle-syrinx/server-websocket 4.2.0 → 4.4.0

package/src/admission-control.test.ts

@@ -1,270 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { createServer } from "node:http";
-import { describe, expect, it } from "vitest";
-import WebSocket, { WebSocketServer } from "ws";
-import { VoiceAgentSession } from "@kuralle-syrinx/core";
-import {
-  createSmartPbxMediaStreamServer,
-  createTelnyxMediaStreamServer,
-  createTwilioMediaStreamServer,
-  createVoiceWebSocketServer,
-} from "./index.js";
-import { TRANSPORT_ADMISSION_REJECTED_METRIC } from "./transport-host.js";
-import {
-  openBrowserSocketReady,
-  openSocket,
-  registerHttpServer,
-  registerServer,
-  registerSocket,
-  setupTransportTestCleanup,
-  waitForClose,
-  waitForCondition,
-} from "./test-helpers.js";
-
-setupTransportTestCleanup();
-
-function websocketUrl(port: number): string {
-  return `ws://127.0.0.1:${port}/ws`;
-}
-
-describe("WT-08 admission control and upgrade routing", () => {
-  it("rejects connections beyond maxConcurrentSessions with 1013 and transport.admission_rejected", async () => {
-    const metrics: string[] = [];
-    const server = registerServer(await createVoiceWebSocketServer({
-      port: 0,
-      maxConcurrentSessions: 2,
-      onTransportMetric: (name) => metrics.push(name),
-      createSession: () => new VoiceAgentSession({ plugins: {} }),
-    }));
-    const address = server.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const first = await openBrowserSocketReady(websocketUrl(address.port));
-    const second = await openBrowserSocketReady(websocketUrl(address.port));
-    expect(server.wsServer.clients.size).toBe(2);
-
-    const rejected = registerSocket(new WebSocket(websocketUrl(address.port)));
-    await new Promise<void>((resolveOpen, reject) => {
-      rejected.once("open", resolveOpen);
-      rejected.once("error", reject);
-    });
-    const closeCode = await waitForClose(rejected);
-
-    expect(closeCode).toBe(1013);
-    expect(metrics).toContain(TRANSPORT_ADMISSION_REJECTED_METRIC);
-
-    first.close();
-    second.close();
-    await server.close();
-  });
-
-  it("allows a new connection after an admitted session disconnects", async () => {
-    const server = registerServer(await createVoiceWebSocketServer({
-      port: 0,
-      maxConcurrentSessions: 1,
-      createSession: () => new VoiceAgentSession({ plugins: {} }),
-    }));
-    const address = server.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const first = await openBrowserSocketReady(websocketUrl(address.port));
-    first.close();
-    await waitForCondition(() => server.wsServer.clients.size === 0);
-
-    const second = await openBrowserSocketReady(websocketUrl(address.port));
-    expect(second.readyState).toBe(WebSocket.OPEN);
-
-    second.close();
-    await server.close();
-  });
-
-  it("rejects an unauthorized upgrade with 4401 and admits an authorized one", async () => {
-    const server = registerServer(await createVoiceWebSocketServer({
-      port: 0,
-      authorize: (request) => new URL(request.url ?? "/", "http://x").searchParams.get("token") === "secret",
-      createSession: () => new VoiceAgentSession({ plugins: {} }),
-    }));
-    const address = server.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const rejected = registerSocket(new WebSocket(`${websocketUrl(address.port)}?token=wrong`));
-    await new Promise<void>((resolve, reject) => {
-      rejected.once("open", resolve);
-      rejected.once("error", reject);
-    });
-    expect(await waitForClose(rejected)).toBe(4401);
-
-    const authorized = await openBrowserSocketReady(`${websocketUrl(address.port)}?token=secret`);
-    expect(authorized.readyState).toBe(WebSocket.OPEN);
-
-    authorized.close();
-    await server.close();
-  });
-
-  it("destroys sockets on unmatched upgrade paths when this router is the sole upgrade handler", async () => {
-    const httpServer = registerHttpServer(createServer());
-    const server = registerServer(await createVoiceWebSocketServer({
-      server: httpServer,
-      createSession: () => new VoiceAgentSession({ plugins: {} }),
-    }));
-    await new Promise<void>((resolveListen, reject) => {
-      httpServer.once("error", reject);
-      httpServer.listen(0, "127.0.0.1", () => {
-        httpServer.off("error", reject);
-        resolveListen();
-      });
-    });
-    const address = httpServer.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const unknownPathClient = registerSocket(
-      new WebSocket(`ws://127.0.0.1:${String(address.port)}/unknown-path`),
-    );
-    const closeCode = await waitForClose(unknownPathClient);
-    expect(closeCode).toBe(1006);
-
-    const registered = await openBrowserSocketReady(websocketUrl(address.port));
-    expect(registered.readyState).toBe(WebSocket.OPEN);
-
-    registered.close();
-    await server.close();
-    await new Promise<void>((resolveClose) => httpServer.close(() => resolveClose()));
-  });
-
-  it("leaves unmatched upgrade paths for co-registered upgrade listeners on a shared HTTP server", async () => {
-    const httpServer = registerHttpServer(createServer());
-    const server = registerServer(await createVoiceWebSocketServer({
-      server: httpServer,
-      createSession: () => new VoiceAgentSession({ plugins: {} }),
-    }));
-    const foreignPath = "/foreign-ws";
-    const foreignConnections: WebSocket[] = [];
-    const foreignListener = (
-      request: import("node:http").IncomingMessage,
-      socket: import("node:net").Socket,
-      head: Buffer,
-    ): void => {
-      if (new URL(request.url ?? "/", "http://localhost").pathname !== foreignPath) return;
-      const foreignServer = new WebSocketServer({ noServer: true });
-      foreignServer.handleUpgrade(request, socket, head, (websocket) => {
-        foreignConnections.push(websocket);
-        foreignServer.emit("connection", websocket, request);
-      });
-    };
-    httpServer.on("upgrade", foreignListener);
-    await new Promise<void>((resolveListen, reject) => {
-      httpServer.once("error", reject);
-      httpServer.listen(0, "127.0.0.1", () => {
-        httpServer.off("error", reject);
-        resolveListen();
-      });
-    });
-    const address = httpServer.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const foreignClient = await openSocket(`ws://127.0.0.1:${String(address.port)}${foreignPath}`, {
-      perMessageDeflate: false,
-    });
-    expect(foreignClient.readyState).toBe(WebSocket.OPEN);
-    expect(foreignConnections).toHaveLength(1);
-
-    foreignClient.close();
-    await server.close();
-    httpServer.off("upgrade", foreignListener);
-    await new Promise<void>((resolveClose) => httpServer.close(() => resolveClose()));
-  });
-
-  it("routes multiple provider websocket paths on a shared HTTP server without handshake cross-talk", async () => {
-    const httpServer = registerHttpServer(createServer());
-    const [twilio, telnyx, smartpbx] = await Promise.all([
-      registerServer(await createTwilioMediaStreamServer({
-        server: httpServer,
-        createSession: () => new VoiceAgentSession({ plugins: {} }),
-      })),
-      registerServer(await createTelnyxMediaStreamServer({
-        server: httpServer,
-        createSession: () => new VoiceAgentSession({ plugins: {} }),
-      })),
-      registerServer(await createSmartPbxMediaStreamServer({
-        server: httpServer,
-        createSession: () => new VoiceAgentSession({ plugins: {} }),
-      })),
-    ]);
-    await new Promise<void>((resolveListen, reject) => {
-      httpServer.once("error", reject);
-      httpServer.listen(0, "127.0.0.1", () => {
-        httpServer.off("error", reject);
-        resolveListen();
-      });
-    });
-    const address = httpServer.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const clients = await Promise.all([
-      openSocket(`ws://127.0.0.1:${String(address.port)}/twilio`, { perMessageDeflate: false }),
-      openSocket(`ws://127.0.0.1:${String(address.port)}/telnyx`, { perMessageDeflate: false }),
-      openSocket(`ws://127.0.0.1:${String(address.port)}/media-stream`, { perMessageDeflate: false }),
-    ]);
-    expect(clients.map((client) => client.readyState)).toEqual([
-      WebSocket.OPEN,
-      WebSocket.OPEN,
-      WebSocket.OPEN,
-    ]);
-
-    const scanner = registerSocket(
-      new WebSocket(`ws://127.0.0.1:${String(address.port)}/random-scanner-path`),
-    );
-    expect(await waitForClose(scanner)).toBe(1006);
-
-    for (const client of clients) client.close();
-    await Promise.all([twilio.close(), telnyx.close(), smartpbx.close()]);
-    await new Promise<void>((resolveClose) => httpServer.close(() => resolveClose()));
-  });
-
-  it("enforces a global shared-server cap when maxConcurrentSessionsScope is server", async () => {
-    const httpServer = registerHttpServer(createServer());
-    const metrics: string[] = [];
-    const [twilio, telnyx] = await Promise.all([
-      registerServer(await createTwilioMediaStreamServer({
-        server: httpServer,
-        maxConcurrentSessions: 1,
-        maxConcurrentSessionsScope: "server",
-        onTransportMetric: (name) => metrics.push(name),
-        createSession: () => new VoiceAgentSession({ plugins: {} }),
-      })),
-      registerServer(await createTelnyxMediaStreamServer({
-        server: httpServer,
-        maxConcurrentSessions: 1,
-        maxConcurrentSessionsScope: "server",
-        onTransportMetric: (name) => metrics.push(name),
-        createSession: () => new VoiceAgentSession({ plugins: {} }),
-      })),
-    ]);
-    await new Promise<void>((resolveListen, reject) => {
-      httpServer.once("error", reject);
-      httpServer.listen(0, "127.0.0.1", () => {
-        httpServer.off("error", reject);
-        resolveListen();
-      });
-    });
-    const address = httpServer.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP address");
-
-    const first = await openSocket(`ws://127.0.0.1:${String(address.port)}/twilio`, { perMessageDeflate: false });
-    expect(first.readyState).toBe(WebSocket.OPEN);
-
-    const second = registerSocket(new WebSocket(`ws://127.0.0.1:${String(address.port)}/telnyx`));
-    await new Promise<void>((resolveOpen, reject) => {
-      second.once("open", resolveOpen);
-      second.once("error", reject);
-    });
-    const closeCode = await waitForClose(second);
-    expect(closeCode).toBe(1013);
-    expect(metrics).toContain(TRANSPORT_ADMISSION_REJECTED_METRIC);
-
-    first.close();
-    await Promise.all([twilio.close(), telnyx.close()]);
-    await new Promise<void>((resolveClose) => httpServer.close(() => resolveClose()));
-  });
-});

package/src/background-audio.test.ts

@@ -1,224 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-
-import { BackgroundAudioMixer } from "./background-audio.js";
-
-function pcmBytes(samples: number[]): Uint8Array {
-  return new Uint8Array(Int16Array.from(samples).buffer.slice(0));
-}
-
-function samplesOf(bytes: Uint8Array): number[] {
-  return Array.from(new Int16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2));
-}
-
-/** Constant-value ambient source: every mixed sample adds value*gain. */
-function constantSource(value: number, length = 160, sampleRateHz = 16000) {
-  return { pcm: new Int16Array(length).fill(value), sampleRateHz };
-}
-
-describe("BackgroundAudioMixer", () => {
-  it("mixes ducked ambient into a TTS chunk and full-gain ambient into idle frames", () => {
-    const mixer = new BackgroundAudioMixer({
-      ambient: { ...constantSource(1000), gain: 0.5 },
-      duckWhileSpeaking: 0.5,
-      fadeMs: 0,
-    });
-
-    const t0 = 1_000_000;
-    const mixed = mixer.mix(pcmBytes([0, 0, 0, 0]), 16000, t0);
-    // ambient 1000 * gain 0.5 * duck 0.5 = 250 on top of silence
-    expect(samplesOf(mixed)).toEqual([250, 250, 250, 250]);
-
-    // Once speech has drained, the idle frame carries ambient at full gain.
-    const idle = mixer.idleFrame(1, 16000, t0 + 10_000);
-    expect(idle).not.toBeNull();
-    expect(samplesOf(idle!)).toEqual(Array(16).fill(500)); // 1ms @16k = 16 samples, 1000*0.5
-  });
-
-  it("suppresses idle frames while speech is still playing out", () => {
-    const mixer = new BackgroundAudioMixer({ ambient: constantSource(1000), fadeMs: 0 });
-    const t0 = 2_000_000;
-    // 160 samples @16k = 10ms of speech → speaking until t0+10.
-    mixer.mix(pcmBytes(Array(160).fill(0)), 16000, t0);
-    expect(mixer.isSpeaking(t0 + 5)).toBe(true);
-    expect(mixer.idleFrame(20, 16000, t0 + 5)).toBeNull();
-    expect(mixer.isSpeaking(t0 + 11)).toBe(false);
-    expect(mixer.idleFrame(20, 16000, t0 + 11)).not.toBeNull();
-  });
-
-  it("keeps the ambient position continuous across mix and idle frames", () => {
-    // Ramp source so position is observable: sample i has value i.
-    const ramp = Int16Array.from({ length: 1000 }, (_, i) => i);
-    const mixer = new BackgroundAudioMixer({
-      ambient: { pcm: ramp, sampleRateHz: 16000, gain: 1 },
-      duckWhileSpeaking: 1,
-      fadeMs: 0,
-    });
-    const t0 = 3_000_000;
-    const first = mixer.mix(pcmBytes([0, 0, 0, 0]), 16000, t0);
-    expect(samplesOf(first)).toEqual([0, 1, 2, 3]);
-    const idle = mixer.idleFrame(1, 16000, t0 + 1000);
-    expect(samplesOf(idle!)[0]).toBe(4); // continues where mix left off
-    const next = mixer.mix(pcmBytes([0, 0]), 16000, t0 + 2000);
-    expect(samplesOf(next)).toEqual([20, 21]); // 4 + 16 idle samples consumed
-  });
-
-  it("loops the ambient source past its end", () => {
-    const ramp = Int16Array.from({ length: 4 }, (_, i) => i + 1); // 1,2,3,4
-    const mixer = new BackgroundAudioMixer({
-      ambient: { pcm: ramp, sampleRateHz: 16000, gain: 1 },
-      duckWhileSpeaking: 1,
-      fadeMs: 0,
-    });
-    const mixed = mixer.mix(pcmBytes(Array(10).fill(0)), 16000, 4_000_000);
-    expect(samplesOf(mixed)).toEqual([1, 2, 3, 4, 1, 2, 3, 4, 1, 2]);
-  });
-
-  it("plays the thinking loop only while thinking, and restarts it fresh each episode", () => {
-    const ramp = Int16Array.from({ length: 100 }, (_, i) => i);
-    const mixer = new BackgroundAudioMixer({
-      thinking: { pcm: ramp, sampleRateHz: 16000, gain: 1 },
-      fadeMs: 0,
-    });
-    const t0 = 5_000_000;
-    expect(mixer.idleFrame(1, 16000, t0)).toBeNull(); // nothing to play
-
-    mixer.setThinking(true);
-    const a = mixer.idleFrame(1, 16000, t0);
-    expect(samplesOf(a!)).toEqual(Array.from({ length: 16 }, (_, i) => i));
-
-    mixer.setThinking(false);
-    expect(mixer.idleFrame(1, 16000, t0)).toBeNull();
-
-    mixer.setThinking(true); // new episode restarts at 0
-    const b = mixer.idleFrame(1, 16000, t0);
-    expect(samplesOf(b!)[0]).toBe(0);
-  });
-
-  it("resamples sources to the wire rate once and mixes correctly", () => {
-    // 8k constant source mixed into a 16k chunk: values unchanged, length follows the chunk.
-    const mixer = new BackgroundAudioMixer({
-      ambient: { pcm: new Int16Array(80).fill(800), sampleRateHz: 8000, gain: 1 },
-      duckWhileSpeaking: 1,
-      fadeMs: 0,
-    });
-    const mixed = mixer.mix(pcmBytes(Array(8).fill(0)), 16000, 6_000_000);
-    expect(samplesOf(mixed)).toEqual(Array(8).fill(800));
-  });
-
-  it("clips the sum to int16 range", () => {
-    const mixer = new BackgroundAudioMixer({
-      ambient: { pcm: new Int16Array(16).fill(20000), sampleRateHz: 16000, gain: 1 },
-      duckWhileSpeaking: 1,
-      fadeMs: 0,
-    });
-    const mixed = mixer.mix(pcmBytes([30000, -30000]), 16000, 7_000_000);
-    expect(samplesOf(mixed)).toEqual([32767, -10000]);
-  });
-
-  it("passes TTS through untouched when no sources are configured", () => {
-    const mixer = new BackgroundAudioMixer({});
-    const chunk = pcmBytes([1, 2, 3]);
-    expect(samplesOf(mixer.mix(chunk, 16000, 8_000_000))).toEqual([1, 2, 3]);
-    expect(mixer.idleFrame(20, 16000, 8_000_000)).toBeNull();
-    expect(mixer.hasSources).toBe(false);
-  });
-
-  it("fades the ambient bed in at start instead of hard-cutting (equal-power ramp)", () => {
-    // fadeMs 1 @ 16k = 16-sample ramp.
-    const mixer = new BackgroundAudioMixer({
-      ambient: { ...constantSource(1000), gain: 1 },
-      fadeMs: 1,
-    });
-    const first = mixer.idleFrame(1, 16000, 9_000_000)!;
-    const samples = samplesOf(first);
-    expect(samples[0]).toBe(0); // sin(0) = 0
-    expect(samples[8]!).toBeGreaterThan(400); // mid-ramp
-    expect(samples[8]!).toBeLessThan(900);
-    // Past the ramp: full gain, permanently.
-    const second = mixer.idleFrame(1, 16000, 9_000_100)!;
-    expect(samplesOf(second)).toEqual(Array(16).fill(1000));
-  });
-
-  it("fades the thinking loop out on stop, then goes silent", () => {
-    const mixer = new BackgroundAudioMixer({
-      thinking: { pcm: new Int16Array(1000).fill(1000), sampleRateHz: 16000, gain: 1 },
-      fadeMs: 1, // 16-sample ramps
-    });
-    const t0 = 10_000_000;
-    mixer.setThinking(true);
-    mixer.idleFrame(2, 16000, t0); // ride past the fade-in
-    const steady = mixer.idleFrame(1, 16000, t0 + 100)!;
-    expect(samplesOf(steady)).toEqual(Array(16).fill(1000));
-
-    mixer.setThinking(false);
-    const fading = mixer.idleFrame(1, 16000, t0 + 200)!; // one fade-out ramp, decaying
-    const fadeSamples = samplesOf(fading);
-    expect(fadeSamples[0]).toBe(1000); // cos(0) = 1
-    expect(fadeSamples[15]!).toBeLessThan(250); // near the end of the ramp
-    expect(mixer.idleFrame(1, 16000, t0 + 300)).toBeNull(); // episode fully over
-  });
-
-  it("IP-C3: plays a one-shot cue in an idle frame with thinking ducked under it", () => {
-    const ramp = Int16Array.from({ length: 2000 }, (_, i) => (i % 2 === 0 ? 800 : -800));
-    const cue = Int16Array.from({ length: 160 }, (_, i) => Math.round(6000 * Math.sin((2 * Math.PI * i) / 160)));
-    const mixer = new BackgroundAudioMixer({
-      thinking: { pcm: ramp, sampleRateHz: 16000, gain: 1 },
-      cues: { mm_hmm: { pcm: cue, sampleRateHz: 16000, gain: 1 } },
-      fadeMs: 0,
-    });
-    const t0 = 12_000_000;
-    mixer.setThinking(true);
-    expect(mixer.queueCue("mm_hmm")).toBe(true);
-
-    const frame = mixer.idleFrame(10, 16000, t0)!;
-    const samples = samplesOf(frame);
-    expect(samples.some((s) => Math.abs(s) > 1000)).toBe(true);
-    expect(samples.every((s) => s <= 32767 && s >= -32768)).toBe(true);
-
-    mixer.setThinking(true);
-    expect(mixer.queueCue("missing")).toBe(false);
-  });
-
-  it("IP-C3: thinking loop continues before and after a one-shot cue", () => {
-    const thinking = Int16Array.from({ length: 1000 }, (_, i) => i);
-    const cue = new Int16Array(32).fill(5000);
-    const mixer = new BackgroundAudioMixer({
-      thinking: { pcm: thinking, sampleRateHz: 16000, gain: 1 },
-      cues: { mm_hmm: { pcm: cue, sampleRateHz: 16000, gain: 1 } },
-      fadeMs: 0,
-    });
-    const t0 = 13_000_000;
-    mixer.setThinking(true);
-    const before = samplesOf(mixer.idleFrame(1, 16000, t0)!);
-    expect(before[0]).toBe(0);
-
-    mixer.queueCue("mm_hmm");
-    mixer.idleFrame(1, 16000, t0 + 100);
-    const after = samplesOf(mixer.idleFrame(1, 16000, t0 + 200)!);
-    expect(after[0]).toBeGreaterThan(0);
-  });
-
-  it("IP-C3: resolves cues from config bytes without filesystem access", () => {
-    const cuePcm = new Int16Array(80).fill(1200);
-    const mixer = new BackgroundAudioMixer({
-      cues: { mm_hmm: { pcm: cuePcm, sampleRateHz: 16000, gain: 0.8 } },
-      fadeMs: 0,
-    });
-    expect(mixer.hasCue("mm_hmm")).toBe(true);
-    expect(mixer.queueCue("mm_hmm")).toBe(true);
-    const frame = mixer.idleFrame(5, 16000, 14_000_000)!;
-    expect(samplesOf(frame).some((s) => s !== 0)).toBe(true);
-  });
-
-  it("fades each new thinking episode in from silence", () => {
-    const mixer = new BackgroundAudioMixer({
-      thinking: { pcm: new Int16Array(1000).fill(1000), sampleRateHz: 16000, gain: 1 },
-      fadeMs: 1,
-    });
-    mixer.setThinking(true);
-    const first = mixer.idleFrame(1, 16000, 11_000_000)!;
-    expect(samplesOf(first)[0]).toBe(0); // soft entry, not a hard cut
-  });
-});

package/src/browser-opus.test.ts

@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import { Decoder as OpusDecoder, Encoder as OpusEncoder } from "@evan/opus";
-import { pcm16BytesToSamples, pcm16SamplesToBytes } from "@kuralle-syrinx/core/audio";
-import { BROWSER_OPUS_FRAME_DURATION_MS, createBrowserOpusCodec } from "./browser-opus.js";
-
-describe("browser opus codec", () => {
-  it("produces non-empty opus frames and decodes them back to PCM16 bytes", () => {
-    const pcm = new Int16Array(960);
-    pcm[0] = 1000;
-    pcm[3] = -1000;
-    const encoder = new OpusEncoder({ channels: 1, sample_rate: 48000, application: "voip" });
-    const decoder = new OpusDecoder({ channels: 1, sample_rate: 48000 });
-    const opus = encoder.encode(pcm16SamplesToBytes(pcm));
-    expect(opus.byteLength).toBeGreaterThan(0);
-    const decoded = pcm16BytesToSamples(decoder.decode(opus));
-    expect(decoded.length).toBeGreaterThan(0);
-
-    const codec = createBrowserOpusCodec(48000);
-    const wire = codec.encodePcm16Frame(pcm, true)[0]!;
-    expect(wire.byteLength).toBeGreaterThan(0);
-    expect(codec.decodeOpusFrame(wire).length).toBeGreaterThan(0);
-  });
-
-  it("does not zero-pad partial PCM until explicitly requested", () => {
-    const codec = createBrowserOpusCodec(48000);
-    const quarter = new Int16Array(Math.round((48000 * BROWSER_OPUS_FRAME_DURATION_MS) / 4000));
-    expect(codec.encodePcm16Frame(quarter, false)).toEqual([]);
-    expect(codec.encodePcm16Frame(quarter, false)).toEqual([]);
-    expect(codec.encodePcm16Frame(new Int16Array(0), true).length).toBeGreaterThan(0);
-  });
-
-  it("accumulates partial PCM before emitting a complete opus frame", () => {
-    const codec = createBrowserOpusCodec(48000);
-    const half = new Int16Array(Math.round((48000 * BROWSER_OPUS_FRAME_DURATION_MS) / 2000));
-    expect(codec.encodePcm16Frame(half, false)).toEqual([]);
-    const full = codec.encodePcm16Frame(half, true);
-    expect(full.length).toBeGreaterThan(0);
-  });
-});