railmux 0.4.1.dev3__tar.gz → 0.4.1.dev5__tar.gz

{railmux-0.4.1.dev3/src/railmux.egg-info → railmux-0.4.1.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.1.dev3
+Version: 0.4.1.dev5
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.1.dev5/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.1.dev5"

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/src/railmux/tmux_ctl.py

@@ -2046,6 +2046,9 @@ _ROOT_TERMUX_TAP_MARKER = "railmux-termux-tap-v1"
 STATUS_ACTION_MODE = "railmux-mode"
 STATUS_ACTION_LAYOUT = "railmux-layout"
 STATUS_ACTION_COPY = "railmux-copy"
+STATUS_ACTION_PAGE_SIDEBAR = "railmux-page-r"
+STATUS_ACTION_PAGE_PRIMARY = "railmux-page-1"
+STATUS_ACTION_PAGE_SECONDARY = "railmux-page-2"
 _ROOT_STATUS_ACTION_KEYS = {
     STATUS_ACTION_MODE: "MouseDown1Control0",
     STATUS_ACTION_LAYOUT: "MouseDown1Control1",
@@ -2059,6 +2062,9 @@ _STATUS_ACTIONS = frozenset({
     STATUS_ACTION_MODE,
     STATUS_ACTION_LAYOUT,
     STATUS_ACTION_COPY,
+    STATUS_ACTION_PAGE_SIDEBAR,
+    STATUS_ACTION_PAGE_PRIMARY,
+    STATUS_ACTION_PAGE_SECONDARY,
 })
 _PREFIX_TARGET_KEY = "Tab"
 _PREFIX_TARGET_MARKER = "railmux-target-toggle-v1"
@@ -2085,6 +2091,15 @@ RAILMUX_HISTORY_RESTORE_KEYS = {
     "primary": ("F23", "\x1b[42~"),
     "secondary": ("F24", "\x1b[43~"),
 }
+# Compact status clicks must reach the controller before pane focus changes so
+# it can park the visible provider, switch the zoomed page, and resume the new
+# provider as one transaction.  tmux names keys only through F12, therefore
+# these private routes use canonical xterm sequences in literal mode.
+RAILMUX_COMPACT_PAGE_KEYS = {
+    STATUS_ACTION_PAGE_SIDEBAR: ("F13", "\x1b[25~"),
+    STATUS_ACTION_PAGE_PRIMARY: ("F14", "\x1b[26~"),
+    STATUS_ACTION_PAGE_SECONDARY: ("F15", "\x1b[28~"),
+}
 RAILMUX_SELECTION_KEY_OPTION = "@railmux_selection_key"
 RAILMUX_SELECTION_PEER_OPTION = "@railmux_selection_peer"
 RAILMUX_SELECTION_FROZEN_OPTION = "@railmux_selection_frozen_by"
@@ -2124,7 +2139,9 @@ def status_pane_range(pane_id: str, content: str) -> str:
     # A pane range sets ``mouse_status_range`` to only the literal ``pane``;
     # ``=`` still resolves to the pane geometrically below the status cell,
     # not to X. A user range preserves the strict pane ID as its argument, so
-    # the managed binding can select the intended compact page explicitly.
+    # the managed binding can select a pane-targeted status control explicitly.
+    # Compact page navigation uses controller actions instead so parking,
+    # resuming, and zooming remain one ordered transaction.
     #
     # Status strings also pass through tmux's strftime expansion.  Escape the
     # pane-ID percent sign so IDs such as ``%76`` are not parsed as padding
@@ -2149,8 +2166,8 @@ def status_action_range(action: str, content: str) -> str:
     # keys avoids routing fixed actions through the generic user-range
     # dispatcher and provides deterministic bindings on the 3.7b version
     # bundled by the managed Windows runtime.
-    if tmux_version() >= (3, 7):
-        key = _ROOT_STATUS_ACTION_KEYS[action]
+    key = _ROOT_STATUS_ACTION_KEYS.get(action)
+    if tmux_version() >= (3, 7) and key is not None:
         index = key.removeprefix("MouseDown1Control")
         return f"#[range=control|{index}]{content}#[norange]"
     return f"#[range=user|{action}]{content}#[norange]"
@@ -3079,7 +3096,7 @@ def set_root_status_click_forwarding(
     marker = f"{_ROOT_STATUS_CLICK_MARKER}-{token}"
     condition = (
         "#{&&:"
-        "#{m/r:^(%[0-9]+|railmux-(mode|layout|copy))$,"
+        "#{m/r:^(%[0-9]+|railmux-(mode|layout|copy|page-[r12]))$,"
         "#{mouse_status_range}},"
         "#{!=:#{@railmux_controller_pane},},"
         f"#{{==:{marker},{marker}}}}}"
@@ -3097,6 +3114,18 @@ def set_root_status_click_forwarding(
             f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' F7 ;; '
             f'{STATUS_ACTION_COPY}) {_tmux_shell_executable()} send-keys -t '
             f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' F6 ;; '
+            f'{STATUS_ACTION_PAGE_SIDEBAR}) '
+            f'{_tmux_shell_executable()} send-keys -l -t '
+            f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' -- '
+            f'{shlex.quote(RAILMUX_COMPACT_PAGE_KEYS[STATUS_ACTION_PAGE_SIDEBAR][1])} ;; '
+            f'{STATUS_ACTION_PAGE_PRIMARY}) '
+            f'{_tmux_shell_executable()} send-keys -l -t '
+            f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' -- '
+            f'{shlex.quote(RAILMUX_COMPACT_PAGE_KEYS[STATUS_ACTION_PAGE_PRIMARY][1])} ;; '
+            f'{STATUS_ACTION_PAGE_SECONDARY}) '
+            f'{_tmux_shell_executable()} send-keys -l -t '
+            f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' -- '
+            f'{shlex.quote(RAILMUX_COMPACT_PAGE_KEYS[STATUS_ACTION_PAGE_SECONDARY][1])} ;; '
             'esac"'
         )
         subprocess.check_call(

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/src/railmux/ui/app.py

@@ -305,7 +305,7 @@ def _compact_tmux_status_left(
     page: WorkspacePage,
     panes: tuple[str | None, str | None, str | None],
     width: int,
-    range_wrapper: Callable[[str, str], str] | None = None,
+    page_range_wrapper: Callable[[str, str], str] | None = None,
     action_range_wrapper: Callable[[str, str], str] | None = None,
     layout_indicator: str | None = None,
 ) -> tuple[str, int]:
@@ -332,19 +332,26 @@ def _compact_tmux_status_left(
         WorkspacePage.PRIMARY,
         WorkspacePage.SECONDARY,
     )
+    page_actions = (
+        tmux_ctl.STATUS_ACTION_PAGE_SIDEBAR,
+        tmux_ctl.STATUS_ACTION_PAGE_PRIMARY,
+        tmux_ctl.STATUS_ACTION_PAGE_SECONDARY,
+    )
     fg_inactive = "colour231" if error else "colour0"
     fg_active = "colour220" if error else "colour231"
     rendered: list[str] = []
     visible = 0
-    for candidate, pane_id, label in zip(pages, panes, labels):
+    for candidate, action, pane_id, label in zip(
+        pages, page_actions, panes, labels,
+    ):
         # Keep all three positions stable even before F8 creates Pane 2. A
         # missing pane has no tmux range, so it is visible but not clickable.
         content = (
             f"#[fg={fg_active if candidate is page else fg_inactive}]"
             f"[{label}]"
         )
-        if range_wrapper is not None and pane_id is not None:
-            content = range_wrapper(pane_id, content)
+        if page_range_wrapper is not None and pane_id is not None:
+            content = page_range_wrapper(action, content)
         rendered.append(content)
         visible += len(label) + 2
     mode_content = mode
@@ -3418,6 +3425,7 @@ class App:
             for changed in reversed(parked):
                 self._resume_compact_slot(changed)
             return False
+        resume_required = bool(desired is not None and desired.display_parked)
         if desired is not None and not self._resume_compact_slot(desired):
             fallback_page = workspace.compact_page
             fallback_pane = self._pane_for_workspace_page(fallback_page)
@@ -3435,6 +3443,14 @@ class App:
         pane_id = self._pane_for_workspace_page(page)
         if pane_id is None or not tmux_ctl.pane_alive(pane_id):
             return False
+        # swap-pane unzooms a window when the active compact placeholder moves
+        # back to the provider's home window.  Re-establish zoom against the
+        # real pane that is now visible before committing the logical page.
+        if resume_required and not self._zoom_pane(pane_id):
+            if announce:
+                self._set_status(
+                    "That compact page could not fill the screen.", "warn")
+            return False
 
         workspace.compact_page = page
         if page is WorkspacePage.PRIMARY:
@@ -8332,6 +8348,17 @@ class App:
         if key == COMPACT_RESIZE_KEY.lower():
             self._handle_remote_compact_prepare()
             return
+        compact_pages = {
+            "f13": WorkspacePage.SIDEBAR,
+            "f14": WorkspacePage.PRIMARY,
+            "f15": WorkspacePage.SECONDARY,
+        }
+        if key in compact_pages:
+            if (self._agent_workspace().presentation
+                    is WorkspacePresentation.COMPACT):
+                self._select_workspace_page(
+                    compact_pages[key], announce=True)
+            return
         for slot_key, (restore_key, _sequence) in (
                 tmux_ctl.RAILMUX_HISTORY_RESTORE_KEYS.items()):
             if key == restore_key.lower():
@@ -11785,16 +11812,15 @@ class App:
                 is WorkspacePresentation.COMPACT):
             width = (getattr(self, "_last_workspace_size", None) or (80, 24))[0]
             manager = getattr(self, "_tmux_binding_manager", None)
-            pane_range_helper = getattr(tmux_ctl, "status_pane_range", None)
             action_range_helper = getattr(
                 tmux_ctl, "status_action_range", None)
             wrap_pane = None
             wrap_action = None
             if (getattr(manager, "status_navigation_available", False)
-                    is True and callable(pane_range_helper)):
-                def wrap_pane(pane_id: str, content: str) -> str:
+                    is True and callable(action_range_helper)):
+                def wrap_pane(action: str, content: str) -> str:
                     try:
-                        return pane_range_helper(pane_id, content)
+                        return action_range_helper(action, content)
                     except (TypeError, ValueError):
                         return content
             if (getattr(manager, "status_navigation_available", False)

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/src/railmux/windows_attach_relay.py

@@ -320,6 +320,22 @@ class _SemanticTerminalRenderer:
             and self._presentation_serial >= self._presentation_required_serial
         )
 
+    @property
+    def pointer_routing_stable(self) -> bool:
+        """Whether the last physical screen still has trusted pointer geometry.
+
+        An ordinary provider repaint can keep one terminal write in flight for
+        long enough to overlap several Windows wheel reports.  That does not
+        invalidate the already visible pane layout.  Explicit topology
+        transitions call :meth:`require_fresh_presentation` and remain
+        fail-closed until the matching newer frame is physically visible.
+        """
+        self._promote_presented_screen()
+        return bool(
+            self._screen is not None
+            and self._presentation_serial >= self._presentation_required_serial
+        )
+
     def require_fresh_presentation(self) -> None:
         """Fail pointer input closed until one newer frame is displayed."""
         required = self._presentation_serial + 1
@@ -1815,14 +1831,19 @@ class LocalPtyClient:
             part,
             logical_height=logical_height,
         )
-        if not self._renderer.presentation_stable:
+        routing_stable = self._renderer.presentation_stable or (
+            event.wheel_direction != 0
+            and self._renderer.pointer_routing_stable
+        )
+        if not routing_stable:
             if not self._selection.capturing and self._selection.cancel():
                 self._renderer.set_selection(self._selection.segments())
             # A queued frame can already represent a new tmux pane topology
-            # while the user still sees the prior one.  Dropping only pointer
-            # input during this bounded transition is safer than forwarding it
-            # to Quit or stock tmux copy-mode. A capture already owns an
-            # immutable visible snapshot and therefore keeps the whole gesture.
+            # while the user still sees the prior one. Explicitly untrusted
+            # geometry stays fail-closed; an ordinary content-only write may
+            # still route wheel input against the last physical screen. A
+            # capture already owns an immutable visible snapshot and therefore
+            # keeps the whole gesture.
             if not self._selection.capturing:
                 return
         if self._selection.capturing:

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.1.dev3
+Version: 0.4.1.dev5
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/tests/test_fullscreen_binding.py

@@ -1,6 +1,6 @@
 """Tests for F8/F9 dispatch and managed binding lifecycle."""
 import threading
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, call
 
 from railmux import tmux_server
 from railmux.config import Config
@@ -847,6 +847,27 @@ def test_compact_page_switch_retargets_and_rezooms_without_losing_layout(
         False, force_border=True)
 
 
+def test_private_compact_page_keys_delegate_only_in_compact_presentation():
+    app = _bare_app()
+    app._select_workspace_page = MagicMock(return_value=True)
+
+    app._agent_workspace().presentation = WorkspacePresentation.COMPACT
+    app._on_input("f14")
+    app._on_input("f15")
+    app._on_input("f13")
+
+    assert app._select_workspace_page.call_args_list == [
+        call(WorkspacePage.PRIMARY, announce=True),
+        call(WorkspacePage.SECONDARY, announce=True),
+        call(WorkspacePage.SIDEBAR, announce=True),
+    ]
+
+    app._select_workspace_page.reset_mock()
+    app._agent_workspace().presentation = WorkspacePresentation.WIDE
+    app._on_input("f14")
+    app._select_workspace_page.assert_not_called()
+
+
 def test_full_sidebar_modal_restores_preexisting_agent_zoom(monkeypatch):
     app = _bare_app(_railmux_pane_id="%1")
     app._show_overlay = MagicMock()

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/tests/test_layout_profile.py

@@ -219,6 +219,7 @@ def test_compact_page_switch_parks_old_agent_before_resuming_target(
 
     transport.park.assert_called_once_with(workspace.primary)
     transport.resume.assert_called_once_with(workspace.secondary)
+    assert app._zoom_pane.call_args_list == [call("%30"), call("%3")]
     assert workspace.compact_page.value == "secondary"
 
 

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/tests/test_tmux_ctl.py

@@ -970,6 +970,9 @@ def test_status_action_range_requires_tmux_34_and_known_action():
             tmux_ctl.STATUS_ACTION_MODE,
             tmux_ctl.STATUS_ACTION_LAYOUT,
             tmux_ctl.STATUS_ACTION_COPY,
+            tmux_ctl.STATUS_ACTION_PAGE_SIDEBAR,
+            tmux_ctl.STATUS_ACTION_PAGE_PRIMARY,
+            tmux_ctl.STATUS_ACTION_PAGE_SECONDARY,
         )
     )
     with patch.object(tmux_ctl, "tmux_version", return_value=(3, 3)):
@@ -985,6 +988,10 @@ def test_status_action_range_requires_tmux_34_and_known_action():
             tmux_ctl.STATUS_ACTION_LAYOUT, "◨") == (
             "#[range=control|1]◨#[norange]"
         )
