Decompose render: toasts and resource indicator as isolated View<T>

[MasonRhodesDev]

Context

Render architecture audit from #203. Both the toast layer and the resource indicator are high-frequency but completely self-contained UI sections that currently live as inline helpers on AnotherOneApp. Because they share the parent's render lifecycle, any unrelated state change causes them to re-render unnecessarily.

Toast layer

Fields today on AnotherOneApp: toasts, next_toast_id, toast_drag, copied_toast, pasted_image_preview.

Zero dependencies on any other app state. During toast animations the render tick runs at 16ms — this currently re-renders the entire app. As View<ToastController> only the toast layer repaints during animations.

Resource indicator

Fields today on AnotherOneApp: resource_indicator_open, last_resource_usage_refresh, resource_collapsed_nodes. Reads registry_state for usage data.

3 fields, all specific to this panel. Updates at 1–5s cadence.

What to do

1. Extract toast fields into struct ToastController implementing Render. Store as Entity<ToastController> on app. Pass toast mutations via the existing app-action pattern or a small dedicated channel.
2. Extract resource indicator fields into struct ResourcePanel implementing Render. Store as Entity<ResourcePanel> on app. Push a ResourceSnapshot from the drain tick when usage data changes.
3. Neither requires a snapshot design — both have fully local state with no project_store dependency.

[MasonRhodesDev]

Implementation plan

Toast fields on AnotherOneApp (exact types)

toasts: Vec<AppToast>,
next_toast_id: u64,
toast_drag: Option<ToastDrag>,
copied_toast: Option<(u64, Instant)>,
pasted_image_preview: Option<PastedImagePreview>,

Zero dependencies on project_store or any other app subsystem. All interactions are self-contained &mut Self calls.

Resource indicator fields (exact types)

resource_indicator_open: bool,
resource_collapsed_nodes: HashSet<String>,
last_resource_usage_refresh: Instant,

Render data comes from project_store.ui.daemon_resource_usage: Option<ResourceUsageSnapshot> — pushed in by the normal absorb_projection path. Three fields, no broad coupling.

Proposed structures

// app/src/toast_controller.rs (new file)
pub(crate) struct ToastController {
    app: WeakEntity<AnotherOneApp>,
    toasts: Vec<AppToast>,
    next_toast_id: u64,
    toast_drag: Option<ToastDrag>,
    copied_toast: Option<(u64, Instant)>,
    pasted_image_preview: Option<PastedImagePreview>,
}
impl Render for ToastController { … }

// app/src/resource_indicator.rs (new struct, replaces impl AnotherOneApp block)
pub(crate) struct ResourcePanel {
    app: WeakEntity<AnotherOneApp>,
    open: bool,
    collapsed_nodes: HashSet<String>,
    last_refresh: Instant,
    snapshot: Option<ResourceUsageSnapshot>,
    theme_mode: ThemeMode,
}
impl Render for ResourcePanel { … }

Both follow the RightSidebarPanel pattern: WeakEntity<AnotherOneApp> for callbacks, snapshot pushed from the parent via cx.defer.

Plan A — ToastController (independent PR)

Step 1 — Move types to toast_controller.rs
Move AppToast, ToastDrag, PastedImagePreview, ToastKind, all constants (TOAST_STACK_LIMIT, animation intervals, etc.) to the new file. pub(crate) use from app.rs.

Step 2 — Define struct + Render
Move tick_toasts, tick_pasted_image_preview, push_toast, dismiss_by_id, on_mouse_down, update_drag, finish_drag, toast_card, toast_animation_state, toast_layer and all helpers into impl ToastController.

Step 3 — Wire into AnotherOneApp

• Remove the five fields; add toast_controller: Entity<ToastController>
• show_*_toast methods on AnotherOneApp become thin forwarding wrappers: self.toast_controller.update(cx, |ctrl, cx| ctrl.push*(…, cx))
• Render timer delegates tick_toasts + tick_pasted_image_preview to the controller
• refresh_timer_interval() reads self.toast_controller.read(cx).has_active_animation() instead of the raw fields
• Replace the three self.toast_layer(cx) call sites with self.toast_controller.clone() as an AnyView child

