Bottom-pane composer, popups, and mention input

fn handle_key_event(&mut self, _key_event: KeyEvent)

Purpose: Receives a keyboard event while this bottom-pane view is active. The default version ignores the key, so only views that care about typing or shortcuts need to override it.

Data flow: A key event comes in from the terminal. By default, the method does not read or change any view state and returns nothing. A real view can override it to turn keys into changes, such as moving a selection or accepting a form.

Call relations: The bottom pane calls this when the active view should receive a key press. Implementing views can use it as their main input point, while views that do not need keyboard handling inherit the no-op behavior.

fn is_complete(&self) -> bool

Purpose: Tells the bottom pane whether this view has finished and should be removed. The default answer is no, meaning the view stays open unless it overrides this.

Data flow: The bottom pane asks for completion status. The default method reads no state and returns false. Views that track whether the user accepted, cancelled, or finished something can override it to return true at the right time.

Call relations: The bottom pane checks this after input or timed updates. It works together with completion so the surrounding UI can know both that the view is done and why it ended.

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

Purpose: Reports why a finished view ended, such as accepted or cancelled. The default returns no reason because the default view never claims to be complete.

Data flow: The caller asks for a completion reason. The default method reads nothing and returns None. A view that can finish should override this to return a ViewCompletion value once it is done.

Call relations: The bottom pane uses this after is_complete indicates the view is finished. Parent views or the bottom-pane controller can then decide whether to continue, dismiss, or clean up based on the reason.

fn dismiss_after_child_accept(&self) -> bool

Purpose: Says whether this view should also close after a child view is accepted. The default is no, so parent views normally remain open.

Data flow: The bottom pane asks whether accepting a nested child view should remove this parent view. The default reads no state and returns false. Views that start a child flow can override this when accepting the child should also dismiss the parent.

Call relations: This is used in multi-step bottom-pane flows, where one view may open another. After the child completes successfully, the bottom pane can ask the parent whether it should disappear too.

fn clear_dismiss_after_child_accept(&mut self)

Purpose: Clears any temporary marker saying the parent should close after a child is accepted. The default does nothing because most views do not use that marker.

Data flow: The bottom pane calls this after a child view is cancelled. The default changes nothing and returns nothing. A parent view that tracks child-flow cleanup can override it to reset its internal state.

Call relations: This pairs with dismiss_after_child_accept. If a child view is cancelled instead of accepted, the bottom pane gives the parent a chance to undo any pending dismissal plan.

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

Purpose: Provides a stable name for a view that may need to be refreshed from outside while it is open. The default has no identifier.

Data flow: The caller asks for a view identifier. The default reads no state and returns None. Views that need external refreshes can override it with a fixed string ID.

Call relations: The bottom pane or other UI coordination code can use this to recognize that a refreshed view is the same kind of screen as the one already open. Views that do not need that recognition skip it.

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

Purpose: Reports the currently selected item in list-style views. This helps preserve the user's place when a list is refreshed.

Data flow: The caller asks for a selected item number. The default returns None, meaning there is no list selection to preserve. A list view can override it to return the current item index.

Call relations: This supports external refreshes for views that show lists. When the view is rebuilt or updated, surrounding code can use the old selected index to keep the cursor from jumping unexpectedly.

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

Purpose: Reports which tab is active in a tabbed bottom-pane view. The default returns no tab because most views are not tabbed.

Data flow: The caller asks for the active tab identifier. The default reads nothing and returns None. A tabbed view can override it to return the current tab's stable ID.

Call relations: This is another preservation hook for refreshed views. If a tabbed list is updated from outside, the bottom pane can keep the user on the same tab instead of resetting the screen.

fn on_ctrl_c(&mut self) -> CancellationEvent

Purpose: Gives the active view a chance to respond to Ctrl-C, which usually means cancellation. The default says the view did not handle it.

Data flow: A Ctrl-C event reaches the active view. The default does not change state and returns CancellationEvent::NotHandled. A view can override it to cancel itself, reject a prompt, or otherwise mark the event as handled.

Call relations: The bottom pane calls this when Ctrl-C is pressed. If the view does not handle it, the broader application can continue with its normal cancellation behavior.

fn prefer_esc_to_handle_key_event(&self) -> bool

Purpose: Says whether the Esc key should be treated like an ordinary key for this view instead of following the Ctrl-C-style cancellation path. The default says no.

Data flow: The bottom pane asks how Esc should be routed. The default returns false, so Esc can follow the normal cancellation route. A view can override this when Esc has a special local meaning, such as closing a menu inside the view.

Call relations: This guides the bottom pane before it dispatches an Esc key. It decides whether Esc goes to handle_key_event or through cancellation handling.

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

Purpose: Lets a view process pasted text. The default ignores pasted text and says no redraw is needed.

Data flow: A pasted string comes in. The default discards it, changes nothing, and returns false. Text-entry views can override it to insert the pasted content and return true when the screen should be redrawn.

Call relations: The bottom pane calls this when paste input arrives while a modal view is active. It allows views that reuse text composers to behave like the main chat composer.

fn flush_paste_burst_if_due(&mut self) -> bool

Purpose: Allows a view to finish processing a burst of pasted text after a short timing window. The default has no paste burst to flush.

Data flow: The bottom pane asks whether pending paste-burst state should be flushed. The default changes nothing and returns false. A view with paste buffering can override it to finalize the paste and request a redraw if its state changed.

Call relations: This supports the same paste behavior used by the primary composer. The bottom pane can periodically call it so modal text-entry views clean up paste state at the right time.

fn is_in_paste_burst(&self) -> bool

Purpose: Tells whether the view is temporarily holding pasted text in a burst window. The default says no.

Data flow: The bottom pane asks whether paste-burst state is active. The default reads nothing and returns false. A view that buffers paste input can override it to return true while waiting to flush.

Call relations: The bottom pane uses this to decide whether to schedule a short delayed redraw. It works with flush_paste_burst_if_due to make pasted content appear smoothly.

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

Purpose: Lets a view update time-based state immediately before it is drawn. The default does nothing.

Data flow: The current time is passed in before rendering. The default ignores it, changes no state, and returns false. Views with timers, animations, or delayed completion can override it and return true if something changed.

Call relations: The bottom pane calls this just before drawing the active view. If it reports a change, the pane can redraw or notice that the view has completed.

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

Purpose: Gives the active view first chance to take over an approval request. The default does not consume it and hands the same request back.

Data flow: An approval request enters the method. The default wraps and returns the original request unchanged, meaning it was not used. A suitable approval view can override this to absorb the request into its own state and return nothing.

Call relations: When an approval request arrives while a bottom-pane view is open, the bottom pane can ask the current view if it can deal with it. If the request is returned, other code can route it elsewhere.

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

Purpose: Gives the active view a chance to handle a tool's request for user input. The default declines by returning the original request.

Data flow: A user-input request comes in. The default returns that same request unchanged inside Some, signaling that it was not consumed. A form-like view can override it to store or display the request and return None.

Call relations: This is used when external tool interaction asks the user for information while a view is active. The bottom pane checks whether the current view can absorb the request before creating or routing another UI flow.

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

Purpose: Gives the active view a chance to handle an MCP server elicitation form request. MCP here means Model Context Protocol, a way for external servers to ask the app for structured interaction.

Data flow: A server form request enters the method. The default returns the original request unchanged, meaning this view did not use it. A view built for that form can override the method to consume the request and update its displayed state.

Call relations: The bottom pane calls this when an MCP server asks for information and a view is already open. If the current view cannot use the request, the returned value can be handled by another part of the UI.

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

Purpose: Lets a view close or update itself when a request it was showing has already been resolved somewhere else. The default says nothing changed.

Data flow: A resolved app-server request is passed in. The default ignores it, changes no state, and returns false. A view showing that request can override this to dismiss itself or remove the resolved item, then return true.

Call relations: This matters when more than one client or UI surface can answer the same request. The bottom pane can tell the active view that the request is no longer pending so the screen does not keep asking for an already-finished action.

fn terminal_title_requires_action(&self) -> bool

Purpose: Reports whether this view is blocking progress until the user responds. The default says no action is required.

Data flow: The UI asks whether the terminal title should show an action-required state. The default returns false. Views that are waiting for approval or input can override it to return true.

Call relations: The terminal title code can use this while the view is active. If a view requires action, the user can see from the terminal tab title that Codex is waiting on them instead of simply working.

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

Purpose: Tells the bottom pane when this view next needs a time-based redraw. The default asks for no scheduled frame.

Data flow: The bottom pane asks for the next redraw delay. The default returns None, meaning there is no timer to set. Animated or time-sensitive views can override it with a duration, such as “redraw in 100 milliseconds.”

Call relations: This works with pre_draw_tick. A view can request a future frame, and when that time arrives the bottom pane can tick the view and redraw if needed.

fn new(params: BottomPaneParams) -> Self

Purpose: Creates a fresh bottom pane with its composer, key bindings, status placeholders, and modal stack ready to use.

Data flow: It receives setup values such as event sender, redraw scheduler, focus state, paste settings, placeholder text, animation setting, and skill mentions. It builds a ChatComposer, connects it to redraw requests and default key bindings, stores the rest of the UI state, and returns a ready BottomPane.

Call relations: Higher-level UI setup and tests call this when they need a bottom pane. It creates the composer and supporting widgets that nearly all later bottom-pane actions use.

Call graph: calls 5 internal fn (new, new, new, new, defaults); called by 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 external calls (new, new).

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

Purpose: Updates the list of skills that can be mentioned from the composer.

Data flow: It receives an optional list of skill metadata, passes it into the composer, then asks the screen to redraw so the mention UI can reflect the change.

Call relations: This is a small forwarding step from application state into the composer, followed by a visual refresh.

Call graph: calls 2 internal fn (request_redraw, set_skill_mentions).

fn set_image_paste_enabled(&mut self, enabled: bool)

Purpose: Turns image pasting support in the composer on or off.

Data flow: It receives a boolean, gives it to the composer, and requests a redraw because visible paste affordances may change.

Call relations: The pane keeps the composer as the source of truth for input behavior while handling redraw scheduling itself.

Call graph: calls 2 internal fn (request_redraw, set_image_paste_enabled).

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

Purpose: Updates connector mention data used by the composer.

Data flow: It receives an optional connector snapshot, stores it through the composer, and redraws the bottom pane.

Call relations: Application code can refresh connector data here; the composer then uses it when offering mention choices.

Call graph: calls 2 internal fn (request_redraw, set_connector_mentions).

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

Purpose: Updates the plugins that can be mentioned while typing.

Data flow: It receives an optional plugin list, passes it to the composer, and schedules a redraw.

Call relations: Plugin-loading flows call this after plugin mention data is available, so the composer can show up-to-date mention suggestions.

Call graph: calls 2 internal fn (request_redraw, set_plugin_mentions); called by 2 (on_plugin_mentions_loaded, refresh_plugin_mentions).

fn set_plugins_command_enabled(&mut self, enabled: bool)

Purpose: Enables or disables the slash command related to plugins.

Data flow: It receives a boolean, updates the composer command availability, and redraws.

Call relations: This lets feature flags or runtime state control which composer commands the user can invoke.

Call graph: calls 2 internal fn (request_redraw, set_plugins_command_enabled).

fn set_token_activity_command_enabled(&mut self, enabled: bool)

Purpose: Enables or disables the command for showing token activity.

Data flow: It passes the enabled flag into the composer and requests a redraw.

Call relations: The bottom pane exposes this as a simple switch while the composer owns command behavior.

Call graph: calls 2 internal fn (request_redraw, set_token_activity_command_enabled).

fn set_mentions_v2_enabled(&mut self, enabled: bool)

Purpose: Switches the newer mention system on or off for the composer.

Data flow: It receives a boolean, forwards it to the composer, and redraws.

Call relations: Feature configuration can call this to change how mentions behave without touching composer internals directly.

Call graph: calls 2 internal fn (request_redraw, set_mentions_v2_enabled).

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

Purpose: Removes and returns mention bindings currently held by the composer.

Data flow: It asks the composer for its stored mention bindings; the composer clears them and returns the list.

Call relations: Submission cleanup calls this when it needs to drain state that belongs to the message being sent.

Call graph: calls 1 internal fn (take_mention_bindings); called by 1 (drain_pending_submission_state).

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

Purpose: Returns mention bindings tied to the most recent submitted message and clears that pending record.

Data flow: It delegates to the composer, which gives back the recent bindings and forgets them.

Call relations: Used during pending submission cleanup so old mention data is not accidentally reused.

Call graph: calls 1 internal fn (take_recent_submission_mention_bindings); called by 1 (drain_pending_submission_state).

fn record_pending_slash_command_history(&mut self)

Purpose: Tells the composer to remember a pending slash command in history.

Data flow: It has no external input. It asks the composer to record its current pending command history state.

Call relations: This is a narrow bridge from surrounding app flow into composer history behavior.

Call graph: calls 1 internal fn (record_pending_slash_command_history).

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

Purpose: Replaces the active keyboard shortcuts used by the bottom pane and its composer.

Data flow: It receives a runtime keymap, stores a copy, updates the composer, updates interrupt shortcut hints in preview and status widgets, then redraws.

Call relations: When key bindings change, this keeps every visible bottom-pane hint aligned with the new shortcut rules.

Call graph: calls 4 internal fn (request_redraw, set_keymap_bindings, set_interrupt_binding, primary_binding); 1 external calls (clone).

fn drain_pending_submission_state(&mut self)

Purpose: Clears leftover attachments, remote image URLs, and mention bindings from a pending submission.

Data flow: It calls several take-style methods that return and clear data, then discards the returned values.

Call relations: Submission flows call this as a cleanup step so stale data from an abandoned or completed submission cannot leak into the next one.

Call graph: calls 4 internal fn (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)

Purpose: Turns collaboration-mode command support on or off in the composer.

Data flow: It forwards the boolean to the composer and redraws.

Call relations: This exposes collaboration feature availability to the typing UI.

Call graph: calls 2 internal fn (request_redraw, set_collaboration_modes_enabled).

fn set_connectors_enabled(&mut self, enabled: bool)

Purpose: Enables or disables connector-related composer behavior.

Data flow: It receives a boolean and forwards it to the composer. It does not request a redraw here.

Call relations: The pane acts as the public access point, while the composer decides what the flag means for input.

Call graph: calls 1 internal fn (set_connectors_enabled).

fn set_windows_degraded_sandbox_active(&mut self, enabled: bool)

Purpose: Shows or hides composer UI related to a degraded Windows sandbox mode.

Data flow: It passes the flag to the composer and redraws so the user can see the changed state.

Call relations: Runtime environment checks can call this to reflect sandbox limitations in the input area.

Call graph: calls 2 internal fn (request_redraw, set_windows_degraded_sandbox_active).

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

Purpose: Sets the small visual indicator for the current collaboration mode.

Data flow: It receives an optional indicator, gives it to the composer, and redraws.

Call relations: This keeps the composer display in sync with collaboration state selected elsewhere.

Call graph: calls 2 internal fn (request_redraw, set_collaboration_mode_indicator).

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

Purpose: Sets the visual indicator for goal status in the composer.

Data flow: It receives an optional goal indicator, forwards it, and redraws.

Call relations: Goal-related application state uses this to surface progress or mode information in the bottom pane.

Call graph: calls 2 internal fn (request_redraw, set_goal_status_indicator).

fn set_ide_context_active(&mut self, active: bool)

Purpose: Marks whether IDE context is currently active in the composer UI.

Data flow: It receives a boolean, updates the composer, and requests a redraw.

Call relations: IDE integration state can call this so the user sees whether editor context is being used.

Call graph: calls 2 internal fn (request_redraw, set_ide_context_active).

fn set_personality_command_enabled(&mut self, enabled: bool)

Purpose: Enables or disables the personality slash command.

Data flow: It sends the enabled flag to the composer and redraws.

Call relations: Feature or account state can use this to change available commands.

Call graph: calls 2 internal fn (request_redraw, set_personality_command_enabled).

fn set_service_tier_commands_enabled(&mut self, enabled: bool)

Purpose: Enables or disables service-tier commands in the composer.

Data flow: It forwards the flag to the composer and redraws.

Call relations: This lets app state control whether service-tier options are visible or usable.

Call graph: calls 2 internal fn (request_redraw, set_service_tier_commands_enabled).

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

Purpose: Provides the composer with the current service-tier command choices.

Data flow: It receives a list of commands, passes them to the composer, and redraws.

Call relations: When available service tiers change, this updates the command menu shown while typing.

Call graph: calls 2 internal fn (request_redraw, set_service_tier_commands).

fn set_goal_command_enabled(&mut self, enabled: bool)

Purpose: Enables or disables the goal-related slash command.

Data flow: It forwards the boolean to the composer and redraws.

Call relations: Goal feature setup can call this to expose or hide the command.

Call graph: calls 2 internal fn (request_redraw, set_goal_command_enabled).

fn set_side_conversation_active(&mut self, active: bool)

Purpose: Marks whether the composer is currently in a side conversation.

Data flow: It passes the active flag to the composer and redraws.

Call relations: Conversation-mode orchestration calls this so the input area shows the right context.

Call graph: calls 2 internal fn (request_redraw, set_side_conversation_active).

fn set_placeholder_text(&mut self, placeholder: String)

Purpose: Changes the placeholder text shown when the composer is empty.

Data flow: It receives the new placeholder string, stores it in the composer, and redraws.

Call relations: Other flows use this when the input box needs different guidance for the user.

Call graph: calls 2 internal fn (request_redraw, set_placeholder_text).

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

Purpose: Changes the shortcut shown for editing queued messages.

Data flow: It receives an optional key binding, stores it in the pending input preview, and redraws.

Call relations: Queue-related UI uses this so shortcut hints match the current keymap.

Call graph: calls 2 internal fn (request_redraw, set_edit_binding).

fn set_vim_enabled(&mut self, enabled: bool)

Purpose: Turns Vim-style editing mode on or off in the composer.

Data flow: It forwards the enabled flag to the composer and redraws.

Call relations: Settings or commands call this to update editor behavior and visible mode state.

Call graph: calls 2 internal fn (request_redraw, set_vim_enabled).

fn toggle_vim_enabled(&mut self) -> bool

Purpose: Flips Vim-style editing mode and reports the new state.

Data flow: It asks the composer to toggle the setting, requests a redraw, and returns whether Vim mode is now enabled.

Call relations: The command that toggles Vim mode calls this, then can notify the user of the resulting state.

Call graph: calls 2 internal fn (request_redraw, toggle_vim_enabled); called by 1 (toggle_vim_mode_and_notify).

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

Purpose: Returns the current status indicator widget, if one exists.

Data flow: It reads the optional status field and returns a shared reference without changing anything.

Call relations: Rendering or inspection code can use this to look at task status UI.

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

Purpose: Returns the skills currently known by the composer.

Data flow: It asks the composer for its optional skills list and returns that reference.

Call relations: Other code can inspect available skill mentions through the bottom pane.

Call graph: calls 1 internal fn (skills).

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

Purpose: Returns the plugin mention data currently known by the composer.

Data flow: It asks the composer for its optional plugin list and returns it.

Call relations: Plugin mention flows use this to check or reuse the current plugin data.

Call graph: calls 1 internal fn (plugins); called by 2 (on_plugin_mentions_loaded, plugins_for_mentions).

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

Purpose: Reports the stored context-window usage percentage, if known.

Data flow: It reads the cached percentage and returns it.

Call relations: Token information displays can query this simple value from the pane.

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

Purpose: Reports the stored number of used context-window tokens, if known.

Data flow: It reads the cached token count and returns it.

Call relations: Token information displays can query this alongside the percentage.

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

Purpose: Finds the currently active modal or popup view, if any.

Data flow: It looks at the last item in the view stack and returns it as a generic bottom-pane view reference.

Call relations: Rendering, frame scheduling, and title-state checks use this to treat the topmost modal as the active UI.

Call graph: called by 3 (as_renderable_with_composer_right_reserve, schedule_active_view_frame, terminal_title_requires_action).

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

Purpose: Shows a new modal or popup by putting it on top of the view stack.

Data flow: It receives a boxed view, pushes it onto the stack, schedules any animation frame it needs, and redraws.

Call relations: All flows that open approval prompts, selection lists, and other overlays route through this helper.

Call graph: calls 2 internal fn (request_redraw, schedule_active_view_frame); called by 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>)

Purpose: Closes the top modal and reacts to whether it was accepted or cancelled.

Data flow: It removes the active view. If a child view was accepted, it may also remove parent views that asked to disappear after child acceptance; if cancelled, it clears that parent-dismiss flag. It then runs the stack-depth cleanup path.

Call relations: Key handling and Ctrl-C call this when a modal finishes, so follow-up cleanup is consistent.

Call graph: calls 1 internal fn (on_view_stack_depth_decreased); called by 2 (handle_key_event, on_ctrl_c).

fn on_view_stack_depth_decreased(&mut self)

Purpose: Runs cleanup when one or more modal views have been removed.

Data flow: It checks whether the view stack is now empty. If so, it calls the active-view-complete cleanup.

Call relations: Modal dismissal paths use this to resume normal composer input only after all modals are gone.

Call graph: calls 1 internal fn (on_active_view_complete); called by 2 (dismiss_app_server_request, pop_active_view_with_completion).

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

Purpose: Calculates how much longer an approval prompt should wait because the user was recently typing.

Data flow: It reads the last composer activity time and the current time. If the idle delay has not passed, it returns the remaining duration; otherwise it returns nothing.

Call relations: Approval prompt scheduling uses this to avoid popping a modal in front of someone mid-typing.

Call graph: called by 3 (maybe_show_delayed_approval_requests_at, push_approval_request, record_composer_activity_at).

fn record_composer_activity_at(&mut self, now: Instant)

Purpose: Records that the user just typed or edited in the composer.

Data flow: It stores the activity time. If approval requests are waiting, it schedules a redraw for the moment they may become eligible to show.

Call relations: Key and paste handling call this so delayed approval prompts follow the latest typing activity.

Call graph: calls 2 internal fn (approval_prompt_delay_remaining, request_redraw_in); called by 2 (handle_key_event, handle_paste); 1 external calls (is_empty).

fn maybe_show_delayed_approval_requests_at(&mut self, now: Instant)

Purpose: Shows delayed approval prompts once the user has been idle long enough.

Data flow: It checks for queued approval requests and active modals. If still within the delay, it schedules a future redraw. Otherwise it builds an approval overlay from the queued requests, pauses the status timer, and pushes the modal.

Call relations: Pre-draw ticks and approval insertion call this to promote waiting requests at the right time.

Call graph: calls 5 internal fn (approval_prompt_delay_remaining, pause_status_timer_for_modal, push_view, request_redraw_in, new); called by 2 (pre_draw_tick_at, push_approval_request); 5 external calls (new, is_empty, pop_back, pop_front, clone).

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

Purpose: Routes a keyboard event to the right place: active modal, task interrupt, or normal composer.

