chore(mirada-compositor): backend DRM — quitar la instrumentación de depuración

El backend DRM funciona en hardware (sesión, render, teclado, atajos,
clientes, salida limpia). Diagnosticado: la franja al pie con `foot` es
que `foot` redondea su superficie a celdas de texto enteras (1920×1040
de 1080) — comportamiento del cliente, no del compositor.

Se retira la instrumentación: log por tecla, censo de dispositivos y
volcado de tamaños de superficie cada 2 s. El tope de tiempo
(MIRADA_DRM_TIMEOUT) pasa a estar desactivado por defecto — Super+Shift+e
y Ctrl+C son la salida normal.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/apps/mirada-compositor/src/drm_backend.rs

@@ -32,7 +32,6 @@ use smithay::backend::renderer::element::surface::{
 };
 use smithay::backend::renderer::element::Kind;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::backend::renderer::utils::with_renderer_surface_state;
 use smithay::backend::renderer::ImportDma;
 use smithay::backend::session::libseat::LibSeatSession;
 use smithay::backend::session::{Event as SessionEvent, Session};
@@ -75,8 +74,6 @@ struct DrmState {
     start: Instant,
     /// Nº de ventanas en el último `tick` — para registrar los cambios.
     last_windows: usize,
-    /// Cuenta de `tick`s — para registrar diagnósticos cada cierto rato.
-    tick_count: u32,
 }
 
 impl DrmState {
@@ -137,18 +134,6 @@ impl DrmState {
             self.last_windows = n;
         }
 
-        // Diagnóstico cada ~2 s: dónde y de qué tamaño está cada superficie.
-        self.tick_count = self.tick_count.wrapping_add(1);
-        if self.tick_count % 120 == 0 {
-            for w in &self.app.windows {
-                let size = with_renderer_surface_state(&w.surface, |s| s.surface_size());
-                eprintln!(
-                    "mirada-compositor · ventana id={} loc={:?} visible={} superficie={size:?}",
-                    w.id, w.loc, w.visible,
-                );
-            }
-        }
-
         if self.keymap_watch.as_ref().is_some_and(|w| w.changed()) {
             if let Some(path) = &self.keymap_path {
                 match Keymap::load(path) {
@@ -184,16 +169,11 @@ impl DrmState {
     }
 
     /// Procesa un evento de `libinput` — por ahora, sólo el teclado.
-    /// Va instrumentado: registra los dispositivos que encuentra y cada
-    /// tecla, para diagnosticar la entrada sin el hardware delante.
     fn handle_input(&mut self, event: InputEvent<LibinputInputBackend>) {
-        match event {
+        let InputEvent::Keyboard { event } = event else {
-            InputEvent::DeviceAdded { device } => {
+            return; // dispositivos, puntero, táctil: aún no
-                eprintln!("input · dispositivo detectado: «{}»", device.name());
+        };
-            }
-            InputEvent::Keyboard { event } => {
         let Some(keyboard) = self.app.keyboard.clone() else {
-                    eprintln!("input · ¡sin teclado en el seat!");
             return;
         };
         let code = event.key_code();
@@ -210,13 +190,12 @@ impl DrmState {
                 if !pressed {
                     return FilterResult::Forward;
                 }
-                        let combo = combo_string(mods, handle.modified_sym());
+                if let Some(combo) = combo_string(mods, handle.modified_sym()) {
-                        let grabbed = combo.as_ref().is_some_and(|c| st.grabs.contains(c));
+                    if st.grabs.contains(&combo) {
-                        eprintln!("input · tecla {code:?} → combo {combo:?} · atajo={grabbed}");
+                        st.pending_keybind = Some(combo);
-                        if grabbed {
-                            st.pending_keybind = combo;
                         return FilterResult::Intercept(());
                     }
+                }
                 FilterResult::Forward
             },
         );
@@ -225,9 +204,6 @@ impl DrmState {
             self.app.brain_feed(ev);
         }
     }
-            _ => {} // puntero/táctil: pendiente
-        }
-    }
 }
 
 /// Arranca el Cuerpo sobre DRM/KMS — fases 1, 2a y 2b.
@@ -472,13 +448,13 @@ pub fn run() -> Result<(), Box<dyn Error>> {
         })
         .map_err(|e| format!("insert timer: {e}"))?;
 
-    // Salida garantizada mientras depuramos: se cierra solo a los N s
+    // Tope de tiempo opcional: `MIRADA_DRM_TIMEOUT=<segundos>` cierra el
-    // (env `MIRADA_DRM_TIMEOUT`, 0 lo desactiva) — así nunca te quedas
+    // compositor solo (0 o sin definir = sin tope). El teclado ya
-    // atrapado si el teclado aún no responde.
+    // funciona — `Super+Shift+e` o `Ctrl+C` son la salida normal.
     let timeout_secs: u64 = std::env::var("MIRADA_DRM_TIMEOUT")
         .ok()
         .and_then(|v| v.parse().ok())
-        .unwrap_or(60);
+        .unwrap_or(0);
 
     println!("──────────────────────────────────────────────────");
     println!("mirada-compositor · escritorio en marcha sobre «{out_name}».");
@@ -499,7 +475,6 @@ pub fn run() -> Result<(), Box<dyn Error>> {
         ctl,
         start: Instant::now(),
         last_windows: 0,
-        tick_count: 0,
     };
 
     let signal = event_loop.get_signal();