Step 4 — Move tests
The existing toast_visuals_follow_*_theme_colors, toast_copy_message_*, toast_visible_message_* tests move into toast_controller.rs.

Net: ~−660 lines from app.rs, ~+680 in toast_controller.rs.

Plan B — ResourcePanel (independent PR)

Step 1 — Snapshot push
In apply_latest_project_list_projection, after absorb_projection:

let usage = self.project_store.ui.daemon_resource_usage.clone();
let mode = self.project_store.ui.theme_mode;
let panel = self.resource_panel.clone();
cx.defer(move |cx| {
    panel.update(cx, |p, cx| { p.snapshot = usage; p.theme_mode = mode; cx.notify(); });
});

Step 2 — Define struct + Render
Move resource_indicator_button, resource_indicator_overlay, resource_indicator_panel, resource_project_group, resource_task_group, resource_group_row, resource_session_row, resource_stat_card, resource_section_heading, resource_metrics, normalize_cpu into impl ResourcePanel.

Toggle/refresh handlers call back to the parent only for refresh_resource_usage (which needs registry_state + terminal_manager that stay on AnotherOneApp):

self.app.update(cx, |app, _cx| app.refresh_resource_usage())

Step 3 — Wire into AnotherOneApp

• Remove three fields; add resource_panel: Entity<ResourcePanel>
• Render timer delegates tick_resource_usage to the panel
• refresh_timer_interval() reads self.resource_panel.read(cx).open
• Replace render call sites with self.resource_panel.clone() as AnyView child

Net: ~−700 lines from app.rs, ~+720 in resource_indicator.rs.

Risks

R1 — Timer interval read after update (medium)
refresh_timer_interval() reads toast_controller/resource_panel state to pick 16 ms vs 250 ms. Must call .read(cx).has_active_animation() after all .update() calls in the same tick to avoid a double-lease panic. Expose the predicate as a dedicated pub(crate) fn — do not read individual fields from outside the entity.

R2 — pasted_image_preview asset teardown (low-medium)
clear_pasted_image_preview calls image.remove_asset(cx) where cx: &mut App. Context<ToastController> derefs to App, so this should work inside ToastController::tick. Verify compiles — if remove_asset requires exactly &mut App (not a deref), wrap in cx.defer back to the parent.

R3 — ResourcePanel needs registry_state for sampling (low)
Only the refresh_resource_usage sampling step (called on toggle + tick) needs registry_state/terminal_manager. Keep that method on AnotherOneApp; the panel calls back via WeakEntity::update. No data duplication needed.

R4 — Snapshot push double-lease (low)
Never call toast_controller.update or resource_panel.update from inside AnotherOneApp::render. Only call from the render timer closure or event handlers. Follow the cx.defer pattern for snapshot pushes.

Acceptance criteria

ToastController

• app.rs no longer holds toasts, next_toast_id, toast_drag, copied_toast, pasted_image_preview
• All ~135 show_*_toast call sites across the codebase compile unchanged (public API preserved)
• Toast display, fade-in/out, swipe-dismiss, copy-to-clipboard, pasted-image-preview work identically
• All existing toast unit tests pass
• app.rs shrinks by ≥ 550 lines

ResourcePanel

• app.rs no longer holds resource_indicator_open, resource_collapsed_nodes, last_resource_usage_refresh
• Toggle, refresh button, node collapse/expand all work
• 1 s / 5 s open/closed sampling cadence preserved
• app.rs shrinks by ≥ 70 additional lines; resource_indicator.rs is self-contained

Estimated scope

The two plans are fully independent and can be PRed in any order. ToastController is the larger of the two (more methods, more tests to move) but also the highest payoff — toast animation ticks at 16 ms are the most frequent re-render trigger during normal use.