Data flow: It receives a key event. If a modal is open, it lets that view process it and closes the view if complete. Otherwise it may interrupt a running task if the configured shortcut was pressed, or pass the key to the composer. It records typing activity, schedules paste-burst redraws, and returns the composer input result when applicable.

Call relations: This is one of the central main-loop entry points for the bottom pane. It coordinates modal behavior, task status, keymap rules, and composer editing.

Call graph: calls 11 internal fn (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 external calls (now, matches!).

fn on_ctrl_c(&mut self) -> CancellationEvent

Purpose: Implements the pane's response to Ctrl-C.

Data flow: If a modal is open, it gives the modal a chance to cancel. If the composer is searching history, it cancels that search. If the composer is empty, it says Ctrl-C was not handled. Otherwise it clears the draft, records it to history when possible, shows the quit shortcut hint, redraws, and reports that Ctrl-C was handled.

Call relations: Global cancellation handling calls this to decide whether Ctrl-C affected the bottom pane or should be handled by the wider app.

Call graph: calls 6 internal fn (clear_composer_for_ctrl_c, composer_is_empty, pop_active_view_with_completion, request_redraw, show_quit_shortcut_hint, ctrl); 3 external calls (Char, matches!, cancel_history_search).

fn handle_paste(&mut self, pasted: String)

Purpose: Routes pasted text to the active modal or to the composer.

Data flow: It receives pasted text. If a modal is open, the modal processes it and may complete. Otherwise the composer processes it, typing activity is recorded for non-empty paste text, and redraws happen when needed.

Call relations: Terminal paste handling enters here so paste behavior stays consistent with whether a modal is currently active.

Call graph: calls 4 internal fn (on_active_view_complete, record_composer_activity_at, request_redraw, handle_paste); 1 external calls (now).

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

Purpose: Programmatically inserts text into the composer.

Data flow: It receives a string slice, inserts it through the composer, and redraws.

Call relations: Higher-level commands use this when they need to add text as if it had been typed.

Call graph: calls 2 internal fn (request_redraw, insert_str); called by 1 (insert_str).

fn pre_draw_tick(&mut self)

Purpose: Runs time-based updates just before drawing.

Data flow: It gets the current time and passes it to the time-aware tick helper.

Call relations: The UI loop calls this before rendering so delayed prompts, animations, and popups are current.

Call graph: calls 1 internal fn (pre_draw_tick_at); called by 1 (pre_draw_tick); 1 external calls (now).

fn pre_draw_tick_at(&mut self, now: Instant)

Purpose: Runs all bottom-pane updates that depend on time.

Data flow: It receives a timestamp, syncs composer popups, tries to show delayed approvals, ticks the active view, and schedules the next active-view frame if needed.

Call relations: The normal pre-draw tick and tests use this to drive timed behavior deterministically.

Call graph: calls 4 internal fn (maybe_show_delayed_approval_requests_at, schedule_active_view_frame, tick_active_view, sync_popups); called by 1 (pre_draw_tick).

fn tick_active_view(&mut self, now: Instant)

Purpose: Lets the active modal update itself before drawing.

Data flow: It gives the current time to the top view. If the view needs redraw or completes, it redraws; if complete, it clears the stack and runs modal-completion cleanup.

Call relations: Pre-draw ticking calls this so modals can animate, time out, or finish themselves.

Call graph: calls 2 internal fn (on_active_view_complete, request_redraw); called by 1 (pre_draw_tick_at).

fn schedule_active_view_frame(&self)

Purpose: Schedules the next redraw needed by the active view.

Data flow: It asks the active view for its next frame delay. If there is one, it schedules a future redraw after that delay.

Call relations: Opening, replacing, dismissing, and ticking views use this to keep modal animations or timers moving.

Call graph: calls 2 internal fn (active_view, request_redraw_in); called by 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>,
    )

Purpose: Replaces the composer contents with given text, structured text elements, and local images.

Data flow: It sends the new content to the composer, moves the cursor to the end, and redraws.

Call relations: External editing or state restoration paths use this to reset the draft shown in the input box.

Call graph: calls 3 internal fn (request_redraw, move_cursor_to_end, set_text_content); called by 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

Purpose: Replaces composer content while preserving explicit mention binding information.

Data flow: It receives text, text elements, image paths, and mention bindings, installs them in the composer, moves the cursor to the end, and redraws.

Call relations: This is used when restoring or editing text that already has resolved mentions attached to it.

Call graph: calls 3 internal fn (request_redraw, move_cursor_to_end, set_text_content_with_mention_bindings).

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

Purpose: Enables or disables typing in the composer, optionally changing the placeholder text.

Data flow: It passes the enabled flag and optional placeholder to the composer, then redraws.

Call relations: Modal flows disable normal typing while the user must answer a prompt, and modal completion re-enables it.

Call graph: calls 2 internal fn (request_redraw, set_input_enabled); called by 3 (on_active_view_complete, push_mcp_server_elicitation_request, push_user_input_request).

fn show_shutdown_in_progress(&mut self)

Purpose: Switches the pane into a shutdown message state.

Data flow: It clears active views, tells the composer to show shutdown-in-progress UI, and redraws.

Call relations: Application shutdown flow uses this so the user sees that input is no longer normal.

Call graph: calls 2 internal fn (request_redraw, show_shutdown_in_progress); called by 1 (show_shutdown_in_progress).

fn clear_composer_for_ctrl_c(&mut self)

Purpose: Clears the current draft because Ctrl-C cancelled it, while trying to save that draft to history.

Data flow: It asks the composer to clear and return the old text. If a thread id is known, it sends an app event to append that text to message history; otherwise it logs a warning. It redraws afterward.

Call relations: Ctrl-C handling calls this when the draft is non-empty and should be cancelled rather than submitted.

Call graph: calls 3 internal fn (send, request_redraw, clear_for_ctrl_c); called by 1 (on_ctrl_c); 1 external calls (warn!).

fn composer_text(&self) -> String

Purpose: Returns the current plain text in the composer.

Data flow: It asks the composer for its current text and returns the string.

Call relations: Key routing uses this to detect special slash-command context, and other code can inspect the draft.

Call graph: calls 1 internal fn (current_text); called by 1 (handle_key_event).

fn composer_cursor(&self) -> usize

Purpose: Returns the current cursor position in the composer text.

Data flow: It reads the cursor index from the composer and returns it.

Call relations: Cursor-aware UI or tests can query this through the pane.

Call graph: calls 1 internal fn (cursor).

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

Purpose: Captures the current composer draft as a snapshot.

Data flow: It asks the composer to package its draft state and returns that snapshot.

Call relations: State-saving flows can use this without reaching into composer internals.

Call graph: calls 1 internal fn (draft_snapshot).

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

Purpose: Returns structured text elements from the current composer draft.

Data flow: It asks the composer for its text elements and returns them as a vector.

Call relations: Submission and editing flows use these elements when plain text alone is not enough.

Call graph: calls 1 internal fn (text_elements).

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

Purpose: Returns local image attachments currently associated with the composer.

Data flow: It asks the composer for local image attachment records and returns them.

Call relations: Message submission can collect attached images through this method.

Call graph: calls 1 internal fn (local_images).

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

Purpose: Returns the file paths of local images attached in the composer.

Data flow: It asks the composer for image paths and returns them.

Call relations: Code that only needs paths, not full attachment records, can use this shortcut.

Call graph: calls 1 internal fn (local_image_paths).

fn composer_text_with_pending(&self) -> String

Purpose: Returns composer text including any pending pasted content.

Data flow: It asks the composer for its text plus pending paste state and returns that string.

Call relations: Submission or preview code can see what the user effectively has queued to send.

Call graph: calls 1 internal fn (current_text_with_pending).

fn composer_input_enabled(&self) -> bool

Purpose: Reports whether normal composer typing is currently enabled.

Data flow: It reads the composer input-enabled flag and returns it.

Call relations: Modal and app-state code can check whether the user should currently be able to type.

Call graph: calls 1 internal fn (input_enabled).

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

Purpose: Returns paste chunks that the composer is still holding as pending.

Data flow: It asks the composer for its pending paste pairs and returns them.

Call relations: Paste-burst handling and tests can inspect this buffered paste state.

Call graph: calls 1 internal fn (pending_pastes).

fn apply_external_edit(&mut self, text: String)

Purpose: Applies text returned from an external editor to the composer.

Data flow: It receives edited text, gives it to the composer, and redraws.

Call relations: External-editor integration uses this when the user finishes editing outside the terminal UI.

Call graph: calls 2 internal fn (request_redraw, apply_external_edit).

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

Purpose: Overrides the composer footer hints with custom key-label pairs.

Data flow: It receives optional hint items, passes them to the composer, and redraws.

Call relations: Temporary modes can use this to change the help text shown under the input area.

Call graph: calls 2 internal fn (request_redraw, set_footer_hint_override).

fn set_plan_mode_nudge_visible(&mut self, visible: bool)

Purpose: Shows or hides a plan-mode nudge in the composer.

Data flow: It passes the requested visibility to the composer. If the composer says something changed, it redraws.

Call relations: Planning-mode guidance can be toggled without causing unnecessary redraws when nothing changed.

Call graph: calls 2 internal fn (request_redraw, set_plan_mode_nudge_visible).

fn plan_mode_nudge_visible(&self) -> bool

Purpose: Reports whether the plan-mode nudge is currently visible.

Data flow: It reads this state from the composer and returns it.

Call relations: Other UI logic can check the current nudge state through the bottom pane.

Call graph: calls 1 internal fn (plan_mode_nudge_visible).

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

Purpose: Stores remote image URLs attached to the current composer draft.

Data flow: It receives URL strings, gives them to the composer, and redraws.

Call relations: Image attachment flows call this when images are represented by remote URLs instead of local files.

Call graph: calls 2 internal fn (request_redraw, set_remote_image_urls); called by 1 (set_remote_image_urls).

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

Purpose: Returns remote image URLs currently attached in the composer.

Data flow: It asks the composer for its URL list and returns it.

Call relations: Submission or inspection code can collect remote image attachments here.

Call graph: calls 1 internal fn (remote_image_urls); called by 1 (remote_image_urls).

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

Purpose: Removes and returns remote image URLs from the composer.

Data flow: It asks the composer to take the URL list, redraws, and returns the removed URLs.

Call relations: Submission cleanup uses this so image URLs are consumed once and not reused.

Call graph: calls 2 internal fn (request_redraw, take_remote_image_urls); called by 2 (drain_pending_submission_state, take_remote_image_urls).

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

Purpose: Replaces the composer's pending paste buffer.

Data flow: It receives pending paste pairs, passes them to the composer, and redraws.

Call relations: State restoration or tests can set paste-burst state directly through this method.

Call graph: calls 2 internal fn (request_redraw, set_pending_pastes).

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

Purpose: Updates the visible status indicator text.

Data flow: It receives a header, optional details, capitalization setting, and maximum detail lines. If a status widget exists, it updates those fields and redraws.

Call relations: Running-task updates use this to refresh the short status message shown above the composer.

Call graph: calls 1 internal fn (request_redraw).

fn show_quit_shortcut_hint(&mut self, key: KeyBinding)

Purpose: Shows a temporary hint telling the user the quit shortcut.

Data flow: It receives the key binding to display. If the feature is enabled, it asks the composer to show the hint, schedules a future frame after the timeout using Tokio or a fallback thread, and redraws.

Call relations: Ctrl-C handling calls this after consuming cancellation, so the user learns how to quit if they press again.

Call graph: calls 2 internal fn (request_redraw, show_quit_shortcut_hint); called by 1 (on_ctrl_c); 4 external calls (spawn, try_current, sleep, clone).

fn clear_quit_shortcut_hint(&mut self)

Purpose: Hides the quit shortcut hint.

Data flow: It tells the composer to clear the hint using the current focus state and redraws.

Call relations: Other input or state changes can clear the temporary quit hint.

Call graph: calls 2 internal fn (request_redraw, clear_quit_shortcut_hint).

fn quit_shortcut_hint_visible(&self) -> bool

Purpose: Reports whether the quit shortcut hint is currently visible.

Data flow: It reads the visibility state from the composer and returns it.

Call relations: Tests and UI logic use this to confirm hint behavior.

Call graph: calls 1 internal fn (quit_shortcut_hint_visible).

fn status_indicator_visible(&self) -> bool

Purpose: Reports whether a status indicator widget currently exists.

Data flow: It checks whether the optional status field is present and returns a boolean.

Call relations: Other UI code can use this to decide whether status is being shown.

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

Purpose: Returns the composer's current status-line text, if any.

Data flow: It asks the composer for status-line text and returns it.

Call relations: Outer UI code can surface or test the status line through the pane.

Call graph: calls 1 internal fn (status_line_text); called by 1 (status_line_text).

fn show_esc_backtrack_hint(&mut self)

Purpose: Shows a hint that Escape can be used for backtracking.

Data flow: It marks the hint as active in the pane, tells the composer to show it, and redraws.

Call relations: Navigation guidance calls this when the app wants to teach or remind the user about Escape behavior.

Call graph: calls 2 internal fn (request_redraw, set_esc_backtrack_hint); called by 1 (show_esc_backtrack_hint).

fn clear_esc_backtrack_hint(&mut self)

Purpose: Hides the Escape backtrack hint if it is currently shown.

Data flow: It checks the pane's flag. If active, it clears the flag, tells the composer to hide the hint, and redraws.

Call relations: Navigation state changes call this when the hint is no longer relevant.

Call graph: calls 2 internal fn (request_redraw, set_esc_backtrack_hint); called by 1 (clear_esc_backtrack_hint).

fn set_task_running(&mut self, running: bool)

Purpose: Marks whether an assistant task is currently running and updates the visible task status UI.

Data flow: It receives a running flag, stores it, and tells the composer. When a task starts, it creates a status indicator if needed, shows the interrupt hint, syncs inline execution summary text, and redraws. When a task ends, it hides the status indicator.

Call relations: Task submission and review-mode flows call this so the bottom pane reflects work in progress and offers the interrupt shortcut.

Call graph: calls 6 internal fn (hide_status_indicator, request_redraw, sync_status_inline_message, set_task_running, primary_binding, new); called by 2 (enter_review_mode_with_hint, submit_op); 2 external calls (clone, clone).

fn set_queue_submissions(&mut self, queue_submissions: bool)

Purpose: Tells the composer whether new submissions should be queued.

Data flow: It receives a boolean and forwards it to the composer.

Call relations: Queueing policy is controlled outside the composer but applied to composer behavior here.

Call graph: calls 1 internal fn (set_queue_submissions).

fn hide_status_indicator(&mut self)

Purpose: Removes the status indicator if it is currently visible.

Data flow: It takes the status widget out of the pane. If one was removed, it redraws.

Call relations: Task completion uses this to clear running-task UI while leaving any modal views alone.

Call graph: calls 1 internal fn (request_redraw); called by 1 (set_task_running).

fn ensure_status_indicator(&mut self)

Purpose: Creates a status indicator if one is not already present.

Data flow: It checks the status field. If missing, it builds a new widget, applies the current interrupt shortcut, syncs inline execution text, and redraws.

Call relations: Code that needs status UI can call this without worrying whether it already exists.

Call graph: calls 4 internal fn (request_redraw, sync_status_inline_message, primary_binding, new); 2 external calls (clone, clone).

fn set_interrupt_hint_visible(&mut self, visible: bool)

Purpose: Shows or hides the interrupt shortcut hint inside the status indicator.

Data flow: It receives a visibility flag, updates the status widget if present, and redraws.

Call relations: Task UI can adjust whether interrupt guidance should be displayed.

Call graph: calls 1 internal fn (request_redraw).

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

Purpose: Updates context-window usage information shown in the composer.

Data flow: It receives optional percent and used-token values. If they differ from cached values, it stores them, updates the composer, and redraws.

Call relations: Token information flows call this to keep the bottom pane's usage indicator current without redrawing for unchanged values.

Call graph: calls 2 internal fn (request_redraw, set_context_window); called by 3 (apply_token_info, restore_pre_review_token_info, set_token_info).

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

Purpose: Opens a list-style selection popup.

Data flow: It receives selection-view parameters, applies the standard cancel/help hint, builds a list view with app events and list keymap, and pushes it onto the modal stack.

Call relations: Feature prompts such as feedback consent or enablement prompts call this to ask the user to choose from a list.

Call graph: calls 3 internal fn (apply_standard_popup_hint, push_view, new); called by 3 (open_feedback_consent, open_memories_enable_prompt, open_multi_agent_enable_prompt); 2 external calls (new, clone).

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

Purpose: Fills in the standard popup footer hint when a selection view allows cancellation.

Data flow: It receives mutable selection parameters. If cancellation is not allowed, it removes the standard hint. If cancellation is allowed and no custom hint is present, it inserts the keymap-aware standard hint.

Call relations: Selection-view creation and replacement call this so popup help text is consistent with the current keymap.

Call graph: calls 2 internal fn (standard_popup_hint_line, standard_popup_hint_line); called by 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

Purpose: Replaces the currently active selection view if it has a matching id.

Data flow: It checks the top view id. If it matches, it removes that view, applies standard hints to the new parameters, builds a new list view, pushes it, and returns true; otherwise it returns false.

Call relations: Flows that refresh an open selection popup use this when only the active popup should be replaced.

Call graph: calls 3 internal fn (apply_standard_popup_hint, push_view, new); 2 external calls (new, clone).

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

Purpose: Replaces a matching selection view anywhere in the view stack.

Data flow: It searches the stack from the top for the given id. If found, it builds a replacement list view and swaps it in; if the replaced view was active, it schedules its frame. It redraws and returns true.

Call relations: This is used when a popup may be underneath another view but still needs its contents updated.

Call graph: calls 4 internal fn (apply_standard_popup_hint, request_redraw, schedule_active_view_frame, new); 2 external calls (new, clone).

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

Purpose: Builds the standard popup help line using the current list keymap.

Data flow: It reads the pane's list keymap and asks the popup constants helper for the matching hint line.

Call relations: Popup hint application calls this so help text reflects customized shortcuts.

Call graph: calls 1 internal fn (standard_popup_hint_line_for_keymap); called by 1 (apply_standard_popup_hint).

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

Purpose: Returns a copy of the current list-navigation keymap.

Data flow: It clones the list part of the runtime keymap and returns it.

Call relations: Views opened elsewhere use this to apply the same list controls as the bottom pane.

Call graph: called by 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

Purpose: Replaces one or more active stacked views with a new selection view when their ids match a given set.

Data flow: It checks whether the top view id is in the given id list. If so, it pops all consecutive matching views from the top, applies standard hints, builds the replacement list view, pushes it, and returns true.

Call relations: Multi-step popup flows use this to collapse old related views into a new selection screen.

Call graph: calls 3 internal fn (apply_standard_popup_hint, push_view, new); 2 external calls (new, clone).

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

Purpose: Returns the selected row index for the active view if its id matches.

Data flow: It checks the top view id, then asks that view for its selected index.

Call relations: Outer logic can remember or inspect selection state for a specific active popup.

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

Purpose: Returns the active tab id for the active view if its id matches.

Data flow: It checks the top view id, then asks that view for its active tab id.

Call relations: Tabbed popups can expose their current tab through this helper.

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

Purpose: Closes the active view only if it has a specific id.

Data flow: It compares the top view id to the requested id. If it matches, it pops the view, redraws, and returns true; otherwise it returns false.

Call relations: Targeted dismissal flows use this to avoid closing the wrong modal.

Call graph: calls 1 internal fn (request_redraw).

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

Purpose: Closes the most recent view with a given id, even if it is not active.

Data flow: It searches the stack from the top. If found, it removes that view, schedules a frame if the active view changed, redraws, and returns true.

Call relations: This supports cleanup of nested or background popup views by identity.

Call graph: calls 2 internal fn (request_redraw, schedule_active_view_frame).

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

Purpose: Updates the preview of queued messages and steering instructions.

Data flow: It receives queued messages, pending steers, and rejected steers, stores them in the preview widget, and redraws.

Call relations: Queue and steering flows call this so the user can see what input is waiting or rejected.

Call graph: calls 1 internal fn (request_redraw).

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

Purpose: Updates the list of threads waiting for approval.

Data flow: It gives the thread list to the pending approvals widget. If that widget reports a change, it redraws.

Call relations: Thread approval state changes flow through this to update the bottom-pane preview.

Call graph: calls 2 internal fn (request_redraw, set_threads); called by 1 (set_pending_thread_approvals).

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

Purpose: Returns the current thread names or ids waiting for approval.

Data flow: It asks the pending approvals widget for its thread slice and returns it.

Call relations: Outer code and tests can inspect pending approval state through this method.

Call graph: calls 1 internal fn (threads); called by 1 (pending_thread_approvals).

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

Purpose: Updates the list of running execution processes shown in the footer or status line.

Data flow: It passes process names to the unified execution footer. If the list changed, it syncs the status inline message and redraws.

Call relations: Execution tracking code uses this to keep the bottom pane's running-process summary current.

Call graph: calls 3 internal fn (request_redraw, sync_status_inline_message, set_processes).

fn sync_status_inline_message(&mut self)

Purpose: Copies the execution footer summary into the status indicator.

Data flow: It reads the footer summary text and, if a status widget exists, updates that widget's inline message.

Call relations: Status creation, task-start logic, and process updates call this so the status line and execution footer do not drift apart.

Call graph: calls 1 internal fn (summary_text); called by 3 (ensure_status_indicator, set_task_running, set_unified_exec_processes).

fn composer_is_empty(&self) -> bool

Purpose: Reports whether the composer draft is empty.

Data flow: It asks the composer whether it has any content and returns that boolean.

Call relations: Ctrl-C handling uses this to decide whether to clear a draft or let cancellation bubble up.

Call graph: calls 1 internal fn (is_empty); called by 2 (on_ctrl_c, composer_is_empty).

fn composer_is_vim_enabled(&self) -> bool

Purpose: Reports whether Vim-style editing is enabled in the composer.

Data flow: It asks the composer for its Vim-mode flag and returns it.

Call relations: Settings and tests can query the current editor mode through the pane.

Call graph: calls 1 internal fn (is_vim_enabled).

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

Purpose: Decides whether Escape should be handled by the composer for Vim insert-mode behavior.

Data flow: It receives a key event, asks the composer whether that key should switch Vim state, and returns the answer.

Call relations: Key routing uses this to avoid treating Escape as a task interrupt when the composer needs it for Vim editing.

Call graph: calls 1 internal fn (should_handle_vim_insert_escape); called by 2 (handle_key_event, should_handle_vim_insert_escape).

fn is_task_running(&self) -> bool

Purpose: Reports whether the pane currently believes a task is running.

Data flow: It returns the stored running-task boolean.

Call relations: Submission and review-mode code use this to make decisions about current task state.

Call graph: called by 3 (enter_review_mode_with_hint, is_task_running_for_test, submit_op).

fn terminal_title_requires_action(&self) -> bool

