refactor(compositor): remove pimpl wrapper from CompositorServer

src/compositor/compositor_cursor.cpp

@@ -86,7 +86,7 @@ auto fallback_cursor_pixels() -> std::vector<uint32_t> {
 } // namespace
 
 void CompositorServer::set_cursor_visible(bool visible) {
-    m_impl->state.set_cursor_visible(visible);
+    m_state->set_cursor_visible(visible);
 }
 
 auto CompositorState::setup_cursor_theme() -> Result<void> {

src/compositor/compositor_focus.cpp

@@ -111,21 +111,21 @@ void deactivate_previous_focus(CompositorState& state) {
 } // namespace
 
 auto CompositorServer::is_pointer_locked() const -> bool {
-    return m_impl->state.pointer_locked.load(std::memory_order_acquire);
+    return m_state->pointer_locked.load(std::memory_order_acquire);
 }
 
 auto CompositorServer::get_surfaces() const -> std::vector<SurfaceInfo> {
     GOGGLES_PROFILE_FUNCTION();
-    return m_impl->state.get_surfaces_snapshot();
+    return m_state->get_surfaces_snapshot();
 }
 
 void CompositorServer::set_input_target(uint32_t surface_id) {
-    m_impl->state.request_focus_target(surface_id);
+    m_state->request_focus_target(surface_id);
 }
 
 void CompositorServer::request_surface_resize(uint32_t surface_id,
                                               const SurfaceResizeInfo& resize) {
-    m_impl->state.request_surface_resize(surface_id, resize);
+    m_state->request_surface_resize(surface_id, resize);
 }
 
 void CompositorState::handle_focus_request() {

src/compositor/compositor_input.cpp

@@ -295,10 +295,10 @@ auto CompositorServer::forward_mouse_wheel(const SDL_MouseWheelEvent& event) ->
 
 auto CompositorServer::inject_event(const InputEvent& event) -> bool {
     GOGGLES_PROFILE_FUNCTION();
-    if (!m_impl->state.event_queue.try_push(event)) {
+    if (!m_state->event_queue.try_push(event)) {
         return false;
     }
-    return m_impl->state.wake_event_loop();
+    return m_state->wake_event_loop();
 }
 
 bool CompositorState::wake_event_loop() {

src/compositor/compositor_present.cpp

@@ -265,11 +265,11 @@ auto CompositorState::initialize_present_output() -> Result<void> {
 auto CompositorServer::get_presented_frame(uint64_t after_frame_number) const
     -> std::optional<util::ExternalImageFrame> {
     GOGGLES_PROFILE_FUNCTION();
-    std::scoped_lock lock(m_impl->state.present_mutex);
-    if (!m_impl->state.presented_frame) {
+    std::scoped_lock lock(m_state->present_mutex);
+    if (!m_state->presented_frame) {
         return std::nullopt;
     }
-    const auto& stored = *m_impl->state.presented_frame;
+    const auto& stored = *m_state->presented_frame;
     if (stored.frame_number <= after_frame_number) {
         return std::nullopt;
     }

src/compositor/compositor_server.cpp

@@ -6,7 +6,7 @@
 
 namespace goggles::compositor {
 
-CompositorServer::CompositorServer() : m_impl(std::make_unique<Impl>()) {}
+CompositorServer::CompositorServer() : m_state(std::make_unique<CompositorState>()) {}
 
 CompositorServer::~CompositorServer() {
     stop();
@@ -27,7 +27,7 @@ auto CompositorServer::create() -> ResultPtr<CompositorServer> {
 
 auto CompositorServer::start() -> Result<void> {
     GOGGLES_PROFILE_FUNCTION();
-    auto& state = m_impl->state;
+    auto& state = *m_state;
     auto cleanup_on_error = [this](void*) { stop(); };
     std::unique_ptr<void, decltype(cleanup_on_error)> guard(this, cleanup_on_error);
 
@@ -92,29 +92,29 @@ auto CompositorServer::start() -> Result<void> {
 
 void CompositorServer::stop() {
     GOGGLES_PROFILE_FUNCTION();
-    m_impl->state.teardown();
+    m_state->teardown();
 }
 
 auto CompositorServer::x11_display() const -> std::string {
-    return m_impl->state.x11_display_name();
+    return m_state->x11_display_name();
 }
 
 auto CompositorServer::wayland_display() const -> std::string {
-    return m_impl->state.wayland_socket_name;
+    return m_state->wayland_socket_name;
 }
 
 auto CompositorServer::target_fps() const -> uint32_t {
-    return m_impl->state.target_fps.load(std::memory_order_acquire);
+    return m_state->target_fps.load(std::memory_order_acquire);
 }
 
 void CompositorServer::set_target_fps(uint32_t target_fps) {
-    m_impl->state.target_fps.store(target_fps, std::memory_order_release);
-    m_impl->state.wake_event_loop();
+    m_state->target_fps.store(target_fps, std::memory_order_release);
+    m_state->wake_event_loop();
 }
 
 auto CompositorServer::get_runtime_metrics_snapshot() const
     -> util::CompositorRuntimeMetricsSnapshot {
-    return m_impl->state.get_runtime_metrics_snapshot();
+    return m_state->get_runtime_metrics_snapshot();
 }
 
 } // namespace goggles::compositor

src/compositor/compositor_server.hpp

@@ -41,6 +41,8 @@ struct InputEvent {
     bool horizontal;
 };
 
+struct CompositorState;
+
 /// @brief Runs a headless Wayland/XWayland compositor for input forwarding and surface capture.
 ///
 /// `start()` spawns a compositor thread. Input injection methods queue events for that thread.
@@ -87,8 +89,7 @@ class CompositorServer {
     void request_surface_resize(uint32_t surface_id, const SurfaceResizeInfo& resize);
 
 private:
-    struct Impl;
-    std::unique_ptr<Impl> m_impl;
+    std::unique_ptr<CompositorState> m_state;
 };
 
 } // namespace goggles::compositor

src/compositor/compositor_state.hpp

@@ -289,8 +289,4 @@ struct CompositorState {
     void set_cursor_visible(bool visible);
 };
 
-struct CompositorServer::Impl {
-    CompositorState state;
-};
-
 } // namespace goggles::compositor

tests/render/test_filter_boundary_contracts.cpp

@@ -180,10 +180,10 @@ TEST_CASE("Filter chain boundary control contract coverage", "[filter_chain][bou
     const auto compositor_set_target_pos =
         compositor_server_text->find("void CompositorServer::set_target_fps(uint32_t target_fps)");
     const auto compositor_store_pos = compositor_server_text->find(
-        "m_impl->state.target_fps.store(target_fps, std::memory_order_release);",
+        "m_state->target_fps.store(target_fps, std::memory_order_release);",
         compositor_set_target_pos);
     const auto compositor_wake_pos =
-        compositor_server_text->find("m_impl->state.wake_event_loop();", compositor_store_pos);
+        compositor_server_text->find("m_state->wake_event_loop();", compositor_store_pos);
     REQUIRE(compositor_set_target_pos != std::string::npos);
     REQUIRE(compositor_store_pos != std::string::npos);
     REQUIRE(compositor_wake_pos != std::string::npos);