@memberjunction/server 5.43.0 → 5.45.0

package/src/__tests__/search-knowledge-tags.test.ts

@@ -127,7 +127,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = createResolver();
             mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-            const result = await resolver.SearchKnowledge('test query', 20, undefined, undefined, fakeContext as never);
+            const result = await resolver.SearchKnowledge('test query', 20, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             expect(mockSearch).toHaveBeenCalledOnce();
             expect(result.Success).toBe(true);
@@ -139,7 +139,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = createResolver();
             mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-            await resolver.SearchKnowledge('cheese', 50, undefined, undefined, fakeContext as never);
+            await resolver.SearchKnowledge('cheese', 50, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             const searchParams = mockSearch.mock.calls[0][0];
             expect(searchParams.Query).toBe('cheese');
@@ -151,7 +151,7 @@ describe('SearchKnowledgeResolver', () => {
             mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
             const filters = { EntityNames: ['Contacts'], SourceTypes: undefined, Tags: ['VIP'] };
-            await resolver.SearchKnowledge('test', 20, filters as never, undefined, fakeContext as never);
+            await resolver.SearchKnowledge('test', 20, filters as never, undefined, undefined, undefined, undefined, fakeContext as never);
 
             const searchParams = mockSearch.mock.calls[0][0];
             expect(searchParams.Filters).toEqual({
@@ -165,7 +165,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = createResolver();
             mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-            await resolver.SearchKnowledge('test', 20, undefined, 0.5, fakeContext as never);
+            await resolver.SearchKnowledge('test', 20, undefined, 0.5, undefined, undefined, undefined, fakeContext as never);
 
             const searchParams = mockSearch.mock.calls[0][0];
             expect(searchParams.MinScore).toBe(0.5);
@@ -175,7 +175,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = createResolver();
             mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             const item = result.Results[0];
             expect(item.ID).toBe('result-1');
@@ -193,7 +193,7 @@ describe('SearchKnowledgeResolver', () => {
                 SourceCounts: { Vector: 5, FullText: 3, Entity: 10, Storage: 0 }
             }));
 
-            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             expect(result.SourceCounts.Vector).toBe(5);
             expect(result.SourceCounts.FullText).toBe(3);
@@ -204,7 +204,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = createResolver();
             mockSearch.mockResolvedValueOnce(createMockSearchResult({ Success: false, ErrorMessage: 'Query cannot be empty' }));
 
-            const result = await resolver.SearchKnowledge('   ', 20, undefined, undefined, fakeContext as never);
+            const result = await resolver.SearchKnowledge('   ', 20, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             expect(mockSearch).toHaveBeenCalled();
             expect(result.Success).toBe(false);
@@ -214,7 +214,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = new SearchKnowledgeResolver();
             (resolver as Record<string, unknown>)['GetUserFromPayload'] = vi.fn().mockReturnValue(null);
 
-            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             expect(result.Success).toBe(false);
             expect(result.ErrorMessage).toContain('current user');
@@ -224,7 +224,7 @@ describe('SearchKnowledgeResolver', () => {
             const resolver = createResolver();
             mockSearch.mockRejectedValueOnce(new Error('Connection failed'));
 
-            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, undefined, undefined, undefined, fakeContext as never);
 
             expect(result.Success).toBe(false);
             expect(result.ErrorMessage).toContain('Connection failed');

package/src/__tests__/teams-meetings-service.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TeamsMeetingsService } from '../telephony/TeamsMeetingsService.js';
+import { TeamsAcsMediaRegistry } from '../telephony/teamsAcsMediaRegistry.js';
+import { RealTeamsBindings } from '@memberjunction/ai-bridge-teams';
+import type { BaseRealtimeBridge } from '@memberjunction/ai-bridge-base';
+import type { TeamsMeetingsConfig } from '../config.js';
+
+const CONFIG: TeamsMeetingsConfig = {
+    enabled: true,
+    tenantId: 'tenant-1',
+    botAccessToken: 'tok',
+    notificationClientState: 'secret',
+    acsSampleRate: 16000,
+    modelSampleRate: 16000,
+};
+
+describe('TeamsMeetingsService.buildBindSdk', () => {
+    it('binds a RealTeamsBindings factory onto the Teams driver (the live Graph + ACS wiring seam)', () => {
+        const service = new TeamsMeetingsService(CONFIG, new TeamsAcsMediaRegistry());
+        const setSdkFactory = vi.fn();
+        const fakeDriver = { SetSdkFactory: setSdkFactory } as unknown as BaseRealtimeBridge;
+        // A minimal fake Graph client (only used as a constructor arg here).
+        const graphClient = { CreateCall: vi.fn() } as unknown as Parameters<typeof service.buildBindSdk>[0];
+
+        service.buildBindSdk(graphClient)(fakeDriver);
+
+        expect(setSdkFactory).toHaveBeenCalledTimes(1);
+        const factory = setSdkFactory.mock.calls[0][0] as () => unknown;
+        expect(typeof factory).toBe('function');
+        // The factory yields a real (bound) RealTeamsBindings — proving the offline seam meets live plumbing.
+        expect(factory()).toBeInstanceOf(RealTeamsBindings);
+    });
+});
+
+describe('TeamsMeetingsService.JoinMeetingByUrl', () => {
+    it('returns accepted=false (never throws) when the agent identity is missing', async () => {
+        const provider = {
+            GetEntityObject: vi.fn().mockResolvedValue({ Load: vi.fn().mockResolvedValue(false), IsActive: false }),
+        };
+        const service = new TeamsMeetingsService(CONFIG, new TeamsAcsMediaRegistry());
+        const result = await service.JoinMeetingByUrl(
+            'identity-1',
+            'https://teams.microsoft.com/l/meetup-join/x',
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- minimal UserInfo stub for a pure-branch test
+            { ID: 'u1' } as never,
+            provider as never,
+        );
+        expect(result.accepted).toBe(false);
+        expect(result.reason).toMatch(/not found or inactive/i);
+    });
+});
+
+describe('TeamsMeetingsService notification drive helpers', () => {
+    it('tears down the call + registry on call-ended (no throw when no client registered)', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        registry.RegisterCall('call-1');
+        expect(registry.HasCall('call-1')).toBe(true);
+        const service = new TeamsMeetingsService(CONFIG, registry);
+
+        service.DriveCallEnded('call-1');
+        expect(registry.HasCall('call-1')).toBe(false);
+        // An unknown roster drive is a silent no-op.
+        expect(() => service.DriveParticipantsUpdated('unknown', [{ id: 'p1' }])).not.toThrow();
+    });
+});

package/src/__tests__/teamsAcsMediaRegistry.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { TeamsAcsMediaRegistry, type IAcsMediaTransport } from '../telephony/teamsAcsMediaRegistry.js';
+import type { AcsInboundAudioFrame } from '@memberjunction/ai-bridge-teams';
+
+class FakeTransport implements IAcsMediaTransport {
+    public readonly Sent: ArrayBuffer[] = [];
+    public Closed = false;
+    public sendAudioFrame(pcm: ArrayBuffer): void {
+        this.Sent.push(pcm);
+    }
+    public close(): void {
+        this.Closed = true;
+    }
+}
+
+const frame = (bytes: number): ArrayBuffer => new ArrayBuffer(bytes);
+
+describe('TeamsAcsMediaRegistry', () => {
+    it('exposes the configured ACS sample rate', () => {
+        expect(new TeamsAcsMediaRegistry().SampleRate).toBe(16000);
+        expect(new TeamsAcsMediaRegistry(8000).SampleRate).toBe(8000);
+    });
+
+    it('buffers outbound PCM before the transport attaches, then flushes on attach', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        const a = frame(4);
+        const b = frame(8);
+        registry.Send('call-1', a);
+        registry.Send('call-1', b);
+
+        const transport = new FakeTransport();
+        registry.AttachTransport('call-1', transport);
+
+        expect(transport.Sent).toEqual([a, b]);
+    });
+
+    it('sends immediately once the transport is attached', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        const transport = new FakeTransport();
+        registry.AttachTransport('call-1', transport);
+        const a = frame(4);
+        registry.Send('call-1', a);
+        expect(transport.Sent).toEqual([a]);
+    });
+
+    it('dispatches inbound frames to all registered handlers for the call', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        const seen: AcsInboundAudioFrame[] = [];
+        registry.OnFrame('call-1', (f) => seen.push(f));
+        registry.OnFrame('call-1', (f) => seen.push(f));
+        const f: AcsInboundAudioFrame = { Pcm: frame(2), ParticipantId: 'p1' };
+        registry.DispatchInbound('call-1', f);
+        expect(seen).toEqual([f, f]);
+    });
+
+    it('dispatches hand-raise signals to registered hand-raise handlers', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        let raised: boolean | undefined;
+        registry.OnHandRaise('call-1', (_p, r) => (raised = r));
+        registry.DispatchHandRaise('call-1', 'p1', true);
+        expect(raised).toBe(true);
+    });
+
+    it('ignores inbound dispatch + hand-raise for unknown calls (no throw)', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        expect(() => registry.DispatchInbound('nope', { Pcm: frame(2), ParticipantId: 'p1' })).not.toThrow();
+        expect(() => registry.DispatchHandRaise('nope', 'p1', true)).not.toThrow();
+    });
+
+    it('closes the transport and forgets the call on EndCall', () => {
+        const registry = new TeamsAcsMediaRegistry();
+        const transport = new FakeTransport();
+        registry.AttachTransport('call-1', transport);
+        expect(registry.HasCall('call-1')).toBe(true);
+
+        registry.EndCall('call-1');
+        expect(transport.Closed).toBe(true);
+        expect(registry.HasCall('call-1')).toBe(false);
+        // EndCall on an unknown call is a silent no-op.
+        expect(() => registry.EndCall('unknown')).not.toThrow();
+    });
+});