Purpose: Reports whether the active modal needs user attention in the terminal title.

Data flow: It checks the active view and asks whether it requires action; if no view is active, it returns false.

Call relations: Terminal title updating uses this to flag pending user decisions.

Call graph: calls 1 internal fn (active_view).

fn has_active_view(&self) -> bool

Purpose: Reports whether any modal or popup view is active.

Data flow: It checks whether the view stack is non-empty and returns that boolean.

Call relations: Other UI code uses this as a simple guard for modal state.

Call graph: called by 1 (has_active_view).

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

Purpose: Returns the id of the active view, if it has one.

Data flow: It looks at the top view and asks for its optional id.

Call relations: Targeted popup logic can identify which view is currently on top.

fn is_normal_backtrack_mode(&self) -> bool

Purpose: Reports whether the pane is in a normal state where Escape backtracking can apply.

Data flow: It returns true only when no task is running, no modal is open, and the composer has no popup active.

Call relations: Navigation logic uses this to decide whether Escape should mean normal backtracking.

Call graph: calls 1 internal fn (popup_active); called by 1 (is_normal_backtrack_mode).

fn can_launch_external_editor(&self) -> bool

Purpose: Reports whether it is safe to open an external editor.

Data flow: It returns true only when no modal view and no composer popup are active.

Call relations: External-editor commands use this to avoid launching while another UI interaction is in progress.

Call graph: calls 1 internal fn (popup_active); called by 1 (no_modal_or_popup_active).

fn no_modal_or_popup_active(&self) -> bool

Purpose: Reports whether there is no modal and no composer popup active.

Data flow: It reuses the external-editor safety check and returns the same boolean.

Call relations: This gives other call sites a clearer name for the same condition.

Call graph: calls 1 internal fn (can_launch_external_editor).

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

Purpose: Shows an already-built bottom-pane view.

Data flow: It receives a boxed view and pushes it onto the view stack.

Call relations: Other modules that construct specialized views call this to display them without duplicating stack logic.

Call graph: calls 1 internal fn (push_view); called by 3 (open_app_link_view, open_memories_popup, show_feedback_note).

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

Purpose: Displays or queues an approval prompt for an action that needs user permission.

Data flow: It receives an approval request and feature settings. If the active view can consume the request, it lets that happen. Otherwise it either delays the request because the user recently typed, or immediately builds and pushes an approval overlay. It pauses the status timer when showing the modal.

Call relations: Execution and permission flows call this when the assistant needs approval before continuing.

Call graph: calls 6 internal fn (approval_prompt_delay_remaining, maybe_show_delayed_approval_requests_at, pause_status_timer_for_modal, push_view, request_redraw, new); 6 external calls (new, now, is_empty, push_back, clone, clone).

fn push_user_input_request(&mut self, request: ToolRequestUserInputParams)

Purpose: Shows a modal asking the user to provide requested tool input.

Data flow: It lets an active view consume the request if possible. Otherwise it builds a user-input overlay, pauses the status timer, disables the normal composer with explanatory placeholder text, and pushes the modal.

Call relations: Tool-request flows use this when progress depends on answers from the user.

Call graph: calls 5 internal fn (pause_status_timer_for_modal, push_view, request_redraw, set_composer_input_enabled, new_with_keymap); 3 external calls (new, clone, clone).

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

Purpose: Shows a modal for an MCP server request, or a special app-link suggestion if the request asks the user to install or enable a tool.

Data flow: It first lets an active view consume the request. If the request contains a tool suggestion with an install URL, it builds an app-link view with instructions and target metadata. Otherwise it builds a normal MCP elicitation overlay. In both cases it pauses status timing, disables composer input with helpful placeholder text, and pushes the view.

Call relations: MCP server interaction flows call this when an external server needs the user to respond before work can continue.

Call graph: calls 10 internal fn (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 external calls (new, matches!, clone, unreachable!).

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

Purpose: Dismisses approval or server-request UI that matches a resolved app-server request.

Data flow: It removes matching delayed approval requests, then walks the view stack and asks each view whether it should dismiss the request. Completed matching views are removed, cleanup runs if the stack shrank to empty, and the pane redraws if anything changed.

Call relations: Request-resolution flows call this to remove prompts that are no longer needed.

Call graph: calls 2 internal fn (on_view_stack_depth_decreased, request_redraw); called by 1 (dismiss_app_server_request); 3 external calls (new, len, retain).

fn on_active_view_complete(&mut self)

Purpose: Restores normal pane behavior after all modal views are gone.

Data flow: It resumes the status timer and re-enables composer input with no special placeholder.

Call relations: View-pop, paste, and tick completion paths call this after modal interaction finishes.

Call graph: calls 2 internal fn (resume_status_timer_after_modal, set_composer_input_enabled); called by 3 (handle_paste, on_view_stack_depth_decreased, tick_active_view).

fn pause_status_timer_for_modal(&mut self)

Purpose: Pauses the status indicator timer while a modal is open.

Data flow: It checks for a status widget and asks it to pause its timer.

Call relations: Modal-opening flows call this so status timing does not keep changing behind a prompt.

Call graph: called by 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)

Purpose: Resumes the status indicator timer after modal interaction ends.

Data flow: It checks for a status widget and asks it to resume its timer.

Call relations: Active-view completion calls this when returning to normal composer interaction.

Call graph: called by 1 (on_active_view_complete).

fn request_redraw(&self)

Purpose: Asks the UI to draw a new frame soon.

Data flow: It calls the frame requester to schedule a frame and returns nothing.

Call relations: Nearly every state-changing method uses this so visible changes appear on screen.

Call graph: calls 1 internal fn (schedule_frame); called by 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)

Purpose: Asks the UI to draw a new frame after a delay.

Data flow: It receives a duration and passes it to the frame requester.

Call relations: Paste-burst flushing, delayed approvals, and animated views use this to wake the UI later.

Call graph: calls 1 internal fn (schedule_frame_in); called by 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,
    )

Purpose: Stores message-history metadata for the current thread and passes it to the composer.

Data flow: It receives a thread id, log id, and entry count. It saves the thread id locally and tells the composer about the history location.

Call relations: History navigation and Ctrl-C draft preservation rely on this metadata.

Call graph: calls 1 internal fn (set_history_metadata).

fn flush_paste_burst_if_due(&mut self) -> bool

Purpose: Flushes buffered paste input when the paste-burst delay has expired.

Data flow: It first asks the active view to flush paste state, if one exists. If that does not flush anything, it asks the composer. It returns whether anything was flushed.

Call relations: The UI loop can call this to finish processing large pastes consistently for modals and normal composer input.

Call graph: calls 1 internal fn (flush_paste_burst_if_due).

fn is_in_paste_burst(&self) -> bool

Purpose: Reports whether the active view or composer is currently buffering a paste burst.

Data flow: It checks the active view first, then the composer, and returns true if either is in paste-burst mode.

Call relations: Paste scheduling code uses this to know whether another delayed flush may be needed.

Call graph: calls 1 internal fn (is_in_paste_burst).

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

Purpose: Applies an asynchronous history lookup response to the composer.

Data flow: It receives the log id, offset, and optional history entry. The composer decides whether this updates its state. If it does, the pane syncs popups and redraws.

Call relations: History response handling calls this after a requested history entry is loaded.

Call graph: calls 3 internal fn (request_redraw, on_history_entry_response, sync_popups); called by 1 (handle_history_entry_response).

fn record_replayed_user_message_history(&mut self, entry: HistoryEntry)

Purpose: Records a replayed user message in composer history.

Data flow: It receives a history entry and forwards it to the composer.

Call relations: Committed replayed-message handling uses this to keep composer history accurate.

Call graph: calls 1 internal fn (record_replayed_user_message_history); called by 1 (on_committed_user_message).

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

Purpose: Delivers file-search results to the composer.

Data flow: It receives the query and matches, passes them to the composer, and redraws.

Call relations: File mention or search flows call this when search results arrive.

Call graph: calls 2 internal fn (request_redraw, on_file_search_result); called by 1 (apply_file_search_result).

fn attach_image(&mut self, path: PathBuf)

Purpose: Attaches a local image to the composer when no modal is active.

Data flow: It receives an image path. If the view stack is empty, it adds the image through the composer and redraws; otherwise it ignores the request.

Call relations: Image attachment commands use this guard so attachments are not added while a modal is taking input.

Call graph: calls 2 internal fn (request_redraw, attach_image).

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

Purpose: Removes and returns local image paths associated with the recent submission.

Data flow: It asks the composer to take its recent submission images and returns them.

Call relations: Submission processing uses this to collect images exactly once.

Call graph: calls 1 internal fn (take_recent_submission_images).

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

Purpose: Removes and returns recent image attachments together with placeholder information.

Data flow: It delegates to the composer, which clears and returns those attachment records.

Call relations: Pending submission cleanup uses this to drain richer image attachment state.

Call graph: calls 1 internal fn (take_recent_submission_images_with_placeholders); called by 1 (drain_pending_submission_state).

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

Purpose: Prepares a submission created from inline command arguments.

Data flow: It receives whether history should be recorded, asks the composer to prepare the submission, and returns optional text plus structured elements.

Call relations: Inline command submission paths use this to turn composer content into a sendable message.

Call graph: calls 1 internal fn (prepare_inline_args_submission).

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

Purpose: Builds the renderable representation of the pane with no extra composer right-side reserve.

Data flow: It calls the more general renderable builder with a reserve value of zero and returns the result.

Call relations: Rendering, height, cursor position, and cursor style methods use this common representation.

Call graph: calls 1 internal fn (as_renderable_with_composer_right_reserve); called by 4 (cursor_pos, cursor_style, desired_height, render).

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

Purpose: Builds the visual layout object for the bottom pane.

Data flow: If a modal is active, it returns that view as the renderable item. Otherwise it assembles a flexible layout containing status, execution footer, pending approvals, pending input preview, spacing, and the composer. If requested, it wraps the composer so part of the right side is reserved.

Call relations: All rendering and layout measurement paths go through this so the bottom pane is drawn consistently.

Call graph: calls 4 internal fn (active_view, is_empty, is_empty, new); called by 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 external calls (new, Borrowed, Owned).

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

Purpose: Draws the pane while leaving extra space on the composer's right side.

Data flow: It receives a screen area, buffer, and reserve width, builds the matching renderable layout, and renders it into the buffer.

Call relations: Outer render code uses this variant when another UI element needs space beside the composer.

Call graph: calls 1 internal fn (as_renderable_with_composer_right_reserve); called by 1 (render).

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

Purpose: Calculates how tall the pane wants to be with a right-side composer reserve.

Data flow: It receives available width and reserve width, builds the renderable layout, and asks it for desired height.

Call relations: Layout code uses this before drawing to allocate enough terminal rows.

Call graph: calls 1 internal fn (as_renderable_with_composer_right_reserve); called by 1 (desired_height).

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

Purpose: Finds the cursor position when rendering with a right-side composer reserve.

Data flow: It receives the screen area and reserve width, builds the renderable layout, and asks it for the cursor coordinates.

Call relations: Terminal cursor placement uses this to keep the visible cursor aligned with the composer.

Call graph: calls 1 internal fn (as_renderable_with_composer_right_reserve); called by 1 (cursor_pos).

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

Purpose: Finds the cursor style when rendering with a right-side composer reserve.

Data flow: It receives the screen area and reserve width, builds the renderable layout, and asks it for the cursor style.

Call relations: Terminal drawing uses this so insert, overwrite, or Vim-style cursor appearance matches composer state.

Call graph: calls 1 internal fn (as_renderable_with_composer_right_reserve); called by 1 (cursor_style).

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

Purpose: Sets or clears an extra status line in the composer.

Data flow: It sends the optional line to the composer. If the composer changed, it redraws.

Call relations: Status-message flows use this to show lightweight information directly in the composer area.

Call graph: calls 2 internal fn (request_redraw, set_status_line).

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

Purpose: Sets or clears the hyperlink associated with the composer status line.

Data flow: It passes the optional URL to the composer and redraws only if state changed.

Call relations: Status lines that point to web or app resources use this to attach their link.

Call graph: calls 2 internal fn (request_redraw, set_status_line_hyperlink).

fn set_status_line_enabled(&mut self, enabled: bool)

Purpose: Turns the composer status line on or off.

Data flow: It passes the enabled flag to the composer and redraws if the setting changed.

Call relations: UI state can suppress or restore the status line through this method.

Call graph: calls 2 internal fn (request_redraw, set_status_line_enabled).

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

Purpose: Sets the label for the currently active agent shown in the composer.

Data flow: It passes the optional label to the composer and redraws if the visible state changed.

Call relations: Agent-selection flows use this to keep the input area labeled with the active agent.

Call graph: calls 2 internal fn (request_redraw, set_active_agent_label).

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

Purpose: Sets the label describing the side-conversation context.

Data flow: It forwards the optional label to the composer and redraws if it changed.

Call relations: Side-conversation UI uses this so the user can see what context they are typing into.

Call graph: calls 2 internal fn (request_redraw, set_side_conversation_context_label).

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

Purpose: Draws a composer while reserving blank space on the right side of its text area.

Data flow: It receives an area and buffer, then asks the composer to render with no mask character and the configured right reserve.

Call relations: The bottom pane uses this wrapper when its layout must leave room beside the composer.

Call graph: calls 1 internal fn (render_with_mask_and_textarea_right_reserve).

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

Purpose: Calculates composer height while accounting for reserved right-side space.

Data flow: It receives a width and asks the composer how tall it wants to be with that reserve.

Call relations: Layout measurement uses this wrapper exactly like any other renderable item.

Call graph: calls 1 internal fn (desired_height_with_textarea_right_reserve).

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

Purpose: Finds the composer's cursor position while accounting for reserved right-side space.

Data flow: It receives the drawing area and asks the composer for cursor coordinates with the reserve applied.

Call relations: Cursor placement uses this so the cursor position matches the reserved layout.

Call graph: calls 1 internal fn (cursor_pos_with_textarea_right_reserve).

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

Purpose: Returns the composer's cursor style.

Data flow: It receives the area but simply asks the composer for its cursor style.

Call relations: This completes the renderable wrapper interface for reserved-space composer rendering.

Call graph: calls 1 internal fn (cursor_style).

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

Purpose: Draws the bottom pane into the terminal buffer.

Data flow: It receives a screen area and buffer, builds the standard renderable layout, and renders it.

Call relations: The terminal rendering system calls this when painting the bottom pane.

Call graph: calls 1 internal fn (as_renderable); called by 1 (render_snapshot).

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

Purpose: Reports how many terminal rows the bottom pane would like.

Data flow: It receives a width, builds the standard renderable layout, and asks for desired height.

Call relations: Layout code calls this before rendering to divide screen space.

Call graph: calls 1 internal fn (as_renderable).

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

Purpose: Reports where the terminal cursor should appear for the bottom pane.

Data flow: It receives the pane area, builds the standard renderable layout, and returns optional cursor coordinates.

Call relations: The terminal UI uses this after drawing to place the hardware cursor.

Call graph: calls 1 internal fn (as_renderable).

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

Purpose: Reports what cursor style should be used for the bottom pane.

Data flow: It receives the pane area, builds the standard renderable layout, and returns the cursor style.

Call relations: The terminal UI uses this so the cursor shape reflects the active input mode.

Call graph: calls 1 internal fn (as_renderable).

fn snapshot_buffer(buf: &Buffer) -> String

Purpose: Turns a rendered terminal buffer into plain text for snapshot-style assertions.

Data flow: It reads every cell in the buffer area, collects the first character from each cell, joins rows with newlines, and returns the resulting string.

Call relations: Rendering tests use this helper to compare what appeared on screen.

Call graph: 3 external calls (area, new, new).

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

Purpose: Renders a bottom pane into a fresh buffer and returns it as text.

Data flow: It receives a pane and area, creates an empty buffer, renders the pane, converts the buffer to text, and returns that text.

Call relations: Tests use this to inspect rendered output without a real terminal.

Call graph: calls 1 internal fn (render); 2 external calls (empty, snapshot_buffer).

fn test_pane(app_event_tx: AppEventSender) -> BottomPane

Purpose: Builds a standard test BottomPane.

Data flow: It receives an app event sender and calls the more configurable test builder with paste-burst handling enabled.

Call relations: Many tests use this shortcut to avoid repeating setup values.

Call graph: 1 external calls (test_pane_with_disable_paste_burst).

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

Purpose: Builds a test BottomPane with a chosen paste-burst setting.

Data flow: It receives an event sender and paste-burst flag, fills in test defaults such as dummy frame requester and placeholder text, and returns a new BottomPane.

Call relations: Tests call this when they need to control paste behavior.

Call graph: calls 2 internal fn (new, test_dummy); 1 external calls (new).

fn exec_request() -> ApprovalRequest

Purpose: Creates a sample command-execution approval request for tests.

Data flow: It builds an approval request for an echo command with accept and cancel decisions and returns it.

Call relations: Approval-modal tests use this consistent fake request.

Call graph: calls 1 internal fn (new); 1 external calls (vec!).

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

Purpose: Provides a no-op render method for a fake dismissible test view.

Data flow: It receives an area and buffer but intentionally draws nothing.

Call relations: This lets the fake view satisfy the view interface while tests focus on dismissal behavior.

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

Purpose: Reports zero height for the fake dismissible test view.

Data flow: It ignores the width and returns 0.

Call relations: The test view only exists for control-flow tests, not visual layout.

fn is_complete(&self) -> bool

Purpose: Reports whether the fake dismissible view has completed.

Data flow: It returns the view's internal complete flag.

Call relations: Dismissal tests use this through the normal bottom-pane view-completion machinery.

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

Purpose: Returns the fake view's optional id.

Data flow: It reads and returns the stored id.

Call relations: View-stack tests can identify this fake view the same way production views are identified.

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

Purpose: Marks the fake view complete when a matching execution approval request is dismissed.

Data flow: It receives a resolved app-server request. If it is an execution approval with the expected id, it sets complete to true and returns true; otherwise it returns false.

Call relations: Tests use this to verify BottomPane removes completed views after resolved requests.

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

Purpose: Provides a no-op render method for a fake completing test view.

Data flow: It receives drawing inputs and ignores them.

Call relations: The fake view is used for key-completion behavior, not rendering.

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

Purpose: Reports zero height for the fake completing test view.

Data flow: It ignores the width and returns 0.

Call relations: This satisfies the view interface for tests.

fn handle_key_event(&mut self, key_event: KeyEvent)

Purpose: Completes the fake view when Enter is pressed.

Data flow: It receives a key event. If the key code is Enter, it sets its complete flag.

Call relations: Key-routing tests use this to check that BottomPane pops views when they complete.

fn is_complete(&self) -> bool

Purpose: Reports whether the fake completing view has completed.

Data flow: It returns the internal complete flag.

Call relations: BottomPane's modal-completion logic reads this during tests.

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

Purpose: Returns the fake completing view's optional id.

Data flow: It reads and returns the stored id.

Call relations: Tests use this for targeted view-stack operations.

fn ctrl_c_on_modal_consumes_without_showing_quit_hint()

Purpose: Checks that Ctrl-C closes an approval modal without showing the quit hint.

Data flow: It builds a pane, opens an approval request, sends Ctrl-C, and asserts the cancellation was handled, no quit hint is visible, and a second Ctrl-C is not handled.

Call relations: This protects the intended priority: modal cancellation should not look like app quit guidance.

Call graph: calls 4 internal fn (with_defaults, new, new, test_dummy); 4 external calls (new, assert!, assert_eq!, exec_request).

fn ctrl_c_cancels_history_search_without_clearing_draft_or_showing_quit_hint()

Purpose: Checks that Ctrl-C cancels composer history search without deleting the draft.

Data flow: It creates a pane, inserts draft text, starts history search with Ctrl-R, sends Ctrl-C, and verifies the draft remains, the popup closes, and no quit hint appears.

Call relations: This guards the composer behavior used by BottomPane::on_ctrl_c.

Call graph: calls 3 internal fn (new, new, test_dummy); 5 external calls (Char, new, new, assert!, assert_eq!).

fn overlay_not_shown_above_approval_modal()

Purpose: Checks that normal status overlays do not appear above an approval modal.

Data flow: It opens an approval modal, renders the pane, reads the top row, and asserts it does not contain the working overlay text.

Call relations: This protects the rendering rule that an active modal replaces the normal bottom-pane layout.

Call graph: calls 4 internal fn (with_defaults, new, new, test_dummy); 6 external calls (empty, new, new, new, assert!, exec_request).

fn approval_request_shows_immediately_without_recent_typing()

Purpose: Checks that approval prompts appear immediately when the user has not recently typed.

Data flow: It creates a pane, pushes an approval request, and asserts one view is active and no delayed approvals remain.

Call relations: This tests the immediate branch of approval prompt scheduling.

Call graph: calls 2 internal fn (with_defaults, new); 4 external calls (assert!, assert_eq!, exec_request, test_pane).

fn approval_request_is_delayed_after_recent_typing()

Purpose: Checks that approval prompts wait until the typing idle delay has passed.

Data flow: It marks recent composer activity, pushes an approval request, verifies it is delayed, ticks just before the delay and then at the delay, and confirms the modal appears only after the deadline.

Call relations: This tests the delayed approval flow used to avoid interrupting active typing.

Call graph: calls 2 internal fn (with_defaults, new); 6 external calls (from_millis, now, assert!, assert_eq!, exec_request, test_pane).

fn continued_typing_resets_delayed_approval_idle_deadline()

Purpose: Checks that more typing pushes back the delayed approval deadline.

Data flow: It creates a delayed approval, records later composer activity, ticks at the old deadline and then the new one, and verifies the prompt appears only after the later deadline.

Call relations: This protects the relationship between record_composer_activity_at and delayed approval display.

Call graph: calls 2 internal fn (with_defaults, new); 6 external calls (from_millis, now, assert!, assert_eq!, exec_request, test_pane).

fn typed_approval_shortcuts_during_delay_stay_in_composer()

Purpose: Checks that approval shortcut letters typed before the approval modal appears are treated as normal composer text.

Data flow: It delays an approval prompt, types letters that might otherwise be approval shortcuts, verifies they appear in the composer, and checks that no approval submission event was sent.

Call relations: This ensures delayed approval requests do not secretly capture user typing before their modal is visible.

Call graph: calls 2 internal fn (with_defaults, new); 7 external calls (now, Char, new, assert!, assert_eq!, exec_request, test_pane_with_disable_paste_burst).

fn delayed_approval_shortcut_works_after_idle_deadline()

Purpose: Checks that a delayed approval prompt still accepts the keyboard shortcut after the user has been idle long enough. This protects the case where approval prompts wait briefly so they do not steal keys while the user is still typing.

Data flow: The test creates a fake app-event channel, a pane, and a command approval request. It marks recent composer activity, queues the approval, advances time to the idle deadline, presses y, then reads the outgoing events. The expected result is an approval event saying the command was accepted.

