底部面板输入器、弹窗与 mention 输入

fn handle_key_event(&mut self, _key_event: KeyEvent)

作用：当底部面板里的视图处于打开状态时，这个函数接收一次键盘按键。默认什么也不做，具体视图可以改写它来处理方向键、回车、删除等操作。

数据流：进去的是一个 KeyEvent，也就是终端捕捉到的一次按键 → 默认实现直接忽略它，不改任何状态 → 出来没有返回值；外层仍会安排重新绘制一次，以便具体实现改了状态时能显示出来。

调用关系：它是底部面板把键盘事件交给当前视图的入口。这个默认版本不把工作交给别人；真正的审批框、输入框或列表视图通常会覆盖它，写入自己的按键反应。

fn is_complete(&self) -> bool

作用：告诉外层：这个视图是不是已经办完事，可以从底部面板移除了。默认回答“没有完成”。

数据流：进去没有额外输入，只读取视图自己的状态 → 默认不检查任何东西，直接认为还没结束 → 出来是 false，表示继续显示。

调用关系：底部面板在处理按键、请求或绘制前后会用它判断是否该关掉当前视图。默认实现适合那些一直显示、直到自己明确改写完成逻辑的视图。

fn completion(&self) -> Option<ViewCompletion>

作用：在视图已经结束后，说明它是被接受了还是被取消了。默认没有结束原因。

数据流：进去没有参数 → 默认不读取状态，直接返回 None → 出来表示“我没有可报告的完成结果”。

调用关系：外层在视图完成后会用它区分用户点了确认还是取消。具体视图如果有确认/取消流程，就会覆盖这个函数返回 ViewCompletion::Accepted 或 ViewCompletion::Cancelled。

fn dismiss_after_child_accept(&self) -> bool

作用：说明如果这个视图打开了一个子视图，并且子视图被用户接受了，自己是否也应该一起关闭。默认不关闭。

数据流：进去没有参数 → 默认直接返回 false → 出来表示父视图会继续留在底部面板里。

调用关系：它服务于“父面板打开子面板”的流程。外层在子视图接受后会询问父视图要不要顺手退场；默认版本表示没有这种联动。

fn clear_dismiss_after_child_accept(&mut self)

作用：当子视图被取消时，清掉父视图里可能记录的“子视图接受后我也关闭”的临时标记。默认什么也不清。

数据流：进去没有参数 → 默认不改状态 → 出来没有返回值，视图保持原样。

调用关系：它和 BottomPaneView::dismiss_after_child_accept 是一组。外层在子流程取消时会调用它，避免留下过期的关闭标记；没有这类标记的视图用默认实现即可。

fn view_id(&self) -> Option<&'static str>

作用：给需要外部刷新支持的视图提供一个稳定名字。默认没有名字。

数据流：进去没有参数 → 默认直接返回 None → 出来表示外层不能用固定标识找到这个视图做刷新。

调用关系：当外部数据更新、需要刷新某个正在打开的底部视图时，外层可以靠这个标识认出它。普通视图不需要被这样定位，所以默认不提供。

fn selected_index(&self) -> Option<usize>

作用：给列表类视图报告当前选中的真实条目位置。这样刷新列表后，用户的选择可以尽量保持不跳走。

数据流：进去没有参数 → 默认返回 None → 出来表示这个视图没有可保存的列表选择位置。

调用关系：它通常配合 BottomPaneView::view_id 使用。外层刷新一个列表视图时，可以先问当前选中哪一项，再在新内容里恢复选择；非列表视图用默认值。

fn active_tab_id(&self) -> Option<&str>

作用：给带标签页的列表视图报告当前打开的是哪个标签页。默认没有标签页信息。

数据流：进去没有参数 → 默认返回 None → 出来表示这个视图没有活动标签页，或者不需要外层记住它。

调用关系：它是给更复杂的列表界面用的，比如一个底部面板里有多个分类页。外层刷新时可以据此恢复用户所在的标签；普通视图不会用到。

fn on_ctrl_c(&mut self) -> CancellationEvent

作用：处理用户按 Ctrl-C 时的反应。Ctrl-C 通常表示取消或中断，默认回答“我不处理”。

数据流：进去没有参数，只代表当前发生了 Ctrl-C → 默认不改视图状态 → 出来是 CancellationEvent::NotHandled，表示这次取消事件要交给更外层处理。

调用关系：底部面板在捕捉到 Ctrl-C 时会先问当前视图。某些弹窗可以自己取消并关闭；默认实现把决定权留给外层的通用取消流程。

fn prefer_esc_to_handle_key_event(&self) -> bool

作用：告诉外层：Esc 键应该像普通按键一样交给 handle_key_event，还是走取消流程。默认走取消流程，不特殊处理。

数据流：进去没有参数 → 默认返回 false → 出来表示 Esc 不优先交给视图自己的按键处理函数。

调用关系：它影响 Esc 键的分流。某些界面可能把 Esc 当作关闭菜单或退出编辑的小动作，所以会覆盖它；默认情况下 Esc 更像取消。

fn handle_paste(&mut self, _pasted: String) -> bool

作用：处理用户粘贴进来的一段文字。默认不接收粘贴内容，也不要求重画。

数据流：进去是一段 pasted 字符串 → 默认忽略这段文字，不改任何内部状态 → 出来是 false，表示视图没有变化，不必因为它额外刷新。

调用关系：底部面板收到粘贴事件时会把文字交给当前视图试试。带输入框的视图通常会覆盖它，把文字塞进编辑器；没有输入能力的视图用默认实现。

fn flush_paste_burst_if_due(&mut self) -> bool

作用：处理“连续粘贴”暂存状态到期后的收尾。这里的粘贴突发可以理解成系统把一大段粘贴拆成多次送来，视图先攒一下再统一处理。

数据流：进去没有参数 → 默认没有任何暂存粘贴状态可清理 → 出来是 false，表示状态没变。

调用关系：它让复用聊天输入框的弹窗也能参与同一套粘贴节奏控制。外层会定期问当前视图是否该把攒着的粘贴内容落地；默认视图不参与。

fn is_in_paste_burst(&self) -> bool

作用：告诉外层当前视图是不是还在等待一批粘贴内容结束。默认不是。

数据流：进去没有参数 → 默认返回 false → 出来表示外层不用为了粘贴突发安排短暂延迟刷新。

调用关系：它配合 BottomPaneView::flush_paste_burst_if_due 使用。外层看到 true 时，会稍后再刷新一次，给后续粘贴片段一点时间；默认实现表示没有这种需要。

fn pre_draw_tick(&mut self, _now: Instant) -> bool

作用：在真正绘制前，让视图按时间推进一下自己的状态。比如倒计时、动画、超时检查，都可以放在这里。默认没有时间相关变化。

数据流：进去是当前时间 Instant → 默认忽略这个时间，不改状态 → 出来是 false，表示不需要因为时间变化而重画或结束视图。

调用关系：底部面板在每次画当前视图之前会给它一次机会更新。需要计时行为的视图会覆盖它；默认实现不调用其他逻辑。

fn try_consume_approval_request(
        &mut self,
        request: ApprovalRequest,
    ) -> Option<ApprovalRequest>

作用：尝试让当前视图接收一个审批请求。默认不接收，并把原请求还回去。

数据流：进去是一个 ApprovalRequest，也就是需要用户批准或拒绝的请求 → 默认不处理它 → 出来是 Some(request)，意思是“我没吃掉它，你拿去给别的地方处理”。

调用关系：当应用收到新的审批请求时，底部面板可能先问当前视图能不能接住。专门的审批视图会覆盖它并消费请求；默认实现让请求继续流向其他处理路径。

fn try_consume_user_input_request(
        &mut self,
        request: ToolRequestUserInputParams,
    ) -> Option<ToolRequestUserInputParams>

作用：尝试让当前视图接收一次“工具请求用户输入”的任务。默认不接收，并把原任务交回去。

数据流：进去是 ToolRequestUserInputParams，包含工具想向用户询问的信息 → 默认不读取也不改它 → 出来是 Some(request)，表示当前视图没有处理。

调用关系：应用服务器或工具需要向用户提问时，底部面板会尝试把请求交给当前视图。能显示输入表单的视图会覆盖它；默认版本保持请求未消费。

fn try_consume_mcp_server_elicitation_request(
        &mut self,
        request: McpServerElicitationFormRequest,
    ) -> Option<McpServerElicitationFormRequest>

作用：尝试处理来自 MCP 服务器的表单请求。MCP 可以简单理解成外部工具服务器和应用沟通的一套协议；这里的请求是服务器想让用户填点东西。

数据流：进去是 McpServerElicitationFormRequest → 默认不处理、不改变 → 出来是 Some(request)，表示请求还在，需要别人继续处理。

调用关系：当外部 MCP 服务器要求用户填写受支持的表单时，底部面板会问当前视图能不能承接。表单视图会覆盖这个函数；普通视图把请求原样退回。

fn dismiss_app_server_request(&mut self, _request: &ResolvedAppServerRequest) -> bool

作用：当某个请求已经被另一个客户端解决时，让当前视图把相关内容关掉或更新掉。默认不变。

数据流：进去是一个 ResolvedAppServerRequest，表示外部已经完成的请求 → 默认忽略它，不改视图状态 → 出来是 false，表示当前视图没有变化。

调用关系：如果同一个会话可能被多个客户端操作，一个客户端处理完请求后，另一个客户端的底部面板需要同步消失或刷新。具体请求视图会覆盖它；默认视图不受影响。

fn terminal_title_requires_action(&self) -> bool

作用：告诉外层：这个视图是否代表程序正在等用户做决定。默认不是。

数据流：进去没有参数 → 默认返回 false → 出来表示终端标题不需要显示“需要操作”这类提醒。

调用关系：外层会根据它调整终端标签页标题。审批、输入表单这类会阻塞流程的视图会返回 true，让用户即使切到别的标签页也能看到 Codex 在等他。

fn next_frame_delay(&self) -> Option<std::time::Duration>

作用：告诉外层下一次基于时间的重画应该等多久。默认不需要定时重画。

数据流：进去没有参数 → 默认返回 None → 出来表示外层不用为了这个视图安排下一帧。

调用关系：它用于动画、光标闪烁、倒计时等需要定时刷新但不一定有用户输入的视图。底部面板会按这个延迟安排下一次绘制；默认视图只在事件触发时刷新。

fn new(params: BottomPaneParams) -> Self

调用图：调用 5 个内部函数（new, new, new, new, defaults）；被 24 处调用（composer_shown_after_denied_while_task_running, ctrl_c_cancels_history_search_without_clearing_draft_or_showing_quit_hint, ctrl_c_on_modal_consumes_without_showing_quit_hint, drain_pending_submission_state_clears_remote_image_urls, esc_interrupts_running_task_when_no_popup, esc_release_after_dismissing_agent_picker_does_not_interrupt_task, esc_routes_to_handle_key_event_when_requested, esc_with_agent_command_without_popup_does_not_interrupt_task, esc_with_skill_popup_does_not_interrupt_task, esc_with_slash_command_popup_does_not_interrupt_task (+14 more)）；外部调用 2 个（new, new）。

fn set_skills(&mut self, skills: Option<Vec<SkillMetadata>>)

调用图：调用 2 个内部函数（request_redraw, set_skill_mentions）。

fn set_image_paste_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_image_paste_enabled）。

fn set_connectors_snapshot(&mut self, snapshot: Option<ConnectorsSnapshot>)

调用图：调用 2 个内部函数（request_redraw, set_connector_mentions）。

fn set_plugin_mentions(&mut self, plugins: Option<Vec<PluginCapabilitySummary>>)

调用图：调用 2 个内部函数（request_redraw, set_plugin_mentions）；被 2 处调用（on_plugin_mentions_loaded, refresh_plugin_mentions）。

fn set_plugins_command_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_plugins_command_enabled）。

fn set_token_activity_command_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_token_activity_command_enabled）。

fn set_mentions_v2_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_mentions_v2_enabled）。

fn take_mention_bindings(&mut self) -> Vec<MentionBinding>

调用图：调用 1 个内部函数（take_mention_bindings）；被 1 处调用（drain_pending_submission_state）。

fn take_recent_submission_mention_bindings(&mut self) -> Vec<MentionBinding>

调用图：调用 1 个内部函数（take_recent_submission_mention_bindings）；被 1 处调用（drain_pending_submission_state）。

fn record_pending_slash_command_history(&mut self)

调用图：调用 1 个内部函数（record_pending_slash_command_history）。

fn set_keymap_bindings(&mut self, keymap: &RuntimeKeymap)

调用图：调用 4 个内部函数（request_redraw, set_keymap_bindings, set_interrupt_binding, primary_binding）；外部调用 1 个（clone）。

fn drain_pending_submission_state(&mut self)

调用图：调用 4 个内部函数（take_mention_bindings, take_recent_submission_images_with_placeholders, take_recent_submission_mention_bindings, take_remote_image_urls）。

fn set_collaboration_modes_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_collaboration_modes_enabled）。

fn set_connectors_enabled(&mut self, enabled: bool)

调用图：调用 1 个内部函数（set_connectors_enabled）。