package/src/__tests__/twilio-telephony-service.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TwilioTelephonyService } from '../telephony/TwilioTelephonyService.js';
+import { TwilioCallMediaRegistry } from '../telephony/twilioMediaRegistry.js';
+import { TwilioCallSdk } from '@memberjunction/ai-bridge-twilio';
+import type { BaseTelephonyBridge } from '@memberjunction/ai-bridge-base';
+
+const CONFIG = { accountSid: 'AC1', authToken: 'tok', streamPublicUrl: 'wss://api.test/telephony/twilio/media' };
+
+describe('TwilioTelephonyService.buildBindSdk', () => {
+    it('binds a TwilioCallSdk factory onto the telephony driver (the live REST + media wiring seam)', () => {
+        const service = new TwilioTelephonyService(CONFIG, new TwilioCallMediaRegistry());
+        const setSdkFactory = vi.fn();
+        const fakeDriver = { SetSdkFactory: setSdkFactory } as unknown as BaseTelephonyBridge;
+
+        service.buildBindSdk()(fakeDriver);
+
+        expect(setSdkFactory).toHaveBeenCalledTimes(1);
+        const factory = setSdkFactory.mock.calls[0][0] as () => unknown;
+        expect(typeof factory).toBe('function');
+        // The factory yields a real (bound) TwilioCallSdk — proving the offline seam meets live plumbing.
+        expect(factory()).toBeInstanceOf(TwilioCallSdk);
+    });
+});