Call relations: The test runner calls this test. Inside it, the pane is built with default features and a test helper, then push_approval_request, pre_draw_tick_at, and handle_key_event are exercised together to prove the delayed prompt becomes active and sends the correct decision.

Call graph: calls 2 internal fn (with_defaults, new); 6 external calls (now, Char, new, assert_eq!, exec_request, test_pane).

fn dismiss_app_server_request_prunes_delayed_approval()

Purpose: Checks that dismissing an app-server approval request also removes any delayed approval prompt waiting to appear. Without this, an approval modal could pop up after the request was already gone.

Data flow: The test creates a pane, records recent typing activity, and adds an approval request that is delayed. It then dismisses the matching request by id and checks that the delayed request list is empty. After advancing time, the view stack is still empty, meaning no stale prompt appeared.

Call relations: The test runner invokes this scenario to connect push_approval_request, dismiss_app_server_request, and the later pre-draw tick. It verifies that dismissal cleans both visible and not-yet-visible approval state.

Call graph: calls 2 internal fn (with_defaults, new); 4 external calls (now, assert!, exec_request, test_pane).

fn dismiss_app_server_request_removes_matching_buried_view()

Purpose: Checks that a dismissed approval request can remove a matching view even when that view is underneath another modal. This matters because modal views are stacked like cards, and a lower card may still belong to a request that has been canceled.

Data flow: The test pushes two views onto the pane: a lower view tied to request request-1 and a top view with no matching request. It dismisses request-1. The lower view is removed, while the top view remains.

Call relations: The test runner calls this to exercise dismiss_app_server_request against the pane’s view stack. It proves the dismissal logic searches through the stack, not just the top visible view.

Call graph: calls 1 internal fn (new); 4 external calls (new, assert!, assert_eq!, test_pane).

fn dismiss_app_server_request_returns_false_when_no_view_matches()

Purpose: Checks that dismissing a request reports failure and changes nothing when no view belongs to that request. This prevents unrelated modals from disappearing by accident.

Data flow: The test pushes two views, neither matching request request-1. It calls the dismissal method and expects false. The view stack length and top view stay the same.

Call relations: The test runner uses this as the negative case for dismiss_app_server_request. Together with the matching-view test, it defines both sides of the expected cleanup behavior.

Call graph: calls 1 internal fn (new); 4 external calls (new, assert!, assert_eq!, test_pane).

fn completing_top_view_preserves_underlying_view()

Purpose: Checks that when the top modal view finishes, only that top view is removed. Any view underneath should remain, because it may still be part of another active interaction.

Data flow: The test pushes an underlying dismissible view and a top view that completes when Enter is pressed. It sends an Enter key event. The top view disappears, and the underlying view remains on the stack.

Call relations: The test runner calls this to exercise handle_key_event and the pane’s completed-view cleanup. It confirms that finishing one modal does not wipe out the whole stack.

Call graph: calls 1 internal fn (new); 4 external calls (new, new, assert_eq!, test_pane).

fn composer_shown_after_denied_while_task_running()

Purpose: Checks that denying an approval while a task is still running returns the interface to a useful state: the running status plus the composer. This prevents the user from being left with a blank or hidden input area after saying no.

Data flow: The test creates a real BottomPane, starts a running task, shows an approval prompt, and simulates pressing n. It checks that the modal is gone, renders the pane, and looks for both a Working status row and the composer placeholder below it.

Call relations: The test runner invokes this to connect approval handling, task-running state, and rendering. It uses the pane’s event and render paths together to prove the visible layout recovers correctly after denial.

Call graph: calls 4 internal fn (with_defaults, new, new, test_dummy); 10 external calls (empty, from_millis, Char, new, new, new, new, assert!, sleep, exec_request).

fn status_indicator_visible_during_command_execution()

Purpose: Checks that the bottom pane shows a working status while a command or task is running. This gives the user feedback that the app is busy rather than frozen.

Data flow: The test creates a pane, marks a task as running, renders it into a small terminal buffer, and turns that buffer into text. The expected output contains • Working.

Call relations: The test runner calls this as a direct rendering check for set_task_running followed by render. It confirms that running-task state reaches the visible terminal output.

Call graph: calls 3 internal fn (new, new, test_dummy); 5 external calls (empty, new, new, assert!, snapshot_buffer).

fn status_and_composer_fill_height_without_bottom_padding()

Purpose: Checks that when status and composer are both visible, the pane uses exactly its desired height and does not leave an extra blank row at the bottom. This keeps the terminal layout compact and predictable.

Data flow: The test creates a running pane, asks it for its desired height at a given width, renders exactly that area, and compares the result with a saved snapshot. The snapshot captures the expected rows with no trailing padding.

Call relations: The test runner uses this snapshot test to tie together desired_height and rendering. It guards against layout regressions where height calculation and actual drawing drift apart.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, new, assert!, assert_snapshot!).

fn status_only_snapshot()

Purpose: Captures the expected appearance of the pane when only the running status layout is active. Snapshot tests like this catch unintended visual changes.

Data flow: The test creates a pane, marks a task as running, asks for the needed height, renders that area, and compares the rendered text to a stored snapshot.

Call relations: The test runner calls this to verify the combined behavior of task state, height calculation, and drawing. It hands the pane to the snapshot helper, which records the visible result.

Call graph: calls 3 internal fn (new, new, test_dummy); 3 external calls (new, new, assert_snapshot!).

fn unified_exec_summary_does_not_increase_height_when_status_visible()

Purpose: Checks that adding a summary for background terminal processes does not make the bottom pane taller when the status indicator is already visible. The summary should fit into the existing status area.

Data flow: The test starts a running task, records the pane’s desired height, adds one background process summary, and checks that the height stays the same. It then renders and confirms the summary text appears.

Call relations: The test runner uses this to connect set_task_running, set_unified_exec_processes, desired_height, and rendering. It ensures extra status information is displayed without disrupting layout.

Call graph: calls 3 internal fn (new, new, test_dummy); 6 external calls (new, new, assert!, assert_eq!, render_snapshot, vec!).

fn status_with_details_and_queued_messages_snapshot()

Purpose: Checks the visual layout when the status has detail lines and there is also queued user input waiting. This protects a busy state where the app needs to show both what it is doing and what the user has queued next.

Data flow: The test starts a task, updates the status with two detail lines, adds a queued follow-up question preview, renders the pane, and compares it to a saved snapshot.

Call relations: The test runner calls this to exercise status updates, queued-input preview state, height calculation, and rendering as one flow. The snapshot records how those pieces should share space.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, new, assert_snapshot!, vec!).

fn queued_messages_visible_when_status_hidden_snapshot()

Purpose: Checks that queued messages still appear when the running status indicator is hidden. This ensures the user can still see pending input even if the status row is not currently displayed.

Data flow: The test starts a task, adds a queued follow-up question, hides the status indicator, renders the pane, and compares the output with a snapshot.

Call relations: The test runner uses this to prove queued-message rendering does not depend on the status indicator being visible. It links set_pending_input_preview, hide_status_indicator, and rendering.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, new, assert_snapshot!, vec!).

fn status_and_queued_messages_snapshot()

Purpose: Checks the normal visual layout when both a running status and queued messages are visible. It makes sure the user can see current work and pending follow-up input together.

Data flow: The test creates a pane, marks a task as running, adds a queued question preview, renders the needed area, and compares the result to a snapshot.

Call relations: The test runner invokes this as a baseline snapshot for status plus queued input. It works alongside the hidden-status test to define both display modes.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, new, assert_snapshot!, vec!).

fn remote_images_render_above_composer_text()

Purpose: Checks that remote image attachments are shown above the composer text. This lets the user see attached images before sending a message.

Data flow: The test creates a pane, sets two remote image URLs, confirms the composer text is still empty, renders the pane, and checks that placeholders for Image #1 and Image #2 appear.

Call relations: The test runner calls this to exercise set_remote_image_urls, desired_height, and rendering. It verifies image attachment state becomes visible without being mixed into the typed text.

Call graph: calls 3 internal fn (new, new, test_dummy); 6 external calls (new, new, assert!, assert_eq!, render_snapshot, vec!).

fn drain_pending_submission_state_clears_remote_image_urls()

Purpose: Checks that remote image URLs are cleared when pending submission state is drained. This prevents old image attachments from accidentally carrying over to the next message.

Data flow: The test adds one remote image URL and confirms it exists. It then drains the pending submission state and checks that the image URL list is empty.

Call relations: The test runner uses this to verify cleanup after submission. It connects attachment state with drain_pending_submission_state, which prepares the pane for the next user input.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, assert!, assert_eq!, vec!).

fn esc_with_skill_popup_does_not_interrupt_task()

Purpose: Checks that pressing Escape while a skill popup is open closes the popup instead of interrupting the running task. This avoids turning a local UI cancel action into a task-killing action.

Data flow: The test creates a pane with one skill, starts a task, types $ to open the skill popup, then presses Escape. It reads outgoing events and confirms no interrupt event was sent, and it checks that the popup closed.

Call relations: The test runner invokes this to exercise composer popup behavior, Escape handling, and task interruption rules together. The pane should give the popup first chance to consume Escape.

Call graph: calls 3 internal fn (new, new, test_dummy); 3 external calls (new, assert!, vec!).

fn esc_with_slash_command_popup_does_not_interrupt_task()

Purpose: Checks that pressing Escape while the slash-command popup is active does not interrupt a running task. Escape should be treated as part of editing or dismissing the command UI first.

Data flow: The test starts a running task, types / to open the command popup, presses Escape, then checks the event channel for absence of an interrupt. The composer text remains /.

Call relations: The test runner calls this to verify the priority order in handle_key_event: active composer popups come before global task interruption.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, new, assert!, assert_eq!).

fn esc_with_agent_command_without_popup_does_not_interrupt_task()

Purpose: Checks that typing an agent command draft, even after its popup has closed, keeps Escape local and does not interrupt a running task. This protects the user while editing /agent ... text.

Data flow: The test starts a task, inserts /agent , verifies no popup is active, presses Escape, and checks that no interrupt event was sent. The composer text remains unchanged.

Call relations: The test runner uses this to cover a subtle state: command text is present but the popup is gone. It confirms interruption logic also considers special draft text, not only visible popups.

Call graph: calls 3 internal fn (new, new, test_dummy); 4 external calls (new, new, assert!, assert_eq!).

fn esc_release_after_dismissing_agent_picker_does_not_interrupt_task()

Purpose: Checks that the key-release event after pressing Escape to close a selection view does not accidentally interrupt a running task. Some terminals send both press and release events, so both must be handled safely.

Data flow: The test starts a task, shows a selection view, sends an Escape press followed by an Escape release, then inspects outgoing events. No interrupt is sent, and the selection view is gone.

Call relations: The test runner invokes this to exercise modal dismissal and key event kinds. It ensures the pane ignores or safely routes the release event after the press already closed the modal.

Call graph: calls 3 internal fn (new, new, test_dummy); 5 external calls (default, new_with_kind, new, assert!, vec!).

fn esc_interrupts_running_task_when_no_popup()

Purpose: Checks the intended global behavior: if a task is running and no popup or modal is active, Escape interrupts the task. This gives the user a quick way to stop ongoing work.

Data flow: The test starts a task in a clean pane, presses Escape, and reads the event channel. The expected output is a Codex interrupt operation.

Call relations: The test runner calls this as the positive counterpart to the popup cases. It proves Escape is still an interrupt shortcut when nothing local needs to consume it first.

Call graph: calls 3 internal fn (new, new, test_dummy); 3 external calls (new, new, assert!).

fn remapped_interrupt_turn_uses_configured_key_including_agent_drafts()

Purpose: Checks that if the interrupt shortcut is remapped, the pane respects the new key even while editing an agent command draft. This lets users customize shortcuts without losing consistent behavior.

Data flow: The test changes the interrupt key from Escape to F12, starts a task, and inserts /agent . Pressing Escape sends no event. Pressing F12 sends the interrupt event.

Call relations: The test runner uses this to connect runtime keymap settings with handle_key_event. It proves interruption is driven by configured bindings, not hard-coded only to Escape.

Call graph: calls 2 internal fn (new, defaults); 5 external calls (F, new, assert!, test_pane, vec!).

fn selection_view_esc_respects_remapped_list_cancel()

Purpose: Checks that a selection list uses the configured cancel key instead of always treating Escape as cancel. This matters for users who remap list navigation keys.

Data flow: The test changes the list cancel key to q, shows a selection view with an on_cancel callback, then presses Escape. The view remains and no callback event is sent. Pressing q closes the view and sends the callback event.

Call relations: The test runner invokes this to verify selection-view cancellation follows the runtime keymap. It ties together modal state, configured bindings, and cancel callbacks.

Call graph: calls 2 internal fn (new, defaults); 7 external calls (new, default, Char, new, assert!, test_pane, vec!).

fn esc_routes_to_handle_key_event_when_requested()

Purpose: Checks that a modal view can ask to receive Escape through its normal key handler instead of through the pane’s cancellation path. This gives special views control over what Escape means.

Data flow: The test defines a small fake view that counts calls to handle_key_event and on_ctrl_c, and says it prefers Escape as a normal key event. After pushing the view and pressing Escape, the normal handler count is one and the cancellation count is zero.

Call relations: The test runner calls this to exercise the prefer_esc_to_handle_key_event choice on active views. It proves the pane consults the view before deciding how to route Escape.

Call graph: calls 3 internal fn (new, new, test_dummy); 7 external calls (new, new, new, clone, new, new, assert_eq!).

fn release_events_are_ignored_for_active_view()

Purpose: Checks that key-release events are not forwarded to the active view as ordinary input. This avoids duplicate actions when terminals report both key press and key release.

Data flow: The test pushes a fake view that counts key-handler calls. It sends a Down-arrow press and then a Down-arrow release. Only the press reaches the view, so the count is one.

Call relations: The test runner invokes this to verify event filtering before dispatching to modal views. It protects all active views from receiving duplicate release events.

Call graph: calls 3 internal fn (new, new, test_dummy); 7 external calls (new, new, new_with_kind, clone, new, new, assert_eq!).

fn paste_completion_clears_stacked_views_and_restores_composer_input()

Purpose: Checks that if a paste completes the active modal flow, the pane clears the stacked views and restores normal composer input. This prevents a finished paste-driven modal from leaving hidden blockers behind.

Data flow: The test disables composer input, pushes a lower blocking view and a top view that marks itself complete when it receives pasted text, then pastes hello. The stack becomes empty. A later key event does not reach the old lower view, and the composer has a cursor again.

Call relations: The test runner uses this to exercise handle_paste, completed-view cleanup, and composer restoration together. It proves a completed top view can tear down the modal flow cleanly instead of exposing stale underlying views.

Call graph: calls 3 internal fn (new, new, test_dummy); 10 external calls (new, new, new, default, clone, new, new, new, assert!, assert_eq!).

fn new() -> Self

Purpose: Creates a ready-to-use composer input with a default placeholder. It also sets up the private event channel needed by the inner composer.

Data flow: It starts with no outside input. It creates a sender and receiver channel, wraps the sender in an AppEventSender, builds a focused ChatComposer with enhanced key support enabled, then returns a ComposerInput containing the composer and the private receiver.

Call relations: This is the setup step for the widget. It is used when code directly constructs a composer input, and it is also the behavior behind the default constructor. Tests create it to check that typed characters render correctly.

Call graph: calls 2 internal fn (new, new); called by 2 (new, composer_input_renders_typed_characters); 1 external calls (unbounded_channel).

fn is_empty(&self) -> bool

Purpose: Tells callers whether the text box currently has any text. This is useful for deciding whether there is anything to submit, clear, or warn about.

Data flow: It reads the current state of the inner composer and returns a simple true-or-false answer. It does not change the widget.

Call relations: This is a small query method. It delegates the real check to the internal ChatComposer so outside callers do not need to inspect the composer directly.

Call graph: calls 1 internal fn (is_empty).

fn clear(&mut self)

Purpose: Erases all text from the input. A caller would use this after a submission or when resetting the form.

Data flow: It takes the current text state, replaces it with an empty string, and clears the related internal text metadata by passing empty lists. It returns nothing, but the composer is left blank.

Call relations: This is part of the public control surface of the wrapper. It relies on the inner composer’s text-setting method rather than editing fields directly.

Call graph: calls 1 internal fn (set_text_content); 2 external calls (new, new).

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

Purpose: Feeds one keyboard event into the composer and reports whether that event submitted text. This is the main method a terminal event loop uses when the user presses a key.

Data flow: It receives a KeyEvent, gives it to the inner composer, and looks at the result. If the composer says text was submitted, it returns ComposerAction::Submitted with that text; otherwise it returns ComposerAction::None. Before finishing, it drains any private app events produced by the inner composer.

Call relations: This sits between the outer terminal event loop and the internal composer. It hands key presses inward, translates the composer’s detailed result into the simpler public ComposerAction, then calls drain_app_events to hide internal event traffic.

Call graph: calls 2 internal fn (handle_key_event, drain_app_events); 1 external calls (Submitted).

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

Purpose: Gives pasted text to the composer using its paste-aware behavior. This lets the widget treat pasted blocks differently from normal typing when needed.

Data flow: It receives a pasted string, passes it to the inner composer, and gets back whether the paste was accepted or processed. It then drains private app events and returns that true-or-false result to the caller.

Call relations: This is used by code that receives paste events separately from normal key presses. Like input, it delegates the real work to ChatComposer and then calls drain_app_events so internal notifications do not leak out.

Call graph: calls 2 internal fn (handle_paste, drain_app_events).

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

Purpose: Replaces the footer hints shown under the input with caller-provided hints. These hints are the small labels that tell the user what keys do, such as a key name followed by an action.

Data flow: It receives a list of key-label pairs that can be turned into strings. It converts each pair into owned strings and passes the list to the inner composer as a footer override. It returns nothing, but future rendering uses the custom hints.

Call relations: This is a customization hook for screens that reuse the composer but want different instructions. It hands the finished hint list to the inner composer’s footer override setting.

Call graph: calls 1 internal fn (set_footer_hint_override).

fn clear_hint_items(&mut self)

Purpose: Removes any custom footer hints and restores the composer’s normal hints. Callers use this when a temporary UI mode ends.

Data flow: It sends None as the footer hint override to the inner composer. Nothing is returned, but the next render falls back to the default hints.

Call relations: This is the counterpart to set_hint_items. It does not rebuild the widget; it simply tells the inner composer to stop using an override.

Call graph: calls 1 internal fn (set_footer_hint_override).

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

Purpose: Asks how many terminal rows the input would like for a given width. This helps the surrounding layout reserve enough space for multi-line text.

Data flow: It receives a width in terminal columns, asks the inner composer to calculate its needed height at that width, and returns the row count. It does not change the widget.

Call relations: A layout system can call this before rendering. The wrapper forwards the question to ChatComposer, which knows how its text wraps and how much footer space it needs.

Call graph: calls 1 internal fn (desired_height).

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

Purpose: Computes where the text cursor should appear on screen. This lets the terminal UI place the visible cursor in the right spot after drawing.

Data flow: It receives a rectangular screen area, asks the inner composer where the cursor belongs inside that area, and returns either coordinates or nothing if no cursor should be shown.

Call relations: This is used after layout has chosen the widget’s area. The wrapper relies on the inner composer’s cursor math, because that code understands wrapping, scrolling, and the current text position.

Call graph: calls 1 internal fn (cursor_pos).

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

Purpose: Draws the composer input into a terminal buffer. The buffer is the off-screen drawing surface that later becomes visible in the terminal.

Data flow: It receives a screen rectangle and a mutable buffer. It asks the inner composer to render itself into that rectangle, which changes the buffer contents but returns no separate value.

Call relations: This is the drawing entry point for code that embeds the widget. It passes rendering straight through to ChatComposer, which knows how to draw the input text, borders or styling, and footer hints.

Call graph: calls 1 internal fn (render).

fn is_in_paste_burst(&self) -> bool

Purpose: Reports whether the composer is currently treating incoming text as part of a rapid paste burst. This helps callers decide whether to schedule a short follow-up flush.

Data flow: It reads the paste-burst state from the inner composer and returns true or false. It does not modify the input.

Call relations: This is a status check used around paste handling. The wrapper exposes the inner composer’s paste-detection state without exposing the whole internal composer.

Call graph: calls 1 internal fn (is_in_paste_burst).

fn flush_paste_burst_if_due(&mut self) -> bool

Purpose: Finishes processing a pending paste burst once enough time has passed. It tells the caller whether the text changed and the screen should be redrawn.

Data flow: It asks the inner composer to flush any paste text whose timeout has expired. It then drains private app events and returns whether a flush actually changed the text.

Call relations: This is called by an outer loop that is watching paste-burst timing. It delegates the timing decision and text update to ChatComposer, then uses drain_app_events to discard internal notifications.

Call graph: calls 2 internal fn (flush_paste_burst_if_due, drain_app_events).

fn recommended_flush_delay() -> Duration

Purpose: Returns the suggested short delay before checking a paste burst again. This gives callers a sensible timer value without hard-coding composer internals.

Data flow: It takes no input. It asks ChatComposer for its recommended paste flush delay and returns that duration.

Call relations: This supports the paste-burst flow. Code that sees is_in_paste_burst can use this delay to schedule the next call to flush_paste_burst_if_due.

Call graph: calls 1 internal fn (recommended_paste_flush_delay).

fn drain_app_events(&mut self)

Purpose: Empties the private internal event queue used only to satisfy the inner composer. This prevents unused internal events from piling up.

Data flow: It repeatedly tries to receive messages from the private receiver. Each message is discarded. When no message is immediately available, it stops and returns nothing.

Call relations: This is an internal cleanup helper. It is called after key input, paste handling, and paste flushing, because those operations may cause ChatComposer to send app events that this public wrapper intentionally hides.

Call graph: called by 3 (flush_paste_burst_if_due, handle_paste, input); 1 external calls (try_recv).

fn default() -> Self

Purpose: Provides the standard default way to create a ComposerInput. It makes the type convenient to use in code that expects a default constructor.

Data flow: It receives no input and returns a newly created composer input by using the same setup as ComposerInput::new.

Call relations: This connects Rust’s Default convention to the widget’s normal constructor. Any code asking for a default ComposerInput gets the same initialized widget that new creates.

Call graph: 1 external calls (new).

fn recommended_flush_delay() -> Duration

Purpose: This gives callers a safe amount of time to wait before checking whether a held first character should be released as normal typing. It is mainly useful for tests and UI ticks that need to cross the paste-detection timing boundary reliably.

Data flow: It takes no input. It reads the configured maximum gap between fast characters, adds one millisecond, and returns that duration. Nothing else is changed.

Call relations: Higher-level code such as recommended_paste_flush_delay and a test use this when they need to wait long enough that a single held key is no longer considered part of a possible paste burst.

Call graph: called by 2 (recommended_paste_flush_delay, ascii_first_char_is_held_then_flushes_as_typed); 1 external calls (from_millis).