+        assert tmux_ctl.status_action_range(
+            tmux_ctl.STATUS_ACTION_PAGE_PRIMARY, "[1]") == (
+            "#[range=user|railmux-page-1][1]#[norange]"
+        )
         try:
             tmux_ctl.status_action_range("railmux-arbitrary", "unsafe")
         except ValueError:
@@ -1013,7 +1020,7 @@ def test_root_status_click_scopes_ranges_and_dispatches_actions():
     assert "-t" not in argv[5:8]
     assert "mouse_status_range" in argv[7]
     assert "%[0-9]+" in argv[7]
-    assert "railmux-(mode|layout|copy)" in argv[7]
+    assert "railmux-(mode|layout|copy|page-[r12])" in argv[7]
     assert tmux_ctl.RAILMUX_CONTROLLER_OPTION in argv[7]
     assert "railmux-status-pane-v1-owner123" in argv[7]
     assert "tmux select-pane -Z -t '#{mouse_status_range}'" in argv[8]
@@ -1023,6 +1030,11 @@ def test_root_status_click_scopes_ranges_and_dispatches_actions():
     assert "' F7 ;;" in argv[8]
     assert "railmux-copy) tmux send-keys" in argv[8]
     assert "' F6 ;;" in argv[8]
+    assert "railmux-page-r) tmux send-keys -l" in argv[8]
+    assert "railmux-page-1) tmux send-keys -l" in argv[8]
+    assert "railmux-page-2) tmux send-keys -l" in argv[8]
+    for _key, sequence in tmux_ctl.RAILMUX_COMPACT_PAGE_KEYS.values():
+        assert sequence in argv[8]
     assert argv[-1] == "select-window -t ="
 
 

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/tests/test_tmux_integration.py

