Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add session output token sparklines
Raine Virta60fd22b8403f
diff --git a/src/monitor.rs b/src/monitor.rsindex 7d9a941..57bb24a 100644--- a/src/monitor.rs+++ b/src/monitor.rs@@ -10,6 +10,7 @@ mod mock;pub use mock::{MockMonitor, mock_state};const DEFAULT_RECENT_LIMIT: usize = 200;+pub const SESSION_TOKEN_BUCKET_SECS: u64 = 10;#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum EndpointKind {@@ -235,6 +236,7 @@ pub struct SessionSummary {pub last_seen: SystemTime,pub input_tokens: u64,pub output_tokens: u64,+ pub output_token_samples: Vec<(SystemTime, u64)>,rate_output_tokens: u64,pub generation_duration: Duration,pub last_status: String,@@ -262,6 +264,7 @@ struct MonitorStore {started_at: SystemTime,active: HashMap<String, ActiveRequest>,recent: VecDeque<CompletedRequest>,+ session_output_buckets: HashMap<Option<String>, Vec<(u64, u64)>>,recent_limit: usize,}@@ -283,6 +286,7 @@ impl MonitorHandle {started_at: SystemTime::now(),active: HashMap::new(),recent: VecDeque::new(),+ session_output_buckets: HashMap::new(),recent_limit,})),}@@ -528,6 +532,7 @@ impl MonitorStore {input_tokens,output_tokens,} => {+ let mut history_update = None;if let Some(active) = self.active.get_mut(&request_id) {active.status = RequestStatus::Streaming;if active.generation_started_instant.is_none() {@@ -550,6 +555,7 @@ impl MonitorStore {.iter_mut().find(|request| request.request_id == request_id){+ let previous_output_tokens = completed.output_tokens.unwrap_or(0);if let Some(started) = completed.generation_started_instant {completed.generation_finished_at = Some(SystemTime::now());completed.generation_duration = Some(started.elapsed());@@ -558,6 +564,22 @@ impl MonitorStore {completed.stream_chunks = completed.stream_chunks.saturating_add(chunks);completed.input_tokens = input_tokens.or(completed.input_tokens);completed.output_tokens = output_tokens.or(completed.output_tokens);+ let added_tokens = completed+ .output_tokens+ .unwrap_or(0)+ .saturating_sub(previous_output_tokens);+ if added_tokens > 0 {+ history_update = Some((+ completed.session_id.clone(),+ completed+ .generation_finished_at+ .unwrap_or(completed.finished_at),+ added_tokens,+ ));+ }+ }+ if let Some((session_id, timestamp, tokens)) = history_update {+ self.record_session_output(session_id, timestamp, tokens);}}MonitorEvent::UsageUpdated {@@ -565,6 +587,7 @@ impl MonitorStore {input_tokens,output_tokens,} => {+ let mut history_update = None;if let Some(active) = self.active.get_mut(&request_id) {if output_tokens.is_some()&& let Some(started) = active.generation_started_instant@@ -579,6 +602,7 @@ impl MonitorStore {.iter_mut().find(|request| request.request_id == request_id){+ let previous_output_tokens = completed.output_tokens.unwrap_or(0);if output_tokens.is_some()&& let Some(started) = completed.generation_started_instant{@@ -587,6 +611,22 @@ impl MonitorStore {}completed.input_tokens = input_tokens.or(completed.input_tokens);completed.output_tokens = output_tokens.or(completed.output_tokens);+ let added_tokens = completed+ .output_tokens+ .unwrap_or(0)+ .saturating_sub(previous_output_tokens);+ if added_tokens > 0 {+ history_update = Some((+ completed.session_id.clone(),+ completed+ .generation_finished_at+ .unwrap_or(completed.finished_at),+ added_tokens,+ ));+ }+ }+ if let Some((session_id, timestamp, tokens)) = history_update {+ self.record_session_output(session_id, timestamp, tokens);}}MonitorEvent::RequestCompleted {@@ -720,16 +760,39 @@ impl MonitorStore {error: error.or(active.error),traffic_capture_path: active.traffic_capture_path,};+ if let Some(tokens) = completed.output_tokens.filter(|tokens| *tokens > 0) {+ self.record_session_output(+ completed.session_id.clone(),+ completed+ .generation_finished_at+ .unwrap_or(completed.finished_at),+ tokens,+ );+ }self.recent.push_front(completed);while self.recent.len() > self.recent_limit {self.recent.pop_back();}}+ fn record_session_output(+ &mut self,+ session_id: Option<String>,+ timestamp: SystemTime,+ tokens: u64,+ ) {+ let bucket = session_token_bucket(timestamp);+ let buckets = self.session_output_buckets.entry(session_id).or_default();+ match buckets.binary_search_by_key(&bucket, |(bucket, _)| *bucket) {+ Ok(index) => buckets[index].1 = buckets[index].1.saturating_add(tokens),+ Err(index) => buckets.insert(index, (bucket, tokens)),+ }+ }+fn snapshot(&self) -> MonitorState {let mut active: Vec<_> = self.active.values().cloned().collect();active.sort_by_key(|request| request.started_at);- let sessions = session_summaries(&active, &self.recent);+ let sessions = session_summaries(&active, &self.recent, &self.session_output_buckets);MonitorState {started_at: self.started_at,sessions,@@ -742,6 +805,7 @@ impl MonitorStore {fn session_summaries(active: &[ActiveRequest],recent: &VecDeque<CompletedRequest>,+ session_output_buckets: &HashMap<Option<String>, Vec<(u64, u64)>>,) -> Vec<SessionSummary> {let mut sessions: HashMap<Option<String>, SessionSummary> = HashMap::new();for request in recent.iter().rev() {@@ -759,6 +823,7 @@ fn session_summaries(last_seen: request.finished_at,input_tokens: 0,output_tokens: 0,+ output_token_samples: Vec::new(),rate_output_tokens: 0,generation_duration: Duration::ZERO,last_status: "-".to_string(),@@ -808,6 +873,7 @@ fn session_summaries(last_seen: request.started_at,input_tokens: 0,output_tokens: 0,+ output_token_samples: Vec::new(),rate_output_tokens: 0,generation_duration: Duration::ZERO,last_status: "-".to_string(),@@ -840,11 +906,32 @@ fn session_summaries(entry.last_status = request.status.label().to_string();}+ for (session_id, session) in &mut sessions {+ if let Some(buckets) = session_output_buckets.get(session_id) {+ session.output_token_samples = buckets+ .iter()+ .map(|(bucket, tokens)| (session_token_bucket_start(*bucket), *tokens))+ .collect();+ }+ }+let mut out: Vec<_> = sessions.into_values().collect();out.sort_by_key(SessionSummary::label);out}+fn session_token_bucket(timestamp: SystemTime) -> u64 {+ timestamp+ .duration_since(SystemTime::UNIX_EPOCH)+ .unwrap_or(Duration::ZERO)+ .as_secs()+ / SESSION_TOKEN_BUCKET_SECS+}++fn session_token_bucket_start(bucket: u64) -> SystemTime {+ SystemTime::UNIX_EPOCH + Duration::from_secs(bucket.saturating_mul(SESSION_TOKEN_BUCKET_SECS))+}+fn max_system_time(left: SystemTime, right: SystemTime) -> SystemTime {if right.duration_since(left).is_ok() {right@@ -1001,6 +1088,14 @@ mod tests {state.recent[0].rate(),Throughput::TokensPerSecond(_)));+ assert_eq!(+ state.sessions[0]+ .output_token_samples+ .iter()+ .map(|(_, tokens)| *tokens)+ .sum::<u64>(),+ 141+ );}#[test]@@ -1181,7 +1276,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input),]);- let sessions = session_summaries(&[], &recent);+ let sessions = session_summaries(&[], &recent, &HashMap::new());assert_eq!(sessions[0].output_tokens, 150);assert_eq!(sessions[0].generation_duration, Duration::from_secs(5));@@ -1194,7 +1289,10 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"inputlet recent = VecDeque::from([request.clone()]);assert_eq!(request.rate(), Throughput::None);- assert_eq!(session_summaries(&[], &recent)[0].rate(), Throughput::None);+ assert_eq!(+ session_summaries(&[], &recent, &HashMap::new())[0].rate(),+ Throughput::None+ );}#[test]@@ -1219,7 +1317,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input]);assert_eq!(- session_summaries(&[], &recent)[0].rate(),+ session_summaries(&[], &recent, &HashMap::new())[0].rate(),Throughput::TokensPerSecond(25.0));}@@ -1237,7 +1335,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input),]);- let session = &session_summaries(&[], &recent)[0];+ let session = &session_summaries(&[], &recent, &HashMap::new())[0];assert_eq!(session.output_tokens, 1_000);assert_eq!(session.rate(), Throughput::TokensPerSecond(25.0));@@ -1270,6 +1368,40 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"inputassert_eq!(state.sessions[0].active_count, 1);assert_eq!(state.sessions[0].effort.as_deref(), Some("xhigh"));assert_eq!(state.sessions[0].output_tokens, 20);+ assert_eq!(+ state.sessions[0]+ .output_token_samples+ .iter()+ .map(|(_, tokens)| *tokens)+ .collect::<Vec<_>>(),+ vec![20]+ );+ }++ #[test]+ fn session_output_history_survives_request_eviction() {+ let monitor = MonitorHandle::new(1);+ for (request_id, tokens) in [("oldest", 20), ("newest", 80)] {+ monitor.request_started(+ request_id,+ Some("s1".to_string()),+ None,+ EndpointKind::Messages,+ );+ monitor.request_completed(request_id, 200, None, Some(tokens));+ }++ let state = monitor.snapshot();++ assert_eq!(state.recent.len(), 1);+ assert_eq!(+ state.sessions[0]+ .output_token_samples+ .iter()+ .map(|(_, tokens)| *tokens)+ .sum::<u64>(),+ 100+ );}#[test]diff --git a/src/monitor/mock.rs b/src/monitor/mock.rsindex 382d79a..afbdc70 100644--- a/src/monitor/mock.rs+++ b/src/monitor/mock.rs@@ -1,5 +1,5 @@use std::{- collections::VecDeque,+ collections::{HashMap, VecDeque},path::PathBuf,time::{Duration, Instant, SystemTime},};@@ -333,7 +333,8 @@ fn mock_state_for_tick(recent.push_back(no_status);add_simulated_requests(now, instant_now, tick, &mut active, &mut recent);- let sessions = session_summaries(&active, &recent);+ let output_buckets = simulated_output_buckets(now, tick, &active, &recent);+ let sessions = session_summaries(&active, &recent, &output_buckets);MonitorState {started_at,sessions,@@ -342,6 +343,94 @@ fn mock_state_for_tick(}}+fn simulated_output_buckets(+ now: SystemTime,+ tick: u64,+ active: &[ActiveRequest],+ recent: &VecDeque<CompletedRequest>,+) -> HashMap<Option<String>, Vec<(u64, u64)>> {+ const HISTORIES: [(&str, [u64; 12]); 3] = [+ (+ "57c7c914-ada4-4f40-9672-985f950fbb66",+ [0, 320, 780, 0, 1_600, 2_900, 850, 0, 440, 3_600, 2_200, 0],+ ),+ (+ "terminal-refactor",+ [180, 0, 420, 960, 0, 0, 1_300, 740, 2_100, 0, 350, 0],+ ),+ (+ "cursor-session",+ [0, 640, 1_200, 2_400, 3_800, 1_900, 0, 0, 820, 1_500, 0, 0],+ ),+ ];++ let current_bucket = super::session_token_bucket(now);+ let mut buckets = HashMap::<Option<String>, Vec<(u64, u64)>>::new();+ for (session_id, history) in HISTORIES {+ for (index, tokens) in history.iter().copied().enumerate() {+ if tokens == 0 {+ continue;+ }+ let offset = (history.len() - 1 - index) as u64;+ record_output_bucket(+ &mut buckets,+ Some(session_id.to_string()),+ current_bucket.saturating_sub(offset),+ tokens,+ );+ }+ }++ for request in recent {+ if let Some(tokens) = request.output_tokens.filter(|tokens| *tokens > 0) {+ record_output_bucket(+ &mut buckets,+ request.session_id.clone(),+ super::session_token_bucket(request.finished_at),+ tokens,+ );+ }+ }+ for request in active {+ if let Some(tokens) = request.output_tokens.filter(|tokens| *tokens > 0) {+ record_output_bucket(+ &mut buckets,+ request.session_id.clone(),+ current_bucket,+ tokens,+ );+ }+ }++ record_output_bucket(+ &mut buckets,+ Some("57c7c914-ada4-4f40-9672-985f950fbb66".to_string()),+ current_bucket,+ 120 + (tick % 40) * 80,+ );+ for samples in buckets.values_mut() {+ samples.sort_by_key(|(bucket, _)| *bucket);+ }+ buckets+}++fn record_output_bucket(+ buckets: &mut HashMap<Option<String>, Vec<(u64, u64)>>,+ session_id: Option<String>,+ bucket: u64,+ tokens: u64,+) {+ let samples = buckets.entry(session_id).or_default();+ if let Some((_, existing)) = samples+ .iter_mut()+ .find(|(existing_bucket, _)| *existing_bucket == bucket)+ {+ *existing = existing.saturating_add(tokens);+ } else {+ samples.push((bucket, tokens));+ }+}+fn simulated_output_tokens(tick: u64) -> u64 {let pairs = tick / 2;pairs@@ -679,6 +768,10 @@ mod tests {assert!(second_request.output_tokens > first_request.output_tokens);assert_ne!(second_request.rate(), first_request.rate());assert!(second_session.output_tokens > first_session.output_tokens);+ assert_ne!(+ second_session.output_token_samples,+ first_session.output_token_samples+ );assert_eq!(second.started_at, first.started_at);}diff --git a/src/tui.rs b/src/tui.rsindex 2e6fc2c..8ccc2d9 100644--- a/src/tui.rs+++ b/src/tui.rs@@ -1,4 +1,5 @@use std::{+ collections::HashMap,io::{self, Stdout},time::{Duration, SystemTime},};@@ -21,7 +22,8 @@ use tokio::sync::oneshot;use crate::{monitor::{- ActiveRequest, CompletedRequest, MockMonitor, MonitorHandle, MonitorState, SessionSummary,+ ActiveRequest, CompletedRequest, MockMonitor, MonitorHandle, MonitorState,+ SESSION_TOKEN_BUCKET_SECS, SessionSummary,},paths,registry::Registry,@@ -41,6 +43,9 @@ const BLUE: Color = Color::Rgb(120, 170, 230);const DIM: Color = Color::Rgb(100, 104, 114);const RECENT_MODEL_WIDTH: u16 = 36;+const SESSION_SPARKLINE_MIN_WIDTH: u16 = 170;+const SESSION_SPARKLINE_MAX_TOKENS: u64 = 4_000;+const SESSION_TABLE_HEADERS: [(&str, Alignment); 13] = [("", Alignment::Left),("ID", Alignment::Left),@@ -57,6 +62,23 @@ const SESSION_TABLE_HEADERS: [(&str, Alignment); 13] = [("Status", Alignment::Left),];+const SESSION_WIDE_TABLE_HEADERS: [(&str, Alignment); 14] = [+ ("", Alignment::Left),+ ("ID", Alignment::Left),+ ("Project", Alignment::Left),+ ("Active", Alignment::Right),+ ("Reqs", Alignment::Right),+ ("Fail", Alignment::Right),+ ("Provider", Alignment::Left),+ ("Model", Alignment::Left),+ ("Effort", Alignment::Left),+ ("In", Alignment::Right),+ ("Out", Alignment::Right),+ ("Rate", Alignment::Right),+ ("Tokens/10s · 4k", Alignment::Left),+ ("Status", Alignment::Left),+];+const ACTIVE_TABLE_HEADERS: [(&str, Alignment); 8] = [("Started", Alignment::Left),("Provider", Alignment::Left),@@ -635,6 +657,62 @@ fn spinner(tick: usize) -> &'static str {FRAMES[tick % FRAMES.len()]}+fn sparkline_bucket(timestamp: SystemTime) -> u64 {+ timestamp+ .duration_since(SystemTime::UNIX_EPOCH)+ .unwrap_or(Duration::ZERO)+ .as_secs()+ / SESSION_TOKEN_BUCKET_SECS+}++fn token_sparkline(samples: &[(SystemTime, u64)], width: usize, now: SystemTime) -> String {+ const LEVELS: [char; 8] = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];++ if width == 0 {+ return String::new();+ }++ let mut buckets = HashMap::<u64, u64>::new();+ for (timestamp, tokens) in samples {+ let bucket = sparkline_bucket(*timestamp);+ let total = buckets.entry(bucket).or_default();+ *total = total.saturating_add(*tokens);+ }++ let current_bucket = sparkline_bucket(now);+ let first_bucket = current_bucket.saturating_sub(width.saturating_sub(1) as u64);+ (first_bucket..=current_bucket)+ .map(|bucket| {+ let value = buckets.get(&bucket).copied().unwrap_or(0);+ if value == 0 {+ return ' ';+ }+ let scaled = value.min(SESSION_SPARKLINE_MAX_TOKENS);+ let level = ((u128::from(scaled) * LEVELS.len() as u128+ + u128::from(SESSION_SPARKLINE_MAX_TOKENS)+ - 1)+ / u128::from(SESSION_SPARKLINE_MAX_TOKENS))+ .saturating_sub(1) as usize;+ LEVELS[level]+ })+ .collect()+}++fn token_sparkline_line(+ samples: &[(SystemTime, u64)],+ width: usize,+ now: SystemTime,+) -> Line<'static> {+ let mut sparkline = token_sparkline(samples, width, now);+ let current = sparkline+ .pop()+ .map_or_else(String::new, |value| value.to_string());+ Line::from(vec![+ Span::styled(sparkline, Style::default().fg(BLUE)),+ Span::styled(current, Style::default().fg(DIM)),+ ])+}+fn render_sessions(frame: &mut ratatui::Frame<'_>,area: Rect,@@ -647,7 +725,8 @@ fn render_sessions(return;}- let widths = [+ let show_sparkline = area.width >= SESSION_SPARKLINE_MIN_WIDTH;+ let mut widths = vec![Constraint::Length(1),Constraint::Length(8),Constraint::Length(18),@@ -660,16 +739,23 @@ fn render_sessions(Constraint::Length(9),Constraint::Length(9),Constraint::Length(12),- Constraint::Length(10),];+ if show_sparkline {+ widths.push(Constraint::Fill(1));+ }+ widths.push(Constraint::Length(10));let model_width = table_column_width(area, &widths, 7);+ let sparkline_width = show_sparkline+ .then(|| table_column_width(area, &widths, 12))+ .unwrap_or(0);+ let now = SystemTime::now();let rows = sessions.iter().enumerate().map(|(index, session)| {let marker = if focused && index == selected {">"} else {" "};- Row::new(vec![+ let mut cells = vec![Cell::from(Span::styled(marker, Style::default().fg(TEAL))),text_cell(display_session_id(session.session_id.as_deref())),text_cell(session.project.as_deref().unwrap_or("-")),@@ -682,16 +768,28 @@ fn render_sessions(number_cell(compact_tokens(session.input_tokens)),number_cell(compact_tokens(session.output_tokens)),rate_cell(session.rate().label()),- status_cell(&session.last_status),- ])- .style(if index == selected {+ ];+ if show_sparkline {+ cells.push(Cell::from(token_sparkline_line(+ &session.output_token_samples,+ sparkline_width,+ now,+ )));+ }+ cells.push(status_cell(&session.last_status));+ Row::new(cells).style(if index == selected {Style::default().bg(SELECTED_BG)} else {Style::default().bg(PANEL_BG)})});+ let headers: &[(&str, Alignment)] = if show_sparkline {+ &SESSION_WIDE_TABLE_HEADERS+ } else {+ &SESSION_TABLE_HEADERS+ };let table = Table::new(rows, widths)- .header(table_header_aligned(SESSION_TABLE_HEADERS))+ .header(table_header_aligned(headers.iter().copied())).block(panel("Sessions", focused));frame.render_widget(table, area);}@@ -1290,6 +1388,25 @@ mod tests {"Out", "Rate", "Status",]);+ assert_eq!(+ table_header_labels(&SESSION_WIDE_TABLE_HEADERS),+ [+ "",+ "ID",+ "Project",+ "Active",+ "Reqs",+ "Fail",+ "Provider",+ "Model",+ "Effort",+ "In",+ "Out",+ "Rate",+ "Tokens/10s · 4k",+ "Status",+ ]+ );assert_eq!(table_header_labels(&ACTIVE_TABLE_HEADERS),[@@ -1386,6 +1503,95 @@ mod tests {assert_eq!(ellipsize("anything", 0), "");}+ #[test]+ fn token_sparkline_uses_fixed_wall_clock_buckets() {+ let samples = [+ (SystemTime::UNIX_EPOCH + Duration::from_secs(78), 2_000),+ (SystemTime::UNIX_EPOCH + Duration::from_secs(85), 3_000),+ (SystemTime::UNIX_EPOCH + Duration::from_secs(100), 4_000),+ ];+ let bucket_start = SystemTime::UNIX_EPOCH + Duration::from_secs(100);+ let bucket_end = SystemTime::UNIX_EPOCH + Duration::from_secs(109);+ let next_bucket = SystemTime::UNIX_EPOCH + Duration::from_secs(110);++ assert_eq!(token_sparkline(&[], 4, bucket_start), " ");+ assert_eq!(token_sparkline(&samples, 4, bucket_start), "▄▆ █");+ assert_eq!(token_sparkline(&samples, 4, bucket_end), "▄▆ █");+ assert_eq!(token_sparkline(&samples, 4, next_bucket), "▆ █ ");+ assert_eq!(token_sparkline(&samples, 0, bucket_start), "");+ }++ #[test]+ fn token_sparkline_uses_fixed_shared_scale() {+ let now = SystemTime::UNIX_EPOCH + Duration::from_secs(100);+ let current = (now, 2_000);+ let offscreen_peak = (SystemTime::UNIX_EPOCH, 4_000);++ assert_eq!(token_sparkline(&[current], 2, now), " ▄");+ assert_eq!(token_sparkline(&[offscreen_peak, current], 2, now), " ▄");+ assert_eq!(token_sparkline(&[(now, 10_000)], 1, now), "█");+ }++ #[test]+ fn token_sparkline_dims_the_current_bucket() {+ let now = SystemTime::UNIX_EPOCH + Duration::from_secs(100);+ let samples = [+ (SystemTime::UNIX_EPOCH + Duration::from_secs(95), 2_000),+ (now, 4_000),+ ];++ let line = token_sparkline_line(&samples, 2, now);++ assert_eq!(line.spans[0].content, "▄");+ assert_eq!(line.spans[0].style.fg, Some(BLUE));+ assert_eq!(line.spans[1].content, "█");+ assert_eq!(line.spans[1].style.fg, Some(DIM));+ }++ #[test]+ fn session_sparkline_appears_only_when_space_allows_and_expands() {+ let monitor = MonitorHandle::new(10);+ for (index, tokens) in [1_000, 2_000, 4_000].into_iter().enumerate() {+ let request_id = format!("request-{index}");+ monitor.request_started(+ &request_id,+ Some("sess-1".to_string()),+ Some(index as u64 + 1),+ EndpointKind::Messages,+ );+ monitor.provider_selected(&request_id, "codex", "gpt-5.6-sol", None);+ monitor.request_completed(&request_id, 200, Some(100), Some(tokens));+ }+ let state = monitor.snapshot();++ let narrow = draw(SESSION_SPARKLINE_MIN_WIDTH - 1, 8, |frame| {+ render_sessions(frame, frame.area(), &state.sessions, 0, true)+ });+ let wide = draw(SESSION_SPARKLINE_MIN_WIDTH, 8, |frame| {+ render_sessions(frame, frame.area(), &state.sessions, 0, true)+ });+ let wider = draw(SESSION_SPARKLINE_MIN_WIDTH + 30, 8, |frame| {+ render_sessions(frame, frame.area(), &state.sessions, 0, true)+ });+ let narrow_text = buffer_text(&narrow);+ let wide_text = buffer_text(&wide);+ let wider_text = buffer_text(&wider);+ let spark_chars = |text: &str| {+ text.chars()+ .filter(|ch| matches!(ch, '▁' | '▂' | '▃' | '▄' | '▅' | '▆' | '▇' | '█'))+ .count()+ };++ assert!(!narrow_text.contains("Tokens/10s"), "{narrow_text}");+ assert_eq!(spark_chars(&narrow_text), 0, "{narrow_text}");+ assert!(wide_text.contains("Tokens/10s"), "{wide_text}");+ assert!(spark_chars(&wide_text) > 0, "{wide_text}");+ assert!(+ wider_text.find("█ completed") > wide_text.find("█ completed"),+ "{wider_text}"+ );+ }+#[test]fn empty_tables_hide_columns_and_center_placeholders() {let sessions = draw(40, 9, |frame| {