fix: isolate text buffers by input context

Author: radislabus-star

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "lay"
-version = "0.1.202"
+version = "0.1.203"
 edition = "2021"
 description = "Alpha Double Shift RU/EN layout rescue for Linux desktops"
 license = "MIT"

Cargo.toml

@@ -22,9 +22,9 @@ const STATS_PATH = GLib.get_home_dir() + '/.local/share/lay/stats.json';
 const RECENT_ACTIONS_PATH = GLib.get_home_dir() + '/.local/share/lay/recent_actions.jsonl';
 const PROJECT_DIR = GLib.get_home_dir() + '/projects/lay';
 const UPDATE_LOG_PATH = GLib.get_home_dir() + '/.local/state/lay/update.log';
-const APP_VERSION = '0.1.202';
+const APP_VERSION = '0.1.203';
 const APP_DESCRIPTION = 'Alpha RU/EN layout helper: double Shift и помощь при наборе';
-const APP_RELEASE_DATE = '2026-05-31';
+const APP_RELEASE_DATE = '2026-06-01';
 const APP_LICENSE = 'MIT';
 const APP_URL = 'https://github.com/radislabus-star/lay-public';
 const APP_PLATFORM = 'Linux desktops: GNOME, KDE, Wayland, X11';

extension/lay@radislabus-star.github.io/lay-impl.js