fn recommended_active_flush_delay() -> Duration

Purpose: This gives tests a safe wait time for an already-detected paste burst to become ready to flush. It exists only in test builds.

Data flow: It takes no input. It reads the active paste idle timeout, adds one millisecond, and returns the resulting duration. It does not change the paste detector.

Call relations: Paste-burst tests use it after simulating fast input so that flush_if_due should definitely return the buffered paste.

Call graph: called by 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 external calls (from_millis).

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

Purpose: This is the main decision point for ordinary ASCII character input. It decides whether the character should be held briefly, added to an active paste buffer, or used to begin a new paste burst.

Data flow: It receives a character and the current time. It updates the record of recent character timing, checks whether a burst is already active or whether characters are arriving very quickly, and returns a CharDecision telling the caller what to do next. It may also store a first character temporarily or start a paste buffer.

Call relations: The composer calls this for plain ASCII characters. Internally it calls note_plain_char to update the timing counter, then hands a decision back to the caller, which is responsible for inserting, buffering, or withholding the character.

Call graph: calls 1 internal fn (note_plain_char); 1 external calls (duration_since).

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

Purpose: This is a version of on_plain_char for non-ASCII input or input method editor text, where hiding the first character would feel like the app dropped it. It still detects fast paste-like streams but never asks the caller to hold the first character.

Data flow: It receives the current time. It updates the recent-character timing, checks whether buffering is already active or whether enough fast characters have arrived, and returns either a paste-buffering decision or None for normal insertion.

Call relations: handle_key_event_at uses this for character input paths that should not delay display. It calls note_plain_char and then returns a simpler decision set to the caller.

Call graph: calls 1 internal fn (note_plain_char); called by 1 (handle_key_event_at).

fn note_plain_char(&mut self, now: Instant)

Purpose: This updates the detector’s memory of how quickly plain characters are arriving. It is the timing counter that lets the rest of the file recognize paste-like bursts.

Data flow: It receives the current time. It compares that time with the previous plain character time; if the gap is short, it increases the consecutive-fast-character count, otherwise it starts the count over at one. It then records the new time.

Call relations: Both character entry points, on_plain_char and on_plain_char_no_hold, call this before making their paste-or-typing decision.

Call graph: called by 2 (on_plain_char, on_plain_char_no_hold); 1 external calls (duration_since).

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

Purpose: This checks whether enough time has passed to stop waiting and release buffered input. It either emits a full paste, releases one held typed character, or says nothing is ready yet.

Data flow: It receives the current time. It compares that time with the last plain character time using the right timeout for the current state. If an active buffer has gone idle, it empties the buffer and returns it as Paste; if only one first character was being held, it returns that as Typed; otherwise it returns None.

Call relations: The UI calls this on ticks. It uses is_active_internal to decide which timeout applies, then hands the caller either pasted text or a normal typed character to apply to the text box.

Call graph: calls 1 internal fn (is_active_internal); 3 external calls (take, Paste, Typed).

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

Purpose: This adds a newline to the paste buffer when Enter happens during a paste burst. It stops pasted multiline text from being mistaken for a request to send the message.

Data flow: It receives the current time. If the detector is in a paste-related active state, it appends \n to the buffer, extends the Enter-suppression window, and returns true; otherwise it returns false and changes nothing.

Call relations: Enter-handling code can call this before submitting. It asks is_active whether a paste burst is in progress and, if so, keeps the newline inside the buffered paste.

Call graph: calls 1 internal fn (is_active).

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

Purpose: This answers the question, “Should Enter make a newline rather than send the message?” It is used to protect multiline paste input during and shortly after a burst.

Data flow: It receives the current time. It checks whether the detector is active or whether the current time is still inside the short Enter-suppression window, and returns a boolean answer.

Call relations: direct_insert_newline_should_insert builds on this. Other Enter logic can use it to decide whether Enter belongs to pasted content instead of the composer’s submit action.

Call graph: calls 1 internal fn (is_active); called by 1 (direct_insert_newline_should_insert).

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

Purpose: This is an Enter decision helper for code paths that insert characters immediately rather than fully buffering them. It is slightly more cautious and treats Enter as a newline if it arrives right after a fast character.

Data flow: It receives the current time. It first checks newline_should_insert_instead_of_submit, then also checks whether the last plain character was recent enough to look like a burst. It returns true for newline insertion or false for normal submit behavior.

Call relations: handle_key_event_at calls this in its Enter handler when it needs a quick yes-or-no decision without going through the full buffering flow.

Call graph: calls 1 internal fn (newline_should_insert_instead_of_submit); called by 1 (handle_key_event_at).

fn extend_window(&mut self, now: Instant)

Purpose: This keeps the short paste-related Enter-suppression window alive. It is used when the caller sees input that should continue to count as part of a burst-like sequence.

Data flow: It receives the current time and sets the suppression deadline to a short time after it. It returns nothing.

Call relations: handle_key_event_at calls this when Enter or burst-like direct input should keep Enter behaving as “insert newline” for a little longer.

Call graph: called by 1 (handle_key_event_at).

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

Purpose: This starts a paste buffer using text that was already inserted into the UI but is now being reclassified as part of a paste. It supports “retro capture,” meaning the app can pull recent text back into the paste buffer.

Data flow: It receives the already-grabbed string and the current time. If the string is not empty, it appends it to the internal buffer, marks buffering as active, and extends the Enter-suppression window. It returns nothing.

Call relations: decide_begin_buffer calls this after deciding that recently typed-looking text actually looks like the start of a paste.

Call graph: called by 1 (decide_begin_buffer).

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

Purpose: This adds one character to the current paste buffer. Callers use it after the detector has already decided that the character belongs to a paste burst.

Data flow: It receives a character and the current time. It appends the character to the internal buffer and refreshes the Enter-suppression window. It returns nothing.

Call relations: Caller code uses this after decisions such as BufferAppend or BeginBufferFromPending. try_append_char_if_active also calls it when it can safely capture a character into an existing burst.

Call graph: called by 1 (try_append_char_if_active).

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

Purpose: This is a safe convenience helper: it appends a character only if a paste buffer is already in progress. It lets callers try to join a character to an existing burst without accidentally starting one.

Data flow: It receives a character and the current time. If buffering is active or the buffer already has text, it appends the character through append_char_to_buffer and returns true; otherwise it leaves state unchanged and returns false.

Call relations: Code that is unsure whether a character should join a paste can call this. When the answer is yes, it delegates the actual append work to append_char_to_buffer.

Call graph: calls 1 internal fn (append_char_to_buffer).

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

Purpose: This decides whether recently inserted text should be pulled back out of the UI and treated as the beginning of a paste. It avoids doing that for short ordinary words, but does it for text that looks paste-like, such as text with whitespace or a long run of characters.

Data flow: It receives the current time, the text before the cursor, and how many recent characters might belong to the burst. It finds the byte position where those characters start, copies that slice, checks whether it looks like paste, and if so starts buffering with it and returns a RetroGrab describing what to remove from the UI. If not, it returns None.

Call relations: Callers use this after a BeginBuffer decision. It calls retro_start_index to convert a character count into a safe string position, then calls begin_with_retro_grabbed if retro capture should happen.

Call graph: calls 2 internal fn (begin_with_retro_grabbed, retro_start_index).

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

Purpose: This immediately releases any paste-related buffered text before the app handles an unrelated key, such as an arrow key or a modified shortcut. It prevents hidden buffered text from being stranded or incorrectly grouped with later typing.

Data flow: It takes no input. If no paste-related state is active, it returns None. Otherwise it marks buffering inactive, takes the buffered text, appends any held first character, and returns the combined string for the caller to apply.

Call relations: Input-handling code should call this before non-character or modified input. It uses is_active to decide whether anything needs flushing, then hands the text back to the caller.

Call graph: calls 1 internal fn (is_active); 1 external calls (take).

fn clear_window_after_non_char(&mut self)

Purpose: This clears the paste-detection timing window after an unrelated key input. It stops the next typed character from being mistakenly grouped into an old burst.

Data flow: It takes no input. It resets the consecutive-character count, last character time, suppression window, active flag, and any held first character. It does not return anything.

Call relations: Callers use this after they have already flushed anything important with another method. It is a cleanup step for classification state, not a way to emit buffered text.

fn is_active(&self) -> bool

Purpose: This reports whether the detector is in any temporary paste-related state. That includes active buffering, a non-empty buffer, or a first character being held briefly.

Data flow: It takes no input. It checks the internal active/buffer state and whether a pending first character exists, then returns true or false.

Call relations: append_newline_if_active, flush_before_modified_input, and newline_should_insert_instead_of_submit use this to decide whether paste-aware behavior should apply.

Call graph: calls 1 internal fn (is_active_internal); called by 3 (append_newline_if_active, flush_before_modified_input, newline_should_insert_instead_of_submit).

fn is_active_internal(&self) -> bool

Purpose: This is the narrower active-state check used inside the detector. It ignores a merely held first character and only asks whether a paste buffer is active or non-empty.

Data flow: It takes no input. It returns whether the active flag is set or the internal buffer contains text. It changes nothing.

Call relations: flush_if_due uses this to choose the correct timeout and decide whether to emit a paste. is_active builds on it by also considering the pending first character.

Call graph: called by 2 (flush_if_due, is_active).

fn clear_after_explicit_paste(&mut self)

Purpose: This fully resets paste-burst detection after the app receives or applies a clear, explicit paste event. It makes sure old timing and buffered data do not affect later typing.

Data flow: It takes no input. It clears timing, counters, the Enter-suppression window, the active flag, the buffer, and any pending first character. It returns nothing.

Call relations: handle_key_event_at and handle_paste call this when paste handling is already known and complete, so the burst detector can start fresh.

Call graph: called by 2 (handle_key_event_at, handle_paste).

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

Purpose: This finds where to start slicing a UTF-8 string when retroactively grabbing a certain number of characters before the cursor. It matters because characters can be more than one byte, so byte positions must be chosen carefully.

Data flow: It receives a string slice and a number of characters to step backward. If the count is zero, it returns the end of the string. Otherwise it walks character boundaries from the end and returns the byte index where the requested number of characters begins, or zero if the string is shorter than requested.

Call relations: decide_begin_buffer calls this before removing already-inserted text from the UI. It supplies the safe starting byte for the RetroGrab result.

Call graph: called by 1 (decide_begin_buffer).

fn ascii_first_char_is_held_then_flushes_as_typed()

Purpose: This test proves that one fast ASCII character is only held briefly and then becomes normal typed input if no paste follows. It protects against a bug where a single typed key might disappear or be treated as paste.

Data flow: It creates a fresh detector, sends one character at a starting time, waits beyond the recommended flush delay, and checks that flushing returns Typed('a'). It also checks that the detector is no longer active.

Call relations: The test calls PasteBurst::recommended_flush_delay to cross the timeout boundary and exercises the public character and flush flow used by the UI.

Call graph: calls 1 internal fn (recommended_flush_delay); 4 external calls (from_millis, now, assert!, default).

fn ascii_two_fast_chars_start_buffer_from_pending_and_flush_as_paste()

Purpose: This test proves that two ASCII characters arriving very quickly are grouped as a paste without first rendering the initial character. It protects the flicker-suppression behavior.

Data flow: It creates a detector, sends a, then sends b one millisecond later. It checks that buffering starts from the held first character, appends b, waits past the active flush delay, and checks that the output paste is ab.

Call relations: The test uses PasteBurst::recommended_active_flush_delay and follows the same caller contract the composer uses: interpret the decision, append to the buffer, then flush.

Call graph: calls 1 internal fn (recommended_active_flush_delay); 4 external calls (from_millis, now, assert!, default).

fn flush_before_modified_input_includes_pending_first_char()

Purpose: This test proves that a held first character is not lost when an unrelated key is about to be handled. It protects the cleanup path used before modified or non-character input.

Data flow: It creates a detector, sends one ASCII character so it is held, then calls flush_before_modified_input. It expects to receive the string a and verifies that the detector is inactive afterward.

Call relations: The test directly exercises the pre-non-character flush path that input handling should use before moving on to unrelated key behavior.

Call graph: 4 external calls (now, assert!, assert_eq!, default).

fn decide_begin_buffer_only_triggers_for_pastey_prefixes()

Purpose: This test proves that retro capture is selective. Short ordinary text should not be pulled back into a paste buffer, but text with whitespace should be considered paste-like.

Data flow: It creates a detector and asks it to retro-capture from ab, expecting no capture. Then it asks using a b, expecting capture of the trailing b, the correct start byte, and an active detector.

Call relations: The test exercises decide_begin_buffer, including its use of safe character-based slicing and its call into the buffer-starting path.

Call graph: 4 external calls (now, assert!, assert_eq!, default).

fn newline_suppression_window_outlives_buffer_flush()

Purpose: This test proves that Enter remains protected briefly even after a paste buffer has flushed. It protects multiline paste behavior where Enter may arrive slightly later than the text.

Data flow: It simulates a fast two-character paste, flushes it as ab, then checks that Enter would still insert a newline at the flush time. After the suppression window expires, it checks that Enter would no longer be treated that way.

Call relations: The test follows the same burst creation and flushing flow as the composer, then checks newline_should_insert_instead_of_submit to verify the post-paste Enter window.

Call graph: calls 1 internal fn (recommended_active_flush_delay); 4 external calls (from_millis, now, assert!, default).

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

Purpose: This turns a key press into the Vim idea of “inner” or “around.” A caller uses it after an operator key, such as delete or change, to know whether the command should affect only the contents or also surrounding characters like spaces or brackets.

Data flow: It receives a keyboard event and reads the text area’s Vim operator key bindings. If the event matches the configured “inner text object” key, it returns Inner; if it matches “around text object,” it returns Around; otherwise it returns nothing.

Call relations: This is part of the first step in reading a Vim-style command. Higher-level input code asks it what kind of text object scope the user requested before later asking for the actual text object and range.

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

Purpose: This turns a key press into the kind of Vim text object the user named, such as a word, parentheses, brackets, braces, or quotes. It is the bridge between raw keyboard input and a meaningful editing target.

Data flow: It receives a keyboard event and checks it against the configured text-object key bindings. The first matching binding becomes a VimTextObject value; if no binding matches, it returns nothing.

Call relations: This is used when the editor is waiting for the final part of a Vim command, such as the w in “delete around word.” Once this identifies the object, other code can call TextArea::text_object_range to find the actual text span.

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

Purpose: This chooses the correct range-finding rule for a requested Vim text object. It answers the practical question: “Given the cursor and the command, which exact part of the text should be selected, deleted, yanked, or changed?”

Data flow: It receives a text object kind and a scope, then looks at the current text and cursor through helper methods. Word objects are sent to TextArea::word_text_object_range, bracket-like objects to TextArea::paired_text_object_range, and quote objects to TextArea::quoted_text_object_range. It returns a byte range if a matching target is found.

Call relations: This is the central dispatcher after key interpretation has already decided what the user asked for. It hands off to specialized helpers because words, paired delimiters, and quotes all need different rules.

Call graph: calls 3 internal fn (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>>

Purpose: This finds the word under or just before the cursor, using either Vim’s small-word or big-word behavior. It also applies the difference between “inner word” and “around word.”

Data flow: It receives the requested scope and a flag saying whether to use big-word rules. It finds the inner word range through TextArea::big_word_range_at_cursor or TextArea::small_word_range_at_cursor. If the scope is Inner, it returns that range as-is; if the scope is Around, it expands the range with TextArea::expand_word_around to include nearby whitespace.

Call relations: It is called by TextArea::text_object_range when the requested object is a word or big word. It then delegates the details of locating and expanding that word to smaller helpers.

Call graph: calls 3 internal fn (big_word_range_at_cursor, expand_word_around, small_word_range_at_cursor); called by 1 (text_object_range).

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

Purpose: This finds a Vim “big word” at the cursor. In this file, a big word means one continuous stretch of non-whitespace characters, so punctuation stays attached instead of being split apart.

Data flow: It reads the full text and cursor position. First it asks TextArea::non_ws_runs for all stretches that are not whitespace. Then it returns the first stretch that contains the cursor or ends exactly at the cursor.

Call relations: It is called by TextArea::word_text_object_range when the user asks for a big-word text object. It relies on TextArea::non_ws_runs to do the basic scanning.

Call graph: calls 1 internal fn (non_ws_runs); called by 1 (word_text_object_range).

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

Purpose: This finds a smaller Vim-style word piece at the cursor. Unlike a big word, it can split a non-whitespace run into more precise pieces, such as separating punctuation from letters.

Data flow: It reads the full text and cursor position. It gets non-whitespace runs from TextArea::non_ws_runs, skips runs the cursor is not touching, and then uses split_word_pieces to break a run into smaller parts. It returns the piece under the cursor, the last piece if the cursor is exactly at the run’s end, or the whole run as a fallback.

Call relations: It is called by TextArea::word_text_object_range for normal word text objects. It uses TextArea::cursor_overlaps_range and TextArea::cursor_is_at_range_end to decide whether the cursor should count as being on a candidate range.

Call graph: calls 3 internal fn (cursor_is_at_range_end, cursor_overlaps_range, non_ws_runs); called by 1 (word_text_object_range); 1 external calls (split_word_pieces).

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

Purpose: This breaks the text into stretches of non-whitespace characters. It provides the raw material for both small-word and big-word selection.

Data flow: It reads the text from start to end, remembering where a non-whitespace stretch begins. Whenever whitespace is reached, it closes the current stretch and stores its range. At the end, it returns all collected ranges.

Call relations: It is used by TextArea::big_word_range_at_cursor and TextArea::small_word_range_at_cursor. Those functions build more Vim-specific word behavior on top of these simple non-space runs.

Call graph: called by 2 (big_word_range_at_cursor, small_word_range_at_cursor); 1 external calls (new).

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

Purpose: This answers whether the cursor is inside a given text range. It is a small helper that makes the word-finding code easier to read and less error-prone.

Data flow: It receives a range and reads the current cursor position. It returns true when the cursor is at or after the range start and before the range end.

Call relations: It is called by TextArea::small_word_range_at_cursor while deciding whether a run or word piece is the one the user is pointing at.

Call graph: called by 1 (small_word_range_at_cursor).

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

Purpose: This answers whether the cursor sits exactly at the end of a non-empty range. That matters because Vim often treats the cursor at the end of a word as still related to that word.

Data flow: It receives a range and reads the current cursor position. It returns true only if the range has at least one character and the cursor position equals the range’s end.

Call relations: It is called by TextArea::small_word_range_at_cursor to support the edge case where the cursor is just after a word rather than inside it.

Call graph: called by 1 (small_word_range_at_cursor).

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

Purpose: This turns an “inner word” range into an “around word” range by including nearby whitespace. This matches Vim’s useful behavior of deleting a word plus one side of its spacing, rather than leaving messy gaps.

Data flow: It receives the word’s inner range. It first checks for whitespace after the word with TextArea::following_whitespace_end; if any exists, it extends the range forward. If not, it looks backward with TextArea::preceding_whitespace_start and includes whitespace before the word instead.

Call relations: It is called by TextArea::word_text_object_range when the user chooses the Around scope. It hands the forward and backward whitespace checks to dedicated helpers.

Call graph: calls 2 internal fn (following_whitespace_end, preceding_whitespace_start); called by 1 (word_text_object_range).

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

Purpose: This finds how far whitespace continues after a given position. It helps decide how much trailing space belongs to an “around word” selection.

Data flow: It receives a starting byte position and scans forward through the text. It stops at the first non-whitespace character and returns the byte position just after the last whitespace character it saw.

Call relations: It is called by TextArea::expand_word_around before checking preceding whitespace, because trailing whitespace is preferred when expanding an around-word selection.

Call graph: called by 1 (expand_word_around).

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

Purpose: This finds where the whitespace immediately before a given position begins. It is used when there is no trailing whitespace to include after a word.

Data flow: It receives an ending byte position and scans backward through the text before that point. It stops when it reaches a non-whitespace character and returns the start position of the whitespace run.

Call relations: It is called by TextArea::expand_word_around as the fallback when there is no whitespace after the selected word.

Call graph: called by 1 (expand_word_around).

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

Purpose: This finds the smallest matching pair of delimiters around the cursor, such as parentheses, brackets, or braces. It supports commands like “change inside parentheses” or “delete around braces.”

Data flow: It receives a scope plus an opening and closing character. It scans the text, skipping positions that are inside special text-area elements. Opening characters are pushed onto a stack, and closing characters pop from that stack to form pairs. If a pair surrounds the cursor, it builds either the inside range or the full around range, then keeps the smallest matching candidate.

Call relations: It is called by TextArea::text_object_range for parentheses, brackets, and braces. It calls TextArea::is_inside_element so structured embedded elements do not get mistaken for real delimiter characters.

Call graph: calls 1 internal fn (is_inside_element); called by 1 (text_object_range); 1 external calls (new).

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

Purpose: This finds a matching quoted string around the cursor on the current line. It supports text objects such as inside double quotes, around single quotes, or around backticks.

Data flow: It receives a scope and the quote character to look for. It scans only the current line, skips quote characters inside special elements, and ignores escaped quotes such as \". It pairs quote marks in order, checks whether the cursor lies between them, and returns either the inside range or the full quoted range.

Call relations: It is called by TextArea::text_object_range for quote-based text objects. It uses TextArea::is_inside_element to ignore embedded elements, TextArea::is_escaped to avoid treating escaped quotes as real boundaries, and idx_range to build the around-quote range.

Call graph: calls 3 internal fn (is_escaped, is_inside_element, idx_range); called by 1 (text_object_range).

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

Purpose: This checks whether a text position falls inside one of the text area’s special embedded elements. Those elements should not be treated like ordinary typed text when searching for brackets or quotes.

Data flow: It receives a byte position and reads the text area’s element ranges. It returns true if the position is inside any element range, and false otherwise.

Call relations: It is called by TextArea::paired_text_object_range and TextArea::quoted_text_object_range while scanning text. This keeps delimiter matching focused on normal editable text instead of structured spans.

Call graph: called by 2 (paired_text_object_range, quoted_text_object_range).

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

Purpose: This decides whether the character at a position is escaped with a backslash. For quotes, this prevents an escaped quote from being mistaken for the end of a quoted section.

Data flow: It receives a byte position and looks backward from that point, counting consecutive backslashes. If the count is odd, it returns true, meaning the character is escaped; if the count is even, it returns false.

Call relations: It is called by TextArea::quoted_text_object_range whenever a quote character is found. This helps the quote scanner tell the difference between a real closing quote and a literal quote character inside the text.

Call graph: called by 1 (quoted_text_object_range).

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

Purpose: This builds the full range for a quoted text object when the selection should include both quote marks. It is a tiny helper for the “around quotes” case.

Data flow: It receives the byte positions of the opening and closing quote and the quote character itself. It returns a range that starts at the opening quote and ends just after the closing quote.

Call relations: It is called by TextArea::quoted_text_object_range when the requested scope is Around. That caller has already found the matching quote pair; this helper just packages the correct byte range.

Call graph: called by 1 (quoted_text_object_range).

fn is_word_separator(ch: char) -> bool

Purpose: Checks whether a character counts as punctuation or a symbol that should be treated as its own word piece. This helps word movement behave more like a real editor.

Data flow: It receives one character, looks for it in the configured separator set, and returns true or false.

Call relations: Word splitting calls this small test for each character so later word-navigation functions can decide where words begin and end.

Call graph: called by 1 (split_word_pieces).

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

Purpose: Breaks a run of non-whitespace text into smaller word-like pieces. It separates normal letters from separator characters so cursor movement can stop at useful places.

Data flow: It receives a text slice, walks through Unicode word boundaries, then further splits when characters switch between separator and non-separator. It returns byte offsets paired with each piece.

Call relations: Previous-word and next-word searches call this when they need editor-like word boundaries rather than just whitespace boundaries.

Call graph: calls 1 internal fn (is_word_separator); called by 2 (beginning_of_previous_word, end_of_next_word_from); 1 external calls (new).

fn new() -> Self

Purpose: Creates an empty text area ready for use. It starts with no text, the cursor at the beginning, no embedded elements, and default keyboard bindings.

Data flow: It reads the default runtime keymap, fills all stored fields with initial values, and returns a new TextArea.

Call relations: Construction code and tests call this before any editing, rendering, or token detection can happen.

Call graph: calls 1 internal fn (defaults); called by 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 external calls (new, new, new).

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

Purpose: Replaces the text area's keyboard shortcuts with a provided runtime keymap. This lets the editor follow user or application key binding settings.

Data flow: It receives a keymap, clones the editor and Vim binding sections, and stores them in the text area.

Call relations: External setup code calls this when key bindings change; later input handling reads these stored bindings to interpret key events.

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

Purpose: Replaces the visible text and removes any embedded element ranges. This is useful when the text is being reset as plain text.

Data flow: It receives new text, passes it to the shared text-setting routine with no element list, and leaves the text area with a clean element table.

Call relations: It delegates to TextArea::set_text_inner, which performs the safe cursor clamping and cache reset.

Call graph: calls 1 internal fn (set_text_inner).

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

Purpose: Replaces the visible text while also installing known embedded element ranges. This is used when restoring or setting text that contains special placeholders.

Data flow: It receives text plus element descriptions, then passes both to the shared text-setting routine.

Call relations: It delegates to TextArea::set_text_inner, which rebuilds internal element records safely against the new text.

Call graph: calls 1 internal fn (set_text_inner).

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

Purpose: Does the real work of replacing the whole buffer. It also rebuilds embedded element ranges and clears cached display information that no longer matches.

Data flow: It receives new text and optionally element ranges. It stores the text, clamps the cursor into the new buffer, creates fresh internal element records with safe character boundaries, clears wrapping state, and resets vertical-movement memory.

Call relations: set_text_clearing_elements and set_text_with_elements both call this so full-buffer replacement follows one safe path.

Call graph: calls 3 internal fn (clamp_pos_to_char_boundary, clamp_pos_to_nearest_boundary, next_element_id); called by 2 (set_text_clearing_elements, set_text_with_elements).

fn set_vim_enabled(&mut self, enabled: bool)

Purpose: Turns Vim-style editing on or off. When enabled, the editor starts in normal mode; when disabled, it behaves like a regular insert-only editor.

Data flow: It receives a boolean, stores it, clears any pending Vim command, and sets the current Vim mode accordingly.

Call relations: Setup or preference code calls this; later input handling checks these fields to choose between normal editing and Vim editing.

fn is_vim_enabled(&self) -> bool

Purpose: Reports whether Vim-style editing is currently turned on.

Data flow: It reads the stored Vim-enabled flag and returns it.

Call relations: Other parts of the UI can call this to decide what behavior or status to show.

fn is_vim_normal_mode(&self) -> bool

Purpose: Reports whether the text area is currently in Vim normal mode. Normal mode means keys are commands rather than typed text.

Data flow: It reads the Vim-enabled flag and current mode, returning true only when both match normal-mode editing.

Call relations: UI and input code can use this to decide cursor style, status labels, or command behavior.

fn vim_normal_end_cursor(&self) -> usize

Purpose: Finds the last safe cursor position for Vim normal mode. Vim normal mode usually places the cursor on a character, not after the final character.

Data flow: It checks whether the text is empty. If not, it moves one atomic step back from the end, respecting graphemes and embedded elements.

Call relations: It relies on prev_atomic_boundary to avoid landing inside a complex character or element.

Call graph: calls 1 internal fn (prev_atomic_boundary).

fn is_vim_operator_pending(&self) -> bool

Purpose: Reports whether Vim is waiting for the rest of a command, such as after pressing delete before choosing a motion.

Data flow: It reads the pending Vim state and returns true unless that state is empty.

Call relations: UI code can use this while displaying command state; Vim input code updates the pending state as keys arrive.

Call graph: 1 external calls (matches!).

fn enter_vim_insert_mode(&mut self)

Purpose: Switches to Vim insert mode, where typed characters are inserted into the text. It only does this if Vim mode is enabled.

Data flow: It checks the Vim-enabled flag, then sets the mode to insert and clears any half-finished Vim command.

Call relations: Vim command handling can call this after commands that begin text entry.

fn enter_vim_normal_mode(&mut self)

Purpose: Switches to Vim normal mode, where keys act as editor commands. It also clears vertical cursor-column memory so later movement starts fresh.

Data flow: It checks the Vim-enabled flag, sets mode to normal, clears pending commands, and resets the preferred column.

Call relations: handle_vim_insert calls this when Escape is pressed.

Call graph: called by 1 (handle_vim_insert).

fn allows_paste_burst(&self) -> bool

Purpose: Tells the caller whether a burst of pasted text should be accepted directly. Paste bursts are allowed outside Vim or while Vim is in insert mode.

Data flow: It reads Vim state and returns true unless Vim normal mode is active.

Call relations: Key-event handling calls this before treating a paste-like stream as text input.

Call graph: called by 1 (handle_key_event_at).

fn uses_vim_insert_cursor(&self) -> bool

Purpose: Reports whether the cursor should look like Vim insert mode. This helps the UI draw the right cursor style.

Data flow: It reads whether Vim is enabled and whether the current mode is insert, then returns that combined answer.

Call relations: Rendering or surrounding UI code can call this when deciding how the cursor should appear.

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

Purpose: Recognizes the plain Escape key while in Vim insert mode. This lets the application intercept Escape as a mode switch instead of treating it as some other command.

Data flow: It receives a key event, checks Vim state, key code, modifiers, and event kind, and returns true only for an unmodified Escape press or repeat.

Call relations: Input orchestration can call this before normal key handling so Escape exits insert mode cleanly.

Call graph: 1 external calls (matches!).

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

Purpose: Returns a short label for the current Vim mode, or nothing if Vim editing is off. This is meant for status display.

Data flow: It reads the Vim-enabled flag and mode, then returns Normal, Insert, or no label.

Call relations: UI code can call this while drawing mode indicators.

fn text(&self) -> &str

Purpose: Gives read-only access to the current text. Callers use this when they need to submit, inspect, or render the buffer.

Data flow: It reads the stored string and returns it as a borrowed text slice without changing anything.

Call relations: Submission, rendering, key handling, and token-detection code call this to see the current buffer content.

Call graph: called by 5 (current_prefixed_token_range, handle_key_event_at, render, render, submit).

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

Purpose: Inserts text at the current cursor position. It is the simple public entry point for normal typing and paste insertion.

Data flow: It receives text and passes it with the current cursor position to insert_str_at, which performs the safe edit.

Call relations: Keyboard input, paste handling, yanking, and Vim paste operations call this when text should appear where the cursor is.

Call graph: calls 1 internal fn (insert_str_at); called by 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)

