diff --git a/crates/maestro-tui/src/app.rs b/crates/maestro-tui/src/app.rs index 6ba960c..15fadd2 100644 --- a/crates/maestro-tui/src/app.rs +++ b/crates/maestro-tui/src/app.rs @@ -112,8 +112,6 @@ pub enum Effect { /// Fast-forward spawn (#67): resolve every default from the daemon and /// spawn with no form; unresolvable defaults open a pre-filled form. FastForward, - /// A reroll drained the form's local name batch (#64). - RefillNames, /// The form's target changed: probe `/api/gitroot` so the worktree /// section knows its base repo (#65). `seq` guards stale answers. ProbeGitRoot { @@ -301,7 +299,6 @@ impl App { Effect::Kill(id) => self.submit_kill(id).await, Effect::LoadDraft => self.spawn_load_draft(), Effect::FastForward => self.spawn_fast_forward(), - Effect::RefillNames => self.spawn_refill_names(), Effect::ProbeGitRoot { seq, path } => self.spawn_probe_git_root(seq, path), Effect::LoadBranches => self.spawn_load_branches(), Effect::Rename { id, name } => self.submit_rename(id, &name).await, @@ -649,9 +646,6 @@ impl App { Err(e) => draft.error = Some(e.to_string()), } } - if draft.take_name_refill() { - effects.push(Effect::RefillNames); - } if let Some((seq, path)) = draft.take_gitroot_probe(std::time::Instant::now()) { effects.push(Effect::ProbeGitRoot { seq, path }); } @@ -696,17 +690,6 @@ impl App { }); } - fn spawn_refill_names(&self) { - let Some(draft) = self.draft_id() else { - return; - }; - let (_, http, base, tx) = self.loader_handles(); - tokio::spawn(async move { - let names = fetch_names(&http, &base, crate::draft::NAME_BATCH_SIZE).await; - let _ = tx.send(DraftUpdate::Names { draft, names }); - }); - } - fn spawn_probe_git_root(&self, seq: u32, path: PathBuf) { let Some(draft) = self.draft_id() else { return; @@ -774,7 +757,6 @@ impl App { } let want = match &update { DraftUpdate::Data { draft, .. } - | DraftUpdate::Names { draft, .. } | DraftUpdate::GitRoot { draft, .. } | DraftUpdate::Branches { draft, .. } => *draft, // Handled above; it targets no particular draft. @@ -806,11 +788,6 @@ impl App { draft.seed_names(names); } } - DraftUpdate::Names { names, .. } => { - if !names.is_empty() { - draft.extend_names(names); - } - } DraftUpdate::GitRoot { seq, root, .. } => { draft.resolve_gitroot(seq, root); follow_up_branches = draft.take_branch_load().is_some(); @@ -1147,10 +1124,6 @@ enum DraftUpdate { projects: Option>, names: Vec, }, - Names { - draft: u64, - names: Vec, - }, GitRoot { draft: u64, seq: u32, @@ -1639,7 +1612,8 @@ mod tests { let req = &posts[0]; assert_eq!(req["cwd"], json!("/repos/fresh")); assert_eq!(req["command"], json!("aider")); - assert_eq!(req["metadata"]["name"], json!("crimson-otter")); + // #131: the fast path names no session; the daemon does. + assert_eq!(req["metadata"], json!({})); assert_eq!(req["worktree"]["base_repo"], json!("/repos/fresh")); assert_eq!(req["worktree"]["branch"], json!("crimson-otter")); assert_eq!(req["worktree"]["create_branch"], json!(true)); @@ -1691,9 +1665,10 @@ mod tests { "the fallback is the spawn modal" ); let draft = app.draft.as_ref().expect("a form behind the modal"); - // Whatever did resolve (nothing project-side) is seeded; the - // generated name still lands so the form is ready to go. - assert_eq!(draft.name.value(), "amber-falcon"); + // Whatever did resolve (nothing project-side) is seeded. The name + // field stays empty (#131); the handle seeds the branch instead. + assert_eq!(draft.name.value(), ""); + assert_eq!(draft.branch.value(), "amber-falcon"); assert_eq!(draft.command(), "claude"); } @@ -1893,7 +1868,7 @@ mod tests { /// built-ins, projects land sorted, and the first generated name seeds /// the field. #[tokio::test] - async fn load_draft_data_fills_presets_projects_and_names() { + async fn load_draft_data_fills_presets_projects_and_the_branch_handle() { use axum::routing::get; use axum::Json; use serde_json::json; @@ -1946,7 +1921,12 @@ mod tests { assert_eq!(draft.groups.len(), 1); assert_eq!(draft.groups[0].main.name, "maestro"); assert_eq!(draft.home_dir, "/home/u"); - assert_eq!(draft.name.value(), "crimson-otter"); + assert_eq!( + draft.name.value(), + "", + "the operator names it, or nobody does" + ); + assert_eq!(draft.branch.value(), "crimson-otter"); } /// Keys fed while the form is not up must be ignored, not panic. diff --git a/crates/maestro-tui/src/draft.rs b/crates/maestro-tui/src/draft.rs index c9077b4..eb2d869 100644 --- a/crates/maestro-tui/src/draft.rs +++ b/crates/maestro-tui/src/draft.rs @@ -10,7 +10,7 @@ //! entry), a two-step project/worktree picker (#96, mirroring the web //! redesign in #95) fed by [`crate::projects`] over `/api/projects` plus an //! `Other directory…` escape hatch, a generated session name from -//! `/api/names` with a reroll key, and validation that reports which field is +//! `/api/names` for the branch default, and validation that reports which field is //! missing instead of posting an empty request. A worktree section (#65) //! mirrors `web/src/spawnForm.ts`: on by default over a git repository, //! branch tracking the generated name until touched, with a new-or-existing @@ -36,7 +36,6 @@ //! 7. Neither step touches the command: the directory and what runs in it //! are independent choices. -use std::collections::VecDeque; use std::path::{Path, PathBuf}; use std::time::{Duration, Instant}; @@ -53,10 +52,13 @@ use ratatui::Frame; use crate::input::InputKey; use crate::projects; -/// How many generated names one `/api/names` refill fetches. Rerolls consume -/// the local batch so they stay instant; the daemon is hit only when it runs -/// dry. -pub const NAME_BATCH_SIZE: usize = 20; +/// Shown in place of an empty name field: what happens if the operator types +/// nothing (#131). +pub const NAME_HINT: &str = "named after your first prompt"; + +/// How many handles one `/api/names` fetch asks for. One is enough: the name +/// field starts empty (#131) and the handle only seeds the worktree branch. +pub const NAME_BATCH_SIZE: usize = 1; /// Quiet period after raw-path typing before a `/api/gitroot` probe fires /// (#74). Every keystroke resets it, so a burst issues one request once the @@ -234,11 +236,10 @@ pub struct DraftPane { /// `selected_group_key` is `None`. pub worktree_choice: WorktreeChoice, pub name: crate::text_input::TextInput, - pub name_queue: VecDeque, - /// Set once the operator types or rerolls a name; guards refills against + /// Set once the operator types a name; a fetched handle then seeds only + /// the branch, never the field. Guards a late fetch against /// clobbering it, exactly like the web form's `nameTouched`. pub name_touched: bool, - needs_name_refill: bool, /// Worktree on for this spawn (#65). Defaults on; a failed gitroot probe /// unticks it, like the web form. pub worktree_enabled: bool, @@ -302,9 +303,7 @@ impl Default for DraftPane { selected_group_key: None, worktree_choice: WorktreeChoice::New, name: crate::text_input::TextInput::default(), - name_queue: VecDeque::new(), name_touched: false, - needs_name_refill: false, worktree_enabled: true, advanced_collapsed: true, base_repo: None, @@ -388,30 +387,23 @@ impl DraftPane { self.select_group(&group); } - /// Fill the local name batch from `GET /api/names`, seeding the field - /// itself unless the operator already typed one. - pub fn seed_names(&mut self, names: Vec) { - self.name_queue.extend(names); - if !self.name_touched && self.name.value().trim().is_empty() { - if let Some(first) = self.name_queue.pop_front() { - self.set_name(first); - } - } - } - - /// Append a refill batch; the first name replaces the field (this only - /// happens after an explicit reroll on an empty batch). + /// Seed the worktree branch from a `GET /api/names` handle (#131). /// - /// The shown name is *consumed*, not left at the head — queueing it too - /// made the next reroll produce the same name and the key look dead - /// (#67 review). - pub fn extend_names(&mut self, mut names: Vec) { - if names.is_empty() { + /// The name field is deliberately left alone: a session the operator does + /// not name is named by the daemon — a provisional handle at spawn, + /// replaced by one derived from the first prompt. The branch still needs + /// a default, and the name field no longer supplies one. + pub fn seed_names(&mut self, names: Vec) { + let Some(handle) = names.into_iter().next() else { + return; + }; + if self.branch_edited + || self.branch_mode != WorktreeBranchMode::New + || !self.branch.value().trim().is_empty() + { return; } - let first = names.remove(0); - self.set_name(first); - self.name_queue.extend(names); + self.branch = crate::text_input::TextInput::with_value(handle); } pub fn set_name(&mut self, name: impl Into) { @@ -421,27 +413,18 @@ impl DraftPane { /// The new-branch field mirrors the session name until the operator types /// their own branch — and only in `New` mode, like the web form. + /// + /// A cleared name leaves the branch on its last value (#131): the branch + /// still has to be something, while the session name no longer does. fn sync_branch_to_name(&mut self) { - if !self.branch_edited && self.branch_mode == WorktreeBranchMode::New { + if !self.branch_edited + && self.branch_mode == WorktreeBranchMode::New + && !self.name.value().is_empty() + { self.branch = crate::text_input::TextInput::with_value(self.name.value().to_string()); } } - /// Reroll the generated name. Pulls from the local batch; when it has run - /// dry, flags the caller to fetch a new one via [`Self::take_name_refill`]. - pub fn reroll(&mut self) { - self.name_touched = true; - match self.name_queue.pop_front() { - Some(next) => self.set_name(next), - None => self.needs_name_refill = true, - } - } - - /// Consume the reroll-needs-a-new-batch flag raised by [`Self::reroll`]. - pub fn take_name_refill(&mut self) -> bool { - std::mem::take(&mut self.needs_name_refill) - } - // -- worktree (#65) ----------------------------------------------------- /// Whether the branch controls are shown: the toggle alone appears until @@ -1070,12 +1053,6 @@ impl DraftPane { self.move_branch_selection(1); DraftInputResult::Consumed } - InputKey::Char { - c: 'r', ctrl: true, .. - } if self.focused_field == DraftField::Name => { - self.reroll(); - DraftInputResult::Consumed - } other => { match self.focused_field { DraftField::Preset | DraftField::Submit => {} @@ -1310,28 +1287,30 @@ impl DraftPane { } } - // -- name + reroll --------------------------------------------------------- + // -- name ----------------------------------------------------------------- let name_row = next_row(); draw_gutter(f, name_row, "name:"); let col = draw_text_field(f, &self.name, name_row, field_style(DraftField::Name)); if self.focused_field == DraftField::Name { cursor = Some((col, name_row.y)); } - // Dim reroll hint, tucked after the typed name without covering it. - let hint_offset = (GUTTER as u16 + self.name.value().chars().count() as u16 + 1) - .min(name_row.width.saturating_sub(10)); - f.render_widget( - Paragraph::new(Line::from(Span::styled( - "^R reroll", - Style::default().add_modifier(Modifier::DIM), - ))), - Rect { - x: name_row.x + hint_offset, - y: name_row.y, - width: name_row.width.saturating_sub(hint_offset), - height: 1, - }, - ); + // An empty field is not a missing value (#131): the daemon names the + // session, so the row says so rather than looking unfinished. + if self.name.value().is_empty() { + let hint_offset = (GUTTER as u16 + 1).min(name_row.width.saturating_sub(10)); + f.render_widget( + Paragraph::new(Line::from(Span::styled( + NAME_HINT, + Style::default().add_modifier(Modifier::DIM), + ))), + Rect { + x: name_row.x + hint_offset, + y: name_row.y, + width: name_row.width.saturating_sub(hint_offset), + height: 1, + }, + ); + } // -- advanced disclosure (#93) ------------------------------------------ let advanced_row = next_row(); @@ -2051,15 +2030,37 @@ mod tests { assert_eq!(draft.cwd_raw.value(), "/repos/picked"); } + /// #131: the field stays empty and the request carries no name — the + /// daemon names the session. The fetched handle only seeds the branch. #[test] - fn generated_names_seed_the_field_and_metadata() { + fn a_fetched_handle_seeds_the_branch_and_leaves_the_name_empty() { let mut draft = DraftPane::default(); + assert!(draft.name.value().is_empty()); + + draft.seed_names(vec!["crimson-otter".into()]); assert!( draft.name.value().is_empty(), - "no name until /api/names lands" + "the name field is the operator's" ); - draft.seed_names(vec!["crimson-otter".into(), "amber-falcon".into()]); - assert_eq!(draft.name.value(), "crimson-otter"); + assert_eq!(draft.branch.value(), "crimson-otter"); + + draft.picked_cwd = Some(PathBuf::from("/w")); + draft.base_repo = Some(PathBuf::from("/w")); + draft.probed_cwd = Some(PathBuf::from("/w")); + let req = draft.build_request().unwrap(); + assert!( + !req.metadata.contains_key("name"), + "an unnamed spawn sends no name" + ); + } + + /// A name the operator types still rides along, and still seeds the + /// branch (#131). + #[test] + fn a_typed_name_rides_along_and_seeds_the_branch() { + let mut draft = DraftPane::default(); + typed_name(&mut draft, "my-session"); + assert_eq!(draft.branch.value(), "my-session"); draft.picked_cwd = Some(PathBuf::from("/w")); draft.base_repo = Some(PathBuf::from("/w")); @@ -2067,36 +2068,19 @@ mod tests { let req = draft.build_request().unwrap(); assert_eq!( req.metadata.get("name").and_then(|v| v.as_str()), - Some("crimson-otter"), - "name rides along as metadata.name" + Some("my-session") ); - - draft.reroll(); - assert_eq!( - draft.name.value(), - "amber-falcon", - "reroll consumes the batch" - ); - draft.reroll(); - assert!( - draft.take_name_refill(), - "dry batch flags the caller to refetch" - ); - assert!(!draft.take_name_refill(), "flag consumes"); } + /// A handle arriving after the operator typed a name never overwrites it, + /// nor the branch it seeded (#131). #[test] - fn refills_do_not_clobber_a_name_the_operator_typed() { + fn a_late_handle_never_clobbers_what_was_typed() { let mut draft = DraftPane::default(); - draft.seed_names(vec!["seeded".into()]); - typed_name(&mut draft, "-mine"); - assert_eq!(draft.name.value(), "seeded-mine"); - draft.seed_names(vec!["late-batch".into()]); - assert_eq!( - draft.name.value(), - "seeded-mine", - "late initial batches never overwrite an edited name" - ); + typed_name(&mut draft, "mine"); + draft.seed_names(vec!["late-handle".into()]); + assert_eq!(draft.name.value(), "mine"); + assert_eq!(draft.branch.value(), "mine"); } fn typed_name(draft: &mut DraftPane, s: &str) { @@ -2147,7 +2131,7 @@ mod tests { } #[test] - fn render_shows_every_field_group_and_the_reroll_hint() { + fn render_shows_every_field_group_and_the_naming_hint() { let mut draft = DraftPane { home_dir: "/home/u".into(), ..DraftPane::default() @@ -2165,7 +2149,7 @@ mod tests { "[Custom…]", "dir:", "name:", - "^R reroll", + NAME_HINT, "maestro", "[ Spawn ]", ] { @@ -2453,18 +2437,24 @@ mod tests { #[test] fn the_new_branch_tracks_the_session_name_until_touched() { let mut draft = DraftPane::default(); - draft.seed_names(vec!["crimson-otter".into(), "amber-falcon".into()]); + draft.seed_names(vec!["crimson-otter".into()]); assert_eq!(draft.branch.value(), "crimson-otter"); - draft.reroll(); - assert_eq!(draft.branch.value(), "amber-falcon", "rerolls carry over"); + + draft.focused_field = DraftField::Name; + typed(&mut draft, "renamed"); + assert_eq!( + draft.branch.value(), + "renamed", + "the branch tracks the name" + ); draft.focused_field = DraftField::BranchNew; typed(&mut draft, "-mine"); - assert_eq!(draft.branch.value(), "amber-falcon-mine"); - draft.seed_names(vec!["late-batch".into()]); + assert_eq!(draft.branch.value(), "renamed-mine"); + draft.seed_names(vec!["late-handle".into()]); assert_eq!( draft.branch.value(), - "amber-falcon-mine", + "renamed-mine", "an edited branch stops tracking the name" ); } diff --git a/crates/maestro-tui/src/fast_forward.rs b/crates/maestro-tui/src/fast_forward.rs index b799b55..f8df0d0 100644 --- a/crates/maestro-tui/src/fast_forward.rs +++ b/crates/maestro-tui/src/fast_forward.rs @@ -2,11 +2,13 @@ //! //! The defaults mirror what the spawn form would settle on after the operator //! picked the most recent project and kept their hands off everything else: -//! its last command (or the first non-custom preset), a freshly generated -//! name, and a worktree with a branch named after that name. Any default -//! that cannot be resolved — no projects yet, no command, no generated -//! name — downgrades the keystroke to the spawn form pre-filled with whatever -//! did resolve ([`FastForwardDefaults::apply_to_draft`]). +//! its last command (or the first non-custom preset), and a worktree on a new +//! branch named after a generated handle. The session itself is left unnamed +//! (#131) — the daemon gives it a provisional handle at spawn and names it +//! after its first prompt. Any default that cannot be resolved — no projects +//! yet, no command, no handle — downgrades the keystroke to the spawn form +//! pre-filled with whatever did resolve +//! ([`FastForwardDefaults::apply_to_draft`]). use std::path::PathBuf; @@ -21,16 +23,18 @@ use crate::draft::DraftPane; pub struct FastForwardDefaults { pub project: Option, pub command: Option, - pub name: Option, + /// A generated handle for the worktree branch (#131). Not a session name: + /// the fast path names no session. + pub handle: Option, } -/// Resolve the fast-forward defaults from the daemon's answers. `name` is +/// Resolve the fast-forward defaults from the daemon's answers. `handle` is /// `None` when `/api/names` yielded nothing; `presets` may be empty (the /// caller falls back to the built-ins it already has). pub fn resolve( projects: &[Project], presets: &[SpawnPreset], - name: Option, + handle: Option, now: DateTime, ) -> FastForwardDefaults { let project = crate::projects::sort_projects(projects.to_vec(), now) @@ -49,37 +53,35 @@ pub fn resolve( FastForwardDefaults { project, command, - name, + handle, } } impl FastForwardDefaults { - /// The spawn request when *every* default resolved: worktree on, new - /// branch named after the generated session name, base repo from the - /// scan (`None` means the project is itself a main checkout). + /// The spawn request when *every* default resolved: worktree on, a new + /// branch named after the generated handle, base repo from the scan + /// (`None` means the project is itself a main checkout). + /// + /// The request carries no name (#131): the daemon assigns a provisional + /// one and replaces it once the session sees a prompt. pub fn build_request(&self) -> Option { let project = self.project.as_ref()?; let command = self.command.as_deref()?.trim(); - let name = self.name.as_deref()?; - if command.is_empty() || name.is_empty() { + let handle = self.handle.as_deref()?; + if command.is_empty() || handle.is_empty() { return None; } - let mut metadata = std::collections::HashMap::new(); - metadata.insert( - "name".to_string(), - serde_json::Value::String(name.to_string()), - ); Some(CreateSessionRequest { cwd: project.path.clone(), command: command.to_string(), env: Default::default(), - metadata, + metadata: Default::default(), worktree: Some(WorktreeSpec { base_repo: project .base_repo .clone() .unwrap_or_else(|| project.path.clone()), - branch: name.to_string(), + branch: handle.to_string(), create_branch: true, }), }) @@ -109,10 +111,10 @@ impl FastForwardDefaults { draft.custom_command = crate::text_input::TextInput::with_value(command); } } - if let Some(name) = &self.name { - draft.set_name(name.clone()); - // Seeded, not generated: a later refill must not clobber it. - draft.name_touched = true; + if let Some(handle) = &self.handle { + // The branch, not the name: the form's name field stays empty so + // the session is named after its first prompt (#131). + draft.seed_names(vec![handle.clone()]); } } } @@ -161,19 +163,17 @@ mod tests { PathBuf::from("/repos/fresh") ); assert_eq!(r.command.as_deref(), Some("claude")); - assert_eq!(r.name.as_deref(), Some("amber-falcon")); + assert_eq!(r.handle.as_deref(), Some("amber-falcon")); let req = r.build_request().expect("all defaults resolved"); assert_eq!(req.cwd, PathBuf::from("/repos/fresh")); assert_eq!(req.command, "claude"); - assert_eq!( - req.metadata.get("name").and_then(|v| v.as_str()), - Some("amber-falcon") - ); + // #131: the fast path names no session — the daemon does. + assert!(req.metadata.is_empty()); let wt = req.worktree.expect("worktree on"); assert_eq!(wt.base_repo, PathBuf::from("/repos/fresh")); assert_eq!(wt.branch, "amber-falcon"); - assert!(wt.create_branch, "fresh branch named after the session"); + assert!(wt.create_branch, "fresh branch named after the handle"); } #[test] @@ -243,31 +243,36 @@ mod tests { assert!(draft.worktree_enabled); } + /// The handle seeds the branch, never the name: a downgraded fast-forward + /// opens a form the operator can still leave unnamed (#131). #[test] - fn a_resolved_name_survives_late_refills_and_tracks_the_branch() { + fn a_resolved_handle_seeds_the_branch_only() { let projects = vec![project("/repos/p", 0, Some("claude"))]; - let named = resolve( + let resolved = resolve( &projects, &[preset("claude", "claude")], Some("amber-falcon".into()), Utc::now(), ); let mut draft = DraftPane::default(); - named.apply_to_draft(&mut draft); - // A later batch must not overwrite the name the spawn was seeded with. - draft.seed_names(vec!["late-name".into()]); - assert_eq!(draft.name.value(), "amber-falcon"); + resolved.apply_to_draft(&mut draft); + assert!(draft.name.value().is_empty()); + assert_eq!(draft.branch.value(), "amber-falcon"); + + // A later handle finds the branch already seeded and leaves it. + draft.seed_names(vec!["late-handle".into()]); assert_eq!(draft.branch.value(), "amber-falcon"); } #[test] - fn an_unresolved_name_still_gets_generated_by_a_later_batch() { + fn an_unresolved_handle_still_arrives_from_a_later_batch() { let projects = vec![project("/repos/p", 0, Some("claude"))]; let r = resolve(&projects, &[preset("claude", "claude")], None, Utc::now()); let mut draft = DraftPane::default(); r.apply_to_draft(&mut draft); - draft.seed_names(vec!["late-name".into()]); - assert_eq!(draft.name.value(), "late-name"); + draft.seed_names(vec!["late-handle".into()]); + assert_eq!(draft.branch.value(), "late-handle"); + assert!(draft.name.value().is_empty()); } #[test] diff --git a/crates/maestro-tui/src/sidebar.rs b/crates/maestro-tui/src/sidebar.rs index 1dc702f..6689ae2 100644 --- a/crates/maestro-tui/src/sidebar.rs +++ b/crates/maestro-tui/src/sidebar.rs @@ -251,10 +251,23 @@ impl Sidebar { ), Span::styled(format!("{glyph} "), base), ]; + // #131: a name the daemon generated is provisional — the session's + // first prompt may replace it — so it reads muted, like the meta line, + // rather than as a name someone chose. See docs/SIDEBAR.md. + let name_style = if maestro_protocol::display::is_provisional_name(s) { + base.patch( + palette::active() + .surface(highlighted && focused) + .muted_style() + .bg(base.bg.unwrap_or(palette::active().chrome_bg)), + ) + } else { + base + }; spans.extend( fit_to_width(vec![Span::raw(name_for(s))], name_budget) .into_iter() - .map(|sp| Span::styled(sp.content, base.patch(sp.style))), + .map(|sp| Span::styled(sp.content, name_style.patch(sp.style))), ); pad_to_width(spans, width, base) } @@ -696,6 +709,39 @@ mod tests { } } + /// #131: a generated handle renders muted, a settled name in the card's + /// own foreground — the same distinction the web sidebar draws. + #[test] + fn a_generated_name_renders_muted_until_it_settles() { + let mut generated = session_named(1, "amber"); + generated.metadata.insert( + maestro_protocol::NAME_SOURCE_KEY.into(), + serde_json::Value::String("Generated".into()), + ); + let mut settled = session_named(2, "falcon"); + settled.metadata.insert( + maestro_protocol::NAME_SOURCE_KEY.into(), + serde_json::Value::String("Haiku".into()), + ); + let sb = Sidebar { + sessions: vec![generated, settled], + highlight: None, + attached: Default::default(), + }; + let buf = draw(&sb, 44, 8); + let palette = palette::active(); + let surface = palette.surface(false); + let colour_of = |needle: char| { + (0..buf.area.height) + .flat_map(|y| (0..buf.area.width).map(move |x| (x, y))) + .find(|&(x, y)| buf[(x, y)].symbol() == needle.to_string()) + .map(|(x, y)| buf[(x, y)].fg) + .expect("name must be drawn") + }; + assert_eq!(colour_of('a'), surface.muted, "the generated handle"); + assert_ne!(colour_of('f'), surface.muted, "the settled name"); + } + /// The additions and deletions are the only coloured fragments: they are /// what a reader scans for, and colouring the rest would make the line /// compete with the activity rail.