fn set_windows_degraded_sandbox_active(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_windows_degraded_sandbox_active）。

fn set_collaboration_mode_indicator(
        &mut self,
        indicator: Option<CollaborationModeIndicator>,
    )

调用图：调用 2 个内部函数（request_redraw, set_collaboration_mode_indicator）。

fn set_goal_status_indicator(&mut self, indicator: Option<GoalStatusIndicator>)

调用图：调用 2 个内部函数（request_redraw, set_goal_status_indicator）。

fn set_ide_context_active(&mut self, active: bool)

调用图：调用 2 个内部函数（request_redraw, set_ide_context_active）。

fn set_personality_command_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_personality_command_enabled）。

fn set_service_tier_commands_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_service_tier_commands_enabled）。

fn set_service_tier_commands(&mut self, commands: Vec<ServiceTierCommand>)

调用图：调用 2 个内部函数（request_redraw, set_service_tier_commands）。

fn set_goal_command_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_goal_command_enabled）。

fn set_side_conversation_active(&mut self, active: bool)

调用图：调用 2 个内部函数（request_redraw, set_side_conversation_active）。

fn set_placeholder_text(&mut self, placeholder: String)

调用图：调用 2 个内部函数（request_redraw, set_placeholder_text）。

fn set_queued_message_edit_binding(&mut self, binding: Option<KeyBinding>)

调用图：调用 2 个内部函数（request_redraw, set_edit_binding）。

fn set_vim_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_vim_enabled）。

fn toggle_vim_enabled(&mut self) -> bool

调用图：调用 2 个内部函数（request_redraw, toggle_vim_enabled）；被 1 处调用（toggle_vim_mode_and_notify）。

fn status_widget(&self) -> Option<&StatusIndicatorWidget>

fn skills(&self) -> Option<&Vec<SkillMetadata>>

调用图：调用 1 个内部函数（skills）。

fn plugins(&self) -> Option<&Vec<PluginCapabilitySummary>>

调用图：调用 1 个内部函数（plugins）；被 2 处调用（on_plugin_mentions_loaded, plugins_for_mentions）。

fn context_window_percent(&self) -> Option<i64>

fn context_window_used_tokens(&self) -> Option<i64>

fn active_view(&self) -> Option<&dyn BottomPaneView>

调用图：被 3 处调用（as_renderable_with_composer_right_reserve, schedule_active_view_frame, terminal_title_requires_action）。

fn push_view(&mut self, view: Box<dyn BottomPaneView>)

调用图：调用 2 个内部函数（request_redraw, schedule_active_view_frame）；被 8 处调用（maybe_show_delayed_approval_requests_at, push_approval_request, push_mcp_server_elicitation_request, push_user_input_request, replace_active_views_with_selection_view, replace_selection_view_if_active, show_selection_view, show_view）。

fn pop_active_view_with_completion(&mut self, completion: Option<ViewCompletion>)

调用图：调用 1 个内部函数（on_view_stack_depth_decreased）；被 2 处调用（handle_key_event, on_ctrl_c）。

fn on_view_stack_depth_decreased(&mut self)

调用图：调用 1 个内部函数（on_active_view_complete）；被 2 处调用（dismiss_app_server_request, pop_active_view_with_completion）。

fn approval_prompt_delay_remaining(&self, now: Instant) -> Option<Duration>

调用图：被 3 处调用（maybe_show_delayed_approval_requests_at, push_approval_request, record_composer_activity_at）。

fn record_composer_activity_at(&mut self, now: Instant)

调用图：调用 2 个内部函数（approval_prompt_delay_remaining, request_redraw_in）；被 2 处调用（handle_key_event, handle_paste）；外部调用 1 个（is_empty）。

fn maybe_show_delayed_approval_requests_at(&mut self, now: Instant)

调用图：调用 5 个内部函数（approval_prompt_delay_remaining, pause_status_timer_for_modal, push_view, request_redraw_in, new）；被 2 处调用（pre_draw_tick_at, push_approval_request）；外部调用 5 个（new, is_empty, pop_back, pop_front, clone）。

fn handle_key_event(&mut self, key_event: KeyEvent) -> InputResult

调用图：调用 11 个内部函数（composer_should_handle_vim_insert_escape, composer_text, pop_active_view_with_completion, record_composer_activity_at, request_redraw, request_redraw_in, handle_key_event, is_in_paste_burst, popup_active, recommended_paste_flush_delay (+1 more)）；外部调用 2 个（now, matches!）。

fn on_ctrl_c(&mut self) -> CancellationEvent

调用图：调用 6 个内部函数（clear_composer_for_ctrl_c, composer_is_empty, pop_active_view_with_completion, request_redraw, show_quit_shortcut_hint, ctrl）；外部调用 3 个（Char, matches!, cancel_history_search）。

fn handle_paste(&mut self, pasted: String)

调用图：调用 4 个内部函数（on_active_view_complete, record_composer_activity_at, request_redraw, handle_paste）；外部调用 1 个（now）。

fn insert_str(&mut self, text: &str)

调用图：调用 2 个内部函数（request_redraw, insert_str）；被 1 处调用（insert_str）。

fn pre_draw_tick(&mut self)

调用图：调用 1 个内部函数（pre_draw_tick_at）；被 1 处调用（pre_draw_tick）；外部调用 1 个（now）。

fn pre_draw_tick_at(&mut self, now: Instant)

调用图：调用 4 个内部函数（maybe_show_delayed_approval_requests_at, schedule_active_view_frame, tick_active_view, sync_popups）；被 1 处调用（pre_draw_tick）。

fn tick_active_view(&mut self, now: Instant)

调用图：调用 2 个内部函数（on_active_view_complete, request_redraw）；被 1 处调用（pre_draw_tick_at）。

fn schedule_active_view_frame(&self)

调用图：调用 2 个内部函数（active_view, request_redraw_in）；被 4 处调用（dismiss_view_by_id, pre_draw_tick_at, push_view, replace_selection_view_if_present）。

fn set_composer_text(
        &mut self,
        text: String,
        text_elements: Vec<TextElement>,
        local_image_paths: Vec<PathBuf>,
    )

调用图：调用 3 个内部函数（request_redraw, move_cursor_to_end, set_text_content）；被 1 处调用（set_composer_text）。

fn set_composer_text_with_mention_bindings(
        &mut self,
        text: String,
        text_elements: Vec<TextElement>,
        local_image_paths: Vec<PathBuf>,
        mention_bindings: Vec<Men

调用图：调用 3 个内部函数（request_redraw, move_cursor_to_end, set_text_content_with_mention_bindings）。

fn set_composer_input_enabled(
        &mut self,
        enabled: bool,
        placeholder: Option<String>,
    )

调用图：调用 2 个内部函数（request_redraw, set_input_enabled）；被 3 处调用（on_active_view_complete, push_mcp_server_elicitation_request, push_user_input_request）。

fn show_shutdown_in_progress(&mut self)

调用图：调用 2 个内部函数（request_redraw, show_shutdown_in_progress）；被 1 处调用（show_shutdown_in_progress）。

fn clear_composer_for_ctrl_c(&mut self)

调用图：调用 3 个内部函数（send, request_redraw, clear_for_ctrl_c）；被 1 处调用（on_ctrl_c）；外部调用 1 个（warn!）。

fn composer_text(&self) -> String

调用图：调用 1 个内部函数（current_text）；被 1 处调用（handle_key_event）。

fn composer_cursor(&self) -> usize

调用图：调用 1 个内部函数（cursor）。

fn composer_draft_snapshot(&self) -> chat_composer::ComposerDraftSnapshot

调用图：调用 1 个内部函数（draft_snapshot）。

fn composer_text_elements(&self) -> Vec<TextElement>

调用图：调用 1 个内部函数（text_elements）。

fn composer_local_images(&self) -> Vec<LocalImageAttachment>

调用图：调用 1 个内部函数（local_images）。

fn composer_local_image_paths(&self) -> Vec<PathBuf>

调用图：调用 1 个内部函数（local_image_paths）。

fn composer_text_with_pending(&self) -> String

调用图：调用 1 个内部函数（current_text_with_pending）。

fn composer_input_enabled(&self) -> bool

调用图：调用 1 个内部函数（input_enabled）。

fn composer_pending_pastes(&self) -> Vec<(String, String)>

调用图：调用 1 个内部函数（pending_pastes）。

fn apply_external_edit(&mut self, text: String)

调用图：调用 2 个内部函数（request_redraw, apply_external_edit）。

fn set_footer_hint_override(&mut self, items: Option<Vec<(String, String)>>)

调用图：调用 2 个内部函数（request_redraw, set_footer_hint_override）。

fn set_plan_mode_nudge_visible(&mut self, visible: bool)

调用图：调用 2 个内部函数（request_redraw, set_plan_mode_nudge_visible）。

fn plan_mode_nudge_visible(&self) -> bool

调用图：调用 1 个内部函数（plan_mode_nudge_visible）。

fn set_remote_image_urls(&mut self, urls: Vec<String>)

调用图：调用 2 个内部函数（request_redraw, set_remote_image_urls）；被 1 处调用（set_remote_image_urls）。

fn remote_image_urls(&self) -> Vec<String>

调用图：调用 1 个内部函数（remote_image_urls）；被 1 处调用（remote_image_urls）。

fn take_remote_image_urls(&mut self) -> Vec<String>

调用图：调用 2 个内部函数（request_redraw, take_remote_image_urls）；被 2 处调用（drain_pending_submission_state, take_remote_image_urls）。

fn set_composer_pending_pastes(&mut self, pending_pastes: Vec<(String, String)>)

调用图：调用 2 个内部函数（request_redraw, set_pending_pastes）。

fn update_status(
        &mut self,
        header: String,
        details: Option<String>,
        details_capitalization: StatusDetailsCapitalization,
        details_max_lines: usize,
    )

调用图：调用 1 个内部函数（request_redraw）。

fn show_quit_shortcut_hint(&mut self, key: KeyBinding)

调用图：调用 2 个内部函数（request_redraw, show_quit_shortcut_hint）；被 1 处调用（on_ctrl_c）；外部调用 4 个（spawn, try_current, sleep, clone）。

fn clear_quit_shortcut_hint(&mut self)

调用图：调用 2 个内部函数（request_redraw, clear_quit_shortcut_hint）。

fn quit_shortcut_hint_visible(&self) -> bool

调用图：调用 1 个内部函数（quit_shortcut_hint_visible）。

fn status_indicator_visible(&self) -> bool

fn status_line_text(&self) -> Option<String>

调用图：调用 1 个内部函数（status_line_text）；被 1 处调用（status_line_text）。

fn show_esc_backtrack_hint(&mut self)

调用图：调用 2 个内部函数（request_redraw, set_esc_backtrack_hint）；被 1 处调用（show_esc_backtrack_hint）。

fn clear_esc_backtrack_hint(&mut self)

调用图：调用 2 个内部函数（request_redraw, set_esc_backtrack_hint）；被 1 处调用（clear_esc_backtrack_hint）。

fn set_task_running(&mut self, running: bool)

调用图：调用 6 个内部函数（hide_status_indicator, request_redraw, sync_status_inline_message, set_task_running, primary_binding, new）；被 2 处调用（enter_review_mode_with_hint, submit_op）；外部调用 2 个（clone, clone）。

fn set_queue_submissions(&mut self, queue_submissions: bool)

调用图：调用 1 个内部函数（set_queue_submissions）。

fn hide_status_indicator(&mut self)

调用图：调用 1 个内部函数（request_redraw）；被 1 处调用（set_task_running）。

fn ensure_status_indicator(&mut self)

调用图：调用 4 个内部函数（request_redraw, sync_status_inline_message, primary_binding, new）；外部调用 2 个（clone, clone）。

fn set_interrupt_hint_visible(&mut self, visible: bool)

调用图：调用 1 个内部函数（request_redraw）。

fn set_context_window(&mut self, percent: Option<i64>, used_tokens: Option<i64>)

调用图：调用 2 个内部函数（request_redraw, set_context_window）；被 3 处调用（apply_token_info, restore_pre_review_token_info, set_token_info）。

fn show_selection_view(
        &mut self,
        mut params: list_selection_view::SelectionViewParams,
    )

调用图：调用 3 个内部函数（apply_standard_popup_hint, push_view, new）；被 3 处调用（open_feedback_consent, open_memories_enable_prompt, open_multi_agent_enable_prompt）；外部调用 2 个（new, clone）。

fn apply_standard_popup_hint(&self, params: &mut list_selection_view::SelectionViewParams)

调用图：调用 2 个内部函数（standard_popup_hint_line, standard_popup_hint_line）；被 4 处调用（replace_active_views_with_selection_view, replace_selection_view_if_active, replace_selection_view_if_present, show_selection_view）。

fn replace_selection_view_if_active(
        &mut self,
        view_id: &'static str,
        mut params: list_selection_view::SelectionViewParams,
    ) -> bool

调用图：调用 3 个内部函数（apply_standard_popup_hint, push_view, new）；外部调用 2 个（new, clone）。

fn replace_selection_view_if_present(
        &mut self,
        view_id: &'static str,
        mut params: list_selection_view::SelectionViewParams,
    ) -> bool

调用图：调用 4 个内部函数（apply_standard_popup_hint, request_redraw, schedule_active_view_frame, new）；外部调用 2 个（new, clone）。

fn standard_popup_hint_line(&self) -> Line<'static>

调用图：调用 1 个内部函数（standard_popup_hint_line_for_keymap）；被 1 处调用（apply_standard_popup_hint）。

fn list_keymap(&self) -> crate::keymap::ListKeymap

调用图：被 2 处调用（open_app_link_view, open_memories_popup）。

fn replace_active_views_with_selection_view(
        &mut self,
        view_ids: &[&'static str],
        mut params: list_selection_view::SelectionViewParams,
    ) -> bool

调用图：调用 3 个内部函数（apply_standard_popup_hint, push_view, new）；外部调用 2 个（new, clone）。

fn selected_index_for_active_view(&self, view_id: &'static str) -> Option<usize>

fn active_tab_id_for_active_view(&self, view_id: &'static str) -> Option<&str>

fn dismiss_active_view_if_id(&mut self, view_id: &'static str) -> bool

调用图：调用 1 个内部函数（request_redraw）。

fn dismiss_view_by_id(&mut self, view_id: &'static str) -> bool

调用图：调用 2 个内部函数（request_redraw, schedule_active_view_frame）。

fn set_pending_input_preview(
        &mut self,
        queued: Vec<String>,
        pending_steers: Vec<String>,
        rejected_steers: Vec<String>,
    )

调用图：调用 1 个内部函数（request_redraw）。

fn set_pending_thread_approvals(&mut self, threads: Vec<String>)

调用图：调用 2 个内部函数（request_redraw, set_threads）；被 1 处调用（set_pending_thread_approvals）。

fn pending_thread_approvals(&self) -> &[String]

调用图：调用 1 个内部函数（threads）；被 1 处调用（pending_thread_approvals）。

fn set_unified_exec_processes(&mut self, processes: Vec<String>)

调用图：调用 3 个内部函数（request_redraw, sync_status_inline_message, set_processes）。

fn sync_status_inline_message(&mut self)

调用图：调用 1 个内部函数（summary_text）；被 3 处调用（ensure_status_indicator, set_task_running, set_unified_exec_processes）。

fn composer_is_empty(&self) -> bool

调用图：调用 1 个内部函数（is_empty）；被 2 处调用（on_ctrl_c, composer_is_empty）。

fn composer_is_vim_enabled(&self) -> bool

调用图：调用 1 个内部函数（is_vim_enabled）。

fn composer_should_handle_vim_insert_escape(&self, key_event: KeyEvent) -> bool

调用图：调用 1 个内部函数（should_handle_vim_insert_escape）；被 2 处调用（handle_key_event, should_handle_vim_insert_escape）。

fn is_task_running(&self) -> bool

调用图：被 3 处调用（enter_review_mode_with_hint, is_task_running_for_test, submit_op）。

fn terminal_title_requires_action(&self) -> bool

调用图：调用 1 个内部函数（active_view）。

fn has_active_view(&self) -> bool

调用图：被 1 处调用（has_active_view）。

fn active_view_id(&self) -> Option<&'static str>

fn is_normal_backtrack_mode(&self) -> bool

调用图：调用 1 个内部函数（popup_active）；被 1 处调用（is_normal_backtrack_mode）。

fn can_launch_external_editor(&self) -> bool

调用图：调用 1 个内部函数（popup_active）；被 1 处调用（no_modal_or_popup_active）。

fn no_modal_or_popup_active(&self) -> bool

调用图：调用 1 个内部函数（can_launch_external_editor）。

fn show_view(&mut self, view: Box<dyn BottomPaneView>)

调用图：调用 1 个内部函数（push_view）；被 3 处调用（open_app_link_view, open_memories_popup, show_feedback_note）。

fn push_approval_request(&mut self, request: ApprovalRequest, features: &Features)

调用图：调用 6 个内部函数（approval_prompt_delay_remaining, maybe_show_delayed_approval_requests_at, pause_status_timer_for_modal, push_view, request_redraw, new）；外部调用 6 个（new, now, is_empty, push_back, clone, clone）。

fn push_user_input_request(&mut self, request: ToolRequestUserInputParams)

调用图：调用 5 个内部函数（pause_status_timer_for_modal, push_view, request_redraw, set_composer_input_enabled, new_with_keymap）；外部调用 3 个（new, clone, clone）。

fn push_mcp_server_elicitation_request(
        &mut self,
        request: McpServerElicitationFormRequest,
    )

调用图：调用 10 个内部函数（pause_status_timer_for_modal, push_view, request_redraw, set_composer_input_enabled, new_with_keymap, request_id, server_name, thread_id, tool_suggestion, new_with_keymap）；外部调用 4 个（new, matches!, clone, unreachable!）。

fn dismiss_app_server_request(
        &mut self,
        request: &ResolvedAppServerRequest,
    ) -> bool

调用图：调用 2 个内部函数（on_view_stack_depth_decreased, request_redraw）；被 1 处调用（dismiss_app_server_request）；外部调用 3 个（new, len, retain）。

fn on_active_view_complete(&mut self)

调用图：调用 2 个内部函数（resume_status_timer_after_modal, set_composer_input_enabled）；被 3 处调用（handle_paste, on_view_stack_depth_decreased, tick_active_view）。

fn pause_status_timer_for_modal(&mut self)

调用图：被 4 处调用（maybe_show_delayed_approval_requests_at, push_approval_request, push_mcp_server_elicitation_request, push_user_input_request）。

fn resume_status_timer_after_modal(&mut self)

调用图：被 1 处调用（on_active_view_complete）。

fn request_redraw(&self)

调用图：调用 1 个内部函数（schedule_frame）；被 67 处调用（apply_external_edit, attach_image, clear_composer_for_ctrl_c, clear_esc_backtrack_hint, clear_quit_shortcut_hint, dismiss_active_view_if_id, dismiss_app_server_request, dismiss_view_by_id, ensure_status_indicator, handle_key_event (+15 more)）。

fn request_redraw_in(&self, dur: Duration)

调用图：调用 1 个内部函数（schedule_frame_in）；被 4 处调用（handle_key_event, maybe_show_delayed_approval_requests_at, record_composer_activity_at, schedule_active_view_frame）。

fn set_history_metadata(
        &mut self,
        thread_id: ThreadId,
        log_id: u64,
        entry_count: usize,
    )

调用图：调用 1 个内部函数（set_history_metadata）。

fn flush_paste_burst_if_due(&mut self) -> bool

调用图：调用 1 个内部函数（flush_paste_burst_if_due）。

fn is_in_paste_burst(&self) -> bool

调用图：调用 1 个内部函数（is_in_paste_burst）。

fn on_history_entry_response(
        &mut self,
        log_id: u64,
        offset: usize,
        entry: Option<String>,
    )

调用图：调用 3 个内部函数（request_redraw, on_history_entry_response, sync_popups）；被 1 处调用（handle_history_entry_response）。

fn record_replayed_user_message_history(&mut self, entry: HistoryEntry)

调用图：调用 1 个内部函数（record_replayed_user_message_history）；被 1 处调用（on_committed_user_message）。

fn on_file_search_result(&mut self, query: String, matches: Vec<FileMatch>)

调用图：调用 2 个内部函数（request_redraw, on_file_search_result）；被 1 处调用（apply_file_search_result）。

fn attach_image(&mut self, path: PathBuf)

调用图：调用 2 个内部函数（request_redraw, attach_image）。

fn take_recent_submission_images(&mut self) -> Vec<PathBuf>

调用图：调用 1 个内部函数（take_recent_submission_images）。

fn take_recent_submission_images_with_placeholders(
        &mut self,
    ) -> Vec<LocalImageAttachment>

调用图：调用 1 个内部函数（take_recent_submission_images_with_placeholders）；被 1 处调用（drain_pending_submission_state）。

fn prepare_inline_args_submission(
        &mut self,
        record_history: bool,
    ) -> Option<(String, Vec<TextElement>)>

调用图：调用 1 个内部函数（prepare_inline_args_submission）。

fn as_renderable(&'_ self) -> RenderableItem<'_>

调用图：调用 1 个内部函数（as_renderable_with_composer_right_reserve）；被 4 处调用（cursor_pos, cursor_style, desired_height, render）。

fn as_renderable_with_composer_right_reserve(
        &'_ self,
        composer_right_reserve: u16,
    ) -> RenderableItem<'_>

调用图：调用 4 个内部函数（active_view, is_empty, is_empty, new）；被 5 处调用（as_renderable, cursor_pos_with_composer_right_reserve, cursor_style_with_composer_right_reserve, desired_height_with_composer_right_reserve, render_with_composer_right_reserve）；外部调用 3 个（new, Borrowed, Owned）。

fn render_with_composer_right_reserve(
        &self,
        area: Rect,
        buf: &mut Buffer,
        composer_right_reserve: u16,
    )

调用图：调用 1 个内部函数（as_renderable_with_composer_right_reserve）；被 1 处调用（render）。

fn desired_height_with_composer_right_reserve(
        &self,
        width: u16,
        composer_right_reserve: u16,
    ) -> u16

调用图：调用 1 个内部函数（as_renderable_with_composer_right_reserve）；被 1 处调用（desired_height）。

fn cursor_pos_with_composer_right_reserve(
        &self,
        area: Rect,
        composer_right_reserve: u16,
    ) -> Option<(u16, u16)>

调用图：调用 1 个内部函数（as_renderable_with_composer_right_reserve）；被 1 处调用（cursor_pos）。

fn cursor_style_with_composer_right_reserve(
        &self,
        area: Rect,
        composer_right_reserve: u16,
    ) -> crossterm::cursor::SetCursorStyle

调用图：调用 1 个内部函数（as_renderable_with_composer_right_reserve）；被 1 处调用（cursor_style）。

fn set_status_line(&mut self, status_line: Option<Line<'static>>)

调用图：调用 2 个内部函数（request_redraw, set_status_line）。

fn set_status_line_hyperlink(&mut self, url: Option<String>)

调用图：调用 2 个内部函数（request_redraw, set_status_line_hyperlink）。

fn set_status_line_enabled(&mut self, enabled: bool)

调用图：调用 2 个内部函数（request_redraw, set_status_line_enabled）。

fn set_active_agent_label(&mut self, active_agent_label: Option<String>)

调用图：调用 2 个内部函数（request_redraw, set_active_agent_label）。

fn set_side_conversation_context_label(&mut self, label: Option<String>)

调用图：调用 2 个内部函数（request_redraw, set_side_conversation_context_label）。

fn render(&self, area: Rect, buf: &mut Buffer)

调用图：调用 1 个内部函数（render_with_mask_and_textarea_right_reserve）。

fn desired_height(&self, width: u16) -> u16

调用图：调用 1 个内部函数（desired_height_with_textarea_right_reserve）。

fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)>

调用图：调用 1 个内部函数（cursor_pos_with_textarea_right_reserve）。

fn cursor_style(&self, area: Rect) -> crossterm::cursor::SetCursorStyle

调用图：调用 1 个内部函数（cursor_style）。

fn render(&self, area: Rect, buf: &mut Buffer)

调用图：调用 1 个内部函数（as_renderable）；被 1 处调用（render_snapshot）。

fn desired_height(&self, width: u16) -> u16

调用图：调用 1 个内部函数（as_renderable）。

fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)>

调用图：调用 1 个内部函数（as_renderable）。

fn cursor_style(&self, area: Rect) -> crossterm::cursor::SetCursorStyle

调用图：调用 1 个内部函数（as_renderable）。

fn snapshot_buffer(buf: &Buffer) -> String

调用图：外部调用 3 个（area, new, new）。

fn render_snapshot(pane: &BottomPane, area: Rect) -> String

调用图：调用 1 个内部函数（render）；外部调用 2 个（empty, snapshot_buffer）。

fn test_pane(app_event_tx: AppEventSender) -> BottomPane

调用图：外部调用 1 个（test_pane_with_disable_paste_burst）。

fn test_pane_with_disable_paste_burst(
        app_event_tx: AppEventSender,
        disable_paste_burst: bool,
    ) -> BottomPane

调用图：调用 2 个内部函数（new, test_dummy）；外部调用 1 个（new）。

fn exec_request() -> ApprovalRequest

调用图：调用 1 个内部函数（new）；外部调用 1 个（vec!）。

fn render(&self, _area: Rect, _buf: &mut Buffer)

fn desired_height(&self, _width: u16) -> u16

fn is_complete(&self) -> bool

fn view_id(&self) -> Option<&'static str>

fn dismiss_app_server_request(&mut self, request: &ResolvedAppServerRequest) -> bool

fn render(&self, _area: Rect, _buf: &mut Buffer)

fn desired_height(&self, _width: u16) -> u16

fn handle_key_event(&mut self, key_event: KeyEvent)

fn is_complete(&self) -> bool

fn view_id(&self) -> Option<&'static str>

fn ctrl_c_on_modal_consumes_without_showing_quit_hint()

调用图：调用 4 个内部函数（with_defaults, new, new, test_dummy）；外部调用 4 个（new, assert!, assert_eq!, exec_request）。

fn ctrl_c_cancels_history_search_without_clearing_draft_or_showing_quit_hint()

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 5 个（Char, new, new, assert!, assert_eq!）。

fn overlay_not_shown_above_approval_modal()

调用图：调用 4 个内部函数（with_defaults, new, new, test_dummy）；外部调用 6 个（empty, new, new, new, assert!, exec_request）。

fn approval_request_shows_immediately_without_recent_typing()

调用图：调用 2 个内部函数（with_defaults, new）；外部调用 4 个（assert!, assert_eq!, exec_request, test_pane）。

fn approval_request_is_delayed_after_recent_typing()

调用图：调用 2 个内部函数（with_defaults, new）；外部调用 6 个（from_millis, now, assert!, assert_eq!, exec_request, test_pane）。

fn continued_typing_resets_delayed_approval_idle_deadline()

调用图：调用 2 个内部函数（with_defaults, new）；外部调用 6 个（from_millis, now, assert!, assert_eq!, exec_request, test_pane）。

fn typed_approval_shortcuts_during_delay_stay_in_composer()

调用图：调用 2 个内部函数（with_defaults, new）；外部调用 7 个（now, Char, new, assert!, assert_eq!, exec_request, test_pane_with_disable_paste_burst）。

fn delayed_approval_shortcut_works_after_idle_deadline()

作用：测试审批提示因为用户刚打完字而延迟显示时，等到空闲时间到了以后，按 y 仍然能批准命令。这样可以避免用户一边打字一边误触审批，但真正该审批时快捷键也不能失效。

数据流：测试先创建一个底部面板和事件接收器，记录“刚刚有输入活动”的时间，再塞入一个命令执行审批请求。它把时间推进到允许显示审批提示的空闲期限，然后模拟用户按下 y。最后从事件队列里找审批结果，确认结果从“待处理”变成了“接受”。

调用关系：这个测试由测试框架运行。它用 test_pane 建一个面板，用 exec_request 准备假审批请求，再通过 pre_draw_tick_at 和 handle_key_event 模拟真实界面的一次刷新和一次按键，最后检查面板是否向外发出了正确的 AppEvent。

调用图：调用 2 个内部函数（with_defaults, new）；外部调用 6 个（now, Char, new, assert_eq!, exec_request, test_pane）。

fn dismiss_app_server_request_prunes_delayed_approval()

作用：测试一个还没真正显示出来的延迟审批请求，如果被服务端取消了，底部面板会把它从等待队列里删掉。否则用户稍后可能会看到一个已经无效的审批弹窗。

数据流：测试先创建面板，标记用户刚刚输入过文字，然后加入一个会延迟显示的审批请求。接着模拟服务端通知这个请求已经被取消。结果应该是：取消操作返回成功，延迟审批列表被清空；即使之后时间到了，也不会再出现任何弹窗。

调用关系：测试框架调用它。它围绕 dismiss_app_server_request 这个入口做验证，先通过 push_approval_request 放入请求，再用 pre_draw_tick_at 检查取消后不会被后续刷新重新推到界面上。

调用图：调用 2 个内部函数（with_defaults, new）；外部调用 4 个（now, assert!, exec_request, test_pane）。

fn dismiss_app_server_request_removes_matching_buried_view()

作用：测试要取消的审批弹窗不在最上层、而是被别的窗口盖住时，也能被准确移除。这样可以防止底层残留一个已经过期的窗口。

数据流：测试先往面板里压入两个视图：底下那个绑定 request-1，上面那个只是普通顶层视图。然后发出取消 request-1 的请求。结果是底下匹配的视图被删掉，顶层视图还在，视图栈长度从 2 变成 1。

调用关系：它直接测试 view_stack 这类“窗口堆叠”行为。测试用 push_view 制造上下两层窗口，再让 dismiss_app_server_request 去堆里找匹配项，最后检查没有误删最上层窗口。

调用图：调用 1 个内部函数（new）；外部调用 4 个（new, assert!, assert_eq!, test_pane）。

fn dismiss_app_server_request_returns_false_when_no_view_matches()

作用：测试服务端要求取消某个请求时，如果当前没有任何窗口对得上，函数会明确返回 false，并且不改动现有窗口。这样调用方能知道“没找到要取消的东西”。

数据流：测试创建两个视图，一个绑定了别的请求，另一个没有绑定请求。然后尝试取消 request-1。因为没有匹配项，返回值应该是 false，视图栈仍然保留两个视图，最上层还是原来的 second。

调用关系：这个测试补上 dismiss_app_server_request 的反面情况。它和移除匹配窗口的测试形成一组：一个证明能删对的，另一个证明找不到时不会乱删。

调用图：调用 1 个内部函数（new）；外部调用 4 个（new, assert!, assert_eq!, test_pane）。

fn completing_top_view_preserves_underlying_view()

作用：测试最上层窗口完成并关闭时，不会把下面的窗口也一起关掉。窗口栈应该像一叠纸，只拿走最上面那张。

数据流：测试先压入一个底层视图，再压入一个按 Enter 会完成的顶层视图。随后模拟按 Enter。结果是顶层视图被移除，底层视图仍然留在栈里。

调用关系：测试框架运行它来确认 handle_key_event 对当前活动视图的收尾逻辑正确。它用 push_view 安排上下层关系，再让按键事件触发顶层视图完成。

调用图：调用 1 个内部函数（new）；外部调用 4 个（new, new, assert_eq!, test_pane）。

fn composer_shown_after_denied_while_task_running()

作用：测试任务还在运行时，如果用户拒绝了一个审批弹窗，弹窗会消失，但“正在工作”的状态和输入框还应该显示。否则用户会以为界面卡住了，或者不知道还能继续输入。

数据流：测试创建真实的 BottomPane，启动任务运行状态，再打开一个审批弹窗。它模拟用户按 n 拒绝审批，然后检查弹窗栈为空。接着渲染一块终端区域，读取第一行和下面几行文字，确认上面有 Working，下面还能看到输入框占位文字 Ask Codex。

调用关系：它串起了 set_task_running、push_approval_request、handle_key_event 和 render。这个测试关注的是多个部件交替出现时的最终画面：审批层退场后，状态栏和输入框必须重新接上。

调用图：调用 4 个内部函数（with_defaults, new, new, test_dummy）；外部调用 10 个（empty, from_millis, Char, new, new, new, new, assert!, sleep, exec_request）。

fn status_indicator_visible_during_command_execution()

作用：测试命令执行期间底部面板会显示“正在工作”的状态提示。用户需要这个提示来知道程序不是没反应，而是在执行任务。

数据流：测试新建面板，把任务状态设为运行中，然后把面板渲染到一个测试用缓冲区里。最后把缓冲区内容转成文本，确认里面包含“• Working”。

调用关系：它主要验证 set_task_running 对 render 输出的影响。测试框架调用它，Buffer 和 snapshot_buffer 只是用来读取终端画面里的文字。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 5 个（empty, new, new, assert!, snapshot_buffer）。

fn status_and_composer_fill_height_without_bottom_padding()

作用：测试状态栏和输入框占满它们需要的高度时，底部不会多留一行空白。这个细节会影响终端界面的紧凑程度。

数据流：测试创建面板并设置任务运行中，然后询问面板在宽度 30 下想要多高。它用这个刚好够用的高度渲染画面，并用快照确认画面底部没有额外 padding，也就是没有无意义的留白。

调用关系：它把 desired_height 和 render 放在一起检查：面板自己说需要多少高度，实际画出来就应该正好用掉这些高度。assert_snapshot 用来保存和比较预期画面。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, new, assert!, assert_snapshot!）。

fn status_only_snapshot()

作用：测试只有运行状态时，底部面板画出来的样子保持稳定。快照测试像给界面拍照片，之后代码改动如果让画面变了，就会被发现。

数据流：测试创建面板，设置任务运行中，按宽度 48 计算所需高度，然后渲染成文本快照。输出不是手动逐字检查，而是和保存的标准画面比较。

调用关系：它覆盖状态栏的基础渲染路径。set_task_running 提供状态，desired_height 决定画布大小，render_snapshot 负责把最终终端画面交给快照断言。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 3 个（new, new, assert_snapshot!）。

fn unified_exec_summary_does_not_increase_height_when_status_visible()

作用：测试后台终端进程摘要出现时，如果状态栏已经可见，它不会额外撑高底部面板。也就是说，提示文字要合并进已有区域，而不是把界面往上挤。

数据流：测试先启动运行状态，记录当前所需高度。然后设置一个后台执行进程，比如 sleep 5，再次计算高度。结果高度必须不变；随后渲染画面，确认能看到“background terminal running · /ps to view”这样的摘要文字。

调用关系：它检查 set_unified_exec_processes 和状态栏显示之间的配合。desired_height 用来防止布局变高，render_snapshot 用来确认摘要仍然确实显示出来。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 6 个（new, new, assert!, assert_eq!, render_snapshot, vec!）。

fn status_with_details_and_queued_messages_snapshot()

作用：测试运行状态带详细说明、同时还有排队消息时，底部面板的整体显示是否正确。用户既要知道当前在做什么，也要看到自己后续输入已经排队。

数据流：测试创建面板并启动任务，设置状态标题 Working 和两行详情，再设置一条待发送的后续问题。之后按宽度 48 计算高度并渲染，用快照确认状态详情和排队消息都在正确位置。

调用关系：它组合使用 update_status 和 set_pending_input_preview。这个测试不是只看一个部件，而是看状态区、详情区、排队消息区一起出现时有没有互相挤乱。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, new, assert_snapshot!, vec!）。

fn queued_messages_visible_when_status_hidden_snapshot()

作用：测试即使状态提示被隐藏，排队消息仍然能显示。这样用户不会因为状态栏收起，就看不到自己已经排队的输入。

数据流：测试先让任务进入运行中，再设置一条排队消息，随后主动隐藏状态提示。最后渲染画面并做快照比较，确认排队消息仍然保留在底部面板中。

调用关系：它验证 hide_status_indicator 不会顺手清掉 pending input preview。set_pending_input_preview 提供排队内容，render_snapshot 检查最终画面。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, new, assert_snapshot!, vec!）。

fn status_and_queued_messages_snapshot()

作用：测试运行状态和排队消息同时显示时的标准画面。这个场景很常见：任务还没结束，用户又输入了下一句话。

数据流：测试创建面板，设置任务运行中，再设置一条排队的后续问题。它计算需要的高度，渲染并用快照确认状态提示和排队消息都正确显示。

调用关系：它是状态栏和排队输入预览的常规组合测试。和“隐藏状态仍显示排队消息”的测试一起，覆盖两种显示状态。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, new, assert_snapshot!, vec!）。

fn remote_images_render_above_composer_text()

作用：测试远程图片或 data 图片作为附件时，会显示在输入框文字上方。这样用户能先看到已附加的图片，再继续编辑文字。

数据流：测试给面板设置两个图片地址，一个普通网址，一个 data:image 开头的内嵌图片。它确认输入框文字仍为空，然后渲染画面，检查里面出现 [Image #1] 和 [Image #2] 两个图片占位提示。

调用关系：它围绕 set_remote_image_urls、composer_text、desired_height 和 render_snapshot 展开。重点是图片附件属于输入前的预览内容，不应该混进输入框文字里。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 6 个（new, new, assert!, assert_eq!, render_snapshot, vec!）。

fn drain_pending_submission_state_clears_remote_image_urls()

作用：测试提交状态被取走后，已附加的远程图片地址会被清空。否则下一次提交可能会误带上上一次的图片。

数据流：测试先设置一个远程图片地址，并确认列表长度是 1。然后调用 drain_pending_submission_state，表示把当前待提交内容取走。之后再查看图片地址列表，应该已经为空。

调用关系：它检查 set_remote_image_urls 和 drain_pending_submission_state 的衔接。这个测试保证提交动作像“打包并清空购物车”，图片附件不会残留。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, assert!, assert_eq!, vec!）。

fn esc_with_skill_popup_does_not_interrupt_task()

作用：测试任务运行中打开技能弹窗时，按 Esc 只关闭弹窗，不会中断任务。Esc 是个危险键，必须根据当前上下文判断含义。

数据流：测试创建带一个技能的面板，启动任务运行状态，然后输入 $ 触发技能弹窗。接着模拟按 Esc，并检查事件队列里没有 Interrupt 中断事件，同时确认弹窗已经关闭。

调用关系：它测试 handle_key_event 对 Esc 的优先级处理。composer 的 popup_active 表示当前有弹窗，所以 Esc 应先交给弹窗关闭逻辑，而不是发给后端去停止任务。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 3 个（new, assert!, vec!）。

fn esc_with_slash_command_popup_does_not_interrupt_task()

作用：测试任务运行中打开斜杠命令弹窗时，按 Esc 不会中断任务。斜杠命令弹窗是用户正在选命令，不代表想停止当前任务。

数据流：测试启动一个正在运行的任务，输入 / 触发命令弹窗，然后按 Esc。它遍历事件队列，确认没有 Interrupt；同时确认输入框里还保留着 /。

调用关系：它和技能弹窗测试类似，但覆盖的是 slash command，也就是以 / 开头的命令建议。handle_key_event 必须先处理输入框弹窗状态，再考虑是否中断任务。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, new, assert!, assert_eq!）。

fn esc_with_agent_command_without_popup_does_not_interrupt_task()

作用：测试用户正在输入 /agent 命令但弹窗已经消失时，按 Esc 也不该中断任务。因为这时用户仍在编辑一个本地命令草稿。

数据流：测试启动任务，输入 /agent 后带空格，使命令弹窗隐藏。然后按 Esc。结果事件队列里没有 Interrupt，中断没有发生；输入框文字仍然是 /agent 加空格。

调用关系：它补充了一个更细的上下文：没有弹窗不一定就能中断任务，还要看输入内容是不是特殊命令草稿。这个行为由 handle_key_event 判断。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 4 个（new, new, assert!, assert_eq!）。

fn esc_release_after_dismissing_agent_picker_does_not_interrupt_task()

作用：测试按下 Esc 关闭代理选择器后，随后键盘释放 Esc 的事件不会被误当成第二次 Esc，从而中断任务。很多终端会分别发“按下”和“松开”事件，这里要避免误伤。

数据流：测试启动任务，打开一个选择视图。它先发送 Esc 按下事件来关闭选择器，再发送 Esc 松开事件。最后检查事件队列没有 Interrupt，并确认已经没有弹窗或弹出层。

调用关系：它检查 handle_key_event 对 KeyEventKind::Press 和 Release 的区分。show_selection_view 提供可关闭的选择器，后续 Esc release 必须被忽略或安全处理。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 5 个（default, new_with_kind, new, assert!, vec!）。

fn esc_interrupts_running_task_when_no_popup()

作用：测试任务运行中没有任何弹窗、选择器或特殊输入状态时，按 Esc 会真正发出中断任务的请求。这是 Esc 的默认“停止当前回合”作用。

数据流：测试创建面板并设置任务运行中，然后直接按 Esc。事件接收器应该收到 AppEvent::CodexOp(Op::Interrupt)，表示面板已经把用户的中断意图发给后端。

调用关系：这个测试是多个“有弹窗不应中断”测试的对照组。它证明 Esc 不是永远无效，而是在没有更高优先级的本地界面要处理时，才交给任务中断逻辑。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 3 个（new, new, assert!）。

fn remapped_interrupt_turn_uses_configured_key_including_agent_drafts()

作用：测试如果用户把“中断任务”的快捷键从 Esc 改成 F12，那么即使正在编辑 /agent 草稿，也要按 F12 才会中断。这样自定义快捷键才真正生效。

数据流：测试创建面板，修改运行时快捷键表，把 chat.interrupt_turn 设成 F12。然后启动任务并输入 /agent。按 Esc 时事件队列应为空；按 F12 时才收到 Interrupt 事件。

调用关系：它通过 set_keymap_bindings 把快捷键配置塞进面板，再用 handle_key_event 验证实际按键路径。这个测试把快捷键系统和底部输入状态连接起来检查。

调用图：调用 2 个内部函数（new, defaults）；外部调用 5 个（F, new, assert!, test_pane, vec!）。

fn selection_view_esc_respects_remapped_list_cancel()

作用：测试列表取消键被改成 q 后，Esc 不再关闭选择列表，只有 q 才关闭。这样用户改快捷键后，选择器也遵守同一套规则。

数据流：测试修改快捷键表，把 list.cancel 设为 q。它打开一个选择视图，并给取消动作挂上一个会发送 OpenApprovalsPopup 的回调。按 Esc 后视图还在、没有事件；按 q 后视图关闭，并收到 OpenApprovalsPopup 事件。

调用关系：它测试 show_selection_view、set_keymap_bindings 和 handle_key_event 的配合。选择视图的取消逻辑不能写死 Esc，而要看当前键位配置。

调用图：调用 2 个内部函数（new, defaults）；外部调用 7 个（new, default, Char, new, assert!, test_pane, vec!）。

fn esc_routes_to_handle_key_event_when_requested()

作用：测试某些弹窗如果明确要求自己处理 Esc，那么底部面板会把 Esc 当普通按键交给它，而不是调用默认的取消逻辑。这样特殊视图可以自定义 Esc 的意义。

数据流：测试定义一个临时视图，里面分别统计 on_ctrl_c 被调用几次、handle_key_event 被调用几次，并声明 prefer_esc_to_handle_key_event 为 true。把它压入面板后按 Esc。结果是 on_ctrl_c 次数为 0，handle_key_event 次数为 1。

调用关系：它围绕 BottomPaneView 这个视图接口验证分发规则。push_view 放入活动视图，handle_key_event 收到 Esc 后应尊重视图自己的 prefer_esc_to_handle_key_event 请求。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 7 个（new, new, new, clone, new, new, assert_eq!）。

fn release_events_are_ignored_for_active_view()

作用：测试键盘松开事件不会再传给活动视图处理。否则一次按键可能被处理两次，导致光标移动两格或菜单跳两项。

数据流：测试定义一个只记录 handle_key_event 调用次数的视图，并把它压入面板。随后发送 Down 的按下事件和 Down 的松开事件。最终调用次数应为 1，说明只有按下事件被处理。

调用关系：它检查 handle_key_event 对活动视图的事件过滤。KeyEventKind::Release 是终端输入里的“松开键”，底部面板应该在分发给视图前就把它挡掉。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 7 个（new, new, new_with_kind, clone, new, new, assert_eq!）。

fn paste_completion_clears_stacked_views_and_restores_composer_input()

作用：测试粘贴内容让顶层弹窗完成后，整个弹窗流程会被清理干净，并且输入框恢复可用。否则用户粘贴后可能被卡在已经结束的弹窗层里。

数据流：测试先禁用输入框，再压入一个底层阻塞视图和一个顶层“收到粘贴就完成”的视图。调用 handle_paste 粘贴 hello 后，顶层视图标记完成，面板应清空整个视图栈。接着按 Down 不应再传给原来的底层视图，并且渲染区域里能拿到输入光标位置，说明输入框回来了。

调用关系：它把 handle_paste、视图完成检测、视图栈清理和输入框恢复串起来测。底层 BlockingView 的调用次数用来证明旧弹窗没有残留接收按键。

调用图：调用 3 个内部函数（new, new, test_dummy）；外部调用 10 个（new, new, new, default, clone, new, new, new, assert!, assert_eq!）。

fn new() -> Self

作用：创建一个新的可复用输入框，并给它准备好内部通信通道和默认提示文字。有人想在界面里放一个任务输入框时，通常就从这里开始。

数据流：进去时不需要参数 → 它新建一对内部消息通道，把发送端包装成 AppEventSender，再创建真正的 ChatComposer，并开启增强按键支持，让 Shift+Enter 这类组合键能按预期工作 → 出来的是一个 ComposerInput，里面已经带好输入框、发送端和接收端，可以马上接收键盘输入和渲染。

调用关系：这是整个组件的起点。Default 默认构造会走到它，测试里渲染输入字符时也会用它。它把底层的 ChatComposer 和应用事件通道组装好，后面的 input、handle_paste、render_ref 等方法都依赖这里创建出的 inner。

调用图：调用 2 个内部函数（new, new）；被 2 处调用（new, composer_input_renders_typed_characters）；外部调用 1 个（unbounded_channel）。

fn is_empty(&self) -> bool

作用：判断当前输入框里有没有文字。外部可以用它来决定是否允许提交、是否显示空状态，或者是否需要清理输入。

数据流：进去的是当前 ComposerInput 自己 → 它直接询问内部 ChatComposer 现在是不是空的 → 出来一个 true 或 false，true 表示没有输入内容，false 表示里面有文字。

调用关系：它是一个很薄的查询口，只负责把问题转交给 inner.is_empty。它不会改动输入框，也不会触发事件，适合界面逻辑随时检查当前状态。

调用图：调用 1 个内部函数（is_empty）。

fn clear(&mut self)

作用：清空输入框里的文字。通常在用户提交成功后，或者需要重置表单时使用。

数据流：进去的是一个可修改的 ComposerInput → 它把内部 ChatComposer 的文本内容设置成空字符串，并同时给相关附加信息传入空列表 → 之后输入框里的可见文字被清掉，但组件本身还可以继续使用。

调用关系：它直接调用内部的 set_text_content，相当于让 ChatComposer 忘掉当前文本。它不负责提交，也不处理键盘，只是一个明确的“擦黑板”动作。

调用图：调用 1 个内部函数（set_text_content）；外部调用 2 个（new, new）。

fn input(&mut self, key: KeyEvent) -> ComposerAction

作用：把一次键盘按键交给输入框处理，并把复杂结果翻译成外部容易理解的动作。最重要的是，它能告诉外部：用户这次是不是按下了提交。

数据流：进去的是一个 KeyEvent，也就是一次键盘事件 → 它交给内部 ChatComposer 处理，内部可能改文字、移动光标、提交内容；如果内部结果是 Submitted，就取出提交文本包装成 ComposerAction::Submitted，否则返回 ComposerAction::None；最后它清掉内部产生但这里不需要处理的应用事件 → 出来的是一个高层动作，外部可以据此决定是否发送任务或重绘界面。

调用关系：这是主循环处理键盘输入时最常用的入口。它调用 handle_key_event 做真正的编辑工作，再调用 drain_app_events 收尾，避免内部事件留在队列里。它把内部的 InputResult 简化成 ComposerAction，降低外部使用难度。

调用图：调用 2 个内部函数（handle_key_event, drain_app_events）；外部调用 1 个（Submitted）。

fn handle_paste(&mut self, pasted: String) -> bool

作用：处理用户粘贴进来的一大段文字。它让输入框使用内部已有的粘贴判断和合并策略，而不是把粘贴当成一堆普通按键乱处理。

数据流：进去的是一段 pasted 字符串 → 它把这段文字交给内部 ChatComposer，内部决定如何插入、是否启用粘贴突发检测；随后清空内部事件队列 → 出来一个布尔值，表示这次粘贴是否被输入框成功处理，同时输入框内容可能已经发生变化。

调用关系：它在终端收到粘贴事件时被调用。真正的粘贴规则在 inner.handle_paste 里，这个包装方法负责转交和清理后续 AppEvent。它和 flush_paste_burst_if_due 配合，用来让大段粘贴显示得更顺滑。

调用图：调用 2 个内部函数（handle_paste, drain_app_events）。

fn set_hint_items(&mut self, items: Vec<(impl Into<String>, impl Into<String>)>)

作用：自定义输入框下面显示的操作提示。比如把底部提示改成“Enter 提交”“Esc 取消”，让用户知道能按什么键。

数据流：进去的是一组键名和说明文字的配对，每一项都可以转换成字符串 → 它把这些配对统一转换成 String，然后交给内部 ChatComposer 作为页脚提示覆盖项 → 之后渲染输入框时，底部会显示这些自定义提示。

调用关系：它服务于外部界面定制，不改输入文字。它调用 set_footer_hint_override，把默认提示换成调用方指定的内容。clear_hint_items 则负责撤销这个覆盖。

调用图：调用 1 个内部函数（set_footer_hint_override）。

fn clear_hint_items(&mut self)

作用：取消之前设置过的自定义底部提示，恢复输入框自己的默认提示。适合离开某个特殊模式后使用。

数据流：进去的是当前可修改的 ComposerInput → 它向内部 ChatComposer 传入 None，表示不再使用外部覆盖的提示项 → 之后输入框渲染时会回到默认提示。

调用关系：它和 set_hint_items 是一对。set_hint_items 负责换提示，clear_hint_items 负责恢复。实际修改仍由内部 set_footer_hint_override 完成。

调用图：调用 1 个内部函数（set_footer_hint_override）。

fn desired_height(&self, width: u16) -> u16

作用：根据给定宽度，计算这个输入框希望占多少行。界面排版时需要它来避免文字被挤坏或显示不全。

数据流：进去的是宽度 width，单位是终端字符格 → 它询问内部 ChatComposer 在这个宽度下需要几行来显示当前内容和提示 → 出来一个行数 u16，供布局系统安排空间。

调用关系：它通常在渲染前的布局阶段使用。它不自己计算换行细节，而是把问题交给 inner.desired_height，因为内部组件最清楚当前文字和样式需要多高。

调用图：调用 1 个内部函数（desired_height）。

fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)>

作用：计算光标应该显示在屏幕上的哪个位置。没有它，终端界面可能不知道该把闪烁光标放到哪一格。

数据流：进去的是一个 Rect，也就是输入框在屏幕上的矩形区域 → 它让内部 ChatComposer 根据当前文本、光标位置和区域大小计算坐标 → 出来可能是一个坐标，也可能是 None，None 表示当前不需要或无法显示光标。

调用关系：它在界面准备显示光标时使用。它把区域信息交给 inner.cursor_pos，和 render_ref 使用的区域应该保持一致，这样光标位置才会和画出来的文字对得上。

调用图：调用 1 个内部函数（cursor_pos）。

fn render_ref(&self, area: Rect, buf: &mut Buffer)

作用：把输入框画到终端界面的缓冲区里。缓冲区可以理解成一张临时画布，先画好，再统一显示到屏幕。

数据流：进去的是绘制区域 area 和可修改的 Buffer → 它调用内部 ChatComposer 的 render，把边框、文字、提示等内容写进这块缓冲区 → 出来没有单独返回值，但 Buffer 被改写，之后终端就能显示这个输入框。

调用关系：它在每次界面重绘时被调用。实际怎么画由 inner.render 完成，这个方法只是公开一个稳定、简单的渲染入口，让外部不用直接接触内部 ChatComposer。

调用图：调用 1 个内部函数（render）。

fn is_in_paste_burst(&self) -> bool

作用：判断当前是否正处在“粘贴突发”状态。粘贴突发指的是终端短时间内收到大量字符，通常是用户粘贴了一大段文本，而不是一个字一个字敲的。

数据流：进去的是当前 ComposerInput → 它询问内部 ChatComposer 是否正在识别和缓冲一段快速粘贴输入 → 出来一个布尔值，true 表示仍在粘贴突发处理中，false 表示没有。

调用关系：它常被外部刷新调度逻辑使用。如果返回 true，外部可能会安排稍后再 flush，也就是把暂存内容刷出来。真正状态保存在 inner 里。

调用图：调用 1 个内部函数（is_in_paste_burst）。

fn flush_paste_burst_if_due(&mut self) -> bool

作用：在粘贴突发等待时间到了之后，把暂存的粘贴内容刷进输入框。这样大段粘贴不会因为逐字符处理而显得卡顿或乱跳。

数据流：进去的是一个可修改的 ComposerInput → 它让内部 ChatComposer 检查是否已经到了该刷新的时间；如果到了，就更新输入文本；随后清掉内部事件队列 → 出来一个布尔值，true 表示文字发生变化、界面值得重画，false 表示这次不用动。

调用关系：它通常由定时刷新或主循环调用，和 handle_paste、is_in_paste_burst、recommended_flush_delay 配合使用。它把实际判断交给 inner.flush_paste_burst_if_due，自己负责把产生的 AppEvent 清理掉。

调用图：调用 2 个内部函数（flush_paste_burst_if_due, drain_app_events）。

fn recommended_flush_delay() -> Duration

作用：告诉外部：粘贴突发期间，下一次小刷新最好等多久。外部可以按这个建议设置计时器，让粘贴显示既及时又不过度刷新。

数据流：进去时不需要具体输入 → 它读取 ChatComposer 提供的推荐粘贴刷新间隔 → 出来一个 Duration，也就是一段时间长度。

调用关系：它是一个静态建议，不依赖某个具体输入框实例。调度器或主循环在发现 is_in_paste_burst 为 true 后，可以用它决定什么时候再调用 flush_paste_burst_if_due。

调用图：调用 1 个内部函数（recommended_paste_flush_delay）。

fn drain_app_events(&mut self)

作用：清空内部事件接收队列里已经产生但这个公开包装层不打算处理的事件。这样可以避免无用消息越积越多。

数据流：进去的是一个可修改的 ComposerInput → 它不断尝试从内部接收端 rx 里取事件，只要还能取到就丢掉 → 出来没有返回值，但接收队列被尽量清空。

调用关系：它是 input、handle_paste、flush_paste_burst_if_due 的收尾动作。内部 ChatComposer 有时会发 AppEvent 给完整应用使用，但这个简化组件不暴露那些事件，所以这里把它们排空，保持包装层干净。

调用图：被 3 处调用（flush_paste_burst_if_due, handle_paste, input）；外部调用 1 个（try_recv）。

fn default() -> Self

作用：提供 Rust 的默认创建方式，让别人可以用通用的 Default 习惯来创建 ComposerInput。它的效果和直接调用 ComposerInput::new 一样。

数据流：进去时没有参数 → 它调用 new 创建完整的输入框，包括内部 ChatComposer 和事件通道 → 出来一个默认配置好的 ComposerInput。

调用关系：这是标准接口的适配层。需要泛型默认值、测试默认初始化，或想写更简洁代码的地方会用它；真正的组装工作仍交给 ComposerInput::new。

调用图：外部调用 1 个（new）。

fn recommended_flush_delay() -> Duration

作用：给调用者一个安全的等待时间，用来确认“第一个被暂存的字符”已经不可能变成粘贴的一部分了。测试和界面定时刷新会用它来避免刚好卡在时间边界上。

数据流：进去没有业务输入，只读取文件里设定的字符间隔阈值 → 在这个阈值上多加 1 毫秒 → 出来一个 Duration，也就是建议等待多久再刷新或断言结果。

调用关系：它调用系统的 from_millis 来造出 1 毫秒的时间量；上层的 recommended_paste_flush_delay 和测试 tests::ascii_first_char_is_held_then_flushes_as_typed 会用它来等待足够久，让暂存字符正常吐出来。

调用图：被 2 处调用（recommended_paste_flush_delay, ascii_first_char_is_held_then_flushes_as_typed）；外部调用 1 个（from_millis）。

fn recommended_active_flush_delay() -> Duration

作用：给测试用的等待时间，专门用于已经进入粘贴缓冲状态后，等它超时并一次性吐出整段粘贴内容。

数据流：进去没有参数，只读取“活跃粘贴缓冲”的空闲超时时间 → 多加 1 毫秒，确保超过阈值 → 出来一个 Duration，测试拿它来推进时间。

调用关系：它调用 from_millis 构造额外的 1 毫秒；多个粘贴相关测试会用它，比如 tests::ascii_two_fast_chars_start_buffer_from_pending_and_flush_as_paste 和 tests::newline_suppression_window_outlives_buffer_flush。

调用图：被 6 处调用（ascii_burst_treats_enter_as_newline, burst_paste_fast_large_inserts_placeholder_on_flush, burst_paste_fast_small_buffers_and_flushes_on_stop, flush_after_paste_burst, ascii_two_fast_chars_start_buffer_from_pending_and_flush_as_paste, newline_suppression_window_outlives_buffer_flush）；外部调用 1 个（from_millis）。

fn on_plain_char(&mut self, ch: char, now: Instant) -> CharDecision

作用：处理一个普通 ASCII 字符，并决定它应该先藏起来、加入粘贴缓冲，还是触发“开始粘贴”的判断。这里的普通字符指没有 Ctrl、Alt 这类修饰键的字符。

数据流：进去一个字符和当前时间 → 先记录这次字符到来的时间和连续快速字符数量 → 如果已经在粘贴中，就要求追加到缓冲；如果前一个字符被暂存且这次来得很快，就把两者组成粘贴；如果连续字符够多，就提示调用者追回之前已经插入的字符；否则先暂存当前字符 → 出来一个 CharDecision，告诉调用者下一步怎么做。

调用关系：它是 ASCII 输入路径的核心入口，会把计时工作交给 PasteBurst::note_plain_char，并用 duration_since 比较两次输入间隔；返回的决定由外层输入框逻辑执行，自己不直接改界面。

调用图：调用 1 个内部函数（note_plain_char）；外部调用 1 个（duration_since）。

fn on_plain_char_no_hold(&mut self, now: Instant) -> Option<CharDecision>

作用：处理不适合暂存的普通字符，比如中文输入法或非 ASCII 字符。它不会把第一个字符藏起来，因为那样用户会感觉字被吞了。

数据流：进去当前时间，不接收具体字符内容 → 记录这次普通字符的时间 → 如果已经在粘贴中，就返回追加到缓冲；如果连续快速字符数量达到阈值，就返回开始缓冲并提示可追回前面的字符；否则返回 None，表示正常插入 → 它只给判断，不改输入框。

调用关系：它调用 PasteBurst::note_plain_char 更新快速输入计数；调用图显示 handle_key_event_at 会在处理按键时使用它，特别是非 ASCII 或输入法场景。

调用图：调用 1 个内部函数（note_plain_char）；被 1 处调用（handle_key_event_at）。

fn note_plain_char(&mut self, now: Instant)

作用：记录一次普通字符输入，并更新“这些字符是不是来得很密集”的计数。它是判断粘贴的计时基础。

数据流：进去当前时间 → 和上一次普通字符时间比较，如果间隔很短就把连续计数加一，否则从一重新开始 → 最后把当前时间保存为最近一次普通字符时间。

调用关系：PasteBurst::on_plain_char 和 PasteBurst::on_plain_char_no_hold 都先调用它；它内部用 duration_since 算时间差，为后面的粘贴判断提供依据。

调用图：被 2 处调用（on_plain_char, on_plain_char_no_hold）；外部调用 1 个（duration_since）。

fn flush_if_due(&mut self, now: Instant) -> FlushResult

作用：在界面定时刷新时检查：暂存的字符或粘贴缓冲是不是该放出来了。它决定输出单个普通字符、整段粘贴，还是暂时什么都不做。

数据流：进去当前时间 → 根据现在是否处在粘贴相关状态选择超时时间 → 如果超时且有粘贴缓冲，就清掉活跃标记并取出整段文本作为 Paste；如果只是暂存了第一个字符，就取出它作为 Typed；如果还没到时间或没东西，就返回 None → 会改变内部缓冲和暂存字符状态。

调用关系：它调用 PasteBurst::is_active_internal 判断内部是否有缓冲，又用 take 把字符串或暂存值安全搬出来；外层 UI tick 会根据 FlushResult 决定是普通插入还是走粘贴处理。

调用图：调用 1 个内部函数（is_active_internal）；外部调用 3 个（take, Paste, Typed）。

fn append_newline_if_active(&mut self, now: Instant) -> bool

作用：如果当前正处在粘贴上下文里，就把 Enter 当成换行塞进粘贴内容，而不是提交消息。

数据流：进去当前时间 → 先检查是否处在粘贴相关状态 → 如果是，就把 '\n' 加进缓冲，并延长 Enter 保护窗口，返回 true；如果不是，什么也不改，返回 false。

调用关系：它调用 PasteBurst::is_active 判断是否应当接管 Enter；通常会被按键处理流程在遇到 Enter 时用来避免多行粘贴被提前发送。

调用图：调用 1 个内部函数（is_active）。

fn newline_should_insert_instead_of_submit(&self, now: Instant) -> bool

作用：判断现在按 Enter 应该换行，还是应该提交消息。它主要保护粘贴中的多行文本。

数据流：进去当前时间 → 查看是否还在短暂的 Enter 保护窗口内，也查看是否仍处于粘贴状态 → 只要满足其中之一，就输出 true，表示 Enter 应插入换行；否则输出 false。

调用关系：它调用 PasteBurst::is_active；PasteBurst::direct_insert_newline_should_insert 会在更直接插入字符的路径里复用这个判断。

调用图：调用 1 个内部函数（is_active）；被 1 处调用（direct_insert_newline_should_insert）。

fn direct_insert_newline_should_insert(&self, now: Instant) -> bool

作用：给“直接插入字符”的调用者判断 Enter 的用途：此刻更像粘贴时，Enter 就应该变成换行。

数据流：进去当前时间 → 先复用 newline_should_insert_instead_of_submit 的判断 → 如果还不够，再看最近一次普通字符是不是刚刚发生，若非常接近也认为像粘贴 → 输出 true 表示插入换行，false 表示可以提交。

调用关系：它调用 PasteBurst::newline_should_insert_instead_of_submit；调用图显示 handle_key_event_at 会在处理 Enter 时使用它。

调用图：调用 1 个内部函数（newline_should_insert_instead_of_submit）；被 1 处调用（handle_key_event_at）。

fn extend_window(&mut self, now: Instant)

作用：把 Enter 保护窗口再往后延一点。这样粘贴流里稍晚到达的 Enter 仍会被当成换行。

数据流：进去当前时间 → 用当前时间加上固定保护时长 → 更新 burst_window_until → 没有返回值，但改变了内部的保护截止时间。

调用关系：调用图显示 handle_key_event_at 会用它；它常配合快速字符或 Enter 事件，让粘贴识别窗口保持活着。

调用图：被 1 处调用（handle_key_event_at）。

fn begin_with_retro_grabbed(&mut self, grabbed: String, now: Instant)

作用：用已经从输入框里追回来的文字开始一个粘贴缓冲。适合“刚才以为是打字，后来发现其实像粘贴”的情况。

数据流：进去追回来的字符串和当前时间 → 如果字符串不空，就放进内部缓冲 → 标记粘贴缓冲为活跃，并设置 Enter 保护窗口 → 没有返回值，但内部状态变成正在收集粘贴。

调用关系：PasteBurst::decide_begin_buffer 在确认前缀像粘贴后会调用它；它不负责从界面删除文字，只负责接住调用者已经决定追回的内容。

调用图：被 1 处调用（decide_begin_buffer）。

fn append_char_to_buffer(&mut self, ch: char, now: Instant)

作用：把当前字符追加进粘贴缓冲，并顺手延长 Enter 保护窗口。

数据流：进去一个字符和当前时间 → 把字符 push 到内部 buffer → 把保护窗口更新到当前时间之后的一小段 → 没有返回值，内部缓冲变长。

调用关系：PasteBurst::try_append_char_if_active 会调用它；外层在收到 BufferAppend 或 BeginBufferFromPending 这类决定后，也会用它把当前字符正式纳入粘贴内容。

调用图：被 1 处调用（try_append_char_if_active）。

fn try_append_char_if_active(&mut self, ch: char, now: Instant) -> bool

作用：尝试把字符加进已有粘贴缓冲，但只有确实已经在粘贴上下文里才会加。它避免普通打字被误塞进缓冲。

数据流：进去一个字符和当前时间 → 检查 active 标记或 buffer 是否非空 → 如果是，就调用 append_char_to_buffer 并返回 true；如果不是，什么也不改并返回 false。

调用关系：它把真正追加字符的活交给 PasteBurst::append_char_to_buffer；适合外层代码不确定当前是否仍在粘贴时做一次安全尝试。

调用图：调用 1 个内部函数（append_char_to_buffer）。

fn decide_begin_buffer(
        &mut self,
        now: Instant,
        before: &str,
        retro_chars: usize,
    ) -> Option<RetroGrab>

作用：判断要不要把光标前已经插入的一小段文字追回来，作为粘贴开头。它用来修正“先当打字插入、后发现像粘贴”的误差。

数据流：进去当前时间、光标前的文本 before、要追回的字符数 → 先用 retro_start_index 把字符数换成 UTF-8 字节位置 → 截出要追回的字符串 → 如果里面有空白字符，或长度至少 16 个字符，就认为像粘贴，调用 begin_with_retro_grabbed 开始缓冲，并返回 RetroGrab；否则返回 None，不改界面文字。

调用关系：它调用 retro_start_index 处理多字节字符的安全切片，又调用 PasteBurst::begin_with_retro_grabbed 开启缓冲；外层调用者拿到 RetroGrab 后才负责从输入框里删除那段文字。

调用图：调用 2 个内部函数（begin_with_retro_grabbed, retro_start_index）。

fn flush_before_modified_input(&mut self) -> Option<String>

作用：在处理方向键、Ctrl/Alt 快捷键等非普通字符前，先把当前粘贴相关内容吐出来，避免状态卡住或串到下一次输入。

数据流：进去没有参数 → 如果当前不活跃，直接返回 None → 如果活跃，就关闭 active，取出 buffer；如果还有暂存的第一个字符，也追加到输出末尾 → 返回 Some(String)，让调用者按粘贴或文本内容处理。

调用关系：它调用 PasteBurst::is_active 判断是否有东西要冲刷，并用 take 取走缓冲；通常由按键处理流程在进入非字符输入前调用。

调用图：调用 1 个内部函数（is_active）；外部调用 1 个（take）。

fn clear_window_after_non_char(&mut self)

作用：清掉粘贴识别的计时窗口，让下一次打字不要被错误地接到上一段快速输入后面。

数据流：进去没有参数 → 把连续计数、最近字符时间、Enter 保护窗口、活跃标记和暂存字符都清空 → 不返回值；注意它不负责输出 buffer，调用者应该先 flush。

调用关系：它通常跟 flush_before_modified_input 搭配：先把内容吐出来，再清掉分类窗口；这样方向键或快捷键之后的新字符会重新开始判断。

fn is_active(&self) -> bool

作用：告诉外界：现在是否处在任何粘贴识别相关的临时状态里。包括正在缓冲、缓冲里还有内容，或者第一个字符正被短暂暂存。

数据流：进去没有参数 → 先调用 is_active_internal 看内部缓冲状态，再检查 pending_first_char 是否存在 → 输出布尔值 true 或 false。

调用关系：它被 PasteBurst::append_newline_if_active、PasteBurst::flush_before_modified_input 和 PasteBurst::newline_should_insert_instead_of_submit 使用，是外层判断“是否还在粘贴上下文”的统一入口。

调用图：调用 1 个内部函数（is_active_internal）；被 3 处调用（append_newline_if_active, flush_before_modified_input, newline_should_insert_instead_of_submit）。

fn is_active_internal(&self) -> bool

作用：只检查真正的粘贴缓冲状态，不把“暂存第一个字符”算进去。它是给内部更精细判断用的小工具。

数据流：进去没有参数 → 查看 active 是否为 true，或 buffer 是否非空 → 输出布尔值。

调用关系：PasteBurst::flush_if_due 用它决定采用粘贴缓冲超时还是普通首字符超时；PasteBurst::is_active 也调用它，再额外考虑暂存字符。

调用图：被 2 处调用（flush_if_due, is_active）。

fn clear_after_explicit_paste(&mut self)

作用：在程序明确收到一次真正的粘贴事件后，清空这个“猜粘贴”的状态机。这样旧的猜测不会影响新输入。

数据流：进去没有参数 → 清掉最近字符时间、连续计数、Enter 保护窗口、active、buffer 和 pending_first_char → 没有返回值，整个 PasteBurst 回到干净状态。

调用关系：调用图显示 handle_key_event_at 和 handle_paste 会调用它；它用于显式粘贴路径结束后做收尾，避免和猜测式粘贴检测互相干扰。

调用图：被 2 处调用（handle_key_event_at, handle_paste）。

fn retro_start_index(before: &str, retro_chars: usize) -> usize

作用：把“从末尾往前数几个字符”转换成字符串里的字节下标。Rust 字符串用 UTF-8，中文、emoji 这类字符可能占多个字节，所以不能直接按字节乱切。

数据流：进去一段字符串 before 和要往回数的字符数 retro_chars → 如果数量是 0，就返回字符串末尾 → 否则从后往前按字符找位置 → 找到就返回对应字节下标，找不到就返回 0。

调用关系：PasteBurst::decide_begin_buffer 调用它来安全计算追回文本的起点；它保证后续 before[start_byte..] 尽量落在合法字符边界上。

调用图：被 1 处调用（decide_begin_buffer）。

fn ascii_first_char_is_held_then_flushes_as_typed()

作用：测试一个普通 ASCII 字符不会马上显示，而是先被短暂暂存；如果后面没有快速字符跟上，它最终会像正常打字一样输出。

数据流：进去没有外部输入 → 创建默认 PasteBurst 和当前时间 → 输入字符 'a'，检查返回 RetainFirstChar → 把时间推进到推荐等待时间之后 → 调用 flush_if_due，确认得到 Typed('a')，并确认状态不再活跃。

调用关系：它调用 PasteBurst::recommended_flush_delay、now、default 和断言宏；它验证 recommended_flush_delay 与 flush_if_due 的配合是否能让单字符正常落地。

调用图：调用 1 个内部函数（recommended_flush_delay）；外部调用 4 个（from_millis, now, assert!, default）。

fn ascii_two_fast_chars_start_buffer_from_pending_and_flush_as_paste()

作用：测试两个 ASCII 字符快速连续到达时，会被当成一次粘贴，而不是先显示第一个再改判。

数据流：进去没有外部输入 → 创建 PasteBurst → 输入 'a' 后确认它被暂存 → 1 毫秒后输入 'b'，确认开始从暂存字符建缓冲 → 把 'b' 追加进缓冲 → 时间越过活跃缓冲超时 → flush_if_due 应返回 Paste("ab")。

调用关系：它调用 PasteBurst::recommended_active_flush_delay、from_millis、now、default 和断言宏；它覆盖 on_plain_char、append_char_to_buffer、flush_if_due 这条典型快速粘贴路径。

调用图：调用 1 个内部函数（recommended_active_flush_delay）；外部调用 4 个（from_millis, now, assert!, default）。

fn flush_before_modified_input_includes_pending_first_char()

作用：测试在处理非普通输入前，连那个还没显示的暂存首字符也会被吐出来，不会丢字。

数据流：进去没有外部输入 → 创建 PasteBurst → 输入 'a' 并确认被 RetainFirstChar 暂存 → 调用 flush_before_modified_input → 期待返回 Some("a")，并确认状态不活跃。

调用关系：它调用 now、default、assert 和 assert_eq；它专门保护 flush_before_modified_input 的收尾行为，避免快捷键或方向键前吞掉用户输入。

调用图：外部调用 4 个（now, assert!, assert_eq!, default）。

fn decide_begin_buffer_only_triggers_for_pastey_prefixes()

作用：测试追回已插入文字时，只有看起来像粘贴的前缀才会触发缓冲，短短的普通词不会被误判。

数据流：进去没有外部输入 → 创建 PasteBurst 和当前时间 → 先用 "ab" 尝试追回 2 个字符，期待 None 且状态不活跃 → 再用 "a b" 尝试追回，因包含空白而被认为像粘贴 → 检查追回起点和追回内容，并确认状态活跃。

调用关系：它调用 now、default、assert 和 assert_eq；它验证 decide_begin_buffer 与 retro_start_index、begin_with_retro_grabbed 的组合不会太激进。

调用图：外部调用 4 个（now, assert!, assert_eq!, default）。

fn newline_suppression_window_outlives_buffer_flush()

作用：测试粘贴缓冲吐出以后，Enter 保护窗口还会短暂存在。这样稍晚到的 Enter 仍会被当作换行，而不是立刻提交消息。

数据流：进去没有外部输入 → 模拟 'a'、'b' 快速形成粘贴 → 等待活跃缓冲超时并确认 flush_if_due 返回 Paste("ab") → 虽然状态不活跃，仍检查当前时间下 Enter 应该插入换行 → 再把时间推进超过保护窗口，确认 Enter 不再被保护。

调用关系：它调用 PasteBurst::recommended_active_flush_delay、from_millis、now、default 和断言宏；它保护 newline_should_insert_instead_of_submit 与 burst_window_until 的关键行为。

调用图：调用 1 个内部函数（recommended_active_flush_delay）；外部调用 4 个（from_millis, now, assert!, default）。

fn vim_text_object_scope_for_event(
        &self,
        event: KeyEvent,
    ) -> Option<VimTextObjectScope>

作用：把一次按键判断成 Vim 文本对象的范围选择：是选“里面”，还是选“周围连带外面的符号或空白”。用户按下类似 i 或 a 这类键时，会用它来决定后面怎么取范围。

数据流：进去的是一个键盘事件，以及输入框里配置好的快捷键表；它逐个检查这个键是不是“选里面”或“选周围”；出来的是 Inner、Around，或者什么都不是的 None，不会修改文本。

调用关系：它通常在 Vim 操作已经开始、正在等待用户指定文本对象范围时被调用。它只负责认出范围类型，不继续找具体文字；后续会再配合 TextArea::vim_text_object_for_event 和 TextArea::text_object_range 算出真正的位置。

fn vim_text_object_for_event(&self, event: KeyEvent) -> Option<VimTextObject>

作用：把一次按键判断成具体的 Vim 文本对象，比如词、括号、方括号、花括号、双引号、单引号或反引号。这样输入框才知道用户想操作哪一类文字块。

数据流：进去的是键盘事件和文本对象快捷键表；它按顺序检查这个键对应哪种对象；出来的是一个 VimTextObject，或者 None，表示这个键不是文本对象键。

调用关系：它通常接在范围判断之后使用：先知道用户要“里面”还是“周围”，再用它知道对象是什么。它本身不计算范围，真正找文字位置的工作交给 TextArea::text_object_range。

fn text_object_range(
        &self,
        object: VimTextObject,
        scope: VimTextObjectScope,
    ) -> Option<Range<usize>>

作用：根据“对象类型”和“里面/周围”这两个选择，算出当前光标附近应该被操作的文字范围。删除、复制、修改这类 Vim 操作最终都需要这个范围。

数据流：进去的是对象类型，比如词或括号，以及范围类型，比如只要里面还是连外壳一起；它按对象分流：词交给 TextArea::word_text_object_range，括号交给 TextArea::paired_text_object_range，引号交给 TextArea::quoted_text_object_range；出来的是一段文字的位置范围，找不到就返回 None。

调用关系：它是文本对象查找的总入口。上游的按键处理先把按键翻译成对象和范围，然后调用它；它再把具体查找交给更专门的小函数。

调用图：调用 3 个内部函数（paired_text_object_range, quoted_text_object_range, word_text_object_range）。

fn word_text_object_range(
        &self,
        scope: VimTextObjectScope,
        big_word: bool,
    ) -> Option<Range<usize>>

作用：专门计算“词”这个文本对象的范围。它支持小词和大词，也支持只选词本身或连旁边空白一起选。

数据流：进去的是范围类型和是否为大词的标记；它先调用 TextArea::big_word_range_at_cursor 或 TextArea::small_word_range_at_cursor 找到光标所在的词；如果用户要 Around，它再调用 TextArea::expand_word_around 把旁边空白也带上；出来的是最终词范围，或者 None。

调用关系：它由 TextArea::text_object_range 在对象是 Word 或 BigWord 时调用。它自己不关心按键，只负责把“词对象”变成实际文字范围。

调用图：调用 3 个内部函数（big_word_range_at_cursor, expand_word_around, small_word_range_at_cursor）；被 1 处调用（text_object_range）。

fn big_word_range_at_cursor(&self) -> Option<Range<usize>>

作用：找出光标所在的“大词”。这里的大词意思很简单：只要不是空白，连续的一串都算一个词。

数据流：进去的是当前输入框文本和光标位置；它先调用 TextArea::non_ws_runs 找出所有非空白片段，再挑出光标落在里面或刚好停在结尾的那一段；出来的是这段大词范围，或者 None。

调用关系：它只被 TextArea::word_text_object_range 调用，用在用户选择 BigWord 的时候。它把“按空白切块”的粗粒度找词工作单独拿出来。

调用图：调用 1 个内部函数（non_ws_runs）；被 1 处调用（word_text_object_range）。

fn small_word_range_at_cursor(&self) -> Option<Range<usize>>

作用：找出光标所在的“小词”。小词比大词更细，会把一串非空白内容再按单词片段拆开，比如标点和字母可能不是同一个片段。

数据流：进去的是当前文本和光标位置；它先用 TextArea::non_ws_runs 找非空白大段，再用外部的 split_word_pieces 把这一段拆成更小的词片；它用 TextArea::cursor_overlaps_range 和 TextArea::cursor_is_at_range_end 判断光标在哪；出来的是最合适的小词范围，或者 None。

调用关系：它由 TextArea::word_text_object_range 在普通 Word 场景下调用。它依赖 split_word_pieces 做细拆分，自己负责把拆出来的小片段和光标位置对上。

调用图：调用 3 个内部函数（cursor_is_at_range_end, cursor_overlaps_range, non_ws_runs）；被 1 处调用（word_text_object_range）；外部调用 1 个（split_word_pieces）。

fn non_ws_runs(&self) -> Vec<Range<usize>>

作用：把整段输入文字切成一段段“不是空白”的连续区域。它是找词的基础步骤，相当于先把句子按空格粗略切开。

数据流：进去的是输入框里的完整文本；它从头扫描每个字符，遇到空白就结束当前片段，遇到非空白就开始或继续片段；出来的是多个位置范围组成的列表，不改动文本。

调用关系：它被 TextArea::big_word_range_at_cursor 和 TextArea::small_word_range_at_cursor 调用。前者直接把这些片段当大词，后者还会继续细分。

调用图：被 2 处调用（big_word_range_at_cursor, small_word_range_at_cursor）；外部调用 1 个（new）。

fn cursor_overlaps_range(&self, range: &Range<usize>) -> bool

作用：判断光标是不是落在某个文字范围里面。这个小判断能避免后面的找词逻辑反复写同样的边界判断。

数据流：进去的是一个文字范围和当前光标位置；它检查范围起点是否不超过光标、光标是否还没到范围终点；出来的是 true 或 false，不产生副作用。

调用关系：它被 TextArea::small_word_range_at_cursor 调用，用来确认光标是否在某个非空白段或小词片段内部。

调用图：被 1 处调用（small_word_range_at_cursor）。

fn cursor_is_at_range_end(&self, range: &Range<usize>) -> bool

作用：判断光标是不是刚好停在某段文字的末尾。这样用户把光标放在词尾后面时，仍然能把前面的词识别出来。

数据流：进去的是一个文字范围和当前光标位置；它确认这个范围不是空的，并且光标正好等于范围结尾；出来的是 true 或 false，不改动任何内容。

调用关系：它被 TextArea::small_word_range_at_cursor 调用，补上“光标在词尾后面”这种常见编辑位置。

调用图：被 1 处调用（small_word_range_at_cursor）。

fn expand_word_around(&self, inner: Range<usize>) -> Range<usize>

作用：把“词本身”的范围扩成 Vim 里 Around 的范围，也就是尽量连旁边空白一起选中。这样删除一个词时，常常不会留下多余空格。

数据流：进去的是已经找到的词范围；它先调用 TextArea::following_whitespace_end 看词后面有没有空白，有就把后面的空白带上；如果后面没有，就调用 TextArea::preceding_whitespace_start 带上前面的空白；出来的是扩展后的范围。

调用关系：它由 TextArea::word_text_object_range 在用户选择 Around 时调用。它不负责找词，只负责把已找到的词范围变得更符合 Vim 的使用习惯。

调用图：调用 2 个内部函数（following_whitespace_end, preceding_whitespace_start）；被 1 处调用（word_text_object_range）。

fn following_whitespace_end(&self, start: usize) -> usize

作用：从某个位置开始，往后数连续空白一直到哪里结束。它用来决定一个词后面的空格要不要一起选。

数据流：进去的是一个起始位置和当前文本；它从这个位置向后扫描，遇到非空白就停；出来的是连续空白结束的位置。如果一开始就没有空白，就返回原位置。

调用关系：它只被 TextArea::expand_word_around 调用，是 Around 选词时“优先吃掉后面空白”的辅助步骤。

调用图：被 1 处调用（expand_word_around）。

fn preceding_whitespace_start(&self, end: usize) -> usize

作用：从某个位置往前看，找到前面连续空白从哪里开始。它用在词后面没有空白时，改为把词前面的空白一起选上。

数据流：进去的是一个结束位置和当前文本；它从这个位置之前向前扫描，连续遇到空白就继续，遇到非空白就停；出来的是这串前置空白的起点。

调用关系：它只被 TextArea::expand_word_around 调用，作为“后面没有空白时”的备用扩展方式。

调用图：被 1 处调用（expand_word_around）。

fn paired_text_object_range(
        &self,
        scope: VimTextObjectScope,
        open: char,
        close: char,
    ) -> Option<Range<usize>>

作用：查找光标所在的成对符号范围，比如圆括号、方括号或花括号。它能区分只选括号里面，还是连括号本身一起选。

数据流：进去的是范围类型，以及开符号和闭符号，比如 '(' 和 ')'；它从头扫描文本，用一个栈（一摞临时记录，用来配对嵌套括号）记住开符号，遇到闭符号就配对；它会调用 TextArea::is_inside_element 跳过特殊元素；最后选出包含光标且最小的那一对，出来的是对应范围或 None。

调用关系：它由 TextArea::text_object_range 在对象是括号、方括号或花括号时调用。它是成对符号文本对象的核心查找器。

调用图：调用 1 个内部函数（is_inside_element）；被 1 处调用（text_object_range）；外部调用 1 个（new）。

fn quoted_text_object_range(
        &self,
        scope: VimTextObjectScope,
        quote: char,
    ) -> Option<Range<usize>>

作用：查找光标所在的一对引号范围，比如双引号、单引号或反引号。它主要用于“删除引号里的内容”或“复制整段引号字符串”这类操作。

数据流：进去的是范围类型和引号字符；它只扫描当前行，从左到右找成对引号；遇到特殊元素会用 TextArea::is_inside_element 跳过，遇到被反斜杠转义的引号会用 TextArea::is_escaped 跳过；如果要 Around，就用 idx_range 把右引号也算进来；出来的是最小的匹配范围或 None。

调用关系：它由 TextArea::text_object_range 在对象是各种引号时调用。它把引号匹配限制在当前行，避免跨行误选太大一片内容。

调用图：调用 3 个内部函数（is_escaped, is_inside_element, idx_range）；被 1 处调用（text_object_range）。

fn is_inside_element(&self, pos: usize) -> bool

作用：判断某个文字位置是不是落在输入框的特殊元素里面。特殊元素不是普通可解析文本，所以找括号或引号时要绕开它们。

数据流：进去的是一个位置和输入框保存的元素范围列表；它检查这个位置是否在任意元素范围内；出来的是 true 或 false，不修改元素或文本。

调用关系：它被 TextArea::paired_text_object_range 和 TextArea::quoted_text_object_range 调用。它像一道过滤门，防止文本对象查找误读特殊区域里的字符。

调用图：被 2 处调用（paired_text_object_range, quoted_text_object_range）。

fn is_escaped(&self, pos: usize) -> bool

作用：判断某个位置的字符是不是被反斜杠转义了。简单说，如果引号前面有奇数个连续反斜杠，这个引号就只是普通字符，不应该当成字符串边界。

数据流：进去的是一个位置和当前位置之前的文本；它从该位置往前数连续的反斜杠数量；如果数量是奇数就返回 true，否则返回 false。

调用关系：它被 TextArea::quoted_text_object_range 调用。引号查找靠它避开类似 \" 这种不是真正结束引号的情况。

调用图：被 1 处调用（quoted_text_object_range）。

fn idx_range(open_idx: usize, close_idx: usize, quote: char) -> Range<usize>

作用：根据一对引号的位置，生成“连引号本身一起包含”的范围。它是一个很小的辅助函数，让 Around 引号范围的计算更清楚。

数据流：进去的是左引号位置、右引号位置和引号字符；它把范围设为从左引号开始，到右引号字符结束之后；出来的是这个位置范围。

调用关系：它被 TextArea::quoted_text_object_range 在 Around 场景下调用。引号查找函数负责找到两边引号，它负责把边界包装成最终范围。

调用图：被 1 处调用（quoted_text_object_range）。

fn is_word_separator(ch: char) -> bool

作用：判断一个字符是不是“单词分隔符”，比如标点这类会把单词切开的字符。它用于按单词移动或删除时，决定哪里算一个词的边界。

数据流：输入一个字符 → 去预先定义的分隔符列表里查它在不在 → 输出 true 或 false，不改任何状态。

调用关系：它是 split_word_pieces 的小工具；当文本框要找上一个词或下一个词时，会间接用到它来切词。

调用图：被 1 处调用（split_word_pieces）。

fn split_word_pieces(run: &str) -> Vec<(usize, &str)>

作用：把一段连续非空白文字切成更小的片段，把普通字母数字和分隔符分开。这样按“跳到下一个词”时，不会把标点和词混成一团。

数据流：输入一段字符串 → 先按 Unicode 单词边界粗分，再按分隔符和非分隔符变化细分 → 输出每片在原字符串里的起点和内容。

调用关系：beginning_of_previous_word 和 end_of_next_word_from 会用它理解“词”的范围；它内部调用 is_word_separator 判断字符类型。

调用图：调用 1 个内部函数（is_word_separator）；被 2 处调用（beginning_of_previous_word, end_of_next_word_from）；外部调用 1 个（new）。

fn new() -> Self

作用：创建一个空的文本框，并把光标、剪切板、Vim 状态和默认按键配置都设好。新输入框刚出现时就靠它初始化。

数据流：不需要输入 → 读取默认按键表，创建空文本、光标位置 0、空元素列表、默认插入模式等状态 → 返回一个可用的 TextArea。

调用关系：外层界面或测试创建输入框时会调用它；后续所有输入、渲染和编辑操作都建立在这些初始状态上。

调用图：调用 1 个内部函数（defaults）；被 20 处调用（new, test_current_at_token_allows_file_queries_with_second_at, test_current_at_token_basic_cases, test_current_at_token_cursor_positions, test_current_at_token_ignores_mid_word_at, test_current_at_token_tracks_tokens_with_second_at, test_current_at_token_whitespace_boundaries, new, new, delete_forward_deletes_element_at_left_edge (+10 more)）；外部调用 3 个（new, new, new）。

fn set_keymap_bindings(&mut self, keymap: &RuntimeKeymap)

作用：替换文本框使用的按键绑定，也就是告诉它哪些键代表删除、移动、Vim 操作等。用户自定义快捷键时会用到。

数据流：输入一份 RuntimeKeymap → 拷贝其中普通编辑和 Vim 各模式的按键表 → 更新文本框内部的按键配置。

调用关系：它通常在配置加载后被调用；之后 input、handle_vim_normal、handle_vim_operator 等处理按键时都会按新配置工作。

fn set_text_clearing_elements(&mut self, text: &str)

作用：把文本框内容整体换成新文字，并清掉原来的特殊元素标记。适合把输入框重置成纯文本。

数据流：输入新字符串 → 交给 set_text_inner，明确不带元素列表 → 文本被替换，元素被清空，光标被调整到安全位置。

调用关系：它是 set_text_inner 的公开入口之一；调用者不关心图片占位符等元素时会用这个版本。

调用图：调用 1 个内部函数（set_text_inner）。

fn set_text_with_elements(&mut self, text: &str, elements: &[UserTextElement])

作用：把文本框内容整体换成新文字，同时重新设置哪些范围是特殊元素。适合恢复带图片占位符等结构化片段的输入。

数据流：输入新字符串和元素范围列表 → 交给 set_text_inner → 文本、元素范围、光标和换行缓存一起更新。

调用关系：它是 set_text_inner 的另一个公开入口；需要保留特殊元素信息的上层功能会用它。

调用图：调用 1 个内部函数（set_text_inner）。

fn set_text_inner(&mut self, text: &str, elements: Option<&[UserTextElement]>)

作用：真正执行“整段替换文本”的内部函数，负责保证新文本、特殊元素和光标都合法。没有它，光标可能落到半个中文字符里，元素范围也可能越界。

数据流：输入新文本和可选元素列表 → 替换原文本，重建元素范围，给元素分配新 id，修正光标，清掉换行缓存和列偏好 → 内部状态变成和新文本一致。

调用关系：set_text_clearing_elements 和 set_text_with_elements 都把活交给它；它会调用字符边界修正和 next_element_id 等底层工具。

调用图：调用 3 个内部函数（clamp_pos_to_char_boundary, clamp_pos_to_nearest_boundary, next_element_id）；被 2 处调用（set_text_clearing_elements, set_text_with_elements）。

fn set_vim_enabled(&mut self, enabled: bool)

作用：打开或关闭 Vim 编辑方式。打开时进入普通模式，关闭时回到普通输入的插入状态。

数据流：输入是否启用 → 更新 vim_enabled，清掉未完成的 Vim 操作，并设置当前 Vim 模式 → 文本内容不变。

调用关系：外层设置切换 Vim 功能时调用；之后 input 会根据这个开关选择普通编辑还是 Vim 编辑。

fn is_vim_enabled(&self) -> bool

作用：告诉调用者 Vim 模式总开关现在是不是打开。界面显示或逻辑判断会用它。

数据流：读取内部 vim_enabled → 返回布尔值 → 不修改任何内容。

调用关系：它是状态查询函数；外层组件可用它决定是否显示 Vim 相关提示。

fn is_vim_normal_mode(&self) -> bool

作用：判断现在是否处在 Vim 的普通模式，也就是按键主要用于移动、删除、复制，而不是直接输入文字。

数据流：读取 vim_enabled 和 vim_mode → 两者满足条件就返回 true → 不改状态。

调用关系：外层界面可用它决定光标样式或按键解释；内部状态由 set_vim_enabled、enter_vim_normal_mode 等函数改变。

fn vim_normal_end_cursor(&self) -> usize

作用：给 Vim 普通模式计算“文本末尾光标应该停在哪里”。Vim 普通模式通常停在最后一个可见字符上，而不是停在字符后面。

数据流：读取文本长度 → 空文本返回 0，否则找到最后一个完整字符或元素的前一个边界 → 返回安全光标位置。

调用关系：它依赖 prev_atomic_boundary；外层需要按 Vim 规则放置光标时会用它。

调用图：调用 1 个内部函数（prev_atomic_boundary）。

fn is_vim_operator_pending(&self) -> bool

作用：判断 Vim 是否正在等第二个按键，比如已经按了 d，正在等后面的 w 或 d。这样界面可以知道有一个未完成命令。

数据流：读取 vim_pending → 如果不是 None 就返回 true → 不改状态。

调用关系：它是 Vim 状态查询；handle_vim_normal 会设置或清掉 vim_pending。

调用图：外部调用 1 个（matches!）。

fn enter_vim_insert_mode(&mut self)

作用：在 Vim 开启时切到插入模式，让后续普通字符能直接写入文本。

数据流：读取 vim_enabled → 如果开启，就把 vim_mode 设为 Insert 并清掉待处理命令 → 文本不变。

调用关系：它配合 enter_vim_normal_mode 使用；Vim 命令或外层控制可调用它改变输入方式。

fn enter_vim_normal_mode(&mut self)

作用：在 Vim 开启时切回普通模式，让后续按键变成移动、删除、复制等命令。

数据流：读取 vim_enabled → 如果开启，设置 Normal，清掉待处理命令和垂直移动记忆列 → 文本不变。

调用关系：handle_vim_insert 在收到 Esc 时会调用它；这是从打字状态回到命令状态的关键切换点。

调用图：被 1 处调用（handle_vim_insert）。

fn allows_paste_burst(&self) -> bool

作用：判断现在是否允许一次性粘贴一大段文字。Vim 普通模式下粘贴原始字符可能会被误当命令，所以要拦住。

数据流：读取 Vim 开关和当前模式 → 非 Vim 或 Vim 插入模式返回 true，否则 false → 不改状态。

调用关系：handle_key_event_at 会用它决定粘贴事件该不该直接送进文本框。

调用图：被 1 处调用（handle_key_event_at）。

fn uses_vim_insert_cursor(&self) -> bool

作用：判断当前是否应该使用 Vim 插入模式的光标样式。界面可以据此改变光标显示。

数据流：读取 vim_enabled 和 vim_mode → 如果 Vim 开启且处于 Insert 就返回 true → 不改状态。

调用关系：它是给渲染或外层状态栏使用的查询函数；模式变化由 Vim 输入处理函数维护。

fn should_handle_vim_insert_escape(&self, event: KeyEvent) -> bool

作用：判断某个按键事件是不是 Vim 插入模式里的 Esc。它用来把 Esc 解释成“退出插入模式”，而不是普通字符。

数据流：输入一个 KeyEvent → 检查 Vim 是否开启、是否插入模式、是否无修饰 Esc、是否按下或重复 → 返回是否应处理。

调用关系：外层按键处理可先问它；真正切换模式由 handle_vim_insert 或 enter_vim_normal_mode 完成。

调用图：外部调用 1 个（matches!）。

fn vim_mode_label(&self) -> Option<&'static str>

作用：返回当前 Vim 模式的显示文字，比如 Normal 或 Insert。状态栏显示模式时会用到。

数据流：读取 Vim 开关和模式 → 关闭时返回 None，开启时返回固定英文标签 → 不改状态。

调用关系：它服务于界面展示；模式由 set_vim_enabled 和 Vim 输入处理改变。

fn text(&self) -> &str

作用：把当前输入框里的完整文本借出去看。提交、渲染或查找当前 token 时会用它。

数据流：读取内部 text 字符串 → 返回只读引用 → 不修改文本框。

调用关系：current_prefixed_token_range、handle_key_event_at、render、submit 等上层流程会调用它拿到当前内容。

调用图：被 5 处调用（current_prefixed_token_range, handle_key_event_at, render, render, submit）。

fn insert_str(&mut self, text: &str)

作用：在当前光标位置插入一段文字。普通打字和粘贴都会走这条路。

数据流：输入要插入的字符串 → 使用当前 cursor_pos 作为位置，交给 insert_str_at → 文本变长，光标和元素位置随之更新。

调用关系：input_with_keymap、handle_paste、yank、paste_after_cursor 等会调用它；具体安全插入由 insert_str_at 完成。

调用图：调用 1 个内部函数（insert_str_at）；被 6 处调用（handle_key_event_at, handle_paste, handle_paste, input_with_keymap, paste_after_cursor, yank）。

fn insert_str_at(&mut self, pos: usize, text: &str)

作用：在指定位置插入文字，并保证不会插进半个字符或特殊元素中间。它是所有插入操作的底层入口。

数据流：输入位置和文字 → 先把位置修正到可插入边界，插入字符串，清掉换行缓存，必要时移动光标，平移后面的元素范围 → 文本和结构同步更新。

调用关系：insert_str、insert_element、Vim 打开新行和行粘贴都会用它；它调用 clamp_pos_for_insertion 和 shift_elements 做安全处理。

调用图：调用 2 个内部函数（clamp_pos_for_insertion, shift_elements）；被 4 处调用（handle_vim_normal, insert_element, insert_str, paste_line_after_current_line）。

fn replace_range(&mut self, range: std::ops::Range<usize>, text: &str)

作用：把一段文本替换成另一段，并且尊重特殊元素边界。外部删除单字时也会用它。

数据流：输入要替换的字节范围和新文字 → 先把范围扩展到完整覆盖相交元素 → 交给 replace_range_raw 真正替换。

调用关系：delete_backward 和 delete_forward 调用它；它防止调用者只删掉图片占位符的一半。

调用图：调用 2 个内部函数（expand_range_to_element_boundaries, replace_range_raw）；被 2 处调用（delete_backward, delete_forward）。

fn replace_range_raw(&mut self, range: std::ops::Range<usize>, text: &str)

作用：真正执行范围替换，并同步更新光标、换行缓存和元素范围。它假设调用者已经决定好范围。

数据流：输入范围和新文字 → 裁剪范围到文本长度，替换字符串，更新元素，按替换前后长度差调整光标，再把光标挪出元素内部 → 内部文本状态改变。

调用关系：replace_range 和 kill_range_with_kind 调用它；它把元素更新交给 update_elements_after_replace。

调用图：调用 2 个内部函数（clamp_pos_to_nearest_boundary, update_elements_after_replace）；被 2 处调用（kill_range_with_kind, replace_range）；外部调用 1 个（assert!）。

fn cursor(&self) -> usize

作用：返回当前光标在字符串里的字节位置。需要知道插入点在哪里的功能会用它。

数据流：读取 cursor_pos → 返回这个数字 → 不改状态。

调用关系：current_prefixed_token_range 和 handle_remote_image_selection_key 等外层逻辑用它定位当前上下文。

调用图：被 2 处调用（current_prefixed_token_range, handle_remote_image_selection_key）。

fn set_cursor(&mut self, pos: usize)

作用：把光标放到指定位置，同时修正到安全边界。这样调用者不用担心把光标放进半个字符或元素内部。

数据流：输入目标位置 → 限制在文本长度内，再贴到最近合法边界，清掉垂直移动记忆列 → 更新 cursor_pos。

调用关系：Vim、普通移动、插入元素、粘贴等许多流程都会调用它；它依赖 clamp_pos_to_nearest_boundary。

调用图：调用 1 个内部函数（clamp_pos_to_nearest_boundary）；被 8 处调用（handle_vim_normal, input_with_keymap, insert_element, move_cursor_to_beginning_of_line, move_cursor_to_end_of_line, paste_after_cursor, paste_line_after_current_line, target_for_motion）。

fn desired_height(&self, width: u16) -> u16

作用：计算在给定宽度下，这个文本框显示完整内容需要多少行高。布局系统可以用它决定输入框高度。

数据流：输入宽度 → 取得按该宽度折行后的行列表 → 返回行数。

调用关系：input_height 会调用它；折行计算由 wrapped_lines 负责，并带缓存。

调用图：调用 1 个内部函数（wrapped_lines）；被 2 处调用（input_height, input_height）。

fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)>

作用：计算光标在屏幕区域里的坐标。终端界面需要它把真实光标画到正确位置。

数据流：输入屏幕矩形 area → 使用默认滚动状态调用 cursor_pos_with_state → 返回可见坐标或 None。

调用关系：它是 cursor_pos_with_state 的简化入口；渲染或光标定位代码会用它。

调用图：调用 1 个内部函数（cursor_pos_with_state）；外部调用 1 个（default）。

fn cursor_pos_with_state(&self, area: Rect, state: TextAreaState) -> Option<(u16, u16)>

作用：在考虑换行和滚动后，算出光标应该显示在屏幕上的哪一列哪一行。

数据流：输入显示区域和滚动状态 → 取折行结果，修正滚动，让光标所在行可见，再计算光标前文字宽度 → 返回屏幕坐标。

调用关系：cursor_pos 调用它；它和 render_ref 使用同一套 wrapped_lines、effective_scroll 逻辑，保证画出来和光标位置一致。

调用图：调用 2 个内部函数（effective_scroll, wrapped_lines）；被 3 处调用（cursor_pos, cursor_pos, cursor_pos）；外部调用 1 个（wrapped_line_index_by_start）。

fn is_empty(&self) -> bool

作用：判断文本框当前是不是空的。提交按钮、占位提示等逻辑可能会用到。

数据流：读取 text → 返回是否为空字符串 → 不改状态。

调用关系：这是简单查询函数，供外层逻辑判断当前输入状态。

fn current_display_col(&self) -> usize

作用：计算光标在当前逻辑行里的显示列数。这里的列不是字节数，而是屏幕上占几格。

数据流：读取当前行开头到光标之间的文字 → 按字符显示宽度相加 → 返回列号。

调用关系：move_cursor_up 和 move_cursor_down 用它记住垂直移动时想保持的列。

调用图：调用 1 个内部函数（beginning_of_current_line）；被 2 处调用（move_cursor_down, move_cursor_up）。

fn wrapped_line_index_by_start(lines: &[Range<usize>], pos: usize) -> Option<usize>

作用：根据一个文本位置，找它属于哪一条折行后的可视行。折行后，一行长文字可能变成多条屏幕行。

数据流：输入折行范围列表和位置 → 用二分式查找找到最后一个起点不大于该位置的范围 → 返回行索引或 None。

调用关系：cursor_pos_with_state、上下移动、effective_scroll 都用它把字节位置映射到屏幕行。

调用图：外部调用 1 个（partition_point）。

fn move_to_display_col_on_line(
        &mut self,
        line_start: usize,
        line_end: usize,
        target_col: usize,
    )

作用：把光标移动到某一行里尽量接近目标显示列的位置。上下移动时用它保持“同一列”的感觉。

数据流：输入行起止范围和目标列 → 按字形逐个累计显示宽度，找到超过目标列的位置 → 设置光标，并修正到安全边界。

调用关系：move_cursor_up 和 move_cursor_down 调用它；它会调用 clamp_pos_to_nearest_boundary 避免落入元素中间。

调用图：调用 1 个内部函数（clamp_pos_to_nearest_boundary）；被 2 处调用（move_cursor_down, move_cursor_up）。

fn beginning_of_line(&self, pos: usize) -> usize

作用：找某个位置所在行的开头。行开头就是前一个换行符之后的位置。

数据流：输入字节位置 → 在它前面的文本里倒着找换行符 → 返回行开头位置，找不到就返回 0。

调用关系：beginning_of_current_line、行级 Vim 操作和移动到行首都会用它。

调用图：被 3 处调用（beginning_of_current_line, linewise_range_for_vertical_motion, move_cursor_to_beginning_of_line）。

fn beginning_of_current_line(&self) -> usize

作用：找当前光标所在行的开头。很多按行操作都要先知道这一点。

数据流：读取 cursor_pos → 调用 beginning_of_line → 返回当前行起点。

调用关系：当前列计算、删到行首、Vim 行首移动、当前行范围计算等都会调用它。

调用图：调用 1 个内部函数（beginning_of_line）；被 9 处调用（current_display_col, current_line_range_with_newline, first_non_blank_of_current_line, handle_vim_insert, handle_vim_normal, kill_to_beginning_of_line, move_cursor_to_beginning_of_line, target_for_motion, vim_line_end_cursor）。

fn first_non_blank_of_current_line(&self) -> usize

作用：找到当前行第一个不是空白的字符位置。Vim 的 I 命令通常会跳到这里开始插入。

数据流：取得当前行起点和终点 → 从行内往后找第一个非空白字符 → 找到就返回位置，否则返回行尾。

调用关系：handle_vim_normal 在处理插入到行首非空白处时调用它。

调用图：调用 2 个内部函数（beginning_of_current_line, end_of_current_line）；被 1 处调用（handle_vim_normal）。

fn end_of_line(&self, pos: usize) -> usize

作用：找某个位置所在行的行尾，也就是下一个换行符之前的位置。

数据流：输入位置 → 从该位置往后找换行符 → 返回换行符位置，找不到就返回文本末尾。

调用关系：end_of_current_line、行级范围、移动到行尾等函数会用它。

调用图：被 3 处调用（end_of_current_line, linewise_range_for_vertical_motion, move_cursor_to_end_of_line）。

fn end_of_current_line(&self) -> usize

作用：找当前光标所在行的行尾。删除到行尾、粘贴整行、Vim 行尾移动都靠它定位。

数据流：读取 cursor_pos → 调用 end_of_line → 返回当前行结束位置。

调用关系：kill_to_end_of_line、paste_line_after_current_line、handle_vim_normal 等都会调用它。

调用图：调用 1 个内部函数（end_of_line）；被 9 处调用（current_line_range_with_newline, first_non_blank_of_current_line, handle_vim_normal, kill_to_end_of_line, move_cursor_to_end_of_line, paste_line_after_current_line, target_for_motion, vim_kill_to_end_of_line, vim_line_end_cursor）。

fn input(&mut self, event: KeyEvent)

作用：接收一个键盘事件，并把它送到正确的编辑模式里处理。它是文本框按键处理的总入口。

数据流：输入 KeyEvent → 忽略松键事件，只处理按下和重复；如果 Vim 开启就交给 Vim 流程，否则按普通键位表处理 → 文本或光标可能改变。

调用关系：handle_key_event_at 和 handle_key_event 会调用它；它再分发给 handle_vim_input 或 input_with_keymap。

调用图：调用 2 个内部函数（handle_vim_input, input_with_keymap）；被 2 处调用（handle_key_event_at, handle_key_event）；外部调用 2 个（matches!, clone）。

fn input_with_keymap(&mut self, event: KeyEvent, keymap: &EditorKeymap)

作用：按普通编辑器的快捷键表解释一个按键，比如回车、退格、移动、剪切、粘贴和输入字符。

数据流：输入 KeyEvent 和编辑键位表 → 按优先级匹配各种快捷键；匹配后执行插入、删除、移动或 yank；普通字符会插入文本 → 状态按具体动作变化。

调用关系：普通 input 会调用它，Vim 插入模式也会调用它；它把具体工作交给 delete_backward、insert_str、move_cursor_left 等编辑函数。

调用图：调用 19 个内部函数（beginning_of_previous_word, delete_backward, delete_backward_word, delete_forward, delete_forward_word, end_of_next_word, insert_str, kill_current_line, kill_to_beginning_of_line, kill_to_end_of_line (+9 more)）；被 2 处调用（handle_vim_insert, input）；外部调用 2 个（matches!, debug!）。

fn handle_vim_input(&mut self, event: KeyEvent)

作用：把 Vim 模式下的按键分给插入模式或普通模式处理。它是 Vim 按键处理的小分发器。

数据流：输入 KeyEvent → 查看当前 vim_mode → Insert 交给 handle_vim_insert，Normal 交给 handle_vim_normal。

调用关系：input 在 Vim 开启时调用它；真正的编辑动作由两个模式处理函数继续完成。

调用图：调用 2 个内部函数（handle_vim_insert, handle_vim_normal）；被 1 处调用（input）。

fn handle_vim_insert(&mut self, event: KeyEvent)

作用：处理 Vim 插入模式里的按键。大多数键像普通编辑器一样输入，Esc 会回到普通模式。

数据流：输入 KeyEvent → 如果是 Esc，光标按 Vim 习惯退到前一个字符并切普通模式；否则用普通键位表处理 → 文本或模式可能改变。

调用关系：handle_vim_input 调用它；它会调用 enter_vim_normal_mode 或 input_with_keymap。

调用图：调用 4 个内部函数（beginning_of_current_line, enter_vim_normal_mode, input_with_keymap, prev_atomic_boundary）；被 1 处调用（handle_vim_input）；外部调用 2 个（matches!, clone）。

fn handle_vim_normal(&mut self, event: KeyEvent)

作用：处理 Vim 普通模式里的命令键，比如 h/j/k/l 移动、w 跳词、x 删除、p 粘贴、d/y/c 等操作符。它让输入框像 Vim 那样先发命令再改文本。

数据流：输入 KeyEvent → 先处理上一次遗留的操作符或文本对象；否则按 Vim 普通模式键位逐项匹配 → 更新光标、切模式、删除、复制、粘贴或记录待完成命令。

调用关系：handle_vim_input 在普通模式下调用它；它会把复杂命令继续交给 handle_vim_operator、handle_vim_text_object 和各类移动/删除函数。

调用图：调用 20 个内部函数（beginning_of_current_line, beginning_of_next_word, beginning_of_previous_word, delete_forward_kill, end_of_current_line, first_non_blank_of_current_line, handle_vim_operator, handle_vim_text_object, insert_str_at, move_cursor_down (+10 more)）；被 1 处调用（handle_vim_input）；外部调用 2 个（replace, Operator）。

fn handle_vim_operator(&mut self, op: VimOperator, event: KeyEvent) -> bool

作用：处理 Vim 里已经按下 d、y 这类操作符之后的第二个键。比如 dd 删除整行，yw 复制到下一个词。

数据流：输入操作符和按键 → 识别整行操作、取消、文本对象开头或移动命令 → 执行对应操作，或记录还在等待文本对象 → 返回是否处理成功。

调用关系：handle_vim_normal 在发现有待处理操作符时调用它；它会调用 kill_current_line、yank_current_line、vim_motion_for_event、apply_vim_operator。

调用图：调用 4 个内部函数（apply_vim_operator, kill_current_line, vim_motion_for_event, yank_current_line）；被 1 处调用（handle_vim_normal）。

fn handle_vim_text_object(
        &mut self,
        op: VimOperator,
        scope: VimTextObjectScope,
        event: KeyEvent,
    ) -> bool

作用：处理 Vim 文本对象命令，比如“删除括号内内容”这类先选范围再操作的命令。

数据流：输入操作符、范围类型和按键 → 如果取消就结束；否则把按键识别成文本对象，找到对应文本范围，再应用删除、复制或修改 → 文本或剪切板可能改变。

调用关系：handle_vim_normal 在等待文本对象时调用它；它把最终执行交给 apply_vim_operator_to_range。

调用图：调用 1 个内部函数（apply_vim_operator_to_range）；被 1 处调用（handle_vim_normal）。

fn vim_motion_for_event(&self, event: KeyEvent) -> Option<VimMotion>

作用：把一个 Vim 按键翻译成抽象移动动作，比如左、右、上、下、到词尾、到行尾。

数据流：输入 KeyEvent → 按 Vim 操作符键位表逐项匹配 → 返回 VimMotion 或 None。

调用关系：handle_vim_operator 用它理解 d 后面的 w、$ 等键；真正算范围由 range_for_motion 完成。

调用图：被 1 处调用（handle_vim_operator）。

fn apply_vim_operator(&mut self, op: VimOperator, motion: VimMotion)

作用：把 Vim 操作符应用到某个移动动作形成的范围上。比如 d+w 会先算范围再删除。

数据流：输入操作符和移动动作 → 计算该动作覆盖的文本范围；Delete 删除并存入剪切板，Yank 只复制，Change 在这里不处理 → 文本或剪切板可能改变。

调用关系：handle_vim_operator 调用它；它依赖 range_for_motion、kill_range 和 yank_range。

调用图：调用 3 个内部函数（kill_range, range_for_motion, yank_range）；被 1 处调用（handle_vim_operator）。

fn apply_vim_operator_to_range(&mut self, op: VimOperator, range: Range<usize>)

作用：把 Vim 操作符直接应用到已经算好的文本范围上。文本对象命令会用这种方式。

数据流：输入操作符和范围 → Delete 删除，Yank 复制，Change 删除后切到插入模式 → 文本、剪切板或模式可能改变。

调用关系：handle_vim_text_object 调用它；它最终使用 kill_range 或 yank_range 完成实际改动。

调用图：调用 2 个内部函数（kill_range, yank_range）；被 1 处调用（handle_vim_text_object）。

fn range_for_motion(&mut self, motion: VimMotion) -> Option<Range<usize>>

作用：根据 Vim 的一个移动动作，算出从当前光标到目标位置之间的范围。删除或复制移动范围时要先用它。

数据流：输入 VimMotion → 上下移动按整行范围处理；其他移动先算目标位置，再把起点终点排好 → 返回范围或 None。

调用关系：apply_vim_operator 调用它；它把上下移动交给 linewise_range_for_vertical_motion，其他交给 target_for_motion。

调用图：调用 2 个内部函数（linewise_range_for_vertical_motion, target_for_motion）；被 1 处调用（apply_vim_operator）；外部调用 1 个（matches!）。

fn linewise_range_for_vertical_motion(&self, motion: VimMotion) -> Option<Range<usize>>

作用：给 Vim 的上移/下移操作算整行范围。因为 d+j 这类命令按 Vim 习惯是删整行，不是删一个矩形区域。

数据流：输入移动方向 → 取当前行范围；向上扩展到上一行开头，向下扩展到下一行结尾 → 返回非空范围。

调用关系：range_for_motion 在处理 Up 或 Down 时调用它；它依赖 beginning_of_line、end_of_line 和 current_line_range_with_newline。

调用图：调用 3 个内部函数（beginning_of_line, current_line_range_with_newline, end_of_line）；被 1 处调用（range_for_motion）。

fn target_for_motion(&mut self, motion: VimMotion) -> usize

作用：临时执行一次移动，只为了知道目标位置在哪里，然后把光标恢复原样。这样算删除范围时不会提前真的移动光标。

数据流：输入移动动作 → 保存当前光标和记忆列，执行对应移动，记下目标位置，再恢复原状态 → 返回目标位置。

调用关系：range_for_motion 调用它；它复用现有 move_cursor_* 和词/行定位函数，避免重复写移动规则。

调用图：调用 10 个内部函数（beginning_of_current_line, beginning_of_next_word, beginning_of_previous_word, end_of_current_line, move_cursor_down, move_cursor_left, move_cursor_right, move_cursor_up, set_cursor, vim_word_end_exclusive）；被 1 处调用（range_for_motion）。

fn delete_backward(&mut self, n: usize)

作用：从光标前面删除 n 个“原子单位”。原子单位可以是一个完整字形，也可以是一个特殊元素整体。

数据流：输入数量 n → 从当前光标往前跳 n 次安全边界 → 用 replace_range 删除这段内容 → 文本变短，光标和元素更新。

调用关系：input_with_keymap 在退格时调用它；它依赖 prev_atomic_boundary 和 replace_range。

调用图：调用 2 个内部函数（prev_atomic_boundary, replace_range）；被 1 处调用（input_with_keymap）。

fn delete_forward(&mut self, n: usize)

作用：从光标后面删除 n 个完整单位，类似 Delete 键。不会删半个 emoji 或半个特殊元素。

数据流：输入数量 n → 从光标往后找 n 次安全边界 → 用 replace_range 删除光标到目标之间内容 → 文本和元素更新。

调用关系：input_with_keymap 在前删键时调用它；它依赖 next_atomic_boundary 和 replace_range。

调用图：调用 2 个内部函数（next_atomic_boundary, replace_range）；被 1 处调用（input_with_keymap）。

fn delete_forward_kill(&mut self, n: usize)

作用：向前删除 n 个单位，并把删掉的内容放进剪切板。Vim 的 x 这类命令会用它。

数据流：输入数量 n → 找到向后的安全目标位置 → kill_range 删除并保存这段文字 → 文本变短，剪切板更新。

调用关系：handle_vim_normal 调用它；它和普通 delete_forward 的区别是会记录 kill buffer。

调用图：调用 2 个内部函数（kill_range, next_atomic_boundary）；被 1 处调用（handle_vim_normal）。

fn delete_backward_word(&mut self)

作用：删除光标前的一个词，并把删除内容记入剪切板。常见于 Ctrl+Backspace 这类快捷键。

数据流：读取当前光标 → 找上一个词的开头 → kill_range 删除从那里到光标的内容 → 文本和剪切板更新。

调用关系：input_with_keymap 调用它；词边界由 beginning_of_previous_word 计算。

调用图：调用 2 个内部函数（beginning_of_previous_word, kill_range）；被 1 处调用（input_with_keymap）。

fn delete_forward_word(&mut self)

作用：删除光标后的一个词，并把删除内容记入剪切板。常见于向前删词快捷键。

数据流：读取当前光标 → 找下一个词的结束位置 → 如果确实在光标后，就 kill_range 删除 → 文本和剪切板更新。

调用关系：input_with_keymap 调用它；词尾由 end_of_next_word 计算。

调用图：调用 2 个内部函数（end_of_next_word, kill_range）；被 1 处调用（input_with_keymap）。

fn kill_to_end_of_line(&mut self)

作用：删除从光标到行尾的内容，并保存到剪切板；如果已经在行尾，就删除换行符。类似命令行里的 Ctrl+K。

数据流：读取当前光标和行尾 → 选择光标到行尾或行尾换行符范围 → kill_range 删除并保存 → 文本变短。

调用关系：input_with_keymap 调用它；Vim 版本有单独的 vim_kill_to_end_of_line。

调用图：调用 2 个内部函数（end_of_current_line, kill_range）；被 1 处调用（input_with_keymap）。

fn vim_kill_to_end_of_line(&mut self)

作用：按 Vim 规则删除从光标到当前行尾的内容。它不会在光标正好在行尾时额外删掉换行符。

数据流：读取行尾 → 如果光标在行尾前，就 kill_range 删除到行尾 → 文本和剪切板更新，否则不动。

调用关系：handle_vim_normal 处理 D 或 C 这类到行尾命令时调用它。

调用图：调用 2 个内部函数（end_of_current_line, kill_range）；被 1 处调用（handle_vim_normal）。

fn kill_to_beginning_of_line(&mut self)

作用：删除从行首到光标的内容，并保存到剪切板；如果已经在行首，就删除前面的换行符。类似命令行里的 Ctrl+U。

数据流：读取当前行首和光标 → 选择行首到光标或前一个换行符范围 → kill_range 删除并保存 → 文本变短。

调用关系：input_with_keymap 调用它；它依赖 beginning_of_current_line。

调用图：调用 2 个内部函数（beginning_of_current_line, kill_range）；被 1 处调用（input_with_keymap）。

fn yank(&mut self)

作用：把剪切板里的内容插回当前光标位置。这里的 yank 是 Emacs/Vim 里“粘贴刚删或刚复制内容”的意思。

数据流：读取 kill_buffer → 如果为空就不动；否则复制一份内容并 insert_str 插入 → 文本变长。

调用关系：input_with_keymap 在 yank 快捷键触发时调用它；插入细节交给 insert_str。

调用图：调用 1 个内部函数（insert_str）；被 1 处调用（input_with_keymap）。

fn kill_range(&mut self, range: Range<usize>)

作用：删除一段字符级范围，并把内容存入剪切板。字符级表示粘贴时按普通文本插入。

数据流：输入范围 → 交给 kill_range_with_kind，标记为 Characterwise → 文本和剪切板可能改变。

调用关系：多个删除词、删除到行首/行尾、Vim 删除操作都会调用它。

调用图：调用 1 个内部函数（kill_range_with_kind）；被 8 处调用（apply_vim_operator, apply_vim_operator_to_range, delete_backward_word, delete_forward_kill, delete_forward_word, kill_to_beginning_of_line, kill_to_end_of_line, vim_kill_to_end_of_line）。

fn kill_line_range(&mut self, range: Range<usize>)

作用：删除一整行范围，并把内容按“整行”类型存入剪切板。这样 Vim 的 p 粘贴时会贴到下一行。

数据流：输入行范围 → 交给 kill_range_with_kind，标记为 Linewise → 文本和剪切板更新。

调用关系：kill_current_line 调用它；paste_after_cursor 会根据这个类型选择行粘贴。

调用图：调用 1 个内部函数（kill_range_with_kind）；被 1 处调用（kill_current_line）。

fn kill_range_with_kind(&mut self, range: Range<usize>, kind: KillBufferKind)

作用：删除指定范围、保存删除内容，并记录这次剪切是字符级还是整行级。它是各种 kill 操作的核心。

数据流：输入范围和剪切类型 → 扩展范围以完整覆盖特殊元素，取出被删文字，存入 kill_buffer，再用 replace_range_raw 删除 → 文本和剪切板同步更新。

调用关系：kill_range 和 kill_line_range 都调用它；它会调用 expand_range_to_element_boundaries、store_kill_buffer、replace_range_raw。

调用图：调用 3 个内部函数（expand_range_to_element_boundaries, replace_range_raw, store_kill_buffer）；被 2 处调用（kill_line_range, kill_range）；外部调用 1 个（clone）。

fn yank_range(&mut self, range: Range<usize>)

作用：复制一段字符级范围到剪切板，但不删除原文。Vim 的 y 加移动命令会用它。

数据流：输入范围 → 交给 yank_range_with_kind，标记为 Characterwise → 文本不变，剪切板可能更新。

调用关系：apply_vim_operator 调用它；实际复制逻辑在 yank_range_with_kind。

调用图：调用 1 个内部函数（yank_range_with_kind）；被 2 处调用（apply_vim_operator, apply_vim_operator_to_range）。

fn yank_line_range(&mut self, range: Range<usize>)

作用：复制一整行范围到剪切板，并标记为整行。这样之后粘贴会按行处理。

数据流：输入行范围 → 交给 yank_range_with_kind，标记为 Linewise → 文本不变，剪切板更新。

调用关系：yank_current_line 调用它；paste_after_cursor 根据保存的类型决定粘贴方式。

调用图：调用 1 个内部函数（yank_range_with_kind）；被 1 处调用（yank_current_line）。

fn yank_range_with_kind(&mut self, range: Range<usize>, kind: KillBufferKind)

作用：复制指定范围到剪切板，并记录复制类型。它不会改变文本内容。

数据流：输入范围和类型 → 扩展范围以完整包含特殊元素，取出字符串，存入 kill_buffer 和类型 → 输出体现在内部剪切板状态上。

调用关系：yank_range 和 yank_line_range 调用它；它复用 expand_range_to_element_boundaries 和 store_kill_buffer。

调用图：调用 2 个内部函数（expand_range_to_element_boundaries, store_kill_buffer）；被 2 处调用（yank_line_range, yank_range）。

fn store_kill_buffer(&mut self, text: String, kind: KillBufferKind)

作用：保存最近一次删除或复制的文字，以及它是字符级还是整行级。后续粘贴要靠这份记录。

数据流：输入字符串和类型 → 覆盖 kill_buffer 与 kill_buffer_kind → 不改变可见文本。

调用关系：kill_range_with_kind 和 yank_range_with_kind 调用它；yank、paste_after_cursor 会读取保存结果。

调用图：被 2 处调用（kill_range_with_kind, yank_range_with_kind）。

fn paste_after_cursor(&mut self)

作用：按 Vim 的 p 规则在光标后粘贴。字符级内容贴在下一个字符位置，整行内容贴到当前行之后。

数据流：读取 kill_buffer 和类型 → 空则不动；整行则调用 paste_line_after_current_line；字符级则移动到下一个安全边界后插入 → 文本变长。

调用关系：handle_vim_normal 处理 paste_after 时调用它；它依赖 next_atomic_boundary、set_cursor、insert_str。

调用图：调用 4 个内部函数（insert_str, next_atomic_boundary, paste_line_after_current_line, set_cursor）；被 1 处调用（handle_vim_normal）。

fn paste_line_after_current_line(&mut self)

作用：把整行剪切板内容粘贴到当前行下面，并处理末尾有没有换行的小差异。

数据流：读取当前行尾和 kill_buffer → 计算插入点、光标应落位置和需要补的换行 → insert_str_at 插入，再 set_cursor → 文本和光标更新。

调用关系：paste_after_cursor 在剪切板类型是 Linewise 时调用它。

调用图：调用 3 个内部函数（end_of_current_line, insert_str_at, set_cursor）；被 1 处调用（paste_after_cursor）；外部调用 1 个（format!）。

fn yank_current_line(&mut self)

作用：复制当前整行到剪切板。Vim 的 yy 会走这里。

数据流：计算当前行含换行符的范围 → yank_line_range 保存 → 文本不变，剪切板更新。

调用关系：handle_vim_normal 和 handle_vim_operator 调用它；范围由 current_line_range_with_newline 提供。

调用图：调用 2 个内部函数（current_line_range_with_newline, yank_line_range）；被 2 处调用（handle_vim_normal, handle_vim_operator）。

fn kill_current_line(&mut self)

作用：删除当前整行，并按整行类型保存到剪切板。Vim 的 dd 或普通整行剪切会用它。

数据流：计算当前行含换行符的范围 → kill_line_range 删除并保存 → 文本变短，剪切板更新。

调用关系：handle_vim_operator 和 input_with_keymap 调用它；范围来自 current_line_range_with_newline。

调用图：调用 2 个内部函数（current_line_range_with_newline, kill_line_range）；被 2 处调用（handle_vim_operator, input_with_keymap）。

fn current_line_range_with_newline(&self) -> Range<usize>

作用：返回当前行的范围，并尽量把行尾换行符也包括进去。整行删除或复制时需要这个范围。

数据流：读取当前行首和行尾 → 如果行尾后还有内容，就把换行符也纳入范围 → 返回 Range。

调用关系：kill_current_line、yank_current_line 和 linewise_range_for_vertical_motion 都用它。

调用图：调用 2 个内部函数（beginning_of_current_line, end_of_current_line）；被 3 处调用（kill_current_line, linewise_range_for_vertical_motion, yank_current_line）。

fn move_cursor_left(&mut self)

作用：把光标向左移动一个完整单位。不会停在 emoji 或特殊元素的中间。

数据流：读取 cursor_pos → 用 prev_atomic_boundary 找左侧安全位置 → 更新光标并清掉垂直移动记忆列。

调用关系：普通键位、Vim 普通模式和 target_for_motion 都会调用它。

调用图：调用 1 个内部函数（prev_atomic_boundary）；被 3 处调用（handle_vim_normal, input_with_keymap, target_for_motion）。

fn move_cursor_right(&mut self)

作用：把光标向右移动一个完整单位。它把特殊元素当成一个整体跳过。

数据流：读取 cursor_pos → 用 next_atomic_boundary 找右侧安全位置 → 更新光标并清掉垂直移动记忆列。

调用关系：普通键位、Vim 普通模式和 target_for_motion 都会调用它。

调用图：调用 1 个内部函数（next_atomic_boundary）；被 3 处调用（handle_vim_normal, input_with_keymap, target_for_motion）。

fn move_cursor_up(&mut self)

作用：把光标向上一行移动，并尽量保持原来的显示列。它优先按屏幕折行后的“可视行”移动。

数据流：读取换行缓存、光标和目标列 → 如果有折行信息就移动到上一条可视行同列；否则按真实换行符的逻辑行移动 → 更新光标和 preferred_col。

调用关系：input_with_keymap、handle_vim_normal 和 target_for_motion 调用它；它使用 current_display_col、wrapped_line_index_by_start、move_to_display_col_on_line。

调用图：调用 2 个内部函数（current_display_col, move_to_display_col_on_line）；被 3 处调用（handle_vim_normal, input_with_keymap, target_for_motion）；外部调用 1 个（wrapped_line_index_by_start）。

fn move_cursor_down(&mut self)

作用：把光标向下一行移动，并尽量保持原来的显示列。长行自动换行时，它按屏幕看到的行移动。

数据流：读取换行缓存、光标和目标列 → 有折行信息就去下一条可视行；没有就按换行符找下一逻辑行 → 更新光标和 preferred_col。

调用关系：input_with_keymap、handle_vim_normal 和 target_for_motion 调用它；逻辑和 move_cursor_up 对称。

调用图：调用 2 个内部函数（current_display_col, move_to_display_col_on_line）；被 3 处调用（handle_vim_normal, input_with_keymap, target_for_motion）；外部调用 1 个（wrapped_line_index_by_start）。

fn move_cursor_to_beginning_of_line(&mut self, move_up_at_bol: bool)

作用：把光标移到当前行开头；某些快捷键在已经处于行首时还会跳到上一行开头。

数据流：输入是否允许行首再上移 → 计算当前行首；如果允许且已在行首，就找上一行行首，否则设为当前行首 → 更新光标。

调用关系：input_with_keymap 处理行首快捷键时调用它；它使用 beginning_of_current_line、beginning_of_line、set_cursor。

调用图：调用 3 个内部函数（beginning_of_current_line, beginning_of_line, set_cursor）；被 1 处调用（input_with_keymap）。

fn move_cursor_to_end_of_line(&mut self, move_down_at_eol: bool)

作用：把光标移到当前行尾；某些快捷键在已经处于行尾时还会跳到下一行行尾。

数据流：输入是否允许行尾再下移 → 计算当前行尾；如果允许且已在行尾，就找下一行行尾，否则设为当前行尾 → 更新光标。

调用关系：input_with_keymap 处理行尾快捷键时调用它；它依赖 end_of_current_line、end_of_line、set_cursor。

调用图：调用 3 个内部函数（end_of_current_line, end_of_line, set_cursor）；被 1 处调用（input_with_keymap）。

fn element_payloads(&self) -> Vec<String>

作用：取出所有特殊元素当前对应的文本内容。比如图片占位符保存成文本时，可以列出来。

数据流：读取 elements 列表 → 对每个范围从 text 里切出字符串，范围无效就跳过 → 返回字符串列表。

调用关系：它是元素信息的查询接口；不改变文本框状态。

fn text_elements(&self) -> Vec<UserTextElement>

作用：把内部特殊元素转换成对外使用的 UserTextElement 列表，包含字节范围和占位文本。

数据流：读取每个内部元素 → 根据 range 取出对应文本，包装成 UserTextElement → 返回列表。

调用关系：外层需要保存或传递输入框里的元素信息时会调用它。

fn text_element_snapshots(&self) -> Vec<TextElementSnapshot>

作用：生成特殊元素的快照，带 id、范围和当前文本。快照适合后续比较或渲染辅助使用。

数据流：读取 elements 和 text → 对每个有效范围生成 TextElementSnapshot → 返回快照列表。

调用关系：它是内部查询接口；element_id_for_exact_range 等功能可配合它识别元素。

fn element_id_for_exact_range(&self, range: Range<usize>) -> Option<u64>

作用：查找某个精确范围对应的特殊元素 id。调用者已知道范围时，可以用它确认是哪一个元素。

数据流：输入范围 → 遍历元素列表找 range 完全相等的一项 → 返回 id 或 None。

调用关系：这是元素定位工具；它不改变状态，只帮助外层把范围和元素身份关联起来。

fn replace_element_payload(&mut self, old: &str, new: &str) -> bool

作用：把某个特殊元素的占位文本从旧值替换成新值，并保持元素范围和后续元素位置正确。比如本地图片上传后改显示标签时会用到。

数据流：输入旧文本和新文本 → 找到文本完全匹配的元素，替换该范围内容，更新该元素范围，按长度差移动后面的元素和光标，清缓存并排序 → 返回是否替换成功。

调用关系：relabel_local_images 会调用它；它内部调用 clamp_pos_to_nearest_boundary 保证光标安全。

调用图：调用 1 个内部函数（clamp_pos_to_nearest_boundary）；被 1 处调用（relabel_local_images）。

fn insert_element(&mut self, text: &str) -> u64

作用：在当前光标处插入一个特殊元素文本，并把这段文本登记为不可随便拆开的元素。

数据流：输入元素显示文本 → 修正插入位置，插入文字，记录 start..end 元素范围并生成 id，把光标放到元素后面 → 返回元素 id。

调用关系：attach_image 会调用它；它组合了 insert_str_at、add_element 和 set_cursor。

调用图：调用 4 个内部函数（add_element, clamp_pos_for_insertion, insert_str_at, set_cursor）；被 1 处调用（attach_image）。

fn add_element(&mut self, range: Range<usize>) -> u64

作用：把一个范围登记成内部特殊元素，并分配唯一 id。它不负责检查范围是否合法。

数据流：输入范围 → 获取下一个元素 id，压入 elements，并按起点排序 → 返回 id。

调用关系：insert_element 和 add_element_range 调用它；id 来自 next_element_id。

调用图：调用 1 个内部函数（next_element_id）；被 2 处调用（add_element_range, insert_element）。

fn add_element_range(&mut self, range: Range<usize>) -> Option<u64>

作用：把已有文本中的一段范围标记为特殊元素，同时检查范围不能为空、重复或与别的元素重叠。

数据流：输入范围 → 修正到字符边界和文本长度内，检查有效性、重复和重叠 → 成功则 add_element 并返回 id，失败返回 None。

调用关系：外层想把已有文本片段变成元素时调用它；它依赖 clamp_pos_to_char_boundary 和 add_element。

调用图：调用 2 个内部函数（add_element, clamp_pos_to_char_boundary）。

fn remove_element_range(&mut self, range: Range<usize>) -> bool

作用：取消某个精确范围的特殊元素标记。文字本身不会被删除，只是不再被当成整体保护。

数据流：输入范围 → 修正到字符边界，找完全相同范围的元素并移除 → 返回是否真的移除了。

调用关系：这是元素维护接口；它只改 elements，不改 text。

调用图：调用 1 个内部函数（clamp_pos_to_char_boundary）。

fn next_element_id(&mut self) -> u64

作用：生成下一个特殊元素 id。每个元素有 id，方便后续识别同一个元素。

数据流：读取 next_element_id → 返回当前值，并把内部计数加 1，溢出时饱和处理 → 更新计数器。

调用关系：set_text_inner 和 add_element 会调用它给新元素编号。

调用图：被 2 处调用（add_element, set_text_inner）。

fn find_element_containing(&self, pos: usize) -> Option<usize>

作用：判断某个位置是否落在特殊元素内部。这里的内部不包括元素两端边界。

数据流：输入位置 → 遍历元素范围，找 start < pos < end 的元素 → 返回元素索引或 None。

调用关系：光标修正、插入修正、左右移动边界和词移动都会用它避免进入元素中间。

调用图：被 5 处调用（adjust_pos_out_of_elements, clamp_pos_for_insertion, clamp_pos_to_nearest_boundary, next_atomic_boundary, prev_atomic_boundary）。

fn clamp_pos_to_char_boundary(&self, pos: usize) -> usize

作用：把一个字节位置修正到最近的合法字符边界。Rust 字符串按字节存，但中文和 emoji 不能从中间切。

数据流：输入位置 → 限制在文本长度内；如果不是字符边界，就找前后最近边界并选更近的 → 返回安全位置。

调用关系：设置文本、添加元素、移除元素、设置光标等许多函数都依赖它打底。

调用图：被 5 处调用（add_element_range, clamp_pos_for_insertion, clamp_pos_to_nearest_boundary, remove_element_range, set_text_inner）。

fn clamp_pos_to_nearest_boundary(&self, pos: usize) -> usize

作用：把位置修正到既是字符边界、又不在特殊元素内部的位置。若落在元素中间，就靠近哪边贴到哪边。

数据流：输入位置 → 先修正到字符边界，再检查是否在元素内部；如果在，就比较到元素两端距离并返回最近端点 → 输出安全位置。

调用关系：set_cursor、replace_range_raw、replace_element_payload、move_to_display_col_on_line 等用它保护光标。

调用图：调用 2 个内部函数（clamp_pos_to_char_boundary, find_element_containing）；被 5 处调用（move_to_display_col_on_line, replace_element_payload, replace_range_raw, set_cursor, set_text_inner）。

fn clamp_pos_for_insertion(&self, pos: usize) -> usize

作用：把插入位置修正到安全地方，特别是不允许把新文字插进特殊元素中间。

数据流：输入位置 → 修正到字符边界；如果在元素内部，就贴到较近的元素起点或终点 → 返回可插入位置。

调用关系：insert_str_at 和 insert_element 调用它；它和 clamp_pos_to_nearest_boundary 逻辑相近，但专门服务插入。

调用图：调用 2 个内部函数（clamp_pos_to_char_boundary, find_element_containing）；被 2 处调用（insert_element, insert_str_at）。

fn expand_range_to_element_boundaries(&self, mut range: Range<usize>) -> Range<usize>

作用：把一个编辑范围扩展到完整包含所有碰到的特殊元素。这样删除、替换、复制不会只处理元素的一半。

数据流：输入范围 → 反复检查所有元素，只要范围和元素相交，就扩大到包含整个元素 → 返回最终范围。

调用关系：replace_range、kill_range_with_kind、yank_range_with_kind 都用它保证元素整体性。

调用图：被 3 处调用（kill_range_with_kind, replace_range, yank_range_with_kind）。

fn shift_elements(&mut self, at: usize, removed: usize, inserted: usize)

作用：文本插入或删除后，移动特殊元素的范围，让它们继续指向正确的文字。就像书里插了一页后，后面页码都要加一。

数据流：输入编辑起点、删除长度、插入长度 → 删除被完全覆盖的元素，按长度差平移后方元素，重叠元素则尽量修正到新边界 → 更新 elements。

调用关系：insert_str_at 和 update_elements_after_replace 调用它；它是文本变化后维护元素位置的核心。

调用图：被 2 处调用（insert_str_at, update_elements_after_replace）。

fn update_elements_after_replace(&mut self, start: usize, end: usize, inserted_len: usize)

作用：在一段文本被替换后更新元素范围。它是 replace_range_raw 里更好读的一层包装。

数据流：输入替换起点、终点和插入长度 → 计算删除长度并调用 shift_elements → elements 被调整。

调用关系：replace_range_raw 调用它；实际细节由 shift_elements 完成。

调用图：调用 1 个内部函数（shift_elements）；被 1 处调用（replace_range_raw）。

fn prev_atomic_boundary(&self, pos: usize) -> usize

作用：找到当前位置左边的上一个“不可拆单位”边界。不可拆单位可以是一个 Unicode 字形，也可以是一个特殊元素整体。

数据流：输入位置 → 如果在元素尾部或内部，直接跳到元素起点；否则用 Unicode 字形边界往前找，再避开元素内部 → 返回左侧安全位置。

调用关系：退格、左移、Vim 退出插入模式、词尾光标计算等都会调用它。

调用图：调用 1 个内部函数（find_element_containing）；被 7 处调用（delete_backward, handle_vim_insert, move_cursor_left, vim_line_end_cursor, vim_normal_end_cursor, vim_word_end_cursor, vim_word_end_exclusive）；外部调用 1 个（new）。

fn next_atomic_boundary(&self, pos: usize) -> usize

作用：找到当前位置右边的下一个完整单位边界。它保证右移或前删不会切开组合字符或特殊元素。

数据流：输入位置 → 如果在元素起点或内部，直接跳到元素终点；否则用 Unicode 字形边界往后找，再避开元素内部 → 返回右侧安全位置。

调用关系：delete_forward、move_cursor_right、paste_after_cursor 和 Vim 普通模式移动会调用它。

调用图：调用 1 个内部函数（find_element_containing）；被 5 处调用（delete_forward, delete_forward_kill, handle_vim_normal, move_cursor_right, paste_after_cursor）；外部调用 1 个（new）。

fn beginning_of_previous_word(&self) -> usize

作用：找到光标前一个词的开头。按词左移或向后删词时会用它。

数据流：读取光标前文本 → 跳过尾部空白，找到连续非空白片段，按分隔符切成小片，从后往前确定词首 → 若落入元素则挪到元素起点 → 返回位置。

调用关系：delete_backward_word、input_with_keymap、handle_vim_normal、target_for_motion 都会调用它；它使用 split_word_pieces。

调用图：调用 2 个内部函数（adjust_pos_out_of_elements, split_word_pieces）；被 4 处调用（delete_backward_word, handle_vim_normal, input_with_keymap, target_for_motion）。

fn end_of_next_word(&self) -> usize

作用：找到从当前光标开始的下一个词结尾。按词右移或向前删词时会用它。

数据流：读取当前 cursor_pos → 调用 end_of_next_word_from → 返回词尾位置。

调用关系：beginning_of_next_word、delete_forward_word、input_with_keymap、vim_word_end_exclusive 都会间接或直接用它。

调用图：调用 1 个内部函数（end_of_next_word_from）；被 4 处调用（beginning_of_next_word, delete_forward_word, input_with_keymap, vim_word_end_exclusive）。

fn end_of_next_word_from(&self, cursor_pos: usize) -> usize

作用：从指定位置开始，找到下一个词的结束位置。它支持从任意位置继续找，不只限当前光标。

数据流：输入起始位置 → 跳过空白，取下一个非空白连续片段，按分隔符切分并确定结尾；如果结尾在元素内部则挪到元素终点 → 返回位置。

调用关系：end_of_next_word 和 vim_word_end_exclusive 调用它；切词依赖 split_word_pieces。

调用图：调用 2 个内部函数（adjust_pos_out_of_elements, split_word_pieces）；被 2 处调用（end_of_next_word, vim_word_end_exclusive）。

fn vim_word_end_exclusive(&self) -> usize

作用：按 Vim 规则计算“词尾之后的位置”。这个位置适合拿来做范围结束点，比如删除到词尾。

数据流：读取当前光标 → 找下一个词尾；若按 Vim 光标规则会停在原地，则继续找下一个词 → 返回用于范围的结束位置。

调用关系：target_for_motion 和 vim_word_end_cursor 调用它；它结合 end_of_next_word、end_of_next_word_from 和 prev_atomic_boundary。

调用图：调用 3 个内部函数（end_of_next_word, end_of_next_word_from, prev_atomic_boundary）；被 2 处调用（target_for_motion, vim_word_end_cursor）。

fn vim_word_end_cursor(&self) -> usize

作用：按 Vim 普通模式的光标规则，算出按 e 后光标应该停在哪个字符上。

数据流：先算词尾后的范围位置 → 如果在当前光标后，就退到前一个完整单位；否则原样返回 → 得到可显示的词尾光标位置。

调用关系：handle_vim_normal 处理移动到词尾时调用它；它依赖 vim_word_end_exclusive。

调用图：调用 2 个内部函数（prev_atomic_boundary, vim_word_end_exclusive）；被 1 处调用（handle_vim_normal）。

fn vim_line_end_cursor(&self) -> usize

作用：按 Vim 规则计算当前行尾光标位置。普通模式下通常停在行内最后一个字符，而不是换行符后。

数据流：读取当前行首和行尾 → 如果行里有内容，就从行尾退到前一个完整单位且不越过行首；空行则返回行尾 → 输出光标位置。

调用关系：handle_vim_normal 处理行尾移动时调用它；它使用 prev_atomic_boundary。

调用图：调用 3 个内部函数（beginning_of_current_line, end_of_current_line, prev_atomic_boundary）；被 1 处调用（handle_vim_normal）。

fn beginning_of_next_word(&self) -> usize

作用：找到下一个词的开头。Vim 的 w 或普通按词右移会用它。

数据流：从当前光标往后找非空白；如果当前在空白中，返回那个词首；如果已在词中，先到当前词尾，再找下一个非空白 → 避开元素内部后返回。

调用关系：handle_vim_normal 和 target_for_motion 调用它；它会用 end_of_next_word 辅助跨过当前词。

调用图：调用 2 个内部函数（adjust_pos_out_of_elements, end_of_next_word）；被 2 处调用（handle_vim_normal, target_for_motion）。

fn adjust_pos_out_of_elements(&self, pos: usize, prefer_start: bool) -> usize

作用：如果某个计算出的位置落在特殊元素里面，就把它挪到元素起点或终点。它保护词移动不会停在元素中间。

数据流：输入位置和偏好方向 → 查找是否在元素内部；如果在，按 prefer_start 返回元素起点或终点，否则返回原位置。

调用关系：beginning_of_next_word、beginning_of_previous_word、end_of_next_word_from 都用它修正词边界。

调用图：调用 1 个内部函数（find_element_containing）；被 3 处调用（beginning_of_next_word, beginning_of_previous_word, end_of_next_word_from）。

fn wrapped_lines(&self, width: u16) -> Ref<'_, Vec<Range<usize>>>

作用：按给定宽度计算文本会折成哪些屏幕行，并缓存结果。终端宽度不够时，长文本需要这样分行显示。

数据流：输入宽度 → 如果缓存不存在或宽度变了，就重新调用 wrapping 算出每行字节范围并保存；然后返回缓存里的行范围引用。

调用关系：desired_height、cursor_pos_with_state 和各类 render 函数都调用它；文本变化时其他函数会清掉 wrap_cache。

调用图：调用 1 个内部函数（wrap_ranges）；被 5 处调用（cursor_pos_with_state, desired_height, render_ref, render_ref_masked, render_ref_styled_with_highlights）；外部调用 2 个（new, map）。

fn effective_scroll(
        &self,
        area_height: u16,
        lines: &[Range<usize>],
        current_scroll: u16,
    ) -> u16

作用：计算实际应该滚动到哪一行，保证光标尽量在可见区域内。用户输入多行时，不会把光标滚出屏幕。

数据流：输入区域高度、折行列表和当前滚动值 → 限制滚动不超过最大值，再根据光标所在行向上或向下修正 → 返回新的滚动行号。

调用关系：cursor_pos_with_state 和 render_ref 系列函数都用它，让渲染和光标坐标使用同一滚动规则。

调用图：被 4 处调用（cursor_pos_with_state, render_ref, render_ref_masked, render_ref_styled_with_highlights）；外部调用 2 个（wrapped_line_index_by_start, len）。

fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State)

作用：把文本框内容画到终端缓冲区里，使用默认样式。这里的缓冲区可以理解成即将显示到屏幕上的字符网格。

数据流：输入显示区域、缓冲区和状态 → 计算折行和有效滚动，更新 state.scroll，取可见行范围并调用 render_lines 绘制 → 屏幕缓冲区被写入。

调用关系：这是组件渲染入口之一；它依赖 wrapped_lines、effective_scroll 和 render_lines。

调用图：调用 3 个内部函数（effective_scroll, render_lines, wrapped_lines）；外部调用 1 个（default）。

fn render_ref_masked(
        &self,
        area: Rect,
        buf: &mut Buffer,
        state: &mut TextAreaState,
        mask_char: char,
    )

作用：把文本框画出来，但用指定字符遮住真实内容。密码输入框这类场景会用到。

数据流：输入区域、缓冲区、滚动状态和遮罩字符 → 计算折行与滚动，更新状态，再调用 render_lines_masked 绘制可见部分 → 缓冲区显示遮罩内容。

调用关系：这是带遮罩的渲染接口；它和普通 render_ref 使用同样的滚动与折行逻辑。

调用图：调用 3 个内部函数（effective_scroll, render_lines_masked, wrapped_lines）。

fn render_ref_styled_with_highlights(
        &self,
        area: Rect,
        buf: &mut Buffer,
        state: &mut TextAreaState,
        base_style: Style,
        highlights: &[(Range<usize>, St

作用：用基础样式和高亮范围绘制文本框。比如某些词需要变色提示时会用到。

数据流：输入区域、缓冲区、状态、基础样式和高亮列表 → 计算折行与滚动，更新 state.scroll，调用 render_lines 绘制带样式的可见行 → 缓冲区被写入。

调用关系：这是带样式和高亮的渲染接口；它复用 wrapped_lines、effective_scroll 和 render_lines。

调用图：调用 3 个内部函数（effective_scroll, render_lines, wrapped_lines）。

fn render_lines(
        &self,
        area: Rect,
        buf: &mut Buffer,
        lines: &[Range<usize>],
        range: std::ops::Range<usize>,
        base_style: Style,
        highlights: &[(R

作用：把文本输入框当前可见的几行画到终端缓冲区里，并按需要加上普通样式、特殊元素样式和搜索高亮。它保证用户看到的文字、附件占位符和临时高亮不会互相盖错。

数据流：输入是屏幕区域、要写入的缓冲区、已经切好的行范围、要显示哪几行、基础样式和高亮范围；它逐行取出文本，先用基础样式填底并写文字，再把特殊元素覆盖成青色，最后把高亮覆盖上去；输出不是返回值，而是缓冲区被改成可显示的画面。

调用关系：当外层渲染函数 render_ref 或 render_ref_styled_with_highlights 需要真正画普通文本时，会把最后一步交给它。它内部调用缓冲区的 set_style、set_string 等方法，把计算好的内容落到屏幕格子上。

调用图：被 2 处调用（render_ref, render_ref_styled_with_highlights）；外部调用 5 个（set_string, set_style, new, fg, enumerate）。

fn render_lines_masked(
        &self,
        area: Rect,
        buf: &mut Buffer,
        lines: &[Range<usize>],
        range: std::ops::Range<usize>,
        mask_char: char,
    )

作用：把可见文本画成一串掩码字符，比如密码输入框里显示星号而不显示真实内容。这样既能保留长度和换行效果，又不会泄露原文。

数据流：输入是屏幕区域、缓冲区、行范围、要显示的行和掩码字符；它逐行读取真实文本，但把每个字符都替换成指定掩码；结果是缓冲区里出现掩码文本，原始文本本身不变。

调用关系：它被 render_ref_masked 调用，专门服务于“隐藏真实内容”的渲染路径。它不像 render_lines 那样叠加元素和高亮，只做简单的遮盖显示。

调用图：被 1 处调用（render_ref_masked）；外部调用 3 个（set_string, default, enumerate）。

fn rand_grapheme(rng: &mut rand::rngs::StdRng) -> String

作用：随机生成一个“用户眼里的一格文字”，可能是普通字母、中文、emoji，或者带重音的组合字符。它用来测试输入框面对复杂 Unicode 字符时是否稳定。

数据流：输入是一个随机数生成器；它按概率挑选换行、空格、字母、数字、emoji、中文、组合字符等；输出是一个字符串，代表一个可插入测试文本里的字符单元。

调用关系：这是测试辅助函数，测试代码会用它制造各种难处理的文本。它依赖随机范围选择和格式化字符串，不参与正式运行时的输入框渲染。

调用图：外部调用 2 个（random_range, format!）。

fn ta_with(text: &str) -> TextArea

作用：快速创建一个已经填好指定文字的 TextArea，方便测试少写重复准备代码。它相当于测试里的“造一个输入框样品”。

数据流：输入是一段字符串；它新建 TextArea，然后把字符串插进去；输出是带有这段文字的 TextArea。

调用关系：很多测试都会先调用它准备场景，然后再测试插入、删除、移动光标或 Vim 操作。它内部只依赖 TextArea::new 和插入文本能力。

调用图：调用 1 个内部函数（new）。

fn insert_and_replace_update_cursor_and_text()

作用：检查插入和替换文字后，文本内容和光标位置是否一起正确更新。没有这类保证，用户打字后光标可能跳到奇怪位置。

数据流：它创建不同文本，设置光标，执行 insert_str、insert_str_at 和 replace_range；然后比较实际文本和光标；结果是测试通过或失败，不产生业务输出。

调用关系：测试运行器调用它来验证基础编辑能力。它主要依赖 ta_with 准备 TextArea，并用断言检查 TextArea 的行为。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn insert_str_at_clamps_to_char_boundary()

作用：确认在中文这类多字节字符中间插入时，位置会被修正到合法字符边界。这样不会把一个字切坏。

数据流：它先插入“你”，再请求在字节位置 1 插入 A；代码会把位置夹到安全边界；最终文本应为“A你”，光标在 A 后面。

调用关系：这是测试运行器执行的边界测试。它直接创建 TextArea，检查 insert_str_at 对 Unicode 边界的保护。

调用图：调用 1 个内部函数（new）；外部调用 1 个（assert_eq!）。

fn set_text_clamps_cursor_to_char_boundary()

作用：检查整段替换文本后，旧光标位置如果不再合法，会被移到安全位置。这样下一次输入不会破坏中文等多字节字符。

数据流：它先让光标在旧文本里，然后把文本换成“你”；光标被修正到 0；再插入 a，结果应正确出现在前面。

调用关系：测试运行器用它覆盖 set_text_clearing_elements 的安全行为。它验证设置文本和随后插入文本能顺利衔接。

调用图：调用 1 个内部函数（new）；外部调用 1 个（assert_eq!）。

fn delete_backward_and_forward_edges()

作用：检查向前删和向后删在开头、结尾这些边界位置不会出错。比如光标在开头按退格键应该什么都不删。

数据流：它准备 abc，移动光标后执行 delete_backward 和 delete_forward；每一步都检查文本和光标；最终确认边界操作是安全的。

调用关系：这是基础删除行为的测试。它通过 ta_with 准备文本，直接调用删除函数。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn delete_forward_deletes_element_at_left_edge()

作用：确认光标正好在特殊元素左边时，向前删除会把整个元素删掉，而不是只删一部分。特殊元素像一个不可拆开的附件占位符。

数据流：它插入普通字母、一个元素和另一个字母；把光标放在元素起点；执行向前删除；结果文本只剩普通字母，光标保持在元素原来的位置。

调用关系：测试运行器用它检查 TextArea 对 atomic element（不可拆分元素）的删除规则。它直接查看元素范围并调用 delete_forward。

调用图：调用 1 个内部函数（new）；外部调用 1 个（assert_eq!）。

fn vim_insert_and_escape()

作用：检查开启 Vim 模式后，按 i 能进入插入，输入字符后按 Esc 能回到普通模式。Vim 模式是一套常见的键盘编辑习惯。

数据流：它创建空输入框，开启 Vim，发送 i、h、Esc 三个按键；文本变成 h，模式显示 Normal，光标回到字符上；测试用断言确认这些结果。

调用关系：测试运行器调用它验证 Vim 输入流程。它通过 TextArea::input 模拟真实按键。

调用图：调用 1 个内部函数（new）；外部调用 3 个（Char, new, assert_eq!）。

fn vim_insert_key_enters_insert_mode()

作用：确认键盘上的 Insert 键也能让 Vim 模式进入插入状态。这样不同键盘习惯的用户都能正常输入。

数据流：它开启 Vim，发送 Insert 键，再发送 h；如果进入插入模式成功，文本会包含 h，模式标签是 Insert。

调用关系：这是 Vim 键位兼容性测试。它把按键事件交给 TextArea::input。

调用图：调用 1 个内部函数（new）；外部调用 3 个（Char, new, assert_eq!）。

fn vim_normal_arrow_keys_move_cursor()

作用：检查 Vim 普通模式下，方向键仍然可以移动光标。即使用 Vim，也不强迫用户只用 hjkl。

数据流：它准备两行文本，把光标放在指定位置；依次发送右、下、左、上方向键；每次检查光标是否到达预期位置。

调用关系：测试运行器用它确认普通模式移动逻辑。它依赖 ta_with 和按键输入入口。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn vim_escape_from_insert_at_start_does_not_underflow()

作用：确认在文本开头退出插入模式时，光标不会往左减到负数。负数位置在程序里可能造成严重错误。

数据流：它开启 Vim，输入 z，再按 Esc；模式变 Normal，光标安全停在 0；断言负责验证。

调用关系：这是 Vim 退出插入模式的边界测试。它通过 input 模拟用户按键。

调用图：调用 1 个内部函数（new）；外部调用 3 个（Char, new, assert_eq!）。

fn vim_escape_from_insert_at_line_start_stays_on_line()

作用：检查在一行开头按 Esc 退出插入模式时，光标不会跳到上一行。用户会期望它还停在当前行开头。

数据流：它准备两行文本，把光标放到第二行开头；进入插入后按 Esc；结果模式变 Normal，光标仍在第二行开头。

调用关系：测试运行器用它保护 Vim 光标规则。它依赖 ta_with 和按键事件。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_escape_moves_by_grapheme_boundary()

作用：检查从 emoji 后面退出插入模式时，光标按完整字符移动，而不是停在 emoji 内部。这里的 grapheme 指用户眼里一个完整字符。

数据流：它准备两个点赞 emoji，让光标在末尾；进入插入再按 Esc；光标应退到第一个 emoji 后，也就是第二个 emoji 上的位置。

调用关系：这是 Unicode 光标安全测试。它验证 Vim 退出插入模式时也尊重字符边界。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_escape_respects_atomic_element_boundary()

作用：确认 Vim 退出插入模式时，不会把光标放进不可拆分元素内部。元素必须像一个整体被跨过。

数据流：它插入 a 和一个元素，开启 Vim，进入插入再退出；结果光标停在元素前的合法边界。

调用关系：测试运行器用它检查 Vim 光标规则和特殊元素规则能一起工作。

调用图：调用 1 个内部函数（new）；外部调用 3 个（Char, new, assert_eq!）。

fn vim_shift_i_enters_insert_at_first_non_blank_with_shift_only_binding()

作用：检查大写 I 这个 Vim 操作能跳到当前行第一个非空格字符处并进入插入模式。它还验证只绑定 Shift 形式时也能识别。

数据流：它准备带缩进的文本，改写 Vim 键位映射，把光标放在行中；发送大写 I；结果进入 Insert，光标到缩进之后。

调用关系：这是 Vim 键位映射测试。它设置 vim_normal_keymap 后，通过 input 验证分发结果。

调用图：外部调用 5 个（Char, new, assert_eq!, ta_with, vec!）。

fn vim_shift_a_enters_insert_at_line_end_with_shift_only_binding()

作用：检查大写 A 能跳到行尾并进入插入模式，同时确认 Shift-only 绑定能匹配。Vim 用户常用它在行尾追加内容。

数据流：它准备两行文本，配置 append_line_end 的键位，发送大写 A；结果模式是 Insert，光标到当前行结尾。

调用关系：测试运行器用它覆盖 Vim 自定义键位。它通过输入事件触发 TextArea 的 Vim 普通模式处理。

调用图：外部调用 5 个（Char, new, assert_eq!, ta_with, vec!）。

fn vim_shift_c_changes_to_line_end_and_enters_insert_mode()

作用：检查 Shift+C 会删除从光标到行尾的内容，并进入插入模式。这是 Vim 的“改到行尾”。

数据流：它准备 hello world，光标放在 world 前；发送带 Shift 的 c；结果 world 被删进 kill_buffer，文本保留换行，光标不乱动并进入 Insert。

调用关系：这是 Vim 改写操作测试。它通过 input 走完整按键处理，而不是直接调用删除函数。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_uppercase_c_changes_to_line_end()

作用：确认直接收到大写 C 时，也能执行“改到行尾”。不同终端可能用不同方式表示 Shift 字母。

数据流：它准备文本，光标放在行中，发送 Char('C')；结果行尾内容被删除，模式进入 Insert，光标停在删除起点。

调用关系：测试运行器用它补充 Shift+C 的兼容场景。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_s_substitutes_current_character_and_enters_insert_mode()

作用：检查 Vim 的 s 命令会删掉当前字符并进入插入模式。用户随后输入的新字会替换原字符。

数据流：它在 abc 的 b 上按 s；文本变 ac，进入 Insert；再输入 X 后文本变 aXc，光标随输入前进。

调用关系：这是 Vim 单字符替换流程测试。它通过连续 input 模拟真实操作。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_s_on_empty_line_enters_insert_without_deleting_newline()

作用：确认在空行上按 s 不会把换行符删掉，只是进入插入模式。否则空行结构会被意外破坏。

数据流：它准备中间有空行的文本，把光标放在空行；按 s 后文本不变，光标不变，模式进入 Insert。

调用关系：测试运行器用它保护 Vim 替换命令在空行上的边界行为。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_d_at_line_end_does_not_remove_newline()

作用：检查在行尾按 D 不会删除换行符。Vim 里 D 是删到行尾，但行尾已经没有普通字符时应不动。

数据流：它把光标放在 hello 的行尾，发送 D；文本不变，模式保持 Normal，kill_buffer 为空。

调用关系：这是 Vim 删除到行尾的边界测试。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_c_at_line_end_enters_insert_without_removing_newline()

作用：检查在行尾按 C 会进入插入模式，但不会删掉下一行。这样用户可以在行尾继续输入。

数据流：它在第一行行尾发送 C；文本不变，模式变 Insert，光标停在行尾，kill_buffer 为空。

调用关系：测试运行器用它验证 Vim 改到行尾的空范围行为。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_shift_o_opens_line_above_with_shift_only_binding()

作用：检查大写 O 能在当前行上方新开一行并进入插入模式。它还验证 Shift-only 键位绑定。

数据流：它准备两行文本，配置 open_line_above，光标在第二行；发送大写 O；文本中间多出空行，光标在新行开始。

调用关系：这是 Vim 开新行命令和键位映射的测试。

调用图：外部调用 5 个（Char, new, assert_eq!, ta_with, vec!）。

fn vim_o_opens_line_below_on_inserted_line()

作用：检查小写 o 能在当前行下方插入新空行，并把光标放到新行。Vim 用户常用它快速开下一行。

数据流：它准备 one/two 两行，在第一行按 o；文本变成中间有空行，模式进入 Insert，光标在新空行。

调用关系：测试运行器通过 input 验证 Vim 普通模式里的开行命令。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_o_opens_line_below_final_line_and_moves_to_new_line()

作用：确认在最后一行按 o 时，也能在末尾创建新行并移动过去。末尾没有原本的换行也要处理好。

数据流：它准备单行 one，按 o；文本变成 one 后跟换行，模式为 Insert，光标到新行开头。

调用关系：这是 Vim 开下方行的末尾边界测试。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_delete_word()

作用：检查 Vim 的 dw 会删除从光标开始到下一个词前的内容。这里还要把删除内容存进 kill_buffer，方便粘贴。

数据流：它准备 hello world，光标在开头；依次输入 d 和 w；结果 hello 加空格被删除，kill_buffer 保存这段内容。

调用关系：这是 Vim 操作符加动作的测试。d 先进入待执行状态，w 决定删除范围。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_change_inner_word_deletes_word_and_enters_insert()

作用：检查 ciw 会删除当前词内部并进入插入模式。ciw 是 Vim 里“改当前词”的常见组合。

数据流：它把光标放在 world 上，输入 c、i、w；world 被删入 kill_buffer，光标留在原处，模式进入 Insert。

调用关系：测试运行器用它验证 Vim 文本对象机制，也就是 i w 这种用来选中一块文字的规则。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_word_text_objects_cover_delete_yank_and_big_word()

作用：检查 Vim 的词文本对象既能复制也能删除，并区分普通 word 和大写 W 的“大词”。大词通常把标点也算进同一块。

数据流：第一段用 yaw 复制 hello 加空格，文本不变但 kill_buffer 有内容；第二段用 diW 删除 foo.bar/baz；结果文本和 kill_buffer 符合预期。

调用关系：这是 Vim 文本对象的综合测试。它通过 y、d 这些操作符和 a/i、w/W 这些对象组合来覆盖不同路径。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_word_text_objects_accept_cursor_at_word_end()

作用：确认光标正好在词尾时，word 文本对象仍然能选中刚结束的词。否则用户在词尾执行命令会失效。

数据流：它先在 hello 末尾执行 daw，删除 hello 加空格；再在文本末尾执行 ciW，删除 bar 并进入 Insert；断言检查文本、缓冲和光标。

调用关系：测试运行器用它覆盖 Vim 文本对象的边界位置。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_delimiter_text_objects_select_innermost_pair_and_aliases()

作用：检查括号、方括号这类分隔符文本对象能选中最近的一对，并支持别名。比如 cib 表示改括号里面。

数据流：它先在嵌套括号里执行 cib，删除最内层内容；再对方括号执行 da]，删除整对方括号及内容；结果写入 kill_buffer。

调用关系：这是 Vim 分隔符文本对象测试，验证 TextArea 能找到正确的左右边界。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_empty_inner_text_objects_are_valid_targets()

作用：确认空括号或空引号内部也算合法目标。即使没有内容可删，命令也应进入插入模式而不是报错。

数据流：它分别准备 call() 和空引号文本；执行 ci( 或 ci"；文本不变，kill_buffer 为空，光标在内部，模式进入 Insert。

调用关系：测试运行器用它保护 Vim 文本对象的空范围行为。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_quote_text_objects_are_line_local_and_handle_escapes()

作用：检查引号文本对象只在当前行内寻找配对引号，并能跳过被反斜杠转义的引号。这样不会把字符串范围找错。

数据流：第一段在含转义引号的字符串里执行 ci"，只删真正引号里的内容；第二段跨行引号里执行 di"，因为不能跨行匹配所以不改文本。

调用关系：这是 Vim 引号文本对象的细节测试，关注转义字符和换行边界。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_text_object_cancellation_and_unsupported_change_motions_do_not_edit()

作用：检查不支持的 Vim 组合或按 Esc 取消时，不会误删文字。用户按错键时输入框应该安全退出待命状态。

数据流：它先输入 c 后接 $，确认文本不变并退出待执行状态；再输入 d i 后按 Esc，也确认文本和 kill_buffer 不变。

调用关系：测试运行器用它验证 Vim 操作符待命状态的取消逻辑。

调用图：外部调用 5 个（Char, new, assert!, assert_eq!, ta_with）。

fn vim_operator_invalid_motion_is_consumed()

作用：确认 Vim 操作符后接无效动作时，会消费掉这个错误按键并回到普通模式。这样不会一直卡在等待状态。

数据流：它输入 d 进入待命，再输入 z；文本不变，光标不动，模式回 Normal，待命标志清除。

调用关系：这是 Vim 操作符状态机的错误路径测试。

调用图：外部调用 5 个（Char, new, assert!, assert_eq!, ta_with）。

fn vim_e_lands_on_word_end_character()

作用：检查 Vim 的 e 会把光标移动到当前词的最后一个字符上。随后按 x 应删除这个字符。

数据流：它在 abc 开头按 e，光标到 c；再按 x，文本变 ab，kill_buffer 保存 c。

调用关系：测试运行器用它验证 Vim 词尾移动和删除当前字符能连起来工作。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_e_advances_from_each_word_end()

作用：检查连续按 e 时，光标会从一个词尾前进到下一个词尾。它用快照记录多个中间状态。

数据流：它准备 alpha beta gamma，从 alpha 末尾附近开始，连续三次发送 e；每次把文本和光标位置画成字符串；最终与保存的快照比较。

调用关系：这是 Vim 词导航的回归测试。它使用 insta 快照来发现行为变化。

调用图：外部调用 6 个（Char, new, new, format!, assert_snapshot!, ta_with）。

fn vim_delete_to_word_end_advances_from_existing_word_end()

作用：检查在已经接近词尾时执行 de，会继续删到后面词的词尾，而不是只删一个字符。这样符合 Vim 的移动语义。

数据流：它在 alpha 的末尾前执行 d e；结果删除 a beta，文本变 alph gamma，kill_buffer 保存被删内容。

调用关系：测试运行器用它验证 Vim 删除操作和 e 移动的组合规则。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_e_from_word_end_can_land_on_trailing_space()

作用：检查从词尾继续按 e 时，可以落到尾随空格上的特定位置。这个细节影响后续删除或移动命令。

数据流：它准备 alpha 后跟空格，从 alpha 末尾附近按 e；光标移动到预期的尾部空格位置。

调用关系：这是 Vim 词尾移动在空白结尾场景下的测试。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_e_advances_across_atomic_element_word_ends()

作用：确认 Vim 的 e 能跨过不可拆分元素，并把元素当作一个整体处理。这样附件占位符不会被光标切开。

数据流：它插入 alpha、一个元素和 gamma；第一次按 e 到元素起点，第二次按 e 到 gamma 的词尾附近；每步检查光标。

调用关系：测试运行器用它验证 Vim 词导航和特殊元素的配合。

调用图：调用 1 个内部函数（new）；外部调用 3 个（Char, new, assert_eq!）。

fn vim_dollar_lands_on_line_end_character()

作用：检查 Vim 的 $ 会把光标放到当前行最后一个字符，而不是换行符上。随后 x 应删除这个行尾字符。

数据流：它在 abc 行中按 $，光标到 c；再按 x，文本变 ab 换行 123，kill_buffer 保存 c。

调用关系：这是 Vim 行尾导航和删除当前字符的组合测试。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn vim_linewise_yank_pastes_below_current_line()

作用：检查 yy 复制整行后，p 会把这行粘贴到当前行下面。linewise 表示按整行处理。

数据流：它准备三行文本，在第一行执行 y y p；结果第一行被复制到下面，光标到新插入行，kill_buffer 记录整行并标记为 Linewise。

调用关系：测试运行器用它验证 Vim 整行复制和粘贴规则。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn delete_backward_word_and_kill_line_variants()

作用：检查按词向后删除，以及删到行尾、删到行首这些常见编辑命令的各种边界。它覆盖行中、行尾、行首和跨换行的情况。

数据流：它多次创建不同文本，设置光标后调用 delete_backward_word、kill_to_end_of_line、kill_to_beginning_of_line；每次检查文本和光标是否正确。

调用关系：这是非 Vim 编辑命令的综合测试。它直接调用 TextArea 的编辑方法，不通过按键映射。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn kill_current_line_removes_current_line_linewise()

作用：检查删除当前行时，会按整行方式删除，并把被删行放进 kill_buffer。这样后续粘贴能按行恢复。

数据流：它准备三行文本，光标在中间行；调用 kill_current_line；结果中间行消失，光标到合适位置，kill_buffer 保存 def 加换行并标记 Linewise。

调用关系：测试运行器用它验证整行删除的核心行为。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn kill_current_line_keeps_previous_newline_for_final_line()

作用：检查删除最后一行时，会保留前一行的换行结构，不把前一行也弄乱。末行没有尾随换行时尤其容易出错。

数据流：它准备 abc 换行 def，光标在 def；删除当前行后文本为 abc 加换行，kill_buffer 保存 def，光标在末尾换行后。

调用关系：这是 kill_current_line 的最后一行边界测试。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn kill_whole_line_keymap_dispatch_uses_linewise_kill()

作用：检查通过快捷键映射触发“删除整行”时，走的是整行删除规则。也就是说按键分发不能误走删到行首的规则。

数据流：它准备三行文本，修改运行时键位表，把 Ctrl+U 绑定到 kill_whole_line；发送按键后，确认中间行被整行删除并存入 linewise 缓冲。

调用关系：测试运行器用它验证 RuntimeKeymap 到 TextArea 编辑命令的分发。

调用图：调用 1 个内部函数（defaults）；外部调用 5 个（Char, new, assert_eq!, ta_with, vec!）。

fn delete_forward_word_variants()

作用：检查向前按词删除在不同位置的行为，包括词首、词中、结尾、换行前和光标越界。它保证删除范围符合用户直觉。

数据流：它用多组文本设置不同光标，调用 delete_forward_word；每组都检查删除后的文本和光标位置。

调用关系：这是前向按词删除的综合测试，直接调用 TextArea 方法。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn delete_forward_word_handles_atomic_elements()

作用：确认向前按词删除遇到特殊元素时，会把元素当作整体删除。即使光标落在元素内部，也会回到元素起点并删整块。

数据流：它构造元素在开头、空格后、普通文字后的几种场景；调用 delete_forward_word；结果元素被整体移除，光标停在合理边界。

调用关系：测试运行器用它检查普通词删除逻辑和不可拆分元素的配合。

调用图：调用 1 个内部函数（new）；外部调用 1 个（assert_eq!）。

fn delete_backward_word_respects_word_separators()

作用：检查向后按词删除会把斜杠等分隔符当成边界。这样编辑路径 path/to/file 时不会一次删太多。

数据流：它准备带斜杠和空格的文本，光标放末尾；反复调用 delete_backward_word；每次确认只删预期的词或分隔符片段。

调用关系：这是词边界规则的测试，重点是标点分隔符。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn delete_forward_word_respects_word_separators()

作用：检查向前按词删除同样尊重斜杠等分隔符。光标在路径开头时，应一段一段删。

数据流：它准备 path/to/file、/ foo、 /foo 等文本；调用 delete_forward_word；结果只删除当前词或分隔符范围，光标保持合理。

调用关系：测试运行器用它验证前向删除和词分隔规则。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn yank_restores_last_kill()

作用：检查 yank 粘贴能恢复最近一次删除的内容。这里的 kill_buffer 就像剪贴板，保存刚删掉的文字。

数据流：它分别测试删到行尾、向后删词、删到行首；每次删除后调用 yank；文本应恢复，光标到插入内容末尾。

调用关系：这是删除和粘贴之间的配合测试。它直接调用编辑命令和 yank。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn kill_buffer_persists_across_set_text()

作用：确认修改输入框当前文本不会清掉 kill_buffer。这样临时换内容后，用户仍能粘贴之前剪下的东西。

数据流：它先删除 restore me 到 kill_buffer，再把文本改成别的又清空；随后 yank；结果 restore me 被恢复出来。

调用关系：测试运行器用它保护剪贴缓冲区的生命周期规则。

调用图：外部调用 3 个（assert!, assert_eq!, ta_with）。

fn cursor_left_and_right_handle_graphemes()

作用：检查左右移动光标时，会按用户看到的完整字符移动，包括 emoji。不能停在 emoji 的内部字节位置。

数据流：它准备 ab，从末尾连续左移三次并记录位置，再右移三次；最终光标回到文本末尾，各中间位置单调变化。

调用关系：这是光标移动的 Unicode 安全测试。

调用图：外部调用 3 个（assert!, assert_eq!, ta_with）。

fn control_b_and_f_move_cursor()

作用：检查 Ctrl+F 和 Ctrl+B 能分别向右、向左移动光标。这是类似 Emacs 的常见快捷键。

数据流：它准备 abcd，光标在 1；发送 Ctrl+F 后光标到 2，再发送 Ctrl+B 后回到 1。

调用关系：测试运行器通过 input 验证快捷键到移动命令的映射。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn control_b_f_fallback_control_chars_move_cursor()

作用：检查有些终端直接发送控制字符时，输入框仍能识别 Ctrl+B 和 Ctrl+F。控制字符是早期终端用来表示快捷键的隐藏字符。

数据流：它发送 U+0002 代表 Ctrl+B，光标左移；再发送 U+0006 代表 Ctrl+F，光标右移。

调用关系：这是终端兼容性测试，确保没有显式 CONTROL 修饰键时也能正常移动。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn c0_line_feed_inserts_newline_through_insert_newline_keymap()

作用：检查 C0 控制字符里的换行符能按键位配置插入真正的新行。C0 控制字符是一些不可见的老式终端控制码。

数据流：它准备 ab，光标在中间；发送 U+000A；文本变成 a 换行 b，光标在新行后。

调用关系：测试运行器用它验证控制字符会经过插入换行的键位路径。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn c0_control_chars_respect_unbound_editor_movement()

作用：检查控制字符快捷键如果在键位表里被解绑，就不会偷偷执行默认移动。用户改了键位，就应该尊重。

数据流：它清空 move_up 绑定，再发送代表 Ctrl+P 的控制字符；光标保持不变。

调用关系：这是 RuntimeKeymap 自定义行为测试，通过 input_with_keymap 走指定键位表。

调用图：调用 1 个内部函数（defaults）；外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn c0_control_chars_respect_remapped_editor_movement()

作用：检查控制字符能跟随用户重映射后的键位执行。比如把 Ctrl+P 改成向下移动，就应该真的向下。

数据流：它改键位表，把 move_down 绑定到 Ctrl+P；发送对应控制字符；光标从第一行移动到下一行。

调用关系：测试运行器用它验证控制字符解析和运行时键位映射能配合。

调用图：调用 1 个内部函数（defaults）；外部调用 5 个（Char, new, assert_eq!, ta_with, vec!）。

fn delete_backward_word_alt_keys()

作用：检查两种 Alt 组合键都能向后删除一个词。Alt+Ctrl+h 和 Alt+Backspace 都是常见终端里“删前一个词”的表示。

数据流：它分别准备 hello world，把光标放末尾；发送两个不同快捷键；结果都只剩 hello 加空格，光标在空格后。

调用关系：这是快捷键兼容性测试，通过 TextArea::input 走真实按键分发。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn shift_backspace_and_shift_delete_keep_grapheme_delete_behavior()

作用：检查 Shift+Backspace 和 Shift+Delete 仍然按普通字符删除，不会因为多了 Shift 就改变语义。这里也保护按完整字符删除的行为。

数据流：它分别在 abc 中用 Shift+Backspace 和 Shift+Delete；结果都删除 b，光标位置正确。

调用关系：测试运行器用它验证删除键修饰符处理。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn control_backspace_variants_delete_backward_word()

作用：确认 Ctrl+Backspace 以及 Ctrl+Shift+Backspace 都是向后删一个词。不同系统可能发送不同修饰组合。

数据流：它循环测试两个修饰符组合，光标在 hello world 末尾；按键后 world 被删，光标到 hello 后。

调用关系：这是后向按词删除快捷键的兼容测试。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn control_delete_variants_delete_forward_word()

作用：确认 Ctrl+Delete 和 Ctrl+Shift+Delete 都是向前删一个词。这样键盘行为和多数编辑器一致。

数据流：它循环测试两个修饰符组合，光标在 hello world 开头；按键后 hello 被删，光标留在开头。

调用关系：这是前向按词删除快捷键的兼容测试。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn delete_backward_word_handles_narrow_no_break_space()

作用：检查窄不换行空格这种特殊空白字符不会破坏按词删除。它常出现在时间或排版文本里。

数据流：它准备 32 后跟窄不换行空格和 AM；按 Alt+Backspace 后只删除 AM，保留前面的数字和特殊空格。

调用关系：这是 Unicode 空白字符的词删除测试。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn delete_forward_word_with_without_alt_modifier()

作用：检查 Delete 键带 Alt 时按词删除，不带 Alt 时只删一个字符。修饰键决定删除粒度。

数据流：第一段在 hello world 开头按 Alt+Delete，删除 hello；第二段在 hello 开头按普通 Delete，只删除 h。

调用关系：测试运行器用它验证 Delete 键的修饰符分发。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn delete_forward_word_alt_d()

作用：确认 Alt+D 能向前删除一个词，这是很多命令行编辑器里的常见快捷键。

数据流：它准备 hello world，光标在 world 前；发送 Alt+D；world 被删，光标保持在原位置。

调用关系：这是 Alt+D 快捷键到 delete_forward_word 的映射测试。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn control_h_backspace()

作用：检查 Ctrl+H 被当作退格键处理。很多终端会把 Backspace 发成 Ctrl+H。

数据流：它在 12345 中间、开头和结尾分别发送 Ctrl+H；中间和结尾会删前一个字符，开头不变。

调用关系：这是终端兼容性测试，确保不同退格表示都能正常工作。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn altgr_ctrl_alt_char_inserts_literal()

作用：检查 Ctrl+Alt+字符在某些情况下会被当作 AltGr 输入的普通字符，而不是快捷键。AltGr 是一些键盘布局用来输入特殊字符的键。

数据流：它向空文本发送 Ctrl+Alt+c；结果插入字母 c，光标前进到 1。

调用关系：测试运行器用它避免误把 AltGr 输入吞掉。

调用图：外部调用 4 个（Char, new, assert_eq!, ta_with）。

fn cursor_vertical_movement_across_lines_and_bounds()

作用：检查上下移动光标时，会尽量保持列位置，同时在短行和文本边界处安全收缩。用户按上下键时期待光标垂直移动而不是乱跳。

数据流：它准备长短不一的三行文本，把光标放第二行；向上、再向上、向下多次移动；每一步检查光标是否在合理行和边界内。

调用关系：这是基础竖向光标移动测试，直接调用 move_cursor_up 和 move_cursor_down。

调用图：外部调用 3 个（assert!, assert_eq!, ta_with）。

fn home_end_and_emacs_style_home_end()

作用：检查 Home/End 类移动，以及类似 Ctrl+A/Ctrl+E 的行首行尾跳转。某些模式下在行首再按会跳到上一行行首，在行尾再按会跳到下一行行尾。

数据流：它准备三行文本，把光标放第二行中间；调用移动到行首、再按行首上跳、移动到行尾、再按行尾下跳；断言检查位置。

调用关系：测试运行器用它验证行内导航和 Emacs 风格边界行为。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn end_of_line_or_down_at_end_of_text()

作用：检查在文本绝对末尾执行“到行尾或下一行”不会崩溃，也不会越界。边界位置必须安全。

数据流：它先把光标放文本末尾，调用移动到行尾并允许下跳，结果不变；再放第一行行尾，调用后跳到下一行末尾。

调用关系：这是 move_cursor_to_end_of_line 的末尾边界测试。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn word_navigation_helpers()

作用：检查查找上一个词开头和下一个词结尾的辅助函数。它们是按词移动和按词删除的基础零件。

数据流：它准备含多个词和空格的文本，设置不同光标；调用 beginning_of_previous_word 和 end_of_next_word；结果应返回预期索引。

调用关系：测试运行器用它直接验证词导航底层函数，不经过按键输入。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn word_navigation_cjk_each_char_is_boundary()

作用：检查中文等 CJK 字符向后按词移动时，每个字都可以作为边界。CJK 指中文、日文、韩文这类文字。

数据流：它准备“你好世界”，从末尾逐步调用 beginning_of_previous_word；每次都退到前一个汉字的起点。

调用关系：这是 Unicode 词边界测试，重点是 CJK 文字。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn word_navigation_cjk_forward()

作用：检查 CJK 字符向前按词移动时，也是一字一跳。这样中文输入的光标移动更符合直觉。

数据流：它从“你好世界”的各个字节边界调用 end_of_next_word；结果依次到下一个汉字末尾。

调用关系：测试运行器用它验证前向词导航的 CJK 规则。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn word_navigation_mixed_ascii_cjk()

作用：检查英文和中文混在一起时，词边界能正确分开。hello 应算一个英文词，每个中文字符也有自己的边界。

数据流：它准备 hello你好，分别测试前进和后退词边界；结果在英文词尾和每个中文字符边界处停下。

调用关系：这是混合语言文本的词导航测试。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn word_navigation_preserves_separator_breaks_within_unicode_segments()

作用：检查撇号、小数点、句点等分隔符会被保留为词边界。比如 can't、32.3、foo.bar 不应被简单当成一个整体。

数据流：它准备包含标点的文本，设置光标在不同位置；调用 beginning_of_previous_word；结果会落到标点附近的正确边界。

调用关系：测试运行器用它保护更细的词分隔规则。

调用图：外部调用 2 个（assert_eq!, ta_with）。

fn wrapping_and_cursor_positions()

作用：检查文本自动换行后，高度计算、光标坐标和滚动状态是否正确。终端输入框宽度有限，长文本必须拆成多行显示。

数据流：它准备长句并设置窄区域；检查 desired_height 至少有多行；把光标放在换行后的单词里，确认坐标；再用小高度渲染，确认滚动让光标可见。

调用关系：这是渲染和光标定位的综合测试，会调用 render_ref 更新 TextAreaState。

调用图：外部调用 7 个（empty, new, assert!, assert_eq!, render_ref, default, ta_with）。

fn render_highlights_apply_style_without_mutating_text()

作用：检查渲染高亮只改变屏幕样式，不改变真实文本。搜索结果高亮应该像荧光笔标记，不应该改字本身。

数据流：它准备 hello world，渲染 world 范围为反色；然后确认 TextArea 的文本仍不变，同时缓冲区中高亮位置带有反色样式。

调用关系：测试运行器用它验证 render_ref_styled_with_highlights 这条渲染路径。

调用图：外部调用 7 个（empty, new, default, assert!, assert_eq!, default, ta_with）。

fn cursor_pos_with_state_basic_and_scroll_behaviors()

作用：检查带滚动状态的光标坐标计算。内容能完全显示时滚动应被忽略，内容过长时光标要被夹在可见区域内。

数据流：它分别构造内容适配、光标在窗口下方、光标在窗口上方三种情况；调用 cursor_pos_with_state；结果 y 坐标被正确映射到可见行。

调用关系：这是 TextAreaState 滚动逻辑的测试，直接调用坐标计算函数。

调用图：外部调用 3 个（new, assert_eq!, ta_with）。

fn wrapped_navigation_across_visual_lines()

作用：检查自动换行产生的“视觉行”之间，上下移动光标是否正确。视觉行是屏幕上看到的一行，不一定是真实换行。

数据流：它用宽度 4 把 abcdefghij 拆成三行显示；测试从第一视觉行向下、从第二行向上再向下、到短尾行时收缩到末尾。

调用关系：测试运行器用它验证移动逻辑基于视觉行，而不只是真实换行符。

调用图：外部调用 4 个（new, assert_eq!, default, ta_with）。

fn cursor_pos_with_state_after_movements()

作用：检查光标移动和渲染滚动状态连续配合时，坐标始终正确。用户上下移动时，窗口应跟着滚动让光标看得见。

数据流：它用宽度 4 和高度 2 的区域渲染文本；多次移动光标并调用 render_ref 更新状态；每次用 cursor_pos_with_state 确认屏幕坐标。

调用关系：这是渲染、滚动状态和光标移动的联动测试。render_ref 会调整 state，随后坐标函数读取它。

调用图：外部调用 6 个（empty, new, assert_eq!, render_ref, default, ta_with）。

fn wrapped_navigation_with_newlines_and_spaces()

作用：检查自动换行、空格和真实换行混在一起时，上下移动仍能保持合理列位置。这里既有视觉行边界，也有真实行边界。

数据流：它准备带空格和换行的文本，用窄宽度触发换行；光标在 word2 上，向上回到第一视觉行，向下回到 word2，再向下跨到 word3。

调用关系：测试运行器用它覆盖更接近真实输入的换行导航场景。

调用图：外部调用 3 个（assert!, assert_eq!, ta_with）。

fn wrapped_navigation_with_wide_graphemes()

作用：检查宽字符比如 emoji 自动换行后，上下移动不会落进字符中间。宽字符在终端上可能占两个格子。

数据流：它准备四个点赞 emoji，用很窄的宽度强制换行；光标在第二个 emoji 后，向下移动到下一视觉行，再向上应回到原位。

调用关系：这是自动换行导航和 Unicode 宽字符边界的测试。

调用图：外部调用 3 个（assert!, assert_eq!, ta_with）。

fn fuzz_textarea_randomized()

作用：这个函数是文本框的随机压力测试。它模拟用户用各种不可预测的方式编辑文本，确认文本框在复杂字符、光标移动、删除替换、内嵌元素和终端渲染时都不会出错。

数据流：进去的是当天日期生成的随机种子，以及测试里临时造出的随机文字、随机光标位置、随机窗口宽高和随机操作。函数先创建一个新的 TextArea 和它的显示状态，然后循环很多轮：随机改文字、移动光标、插入特殊元素、尝试在元素中间操作、渲染到 Buffer（终端界面的内存画布）里。出来的不是业务结果，而是一组断言检查：如果光标越界、元素内容被意外改坏、光标停进元素内部、渲染崩溃或滚动状态不合理，测试就会失败；如果都没问题，就说明这些随机场景下文本框行为可靠。

调用关系：它位于测试模块里，平时由测试框架运行，不是用户直接调用的功能。它会大量调用 TextArea 的核心能力，比如 new 创建文本框、set_text_clearing_elements 设置文本、insert_str 插入文字、replace_range 替换范围、delete_backward/delete_forward 删除、各种 move_cursor 移动光标、insert_element 插入整体元素、desired_height 计算换行后的高度，以及 cursor_pos 和 cursor_pos_with_state 计算屏幕上的光标位置。最后它还把文本框交给 ratatui 的渲染接口画到缓冲区，用这种方式同时检查编辑逻辑和显示逻辑是否能配合工作。

调用图：调用 1 个内部函数（new）；外部调用 15 个（empty, new, new, new, assert!, assert_eq!, hours, now, format!, seed_from_u64 (+5 more)）。

fn new() -> Self

作用：创建一份全新的空草稿状态，给聊天输入框从零开始使用。它会把文本框、光标状态、粘贴记录、提及记录等都设置成安全的初始值。

数据流：进去不需要任何外部输入 → 它新建一个空的 TextArea，准备默认的 TextAreaState，把 Bash 模式关掉，把待处理粘贴和提及列表清空，把输入设为可用，并建立默认的粘贴突发检测器 → 出来是一份完整可用的 DraftState，之后输入框可以直接拿它来记录用户正在编辑的内容。

调用关系：它通常由更上层的 new_with_config 在创建聊天输入组件时调用。它自己会把初始化工作交给一些更小的零件，比如文本框的 new、默认状态的 default、列表和表的创建函数；这样上层不需要知道每个字段该怎么从零摆好。

调用图：调用 1 个内部函数（new）；被 1 处调用（new_with_config）；外部调用 5 个（new, new, new, default, default）。

fn flash_visible(&self) -> bool

作用：判断底部的临时提示现在还该不该显示。比如一条提示只闪几秒，这个函数就是看它有没有过期。

数据流：它读取 FooterState 里的 flash 字段；如果没有临时提示，就返回 false；如果有，就拿当前时间和提示的过期时间比较；当前时间还没到过期点，就返回 true，否则返回 false。它不改动任何状态。

调用关系：在界面计算底栏高度和真正渲染底栏时会用到它，也就是 custom_footer_height 和 render_with_mask_and_textarea_right_reserve 会先问一句“闪现提示还活着吗”，再决定要不要给它留位置、画出来。

调用图：被 2 处调用（custom_footer_height, render_with_mask_and_textarea_right_reserve）。

fn show_flash(&mut self, line: Line<'static>, duration: Duration)

作用：在测试环境里放入一条会自动过期的底部闪现提示。它主要是给测试用的，方便模拟“底部弹出一条短暂消息”。

数据流：它接收要显示的文字行和持续时间；先读取当前时间，再把持续时间加上去算出过期时间；然后把 FooterState.flash 改成一个新的 FooterFlash，里面包含这行文字和过期时间。结果是状态对象从“可能没有提示”变成“有一条会在指定时间后消失的提示”。

调用关系：show_footer_flash 会调用它来设置这条临时提示。函数内部会向系统时间要一次“现在几点”，用来算提示什么时候结束。

调用图：被 1 处调用（show_footer_flash）；外部调用 1 个（now）。

fn status_line_text(&self) -> Option<String>

作用：在测试环境里把状态行里的富文本内容转成普通字符串。这样测试就不用关心颜色、样式，只检查文字对不对。

数据流：它读取 status_line_value；如果没有状态行，就返回 None；如果有，就把这一行里的多个文字片段按顺序拼起来，返回一个普通字符串。它不会修改状态。

调用关系：外层的 status_line_text 会调用它，通常用于测试或检查当前底部状态行显示的文字。它把界面用的复杂文字结构简化成容易比较的一串字。

调用图：被 1 处调用（status_line_text）。

fn active(&self) -> bool

作用：这个函数用来回答一个简单问题：现在有没有弹窗正在显示。外部界面逻辑会用它来决定是否要把输入、快捷键或其他行为让给弹窗。

数据流：它读取 PopupState 里的 active 字段，看当前状态是不是 ActivePopup::None。若不是 None，就返回 true，表示有弹窗；如果是 None，就返回 false，表示没有弹窗。它不修改任何数据，只做一次状态判断。

调用关系：当界面需要知道弹窗是否存在时，会通过 popup_active 或 set_input_enabled 间接用到它。它内部只是用 matches! 这个模式匹配工具做判断，相当于看一眼当前登记的弹窗类型，然后把“有”或“没有”的答案交回给调用者。

调用图：被 2 处调用（popup_active, set_input_enabled）；外部调用 1 个（matches!）。

fn is_empty(&self) -> bool

作用：判断当前聊天输入框有没有任何图片附件。外层代码可以用它来决定要不要显示附件区域，或发送时是否需要附带图片。

数据流：进去的是当前附件状态 → 它检查本地图片列表和远程图片链接列表是不是都为空 → 出来一个真假值，表示是否完全没有图片，不会改动任何数据。

调用关系：这是一个简单的状态查询函数，通常会被界面或提交流程在需要判断“有没有附件”时使用；它不把工作交给别的函数。

fn local_image_paths(&self) -> Vec<PathBuf>

作用：取出所有本地图片的文件路径。有人只关心图片文件在哪里、不关心占位符文字时会用它。

数据流：进去的是当前保存的本地图片记录 → 它逐个拿出里面的路径并复制一份 → 出来一个路径列表，原来的附件状态不变。

调用关系：这是给外部读取本地图片路径的出口之一；它只读自己的清单，不调用其他内部步骤。

fn local_images(&self) -> Vec<LocalImageAttachment>

作用：取出本地图片的完整发送信息，包括占位符和文件路径。发送或预览时需要知道“哪个占位符对应哪个文件”，就会用到它。

数据流：进去的是当前本地图片记录 → 它把内部记录转换成聊天面板通用的 LocalImageAttachment 格式 → 出来一个新的附件列表，不改变内部状态。

调用关系：这是把内部记账格式交给外部使用的函数；它不处理键盘、不改输入框，只做安全的复制和格式转换。

fn set_remote_image_urls(&mut self, urls: Vec<String>, textarea: &mut TextArea)

作用：一次性设置远程图片链接列表。远程图片数量变了，本地图片的编号也要跟着往后排，所以它会顺手重新编号。

数据流：进去的是新的远程图片 URL 列表和输入框对象 → 它替换旧的远程 URL，清掉当前远程图片选择状态，再调用重新编号逻辑 → 出来时远程图片变成新列表，输入框里的本地图片占位符也可能被改名。

调用关系：当外部拿到一组新的远程图片链接时会走这里；它把编号修正的活交给 AttachmentState::relabel_local_images，避免远程图片和本地图片编号撞车。

调用图：调用 1 个内部函数（relabel_local_images）。

fn remote_image_urls(&self) -> Vec<String>

作用：取出当前所有远程图片链接。外层代码要发送、显示或检查远程图片时会用它。

数据流：进去的是当前附件状态 → 它复制远程图片 URL 列表 → 出来一个独立的新列表，内部保存的 URL 不变。

调用关系：这是远程图片清单的只读出口；它不参与选择、删除或重新编号。

fn take_remote_image_urls(&mut self, textarea: &mut TextArea) -> Vec<String>

作用：把远程图片链接一次性取走，并把这里的远程图片清空。适合在提交消息时使用，因为提交后这些远程图片不该继续留在输入框状态里。

数据流：进去的是当前状态和输入框对象 → 它用 take 把远程 URL 列表搬走，让内部列表变空，清掉选择状态，再重新给本地图片编号 → 出来的是原来的远程 URL 列表，状态里不再保存这些远程图。

调用关系：它通常出现在发送流程中；取走数据后会调用 AttachmentState::relabel_local_images，因为远程图片没了，本地图片的编号要从前面补上。

调用图：调用 1 个内部函数（relabel_local_images）；外部调用 1 个（take）。

fn clear_remote_image_urls(&mut self)

作用：清空所有远程图片链接，并取消当前选中项。它用于放弃或重置远程图片附件。

数据流：进去的是当前附件状态 → 它清掉远程 URL 列表，并把选中的远程图片位置设为空 → 没有返回值，本地图片不重新编号。

调用关系：这是一个直接清理远程图片的工具函数；和 take_remote_image_urls 不同，它不返回被清掉的链接，也不触碰输入框。

fn reset_local_images(
        &mut self,
        local_image_paths: Vec<PathBuf>,
        textarea: &mut TextArea,
    )

作用：用一批新的本地图片路径重建本地图片清单。它常用于从外部状态恢复输入框，或者重新载入附件列表。

数据流：进去的是新的本地图片路径列表和输入框对象 → 它先清空旧本地图片，再按当前远程图片数量给这些本地图生成占位符编号，清掉远程选择，最后修正输入框里的占位符 → 出来时本地图片清单完全换成新的一批。

调用关系：这是本地图片状态的大重置入口；它最后调用 AttachmentState::relabel_local_images，确保输入框文字和内部新编号一致。

调用图：调用 1 个内部函数（relabel_local_images）。

fn attach_image(&mut self, textarea: &mut TextArea, path: PathBuf)

作用：把一张新的本地图片加到聊天输入框里。它会生成一个“图片编号”占位符，并把这个占位符插进输入框。

数据流：进去的是输入框对象和图片文件路径 → 它根据远程图片数和已有本地图片数算出下一个编号，用 local_image_label_text 生成占位符，再让输入框 insert_element 插入这个占位符，最后把路径和占位符记到账本里 → 出来时输入框多了一个图片标记，状态里也多了一张本地图片。

调用关系：当用户添加本地图片时会走这里；它依赖占位符生成函数和输入框的插入能力，让界面显示和后台记录同时更新。

调用图：调用 2 个内部函数（local_image_label_text, insert_element）。

fn prune_local_images_for_submission(
        &mut self,
        text: &str,
        text_elements: &[TextElement],
    )

作用：发送前删掉那些已经不在输入文字里的本地图片记录。这样用户手动删掉占位符后，系统不会偷偷把那张图片也发出去。

数据流：进去的是当前文本和解析出来的文本元素 → 它从文本元素里找出还存在的图片占位符，做成一张快速查找表，然后只保留占位符仍在文本里的本地图片 → 没有返回值，但本地图片清单可能变短。

调用关系：它通常在提交消息前运行；它不改输入框文字，只根据文本元素这份事实清理内部附件清单。

调用图：外部调用 1 个（iter）。

fn take_recent_submission_images(&mut self) -> Vec<PathBuf>

作用：测试中使用：取走最近要提交的本地图片路径，并清空本地图片清单。它帮助测试确认哪些图片会被发送。

数据流：进去的是当前本地图片状态 → 它用 take 把整个本地图片列表搬空，再只取出每张图片的路径 → 出来一个路径列表，内部本地图片列表变为空。

调用关系：这个函数只在测试编译时存在；它服务于测试断言，不参与正式界面的普通运行。

调用图：外部调用 1 个（take）。

fn take_recent_submission_images_with_placeholders(
        &mut self,
    ) -> Vec<LocalImageAttachment>

作用：取走最近要提交的本地图片，并保留每张图对应的占位符。发送流程需要知道“文本里的哪个标记对应哪个文件”时会用它。

数据流：进去的是当前本地图片状态 → 它用 take 把本地图片列表整体搬走并清空内部状态，再转换成 LocalImageAttachment 列表 → 出来的是带占位符和路径的附件列表，状态里不再保留这些本地图片。

调用关系：它适合提交消息时调用；和只取路径的测试函数相比，它保留了占位符信息，方便发送端把文本和图片正确配对。

调用图：外部调用 1 个（take）。

fn remote_image_lines(&self) -> Vec<Line<'static>>

作用：把远程图片列表变成可以显示在终端界面上的一行行文字。当前选中的那一行会用反色高亮，用户就知道自己选中了哪张。

数据流：进去的是远程图片 URL 列表和当前选中下标 → 它按顺序生成“图片 1、图片 2”这类标签，并给选中的标签加上高亮样式 → 出来是一组界面可直接渲染的 Line，不改变状态。

调用关系：这是显示层会调用的函数；它只把状态翻译成界面文字，不处理按键，也不删除图片。

fn clear_remote_image_selection(&mut self)

作用：取消远程图片的当前选中状态。用户离开选择区域，或选中的图片被删完时，需要把这个状态清掉。

数据流：进去的是当前附件状态 → 它把 selected_remote_image_index 设为空 → 没有返回值，只改变选中状态。

调用关系：AttachmentState::handle_remote_image_selection_key 在用户按方向键离开列表时会用它，AttachmentState::remove_selected_remote_image 在删除后没有合适选中项时也会用它。

调用图：被 2 处调用（handle_remote_image_selection_key, remove_selected_remote_image）。

fn handle_remote_image_selection_key(
        &mut self,
        key_event: &KeyEvent,
        textarea: &mut TextArea,
    ) -> Option<(InputResult, bool)>

作用：处理远程图片列表上的键盘操作。用户可以用上箭头进入或上移选择，用下箭头下移或退出选择，用删除键移除选中的远程图片。

数据流：进去的是一次键盘事件和输入框对象 → 它先排除不该处理的情况，比如没有远程图片、带修饰键、不是按下事件；然后根据按键更新选中下标，必要时查询输入框 cursor 位置，删除时调用删除函数 → 出来可能是一个输入处理结果和“事件已被处理”的标记，也可能返回空表示这次按键不归它管。

调用关系：这是远程图片键盘交互的入口；它在需要取消选择时调用 AttachmentState::clear_remote_image_selection，在需要真正删除图片时交给 AttachmentState::remove_selected_remote_image。

调用图：调用 3 个内部函数（clear_remote_image_selection, remove_selected_remote_image, cursor）。

fn remove_deleted_local_placeholders(
        &mut self,
        removed_payloads: &[String],
        textarea: &mut TextArea,
    ) -> bool

作用：当输入框里有图片占位符被删掉时，同步删掉对应的本地图片记录。否则文字里没有图片标记了，后台却还可能发送图片。

数据流：进去的是被删除的占位符文本列表和输入框对象 → 它从本地图片清单里移除占位符匹配的图片，判断长度有没有变化；如果确实删了图片，就重新编号剩下的本地图片 → 出来一个真假值，表示是否真的移除了本地图片，同时状态和输入框占位符可能被更新。

调用关系：它会在输入框报告某些元素被删除后使用；如果清单发生变化，它把编号整理工作交给 AttachmentState::relabel_local_images。

调用图：调用 1 个内部函数（relabel_local_images）。

fn relabel_local_images(&mut self, textarea: &mut TextArea)

作用：重新给本地图片占位符编号，并把输入框里的旧占位符也一起改掉。它是防止图片编号混乱的核心修补工。

数据流：进去的是当前远程图片数量、本地图片列表和输入框对象 → 它逐个计算本地图片应该有的新编号；如果旧占位符不对，就替换内部记录，并让输入框 replace_element_payload 把文本里的旧标记换成新标记 → 没有返回值，但本地图片占位符和输入框内容可能被同步改名。

调用关系：很多会改变图片数量或顺序的函数都会调用它，包括 AttachmentState::set_remote_image_urls、AttachmentState::take_remote_image_urls、AttachmentState::reset_local_images、AttachmentState::remove_deleted_local_placeholders 和 AttachmentState::remove_selected_remote_image。

调用图：调用 2 个内部函数（local_image_label_text, replace_element_payload）；被 5 处调用（remove_deleted_local_placeholders, remove_selected_remote_image, reset_local_images, set_remote_image_urls, take_remote_image_urls）；外部调用 1 个（replace）。

fn remove_selected_remote_image(&mut self, selected_index: usize, textarea: &mut TextArea)

作用：删除当前选中的某一条远程图片链接，并把选择位置挪到合理的位置。删除远程图片后，本地图片编号也要重新排。

数据流：进去的是要删除的远程图片下标和输入框对象 → 如果下标越界，它只清掉选择；如果有效，它从远程 URL 列表删除那一项，再把选中位置移动到下一项或最后一项，列表空了就取消选择，最后重新编号本地图片 → 没有返回值，但远程图片列表、选中状态和本地图片占位符可能都会变化。

调用关系：它由 AttachmentState::handle_remote_image_selection_key 在用户按 Delete 或 Backspace 时调用；内部会按情况调用 AttachmentState::clear_remote_image_selection，并在删除成功后调用 AttachmentState::relabel_local_images。

调用图：调用 2 个内部函数（clear_remote_image_selection, relabel_local_images）；被 1 处调用（handle_remote_image_selection_key）。

fn new(text: String) -> Self

作用：创建一条只有文字的历史记录，适合从旧历史里恢复普通输入。它默认会尝试恢复历史里保存的提及信息。

数据流：输入一段历史文字 → 交给 HistoryEntry::new_with_at_mentions，并打开 @ 提及恢复开关 → 输出一个 HistoryEntry，附件、图片、粘贴内容等字段为空。

调用关系：这是创建历史条目的最常用入口；导航向下清空输入框、测试用例、持久化回复转换时都会间接或直接用它。

调用图：外部调用 1 个（new_with_at_mentions）。

fn new_with_at_mentions(text: String, at_mentions_enabled: bool) -> Self

作用：创建文字历史记录，并按开关决定是否把历史里的 @ 提及恢复成可识别的提及绑定。这个开关用于兼容不同版本的提及写法。

数据流：输入原始文字和是否启用 @ 提及 → 调用 decode_history_mentions_with_at_mentions 解码历史里的提及标记 → 输出带纯文本和 mention_bindings 的 HistoryEntry，其他草稿附件字段为空。

调用关系：HistoryEntry::new 会调用它；ChatComposerHistory::on_entry_response 收到旧历史文字后也用它把字符串变回可放进输入框的草稿。

调用图：调用 1 个内部函数（decode_history_mentions_with_at_mentions）；外部调用 1 个（new）。

fn with_pending(
        text: String,
        text_elements: Vec<TextElement>,
        local_image_paths: Vec<PathBuf>,
        pending_pastes: Vec<(String, String)>,
    ) -> Self

作用：测试里用来造一条带待恢复粘贴内容和本地图片的历史记录。它帮助验证复杂草稿不会在历史回放时丢信息。

数据流：输入文字、文本元素、本地图片路径、待粘贴内容 → 直接装进 HistoryEntry → 输出一条没有远程图片和提及绑定的测试记录。

调用关系：这是测试辅助函数，不参与正常运行；它让测试可以绕过真实输入框，直接准备带附件的历史条目。

调用图：外部调用 1 个（new）。

fn with_pending_and_remote(
        text: String,
        text_elements: Vec<TextElement>,
        local_image_paths: Vec<PathBuf>,
        pending_pastes: Vec<(String, String)>,
        remote_image_

作用：测试里用来造一条同时带本地图片、远程图片和待粘贴内容的历史记录。它覆盖比 with_pending 更完整的草稿场景。

数据流：输入文字、文本元素、本地图片路径、待粘贴内容、远程图片网址 → 填入 HistoryEntry → 输出一条完整的测试历史记录。

调用关系：这是测试专用构造器；正常代码不会调用它，但测试复杂附件恢复时会需要这种假数据。

调用图：外部调用 1 个（new）。

fn new() -> Self

作用：创建一个空的输入框历史管理器。刚创建时还不知道旧历史文件的信息，但已经可以记录本次会话的新输入。

数据流：不需要输入 → 初始化线程编号、旧历史数量、缓存、光标、搜索状态等字段为空或零 → 输出一个可开始使用的 ChatComposerHistory。

调用关系：输入框初始化和大量测试都会先调用它；后续 set_metadata 会补上持久化历史的信息。

调用图：被 12 处调用（new_with_config, duplicate_submissions_are_not_recorded, navigation_with_async_fetch, persistent_restore_gates_at_mentions, repeated_boundary_search_does_not_refetch_persistent_history, reset_navigation_resets_cursor, search_fetches_persistent_history_until_match, search_is_case_insensitive_and_empty_query_finds_latest, search_matches_local_history_and_stops_at_boundaries, search_skips_duplicate_local_matches (+2 more)）；外部调用 2 个（new, new）。