@@ -1,8 +1,8 @@
 {
     "uuid": "lay@radislabus-star.github.io",
     "name": "Lay Layout Switcher",
-    "version": 202,
-    "version-name": "0.1.202",
+    "version": 203,
+    "version-name": "0.1.203",
     "description": "Alpha GNOME Shell extension для lay-daemon. Показывает EN/RU в трее, переключает раскладку по клику. Минимальный DBus bridge для layout activation и fallback text insert.",
     "shell-version": ["45", "46", "47", "50"],
     "url": "https://github.com/radislabus-star/lay-public"

extension/lay@radislabus-star.github.io/metadata.json

@@ -118,6 +118,9 @@ mod boundary_runtime;
 #[path = "lay_daemon/typing_key_runtime.rs"]
 mod typing_key_runtime;
 
+#[path = "lay_daemon/text_context_runtime.rs"]
+mod text_context_runtime;
+
 #[path = "lay_daemon/buffer_filter_runtime.rs"]
 mod buffer_filter_runtime;
 use buffer_filter_runtime::*;

src/bin/lay_daemon.rs

@@ -2,6 +2,7 @@ use evdev::{uinput::VirtualDevice, Device, EventType, InputEvent, KeyCode};
 use lay::config::LayConfig;
 use lay::keyboard::is_typing_key;
 use std::os::fd::AsRawFd;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
 use super::boundary_runtime::{
@@ -16,17 +17,20 @@ use super::manual_trigger_runtime::{
     fire_expired_pending_multi_tap, handle_manual_trigger_event, ManualTriggerEventContext,
     PendingMultiTapTimeoutContext,
 };
+use super::text_context_runtime::should_advance_text_context;
 use super::trigger_dispatch::{is_single_trigger_id, trigger_key_from_config};
 use super::typing_key_runtime::{handle_typing_key_press, TypingKeyContext};
 use super::{
     active_enter_autocorrect_from_env, active_layout_backend, idle_wait_timeout, log,
-    poll_focused_window_state, should_skip_buffer_input, wait_for_keyboard_event_or_timeout,
-    DShiftState, ForceLayoutHotkeyContext, ShiftState, ENTER_AUTOCORRECT_EXPERIMENT_ENV,
+    poll_focused_window_state, poll_focused_window_state_for_key_event, should_skip_buffer_input,
+    wait_for_keyboard_event_or_timeout, DShiftState, ForceLayoutHotkeyContext, ShiftState,
+    ENTER_AUTOCORRECT_EXPERIMENT_ENV,
 };
 
 pub(super) fn listen_keyboard(
     device_path: std::path::PathBuf,
     virtual_kbd: Arc<Mutex<Option<VirtualDevice>>>,
+    field_context_epoch: Arc<AtomicU64>,
     verbose: bool,
     cfg: LayConfig,
 ) -> std::io::Result<()> {
@@ -139,7 +143,8 @@ pub(super) fn listen_keyboard(
             Err(e) => return Err(e),
         };
 
-        update_focus_state(&mut state);
+        update_focus_state_for_key_batch(&events, &mut state);
+        sync_field_context_epoch(&field_context_epoch, &mut state);
         if state.focus_ignored {
             state.shift_state = ShiftState::default();
             state.dshift_state = DShiftState::Idle;
@@ -169,6 +174,12 @@ pub(super) fn listen_keyboard(
 
             // ─── modifier tracking ────────────────────────────
             state.shift_state.update(key, value);
+            if should_advance_text_context(key, value, &state.shift_state) {
+                let epoch = field_context_epoch.fetch_add(1, Ordering::Relaxed) + 1;
+                if state.switch_field_context_epoch(epoch) && verbose {
+                    log("► text context changed: switched field buffer");
+                }
+            }
             if state.force_layout_hotkeys.handle_event(
                 key,
                 value,
@@ -339,11 +350,92 @@ pub(super) fn listen_keyboard(
     }
 }
 
+pub(super) fn listen_pointer(
+    device_path: std::path::PathBuf,
+    field_context_epoch: Arc<AtomicU64>,
+    verbose: bool,
+) -> std::io::Result<()> {
+    let mut device = Device::open(&device_path)?;
+    device.set_nonblocking(true)?;
+    let device_fd = device.as_raw_fd();
+    log(&format!(
+        "► слушаю pointer: {device_path:?} имя={:?}",
+        device.name().unwrap_or("?")
+    ));
+
+    loop {
+        let fetched_events = {
+            device
+                .fetch_events()
+                .map(|events| events.collect::<Vec<_>>())
+        };
+        let events: Vec<InputEvent> = match fetched_events {
+            Ok(events) => events,
+            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+                wait_for_keyboard_event_or_timeout(
+                    device_fd,
+                    std::time::Duration::from_millis(500),
+                )?;
+                continue;
+            }
+            Err(e) => return Err(e),
+        };
+
+        for event in events {
+            if event.event_type() != EventType::KEY || event.value() != 1 {
+                continue;
+            }
+            let key = KeyCode::new(event.code());
+            if matches!(
+                key,
+                KeyCode::BTN_LEFT
+                    | KeyCode::BTN_RIGHT
+                    | KeyCode::BTN_MIDDLE
+                    | KeyCode::BTN_SIDE
+                    | KeyCode::BTN_EXTRA
+                    | KeyCode::BTN_FORWARD
+                    | KeyCode::BTN_BACK
+                    | KeyCode::BTN_TASK
+            ) {
+                let epoch = field_context_epoch.fetch_add(1, Ordering::Relaxed) + 1;
+                if verbose {
+                    log(&format!("► pointer context changed: field epoch {epoch}"));
+                }
+            }
+        }
+    }
+}
+
 fn update_focus_state(state: &mut DaemonLoopState) {
-    let Some(focus) = poll_focused_window_state(&mut state.last_focus_ignore_poll) else {
-        return;
+    let focus = poll_focused_window_state(&mut state.last_focus_ignore_poll);
+    apply_focus_state(state, focus);
+}
+
+fn update_focus_state_for_key_batch(events: &[InputEvent], state: &mut DaemonLoopState) {
+    let has_key_event = events
+        .iter()
+        .any(|event| event.event_type() == EventType::KEY);
+    let focus = if has_key_event {
+        poll_focused_window_state_for_key_event(&mut state.last_focus_ignore_poll)
+    } else {
+        poll_focused_window_state(&mut state.last_focus_ignore_poll)
     };
+    apply_focus_state(state, focus);
+}
+
+fn sync_field_context_epoch(field_context_epoch: &AtomicU64, state: &mut DaemonLoopState) {
+    let epoch = field_context_epoch.load(Ordering::Relaxed);
+    if state.switch_field_context_epoch(epoch) {
+        log("► text context changed: switched field buffer");
+        state.dshift_state = DShiftState::Idle;
+        state.pending_multi_tap = None;
+    }
+}
 
+fn apply_focus_state(state: &mut DaemonLoopState, focus: Option<super::FocusedWindowState>) {
+    let Some(focus) = focus else {
+        return;
+    };
     let identity_changed = state.switch_window_input_state(focus.identity);
     if identity_changed {
         log("► focused window changed: switched text tail buffer");

src/bin/lay_daemon/daemon_runtime.rs

@@ -31,6 +31,8 @@ pub(super) struct DaemonLoopState {
     pub(super) events_since_word_start: u32,
     pub(super) pending_typing_assist_after_space: Option<PendingTypingAssist>,
     pub(super) focus_ignored: bool,
+    pub(super) focused_window_identity: Option<String>,
+    pub(super) field_context_epoch: u64,
     pub(super) active_window_identity: Option<String>,
     pub(super) window_states: HashMap<String, WindowInputState>,
     pub(super) ignore_current_token_until_space: bool,
@@ -44,6 +46,7 @@ pub(super) struct WindowInputState {
     ignore_current_token_until_space: bool,
     clear_on_next_typing: bool,
     suppress_next_typing_assist_after_manual_replay: bool,
+    saved_at: Instant,
 }
 
 impl WindowInputState {
@@ -56,6 +59,7 @@ impl WindowInputState {
             clear_on_next_typing: state.clear_on_next_typing,
             suppress_next_typing_assist_after_manual_replay: state
                 .suppress_next_typing_assist_after_manual_replay,
+            saved_at: Instant::now(),
         }
     }
 
@@ -95,6 +99,8 @@ impl DaemonLoopState {
             events_since_word_start: 0,
             pending_typing_assist_after_space: None,
             focus_ignored: false,
+            focused_window_identity: None,
+            field_context_epoch: 0,
             active_window_identity: None,
             window_states: HashMap::new(),
             ignore_current_token_until_space: false,
@@ -103,12 +109,28 @@ impl DaemonLoopState {
     }
 
     pub(super) fn switch_window_input_state(&mut self, identity: Option<String>) -> bool {
+        self.focused_window_identity = identity;
+        self.switch_text_context_state()
+    }
+
+    pub(super) fn switch_field_context_epoch(&mut self, epoch: u64) -> bool {
+        if self.field_context_epoch == epoch {
+            return false;
+        }
+        self.field_context_epoch = epoch;
+        self.switch_text_context_state()
+    }
+
+    fn switch_text_context_state(&mut self) -> bool {
+        let identity = self.active_text_context_identity();
         if self.active_window_identity == identity {
             return false;
         }
         if let Some(previous) = self.active_window_identity.take() {
-            let previous_state = WindowInputState::take_from(self);
-            self.window_states.insert(previous, previous_state);
+            if self.should_save_current_text_context() {
+                let previous_state = WindowInputState::take_from(self);
+                self.window_states.insert(previous, previous_state);
+            }
         }
 
         if let Some(current) = identity.clone() {
@@ -124,6 +146,38 @@ impl DaemonLoopState {
             }
         }
         self.active_window_identity = identity;
+        self.prune_window_states();
         true
     }
+
+    fn active_text_context_identity(&self) -> Option<String> {
+        self.focused_window_identity
+            .as_ref()
+            .map(|window| format!("{window}:field:{}", self.field_context_epoch))
+    }
+
+    fn should_save_current_text_context(&self) -> bool {
+        !self.buffer.current_is_empty()
+            || self.events_since_word_start > 0
+            || self.pending_typing_assist_after_space.is_some()
+            || self.ignore_current_token_until_space
+            || self.clear_on_next_typing
+            || self.suppress_next_typing_assist_after_manual_replay
+    }
+
+    fn prune_window_states(&mut self) {
+        const MAX_SAVED_TEXT_CONTEXTS: usize = 50;
+
+        while self.window_states.len() > MAX_SAVED_TEXT_CONTEXTS {
+            let Some(oldest_key) = self
+                .window_states
+                .iter()
+                .min_by_key(|(_, state)| state.saved_at)
+                .map(|(key, _)| key.clone())
+            else {
+                break;
+            };
+            self.window_states.remove(&oldest_key);
+        }
+    }
 }