package/src/__tests__/twilioMediaRegistry.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TwilioCallMediaRegistry, type ITelephonyMediaSocket } from '../telephony/twilioMediaRegistry.js';
+import type { TwilioMediaFrame } from '@memberjunction/ai-bridge-twilio';
+
+/** A fake Media-Streams socket capturing sends + tracking close. */
+function fakeSocket(): ITelephonyMediaSocket & { sent: string[]; closed: boolean } {
+    const sent: string[] = [];
+    return {
+        sent,
+        closed: false,
+        send(data: string) {
+            sent.push(data);
+        },
+        close() {
+            (this as { closed: boolean }).closed = true;
+        },
+    };
+}
+
+const mediaFrame = (payload: string): TwilioMediaFrame => ({ event: 'media', streamSid: 'MZ1', media: { payload } });
+
+describe('TwilioCallMediaRegistry', () => {
+    describe('outbound buffering', () => {
+        it('buffers outbound frames before the socket connects, then flushes on AttachSocket in order', () => {
+            const reg = new TwilioCallMediaRegistry();
+            reg.RegisterCall('CA1');
+            reg.Send('CA1', mediaFrame('a'));
+            reg.Send('CA1', mediaFrame('b'));
+
+            const sock = fakeSocket();
+            reg.AttachSocket('CA1', sock, 'MZ1');
+
+            expect(sock.sent).toHaveLength(2);
+            expect(JSON.parse(sock.sent[0]).media.payload).toBe('a');
+            expect(JSON.parse(sock.sent[1]).media.payload).toBe('b');
+        });
+
+        it('sends immediately once the socket is attached', () => {
+            const reg = new TwilioCallMediaRegistry();
+            const sock = fakeSocket();
+            reg.AttachSocket('CA1', sock, 'MZ1');
+            reg.Send('CA1', mediaFrame('c'));
+            expect(sock.sent).toHaveLength(1);
+            expect(JSON.parse(sock.sent[0]).media.payload).toBe('c');
+        });
+    });
+
+    describe('inbound dispatch', () => {
+        it('delivers inbound frames to handlers registered before the socket existed', () => {
+            const reg = new TwilioCallMediaRegistry();
+            const received: TwilioMediaFrame[] = [];
+            reg.OnFrame('CA1', (f) => received.push(f));
+
+            reg.DispatchInbound('CA1', mediaFrame('in'));
+
+            expect(received).toHaveLength(1);
+            expect(received[0].media?.payload).toBe('in');
+        });
+
+        it('captures the stream SID from a start frame and exposes it via GetStreamSid', () => {
+            const reg = new TwilioCallMediaRegistry();
+            reg.RegisterCall('CA1');
+            expect(reg.GetStreamSid('CA1')).toBe('');
+            reg.DispatchInbound('CA1', { event: 'start', streamSid: 'MZ-XYZ' });
+            expect(reg.GetStreamSid('CA1')).toBe('MZ-XYZ');
+        });
+
+        it('drops inbound frames for an unknown call (no channel) without throwing', () => {
+            const reg = new TwilioCallMediaRegistry();
+            expect(() => reg.DispatchInbound('UNKNOWN', mediaFrame('x'))).not.toThrow();
+        });
+
+        it('fans out to multiple handlers (audio + dtmf + status all registered on one call)', () => {
+            const reg = new TwilioCallMediaRegistry();
+            const h1 = vi.fn();
+            const h2 = vi.fn();
+            reg.OnFrame('CA1', h1);
+            reg.OnFrame('CA1', h2);
+            reg.DispatchInbound('CA1', mediaFrame('y'));
+            expect(h1).toHaveBeenCalledTimes(1);
+            expect(h2).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('lifecycle', () => {
+        it('EndCall closes the socket and forgets the channel', () => {
+            const reg = new TwilioCallMediaRegistry();
+            const sock = fakeSocket();
+            reg.AttachSocket('CA1', sock, 'MZ1');
+            expect(reg.HasCall('CA1')).toBe(true);
+
+            reg.EndCall('CA1');
+
+            expect(sock.closed).toBe(true);
+            expect(reg.HasCall('CA1')).toBe(false);
+        });
+
+        it('EndCall on an unknown call is a no-op', () => {
+            const reg = new TwilioCallMediaRegistry();
+            expect(() => reg.EndCall('NOPE')).not.toThrow();
+        });
+    });
+});

package/src/__tests__/vonageMediaRegistry.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi } from 'vitest';
+import { VonageCallMediaRegistry, type ITelephonyMediaSocket } from '../telephony/vonageMediaRegistry.js';
+import type { VonageControlEvent } from '@memberjunction/ai-bridge-vonage';
+
+/** A fake media socket capturing outbound BINARY audio + TEXT control frames + tracking close. */
+function fakeSocket(): ITelephonyMediaSocket & { sent: Uint8Array[]; text: string[]; closed: boolean } {
+    const sent: Uint8Array[] = [];
+    const text: string[] = [];
+    return {
+        sent,
+        text,
+        closed: false,
+        sendBinary(data: Uint8Array) {
+            sent.push(data);
+        },
+        sendText(data: string) {
+            text.push(data);
+        },
+        close() {
+            (this as { closed: boolean }).closed = true;
+        },
+    };
+}
+
+/** A small PCM16 ArrayBuffer carrying one recognizable little-endian sample, for ordering/round-trip checks. */
+const pcm = (sample: number): ArrayBuffer => {
+    const buf = new ArrayBuffer(2);
+    new DataView(buf).setInt16(0, sample, true);
+    return buf;
+};
+
+/** Vonage's outbound frame size: 20 ms @ 8 kHz / 16-bit = 320 bytes. */
+const FRAME_BYTES = 320;
+
+/** Builds an N-byte PCM ArrayBuffer whose first byte is `tag`, so frames are distinguishable. */
+const audio = (bytes: number, tag = 0): ArrayBuffer => {
+    const buf = new Uint8Array(bytes);
+    if (bytes > 0) buf[0] = tag;
+    return buf.buffer;
+};
+
+describe('VonageCallMediaRegistry', () => {
+    describe('outbound audio framing (20 ms / 320-byte slices)', () => {
+        it('buffers whole 320-byte frames before the socket connects, then flushes them on AttachSocket in order', () => {
+            const reg = new VonageCallMediaRegistry();
+            reg.RegisterCall('CALL-1');
+            reg.SendAudio('CALL-1', audio(FRAME_BYTES, 0xa1));
+            reg.SendAudio('CALL-1', audio(FRAME_BYTES, 0xb2));
+
+            const sock = fakeSocket();
+            reg.AttachSocket('CALL-1', sock);
+
+            expect(sock.sent).toHaveLength(2);
+            expect(sock.sent[0]).toHaveLength(FRAME_BYTES);
+            expect(sock.sent[0][0]).toBe(0xa1);
+            expect(sock.sent[1][0]).toBe(0xb2);
+        });
+
+        it('slices an oversized delta into multiple 320-byte frames and carries the sub-frame remainder', () => {
+            const reg = new VonageCallMediaRegistry();
+            const sock = fakeSocket();
+            reg.AttachSocket('CALL-1', sock);
+
+            // 800 bytes = two whole frames + 160 left over (held, not sent).
+            reg.SendAudio('CALL-1', audio(800));
+            expect(sock.sent).toHaveLength(2);
+            expect(sock.sent.every((f) => f.length === FRAME_BYTES)).toBe(true);
+
+            // Another 160 bytes completes the carried remainder into a third whole frame.
+            reg.SendAudio('CALL-1', audio(160));
+            expect(sock.sent).toHaveLength(3);
+            expect(sock.sent[2]).toHaveLength(FRAME_BYTES);
+        });
+
+        it('holds a sub-frame delta until enough bytes accumulate (no silence-padded partial frame)', () => {
+            const reg = new VonageCallMediaRegistry();
+            const sock = fakeSocket();
+            reg.AttachSocket('CALL-1', sock);
+            reg.SendAudio('CALL-1', audio(100));
+            expect(sock.sent).toHaveLength(0); // < one frame — nothing sent yet
+        });
+    });
+
+    describe('inbound audio dispatch', () => {
+        it('delivers inbound audio to handlers registered before the socket existed', () => {
+            const reg = new VonageCallMediaRegistry();
+            const received: number[] = [];
+            reg.OnAudio('CALL-1', (p) => received.push(new DataView(p).getInt16(0, true)));
+
+            reg.DispatchInboundAudio('CALL-1', pcm(42));
+
+            expect(received).toEqual([42]);
+        });
+
+        it('drops inbound audio for an unknown call (no channel) without throwing', () => {
+            const reg = new VonageCallMediaRegistry();
+            expect(() => reg.DispatchInboundAudio('UNKNOWN', pcm(1))).not.toThrow();
+        });
+
+        it('fans out audio to multiple handlers registered on one call', () => {
+            const reg = new VonageCallMediaRegistry();
+            const h1 = vi.fn();
+            const h2 = vi.fn();
+            reg.OnAudio('CALL-1', h1);
+            reg.OnAudio('CALL-1', h2);
+            reg.DispatchInboundAudio('CALL-1', pcm(7));
+            expect(h1).toHaveBeenCalledTimes(1);
+            expect(h2).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('inbound control-event dispatch', () => {
+        it('delivers parsed control events (DTMF / close) to event handlers, separate from audio', () => {
+            const reg = new VonageCallMediaRegistry();
+            const events: VonageControlEvent[] = [];
+            const audio = vi.fn();
+            reg.OnEvent('CALL-1', (e) => events.push(e));
+            reg.OnAudio('CALL-1', audio);
+
+            reg.DispatchInboundEvent('CALL-1', { event: 'websocket:dtmf', digit: '5', duration: 260 });
+            reg.DispatchInboundEvent('CALL-1', { event: 'close' });
+
+            expect(audio).not.toHaveBeenCalled();
+            expect(events).toHaveLength(2);
+            expect(events[0].digit).toBe('5');
+            expect(events[1].event).toBe('close');
+        });
+
+        it('drops inbound events for an unknown call without throwing', () => {
+            const reg = new VonageCallMediaRegistry();
+            expect(() => reg.DispatchInboundEvent('UNKNOWN', { event: 'close' })).not.toThrow();
+        });
+    });
+
+    describe('barge-in flush (Clear)', () => {
+        it('sends Vonage {"action":"clear"} on the live socket and drops locally-buffered audio', () => {
+            const reg = new VonageCallMediaRegistry();
+            const sock = fakeSocket();
+            reg.AttachSocket('CALL-1', sock);
+            reg.Clear('CALL-1');
+            expect(sock.text).toEqual([JSON.stringify({ action: 'clear' })]);
+        });
+
+        it('drops outbound frames buffered before the socket connected, sending nothing on attach', () => {
+            const reg = new VonageCallMediaRegistry();
+            reg.RegisterCall('CALL-1');
+            reg.SendAudio('CALL-1', audio(FRAME_BYTES)); // a whole frame, buffered (no socket yet)
+            reg.SendAudio('CALL-1', audio(100)); // sub-frame remainder, held in partial
+            reg.Clear('CALL-1'); // barge-in before the media socket connected
+
+            const sock = fakeSocket();
+            reg.AttachSocket('CALL-1', sock);
+            expect(sock.sent).toHaveLength(0); // both the buffered frame and the partial were cleared
+        });
+
+        it('Clear on an unknown call is a no-op', () => {
+            const reg = new VonageCallMediaRegistry();
+            expect(() => reg.Clear('NOPE')).not.toThrow();
+        });
+    });
+
+    describe('lifecycle', () => {
+        it('EndCall closes the socket and forgets the channel', () => {
+            const reg = new VonageCallMediaRegistry();
+            const sock = fakeSocket();
+            reg.AttachSocket('CALL-1', sock);
+            expect(reg.HasCall('CALL-1')).toBe(true);
+
+            reg.EndCall('CALL-1');
+
+            expect(sock.closed).toBe(true);
+            expect(reg.HasCall('CALL-1')).toBe(false);
+        });
+
+        it('EndCall on an unknown call is a no-op', () => {
+            const reg = new VonageCallMediaRegistry();
+            expect(() => reg.EndCall('NOPE')).not.toThrow();
+        });
+    });
+});