Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

25.6 KB
Raw Blame
import { ThrownResultError } from '@core/util/result';
import type { CallTokenResponse } from '@service-call/client';
import type { DisconnectReason } from 'livekit-client';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { type ActiveCallLookup, AUTO_REJOIN_DELAY_MS } from '../auto-rejoin';
import {
  createCallLifecycle,
  JOIN_TIMEOUT_MS,
  LEAVE_TIMEOUT_MS,
} from '../call-lifecycle';
import { LK_DISCONNECT_REASON } from '../livekit-loader';

function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((yes) => {
    resolve = yes;
  });
  return { promise, resolve };
}

const call = { channelId: 'channel-1', callId: 'call-1' };
const token: CallTokenResponse = {
  ...call,
  roomName: 'room-1',
  token: 'token',
  serverUrl: 'ws://localhost',
  participantId: 'macro|[email protected]',
  started: false,
  shareToken: null,
} satisfies CallTokenResponse;
const cleanups: (() => void)[] = [];

function setup(extra: Partial<Parameters<typeof createCallLifecycle>[0]> = {}) {
  let disconnected: (reason?: DisconnectReason) => void = () => {};
  let nativeEnded: () => void = () => {};
  const unwatch = vi.fn();
  const ports = {
    shouldRequestToken: vi.fn(() => true),
    requestToken: vi.fn(async () => token),
    connect: vi.fn(async () => {}),
    disconnect: vi.fn(async () => {}),
    leave: vi.fn(async () => {}),
    lookup: vi.fn<() => Promise<ActiveCallLookup>>(async () => ({
      callId: call.callId,
    })),
    currentCall: vi.fn(() => call),
    beginJoin: vi.fn(),
    rollbackJoin: vi.fn(),
    setError: vi.fn(),
    watch: vi.fn((_call, onDisconnect, onNativeEnd) => {
      disconnected = onDisconnect;
      nativeEnded = onNativeEnd;
      return unwatch;
    }),
    onJoined: vi.fn(),
    onLeft: vi.fn(),
    reportError: vi.fn(),
  } satisfies Parameters<typeof createCallLifecycle>[0];
  const lifecycle = createCallLifecycle({ ...ports, ...extra });
  cleanups.push(lifecycle.dispose);
  return {
    lifecycle,
    ports,
    unwatch,
    disconnect: (reason?: DisconnectReason) => disconnected(reason),
    nativeEnd: () => nativeEnded(),
    async join() {
      const promise = lifecycle.join(call.channelId);
      await vi.advanceTimersByTimeAsync(300);
      await promise;
    },
  };
}