@@ -3517,18 +3517,20 @@ def test_real_tmux_status_pane_range_selects_and_keeps_zoom(
         # status range beneath the pointer.
         os.write(master_fd, release)
 
-        # Exercise a real action range too. A raw-mode reader in the controller
-        # pane records the F5 generated by the Mode branch; this closes the
-        # second tmux parsing pass that argv-string assertions cannot cover.
+        # Exercise the compact page action used by the product UI. A raw-mode
+        # reader in the controller records its private sequence; the click
+        # must not select/unzoom a pane before the controller performs the
+        # complete park/zoom/resume transaction.
         ready_path = tmp_path / "status-action-ready"
         key_path = tmp_path / "status-action-key"
         reader = (
-            "import os,termios,pathlib;"
+            "import os,termios,pathlib,time;"
             "a=termios.tcgetattr(0);"
             "a[3]&=~(termios.ICANON|termios.ECHO);"
             "termios.tcsetattr(0,termios.TCSANOW,a);"
             f"pathlib.Path({str(ready_path)!r}).touch();"
-            f"pathlib.Path({str(key_path)!r}).write_bytes(os.read(0,32))"
+            f"pathlib.Path({str(key_path)!r}).write_bytes(os.read(0,32));"
+            "time.sleep(10)"
         )
         subprocess.run(
             [
@@ -3542,7 +3544,7 @@ def test_real_tmux_status_pane_range_selects_and_keeps_zoom(
             [
                 "tmux", "set-option", "-t", display_session, "status-left",
                 tmux_ctl.status_action_range(
-                    tmux_ctl.STATUS_ACTION_MODE, "[M]"),
+                    tmux_ctl.STATUS_ACTION_PAGE_PRIMARY, "[1]"),
             ],
             check=True,
         )
@@ -3553,7 +3555,7 @@ def test_real_tmux_status_pane_range_selects_and_keeps_zoom(
         action_painted = bytearray()
         action_deadline = time.monotonic() + 3.0
         while (time.monotonic() < action_deadline
-               and b"[M]" not in action_painted):
+               and b"[1]" not in action_painted):
             readable, _, _ = select.select([master_fd], [], [], 0.1)
             if not readable:
                 continue
@@ -3561,13 +3563,23 @@ def test_real_tmux_status_pane_range_selects_and_keeps_zoom(
                 action_painted.extend(os.read(master_fd, 65536))
             except BlockingIOError:
                 pass
-        assert b"[M]" in action_painted
+        assert b"[1]" in action_painted
         # Keep this a second ordinary click rather than tmux coalescing the two
         # synthetic presses into DoubleClick1Status (a different key binding).
         time.sleep(0.6)
         os.write(master_fd, click)
         assert _wait_until(key_path.exists)
-        assert key_path.read_bytes()
+        assert key_path.read_bytes() == (
+            tmux_ctl.RAILMUX_COMPACT_PAGE_KEYS[
+                tmux_ctl.STATUS_ACTION_PAGE_PRIMARY
+            ][1].encode()
+        )
+        assert tmux_ctl.active_pane_id(owner_pane) == other_pane
+        assert subprocess.check_output(
+            ["tmux", "display-message", "-p", "-t", other_pane,
+             "#{window_zoomed_flag}"],
+            text=True,
+        ).strip() == "1"
     finally:
         if client.poll() is None:
             client.kill()

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/tests/test_tmux_status.py

@@ -367,6 +367,31 @@ def test_compact_status_left_wraps_mode_and_layout_as_actions():
     assert visible == len("[R][1][2] CC · ◨ ")
 
 
+def test_compact_status_left_routes_available_pages_through_controller_actions():
+    pages = []
+
+    def wrap_page(action, content):
+        pages.append((action, content))
+        return f"<{action}>{content}</{action}>"
+
+    value, _visible = _compact_tmux_status_left(
+        False,
+        "Codex",
+        WorkspacePage.PRIMARY,
+        ("%1", "%2", None),
+        40,
+        page_range_wrapper=wrap_page,
+    )
+
+    assert pages == [
+        ("railmux-page-r", "#[fg=colour0][R]"),
+        ("railmux-page-1", "#[fg=colour231][1]"),
+    ]
+    assert "<railmux-page-r>" in value
+    assert "<railmux-page-1>" in value
+    assert "<railmux-page-2>" not in value
+
+
 def test_apply_bar_uses_dynamic_compact_left_length(monkeypatch):
     run = MagicMock()
     monkeypatch.setattr("subprocess.run", run)
@@ -413,9 +438,9 @@ def test_apply_compact_bar_makes_pages_mode_and_layout_clickable(monkeypatch):
     app._apply_tmux_bar(error=False)
 
     left = _style_calls(run, "status-left")[-1]
-    assert "#[range=user|%%1]" in left
-    assert "#[range=user|%%2]" in left
-    assert "#[range=user|%%3]" in left
+    assert "#[range=user|railmux-page-r]" in left
+    assert "#[range=user|railmux-page-1]" in left
+    assert "#[range=user|railmux-page-2]" in left
     assert "#[range=user|railmux-mode]CC#[norange]" in left
     assert "#[range=user|railmux-layout]◨#[norange]" in left
     visible = len("[R][1][2] CC · ◨ ")

{railmux-0.4.1.dev3 → railmux-0.4.1.dev5}/tests/test_windows_attach_relay.py

@@ -430,6 +430,114 @@ def test_local_windows_wheel_uses_shared_managed_history_without_tmux_copy_mode(
         child_socket.close()
 
 
+def test_local_windows_real_sgr_wheel_survives_busy_content_paint():
+    proxy_socket, child_socket = socket.socketpair()
+    client = windows_attach_relay.LocalPtyClient.__new__(
+        windows_attach_relay.LocalPtyClient
+    )
+    client.master_fd = proxy_socket.detach()
+    client._session_id = "$4"
+    client._selection = LocalTextSelection()
+    client._routes = ()
+    client._routes_checked_at = time.monotonic()
+    client._path_prompt = None
+    client._path_prompt_mouse_button = None
+    _set_local_history_state(client)
+    _install_local_history_snapshot(
+        client,
+        HistorySnapshot(
+            0,
+            "%8",
+            0,
+            0,
+            20,
+            2,
+            lines=tuple(f"row-{index}".encode() for index in range(8)),
+        ),
+    )
+    renderer = MagicMock()
+    renderer.presentation_stable = False
+    renderer.pointer_routing_stable = True
+    renderer.screen = SimpleNamespace(
+        width=20,
+        height=3,
+        cursor_x=1,
+        cursor_y=0,
+        rows=(b"live-0", b"live-1", b"status"),
+    )
+    renderer.surface.translate_mouse_event.side_effect = lambda event, **_kwargs: event
+    client._renderer = renderer
+    decoder = windows_attach_relay.TerminalInputDecoder()
+    child_socket.setblocking(False)
+    try:
+        parts = decoder.feed(b"\033[<64;2;1M")
+        assert len(parts) == 1
+        client._forward_input_part(parts[0])
+
+        assert client._history.active
+        renderer.set_history_overlays.assert_called_with(
+            client._history.overlays()
+        )
+        with pytest.raises(BlockingIOError):
+            child_socket.recv(64)
+    finally:
+        os.close(client.master_fd)
+        child_socket.close()
+
+
+def test_local_windows_wheel_stays_fail_closed_during_topology_transition():
+    proxy_socket, child_socket = socket.socketpair()
+    client = windows_attach_relay.LocalPtyClient.__new__(
+        windows_attach_relay.LocalPtyClient
+    )
+    client.master_fd = proxy_socket.detach()
+    client._session_id = "$4"
+    client._selection = LocalTextSelection()
+    client._routes = ()
+    client._routes_checked_at = time.monotonic()
+    client._path_prompt = None
+    client._path_prompt_mouse_button = None
+    _set_local_history_state(client)
+    _install_local_history_snapshot(
+        client,
+        HistorySnapshot(
+            0,
+            "%8",
+            0,
+            0,
+            20,
+            2,
+            lines=tuple(f"row-{index}".encode() for index in range(8)),
+        ),
+    )
+    renderer = MagicMock()
+    renderer.presentation_stable = False
+    renderer.pointer_routing_stable = False
+    renderer.screen = SimpleNamespace(
+        width=20,
+        height=3,
+        cursor_x=1,
+        cursor_y=0,
+        rows=(b"live-0", b"live-1", b"status"),
+    )
+    renderer.surface.translate_mouse_event.side_effect = lambda event, **_kwargs: event
+    client._renderer = renderer
+    decoder = windows_attach_relay.TerminalInputDecoder()
+    child_socket.setblocking(False)
+    try:
+        parts = decoder.feed(b"\033[<64;2;1M")
+        assert len(parts) == 1
+        client._forward_input_part(parts[0])
+
+        assert not client._history.active
+        renderer.set_history_overlays.assert_not_called()
+        with pytest.raises(BlockingIOError):
+            child_socket.recv(64)
+    finally:
+        os.close(client.master_fd)
+        child_socket.close()
+
+
 def test_local_windows_sidebar_wheel_stays_tmux_owned():
     proxy_socket, child_socket = socket.socketpair()
     client = windows_attach_relay.LocalPtyClient.__new__(
@@ -1199,18 +1307,24 @@ def test_semantic_renderer_hit_testing_waits_for_physical_frame(monkeypatch):
         assert renderer.screen is old_screen
         assert renderer.presentation_serial == old_serial
         assert renderer.presentation_stable is False
+        # Ordinary content backpressure does not invalidate the pane geometry
+        # of the frame that is still physically visible.
+        assert renderer.pointer_routing_stable is True
 
         # A topology mutation requested while this already-queued frame is
         # writing must wait for one still-newer authoritative frame.
         renderer.require_fresh_presentation()
+        assert renderer.pointer_routing_stable is False
         release.set()
         assert renderer.writer.wait_idle(1.0)
         assert renderer.presentation_stable is False
+        assert renderer.pointer_routing_stable is False
         assert renderer.presentation_serial == old_serial + 1
         renderer.feed(b"\033[H\033[2KNEW-TOPOLOGY-VISIBLE")
         renderer.paint_due(3.0, force=True)
         assert renderer.writer.wait_idle(1.0)
         assert renderer.presentation_stable is True
+        assert renderer.pointer_routing_stable is True
         assert b"NEW-TOPOLOGY-VISIBLE" in renderer.screen.rows[0]
     finally:
         release.set()

railmux-0.4.1.dev3/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.1.dev3"