Purpose: Inserts text at a requested byte position while keeping the cursor and embedded elements consistent. It avoids inserting into the middle of a protected element.

Data flow: It receives a position and text, clamps the position to a safe insertion point, inserts the text, invalidates wrapping, shifts later element ranges, updates the cursor if needed, and clears preferred column memory.

Call relations: Lower-level editing paths call this for normal insertion, element insertion, Vim line opening, and linewise paste.

Call graph: calls 2 internal fn (clamp_pos_for_insertion, shift_elements); called by 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)

Purpose: Replaces a range of text, but first expands the range so embedded elements are not split apart. This is the safe public replacement path.

Data flow: It receives a byte range and replacement text, expands the range around any intersecting element, then hands it to the raw replacement routine.

Call relations: Backward and forward deletion use this so simple deletes still respect embedded elements.

Call graph: calls 2 internal fn (expand_range_to_element_boundaries, replace_range_raw); called by 2 (delete_backward, delete_forward).

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

Purpose: Performs the actual text replacement once the caller has chosen the range. It updates the cursor, element ranges, and wrapping cache afterward.

Data flow: It receives a range and replacement text, clamps the range into the buffer, replaces the bytes, updates element positions, moves the cursor according to where the edit happened, and clamps the cursor to a safe boundary.

Call relations: replace_range and kill operations call this after deciding what text should be removed or replaced.

Call graph: calls 2 internal fn (clamp_pos_to_nearest_boundary, update_elements_after_replace); called by 2 (kill_range_with_kind, replace_range); 1 external calls (assert!).

fn cursor(&self) -> usize

Purpose: Returns the current cursor byte position. This is useful for code that needs to relate outside actions to the text buffer.

Data flow: It reads and returns the stored cursor position without changing the text area.

Call relations: Token detection and remote image selection code call this to know where the user is editing.

Call graph: called by 2 (current_prefixed_token_range, handle_remote_image_selection_key).

fn set_cursor(&mut self, pos: usize)

Purpose: Moves the cursor to a requested position while keeping it valid. It will not leave the cursor inside a multi-byte character or embedded element.

Data flow: It receives a byte position, clamps it into the text length, snaps it to the nearest safe boundary, and clears preferred column memory.

Call relations: Many movement, insertion, paste, and Vim helper paths call this whenever they need an explicit cursor jump.

Call graph: calls 1 internal fn (clamp_pos_to_nearest_boundary); called by 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

Purpose: Calculates how many terminal rows the current text would need at a given width. This helps the UI size the input area.

Data flow: It receives a width, gets the wrapped line ranges for that width, and returns their count as a terminal row count.

Call relations: Input layout code calls this when deciding how tall the bottom pane should be.

Call graph: calls 1 internal fn (wrapped_lines); called by 2 (input_height, input_height).

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

Purpose: Calculates the cursor's screen coordinates using default scroll state. This maps the internal byte cursor to a visible terminal position.

Data flow: It receives a rectangular drawing area, creates default state, and delegates to the state-aware cursor position function.

Call relations: Rendering code calls this when it does not need to preserve or supply scroll state explicitly.

Call graph: calls 1 internal fn (cursor_pos_with_state); 1 external calls (default).

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

Purpose: Calculates where the cursor appears on screen after wrapping and scrolling. This turns the text cursor into terminal coordinates.

Data flow: It receives a drawing area and scroll state, wraps the text, adjusts scroll so the cursor is visible, finds the wrapped line containing the cursor, measures the display width before the cursor, and returns x/y coordinates.

Call relations: cursor_pos and other cursor display code call this when drawing or positioning the terminal cursor.

Call graph: calls 2 internal fn (effective_scroll, wrapped_lines); called by 3 (cursor_pos, cursor_pos, cursor_pos); 1 external calls (wrapped_line_index_by_start).

fn is_empty(&self) -> bool

Purpose: Reports whether the text area currently contains no text.

Data flow: It reads the stored string and returns whether it is empty.

Call relations: Outside code can use this for decisions such as whether submission is meaningful.

fn current_display_col(&self) -> usize

Purpose: Finds the cursor's visual column within the current logical line. Visual width matters because some Unicode characters occupy more than one terminal column.

Data flow: It finds the start of the current line, measures the display width from that point to the cursor, and returns the width.

Call relations: Vertical cursor movement uses this to keep the cursor in the same apparent column when moving up or down.

Call graph: calls 1 internal fn (beginning_of_current_line); called by 2 (move_cursor_down, move_cursor_up).

fn wrapped_line_index_by_start(lines: &[Range<usize>], pos: usize) -> Option<usize>

Purpose: Finds which wrapped line contains a given byte position. Wrapped lines are the visual rows after long text is broken to fit the terminal width.

Data flow: It receives wrapped line ranges and a position, searches by range starts, and returns the matching line index if one exists.

Call relations: Cursor positioning and vertical movement use this to connect a byte position to a visual line.

Call graph: 1 external calls (partition_point).

fn move_to_display_col_on_line(
        &mut self,
        line_start: usize,
        line_end: usize,
        target_col: usize,
    )

Purpose: Moves the cursor within one line to the closest position for a target visual column. It respects Unicode display width and embedded element boundaries.

Data flow: It receives a line start, line end, and target column. It walks grapheme clusters, adds their screen widths, and sets the cursor where the target column is reached or at the line end.

Call relations: Up and down movement call this after deciding which line the cursor should move to.

Call graph: calls 1 internal fn (clamp_pos_to_nearest_boundary); called by 2 (move_cursor_down, move_cursor_up).

fn beginning_of_line(&self, pos: usize) -> usize

Purpose: Finds the byte position where the line containing a given position starts.

Data flow: It receives a position, searches backward for a newline, and returns the byte after it or zero if there is no earlier newline.

Call relations: Line movement, current-line calculations, and vertical Vim ranges use this as their basic line-start helper.

Call graph: called by 3 (beginning_of_current_line, linewise_range_for_vertical_motion, move_cursor_to_beginning_of_line).

fn beginning_of_current_line(&self) -> usize

Purpose: Finds the start of the line where the cursor currently sits.

Data flow: It reads the current cursor position and delegates to beginning_of_line.

Call relations: Many editing and Vim commands call this before moving, deleting, or opening lines.

Call graph: calls 1 internal fn (beginning_of_line); called by 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

Purpose: Finds the first non-whitespace character on the current line. This supports Vim-style commands that jump to indentation.

Data flow: It finds the current line boundaries, scans from the start for a non-whitespace character, and returns that position or the line end if the line is blank.

Call relations: Vim normal-mode insert-at-line-start uses this to place the cursor after indentation.

Call graph: calls 2 internal fn (beginning_of_current_line, end_of_current_line); called by 1 (handle_vim_normal).

fn end_of_line(&self, pos: usize) -> usize

Purpose: Finds the byte position where the line containing a given position ends, not including the newline.

Data flow: It receives a position, searches forward for a newline, and returns that newline position or the end of the text.

Call relations: Line movement, current-line calculations, and linewise Vim ranges use this as their basic line-end helper.

Call graph: called by 3 (end_of_current_line, linewise_range_for_vertical_motion, move_cursor_to_end_of_line).

fn end_of_current_line(&self) -> usize

Purpose: Finds the end of the line where the cursor currently sits.

Data flow: It reads the cursor position and delegates to end_of_line.

Call relations: Deletion, paste, Vim movement, and line opening all use this to know where the current line stops.

Call graph: calls 1 internal fn (end_of_line); called by 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)

Purpose: Processes one keyboard event for the text area. It ignores key releases and sends key presses to either normal editing or Vim editing.

Data flow: It receives a key event, returns immediately unless it is a press or repeat, then chooses handle_vim_input or input_with_keymap based on Vim state.

Call relations: Top-level key-event handling calls this when the text area should react to user input.

Call graph: calls 2 internal fn (handle_vim_input, input_with_keymap); called by 2 (handle_key_event_at, handle_key_event); 2 external calls (matches!, clone).

fn input_with_keymap(&mut self, event: KeyEvent, keymap: &EditorKeymap)

Purpose: Interprets a key event using the regular editor keymap. It turns shortcuts into editing actions and plain printable characters into inserted text.

Data flow: It receives a key event and keymap, checks shortcuts in priority order, performs matching actions such as delete, move, kill, yank, or insert newline, and inserts plain characters when appropriate.

Call relations: input uses this when Vim is off, and handle_vim_insert uses it while Vim is in insert mode.

Call graph: calls 19 internal fn (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)); called by 2 (handle_vim_insert, input); 2 external calls (matches!, debug!).

fn handle_vim_input(&mut self, event: KeyEvent)

Purpose: Dispatches a Vim-mode key event to the correct mode-specific handler. Vim insert mode and normal mode interpret the same keys very differently.

Data flow: It receives a key event, reads the current Vim mode, and calls either handle_vim_insert or handle_vim_normal.

Call relations: input calls this whenever Vim editing is enabled.

Call graph: calls 2 internal fn (handle_vim_insert, handle_vim_normal); called by 1 (input).

fn handle_vim_insert(&mut self, event: KeyEvent)

Purpose: Handles keys while Vim is in insert mode. Most keys behave like normal editor input, but Escape returns to normal mode.

Data flow: It receives a key event. If it is Escape, it moves the cursor back one safe step when appropriate and enters normal mode; otherwise it passes the event to regular keymap input handling.

Call relations: handle_vim_input calls this for insert-mode Vim events.

Call graph: calls 4 internal fn (beginning_of_current_line, enter_vim_normal_mode, input_with_keymap, prev_atomic_boundary); called by 1 (handle_vim_input); 2 external calls (matches!, clone).

fn handle_vim_normal(&mut self, event: KeyEvent)

Purpose: Handles keys while Vim is in normal mode. In this mode keys move the cursor, start commands, delete or yank text, paste, or switch back to insert mode.

Data flow: It receives a key event, first completes any pending operator or text-object command, then checks normal-mode bindings and updates text, cursor, mode, or pending command state.

Call relations: handle_vim_input calls this for normal-mode events; it hands multi-key commands to operator and text-object helpers.

Call graph: calls 20 internal fn (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)); called by 1 (handle_vim_input); 2 external calls (replace, Operator).

fn handle_vim_operator(&mut self, op: VimOperator, event: KeyEvent) -> bool

Purpose: Handles the second key after a Vim operator such as delete or yank. For example, it decides whether d followed by a motion deletes that motion's range.

Data flow: It receives an operator and key event, checks special line commands, cancellation, text-object starts, and motion keys. It may update pending state or apply the operator to a motion range, returning whether it consumed the key.

Call relations: handle_vim_normal calls this when an operator was pending from the previous key.

Call graph: calls 4 internal fn (apply_vim_operator, kill_current_line, vim_motion_for_event, yank_current_line); called by 1 (handle_vim_normal).

fn handle_vim_text_object(
        &mut self,
        op: VimOperator,
        scope: VimTextObjectScope,
        event: KeyEvent,
    ) -> bool

Purpose: Completes a Vim text-object command, such as operating on a quoted or bracketed region. It applies delete, yank, or change to the chosen object range.

Data flow: It receives an operator, object scope, and key event. It handles cancellation, identifies the requested text object, finds its range, and applies the operator if a range exists.

Call relations: handle_vim_normal calls this when the previous keys started a text-object operation.

Call graph: calls 1 internal fn (apply_vim_operator_to_range); called by 1 (handle_vim_normal).

fn vim_motion_for_event(&self, event: KeyEvent) -> Option<VimMotion>

Purpose: Converts a Vim operator-mode key event into a motion name, such as left, word-forward, or line-end.

Data flow: It receives a key event, checks it against Vim operator motion bindings, and returns the matching motion or nothing.

Call relations: handle_vim_operator calls this before applying delete or yank over a movement range.

Call graph: called by 1 (handle_vim_operator).

fn apply_vim_operator(&mut self, op: VimOperator, motion: VimMotion)

Purpose: Applies a Vim operator to the range described by a motion. This is how commands like delete-word or yank-to-line-end become concrete edits.

Data flow: It receives an operator and motion, asks for the motion's range, and then deletes or yanks that range. Change is intentionally not handled on plain motions here.

Call relations: handle_vim_operator calls this after recognizing a motion key.

Call graph: calls 3 internal fn (kill_range, range_for_motion, yank_range); called by 1 (handle_vim_operator).

fn apply_vim_operator_to_range(&mut self, op: VimOperator, range: Range<usize>)

Purpose: Applies a Vim operator directly to an already-known range, usually from a text object. Change deletes the range and switches to insert mode.

Data flow: It receives an operator and byte range, then deletes, yanks, or deletes-and-enters-insert depending on the operator.

Call relations: handle_vim_text_object calls this after resolving the selected text object.

Call graph: calls 2 internal fn (kill_range, yank_range); called by 1 (handle_vim_text_object).

fn range_for_motion(&mut self, motion: VimMotion) -> Option<Range<usize>>

Purpose: Turns a Vim motion into the byte range that an operator should affect. It handles vertical movement specially as linewise ranges.

Data flow: It receives a motion, uses linewise logic for up/down, otherwise calculates a target position, compares it with the original cursor, and returns the span between them if non-empty.

Call relations: apply_vim_operator calls this before deleting or yanking motion-based text.

Call graph: calls 2 internal fn (linewise_range_for_vertical_motion, target_for_motion); called by 1 (apply_vim_operator); 1 external calls (matches!).

fn linewise_range_for_vertical_motion(&self, motion: VimMotion) -> Option<Range<usize>>

Purpose: Builds a whole-line range for Vim operators combined with up or down movement. Vertical operator motions affect lines rather than just columns.

Data flow: It reads the current line range, expands upward to include the previous line or downward to include the next line, and returns the non-empty range.

Call relations: range_for_motion uses this when the motion is up or down.

Call graph: calls 3 internal fn (beginning_of_line, current_line_range_with_newline, end_of_line); called by 1 (range_for_motion).

fn target_for_motion(&mut self, motion: VimMotion) -> usize

Purpose: Finds where a motion would move the cursor without actually leaving the cursor there. This lets operators measure a range safely.

Data flow: It saves the current cursor and preferred column, performs the requested movement, records the resulting cursor, then restores the original cursor state and returns the target.

Call relations: range_for_motion calls this for non-linewise Vim motions.

Call graph: calls 10 internal fn (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); called by 1 (range_for_motion).

fn delete_backward(&mut self, n: usize)

Purpose: Deletes a given number of atomic units before the cursor. An atomic unit may be a whole grapheme or a whole embedded element.

Data flow: It receives a count, repeatedly steps backward to find the deletion start, then replaces that range with nothing.

Call relations: Regular keymap input calls this for backspace-style deletion.

Call graph: calls 2 internal fn (prev_atomic_boundary, replace_range); called by 1 (input_with_keymap).

fn delete_forward(&mut self, n: usize)

Purpose: Deletes a given number of atomic units after the cursor. It respects complex characters and embedded elements.

Data flow: It receives a count, repeatedly steps forward to find the deletion end, then replaces the range from the cursor to that point with nothing.

Call relations: Regular keymap input calls this for delete-key behavior.

Call graph: calls 2 internal fn (next_atomic_boundary, replace_range); called by 1 (input_with_keymap).

