@kuralle-syrinx/server-websocket 3.1.0 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuralle-syrinx/server-websocket",
-  "version": "3.1.0",
+  "version": "4.1.0",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -15,8 +15,8 @@
   "dependencies": {
     "@evan/opus": "1.0.3",
     "ws": "^8.18.0",
-    "@kuralle-syrinx/core": "3.1.0",
-    "@kuralle-syrinx/ws": "3.1.0"
+    "@kuralle-syrinx/core": "4.1.0",
+    "@kuralle-syrinx/ws": "4.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/admission-control.test.ts

@@ -79,6 +79,29 @@ describe("WT-08 admission control and upgrade routing", () => {
     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({

package/src/background-audio.test.ts

@@ -0,0 +1,172 @@
+// 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("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/background-audio.ts

@@ -0,0 +1,263 @@
+// SPDX-License-Identifier: MIT
+//
+// Background audio for the outbound path: a looped ambient bed (which doubles
+// as telephony comfort noise between turns), an optional "thinking" loop keyed
+// off the G3 tool-call cues, and ducking under assistant speech.
+//
+// Syrinx wires (Twilio media stream, browser jitter buffer) are single ORDERED
+// streams — unlike LiveKit's WebRTC rooms there is no client-side track mixing
+// — so background audio is mixed server-side into the one stream: `mix()` layers
+// the bed under every TTS chunk (ducked), and `idleFrame()` produces bed-only
+// frames for the gaps between turns. Source playback positions are shared
+// between the two so the bed is seamless across turn boundaries.
+//
+// Runtime-neutral: no Node imports — runs on workerd (edge hosts) as-is.
+// Prior art: Pipecat SoundfileMixer (transport-level mix + volume + loop),
+// LiveKit BackgroundAudioPlayer (ambient/thinking split, state-keyed thinking).
+
+import type { VoiceAgentSession } from "@kuralle-syrinx/core";
+import { pcm16BytesToSamples, pcm16SamplesToBytes, resamplePcm16 } from "@kuralle-syrinx/core/audio";
+
+export interface BackgroundAudioSource {
+  /** Mono PCM16 samples. Must be loop-clean if it will loop audibly. */
+  readonly pcm: Int16Array;
+  readonly sampleRateHz: number;
+  /** Linear gain 0..1 applied to this source. */
+  readonly gain?: number;
+}
+
+export interface BackgroundAudioConfig {
+  /** Looped continuously: under speech (ducked) and alone between turns. */
+  readonly ambient?: BackgroundAudioSource;
+  /** Looped while `setThinking(true)` — the audible face of a pending tool call. */
+  readonly thinking?: BackgroundAudioSource;
+  /**
+   * Extra multiplier on background sources while assistant speech is being
+   * mixed, so the bed never muddies the voice. 1 disables ducking. @default 0.5
+   */
+  readonly duckWhileSpeaking?: number;
+  /**
+   * Equal-power fade applied where the bed would otherwise hard-cut: the
+   * ambient's very first samples, and each thinking episode's start and stop.
+   * An abrupt full-volume onset is the harshest moment a caller hears from a
+   * wait — the fade is what makes an episode feel placed rather than switched.
+   * 0 disables. @default 250
+   */
+  readonly fadeMs?: number;
+}
+
+const DEFAULT_AMBIENT_GAIN = 0.25;
+const DEFAULT_THINKING_GAIN = 0.4;
+const DEFAULT_DUCK = 0.5;
+const DEFAULT_FADE_MS = 250;
+
+interface LoopedSource {
+  readonly original: BackgroundAudioSource;
+  readonly gain: number;
+  /** Resampled variants cached per wire rate. */
+  readonly byRate: Map<number, Int16Array>;
+  /** Playback position in samples at the current wire rate. */
+  position: number;
+  positionRateHz: number;
+}
+
+function loopedSource(source: BackgroundAudioSource, defaultGain: number): LoopedSource {
+  return {
+    original: source,
+    gain: source.gain ?? defaultGain,
+    byRate: new Map(),
+    position: 0,
+    positionRateHz: source.sampleRateHz,
+  };
+}
+
+function samplesAtRate(source: LoopedSource, rateHz: number): Int16Array {
+  let samples = source.byRate.get(rateHz);
+  if (!samples) {
+    samples = resamplePcm16(source.original.pcm, source.original.sampleRateHz, rateHz);
+    source.byRate.set(rateHz, samples);
+  }
+  if (source.positionRateHz !== rateHz) {
+    // Wire rate changed mid-connection (rare): carry the position over proportionally.
+    source.position = Math.round((source.position * rateHz) / source.positionRateHz);
+    source.positionRateHz = rateHz;
+  }
+  return samples;
+}
+
+/**
+ * Add samples of `source` (scaled by `scale`, optionally shaped per-sample by
+ * `envelope(i)`) into `target`, advancing the loop.
+ */
+function addLooped(
+  target: Float64Array,
+  source: LoopedSource,
+  rateHz: number,
+  scale: number,
+  envelope?: (i: number) => number,
+): void {
+  const samples = samplesAtRate(source, rateHz);
+  if (samples.length === 0 || scale === 0) return;
+  let pos = source.position % samples.length;
+  for (let i = 0; i < target.length; i += 1) {
+    const gain = envelope ? scale * envelope(i) : scale;
+    target[i]! += samples[pos]! * gain;
+    pos += 1;
+    if (pos >= samples.length) pos = 0;
+  }
+  source.position = pos;
+}
+
+/** Equal-power fade-in gain for sample `n` of a `total`-sample ramp (1 past the ramp). */
+function fadeInGain(n: number, total: number): number {
+  if (total <= 0 || n >= total) return 1;
+  return Math.sin((n / total) * (Math.PI / 2));
+}
+
+/** Equal-power fade-out gain for sample `n` of a `total`-sample ramp (0 past the ramp). */
+function fadeOutGain(n: number, total: number): number {
+  if (total <= 0 || n >= total) return 0;
+  return Math.cos((n / total) * (Math.PI / 2));
+}
+
+function clipToPcm16Bytes(mix: Float64Array): Uint8Array {
+  const out = new Int16Array(mix.length);
+  for (let i = 0; i < mix.length; i += 1) {
+    const v = Math.round(mix[i]!);
+    out[i] = v > 32767 ? 32767 : v < -32768 ? -32768 : v;
+  }
+  return pcm16SamplesToBytes(out);
+}
+
+export class BackgroundAudioMixer {
+  private readonly ambient: LoopedSource | null;
+  private readonly thinking: LoopedSource | null;
+  private readonly duck: number;
+  private readonly fadeMs: number;
+  /**
+   * Thinking episode lifecycle: "stopping" keeps the loop audible for one
+   * fade-out ramp after `setThinking(false)` instead of hard-cutting it.
+   */
+  private thinkingState: "off" | "on" | "stopping" = "off";
+  /** Samples rendered since the current thinking episode started (fade-in). */
+  private thinkingFadeInPos = 0;
+  /** Samples rendered since the stop was requested (fade-out). */
+  private thinkingFadeOutPos = 0;
+  /** Samples of ambient rendered so far (one-time fade-in at bed start). */
+  private ambientFadeInPos = 0;
+  /** Realtime estimate of when already-mixed speech finishes playing out. */
+  private speakingUntilMs = 0;
+
+  constructor(config: BackgroundAudioConfig) {
+    this.ambient = config.ambient ? loopedSource(config.ambient, DEFAULT_AMBIENT_GAIN) : null;
+    this.thinking = config.thinking ? loopedSource(config.thinking, DEFAULT_THINKING_GAIN) : null;
+    this.duck = config.duckWhileSpeaking ?? DEFAULT_DUCK;
+    this.fadeMs = config.fadeMs ?? DEFAULT_FADE_MS;
+  }
+
+  get hasSources(): boolean {
+    return this.ambient !== null || this.thinking !== null;
+  }
+
+  isSpeaking(nowMs = Date.now()): boolean {
+    return nowMs < this.speakingUntilMs;
+  }
+
+  /** G3 cue wiring: started/delayed → true, complete/failed → false. */
+  setThinking(on: boolean): void {
+    if (on) {
+      if (this.thinkingState === "on") return;
+      this.thinkingState = "on";
+      this.thinkingFadeInPos = 0;
+      if (this.thinking) this.thinking.position = 0; // each episode starts from the top
+      return;
+    }
+    if (this.thinkingState !== "on") return;
+    // Audible for one fade-out ramp, then off (immediately off when fades are disabled).
+    this.thinkingState = this.fadeMs > 0 ? "stopping" : "off";
+    this.thinkingFadeOutPos = 0;
+  }
+
+  /**
+   * Add the bed sources into `mixBuf` at `bedScale`, applying the fade
+   * envelopes and advancing their positions/counters. Shared by mix (ducked)
+   * and idleFrame (full gain) so episodes stay continuous across both.
+   */
+  private addBed(mixBuf: Float64Array, sampleRateHz: number, bedScale: number): void {
+    const fadeSamples = Math.round((this.fadeMs / 1000) * sampleRateHz);
+
+    if (this.ambient) {
+      const startPos = this.ambientFadeInPos;
+      const envelope = startPos >= fadeSamples
+        ? undefined
+        : (i: number) => fadeInGain(startPos + i, fadeSamples);
+      addLooped(mixBuf, this.ambient, sampleRateHz, this.ambient.gain * bedScale, envelope);
+      this.ambientFadeInPos = Math.min(fadeSamples, startPos + mixBuf.length);
+    }
+
+    if (this.thinking && this.thinkingState !== "off") {
+      if (this.thinkingState === "on") {
+        const startPos = this.thinkingFadeInPos;
+        const envelope = startPos >= fadeSamples
+          ? undefined
+          : (i: number) => fadeInGain(startPos + i, fadeSamples);
+        addLooped(mixBuf, this.thinking, sampleRateHz, this.thinking.gain * bedScale, envelope);
+        this.thinkingFadeInPos = Math.min(fadeSamples, startPos + mixBuf.length);
+      } else {
+        const startPos = this.thinkingFadeOutPos;
+        addLooped(
+          mixBuf,
+          this.thinking,
+          sampleRateHz,
+          this.thinking.gain * bedScale,
+          (i: number) => fadeOutGain(startPos + i, fadeSamples),
+        );
+        this.thinkingFadeOutPos = startPos + mixBuf.length;
+        if (this.thinkingFadeOutPos >= fadeSamples) this.thinkingState = "off";
+      }
+    }
+  }
+
+  /**
+   * Mix the background bed (ducked) into an assistant speech chunk and advance
+   * the speaking-until estimate by the chunk's realtime duration. Returns a new
+   * buffer; the input is never mutated.
+   */
+  mix(chunk: Uint8Array, sampleRateHz: number, nowMs = Date.now()): Uint8Array {
+    const speech = pcm16BytesToSamples(chunk);
+    const durationMs = (speech.length / sampleRateHz) * 1000;
+    this.speakingUntilMs = Math.max(this.speakingUntilMs, nowMs) + durationMs;
+
+    if (!this.hasSources) return chunk;
+    const mixBuf = new Float64Array(speech.length);
+    for (let i = 0; i < speech.length; i += 1) mixBuf[i] = speech[i]!;
+    this.addBed(mixBuf, sampleRateHz, this.duck);
+    return clipToPcm16Bytes(mixBuf);
+  }
+
+  /**
+   * Bed-only frame for the gaps between turns (telephony comfort noise), or
+   * null while speech is still playing out / there is nothing to play.
+   */
+  idleFrame(frameMs: number, sampleRateHz: number, nowMs = Date.now()): Uint8Array | null {
+    if (this.isSpeaking(nowMs)) return null;
+    const playThinking = this.thinking !== null && this.thinkingState !== "off";
+    if (!this.ambient && !playThinking) return null;
+
+    const sampleCount = Math.max(1, Math.round((frameMs / 1000) * sampleRateHz));
+    const mixBuf = new Float64Array(sampleCount);
+    this.addBed(mixBuf, sampleRateHz, 1);
+    return clipToPcm16Bytes(mixBuf);
+  }
+}
+
+/**
+ * Drive the mixer's thinking loop from the session's G3 tool-call cues:
+ * started/delayed → thinking on; complete/failed → off. Listener lifetime is
+ * the session's — both are per-connection.
+ */
+export function wireBackgroundThinking(session: VoiceAgentSession, mixer: BackgroundAudioMixer): void {
+  session.on("tool_call_cue", (event) => {
+    mixer.setThinking(event.phase === "started" || event.phase === "delayed");
+  });
+}

package/src/browser-pacing.test.ts

@@ -168,7 +168,7 @@ describe("WT-03 Browser outbound pacing", () => {
       expect(c.type).toBe("tts_chunk");
       expect(c.turnId).toBe("test-turn");
       expect(c.sequence).toBeGreaterThan(0);
-      expect(c.sampleRateHz).toBe(16000);
+      expect(c.sampleRateHz).toBe(48000); // opus frames carry the 48 kHz codec rate
       expect(c.encoding).toBe("opus");
       expect(c.channels).toBe(1);
       expect(c.byteLength).toBeGreaterThan(0);

package/src/edge-twilio.test.ts

@@ -78,7 +78,10 @@ function bytesToBase64(bytes: Uint8Array): string {
   return Buffer.from(bytes).toString("base64");
 }
 
-async function startConnection(received: UserAudioReceivedPacket[] = []) {
+async function startConnection(
+  received: UserAudioReceivedPacket[] = [],
+  extraOptions: Record<string, unknown> = {},
+) {
   const socket = new FakeSocket();
   const session = fakeSession(received);
   await runTwilioEdgeWebSocketConnection(
@@ -88,6 +91,7 @@ async function startConnection(received: UserAudioReceivedPacket[] = []) {
       sessionStore: new InMemorySessionStore(),
       createSession: () => session,
       keepAliveIntervalMs: 0,
+      ...extraOptions,
     },
   );
   socket.emit(JSON.stringify({ event: "connected", protocol: "Call" }));
@@ -139,6 +143,54 @@ describe("Twilio edge ingress", () => {
     expect(Math.abs(decoded[100]! - 6000)).toBeLessThan(600);
   });
 
+  it("mixes the background bed (ducked) under TTS media", async () => {
+    const { socket, session } = await startConnection([], {
+      backgroundAudio: {
+        ambient: { pcm: new Int16Array(320).fill(4000), sampleRateHz: 16000, gain: 0.5 },
+        duckWhileSpeaking: 0.5,
+        fadeMs: 0,
+      },
+      backgroundIdleFrameMs: 10_000, // keep the idle ticker out of this test
+    });
+
+    const silence = new Uint8Array(new Int16Array(640).buffer.slice(0)); // 40ms @16k of silence
+    session.bus.push(Route.Critical, {
+      kind: "tts.audio",
+      contextId: "twilio-CA456",
+      timestampMs: Date.now(),
+      audio: silence,
+      sampleRateHz: 16000,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const media = socket.json().filter((msg) => msg.event === "media");
+    expect(media).toHaveLength(1);
+    const payload = (media[0]!.media as { payload: string }).payload;
+    const decoded = decodeMuLawToPcm16(new Uint8Array(Buffer.from(payload, "base64")));
+    // ambient 4000 × gain 0.5 × duck 0.5 = 1000 under the silent speech
+    expect(Math.abs(decoded[100]! - 1000)).toBeLessThan(120); // mu-law quantization tolerance
+  });
+
+  it("sends idle comfort-noise frames between turns", async () => {
+    const { socket } = await startConnection([], {
+      backgroundAudio: {
+        ambient: { pcm: new Int16Array(320).fill(4000), sampleRateHz: 8000, gain: 0.5 },
+        fadeMs: 0,
+      },
+      backgroundIdleFrameMs: 25,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 120));
+
+    const media = socket.json().filter((msg) => msg.event === "media");
+    expect(media.length).toBeGreaterThanOrEqual(2); // ticker fills the silence
+    const payload = (media[0]!.media as { payload: string }).payload;
+    const decoded = decodeMuLawToPcm16(new Uint8Array(Buffer.from(payload, "base64")));
+    // full-gain bed between turns: 4000 × 0.5 = 2000
+    expect(Math.abs(decoded[10]! - 2000)).toBeLessThan(220);
+    expect(decoded.length).toBe(200); // 25ms @ 8k
+  });
+
   it("sends a clear event on interrupt.detected (barge-in)", async () => {
     const { socket, session } = await startConnection();
 
@@ -159,6 +211,32 @@ describe("Twilio edge ingress", () => {
     expect(socket.disposed).toBe(true);
   });
 
+  it("actually closes the session on hangup (no provider-socket leak)", async () => {
+    // Regression for the R1 leak: cleanup released without decrementing
+    // connectionCount, so release early-returned and session.close() never ran —
+    // Deepgram/TTS sockets leaked until DO eviction on every phone call.
+    const socket = new FakeSocket();
+    let closed = false;
+    const bus = new PipelineBusImpl();
+    const session = {
+      bus,
+      async start() { void bus.start(); },
+      async close() { closed = true; bus.stop(); },
+      on() {}, off() {}, requestClientInterrupt() {},
+    } as unknown as VoiceAgentSession;
+
+    await runTwilioEdgeWebSocketConnection(
+      socket,
+      new Request("https://edge.test/twilio?sessionId=tw-close"),
+      { sessionStore: new InMemorySessionStore(), createSession: () => session, keepAliveIntervalMs: 0 },
+    );
+    socket.emit(JSON.stringify({ event: "start", streamSid: "MZ9", start: { streamSid: "MZ9", callSid: "CA9" } }));
+    socket.emit(JSON.stringify({ event: "stop", streamSid: "MZ9" }));
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(closed).toBe(true);
+  });
+
   it("rotates the uplink contextId after each completed turn", async () => {
     const received: UserAudioReceivedPacket[] = [];
     const { socket, session } = await startConnection(received);