describe('shared call lifecycle', () => {
  it.each([true, false])(
    'returns the server call-ended result: %s',
    async (callEnded) => {
      const { lifecycle, join } = setup({ leave: async () => ({ callEnded }) });
      await join();
      await expect(lifecycle.leave(call.channelId)).resolves.toEqual({
        callEnded,
      });
    }
  );
  beforeEach(() => {
    vi.useFakeTimers();
    vi.setSystemTime(1_700_000_000_000);
  });
  afterEach(() => {
    for (const cleanup of cleanups.splice(0)) cleanup();
    vi.useRealTimers();
  });

  it('shares one in-flight join across controls and rejects a competing channel', async () => {
    const { lifecycle, ports } = setup();
    const first = lifecycle.join(call.channelId);
    expect(lifecycle.join(call.channelId)).toBe(first);
    await expect(lifecycle.join('channel-2')).rejects.toThrow(
      'Already joining'
    );
    expect(ports.requestToken).toHaveBeenCalledTimes(1);
    await vi.advanceTimersByTimeAsync(300);
    await first;
    expect(ports.connect).toHaveBeenCalledExactlyOnceWith(token);
    expect(lifecycle.getState()).toEqual({ t: 'active', call });
    expect(vi.getTimerCount()).toBe(0);
  });

  it('prepares native ring handoff before requesting membership and releases it after commit', async () => {
    const preparation = deferred<() => Promise<void>>();
    const cleanup = vi.fn(async () => {});
    const prepareToken = vi.fn(() => preparation.promise);
    const { lifecycle, ports } = setup({ prepareToken });
    const joined = lifecycle.join(call.channelId);
    expect(prepareToken).toHaveBeenCalledWith(call.channelId);
    expect(ports.requestToken).not.toHaveBeenCalled();
    preparation.resolve(cleanup);
    await vi.advanceTimersByTimeAsync(300);
    await joined;
    expect(ports.requestToken).toHaveBeenCalledOnce();
    expect(ports.connect).toHaveBeenCalledOnce();
    expect(cleanup).toHaveBeenCalledOnce();
  });

  it('releases native handoff immediately when a pending token request is cancelled', async () => {
    const cleanup = vi.fn(async () => {});
    const pendingToken = deferred<CallTokenResponse>();
    const { lifecycle, ports } = setup({ prepareToken: async () => cleanup });
    ports.requestToken.mockReturnValueOnce(pendingToken.promise);
    const joined = lifecycle.join(call.channelId);
    const rejected = expect(joined).rejects.toThrow('cancelled');
    await vi.advanceTimersByTimeAsync(0);
    lifecycle.dispose();
    expect(cleanup).toHaveBeenCalledOnce();
    pendingToken.resolve(token);
    await rejected;
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.connect).not.toHaveBeenCalled();
    expect(cleanup).toHaveBeenCalledOnce();
  });

  it('cleans a preparation that resolves after the join was cancelled', async () => {
    const preparation = deferred<() => Promise<void>>();
    const cleanup = vi.fn(async () => {});
    const { lifecycle, ports } = setup({
      prepareToken: () => preparation.promise,
    });
    const rejected = expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'cancelled'
    );
    lifecycle.dispose();
    preparation.resolve(cleanup);
    await rejected;
    await vi.advanceTimersByTimeAsync(0);
    expect(cleanup).toHaveBeenCalledOnce();
    expect(ports.requestToken).not.toHaveBeenCalled();
  });

  it('allows permission preparation to outlast the connection deadline', async () => {
    const preparation = deferred<() => Promise<void>>();
    const cleanup = vi.fn(async () => {});
    const { lifecycle, ports } = setup({
      prepareToken: () => preparation.promise,
    });
    ports.rollbackJoin.mockClear();
    const joined = lifecycle.join(call.channelId);
    await vi.advanceTimersByTimeAsync(JOIN_TIMEOUT_MS + 5_000);
    expect(ports.rollbackJoin).not.toHaveBeenCalled();
    expect(ports.requestToken).not.toHaveBeenCalled();
    preparation.resolve(cleanup);
    await joined;
    expect(ports.connect).toHaveBeenCalledOnce();
    expect(cleanup).toHaveBeenCalledOnce();
  });

  it('starts the connection deadline after permission preparation', async () => {
    const preparation = deferred<() => Promise<void>>();
    const cleanup = vi.fn(async () => {});
    const { lifecycle, ports } = setup({
      prepareToken: () => preparation.promise,
    });
    ports.requestToken.mockReturnValueOnce(
      deferred<CallTokenResponse>().promise
    );
    const rejected = expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'Connection timed out'
    );
    await vi.advanceTimersByTimeAsync(JOIN_TIMEOUT_MS + 5_000);
    preparation.resolve(cleanup);
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.requestToken).toHaveBeenCalledOnce();
    await vi.advanceTimersByTimeAsync(JOIN_TIMEOUT_MS);
    await rejected;
    expect(cleanup).toHaveBeenCalledOnce();
    expect(ports.connect).not.toHaveBeenCalled();
  });

  it('aborts native handoff when requesting membership fails', async () => {
    const cleanup = vi.fn(async () => {});
    const { lifecycle, ports } = setup({ prepareToken: async () => cleanup });
    ports.requestToken.mockRejectedValueOnce(new Error('Backend unavailable'));
    await expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'Backend unavailable'
    );
    expect(cleanup).toHaveBeenCalledOnce();
    expect(ports.connect).not.toHaveBeenCalled();
  });

  it('publishes an answer only after the connection completes', async () => {
    const { lifecycle, ports } = setup();
    const connection = deferred<void>();
    ports.connect.mockReturnValueOnce(connection.promise);
    const onJoin = vi.fn();
    const promise = lifecycle.join(call.channelId, onJoin);
    expect(onJoin).toHaveBeenCalledOnce();
    await vi.advanceTimersByTimeAsync(300);
    expect(ports.onJoined).not.toHaveBeenCalled();
    connection.resolve();
    await promise;
    expect(ports.onJoined).toHaveBeenCalledExactlyOnceWith(call, 'user');
    expect(ports.watch).toHaveBeenCalledOnce();
  });

  it('keeps the existing session when selecting its call tab again', async () => {
    const { lifecycle, ports, join } = setup();
    await join();
    const selectTab = vi.fn();
    await lifecycle.join(call.channelId, selectTab);
    expect(selectTab).toHaveBeenCalledOnce();
    expect(ports.connect).toHaveBeenCalledOnce();
    expect(ports.watch).toHaveBeenCalledOnce();
  });

  it('adopts an existing native session without requesting a token', async () => {
    const { lifecycle, ports } = setup();
    ports.shouldRequestToken.mockReturnValue(false);
    await lifecycle.join(call.channelId);
    expect(ports.requestToken).not.toHaveBeenCalled();
    expect(ports.connect).not.toHaveBeenCalled();
    expect(lifecycle.getState()).toEqual({ t: 'active', call });
    expect(ports.onJoined).toHaveBeenCalledExactlyOnceWith(call, 'user');
    expect(vi.getTimerCount()).toBe(0);
  });

  it.each(['joined', 'adopted'] as const)(
    'preserves the %s live call when another channel tries to join',
    async (origin) => {
      const { lifecycle, ports, join, unwatch, disconnect } = setup();
      if (origin === 'joined') await join();
      else lifecycle.syncSession(call);
      const tokenRequests = ports.requestToken.mock.calls.length;
      const onLeave = vi.fn();
      const onJoin = vi.fn();
      lifecycle.onLeave(onLeave);
      ports.requestToken.mockRejectedValueOnce(
        new ThrownResultError([
          { code: 'CONFLICT', message: 'Already in another call' },
        ])
      );
      await expect(lifecycle.join('channel-2', onJoin)).rejects.toThrow();
      await vi.advanceTimersByTimeAsync(300);
      expect(lifecycle.getState()).toEqual({ t: 'active', call });
      expect(ports.requestToken).toHaveBeenCalledTimes(tokenRequests);
      expect(ports.disconnect).not.toHaveBeenCalled();
      expect(ports.leave).not.toHaveBeenCalled();
      expect(unwatch).not.toHaveBeenCalled();
      expect(onLeave).not.toHaveBeenCalled();
      expect(onJoin).toHaveBeenCalledOnce();
      expect(ports.setError).toHaveBeenLastCalledWith(
        "You're already in another call. Leave your current call before joining a new one."
      );
      await lifecycle.join(call.channelId);
      expect(ports.setError).toHaveBeenLastCalledWith(null);
      disconnect(LK_DISCONNECT_REASON.CLIENT_INITIATED);
      expect(onLeave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    }
  );

  it('releases a timed-out join while cleanup hangs, and ignores its late token', async () => {
    const { lifecycle, ports } = setup();
    const oldToken = deferred<CallTokenResponse>();
    const cleanup = deferred<void>();
    ports.requestToken.mockReturnValueOnce(oldToken.promise);
    ports.disconnect.mockReturnValueOnce(cleanup.promise);
    const failed = expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'timed out'
    );
    await vi.advanceTimersByTimeAsync(JOIN_TIMEOUT_MS);
    await failed;
    expect(lifecycle.getState().t).toBe('failed');
    expect(ports.rollbackJoin).toHaveBeenCalled();
    const retry = lifecycle.join(call.channelId);
    await vi.advanceTimersByTimeAsync(300);
    await retry;
    oldToken.resolve(token);
    cleanup.resolve();
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.connect).toHaveBeenCalledOnce();
    expect(ports.leave).not.toHaveBeenCalled();
    expect(lifecycle.getState().t).toBe('active');
  });

  it('does not publish an answer for a connection that completed after cancellation', async () => {
    const { lifecycle, ports } = setup();
    const connection = deferred<void>();
    ports.connect.mockReturnValueOnce(connection.promise);
    const cancelled = expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'cancelled'
    );
    await vi.advanceTimersByTimeAsync(300);
    await lifecycle.leave(call.channelId);
    await cancelled;
    connection.resolve();
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.onJoined).not.toHaveBeenCalled();
    expect(lifecycle.getState().t).toBe('idle');
  });

  it.each([
    {
      error: new ThrownResultError([
        { code: 'CONFLICT', message: 'Already in another call' },
      ]),
      message:
        "You're already in another call. Leave your current call before joining a new one.",
    },
    {
      error: new Error('Network unavailable'),
      message: 'Unable to join the call. Please check your connection.',
    },
  ])(
    'preserves join failures and displays $message',
    async ({ error, message }) => {
      const { lifecycle, ports } = setup();
      ports.requestToken.mockRejectedValueOnce(error);
      await expect(lifecycle.join(call.channelId)).rejects.toBe(error);
      expect(lifecycle.getState()).toEqual({
        t: 'failed',
        channelId: call.channelId,
        error,
      });
      expect(ports.setError).toHaveBeenLastCalledWith(message);
    }
  );

  it('cancels a pending join when native confirms the session ended', async () => {
    const { lifecycle, ports } = setup();
    const pending = deferred<CallTokenResponse>();
    ports.requestToken.mockReturnValueOnce(pending.promise);
    const cancelled = expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'cancelled'
    );
    lifecycle.syncSession(undefined);
    await cancelled;
    expect(lifecycle.getState().t).toBe('idle');
    expect(ports.setError).toHaveBeenLastCalledWith(null);
    pending.resolve(token);
    await vi.advanceTimersByTimeAsync(JOIN_TIMEOUT_MS);
    expect(ports.connect).not.toHaveBeenCalled();
    expect(ports.onJoined).not.toHaveBeenCalled();
  });

  it.each([0, 300])(
    'leaves server membership when native cancels %s ms after requesting a token',
    async (elapsed) => {
      const { lifecycle, ports } = setup();
      let participantRegistered = false;
      ports.requestToken.mockImplementationOnce(async () => {
        participantRegistered = true;
        return token;
      });
      ports.leave.mockImplementationOnce(async () => {
        participantRegistered = false;
      });
      const connection = deferred<void>();
      ports.connect.mockReturnValueOnce(connection.promise);
      const cancelled = expect(lifecycle.join(call.channelId)).rejects.toThrow(
        'cancelled'
      );
      await vi.advanceTimersByTimeAsync(elapsed);
      expect(participantRegistered).toBe(true);
      lifecycle.syncSession(undefined);
      lifecycle.syncSession(undefined);
      await cancelled;
      await vi.advanceTimersByTimeAsync(0);
      expect(ports.disconnect).toHaveBeenCalledExactlyOnceWith({
        endNativeCall: false,
      });
      expect(ports.leave).toHaveBeenCalledExactlyOnceWith(call.channelId);
      expect(participantRegistered).toBe(false);
      expect(lifecycle.getState().t).toBe('idle');
      connection.resolve();
      await vi.advanceTimersByTimeAsync(JOIN_TIMEOUT_MS);
      expect(ports.onJoined).not.toHaveBeenCalled();
      expect(ports.leave).toHaveBeenCalledOnce();
    }
  );

  it('leaves server membership even if native cancellation disconnect fails', async () => {
    const { lifecycle, ports } = setup();
    const failure = new Error('transport cleanup failed');
    ports.disconnect.mockRejectedValueOnce(failure);
    const connection = deferred<void>();
    ports.connect.mockReturnValueOnce(connection.promise);
    const cancelled = expect(lifecycle.join(call.channelId)).rejects.toThrow(
      'cancelled'
    );
    await vi.advanceTimersByTimeAsync(300);
    lifecycle.syncSession(undefined);
    await cancelled;
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.leave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    expect(ports.reportError).toHaveBeenCalledExactlyOnceWith(failure);
    expect(lifecycle.getState().t).toBe('idle');
    connection.resolve();
  });

  it('detaches the session listener before explicit leave and shares duplicate leaves', async () => {
    const { lifecycle, ports, unwatch, disconnect, join } = setup();
    await join();
    const serverLeave = deferred<void>();
    ports.leave.mockReturnValueOnce(serverLeave.promise);
    const onLeave = vi.fn();
    lifecycle.onLeave(onLeave);
    const first = lifecycle.leave(call.channelId);
    expect(lifecycle.leave(call.channelId)).toBe(first);
    expect(unwatch).toHaveBeenCalledOnce();
    disconnect(); // An emitter may already have captured its listener list.
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.lookup).not.toHaveBeenCalled();
    expect(onLeave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    serverLeave.resolve();
    await first;
    expect(ports.disconnect).toHaveBeenCalledOnce();
    expect(ports.leave).toHaveBeenCalledOnce();
    expect(vi.getTimerCount()).toBe(0);
  });

  it('leaves the channel view and the server before slow media teardown completes', async () => {
    const leave = vi.fn(async () => ({ callEnded: true }));
    const { lifecycle, ports, join } = setup({ leave });
    await join();
    const teardown = deferred<void>();
    ports.disconnect.mockReturnValueOnce(teardown.promise);
    const onLeave = vi.fn();
    lifecycle.onLeave(onLeave);
    const leaving = lifecycle.leave(call.channelId);
    expect(onLeave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    // The last participant's RTC departure ends the call on the server, so a
    // leave sent after teardown could not report it.
    expect(leave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    teardown.resolve();
    await expect(leaving).resolves.toEqual({ callEnded: true });
    expect(onLeave).toHaveBeenCalledOnce();
  });

  it('handles native call end through the same leave lifecycle', async () => {
    const { ports, nativeEnd, join } = setup();
    await join();
    const teardown = deferred<void>();
    ports.disconnect.mockReturnValueOnce(teardown.promise);
    nativeEnd();
    await vi.advanceTimersByTimeAsync(0);
    // A restored session may still supersede native-end cleanup.
    expect(ports.leave).not.toHaveBeenCalled();
    teardown.resolve();
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.disconnect).toHaveBeenCalledExactlyOnceWith({
      endNativeCall: false,
    });
    expect(ports.leave).toHaveBeenCalledExactlyOnceWith(call.channelId);
  });

  it('rejoins only the same live call after a transport disconnect', async () => {
    const { lifecycle, ports, unwatch, disconnect, join } = setup();
    await join();
    disconnect();
    expect(unwatch).toHaveBeenCalledOnce();
    expect(lifecycle.getState().t).toBe('retry-wait');
    await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS + 300);
    expect(ports.lookup).toHaveBeenCalledExactlyOnceWith(call.channelId);
    expect(ports.connect).toHaveBeenCalledTimes(2);
    expect(lifecycle.getState()).toEqual({ t: 'active', call });
  });

  it.each([null, 'unavailable', { callId: 'replacement' }] as const)(
    'never starts a new call when recovery lookup returns %s',
    async (result) => {
      const { lifecycle, ports, disconnect, join } = setup();
      await join();
      ports.lookup.mockResolvedValueOnce(result);
      disconnect();
      await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS);
      expect(ports.requestToken).toHaveBeenCalledOnce();
      expect(lifecycle.getState().t).toBe('idle');
    }
  );

  it.each(Object.values(LK_DISCONNECT_REASON))(
    'does not recover intentional disconnect reason %s',
    async (reason) => {
      const { lifecycle, ports, disconnect, join } = setup();
      await join();
      const onLeave = vi.fn();
      lifecycle.onLeave(onLeave);
      disconnect(reason);
      expect(onLeave).toHaveBeenCalledOnce();
      expect(lifecycle.getState().t).toBe('idle');
      await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS);
      expect(ports.lookup).not.toHaveBeenCalled();
    }
  );

  it('cancels pending recovery when the user leaves during its lookup', async () => {
    const { lifecycle, ports, disconnect, join } = setup();
    await join();
    const lookup = deferred<ActiveCallLookup>();
    ports.lookup.mockReturnValueOnce(lookup.promise);
    disconnect();
    await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS);
    await lifecycle.leave(call.channelId);
    lookup.resolve({ callId: call.callId });
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.requestToken).toHaveBeenCalledOnce();
    expect(lifecycle.getState().t).toBe('idle');
  });

  it.each(['retry-wait', 'checking'] as const)(
    'cancels recovery when native ends during %s',
    async (phase) => {
      const { lifecycle, ports, disconnect, join } = setup();
      await join();
      const lookup = deferred<ActiveCallLookup>();
      ports.lookup.mockReturnValueOnce(lookup.promise);
      const onLeave = vi.fn();
      lifecycle.onLeave(onLeave);
      disconnect();
      if (phase === 'checking')
        await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS);
      expect(lifecycle.getState().t).toBe(phase);
      lifecycle.syncSession(undefined);
      lifecycle.syncSession(undefined);
      expect(lifecycle.getState().t).toBe('idle');
      expect(ports.setError).toHaveBeenLastCalledWith(null);
      expect(onLeave).toHaveBeenCalledExactlyOnceWith(call.channelId);
      lookup.resolve({ callId: call.callId });
      await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS + 300);
      expect(ports.requestToken).toHaveBeenCalledOnce();
    }
  );

  it('clears the recovery error when a live native session is adopted', async () => {
    const { lifecycle, ports, disconnect, join } = setup();
    await join();
    disconnect();
    expect(ports.setError).toHaveBeenLastCalledWith(
      'Call disconnected. Reconnecting…'
    );
    lifecycle.syncSession(call);
    expect(lifecycle.getState()).toEqual({ t: 'active', call });
    expect(ports.setError).toHaveBeenLastCalledWith(null);
    await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS);
    expect(ports.lookup).not.toHaveBeenCalled();
  });

  it('refuses recovery after sleep, including a lookup frozen in flight', async () => {
    const { lifecycle, ports, disconnect, join } = setup();
    await join();
    const lookup = deferred<ActiveCallLookup>();
    ports.lookup.mockReturnValueOnce(lookup.promise);
    disconnect();
    await vi.advanceTimersByTimeAsync(AUTO_REJOIN_DELAY_MS);
    vi.setSystemTime(Date.now() + 60_000);
    lookup.resolve({ callId: call.callId });
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.requestToken).toHaveBeenCalledOnce();
    expect(lifecycle.getState().t).toBe('idle');
  });

  it.each([LEAVE_TIMEOUT_MS + 1, -1])(
    'allows a resumed leave after a wall-clock jump of %s ms',
    async (jump) => {
      const { lifecycle, ports } = setup();
      const oldDisconnect = deferred<void>();
      ports.disconnect.mockReturnValueOnce(oldDisconnect.promise);
      const oldLeave = expect(lifecycle.leave(call.channelId)).rejects.toThrow(
        'cancelled'
      );
      vi.setSystemTime(Date.now() + jump);
      await lifecycle.leave(call.channelId);
      await oldLeave;
      oldDisconnect.resolve();
      await vi.advanceTimersByTimeAsync(0);
      expect(ports.disconnect).toHaveBeenCalledTimes(2);
      // Each hangup reaches the server before teardown; leaving is idempotent.
      expect(ports.leave).toHaveBeenCalledTimes(2);
      expect(ports.onLeft).toHaveBeenCalledOnce();
    }
  );

  it('still leaves the server when media teardown outlasts the leave timeout', async () => {
    const { lifecycle, ports, join } = setup();
    await join();
    ports.disconnect.mockReturnValueOnce(new Promise(() => {}));
    const failed = expect(lifecycle.leave(call.channelId)).rejects.toThrow(
      'timed out'
    );
    await vi.advanceTimersByTimeAsync(LEAVE_TIMEOUT_MS);
    await failed;
    expect(ports.leave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    expect(lifecycle.getState().t).toBe('idle');
  });

  it('records why each leave ran and which call it left', async () => {
    const { lifecycle, ports, join, nativeEnd } = setup();
    await join();
    await lifecycle.leave(call.channelId);
    await join();
    nativeEnd();
    await vi.advanceTimersByTimeAsync(0);
    expect(ports.onLeft.mock.calls).toEqual([
      [call, 'user_initiated'],
      [call, 'native_ended'],
    ]);
  });

  it('times out a hung leave and permits a new join', async () => {
    const { lifecycle, ports, join } = setup();
    ports.disconnect.mockReturnValueOnce(new Promise(() => {}));
    const failed = expect(lifecycle.leave(call.channelId)).rejects.toThrow(
      'timed out'
    );
    await vi.advanceTimersByTimeAsync(LEAVE_TIMEOUT_MS);
    await failed;
    await join();
    expect(lifecycle.getState().t).toBe('active');
  });

  it('owns exactly one listener for an adopted session and cleans it on disposal', async () => {
    const { lifecycle, ports, unwatch, disconnect } = setup();
    lifecycle.syncSession(call);
    lifecycle.syncSession(call);
    expect(ports.watch).toHaveBeenCalledOnce();
    lifecycle.dispose();
    disconnect();
    expect(unwatch).toHaveBeenCalledOnce();
    expect(vi.getTimerCount()).toBe(0);
    await expect(lifecycle.join(call.channelId)).rejects.toThrow('disposed');
    await expect(lifecycle.leave(call.channelId)).rejects.toThrow('disposed');
  });

  it('can join again after foreground sync clears a native call that ended while suspended', async () => {
    const { lifecycle, ports, unwatch, join } = setup();
    const onLeave = vi.fn();
    lifecycle.onLeave(onLeave);
    lifecycle.syncSession(call);
    lifecycle.syncSession(undefined);
    lifecycle.syncSession(undefined);
    expect(lifecycle.getState().t).toBe('idle');
    expect(unwatch).toHaveBeenCalledOnce();
    expect(onLeave).toHaveBeenCalledExactlyOnceWith(call.channelId);
    await join();
    expect(ports.requestToken).toHaveBeenCalledOnce();
    expect(ports.connect).toHaveBeenCalledOnce();
    expect(lifecycle.getState()).toEqual({ t: 'active', call });
  });
});