fn delete_forward_kill(&mut self, n: usize)

Purpose: Deletes text after the cursor and saves it in the kill buffer. This is used for Vim delete-character behavior.

Data flow: It receives a count, finds the forward atomic boundary after that many units, and kills the range from the cursor to that boundary.

Call relations: Vim normal mode calls this for commands that delete characters under or after the cursor.

Call graph: calls 2 internal fn (kill_range, next_atomic_boundary); called by 1 (handle_vim_normal).

fn delete_backward_word(&mut self)

Purpose: Deletes the word before the cursor and saves it in the kill buffer. This matches common editor shortcut behavior.

Data flow: It finds the beginning of the previous word, then kills the range from that point to the cursor.

Call relations: Regular keymap input calls this for backward-word deletion.

Call graph: calls 2 internal fn (beginning_of_previous_word, kill_range); called by 1 (input_with_keymap).

fn delete_forward_word(&mut self)

Purpose: Deletes the next word after the cursor and saves it in the kill buffer.

Data flow: It finds the end of the next word and, if that is beyond the cursor, kills the range between the cursor and that end.

Call relations: Regular keymap input calls this for forward-word deletion.

Call graph: calls 2 internal fn (end_of_next_word, kill_range); called by 1 (input_with_keymap).

fn kill_to_end_of_line(&mut self)

Purpose: Deletes from the cursor to the end of the current line, saving what was removed. If already at line end, it removes the newline when possible.

Data flow: It finds the current line end, chooses the correct range, and kills it if there is something to remove.

Call relations: Regular keymap input calls this for kill-line-end shortcuts.

Call graph: calls 2 internal fn (end_of_current_line, kill_range); called by 1 (input_with_keymap).

fn vim_kill_to_end_of_line(&mut self)

Purpose: Deletes from the cursor to the end of the current line for Vim commands. Unlike the regular version, it does not remove the newline when already at line end.

Data flow: It finds the current line end and kills text only if the cursor is before that end.

Call relations: Vim normal mode calls this for delete-to-line-end and change-to-line-end commands.

Call graph: calls 2 internal fn (end_of_current_line, kill_range); called by 1 (handle_vim_normal).

fn kill_to_beginning_of_line(&mut self)

Purpose: Deletes from the cursor back to the start of the current line, saving what was removed. If already at the start, it removes the previous newline when possible.

Data flow: It finds the current line start, chooses a backward range, and kills it if one exists.

Call relations: Regular keymap input calls this for kill-line-start shortcuts.

Call graph: calls 2 internal fn (beginning_of_current_line, kill_range); called by 1 (input_with_keymap).

fn yank(&mut self)

Purpose: Pastes the current kill buffer at the cursor. This is similar to paste after a previous cut or yank.

Data flow: It checks whether the kill buffer has text, clones it, and inserts it at the cursor.

Call relations: Regular keymap input calls this for yank/paste shortcuts.

Call graph: calls 1 internal fn (insert_str); called by 1 (input_with_keymap).

fn kill_range(&mut self, range: Range<usize>)

Purpose: Deletes a characterwise range and stores the removed text in the kill buffer. Characterwise means the paste later behaves like inline text.

Data flow: It receives a range and delegates to the kind-aware kill routine with the characterwise kind.

Call relations: Vim operators and word/line-edge deletion helpers call this for normal cut-style operations.

Call graph: calls 1 internal fn (kill_range_with_kind); called by 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>)

Purpose: Deletes a whole-line range and marks the kill buffer as linewise. Linewise paste later inserts it as a line, not inline text.

Data flow: It receives a range and delegates to the kind-aware kill routine with the linewise kind.

Call relations: kill_current_line calls this when a complete line is removed.

Call graph: calls 1 internal fn (kill_range_with_kind); called by 1 (kill_current_line).

fn kill_range_with_kind(&mut self, range: Range<usize>, kind: KillBufferKind)

Purpose: Cuts text out of the buffer and records how it should paste later. It also protects embedded elements by expanding the cut range around them.

Data flow: It receives a range and kill-buffer kind, expands the range to include whole elements, copies the removed text into the kill buffer, then removes it from the buffer.

Call relations: kill_range and kill_line_range use this shared implementation.

Call graph: calls 3 internal fn (expand_range_to_element_boundaries, replace_range_raw, store_kill_buffer); called by 2 (kill_line_range, kill_range); 1 external calls (clone).

fn yank_range(&mut self, range: Range<usize>)

Purpose: Copies a characterwise range into the kill buffer without deleting it.

Data flow: It receives a range and delegates to the kind-aware yank routine with the characterwise kind.

Call relations: Vim operator application calls this for yank motions and text objects.

Call graph: calls 1 internal fn (yank_range_with_kind); called by 2 (apply_vim_operator, apply_vim_operator_to_range).

fn yank_line_range(&mut self, range: Range<usize>)

Purpose: Copies a whole-line range into the kill buffer and marks it as linewise.

Data flow: It receives a range and delegates to the kind-aware yank routine with the linewise kind.

Call relations: yank_current_line calls this for Vim line-yank commands.

Call graph: calls 1 internal fn (yank_range_with_kind); called by 1 (yank_current_line).

fn yank_range_with_kind(&mut self, range: Range<usize>, kind: KillBufferKind)

Purpose: Copies text into the kill buffer without changing the visible buffer. It expands around embedded elements so copied text does not contain half an element.

Data flow: It receives a range and kind, expands the range to whole elements, copies the text if non-empty, and stores it in the kill buffer with the kind.

Call relations: yank_range and yank_line_range share this implementation.

Call graph: calls 2 internal fn (expand_range_to_element_boundaries, store_kill_buffer); called by 2 (yank_line_range, yank_range).

fn store_kill_buffer(&mut self, text: String, kind: KillBufferKind)

Purpose: Stores text in the internal kill buffer and remembers whether it is inline or linewise.

Data flow: It receives text and a kind, then replaces the previous kill buffer contents and kind.

Call relations: Cut and yank helpers call this after they have decided what text should be saved.

Call graph: called by 2 (kill_range_with_kind, yank_range_with_kind).

fn paste_after_cursor(&mut self)

Purpose: Implements Vim-style paste after the cursor. Linewise saved text is pasted after the current line; inline saved text is inserted after the current atomic unit.

Data flow: It checks the kill buffer, chooses linewise or characterwise paste, moves the cursor to the insertion point for inline paste, and inserts the saved text.

Call relations: Vim normal mode calls this for paste-after commands.

Call graph: calls 4 internal fn (insert_str, next_atomic_boundary, paste_line_after_current_line, set_cursor); called by 1 (handle_vim_normal).

fn paste_line_after_current_line(&mut self)

Purpose: Pastes linewise kill-buffer text after the current line. It adjusts newlines so the result looks like a line paste rather than a raw string splice.

Data flow: It finds the current line end, chooses an insertion point and final cursor position, prepares text with needed newline handling, inserts it, and moves the cursor.

Call relations: paste_after_cursor calls this when the kill buffer is marked linewise.

Call graph: calls 3 internal fn (end_of_current_line, insert_str_at, set_cursor); called by 1 (paste_after_cursor); 1 external calls (format!).

fn yank_current_line(&mut self)

Purpose: Copies the current line, including its newline when present, into the kill buffer as linewise text.

Data flow: It finds the current line range including the newline and yanks that range with linewise kind.

Call relations: Vim normal mode and Vim operator handling call this for line-yank commands.

Call graph: calls 2 internal fn (current_line_range_with_newline, yank_line_range); called by 2 (handle_vim_normal, handle_vim_operator).

fn kill_current_line(&mut self)

Purpose: Deletes the current line, including its newline when present, and stores it as linewise kill-buffer text.

Data flow: It finds the current line range including the newline and kills that range with linewise kind.

Call relations: Regular keymap input and Vim operator handling call this for whole-line deletion.

Call graph: calls 2 internal fn (current_line_range_with_newline, kill_line_range); called by 2 (handle_vim_operator, input_with_keymap).

fn current_line_range_with_newline(&self) -> Range<usize>

Purpose: Returns the range for the current line, including the trailing newline if there is one. This is the unit used for whole-line operations.

Data flow: It finds the current line start and end, extends the end past the newline when possible, and returns the resulting byte range.

Call relations: Whole-line kill, yank, and vertical Vim operator ranges call this.

Call graph: calls 2 internal fn (beginning_of_current_line, end_of_current_line); called by 3 (kill_current_line, linewise_range_for_vertical_motion, yank_current_line).

fn move_cursor_left(&mut self)

Purpose: Moves the cursor one atomic step left. It will jump over an embedded element as a whole instead of entering it.

Data flow: It asks for the previous atomic boundary, stores it as the cursor position, and clears preferred column memory.

Call relations: Regular input, Vim normal mode, and Vim range measurement call this for left movement.

Call graph: calls 1 internal fn (prev_atomic_boundary); called by 3 (handle_vim_normal, input_with_keymap, target_for_motion).

fn move_cursor_right(&mut self)

Purpose: Moves the cursor one atomic step right. It respects graphemes and embedded elements.

Data flow: It asks for the next atomic boundary, stores it as the cursor position, and clears preferred column memory.

Call relations: Regular input, Vim normal mode, and Vim range measurement call this for right movement.

Call graph: calls 1 internal fn (next_atomic_boundary); called by 3 (handle_vim_normal, input_with_keymap, target_for_motion).

fn move_cursor_up(&mut self)

Purpose: Moves the cursor up one visible row while trying to keep the same screen column. If wrapped-line information exists, it moves by visual wrapped lines; otherwise it falls back to newline-based lines.

Data flow: It reads cached wrapping when available, chooses the previous visual line and target column, moves within that line, or moves to the start if already at the top. Without wrapping, it uses newline searches.

Call relations: Regular input, Vim normal mode, and Vim range measurement call this for upward movement.

Call graph: calls 2 internal fn (current_display_col, move_to_display_col_on_line); called by 3 (handle_vim_normal, input_with_keymap, target_for_motion); 1 external calls (wrapped_line_index_by_start).

fn move_cursor_down(&mut self)

Purpose: Moves the cursor down one visible row while preserving the preferred screen column. It understands both wrapped visual lines and plain newline-separated lines.

Data flow: It uses cached wrapping when available to choose the next visual line, otherwise searches for the next logical line. It updates the cursor or moves to the end if already at the bottom.

Call relations: Regular input, Vim normal mode, and Vim range measurement call this for downward movement.

Call graph: calls 2 internal fn (current_display_col, move_to_display_col_on_line); called by 3 (handle_vim_normal, input_with_keymap, target_for_motion); 1 external calls (wrapped_line_index_by_start).

fn move_cursor_to_beginning_of_line(&mut self, move_up_at_bol: bool)

Purpose: Moves the cursor to the start of the current line, with an optional shortcut behavior that moves to the previous line if already at the start.

Data flow: It receives a flag, finds the current line start, optionally finds the previous line start, sets the cursor, and clears preferred column memory.

Call relations: Regular keymap input calls this for line-start movement shortcuts.

Call graph: calls 3 internal fn (beginning_of_current_line, beginning_of_line, set_cursor); called by 1 (input_with_keymap).

fn move_cursor_to_end_of_line(&mut self, move_down_at_eol: bool)

Purpose: Moves the cursor to the end of the current line, with an optional shortcut behavior that moves to the next line's end if already at the end.

Data flow: It receives a flag, finds the current line end, optionally finds the next line end, and sets the cursor there.

Call relations: Regular keymap input calls this for line-end movement shortcuts.

Call graph: calls 3 internal fn (end_of_current_line, end_of_line, set_cursor); called by 1 (input_with_keymap).

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

Purpose: Returns the current text content of all embedded elements. This gives callers just the visible placeholder strings for those elements.

Data flow: It walks internal element ranges, extracts each matching text slice, converts it to an owned string, and returns the list.

Call relations: External feature code can call this when it needs the text represented by embedded elements.

fn text_elements(&self) -> Vec<UserTextElement>

Purpose: Returns public descriptions of all embedded elements, including their byte ranges and placeholder text. This lets outside code save or inspect element positions.

Data flow: It walks internal elements, builds UserTextElement values with their ranges and current text, and returns them.

Call relations: Code outside the text area can use this to preserve element metadata alongside the raw text.

fn text_element_snapshots(&self) -> Vec<TextElementSnapshot>

Purpose: Returns internal snapshots of embedded elements, including stable ids, ranges, and current text. This is useful when later code needs to compare or update elements.

Data flow: It walks element records, extracts text for each valid range, and returns snapshot objects.

Call relations: Internal UI or attachment code can call this to track embedded element state.

fn element_id_for_exact_range(&self, range: Range<usize>) -> Option<u64>

Purpose: Finds the id of an embedded element that exactly matches a given byte range.

Data flow: It receives a range, searches stored elements for the same range, and returns the id if found.

Call relations: Internal code can use this when it already knows a range and needs the stable element identity.

fn replace_element_payload(&mut self, old: &str, new: &str) -> bool

Purpose: Replaces the text of one embedded element while preserving element tracking. This is useful when a placeholder needs to be relabeled.

Data flow: It receives old and new text, finds the element whose current payload matches the old text, replaces that text, updates that element's range, shifts later elements, updates the cursor, clears wrapping, and returns whether a replacement happened.

Call relations: Image relabeling code calls this when local image placeholders need new visible text.

Call graph: calls 1 internal fn (clamp_pos_to_nearest_boundary); called by 1 (relabel_local_images).

fn insert_element(&mut self, text: &str) -> u64

Purpose: Inserts a new embedded element at the cursor and records its range as protected. The cursor ends up after the inserted element.

Data flow: It receives the element's text, clamps the insertion point, inserts the text, adds an element range around it, moves the cursor to the end, and returns the new element id.

Call relations: Attachment code calls this when inserting things such as image placeholders into the input.

Call graph: calls 4 internal fn (add_element, clamp_pos_for_insertion, insert_str_at, set_cursor); called by 1 (attach_image).

fn add_element(&mut self, range: Range<usize>) -> u64

Purpose: Adds an internal embedded-element record for an existing range and assigns it a fresh id.

Data flow: It receives a range, allocates the next id, stores the element, sorts elements by position, and returns the id.

Call relations: insert_element and add_element_range use this after they have chosen a valid range.

Call graph: calls 1 internal fn (next_element_id); called by 2 (add_element_range, insert_element).

fn add_element_range(&mut self, range: Range<usize>) -> Option<u64>

Purpose: Marks an existing range of text as an embedded element. It rejects empty, duplicate, or overlapping ranges.

Data flow: It receives a range, clamps both ends to safe character boundaries, checks for validity and overlap, then adds the element and returns its id if successful.

Call relations: External code can call this when text already contains a placeholder that should become protected.

Call graph: calls 2 internal fn (add_element, clamp_pos_to_char_boundary).

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

Purpose: Removes embedded-element tracking for an exact text range without deleting the text itself.

Data flow: It receives a range, clamps it safely, removes any stored element with exactly that range, and returns whether anything was removed.

Call relations: External code can call this when a placeholder should stop being treated as protected.

Call graph: calls 1 internal fn (clamp_pos_to_char_boundary).

fn next_element_id(&mut self) -> u64

Purpose: Generates a new stable id for an embedded element. The id counter saturates instead of overflowing.

Data flow: It reads the current next id, increments the stored counter, and returns the old value as the assigned id.

Call relations: Element creation paths call this when rebuilding text with elements or adding a new element.

Call graph: called by 2 (add_element, set_text_inner).

fn find_element_containing(&self, pos: usize) -> Option<usize>

Purpose: Finds whether a byte position is inside an embedded element, not including its edges. This helps keep the cursor out of protected ranges.

Data flow: It receives a position, scans element ranges, and returns the index of the first element whose interior contains that position.

Call relations: Boundary clamping and atomic cursor movement call this whenever they need to avoid splitting an element.

Call graph: called by 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

Purpose: Moves a byte position to the nearest valid character boundary. This prevents slicing a UTF-8 character in half.

Data flow: It receives a byte position, limits it to the text length, checks whether it is already valid, otherwise searches backward and forward for valid boundaries and returns the closest one.

Call relations: Text setting, element range changes, cursor clamping, and insertion safety all rely on this.

Call graph: called by 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

Purpose: Moves a byte position to a safe cursor location. Safe means both a valid character boundary and not inside an embedded element.

Data flow: It first clamps to a character boundary, then if the position is inside an element, chooses the nearest element edge and returns that boundary.

Call relations: Cursor setting, text replacement, element replacement, and visual-line movement use this after computing a new position.

Call graph: calls 2 internal fn (clamp_pos_to_char_boundary, find_element_containing); called by 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

Purpose: Chooses a safe insertion point for new text. It prevents new text from being inserted into the middle of an embedded element.

Data flow: It receives a position, clamps it to a character boundary, and if it falls inside an element, returns the closest edge of that element.

Call relations: Text insertion and element insertion call this before modifying the string.

Call graph: calls 2 internal fn (clamp_pos_to_char_boundary, find_element_containing); called by 2 (insert_element, insert_str_at).

fn expand_range_to_element_boundaries(&self, mut range: Range<usize>) -> Range<usize>

Purpose: Expands an edit range until any touched embedded elements are included whole. This avoids cutting or copying half of a protected placeholder.

Data flow: It receives a range, repeatedly scans elements for overlaps, grows the range to include full overlapping elements, and returns the final range.

Call relations: Replacement, kill, and yank routines call this before operating on user-visible text.

Call graph: called by 3 (kill_range_with_kind, replace_range, yank_range_with_kind).

fn shift_elements(&mut self, at: usize, removed: usize, inserted: usize)

Purpose: Updates embedded-element ranges after text has been inserted, deleted, or replaced. It keeps element positions lined up with the changed string.

Data flow: It receives an edit start, removed length, and inserted length. It removes elements fully deleted by the edit, shifts elements after the edit by the length difference, and repairs partial overlaps defensively.

Call relations: Insertion and replacement-update code call this whenever text length changes.

Call graph: called by 2 (insert_str_at, update_elements_after_replace).

fn update_elements_after_replace(&mut self, start: usize, end: usize, inserted_len: usize)

Purpose: Updates element positions after a replacement operation. It is a small adapter around the generic element-shifting logic.

Data flow: It receives replacement start, end, and inserted length, computes the removed length, and calls shift_elements.

Call relations: replace_range_raw calls this after changing the text.

Call graph: calls 1 internal fn (shift_elements); called by 1 (replace_range_raw).

fn prev_atomic_boundary(&self, pos: usize) -> usize

Purpose: Finds the previous safe cursor boundary before a position. It treats an embedded element as one indivisible chunk and respects Unicode grapheme clusters.

Data flow: It receives a position, returns zero at the start, jumps to an element start when inside or at an element end, otherwise asks a Unicode grapheme cursor for the previous boundary and adjusts away from element interiors.

Call relations: Backward deletion, left movement, Vim cursor placement, and word-end logic use this.

Call graph: calls 1 internal fn (find_element_containing); called by 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 external calls (new).

fn next_atomic_boundary(&self, pos: usize) -> usize

Purpose: Finds the next safe cursor boundary after a position. It treats embedded elements and complex Unicode characters as indivisible units.

Data flow: It receives a position, returns the text length at the end, jumps to an element end when inside or at its start, otherwise asks a Unicode grapheme cursor for the next boundary and adjusts away from element interiors.

Call relations: Forward deletion, right movement, Vim append, and paste-after logic use this.

Call graph: calls 1 internal fn (find_element_containing); called by 5 (delete_forward, delete_forward_kill, handle_vim_normal, move_cursor_right, paste_after_cursor); 1 external calls (new).

fn beginning_of_previous_word(&self) -> usize

Purpose: Finds where the previous word-like piece starts. It skips trailing whitespace and treats runs of punctuation separately from normal word text.

Data flow: It looks backward from the cursor, finds the previous non-whitespace run, splits it into pieces, chooses the correct piece start, and adjusts out of embedded elements.

Call relations: Word movement and backward-word deletion call this in regular and Vim editing.

Call graph: calls 2 internal fn (adjust_pos_out_of_elements, split_word_pieces); called by 4 (delete_backward_word, handle_vim_normal, input_with_keymap, target_for_motion).

fn end_of_next_word(&self) -> usize

Purpose: Finds the end position of the next word-like piece starting from the current cursor.

Data flow: It passes the current cursor position to the more general end_of_next_word_from helper and returns that result.

Call relations: Word deletion, word movement, and Vim word-end helpers call this.

Call graph: calls 1 internal fn (end_of_next_word_from); called by 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

Purpose: Finds the end of the next word-like piece starting from a supplied position. It can be used from places other than the current cursor.

Data flow: It receives a starting position, skips whitespace, takes the next non-whitespace run, splits it into separator-aware pieces, chooses the correct end, and adjusts out of embedded elements.

Call relations: end_of_next_word and Vim word-end logic call this when they need word boundaries.

Call graph: calls 2 internal fn (adjust_pos_out_of_elements, split_word_pieces); called by 2 (end_of_next_word, vim_word_end_exclusive).

fn vim_word_end_exclusive(&self) -> usize

Purpose: Computes the exclusive end boundary used for Vim word-end operations. Exclusive means the returned position is just after the affected text.

Data flow: It finds the next word end, checks whether the cursor would fail to move in Vim terms, and may advance to the following word end.

Call relations: Vim motion targeting and Vim word-end cursor placement call this.

Call graph: calls 3 internal fn (end_of_next_word, end_of_next_word_from, prev_atomic_boundary); called by 2 (target_for_motion, vim_word_end_cursor).

fn vim_word_end_cursor(&self) -> usize

Purpose: Finds the cursor position for Vim's word-end movement. Vim displays the cursor on the last character of the word, so this moves back from the exclusive end.

Data flow: It gets the exclusive word end and, if it is beyond the cursor, returns the previous atomic boundary; otherwise it returns the end itself.

Call relations: Vim normal mode calls this for word-end movement.

Call graph: calls 2 internal fn (prev_atomic_boundary, vim_word_end_exclusive); called by 1 (handle_vim_normal).

fn vim_line_end_cursor(&self) -> usize

Purpose: Finds the cursor position for Vim's line-end movement. Vim normally lands on the last character of the line rather than after it.

Data flow: It finds the current line start and end, moves one atomic step back from the line end when the line is non-empty, and never moves before the line start.

Call relations: Vim normal mode calls this for line-end movement.

Call graph: calls 3 internal fn (beginning_of_current_line, end_of_current_line, prev_atomic_boundary); called by 1 (handle_vim_normal).

fn beginning_of_next_word(&self) -> usize

Purpose: Finds the start of the next word-like piece. If the cursor is in whitespace, it returns the next non-whitespace position; otherwise it skips the current word first.

Data flow: It searches forward from the cursor, either returns the next non-whitespace start or finds the current word end and then the next word start, adjusting away from embedded elements.

Call relations: Vim normal movement and Vim motion targeting call this for word-forward commands.

