Entire process is terminated when xserver is killed

[tydanel]

Describe the bug
Process seems to exit after killing the xserver even though the thread running tao instance is terminated, not sure if this is expected but it seems like this shouldn't be the case.. I might also just be overlooking something here..

If I comment out the tao stuff and leave the xephyr child process stuff the loop continues and if I stop tao and never stop the xserver the loop keeps running...

Not sure what actually causes the entire process to terminate, will keep looking and update if I spot anything

Steps To Reproduce
Will need Xephyr installed but will also work with Xvfb.

use tao::{
    event_loop::{ControlFlow, EventLoopBuilder},
    platform::{run_return::EventLoopExtRunReturn, unix::EventLoopBuilderExtUnix},
    window::WindowBuilder,
};

const DISPLAY: &str = ":60";

fn main() {
    let mut display = spawn_xephyr(DISPLAY, 800, 600);
    std::thread::sleep(std::time::Duration::from_secs(1));
    std::env::set_var("DISPLAY", DISPLAY);

    let (tx_ready, rx_ready) = std::sync::mpsc::channel();

    let mut ui_thread = Some(std::thread::spawn(|| {
        let mut event_loop = EventLoopBuilder::<()>::with_user_event()
            .with_any_thread(true)
            .build();

        let event_proxy = event_loop.create_proxy();

        let mut _window = Some(
            WindowBuilder::new()
                .with_title("Window")
                .with_inner_size(tao::dpi::LogicalSize::new(300.0, 300.0))
                .with_min_inner_size(tao::dpi::LogicalSize::new(200.0, 200.0))
                .build(&event_loop)
                .unwrap(),
        );

        event_loop.run_return(move |event, _, control_flow| {
            *control_flow = ControlFlow::Wait;
            match event {
                tao::event::Event::NewEvents(tao::event::StartCause::Init) => {
                    tx_ready.send(event_proxy.clone()).unwrap();
                }
                tao::event::Event::UserEvent(()) => {
                    *control_flow = tao::event_loop::ControlFlow::Exit;
                    println!("Exiting... {:?}", control_flow);
                }
                _ => {}
            }
        })
    }));

    let event_proxy = rx_ready.recv().unwrap();

    loop {
        println!("Should loop forever");
        std::thread::sleep(std::time::Duration::from_secs(1));

        if ui_thread.is_some() {
            event_proxy.send_event(()).unwrap();
            let ui_thread = ui_thread.take().unwrap();
            ui_thread.join().unwrap();
            let _ = display.kill();
        }
    }
}

fn spawn_xephyr(display_identifier: &str, width: u32, height: u32) -> std::process::Child {
    std::process::Command::new("Xephyr")
        .arg(display_identifier)
        .arg("-screen")
        .arg(format!("{}x{}", width, height))
        .spawn()
        .expect("Failed to start Xephyr")
}

Expected behavior
The loop in main should continue even after the xserver is killed

Platform and Versions (please complete the following information):
OS: Arch Linux x86_64 Linux 6.12.8-arch1-1
Rustc: 1.82.0

[tydanel]

Okay from what I can see, when I do this *control_flow = tao::event_loop::ControlFlow::Exit; and then call join() on the JoinHandle the window still remains visible in the xserver and only goes away when the entire process terminates.

I'm guessing this is why the documentation recommends using run() instead of run_return() as it calls process::exit() in order to clear everything up.

A bit of a pain if this can't be resolved but I'm early enough in the project and have an idea to re-architect things to work around this limitation