Call graph: calls 2 internal fn (adjust_pos_out_of_elements, end_of_next_word); called by 2 (handle_vim_normal, target_for_motion).

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

Purpose: Moves a position out of an embedded element if it lands inside one. The caller chooses whether to prefer the start or end edge.

Data flow: It receives a position and preference flag, checks whether the position is inside an element, and returns that element's start or end if needed.

Call relations: Word-boundary functions call this so word movement does not stop inside protected placeholders.

Call graph: calls 1 internal fn (find_element_containing); called by 3 (beginning_of_next_word, beginning_of_previous_word, end_of_next_word_from).

fn wrapped_lines(&self, width: u16) -> Ref<'_, Vec<Range<usize>>>

Purpose: Returns the current text split into visual line ranges for a given terminal width. It caches the result so repeated rendering does not rewrap unchanged text.

Data flow: It receives a width, checks whether the cached wrap result matches that width, recalculates ranges if needed, stores them, and returns a borrowed view of the ranges.

Call relations: Height calculation, cursor positioning, and rendering paths call this before working with visual rows.

Call graph: calls 1 internal fn (wrap_ranges); called by 5 (cursor_pos_with_state, desired_height, render_ref, render_ref_masked, render_ref_styled_with_highlights); 2 external calls (new, map).

fn effective_scroll(
        &self,
        area_height: u16,
        lines: &[Range<usize>],
        current_scroll: u16,
    ) -> u16

Purpose: Chooses a scroll offset that keeps the cursor visible inside the drawing area. It also clamps scroll so it never goes past the available wrapped lines.

Data flow: It receives area height, wrapped lines, and current scroll, computes total lines and cursor line, adjusts scroll upward or downward if the cursor is outside the visible window, and returns the new scroll.

Call relations: Cursor positioning and all render variants call this before drawing visible lines.

Call graph: called by 4 (cursor_pos_with_state, render_ref, render_ref_masked, render_ref_styled_with_highlights); 2 external calls (wrapped_line_index_by_start, len).

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

Purpose: Draws the text area normally into the terminal buffer. It wraps the text, updates scroll, and renders only visible lines.

Data flow: It receives a drawing rectangle, buffer, and state, gets wrapped lines, computes effective scroll, stores it in state, and asks the line renderer to draw the visible slice with default styling.

Call relations: The terminal UI rendering system calls this as the standard render path.

Call graph: calls 3 internal fn (effective_scroll, render_lines, wrapped_lines); 1 external calls (default).

fn render_ref_masked(
        &self,
        area: Rect,
        buf: &mut Buffer,
        state: &mut TextAreaState,
        mask_char: char,
    )

Purpose: Draws the text area with every visible character replaced by a mask character. This is useful for password-like input.

Data flow: It receives a drawing area, buffer, state, and mask character, computes wrapped lines and scroll, then calls the masked line renderer for the visible range.

Call relations: UI code calls this variant when the input content should be hidden.

Call graph: calls 3 internal fn (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

Purpose: Draws the text area with a base style and extra highlighted ranges. This supports visual emphasis such as matches or tokens.

Data flow: It receives drawing information, a base style, and highlight ranges, computes wrapped lines and scroll, then renders the visible lines with those styles applied.

Call relations: UI code calls this styled render path when plain text drawing is not enough.

Call graph: calls 3 internal fn (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

Purpose: Draws a set of visible text lines into the terminal buffer with a base style, special element coloring, and optional temporary highlights. It is used when the text area is visible and may need styled regions such as attachments or search matches.

Data flow: It reads the text, the precomputed line byte ranges, the screen rectangle, the base style, and highlight ranges. For each visible row, it paints the whole row with the base style, writes the plain text, overlays embedded elements in cyan where they overlap the line, then overlays highlight styles last. The output is a changed terminal buffer; the stored text is not changed.

Call relations: The normal render paths, including render_ref and render_ref_styled_with_highlights, call this when they need to paint unmasked text. It hands the actual screen writing to the buffer methods that set styles and strings.

Call graph: called by 2 (render_ref, render_ref_styled_with_highlights); 5 external calls (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,
    )

Purpose: Draws visible text as repeated mask characters, like password dots or stars. It lets the text area show that content exists without revealing the actual characters.

Data flow: It reads the same line ranges and screen rectangle as normal rendering, plus a mask character. For each visible line, it replaces every character in that slice with the mask character and writes that masked string to the terminal buffer. The original text remains unchanged.

Call relations: The masked render path, render_ref_masked, calls this when hidden input should be displayed. It delegates final drawing to the terminal buffer.

Call graph: called by 1 (render_ref_masked); 3 external calls (set_string, default, enumerate).

fn rand_grapheme(rng: &mut rand::rngs::StdRng) -> String

Purpose: Creates a random visible text unit for tests, including plain letters, spaces, newlines, emoji, CJK characters, combining marks, and joined emoji sequences. This helps tests cover the kinds of text that often break cursor movement.

Data flow: It takes a seeded random number generator, chooses a category, then returns one string representing a single grapheme, meaning what a user sees as one character even if it is stored as several code points. It changes only the random generator’s state.

Call relations: This is a test helper. No caller is shown in this chunk, but it is designed to feed randomized TextArea tests with realistic Unicode cases.

Call graph: 2 external calls (random_range, format!).

fn ta_with(text: &str) -> TextArea

Purpose: Builds a TextArea already filled with the given text. Tests use it to avoid repeating setup code.

Data flow: It receives a string slice, creates a new TextArea, inserts the string, and returns the populated TextArea. The caller gets a ready-to-edit test object.

Call relations: Many tests in this module call it before exercising cursor movement, deletion, rendering, or Vim behavior. It relies on TextArea::new and insert_str.

Call graph: calls 1 internal fn (new).

fn insert_and_replace_update_cursor_and_text()

Purpose: Checks that inserting and replacing text changes both the text and cursor position in predictable ways. It protects against edits leaving the cursor in the wrong place.

Data flow: It builds small text areas, performs inserts and replacements before, at, and after the cursor, then compares the resulting text and cursor values with expected results. It produces no value; failures are reported by assertions.

Call relations: The test runner calls this test. It uses ta_with and public editing methods to verify the core insertion and replacement rules.

Call graph: 2 external calls (assert_eq!, ta_with).

fn insert_str_at_clamps_to_char_boundary()

Purpose: Checks that insertion at an invalid byte position inside a multi-byte character is moved to a safe character boundary. This prevents corrupt Unicode text.

Data flow: It creates a TextArea containing a Chinese character, asks to insert at byte position 1, and confirms the insertion happens before the character. The text and cursor are the observed outputs.

Call relations: The test runner calls it. It directly exercises TextArea::new, insert_str_at, and cursor handling for Unicode safety.

Call graph: calls 1 internal fn (new); 1 external calls (assert_eq!).

fn set_text_clamps_cursor_to_char_boundary()

Purpose: Checks that replacing the whole text moves the cursor to a valid boundary when the old cursor position would land inside a new multi-byte character.

Data flow: It starts with ASCII text and a cursor at byte 1, replaces the text with one Chinese character, then inserts another character. The expected final text proves the cursor was clamped safely.

Call relations: The test runner calls it. It verifies set_text_clearing_elements and later insertion work together without Unicode corruption.

Call graph: calls 1 internal fn (new); 1 external calls (assert_eq!).

fn delete_backward_and_forward_edges()

Purpose: Checks basic backspace and delete behavior at normal positions and at the start or end of text. It ensures edge positions are harmless no-ops instead of crashes or wrong edits.

Data flow: It edits a short string, deletes backward and forward, moves the cursor to boundaries, and checks text and cursor after each step. The only output is assertion success or failure.

Call relations: The test runner calls it. It uses ta_with and deletion methods to validate simple character deletion rules.

Call graph: 2 external calls (assert_eq!, ta_with).

fn delete_forward_deletes_element_at_left_edge()

Purpose: Checks that forward delete removes a special embedded element when the cursor is at the element’s start. Embedded elements are treated as one atomic item.

Data flow: It inserts normal text, an element placeholder, and more text, moves the cursor to the element start, deletes forward, and confirms the element text is gone while surrounding text remains. Cursor position is also checked.

Call relations: The test runner calls it. It uses TextArea::new and insert_element to exercise element-aware deletion.

Call graph: calls 1 internal fn (new); 1 external calls (assert_eq!).

fn vim_insert_and_escape()

Purpose: Checks the basic Vim flow of entering insert mode, typing a character, then returning to normal mode with Escape. Vim mode here means an editing style where keys can mean commands instead of literal input.

Data flow: It enables Vim behavior, sends key events for i, h, and Escape, then checks that h was inserted, mode is Normal, and cursor moved to the expected spot. It changes only the test TextArea.

Call relations: The test runner calls it. It drives TextArea::input with key events to verify the Vim state machine.

Call graph: calls 1 internal fn (new); 3 external calls (Char, new, assert_eq!).

fn vim_insert_key_enters_insert_mode()

Purpose: Checks that the Insert key can enter Vim insert mode and allow typing. This supports keyboards or users that use the physical Insert key.

Data flow: It enables Vim mode, sends Insert and then h, and verifies the text contains h and the mode label says Insert. Assertions are the output.

Call relations: The test runner calls it. It exercises TextArea::input and the Vim mode label.

Call graph: calls 1 internal fn (new); 3 external calls (Char, new, assert_eq!).

fn vim_normal_arrow_keys_move_cursor()

Purpose: Checks that arrow keys still move the cursor while Vim is in normal mode. This keeps standard terminal navigation usable even with Vim behavior enabled.

Data flow: It starts with two lines of text, enables Vim mode, sends right, down, left, and up key events, and checks the cursor after each move. The TextArea cursor is the changing state.

Call relations: The test runner calls it. It verifies the normal-mode input path dispatches arrow keys to cursor movement.

Call graph: 3 external calls (new, assert_eq!, ta_with).

fn vim_escape_from_insert_at_start_does_not_underflow()

Purpose: Checks that pressing Escape at the start of text does not move the cursor before zero. This prevents an underflow, where subtracting from zero wraps to a huge number.

Data flow: It enables Vim mode, types one character, presses Escape, and checks mode and cursor. The expected cursor remains safely at 0.

Call relations: The test runner calls it. It targets a boundary case in the Escape-from-insert logic.

Call graph: calls 1 internal fn (new); 3 external calls (Char, new, assert_eq!).

fn vim_escape_from_insert_at_line_start_stays_on_line()

Purpose: Checks that leaving Vim insert mode at the beginning of a line does not jump to the previous line. This matches user expectations around line starts.

Data flow: It places the cursor at the start of the second line, enters insert mode, presses Escape, and checks that cursor stays at that line start. The text is unchanged.

Call relations: The test runner calls it. It exercises TextArea::input with Vim enabled and a newline boundary.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_escape_moves_by_grapheme_boundary()

Purpose: Checks that Escape in Vim mode moves left by one visible character, not by one byte. This is important for emoji and other multi-byte text.

Data flow: It starts with two thumbs-up emoji, puts the cursor at the end, enters insert mode, exits it, and checks the cursor lands before the second emoji. The byte index matches a full emoji boundary.

Call relations: The test runner calls it. It verifies Vim cursor adjustment uses grapheme-aware movement.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_escape_respects_atomic_element_boundary()

Purpose: Checks that leaving insert mode near an embedded element does not put the cursor inside that element. Atomic elements should be skipped like indivisible objects.

Data flow: It inserts text and an element, enables Vim mode, enters and exits insert mode, then checks the cursor sits before the element. The element remains intact.

Call relations: The test runner calls it. It combines insert_element with Vim Escape behavior.

Call graph: calls 1 internal fn (new); 3 external calls (Char, new, assert_eq!).

fn vim_shift_i_enters_insert_at_first_non_blank_with_shift_only_binding()

Purpose: Checks that a configured Shift-I Vim command moves to the first non-space character on the line and enters insert mode. This tests custom key binding behavior.

Data flow: It sets a keymap entry for Shift-I, places the cursor within an indented line, sends uppercase I, and checks mode and cursor. The cursor moves to after the indentation.

Call relations: The test runner calls it. It edits the TextArea Vim keymap and then drives input through that custom binding.

Call graph: 5 external calls (Char, new, assert_eq!, ta_with, vec!).

fn vim_shift_a_enters_insert_at_line_end_with_shift_only_binding()

Purpose: Checks that a configured Shift-A Vim command moves to the end of the current line and enters insert mode. It protects the append-at-line-end command.

Data flow: It sets the append-line-end binding, places the cursor in a line, sends uppercase A, and verifies the cursor is at that line’s end and mode is Insert. The text is unchanged.

Call relations: The test runner calls it. It verifies custom Vim normal-mode key binding dispatch.

Call graph: 5 external calls (Char, new, assert_eq!, ta_with, vec!).

fn vim_shift_c_changes_to_line_end_and_enters_insert_mode()

Purpose: Checks that Shift-C deletes from the cursor to the end of the line, saves the removed text, and enters insert mode. This is the Vim change-to-end-of-line command.

Data flow: It starts in the middle of a line, sends Shift-C, and checks that the tail of the line was removed, the cursor stayed in place, mode became Insert, and the kill buffer holds the deleted text.

Call relations: The test runner calls it. It drives TextArea::input to test Vim command editing and kill-buffer storage.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_uppercase_c_changes_to_line_end()

Purpose: Checks that an uppercase C key event without an explicit Shift modifier also performs Vim change-to-end-of-line. This covers how terminals may report uppercase letters.

Data flow: It sends C, then checks the text was cut at the cursor and Vim mode changed to Insert. The expected cursor remains at the cut point.

Call relations: The test runner calls it. It verifies equivalent input forms reach the same Vim command path.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_s_substitutes_current_character_and_enters_insert_mode()

Purpose: Checks that Vim s deletes the current character and enters insert mode, so the next typed character replaces it. This is the substitute command.

Data flow: It sends s on the middle character of abc, confirms b is removed, then types X and confirms the text becomes aXc. Cursor and mode are checked after each phase.

Call relations: The test runner calls it. It exercises Vim normal command handling followed by insert-mode typing.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_s_on_empty_line_enters_insert_without_deleting_newline()

Purpose: Checks that Vim s on an empty line does not delete the newline. It should simply enter insert mode at that empty line.

Data flow: It positions the cursor on a blank line, sends s, and verifies text is unchanged, cursor stays there, and mode becomes Insert. The newline remains present.

Call relations: The test runner calls it. It targets an empty-line edge case in Vim substitute behavior.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_d_at_line_end_does_not_remove_newline()

Purpose: Checks that Vim D at the end of a line does not remove the newline or store anything. There is no text after the cursor on that line to delete.

Data flow: It places the cursor right before a newline, sends D, and checks text, mode, and kill buffer. Everything remains unchanged except normal-mode processing completes.

Call relations: The test runner calls it. It verifies delete-to-line-end has a safe no-op case.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_c_at_line_end_enters_insert_without_removing_newline()

Purpose: Checks that Vim C at a line end enters insert mode without deleting the newline. This allows changing an empty tail of a line.

Data flow: It places the cursor before a newline, sends C, and verifies text and kill buffer stay unchanged while mode becomes Insert. Cursor remains at the line end.

Call relations: The test runner calls it. It tests the change-to-line-end edge case.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_shift_o_opens_line_above_with_shift_only_binding()

Purpose: Checks that a configured Shift-O Vim command inserts a new blank line above the current line and enters insert mode. This matches Vim’s open-line-above command.

Data flow: It sets the open-line-above binding, positions the cursor in the second line, sends uppercase O, and checks a blank line was inserted before that line. Cursor lands on the new line.

Call relations: The test runner calls it. It verifies custom key binding plus line insertion behavior.

Call graph: 5 external calls (Char, new, assert_eq!, ta_with, vec!).

fn vim_o_opens_line_below_on_inserted_line()

Purpose: Checks that Vim o opens a blank line below the current line, even when the cursor is in the middle of that line. It should enter insert mode on the new line.

Data flow: It starts in one line of a two-line string, sends o, and verifies a blank line appears after the current line. Cursor moves to the start of the inserted line.

Call relations: The test runner calls it. It exercises the Vim open-line-below command.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_o_opens_line_below_final_line_and_moves_to_new_line()

Purpose: Checks that Vim o works on the final line by appending a newline and moving the cursor there. This covers the end-of-text case.

Data flow: It sends o while editing a one-line string and confirms the text ends with a newline, mode is Insert, and cursor is at the new line. The TextArea is modified in place.

Call relations: The test runner calls it. It verifies the final-line branch of open-line-below.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_delete_word()

Purpose: Checks Vim dw, delete word, from the start of a word. It should remove the word plus following space and save that text.

Data flow: It sends d then w at the start of hello world. The text becomes world and the kill buffer becomes hello plus a space.

Call relations: The test runner calls it. It tests Vim operator-pending flow, where d waits for a motion like w.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_change_inner_word_deletes_word_and_enters_insert()

Purpose: Checks Vim ciw, change inner word, deletes the current word and enters insert mode. This supports common Vim text-object editing.

Data flow: It places the cursor on world, sends c, i, w, then verifies world was removed, saved in the kill buffer, and the cursor stayed at the deletion point in Insert mode.

Call relations: The test runner calls it. It exercises a Vim operator followed by a text object.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_word_text_objects_cover_delete_yank_and_big_word()

Purpose: Checks word text objects for yanking, deleting, and big-word behavior. A big word treats punctuation as part of the word until whitespace.

Data flow: First it yanks a word plus following space without changing text. Then it deletes a punctuation-heavy big word. It checks text, kill buffer, and mode.

Call relations: The test runner calls it. It verifies several Vim text-object paths through TextArea::input.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_word_text_objects_accept_cursor_at_word_end()

Purpose: Checks that word text objects still work when the cursor is at the end of a word or at the end of text. This avoids surprising no-ops at boundaries.

Data flow: It performs delete-around-word at the end of hello, then change-inner-big-word at the end of foo bar. It confirms the right text is removed and stored.

Call relations: The test runner calls it. It targets boundary handling in Vim word text-object selection.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_delimiter_text_objects_select_innermost_pair_and_aliases()

Purpose: Checks Vim text objects for paired delimiters such as parentheses and brackets. It should choose the innermost matching pair and support aliases like b for parentheses.

Data flow: It changes inside nested parentheses, then deletes around brackets. After each command sequence it checks the remaining text, kill buffer, and mode.

Call relations: The test runner calls it. It exercises delimiter-finding logic through Vim input commands.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_empty_inner_text_objects_are_valid_targets()

Purpose: Checks that empty text objects, such as inside empty parentheses or quotes, are still valid change targets. They should enter insert mode without deleting anything.

Data flow: It runs change-inside-parentheses on call() and change-inside-quotes on an empty quoted string. In both cases text stays the same, kill buffer is empty, and mode becomes Insert.

Call relations: The test runner calls it. It verifies Vim text-object commands can target zero-length ranges safely.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_quote_text_objects_are_line_local_and_handle_escapes()

Purpose: Checks quote-based Vim text objects with escaped quotes and with quotes split across lines. It ensures escaped quotes do not end the selection and quote matching stays on one line.

Data flow: First it changes inside a quoted string containing escaped quotes and verifies the inner text is removed. Then it tries deleting inside quotes across a newline and verifies nothing changes.

Call relations: The test runner calls it. It drives quote text-object selection through TextArea::input.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_text_object_cancellation_and_unsupported_change_motions_do_not_edit()

Purpose: Checks that unsupported Vim change motions and cancelled text-object commands do not edit text. This prevents partial command sequences from damaging input.

Data flow: It sends c then an unsupported motion and checks text and kill buffer are unchanged. Then it starts a d i sequence, presses Escape, and checks the pending operator is cleared.

Call relations: The test runner calls it. It verifies the Vim command state machine cancels safely.

Call graph: 5 external calls (Char, new, assert!, assert_eq!, ta_with).

fn vim_operator_invalid_motion_is_consumed()

Purpose: Checks that an invalid motion after a Vim operator is consumed and clears the pending command. The invalid key should not be inserted or leave the editor stuck.

Data flow: It sends d to start delete, confirms an operator is pending, then sends z and checks text, cursor, mode, and pending state are unchanged or reset. No deletion happens.

Call relations: The test runner calls it. It tests Vim operator-pending error handling.

Call graph: 5 external calls (Char, new, assert!, assert_eq!, ta_with).

fn vim_e_lands_on_word_end_character()

Purpose: Checks that Vim e moves to the last character of the current word, not after it. This matters because later commands act on the character under the cursor.

Data flow: It sends e from the start of abc, confirms cursor lands on c, then sends x and confirms c is deleted and stored. The final text is ab.

Call relations: The test runner calls it. It connects motion behavior with a following Vim delete-character command.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_e_advances_from_each_word_end()

Purpose: Checks repeated Vim e movement across several word endings. It captures the cursor positions as a snapshot for easier regression detection.

Data flow: It starts near the end of alpha, sends e three times, and records the text plus a caret line showing cursor position after each move. The snapshot assertion is the expected output.

Call relations: The test runner calls it. It uses TextArea::input and insta snapshot testing to verify motion over multiple words.

Call graph: 6 external calls (Char, new, new, format!, assert_snapshot!, ta_with).

fn vim_delete_to_word_end_advances_from_existing_word_end()

Purpose: Checks that d e from an existing word end deletes through the next word end rather than doing nothing. This matches Vim’s forward motion behavior.

Data flow: It starts near the end of alpha, sends d then e, and verifies the removed text spans a beta segment while the remaining text joins correctly. The kill buffer records the deleted range.

Call relations: The test runner calls it. It tests the combination of Vim delete operator and e motion.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_e_from_word_end_can_land_on_trailing_space()

Purpose: Checks that Vim e can move into trailing spaces when there is no later word. This covers the end-of-line whitespace case.

Data flow: It starts near the end of alpha followed by spaces, sends e, and checks the cursor lands in the trailing space area. Text is unchanged.

Call relations: The test runner calls it. It exercises a whitespace edge case in Vim word-end motion.

Call graph: 4 external calls (Char, new, assert_eq!, ta_with).

fn vim_e_advances_across_atomic_element_word_ends()

Purpose: Checks that Vim e treats embedded elements as atomic word-like units when moving across text. It should land at the element boundary, then continue to the next word.

Data flow: It builds text with alpha, an element, and gamma, starts near alpha’s end, sends e twice, and checks cursor positions. The first stop is the element start, the second is near the end of gamma.

Call relations: The test runner calls it. It combines insert_element with Vim word-end motion.

Call graph: calls 1 internal fn (new); 3 external calls (Char, new, assert_eq!).

fn vim_dollar_lands_on_line_end_character()

Purpose: Checks that Vim $ lands on the final character of the current line. A following x should delete that character, not the newline.

Data flow: It sends $ from inside abc, checks cursor is on c, then sends x and confirms c is removed while the newline and next line remain. The kill buffer stores c.

Call relations: The test runner calls it. It verifies line-end motion and delete-character behavior.