1#![forbid(unsafe_code)]
60
61use std::collections::VecDeque;
62use web_time::{Duration, Instant};
63
64use crate::bocpd::{BocpdConfig, BocpdDetector, BocpdRegime};
65use crate::evidence_sink::{EVIDENCE_SCHEMA_VERSION, EvidenceSink};
66use crate::terminal_writer::ScreenMode;
67
68const MAX_CYCLE_TIME_SAMPLES: usize = 1024;
73
74const MAX_TRANSITION_LOGS: usize = 256;
77
78const FNV_OFFSET_BASIS: u64 = 0xcbf29ce484222325;
79const FNV_PRIME: u64 = 0x100000001b3;
81
82fn fnv_hash_bytes(hash: &mut u64, bytes: &[u8]) {
83 for byte in bytes {
84 *hash ^= *byte as u64;
85 *hash = hash.wrapping_mul(FNV_PRIME);
86 }
87}
88
89#[inline]
90fn duration_since_or_zero(now: Instant, earlier: Instant) -> Duration {
91 now.saturating_duration_since(earlier)
92}
93
94fn default_resize_run_id() -> String {
95 format!("resize-{}", std::process::id())
96}
97
98fn screen_mode_str(mode: ScreenMode) -> &'static str {
99 match mode {
100 ScreenMode::Inline { .. } => "inline",
101 ScreenMode::InlineAuto { .. } => "inline_auto",
102 ScreenMode::AltScreen => "altscreen",
103 }
104}
105
106#[inline]
107fn json_escape(value: &str) -> String {
108 let mut out = String::with_capacity(value.len());
109 for ch in value.chars() {
110 match ch {
111 '"' => out.push_str("\\\""),
112 '\\' => out.push_str("\\\\"),
113 '\n' => out.push_str("\\n"),
114 '\r' => out.push_str("\\r"),
115 '\t' => out.push_str("\\t"),
116 c if c.is_control() => {
117 use std::fmt::Write as _;
118 let _ = write!(out, "\\u{:04X}", c as u32);
119 }
120 _ => out.push(ch),
121 }
122 }
123 out
124}
125
126fn evidence_prefix(
127 run_id: &str,
128 screen_mode: ScreenMode,
129 cols: u16,
130 rows: u16,
131 event_idx: u64,
132) -> String {
133 format!(
134 r#""schema_version":"{}","run_id":"{}","event_idx":{},"screen_mode":"{}","cols":{},"rows":{}"#,
135 EVIDENCE_SCHEMA_VERSION,
136 json_escape(run_id),
137 event_idx,
138 screen_mode_str(screen_mode),
139 cols,
140 rows,
141 )
142}
143
144#[derive(Debug, Clone)]
146pub struct CoalescerConfig {
147 pub steady_delay_ms: u64,
150
151 pub burst_delay_ms: u64,
154
155 pub hard_deadline_ms: u64,
158
159 pub burst_enter_rate: f64,
161
162 pub burst_exit_rate: f64,
165
166 pub cooldown_frames: u32,
168
169 pub rate_window_size: usize,
171
172 pub enable_logging: bool,
174
175 pub enable_bocpd: bool,
187
188 pub heuristic_fallback: bool,
198
199 pub bocpd_config: Option<BocpdConfig>,
201}
202
203impl Default for CoalescerConfig {
204 fn default() -> Self {
205 Self {
206 steady_delay_ms: 16, burst_delay_ms: 40, hard_deadline_ms: 100,
209 burst_enter_rate: 10.0, burst_exit_rate: 5.0, cooldown_frames: 3,
212 rate_window_size: 8,
213 enable_logging: false,
214 enable_bocpd: true,
215 heuristic_fallback: true,
216 bocpd_config: None,
217 }
218 }
219}
220
221impl CoalescerConfig {
222 #[must_use]
224 pub fn with_logging(mut self, enabled: bool) -> Self {
225 self.enable_logging = enabled;
226 self
227 }
228
229 #[must_use]
231 pub fn with_bocpd(mut self) -> Self {
232 self.enable_bocpd = true;
233 self.bocpd_config = Some(BocpdConfig::default());
234 self
235 }
236
237 #[must_use]
239 pub fn with_bocpd_config(mut self, config: BocpdConfig) -> Self {
240 self.enable_bocpd = true;
241 self.bocpd_config = Some(config);
242 self
243 }
244
245 #[must_use]
248 pub fn without_bocpd(mut self) -> Self {
249 self.enable_bocpd = false;
250 self.bocpd_config = None;
251 self
252 }
253
254 #[must_use]
257 pub fn with_heuristic_fallback(mut self, enabled: bool) -> Self {
258 self.heuristic_fallback = enabled;
259 self
260 }
261
262 #[must_use]
264 pub fn to_jsonl(
265 &self,
266 run_id: &str,
267 screen_mode: ScreenMode,
268 cols: u16,
269 rows: u16,
270 event_idx: u64,
271 ) -> String {
272 let prefix = evidence_prefix(run_id, screen_mode, cols, rows, event_idx);
273 format!(
274 r#"{{{prefix},"event":"config","steady_delay_ms":{},"burst_delay_ms":{},"hard_deadline_ms":{},"burst_enter_rate":{:.3},"burst_exit_rate":{:.3},"cooldown_frames":{},"rate_window_size":{},"logging_enabled":{},"enable_bocpd":{},"heuristic_fallback":{}}}"#,
275 self.steady_delay_ms,
276 self.burst_delay_ms,
277 self.hard_deadline_ms,
278 self.burst_enter_rate,
279 self.burst_exit_rate,
280 self.cooldown_frames,
281 self.rate_window_size,
282 self.enable_logging,
283 self.enable_bocpd,
284 self.heuristic_fallback
285 )
286 }
287}
288
289#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
297pub enum RegimeDetector {
298 #[default]
300 Heuristic,
301 Bocpd,
303}
304
305impl RegimeDetector {
306 #[must_use]
308 pub const fn as_str(self) -> &'static str {
309 match self {
310 Self::Heuristic => "heuristic",
311 Self::Bocpd => "bocpd",
312 }
313 }
314}
315
316#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
318pub struct DetectorDecisions {
319 pub bocpd: u64,
321 pub heuristic: u64,
323}
324
325#[derive(Debug, Clone, Copy, PartialEq, Eq)]
327pub enum CoalesceAction {
328 None,
332
333 ApplyResize {
335 width: u16,
336 height: u16,
337 coalesce_time: Duration,
339 forced_by_deadline: bool,
341 },
342}
343
344#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
346pub enum Regime {
347 #[default]
349 Steady,
350 Burst,
352}
353
354impl Regime {
355 #[must_use]
357 pub const fn as_str(self) -> &'static str {
358 match self {
359 Self::Steady => "steady",
360 Self::Burst => "burst",
361 }
362 }
363}
364
365#[derive(Debug, Clone, Copy, PartialEq, Eq)]
367pub enum TransitionReasonCode {
368 HeuristicEnterBurstRate,
370 HeuristicExitBurstCooldown,
372 HeuristicExitBurstRate,
376 BocpdPosteriorBurst,
378 BocpdPosteriorSteady,
380 BocpdIdleExit,
386}
387
388impl TransitionReasonCode {
389 #[must_use]
391 pub const fn as_str(self) -> &'static str {
392 match self {
393 Self::HeuristicEnterBurstRate => "heuristic_enter_burst_rate",
394 Self::HeuristicExitBurstCooldown => "heuristic_exit_burst_cooldown",
395 Self::HeuristicExitBurstRate => "heuristic_exit_burst_rate",
396 Self::BocpdPosteriorBurst => "bocpd_posterior_burst",
397 Self::BocpdPosteriorSteady => "bocpd_posterior_steady",
398 Self::BocpdIdleExit => "bocpd_idle_exit",
399 }
400 }
401}
402
403#[derive(Debug, Clone)]
407pub struct ResizeAppliedEvent {
408 pub new_size: (u16, u16),
410 pub old_size: (u16, u16),
412 pub elapsed: Duration,
414 pub forced: bool,
416}
417
418#[derive(Debug, Clone)]
422pub struct RegimeChangeEvent {
423 pub from: Regime,
425 pub to: Regime,
427 pub event_idx: u64,
429 pub reason_code: TransitionReasonCode,
431 pub confidence: f64,
433}
434
435#[derive(Debug, Clone)]
463pub struct DecisionEvidence {
464 pub log_bayes_factor: f64,
466
467 pub regime_contribution: f64,
469
470 pub timing_contribution: f64,
472
473 pub rate_contribution: f64,
475
476 pub explanation: String,
478}
479
480impl DecisionEvidence {
481 #[must_use]
483 pub fn favor_apply(regime: Regime, dt_ms: f64, event_rate: f64) -> Self {
484 let regime_contrib = if regime == Regime::Steady { 1.0 } else { -0.5 };
485 let timing_contrib = (dt_ms / 50.0).min(2.0); let rate_contrib = if event_rate < 5.0 { 0.5 } else { -0.3 };
487
488 let lbf = regime_contrib + timing_contrib + rate_contrib;
489
490 Self {
491 log_bayes_factor: lbf,
492 regime_contribution: regime_contrib,
493 timing_contribution: timing_contrib,
494 rate_contribution: rate_contrib,
495 explanation: format!(
496 "Regime={:?} (contrib={:.2}), dt={:.1}ms (contrib={:.2}), rate={:.1}/s (contrib={:.2})",
497 regime, regime_contrib, dt_ms, timing_contrib, event_rate, rate_contrib
498 ),
499 }
500 }
501
502 #[must_use]
504 pub fn favor_coalesce(regime: Regime, dt_ms: f64, event_rate: f64) -> Self {
505 let regime_contrib = if regime == Regime::Burst { 1.0 } else { -0.5 };
506 let timing_contrib = (20.0 / dt_ms.max(1.0)).min(2.0); let rate_contrib = if event_rate > 10.0 { 0.5 } else { -0.3 };
508
509 let lbf = -(regime_contrib + timing_contrib + rate_contrib);
510
511 Self {
512 log_bayes_factor: lbf,
513 regime_contribution: regime_contrib,
514 timing_contribution: timing_contrib,
515 rate_contribution: rate_contrib,
516 explanation: format!(
517 "Regime={:?} (contrib={:.2}), dt={:.1}ms (contrib={:.2}), rate={:.1}/s (contrib={:.2})",
518 regime, regime_contrib, dt_ms, timing_contrib, event_rate, rate_contrib
519 ),
520 }
521 }
522
523 #[must_use]
525 pub fn forced_deadline(deadline_ms: f64) -> Self {
526 Self {
527 log_bayes_factor: f64::INFINITY,
528 regime_contribution: 0.0,
529 timing_contribution: deadline_ms,
530 rate_contribution: 0.0,
531 explanation: format!("Forced by hard deadline ({:.1}ms)", deadline_ms),
532 }
533 }
534
535 #[must_use]
537 pub fn to_jsonl(
538 &self,
539 run_id: &str,
540 screen_mode: ScreenMode,
541 cols: u16,
542 rows: u16,
543 event_idx: u64,
544 ) -> String {
545 let lbf_str = if self.log_bayes_factor.is_infinite() {
546 "\"inf\"".to_string()
547 } else {
548 format!("{:.3}", self.log_bayes_factor)
549 };
550 let prefix = evidence_prefix(run_id, screen_mode, cols, rows, event_idx);
551 format!(
552 r#"{{{prefix},"event":"decision_evidence","log_bayes_factor":{},"regime_contribution":{:.3},"timing_contribution":{:.3},"rate_contribution":{:.3},"explanation":"{}"}}"#,
553 lbf_str,
554 self.regime_contribution,
555 self.timing_contribution,
556 self.rate_contribution,
557 json_escape(&self.explanation)
558 )
559 }
560
561 #[must_use]
563 pub fn is_strong(&self) -> bool {
564 self.log_bayes_factor.abs() > 1.0
565 }
566
567 #[must_use]
569 pub fn is_decisive(&self) -> bool {
570 self.log_bayes_factor.abs() > 2.0 || self.log_bayes_factor.is_infinite()
571 }
572}
573
574#[derive(Debug, Clone)]
576pub struct DecisionLog {
577 pub timestamp: Instant,
579 pub elapsed_ms: f64,
581 pub event_idx: u64,
583 pub dt_ms: f64,
585 pub event_rate: f64,
587 pub regime: Regime,
589 pub action: &'static str,
591 pub pending_size: Option<(u16, u16)>,
593 pub applied_size: Option<(u16, u16)>,
595 pub time_since_render_ms: f64,
597 pub coalesce_ms: Option<f64>,
599 pub forced: bool,
601 pub transition_reason_code: Option<TransitionReasonCode>,
603 pub transition_confidence: Option<f64>,
605 pub detector: RegimeDetector,
607 pub p_burst: Option<f64>,
610}
611
612impl DecisionLog {
613 #[must_use]
615 pub fn to_jsonl(&self, run_id: &str, screen_mode: ScreenMode, cols: u16, rows: u16) -> String {
616 let (pending_w, pending_h) = match self.pending_size {
617 Some((w, h)) => (w.to_string(), h.to_string()),
618 None => ("null".to_string(), "null".to_string()),
619 };
620 let (applied_w, applied_h) = match self.applied_size {
621 Some((w, h)) => (w.to_string(), h.to_string()),
622 None => ("null".to_string(), "null".to_string()),
623 };
624 let coalesce_ms = match self.coalesce_ms {
625 Some(ms) => format!("{:.3}", ms),
626 None => "null".to_string(),
627 };
628 let transition_reason_code = self
629 .transition_reason_code
630 .map(TransitionReasonCode::as_str)
631 .map(|code| format!(r#""{code}""#))
632 .unwrap_or_else(|| "null".to_string());
633 let transition_confidence = self
634 .transition_confidence
635 .map(|confidence| format!("{confidence:.6}"))
636 .unwrap_or_else(|| "null".to_string());
637 let prefix = evidence_prefix(run_id, screen_mode, cols, rows, self.event_idx);
638
639 format!(
640 r#"{{{prefix},"event":"decision","idx":{},"elapsed_ms":{:.3},"dt_ms":{:.3},"event_rate":{:.3},"regime":"{}","action":"{}","pending_w":{},"pending_h":{},"applied_w":{},"applied_h":{},"time_since_render_ms":{:.3},"coalesce_ms":{},"forced":{},"transition_reason_code":{},"transition_confidence":{},"detector":"{}","p_burst":{}}}"#,
641 self.event_idx,
642 self.elapsed_ms,
643 self.dt_ms,
644 self.event_rate,
645 self.regime.as_str(),
646 self.action,
647 pending_w,
648 pending_h,
649 applied_w,
650 applied_h,
651 self.time_since_render_ms,
652 coalesce_ms,
653 self.forced,
654 transition_reason_code,
655 transition_confidence,
656 self.detector.as_str(),
657 self.p_burst
658 .map_or_else(|| "null".to_string(), |p| format!("{p:.6}"))
659 )
660 }
661}
662
663#[derive(Debug, Clone, Copy)]
664struct PendingTransitionEvidence {
665 reason_code: TransitionReasonCode,
666 confidence: f64,
667}
668
669#[derive(Debug, Clone)]
671pub struct RegimeTransitionLog {
672 pub timestamp: Instant,
674 pub event_idx: u64,
676 pub from_regime: Regime,
678 pub to_regime: Regime,
680 pub reason_code: TransitionReasonCode,
682 pub confidence: f64,
684 pub event_rate: f64,
686 pub p_burst: Option<f64>,
688 pub cooldown_remaining: u32,
690 pub detector: RegimeDetector,
692}
693
694impl RegimeTransitionLog {
695 #[must_use]
697 pub fn to_jsonl(&self, run_id: &str, screen_mode: ScreenMode, cols: u16, rows: u16) -> String {
698 let prefix = evidence_prefix(run_id, screen_mode, cols, rows, self.event_idx);
699 let p_burst = self
700 .p_burst
701 .map(|value| format!("{value:.6}"))
702 .unwrap_or_else(|| "null".to_string());
703 format!(
704 r#"{{{prefix},"event":"regime_transition","from_regime":"{}","to_regime":"{}","reason_code":"{}","confidence":{:.6},"event_rate":{:.3},"p_burst":{},"detector":"{}","cooldown_remaining":{}}}"#,
705 self.from_regime.as_str(),
706 self.to_regime.as_str(),
707 self.reason_code.as_str(),
708 self.confidence,
709 self.event_rate,
710 p_burst,
711 self.detector.as_str(),
712 self.cooldown_remaining,
713 )
714 }
715}
716
717#[derive(Debug)]
721pub struct ResizeCoalescer {
722 config: CoalescerConfig,
723
724 pending_size: Option<(u16, u16)>,
726
727 last_applied: (u16, u16),
729
730 window_start: Option<Instant>,
732
733 last_event: Option<Instant>,
735
736 last_render: Instant,
738
739 regime: Regime,
741
742 cooldown_remaining: u32,
744
745 event_times: VecDeque<Instant>,
747
748 event_count: u64,
750
751 log_start: Option<Instant>,
753
754 logs: Vec<DecisionLog>,
756 transition_logs: Vec<RegimeTransitionLog>,
758 pending_transition_evidence: Option<PendingTransitionEvidence>,
760 evidence_sink: Option<EvidenceSink>,
762 config_logged: bool,
764 evidence_run_id: String,
766 evidence_screen_mode: ScreenMode,
768
769 telemetry_hooks: Option<TelemetryHooks>,
772
773 regime_transitions: u64,
775
776 events_in_window: u64,
778
779 cycle_times: Vec<f64>,
781
782 bocpd: Option<BocpdDetector>,
784
785 last_detector: RegimeDetector,
787
788 detector_decisions: DetectorDecisions,
790}
791
792#[derive(Debug, Clone, Copy)]
794pub struct CycleTimePercentiles {
795 pub p50_ms: f64,
797 pub p95_ms: f64,
799 pub p99_ms: f64,
801 pub count: usize,
803 pub mean_ms: f64,
805}
806
807impl CycleTimePercentiles {
808 #[must_use]
810 pub fn to_jsonl(&self) -> String {
811 format!(
812 r#"{{"event":"cycle_time_percentiles","p50_ms":{:.3},"p95_ms":{:.3},"p99_ms":{:.3},"mean_ms":{:.3},"count":{}}}"#,
813 self.p50_ms, self.p95_ms, self.p99_ms, self.mean_ms, self.count
814 )
815 }
816}
817
818impl ResizeCoalescer {
819 pub fn new(config: CoalescerConfig, initial_size: (u16, u16)) -> Self {
821 let bocpd = if config.enable_bocpd {
822 let mut bocpd_cfg = config.bocpd_config.clone().unwrap_or_default();
823 if config.enable_logging {
824 bocpd_cfg.enable_logging = true;
825 }
826 Some(BocpdDetector::new(bocpd_cfg))
827 } else {
828 None
829 };
830
831 Self {
832 config,
833 pending_size: None,
834 last_applied: initial_size,
835 window_start: None,
836 last_event: None,
837 last_render: Instant::now(),
838 regime: Regime::Steady,
839 cooldown_remaining: 0,
840 event_times: VecDeque::new(),
841 event_count: 0,
842 log_start: None,
843 logs: Vec::new(),
844 transition_logs: Vec::new(),
845 pending_transition_evidence: None,
846 evidence_sink: None,
847 config_logged: false,
848 evidence_run_id: default_resize_run_id(),
849 evidence_screen_mode: ScreenMode::AltScreen,
850 telemetry_hooks: None,
851 regime_transitions: 0,
852 events_in_window: 0,
853 cycle_times: Vec::new(),
854 bocpd,
855 last_detector: RegimeDetector::Heuristic,
856 detector_decisions: DetectorDecisions::default(),
857 }
858 }
859
860 #[must_use]
862 pub fn with_telemetry_hooks(mut self, hooks: TelemetryHooks) -> Self {
863 self.telemetry_hooks = Some(hooks);
864 self
865 }
866
867 #[must_use]
869 pub fn with_evidence_sink(mut self, sink: EvidenceSink) -> Self {
870 self.evidence_sink = Some(sink);
871 self.config_logged = false;
872 self
873 }
874
875 #[must_use]
877 pub fn with_evidence_run_id(mut self, run_id: impl Into<String>) -> Self {
878 self.evidence_run_id = run_id.into();
879 self
880 }
881
882 #[must_use]
884 pub fn with_screen_mode(mut self, screen_mode: ScreenMode) -> Self {
885 self.evidence_screen_mode = screen_mode;
886 self
887 }
888
889 pub fn set_evidence_sink(&mut self, sink: Option<EvidenceSink>) {
891 self.evidence_sink = sink;
892 self.config_logged = false;
893 }
894
895 #[must_use]
897 pub fn with_last_render(mut self, time: Instant) -> Self {
898 self.last_render = time;
899 self
900 }
901
902 pub fn record_external_apply(&mut self, width: u16, height: u16, now: Instant) {
904 self.event_count += 1;
905 self.event_times.push_back(now);
906 while self.event_times.len() > self.config.rate_window_size {
907 self.event_times.pop_front();
908 }
909 self.update_regime(now);
910 if self.heuristic_decides() && self.regime == Regime::Burst {
917 let rate = self.calculate_event_rate(now);
918 if rate < self.config.burst_exit_rate {
919 self.record_regime_transition(
920 now,
921 Regime::Steady,
922 TransitionReasonCode::HeuristicExitBurstRate,
923 (1.0 - (rate / self.config.burst_exit_rate)).clamp(0.0, 1.0),
924 rate,
925 None,
926 );
927 }
928 }
929
930 self.pending_size = None;
931 self.window_start = None;
932 self.last_event = Some(now);
933 self.last_applied = (width, height);
934 self.last_render = now;
935 self.events_in_window = 0;
936 self.cooldown_remaining = 0;
937
938 self.log_decision(now, "apply_immediate", false, Some(0.0), Some(0.0));
939
940 if let Some(ref hooks) = self.telemetry_hooks
941 && let Some(entry) = self.logs.last()
942 {
943 hooks.fire_resize_applied(entry);
944 }
945 }
946
947 #[must_use]
949 pub fn regime_transition_count(&self) -> u64 {
950 self.regime_transitions
951 }
952
953 #[must_use]
956 pub fn cycle_time_percentiles(&self) -> Option<CycleTimePercentiles> {
957 if self.cycle_times.is_empty() {
958 return None;
959 }
960
961 let mut sorted = self.cycle_times.clone();
962 sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
963
964 let len = sorted.len();
965 let p50_idx = len / 2;
966 let p95_idx = (len * 95) / 100;
967 let p99_idx = (len * 99) / 100;
968
969 Some(CycleTimePercentiles {
970 p50_ms: sorted[p50_idx],
971 p95_ms: sorted[p95_idx.min(len - 1)],
972 p99_ms: sorted[p99_idx.min(len - 1)],
973 count: len,
974 mean_ms: sorted.iter().sum::<f64>() / len as f64,
975 })
976 }
977
978 pub fn handle_resize(&mut self, width: u16, height: u16) -> CoalesceAction {
982 self.handle_resize_at(width, height, Instant::now())
983 }
984
985 pub fn handle_resize_at(&mut self, width: u16, height: u16, now: Instant) -> CoalesceAction {
987 self.event_count += 1;
988
989 let dt = self.last_event.map(|t| duration_since_or_zero(now, t));
991 let dt_ms = dt.map(|d| d.as_secs_f64() * 1000.0).unwrap_or(0.0);
992
993 if dt_ms > 1000.0 {
996 self.event_times.clear();
997 }
998
999 self.event_times.push_back(now);
1000 while self.event_times.len() > self.config.rate_window_size {
1001 self.event_times.pop_front();
1002 }
1003
1004 self.update_regime(now);
1006
1007 self.last_event = Some(now);
1008
1009 if self.pending_size.is_none() && (width, height) == self.last_applied {
1011 self.log_decision(now, "skip_same_size", false, Some(dt_ms), None);
1012 return CoalesceAction::None;
1013 }
1014
1015 let had_pending_before_event = self.pending_size.is_some();
1019
1020 self.pending_size = Some((width, height));
1022
1023 self.events_in_window += 1;
1025
1026 if self.window_start.is_none() {
1028 self.window_start = Some(now);
1029 }
1030
1031 let time_since_render = duration_since_or_zero(now, self.last_render);
1036 if time_since_render >= Duration::from_millis(self.config.hard_deadline_ms) {
1037 return self.apply_pending_at(now, had_pending_before_event);
1038 }
1039
1040 let time_ok = match dt {
1043 Some(d) => d >= Duration::from_millis(self.current_delay_ms()),
1044 None => false, };
1046
1047 if time_ok && (!self.heuristic_decides() || self.regime == Regime::Steady) {
1048 return self.apply_pending_at(now, false);
1049 }
1050
1051 self.log_decision(now, "coalesce", false, Some(dt_ms), None);
1052
1053 if let Some(ref hooks) = self.telemetry_hooks
1055 && let Some(entry) = self.logs.last()
1056 {
1057 hooks.fire_decision(entry);
1058 }
1059
1060 CoalesceAction::None
1064 }
1065
1066 pub fn tick(&mut self) -> CoalesceAction {
1070 self.tick_at(Instant::now())
1071 }
1072
1073 pub fn tick_at(&mut self, now: Instant) -> CoalesceAction {
1075 if self.regime == Regime::Burst && self.heuristic_decides() {
1085 let rate = self.calculate_event_rate(now);
1086 if rate >= self.config.burst_exit_rate {
1087 self.cooldown_remaining = self.config.cooldown_frames.max(1);
1088 } else if self.cooldown_remaining > 0 {
1089 self.cooldown_remaining -= 1;
1090 if self.cooldown_remaining == 0 {
1091 self.record_regime_transition(
1092 now,
1093 Regime::Steady,
1094 TransitionReasonCode::HeuristicExitBurstCooldown,
1095 (1.0 - (rate / self.config.burst_exit_rate)).clamp(0.0, 1.0),
1096 rate,
1097 None,
1098 );
1099 }
1100 }
1101 }
1102
1103 if self.regime == Regime::Burst
1110 && !self.heuristic_decides()
1111 && let Some(idle_exit) = self.bocpd_idle_exit(now)
1112 {
1113 let (confidence, rate, p_burst) = idle_exit;
1114 self.record_regime_transition(
1115 now,
1116 Regime::Steady,
1117 TransitionReasonCode::BocpdIdleExit,
1118 confidence,
1119 rate,
1120 Some(p_burst),
1121 );
1122 }
1123
1124 if self.pending_size.is_none() {
1125 return CoalesceAction::None;
1126 }
1127
1128 if self.window_start.is_none() {
1129 return CoalesceAction::None;
1130 }
1131
1132 let time_since_render = duration_since_or_zero(now, self.last_render);
1134 if time_since_render >= Duration::from_millis(self.config.hard_deadline_ms) {
1135 return self.apply_pending_at(now, true);
1136 }
1137
1138 let delay_ms = self.current_delay_ms();
1139
1140 if let Some(last_event) = self.last_event {
1142 let since_last_event = duration_since_or_zero(now, last_event);
1143 if since_last_event >= Duration::from_millis(delay_ms) {
1144 return self.apply_pending_at(now, false);
1145 }
1146 }
1147
1148 CoalesceAction::None
1149 }
1150
1151 pub fn time_until_apply(&self, now: Instant) -> Option<Duration> {
1153 let _pending = self.pending_size?;
1154
1155 let time_since_render = duration_since_or_zero(now, self.last_render);
1157 let hard_deadline = Duration::from_millis(self.config.hard_deadline_ms);
1158 let hard_deadline_remaining = hard_deadline.saturating_sub(time_since_render);
1159
1160 let delay_remaining = if let Some(last_event) = self.last_event {
1162 let since_last_event = duration_since_or_zero(now, last_event);
1163 let delay = Duration::from_millis(self.current_delay_ms());
1164 delay.saturating_sub(since_last_event)
1165 } else {
1166 Duration::ZERO
1167 };
1168
1169 Some(hard_deadline_remaining.min(delay_remaining))
1174 }
1175
1176 #[inline]
1178 pub fn has_pending(&self) -> bool {
1179 self.pending_size.is_some()
1180 }
1181
1182 #[inline]
1184 pub fn regime(&self) -> Regime {
1185 self.regime
1186 }
1187
1188 #[inline]
1190 pub fn bocpd_enabled(&self) -> bool {
1191 self.bocpd.is_some()
1192 }
1193
1194 #[inline]
1197 pub fn last_detector(&self) -> RegimeDetector {
1198 self.last_detector
1199 }
1200
1201 #[inline]
1203 pub fn detector_decisions(&self) -> DetectorDecisions {
1204 self.detector_decisions
1205 }
1206
1207 #[inline]
1211 pub fn bocpd(&self) -> Option<&BocpdDetector> {
1212 self.bocpd.as_ref()
1213 }
1214
1215 #[inline]
1220 pub fn bocpd_p_burst(&self) -> Option<f64> {
1221 self.bocpd.as_ref().map(|b| b.p_burst())
1222 }
1223
1224 #[inline]
1229 pub fn bocpd_recommended_delay(&self) -> Option<u64> {
1230 self.bocpd
1231 .as_ref()
1232 .map(|b| b.recommended_delay(self.config.steady_delay_ms, self.config.burst_delay_ms))
1233 }
1234
1235 pub fn event_rate(&self) -> f64 {
1237 self.calculate_event_rate(Instant::now())
1238 }
1239
1240 #[inline]
1242 pub fn last_applied(&self) -> (u16, u16) {
1243 self.last_applied
1244 }
1245
1246 pub fn logs(&self) -> &[DecisionLog] {
1248 &self.logs
1249 }
1250
1251 pub fn transition_logs(&self) -> &[RegimeTransitionLog] {
1253 &self.transition_logs
1254 }
1255
1256 fn record_cycle_time(&mut self, coalesce_ms: f64) {
1262 self.cycle_times.push(coalesce_ms);
1263 let len = self.cycle_times.len();
1264 if len > MAX_CYCLE_TIME_SAMPLES {
1265 self.cycle_times.drain(..len - MAX_CYCLE_TIME_SAMPLES);
1266 }
1267 }
1268
1269 fn push_transition_log(&mut self, log: RegimeTransitionLog) {
1273 self.transition_logs.push(log);
1274 let len = self.transition_logs.len();
1275 if len > MAX_TRANSITION_LOGS {
1276 self.transition_logs.drain(..len - MAX_TRANSITION_LOGS);
1277 }
1278 }
1279
1280 pub fn clear_logs(&mut self) {
1282 self.logs.clear();
1283 self.transition_logs.clear();
1284 self.pending_transition_evidence = None;
1285 self.log_start = None;
1286 self.config_logged = false;
1287 }
1288
1289 pub fn stats(&self) -> CoalescerStats {
1291 CoalescerStats {
1292 event_count: self.event_count,
1293 regime: self.regime,
1294 event_rate: self.event_rate(),
1295 has_pending: self.pending_size.is_some(),
1296 last_applied: self.last_applied,
1297 detector: self.last_detector,
1298 detector_decisions: self.detector_decisions,
1299 }
1300 }
1301
1302 #[must_use]
1311 pub fn decision_logs_jsonl(&self) -> String {
1312 let (cols, rows) = self.last_applied;
1313 let run_id = self.evidence_run_id.as_str();
1314 let screen_mode = self.evidence_screen_mode;
1315 self.logs
1316 .iter()
1317 .map(|entry| entry.to_jsonl(run_id, screen_mode, cols, rows))
1318 .collect::<Vec<_>>()
1319 .join("\n")
1320 }
1321
1322 #[must_use]
1324 pub fn decision_checksum(&self) -> u64 {
1325 let mut hash = FNV_OFFSET_BASIS;
1326 for entry in &self.logs {
1327 fnv_hash_bytes(&mut hash, &entry.event_idx.to_le_bytes());
1328 fnv_hash_bytes(&mut hash, &entry.elapsed_ms.to_bits().to_le_bytes());
1329 fnv_hash_bytes(&mut hash, &entry.dt_ms.to_bits().to_le_bytes());
1330 fnv_hash_bytes(&mut hash, &entry.event_rate.to_bits().to_le_bytes());
1331 fnv_hash_bytes(
1332 &mut hash,
1333 &[match entry.regime {
1334 Regime::Steady => 0u8,
1335 Regime::Burst => 1u8,
1336 }],
1337 );
1338 fnv_hash_bytes(&mut hash, entry.action.as_bytes());
1339 fnv_hash_bytes(&mut hash, &[0u8]); fnv_hash_bytes(&mut hash, &[entry.pending_size.is_some() as u8]);
1342 if let Some((w, h)) = entry.pending_size {
1343 fnv_hash_bytes(&mut hash, &w.to_le_bytes());
1344 fnv_hash_bytes(&mut hash, &h.to_le_bytes());
1345 }
1346
1347 fnv_hash_bytes(&mut hash, &[entry.applied_size.is_some() as u8]);
1348 if let Some((w, h)) = entry.applied_size {
1349 fnv_hash_bytes(&mut hash, &w.to_le_bytes());
1350 fnv_hash_bytes(&mut hash, &h.to_le_bytes());
1351 }
1352
1353 fnv_hash_bytes(
1354 &mut hash,
1355 &entry.time_since_render_ms.to_bits().to_le_bytes(),
1356 );
1357 fnv_hash_bytes(&mut hash, &[entry.coalesce_ms.is_some() as u8]);
1358 if let Some(ms) = entry.coalesce_ms {
1359 fnv_hash_bytes(&mut hash, &ms.to_bits().to_le_bytes());
1360 }
1361 fnv_hash_bytes(&mut hash, &[entry.forced as u8]);
1362 fnv_hash_bytes(&mut hash, &[entry.transition_reason_code.is_some() as u8]);
1363 if let Some(reason_code) = entry.transition_reason_code {
1364 fnv_hash_bytes(&mut hash, reason_code.as_str().as_bytes());
1365 }
1366 fnv_hash_bytes(&mut hash, &[entry.transition_confidence.is_some() as u8]);
1367 if let Some(confidence) = entry.transition_confidence {
1368 fnv_hash_bytes(&mut hash, &confidence.to_bits().to_le_bytes());
1369 }
1370 }
1371 hash
1372 }
1373
1374 #[must_use]
1376 pub fn decision_checksum_hex(&self) -> String {
1377 format!("{:016x}", self.decision_checksum())
1378 }
1379
1380 #[must_use]
1382 #[allow(clippy::field_reassign_with_default)]
1383 pub fn decision_summary(&self) -> DecisionSummary {
1384 let mut summary = DecisionSummary::default();
1385 summary.decision_count = self.logs.len();
1386 summary.last_applied = self.last_applied;
1387 summary.regime = self.regime;
1388
1389 for entry in &self.logs {
1390 match entry.action {
1391 "apply" | "apply_forced" | "apply_immediate" => {
1392 summary.apply_count += 1;
1393 if entry.forced {
1394 summary.forced_apply_count += 1;
1395 }
1396 }
1397 "coalesce" => summary.coalesce_count += 1,
1398 "skip_same_size" => summary.skip_count += 1,
1399 _ => {}
1400 }
1401 }
1402
1403 summary.checksum = self.decision_checksum();
1404 summary
1405 }
1406
1407 #[must_use]
1409 pub fn evidence_to_jsonl(&self) -> String {
1410 let mut lines = Vec::with_capacity(self.logs.len() + self.transition_logs.len() + 2);
1411 let (cols, rows) = self.last_applied;
1412 let run_id = self.evidence_run_id.as_str();
1413 let screen_mode = self.evidence_screen_mode;
1414 let summary_event_idx = self
1415 .logs
1416 .last()
1417 .map(|entry| entry.event_idx)
1418 .or_else(|| self.transition_logs.last().map(|entry| entry.event_idx))
1419 .unwrap_or(0);
1420 lines.push(self.config.to_jsonl(run_id, screen_mode, cols, rows, 0));
1421 lines.extend(
1422 self.logs
1423 .iter()
1424 .map(|entry| entry.to_jsonl(run_id, screen_mode, cols, rows)),
1425 );
1426 lines.extend(
1427 self.transition_logs
1428 .iter()
1429 .map(|entry| entry.to_jsonl(run_id, screen_mode, cols, rows)),
1430 );
1431 lines.push(self.decision_summary().to_jsonl(
1432 run_id,
1433 screen_mode,
1434 cols,
1435 rows,
1436 summary_event_idx,
1437 ));
1438 lines.join("\n")
1439 }
1440
1441 fn apply_pending_at(&mut self, now: Instant, forced: bool) -> CoalesceAction {
1444 let Some((width, height)) = self.pending_size.take() else {
1445 return CoalesceAction::None;
1446 };
1447
1448 let coalesce_time = self
1449 .window_start
1450 .map(|s| duration_since_or_zero(now, s))
1451 .unwrap_or(Duration::ZERO);
1452 let coalesce_ms = coalesce_time.as_secs_f64() * 1000.0;
1453
1454 self.record_cycle_time(coalesce_ms);
1456
1457 self.window_start = None;
1458 self.last_applied = (width, height);
1459 self.last_render = now;
1460
1461 self.events_in_window = 0;
1463
1464 self.log_decision(
1465 now,
1466 if forced { "apply_forced" } else { "apply" },
1467 forced,
1468 None,
1469 Some(coalesce_ms),
1470 );
1471
1472 if let Some(ref hooks) = self.telemetry_hooks
1474 && let Some(entry) = self.logs.last()
1475 {
1476 hooks.fire_resize_applied(entry);
1477 }
1478
1479 CoalesceAction::ApplyResize {
1480 width,
1481 height,
1482 coalesce_time,
1483 forced_by_deadline: forced,
1484 }
1485 }
1486
1487 #[inline]
1488 fn current_delay_ms(&self) -> u64 {
1489 match (&self.bocpd, self.last_detector) {
1490 (Some(bocpd), RegimeDetector::Bocpd) => {
1491 bocpd.recommended_delay(self.config.steady_delay_ms, self.config.burst_delay_ms)
1492 }
1493 _ => match self.regime {
1494 Regime::Steady => self.config.steady_delay_ms,
1495 Regime::Burst => self.config.burst_delay_ms,
1496 },
1497 }
1498 }
1499
1500 #[inline]
1503 fn heuristic_decides(&self) -> bool {
1504 self.bocpd.is_none() || self.last_detector == RegimeDetector::Heuristic
1505 }
1506
1507 fn bocpd_idle_exit(&self, now: Instant) -> Option<(f64, f64, f64)> {
1512 let bocpd = self.bocpd.as_ref()?;
1513 let last_event = self.last_event?;
1514 let idle_ms = duration_since_or_zero(now, last_event).as_secs_f64() * 1000.0;
1515 let cfg = bocpd.config();
1516 if idle_ms < cfg.mu_steady_ms {
1517 return None;
1518 }
1519 let confidence =
1520 (1.0 - (-idle_ms / cfg.mu_burst_ms.max(f64::EPSILON)).exp()).clamp(0.0, 1.0);
1521 Some((confidence, self.calculate_event_rate(now), bocpd.p_burst()))
1522 }
1523
1524 fn select_detector(&self, observation_ms: Option<f64>) -> RegimeDetector {
1527 let Some(bocpd) = self.bocpd.as_ref() else {
1528 return RegimeDetector::Heuristic;
1529 };
1530 if !self.config.heuristic_fallback {
1531 return RegimeDetector::Bocpd;
1532 }
1533 let cfg = bocpd.config();
1534 match observation_ms {
1535 None => RegimeDetector::Heuristic,
1536 Some(obs) if !obs.is_finite() => RegimeDetector::Heuristic,
1537 Some(obs) if obs < cfg.min_observation_ms || obs > cfg.max_observation_ms => {
1538 RegimeDetector::Heuristic
1539 }
1540 Some(_) => RegimeDetector::Bocpd,
1541 }
1542 }
1543
1544 fn update_regime(&mut self, now: Instant) {
1545 let observation_ms = self
1548 .last_event
1549 .map(|t| duration_since_or_zero(now, t).as_secs_f64() * 1000.0);
1550 let mut detector = self.select_detector(observation_ms);
1551
1552 let posterior = self.bocpd.as_mut().map(|bocpd| {
1555 bocpd.observe_event(now);
1556 (bocpd.regime(), bocpd.p_burst())
1557 });
1558 if self.config.heuristic_fallback
1559 && let Some((_, p_burst)) = posterior
1560 && !p_burst.is_finite()
1561 {
1562 detector = RegimeDetector::Heuristic;
1563 }
1564
1565 if detector != self.last_detector {
1566 tracing::debug!(
1567 target: crate::telemetry_schema::TARGET_RESIZE,
1568 from = self.last_detector.as_str(),
1569 to = detector.as_str(),
1570 observation_ms = ?observation_ms,
1571 event_idx = self.event_count,
1572 "resize regime detector switched"
1573 );
1574 }
1575 self.last_detector = detector;
1576
1577 match detector {
1578 RegimeDetector::Bocpd => {
1579 self.detector_decisions.bocpd += 1;
1580 let Some((bocpd_regime, p_burst)) = posterior else {
1581 return;
1582 };
1583 let proposed = match bocpd_regime {
1585 BocpdRegime::Steady => Regime::Steady,
1586 BocpdRegime::Burst => Regime::Burst,
1587 BocpdRegime::Transitional => self.regime,
1589 };
1590 if proposed != self.regime {
1591 let (reason_code, confidence) = if proposed == Regime::Burst {
1592 (
1593 TransitionReasonCode::BocpdPosteriorBurst,
1594 p_burst.clamp(0.0, 1.0),
1595 )
1596 } else {
1597 (
1598 TransitionReasonCode::BocpdPosteriorSteady,
1599 (1.0 - p_burst).clamp(0.0, 1.0),
1600 )
1601 };
1602 let rate = self.calculate_event_rate(now);
1603 self.record_regime_transition(
1604 now,
1605 proposed,
1606 reason_code,
1607 confidence,
1608 rate,
1609 Some(p_burst),
1610 );
1611 }
1612 }
1613 RegimeDetector::Heuristic => {
1614 self.detector_decisions.heuristic += 1;
1615 let rate = self.calculate_event_rate(now);
1616 let p_burst = posterior.map(|(_, p)| p).filter(|p| p.is_finite());
1617
1618 match self.regime {
1619 Regime::Steady => {
1620 if rate >= self.config.burst_enter_rate {
1621 self.cooldown_remaining = self.config.cooldown_frames.max(1);
1622 let confidence = (rate / self.config.burst_enter_rate).clamp(0.0, 1.0);
1623 self.record_regime_transition(
1624 now,
1625 Regime::Burst,
1626 TransitionReasonCode::HeuristicEnterBurstRate,
1627 confidence,
1628 rate,
1629 p_burst,
1630 );
1631 }
1632 }
1633 Regime::Burst => {
1634 if rate >= self.config.burst_exit_rate {
1635 self.cooldown_remaining = self.config.cooldown_frames.max(1);
1636 }
1637 }
1638 }
1639 }
1640 }
1641 }
1642
1643 fn record_regime_transition(
1644 &mut self,
1645 now: Instant,
1646 to_regime: Regime,
1647 reason_code: TransitionReasonCode,
1648 confidence: f64,
1649 event_rate: f64,
1650 p_burst: Option<f64>,
1651 ) {
1652 let from_regime = self.regime;
1653 if from_regime == to_regime {
1654 return;
1655 }
1656 self.regime = to_regime;
1657 self.regime_transitions += 1;
1658 self.pending_transition_evidence = Some(PendingTransitionEvidence {
1659 reason_code,
1660 confidence,
1661 });
1662 self.push_transition_log(RegimeTransitionLog {
1663 timestamp: now,
1664 event_idx: self.event_count,
1665 from_regime,
1666 to_regime,
1667 reason_code,
1668 confidence,
1669 event_rate,
1670 p_burst,
1671 cooldown_remaining: self.cooldown_remaining,
1672 detector: self.last_detector,
1673 });
1674 if let Some(ref hooks) = self.telemetry_hooks {
1675 hooks.fire_regime_change(from_regime, to_regime);
1676 }
1677
1678 if let Some(ref sink) = self.evidence_sink {
1679 let (cols, rows) = self.last_applied;
1680 let run_id = self.evidence_run_id.as_str();
1681 let screen_mode = self.evidence_screen_mode;
1682 if !self.config_logged {
1683 let _ = sink.write_jsonl(&self.config.to_jsonl(run_id, screen_mode, cols, rows, 0));
1684 self.config_logged = true;
1685 }
1686 if let Some(entry) = self.transition_logs.last() {
1687 let _ = sink.write_jsonl(&entry.to_jsonl(run_id, screen_mode, cols, rows));
1688 }
1689 }
1690 }
1691
1692 fn calculate_event_rate(&self, now: Instant) -> f64 {
1693 if self.event_times.len() < 2 {
1694 return 0.0;
1695 }
1696
1697 let first = *self
1698 .event_times
1699 .front()
1700 .expect("event_times has >=2 elements per length guard");
1701 let window_duration = match now.checked_duration_since(first) {
1702 Some(duration) => duration,
1703 None => return 0.0,
1704 };
1705
1706 let duration_secs = window_duration.as_secs_f64().max(0.001);
1709
1710 ((self.event_times.len() - 1) as f64) / duration_secs
1712 }
1713
1714 fn log_decision(
1715 &mut self,
1716 now: Instant,
1717 action: &'static str,
1718 forced: bool,
1719 dt_ms_override: Option<f64>,
1720 coalesce_ms: Option<f64>,
1721 ) {
1722 if !self.config.enable_logging {
1723 return;
1724 }
1725
1726 if self.log_start.is_none() {
1727 self.log_start = Some(now);
1728 }
1729
1730 let elapsed_ms = self
1731 .log_start
1732 .map(|t| duration_since_or_zero(now, t).as_secs_f64() * 1000.0)
1733 .unwrap_or(0.0);
1734
1735 let dt_ms = dt_ms_override
1736 .or_else(|| {
1737 self.last_event
1738 .map(|t| duration_since_or_zero(now, t).as_secs_f64() * 1000.0)
1739 })
1740 .unwrap_or(0.0);
1741
1742 let time_since_render_ms =
1743 duration_since_or_zero(now, self.last_render).as_secs_f64() * 1000.0;
1744
1745 let applied_size =
1746 if action == "apply" || action == "apply_forced" || action == "apply_immediate" {
1747 Some(self.last_applied)
1748 } else {
1749 None
1750 };
1751 let (transition_reason_code, transition_confidence) =
1752 match self.pending_transition_evidence.take() {
1753 Some(ev) => (Some(ev.reason_code), Some(ev.confidence)),
1754 None => (None, None),
1755 };
1756
1757 self.logs.push(DecisionLog {
1758 timestamp: now,
1759 elapsed_ms,
1760 event_idx: self.event_count,
1761 dt_ms,
1762 event_rate: self.calculate_event_rate(now),
1763 regime: self.regime,
1764 action,
1765 pending_size: self.pending_size,
1766 applied_size,
1767 time_since_render_ms,
1768 coalesce_ms,
1769 forced,
1770 transition_reason_code,
1771 transition_confidence,
1772 detector: self.last_detector,
1773 p_burst: self.bocpd_p_burst().filter(|p| p.is_finite()),
1774 });
1775
1776 if let Some(ref sink) = self.evidence_sink {
1777 let (cols, rows) = self.last_applied;
1778 let run_id = self.evidence_run_id.as_str();
1779 let screen_mode = self.evidence_screen_mode;
1780 if !self.config_logged {
1781 let _ = sink.write_jsonl(&self.config.to_jsonl(run_id, screen_mode, cols, rows, 0));
1782 self.config_logged = true;
1783 }
1784 if let Some(entry) = self.logs.last() {
1785 let _ = sink.write_jsonl(&entry.to_jsonl(run_id, screen_mode, cols, rows));
1786 }
1787 if let Some(ref bocpd) = self.bocpd
1788 && let Some(jsonl) = bocpd.decision_log_jsonl(
1789 self.config.steady_delay_ms,
1790 self.config.burst_delay_ms,
1791 forced,
1792 )
1793 {
1794 let _ = sink.write_jsonl(&jsonl);
1795 }
1796 }
1797 }
1798}
1799
1800#[derive(Debug, Clone)]
1802pub struct CoalescerStats {
1803 pub event_count: u64,
1805 pub regime: Regime,
1807 pub event_rate: f64,
1809 pub has_pending: bool,
1811 pub last_applied: (u16, u16),
1813 pub detector: RegimeDetector,
1815 pub detector_decisions: DetectorDecisions,
1817}
1818
1819#[derive(Debug, Clone, Default)]
1821pub struct DecisionSummary {
1822 pub decision_count: usize,
1824 pub apply_count: usize,
1826 pub forced_apply_count: usize,
1828 pub coalesce_count: usize,
1830 pub skip_count: usize,
1832 pub regime: Regime,
1834 pub last_applied: (u16, u16),
1836 pub checksum: u64,
1838}
1839
1840impl DecisionSummary {
1841 #[must_use]
1843 pub fn checksum_hex(&self) -> String {
1844 format!("{:016x}", self.checksum)
1845 }
1846
1847 #[must_use]
1849 pub fn to_jsonl(
1850 &self,
1851 run_id: &str,
1852 screen_mode: ScreenMode,
1853 cols: u16,
1854 rows: u16,
1855 event_idx: u64,
1856 ) -> String {
1857 let prefix = evidence_prefix(run_id, screen_mode, cols, rows, event_idx);
1858 format!(
1859 r#"{{{prefix},"event":"summary","decisions":{},"applies":{},"forced_applies":{},"coalesces":{},"skips":{},"regime":"{}","last_w":{},"last_h":{},"checksum":"{}"}}"#,
1860 self.decision_count,
1861 self.apply_count,
1862 self.forced_apply_count,
1863 self.coalesce_count,
1864 self.skip_count,
1865 self.regime.as_str(),
1866 self.last_applied.0,
1867 self.last_applied.1,
1868 self.checksum_hex()
1869 )
1870 }
1871}
1872
1873pub type OnResizeApplied = Box<dyn Fn(&DecisionLog) + Send + Sync>;
1879pub type OnRegimeChange = Box<dyn Fn(Regime, Regime) + Send + Sync>;
1881pub type OnCoalesceDecision = Box<dyn Fn(&DecisionLog) + Send + Sync>;
1883
1884pub struct TelemetryHooks {
1899 on_resize_applied: Option<OnResizeApplied>,
1901 on_regime_change: Option<OnRegimeChange>,
1903 on_decision: Option<OnCoalesceDecision>,
1905 emit_tracing: bool,
1907}
1908
1909impl Default for TelemetryHooks {
1910 fn default() -> Self {
1911 Self::new()
1912 }
1913}
1914
1915impl std::fmt::Debug for TelemetryHooks {
1916 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1917 f.debug_struct("TelemetryHooks")
1918 .field("on_resize_applied", &self.on_resize_applied.is_some())
1919 .field("on_regime_change", &self.on_regime_change.is_some())
1920 .field("on_decision", &self.on_decision.is_some())
1921 .field("emit_tracing", &self.emit_tracing)
1922 .finish()
1923 }
1924}
1925
1926impl TelemetryHooks {
1927 #[must_use]
1929 pub fn new() -> Self {
1930 Self {
1931 on_resize_applied: None,
1932 on_regime_change: None,
1933 on_decision: None,
1934 emit_tracing: false,
1935 }
1936 }
1937
1938 #[must_use]
1940 pub fn on_resize_applied<F>(mut self, callback: F) -> Self
1941 where
1942 F: Fn(&DecisionLog) + Send + Sync + 'static,
1943 {
1944 self.on_resize_applied = Some(Box::new(callback));
1945 self
1946 }
1947
1948 #[must_use]
1950 pub fn on_regime_change<F>(mut self, callback: F) -> Self
1951 where
1952 F: Fn(Regime, Regime) + Send + Sync + 'static,
1953 {
1954 self.on_regime_change = Some(Box::new(callback));
1955 self
1956 }
1957
1958 #[must_use]
1960 pub fn on_decision<F>(mut self, callback: F) -> Self
1961 where
1962 F: Fn(&DecisionLog) + Send + Sync + 'static,
1963 {
1964 self.on_decision = Some(Box::new(callback));
1965 self
1966 }
1967
1968 #[must_use]
1973 pub fn with_tracing(mut self, enabled: bool) -> Self {
1974 self.emit_tracing = enabled;
1975 self
1976 }
1977
1978 pub fn has_resize_applied(&self) -> bool {
1980 self.on_resize_applied.is_some()
1981 }
1982
1983 pub fn has_regime_change(&self) -> bool {
1985 self.on_regime_change.is_some()
1986 }
1987
1988 pub fn has_decision(&self) -> bool {
1990 self.on_decision.is_some()
1991 }
1992
1993 fn fire_resize_applied(&self, entry: &DecisionLog) {
1995 if let Some(ref cb) = self.on_resize_applied {
1996 cb(entry);
1997 }
1998 if self.emit_tracing {
1999 Self::emit_resize_tracing(entry);
2000 }
2001 }
2002
2003 fn fire_regime_change(&self, from: Regime, to: Regime) {
2005 if let Some(ref cb) = self.on_regime_change {
2006 cb(from, to);
2007 }
2008 if self.emit_tracing {
2009 tracing::debug!(
2010 target: crate::telemetry_schema::TARGET_RESIZE,
2011 from_regime = %from.as_str(),
2012 to_regime = %to.as_str(),
2013 "regime_change"
2014 );
2015 }
2016 }
2017
2018 fn fire_decision(&self, entry: &DecisionLog) {
2020 if let Some(ref cb) = self.on_decision {
2021 cb(entry);
2022 }
2023 }
2024
2025 fn emit_resize_tracing(entry: &DecisionLog) {
2027 let (pending_w, pending_h) = entry.pending_size.unwrap_or((0, 0));
2028 let (applied_w, applied_h) = entry.applied_size.unwrap_or((0, 0));
2029 let coalesce_ms = entry.coalesce_ms.unwrap_or(0.0);
2030
2031 tracing::info!(
2032 target: crate::telemetry_schema::TARGET_RESIZE,
2033 event_idx = entry.event_idx,
2034 elapsed_ms = entry.elapsed_ms,
2035 dt_ms = entry.dt_ms,
2036 event_rate = entry.event_rate,
2037 regime = %entry.regime.as_str(),
2038 action = entry.action,
2039 pending_w = pending_w,
2040 pending_h = pending_h,
2041 applied_w = applied_w,
2042 applied_h = applied_h,
2043 time_since_render_ms = entry.time_since_render_ms,
2044 coalesce_ms = coalesce_ms,
2045 forced = entry.forced,
2046 "resize_decision"
2047 );
2048 }
2049}
2050
2051#[cfg(test)]
2052mod tests {
2053 use super::*;
2054
2055 #[test]
2056 fn retained_diagnostics_are_bounded() {
2057 let mut c = ResizeCoalescer::new(test_config(), (80, 24));
2058 for i in 0..(MAX_CYCLE_TIME_SAMPLES + 500) {
2059 c.record_cycle_time(i as f64);
2060 }
2061 assert_eq!(c.cycle_times.len(), MAX_CYCLE_TIME_SAMPLES);
2062 assert_eq!(c.cycle_times[0], 500.0);
2064 assert!(c.cycle_time_percentiles().is_some());
2066
2067 let now = Instant::now();
2068 for i in 0..(MAX_TRANSITION_LOGS + 100) {
2069 c.push_transition_log(RegimeTransitionLog {
2070 timestamp: now,
2071 event_idx: i as u64,
2072 from_regime: Regime::Steady,
2073 to_regime: Regime::Burst,
2074 reason_code: TransitionReasonCode::HeuristicEnterBurstRate,
2075 confidence: 1.0,
2076 event_rate: 0.0,
2077 p_burst: None,
2078 cooldown_remaining: 0,
2079 detector: RegimeDetector::Heuristic,
2080 });
2081 }
2082 assert_eq!(c.transition_logs.len(), MAX_TRANSITION_LOGS);
2083 assert_eq!(c.transition_logs[0].event_idx, 100);
2084 }
2085
2086 fn test_config() -> CoalescerConfig {
2087 CoalescerConfig {
2088 steady_delay_ms: 16,
2089 burst_delay_ms: 40,
2090 hard_deadline_ms: 100,
2091 burst_enter_rate: 10.0,
2092 burst_exit_rate: 5.0,
2093 cooldown_frames: 3,
2094 rate_window_size: 8,
2095 enable_logging: true,
2096 enable_bocpd: false,
2097 heuristic_fallback: true,
2098 bocpd_config: None,
2099 }
2100 }
2101
2102 #[derive(Debug, Clone, Copy)]
2103 struct SimulationMetrics {
2104 event_count: u64,
2105 apply_count: u64,
2106 forced_count: u64,
2107 mean_coalesce_ms: f64,
2108 max_coalesce_ms: f64,
2109 decision_checksum: u64,
2110 final_regime: Regime,
2111 }
2112
2113 impl SimulationMetrics {
2114 fn to_jsonl(self, pattern: &str, mode: &str) -> String {
2115 let pattern = json_escape(pattern);
2116 let mode = json_escape(mode);
2117 let apply_ratio = if self.event_count == 0 {
2118 0.0
2119 } else {
2120 self.apply_count as f64 / self.event_count as f64
2121 };
2122
2123 format!(
2124 r#"{{"event":"simulation_summary","pattern":"{pattern}","mode":"{mode}","events":{},"applies":{},"forced":{},"apply_ratio":{:.4},"mean_coalesce_ms":{:.3},"max_coalesce_ms":{:.3},"final_regime":"{}","checksum":"{:016x}"}}"#,
2125 self.event_count,
2126 self.apply_count,
2127 self.forced_count,
2128 apply_ratio,
2129 self.mean_coalesce_ms,
2130 self.max_coalesce_ms,
2131 self.final_regime.as_str(),
2132 self.decision_checksum
2133 )
2134 }
2135 }
2136
2137 #[derive(Debug, Clone, Copy)]
2138 struct SimulationComparison {
2139 apply_delta: i64,
2140 mean_coalesce_delta_ms: f64,
2141 }
2142
2143 impl SimulationComparison {
2144 fn from_metrics(heuristic: SimulationMetrics, bocpd: SimulationMetrics) -> Self {
2145 let heuristic_apply = i64::try_from(heuristic.apply_count).unwrap_or(i64::MAX);
2146 let bocpd_apply = i64::try_from(bocpd.apply_count).unwrap_or(i64::MAX);
2147 let apply_delta = heuristic_apply.saturating_sub(bocpd_apply);
2148 let mean_coalesce_delta_ms = heuristic.mean_coalesce_ms - bocpd.mean_coalesce_ms;
2149 Self {
2150 apply_delta,
2151 mean_coalesce_delta_ms,
2152 }
2153 }
2154
2155 fn to_jsonl(self, pattern: &str) -> String {
2156 let pattern = json_escape(pattern);
2157 format!(
2158 r#"{{"event":"simulation_compare","pattern":"{pattern}","apply_delta":{},"mean_coalesce_delta_ms":{:.3}}}"#,
2159 self.apply_delta, self.mean_coalesce_delta_ms
2160 )
2161 }
2162 }
2163
2164 fn as_u64(value: usize) -> u64 {
2165 u64::try_from(value).unwrap_or(u64::MAX)
2166 }
2167
2168 fn build_schedule(base: Instant, events: &[(u16, u16, u64)]) -> Vec<(Instant, u16, u16)> {
2169 let mut schedule = Vec::with_capacity(events.len());
2170 let mut elapsed_ms = 0u64;
2171 for (w, h, delay_ms) in events {
2172 elapsed_ms = elapsed_ms.saturating_add(*delay_ms);
2173 schedule.push((base + Duration::from_millis(elapsed_ms), *w, *h));
2174 }
2175 schedule
2176 }
2177
2178 fn run_simulation(
2179 events: &[(u16, u16, u64)],
2180 config: CoalescerConfig,
2181 tick_ms: u64,
2182 ) -> SimulationMetrics {
2183 let mut c = ResizeCoalescer::new(config, (80, 24));
2184 let base = Instant::now();
2185 let schedule = build_schedule(base, events);
2186 let last_event_ms = schedule
2187 .last()
2188 .map(|(time, _, _)| {
2189 u64::try_from(duration_since_or_zero(*time, base).as_millis()).unwrap_or(u64::MAX)
2190 })
2191 .unwrap_or(0);
2192 let end_ms = last_event_ms
2193 .saturating_add(c.config.hard_deadline_ms)
2194 .saturating_add(tick_ms);
2195
2196 let mut next_idx = 0usize;
2197 let mut now_ms = 0u64;
2198 while now_ms <= end_ms {
2199 let now = base + Duration::from_millis(now_ms);
2200
2201 while next_idx < schedule.len() && schedule[next_idx].0 <= now {
2202 let (event_time, w, h) = schedule[next_idx];
2203 let _ = c.handle_resize_at(w, h, event_time);
2204 next_idx += 1;
2205 }
2206
2207 let _ = c.tick_at(now);
2208 now_ms = now_ms.saturating_add(tick_ms);
2209 }
2210
2211 let mut coalesce_values = Vec::new();
2212 let mut apply_count = 0usize;
2213 let mut forced_count = 0usize;
2214 for entry in c.logs() {
2215 if matches!(entry.action, "apply" | "apply_forced" | "apply_immediate") {
2216 apply_count += 1;
2217 if entry.forced {
2218 forced_count += 1;
2219 }
2220 if let Some(ms) = entry.coalesce_ms {
2221 coalesce_values.push(ms);
2222 }
2223 }
2224 }
2225
2226 let max_coalesce_ms = coalesce_values
2227 .iter()
2228 .copied()
2229 .fold(0.0_f64, |acc, value| acc.max(value));
2230 let mean_coalesce_ms = if coalesce_values.is_empty() {
2231 0.0
2232 } else {
2233 let sum = coalesce_values.iter().sum::<f64>();
2234 sum / as_u64(coalesce_values.len()) as f64
2235 };
2236
2237 SimulationMetrics {
2238 event_count: as_u64(events.len()),
2239 apply_count: as_u64(apply_count),
2240 forced_count: as_u64(forced_count),
2241 mean_coalesce_ms,
2242 max_coalesce_ms,
2243 decision_checksum: c.decision_checksum(),
2244 final_regime: c.regime(),
2245 }
2246 }
2247
2248 fn steady_pattern() -> Vec<(u16, u16, u64)> {
2249 let mut events = Vec::new();
2250 for i in 0..8u16 {
2251 let width = 90 + i;
2252 let height = 30 + (i % 3);
2253 events.push((width, height, 300));
2254 }
2255 events
2256 }
2257
2258 fn burst_pattern() -> Vec<(u16, u16, u64)> {
2259 let mut events = Vec::new();
2260 for i in 0..30u16 {
2261 let width = 100 + i;
2262 let height = 25 + (i % 5);
2263 events.push((width, height, 10));
2264 }
2265 events
2266 }
2267
2268 fn oscillatory_pattern() -> Vec<(u16, u16, u64)> {
2269 let mut events = Vec::new();
2270 let sizes = [(120, 40), (140, 28), (130, 36), (150, 32)];
2271 let delays = [40u64, 200u64, 60u64, 180u64];
2272 for i in 0..16usize {
2273 let (w, h) = sizes[i % sizes.len()];
2274 let delay = delays[i % delays.len()];
2275 events.push((w + (i as u16 % 3), h, delay));
2276 }
2277 events
2278 }
2279
2280 #[test]
2281 fn new_coalescer_starts_in_steady() {
2282 let c = ResizeCoalescer::new(CoalescerConfig::default(), (80, 24));
2283 assert_eq!(c.regime(), Regime::Steady);
2284 assert!(!c.has_pending());
2285 }
2286
2287 #[test]
2288 fn same_size_returns_none() {
2289 let mut c = ResizeCoalescer::new(test_config(), (80, 24));
2290 let action = c.handle_resize(80, 24);
2291 assert_eq!(action, CoalesceAction::None);
2292 }
2293
2294 #[test]
2295 fn different_size_coalesces_with_no_action_and_a_pending_size() {
2296 let mut c = ResizeCoalescer::new(test_config(), (80, 24));
2297 let action = c.handle_resize(100, 40);
2298 assert_eq!(action, CoalesceAction::None);
2299 assert!(c.has_pending(), "the size is held until the delay elapses");
2300 }
2301
2302 #[test]
2303 fn latest_wins_semantics() {
2304 let config = test_config();
2305 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2306
2307 let base = Instant::now();
2308
2309 c.handle_resize_at(90, 30, base);
2311 c.handle_resize_at(100, 40, base + Duration::from_millis(5));
2312 c.handle_resize_at(110, 50, base + Duration::from_millis(10));
2313
2314 let action = c.tick_at(base + Duration::from_millis(60));
2316
2317 let (width, height) = if let CoalesceAction::ApplyResize { width, height, .. } = action {
2318 (width, height)
2319 } else {
2320 assert!(
2321 matches!(action, CoalesceAction::ApplyResize { .. }),
2322 "Expected ApplyResize, got {action:?}"
2323 );
2324 return;
2325 };
2326 assert_eq!((width, height), (110, 50), "Should apply latest size");
2327 }
2328
2329 #[test]
2330 fn hard_deadline_forces_apply() {
2331 let config = test_config();
2332 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2333
2334 let base = Instant::now();
2335
2336 c.handle_resize_at(100, 40, base);
2338
2339 let action = c.tick_at(base + Duration::from_millis(150));
2341
2342 let forced_by_deadline = if let CoalesceAction::ApplyResize {
2343 forced_by_deadline, ..
2344 } = action
2345 {
2346 forced_by_deadline
2347 } else {
2348 assert!(
2349 matches!(action, CoalesceAction::ApplyResize { .. }),
2350 "Expected ApplyResize, got {action:?}"
2351 );
2352 return;
2353 };
2354 assert!(forced_by_deadline, "Should be forced by deadline");
2355 }
2356
2357 #[test]
2361 fn isolated_resize_after_quiet_gap_is_not_forced() {
2362 let config = test_config();
2363 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2364
2365 let base = Instant::now();
2366 let action = c.handle_resize_at(120, 40, base + Duration::from_millis(500));
2367
2368 match action {
2369 CoalesceAction::ApplyResize {
2370 forced_by_deadline, ..
2371 } => {
2372 assert!(
2373 !forced_by_deadline,
2374 "quiet-gap instant apply must not count as forced"
2375 );
2376 }
2377 other => panic!("Expected ApplyResize, got {other:?}"),
2378 }
2379 }
2380
2381 #[test]
2385 fn resize_arriving_while_pending_past_deadline_stays_forced() {
2386 let config = test_config();
2387 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2388
2389 let base = Instant::now();
2390 c.handle_resize_at(90, 30, base);
2392
2393 let action = c.handle_resize_at(120, 40, base + Duration::from_millis(500));
2396
2397 match action {
2398 CoalesceAction::ApplyResize {
2399 forced_by_deadline, ..
2400 } => {
2401 assert!(
2402 forced_by_deadline,
2403 "deadline breach of WAITING work must stay forced"
2404 );
2405 }
2406 other => panic!("Expected ApplyResize, got {other:?}"),
2407 }
2408 }
2409
2410 #[test]
2411 fn burst_mode_detection() {
2412 let config = test_config();
2413 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2414
2415 let base = Instant::now();
2416
2417 for i in 0..15 {
2419 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 10));
2420 }
2421
2422 assert_eq!(c.regime(), Regime::Burst);
2423 }
2424
2425 #[test]
2426 fn steady_mode_fast_response() {
2427 let config = test_config();
2428 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2429
2430 let base = Instant::now();
2431
2432 c.handle_resize_at(100, 40, base);
2434
2435 let action = c.tick_at(base + Duration::from_millis(20));
2437
2438 assert!(matches!(action, CoalesceAction::ApplyResize { .. }));
2439 }
2440
2441 #[test]
2442 fn record_external_apply_updates_state_and_logs() {
2443 let config = test_config();
2444 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2445
2446 let base = Instant::now();
2447 c.handle_resize_at(100, 40, base);
2448 c.record_external_apply(120, 50, base + Duration::from_millis(5));
2449
2450 assert!(!c.has_pending());
2451 assert_eq!(c.last_applied(), (120, 50));
2452
2453 let summary = c.decision_summary();
2454 assert_eq!(summary.apply_count, 1);
2455 assert_eq!(summary.last_applied, (120, 50));
2456 assert!(
2457 c.logs()
2458 .iter()
2459 .any(|entry| entry.action == "apply_immediate"),
2460 "record_external_apply should emit apply_immediate decision"
2461 );
2462 }
2463
2464 #[test]
2465 fn coalesce_time_tracked() {
2466 let config = test_config();
2467 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2468
2469 let base = Instant::now();
2470
2471 c.handle_resize_at(100, 40, base);
2472 let action = c.tick_at(base + Duration::from_millis(50));
2473
2474 let coalesce_time = if let CoalesceAction::ApplyResize { coalesce_time, .. } = action {
2475 coalesce_time
2476 } else {
2477 assert!(
2478 matches!(action, CoalesceAction::ApplyResize { .. }),
2479 "Expected ApplyResize"
2480 );
2481 return;
2482 };
2483 assert!(coalesce_time >= Duration::from_millis(40));
2484 assert!(coalesce_time <= Duration::from_millis(60));
2485 }
2486
2487 #[test]
2488 fn event_rate_calculation() {
2489 let config = test_config();
2490 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2491
2492 let base = Instant::now();
2493
2494 for i in 0..10 {
2496 c.handle_resize_at(80 + i, 24, base + Duration::from_millis(i as u64 * 100));
2497 }
2498
2499 let rate = c.calculate_event_rate(base + Duration::from_millis(1000));
2500 assert!(rate > 8.0 && rate < 12.0, "Rate should be ~10 events/sec");
2501 }
2502
2503 #[test]
2504 fn rapid_burst_triggers_high_rate() {
2505 let config = test_config();
2506 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2507 let base = Instant::now();
2508
2509 for _ in 0..8 {
2511 c.handle_resize_at(80, 24, base);
2512 }
2513
2514 let rate = c.calculate_event_rate(base);
2515 assert!(
2517 rate >= 1000.0,
2518 "Rate should be high for instantaneous burst, got {}",
2519 rate
2520 );
2521 }
2522
2523 #[test]
2524 fn cooldown_prevents_immediate_exit() {
2525 let config = test_config();
2526 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2527
2528 let base = Instant::now();
2529
2530 for i in 0..15 {
2532 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 10));
2533 }
2534 assert_eq!(c.regime(), Regime::Burst);
2535
2536 c.tick_at(base + Duration::from_millis(500));
2538 c.tick_at(base + Duration::from_millis(600));
2539
2540 assert_eq!(c.regime(), Regime::Burst);
2542
2543 for i in 0..6 {
2546 c.tick_at(base + Duration::from_millis(1300 + 100 * i));
2547 }
2548
2549 assert_eq!(c.stats().regime, Regime::Steady);
2553 }
2554
2555 #[test]
2556 fn cooldown_frames_zero_cannot_dead_end_burst() {
2557 let mut c = ResizeCoalescer::new(
2563 CoalescerConfig {
2564 cooldown_frames: 0,
2565 ..Default::default()
2566 },
2567 (80, 24),
2568 );
2569 let base = Instant::now();
2570 for i in 0..10 {
2572 let _ =
2573 c.handle_resize_at(100 + i, 40, base + Duration::from_millis(10 * u64::from(i)));
2574 }
2575 assert_eq!(c.stats().regime, Regime::Burst);
2576 for i in 1..=20 {
2578 c.tick_at(base + Duration::from_millis(100 + 200 * i));
2579 }
2580 assert_eq!(
2581 c.stats().regime,
2582 Regime::Steady,
2583 "Burst must always have an exit path"
2584 );
2585 }
2586
2587 #[test]
2588 fn logging_captures_decisions() {
2589 let mut config = test_config();
2590 config.enable_logging = true;
2591 let mut c = ResizeCoalescer::new(config, (80, 24));
2592
2593 let base = Instant::now();
2594 c.handle_resize_at(100, 40, base);
2595 c.tick_at(base + Duration::from_millis(50));
2596
2597 assert!(!c.logs().is_empty());
2598 assert_eq!(c.logs()[0].action, "coalesce");
2599 }
2600
2601 #[test]
2602 fn logging_jsonl_format() {
2603 let mut config = test_config();
2604 config.enable_logging = true;
2605 let mut c = ResizeCoalescer::new(config, (80, 24));
2606
2607 c.handle_resize_at(100, 40, Instant::now());
2608 c.tick_at(Instant::now() + Duration::from_millis(50));
2609
2610 let (cols, rows) = c.last_applied();
2611 let jsonl = c.logs()[0].to_jsonl("resize-test", ScreenMode::AltScreen, cols, rows);
2612
2613 assert!(jsonl.contains("\"event\":\"decision\""));
2614 assert!(jsonl.contains("\"action\":\"coalesce\""));
2615 assert!(jsonl.contains("\"regime\":\"steady\""));
2616 assert!(jsonl.contains("\"pending_w\":100"));
2617 assert!(jsonl.contains("\"pending_h\":40"));
2618 }
2619
2620 #[test]
2621 fn apply_logs_coalesce_ms() {
2622 let mut config = test_config();
2623 config.enable_logging = true;
2624 let mut c = ResizeCoalescer::new(config, (80, 24));
2625
2626 let base = Instant::now();
2627 c.handle_resize_at(100, 40, base);
2628 let action = c.tick_at(base + Duration::from_millis(50));
2629 assert!(matches!(action, CoalesceAction::ApplyResize { .. }));
2630
2631 let last = c.logs().last().expect("Expected a decision log entry");
2632 assert!(last.coalesce_ms.is_some());
2633 assert!(last.coalesce_ms.unwrap() >= 0.0);
2634 }
2635
2636 #[test]
2637 fn decision_checksum_is_stable() {
2638 let mut config = test_config();
2639 config.enable_logging = true;
2640
2641 let base = Instant::now();
2642 let mut c1 = ResizeCoalescer::new(config.clone(), (80, 24)).with_last_render(base);
2643 let mut c2 = ResizeCoalescer::new(config, (80, 24)).with_last_render(base);
2644
2645 for c in [&mut c1, &mut c2] {
2646 c.handle_resize_at(90, 30, base);
2647 c.handle_resize_at(100, 40, base + Duration::from_millis(10));
2648 let _ = c.tick_at(base + Duration::from_millis(80));
2649 }
2650
2651 assert_eq!(c1.decision_checksum(), c2.decision_checksum());
2652 }
2653
2654 #[test]
2655 fn evidence_jsonl_includes_summary() {
2656 let mut config = test_config();
2657 config.enable_logging = true;
2658 let mut c = ResizeCoalescer::new(config, (80, 24));
2659
2660 c.handle_resize_at(100, 40, Instant::now());
2661 c.tick_at(Instant::now() + Duration::from_millis(50));
2662
2663 let jsonl = c.evidence_to_jsonl();
2664
2665 assert!(jsonl.contains("\"event\":\"config\""));
2666 assert!(jsonl.contains("\"event\":\"summary\""));
2667 }
2668
2669 #[test]
2670 fn evidence_jsonl_parses_and_has_required_fields() {
2671 use serde_json::Value;
2672
2673 let mut config = test_config();
2674 config.enable_logging = true;
2675 let base = Instant::now();
2676 let mut c = ResizeCoalescer::new(config, (80, 24))
2677 .with_last_render(base)
2678 .with_evidence_run_id("resize-test")
2679 .with_screen_mode(ScreenMode::AltScreen);
2680
2681 c.handle_resize_at(90, 30, base);
2682 c.handle_resize_at(100, 40, base + Duration::from_millis(10));
2683 let _ = c.tick_at(base + Duration::from_millis(120));
2684
2685 let jsonl = c.evidence_to_jsonl();
2686 let mut saw_config = false;
2687 let mut saw_decision = false;
2688 let mut saw_summary = false;
2689
2690 for line in jsonl.lines() {
2691 let value: Value = serde_json::from_str(line).expect("valid JSONL evidence");
2692 let event = value
2693 .get("event")
2694 .and_then(Value::as_str)
2695 .expect("event field");
2696 assert_eq!(value["schema_version"], EVIDENCE_SCHEMA_VERSION);
2697 assert_eq!(value["run_id"], "resize-test");
2698 assert!(
2699 value["event_idx"].is_number(),
2700 "event_idx should be numeric"
2701 );
2702 assert_eq!(value["screen_mode"], "altscreen");
2703 assert!(value["cols"].is_number(), "cols should be numeric");
2704 assert!(value["rows"].is_number(), "rows should be numeric");
2705 match event {
2706 "config" => {
2707 for key in [
2708 "steady_delay_ms",
2709 "burst_delay_ms",
2710 "hard_deadline_ms",
2711 "burst_enter_rate",
2712 "burst_exit_rate",
2713 "cooldown_frames",
2714 "rate_window_size",
2715 "logging_enabled",
2716 ] {
2717 assert!(value.get(key).is_some(), "missing config field {key}");
2718 }
2719 saw_config = true;
2720 }
2721 "decision" => {
2722 for key in [
2723 "idx",
2724 "elapsed_ms",
2725 "dt_ms",
2726 "event_rate",
2727 "regime",
2728 "action",
2729 "pending_w",
2730 "pending_h",
2731 "applied_w",
2732 "applied_h",
2733 "time_since_render_ms",
2734 "coalesce_ms",
2735 "forced",
2736 "transition_reason_code",
2737 "transition_confidence",
2738 ] {
2739 assert!(value.get(key).is_some(), "missing decision field {key}");
2740 }
2741 saw_decision = true;
2742 }
2743 "summary" => {
2744 for key in [
2745 "decisions",
2746 "applies",
2747 "forced_applies",
2748 "coalesces",
2749 "skips",
2750 "regime",
2751 "last_w",
2752 "last_h",
2753 "checksum",
2754 ] {
2755 assert!(value.get(key).is_some(), "missing summary field {key}");
2756 }
2757 saw_summary = true;
2758 }
2759 _ => {}
2760 }
2761 }
2762
2763 assert!(saw_config, "config evidence missing");
2764 assert!(saw_decision, "decision evidence missing");
2765 assert!(saw_summary, "summary evidence missing");
2766 }
2767
2768 #[test]
2769 fn evidence_jsonl_is_deterministic_for_fixed_schedule() {
2770 let mut config = test_config();
2771 config.enable_logging = true;
2772 let base = Instant::now();
2773
2774 let run = || {
2775 let mut c = ResizeCoalescer::new(config.clone(), (80, 24))
2776 .with_last_render(base)
2777 .with_evidence_run_id("resize-test")
2778 .with_screen_mode(ScreenMode::AltScreen);
2779 c.handle_resize_at(90, 30, base);
2780 c.handle_resize_at(100, 40, base + Duration::from_millis(10));
2781 let _ = c.tick_at(base + Duration::from_millis(120));
2782 c.evidence_to_jsonl()
2783 };
2784
2785 let first = run();
2786 let second = run();
2787 assert_eq!(first, second);
2788 }
2789
2790 #[test]
2791 fn bocpd_logging_inherits_coalescer_logging() {
2792 let mut config = test_config();
2793 config.enable_bocpd = true;
2794 config.bocpd_config = Some(BocpdConfig::default());
2795
2796 let c = ResizeCoalescer::new(config, (80, 24));
2797 let bocpd = c.bocpd().expect("BOCPD should be enabled");
2798 assert!(bocpd.config().enable_logging);
2799 }
2800
2801 #[test]
2802 fn stats_reflect_state() {
2803 let mut c = ResizeCoalescer::new(test_config(), (80, 24));
2804 let base = Instant::now();
2805
2806 c.handle_resize_at(100, 40, base);
2807 let action = c.tick_at(base + Duration::from_millis(5));
2808 assert_eq!(action, CoalesceAction::None);
2809
2810 let stats = c.stats();
2811 assert_eq!(stats.event_count, 1);
2812 assert!(stats.has_pending);
2813 assert_eq!(stats.last_applied, (80, 24));
2814
2815 let action = c.tick_at(base + Duration::from_millis(50));
2816 assert_eq!(
2817 action,
2818 CoalesceAction::ApplyResize {
2819 width: 100,
2820 height: 40,
2821 coalesce_time: Duration::from_millis(50),
2822 forced_by_deadline: false,
2823 }
2824 );
2825
2826 let stats = c.stats();
2827 assert!(!stats.has_pending);
2828 assert_eq!(stats.last_applied, (100, 40));
2829 }
2830
2831 #[test]
2832 fn time_until_apply_calculation() {
2833 let config = test_config();
2834 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2835
2836 let base = Instant::now();
2837 c.handle_resize_at(100, 40, base);
2838
2839 let time_left = c.time_until_apply(base + Duration::from_millis(5));
2840 assert!(time_left.is_some());
2841 let time_left = time_left.unwrap();
2842 assert!(time_left.as_millis() > 0);
2843 assert!(time_left.as_millis() < config.steady_delay_ms as u128);
2844 }
2845
2846 #[test]
2847 fn deterministic_behavior() {
2848 let config = test_config();
2849
2850 let results: Vec<_> = (0..2)
2852 .map(|_| {
2853 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
2854 let base = Instant::now();
2855
2856 for i in 0..5 {
2857 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 20));
2858 }
2859
2860 c.tick_at(base + Duration::from_millis(200))
2861 })
2862 .collect();
2863
2864 assert_eq!(results[0], results[1], "Results must be deterministic");
2865 }
2866
2867 #[test]
2868 fn transition_reason_codes_and_evidence_fields_are_logged() {
2869 let mut config = test_config();
2870 config.enable_logging = true;
2871 config.hard_deadline_ms = 5_000;
2872 config.burst_delay_ms = 50;
2873 let base = Instant::now();
2874 let mut c = ResizeCoalescer::new(config, (80, 24)).with_last_render(base);
2875
2876 for i in 0..12 {
2877 c.handle_resize_at(90 + i, 30, base + Duration::from_millis(i as u64 * 10));
2878 }
2879
2880 let transition = c
2881 .transition_logs()
2882 .first()
2883 .expect("rapid events should trigger a transition");
2884 assert_eq!(transition.from_regime, Regime::Steady);
2885 assert_eq!(transition.to_regime, Regime::Burst);
2886 assert_eq!(
2887 transition.reason_code,
2888 TransitionReasonCode::HeuristicEnterBurstRate
2889 );
2890 assert!(
2891 (0.0..=1.0).contains(&transition.confidence),
2892 "transition confidence should be normalized"
2893 );
2894 assert!(
2895 transition.event_rate >= 0.0,
2896 "event-rate evidence should be included"
2897 );
2898
2899 let decision_with_transition = c
2900 .logs()
2901 .iter()
2902 .find(|entry| entry.transition_reason_code.is_some())
2903 .expect("transition decisions should include reason code/evidence");
2904 assert_eq!(
2905 decision_with_transition.transition_reason_code,
2906 Some(TransitionReasonCode::HeuristicEnterBurstRate)
2907 );
2908 assert!(decision_with_transition.transition_confidence.is_some());
2909
2910 let jsonl = c.evidence_to_jsonl();
2911 assert!(jsonl.contains("\"event\":\"regime_transition\""));
2912 assert!(jsonl.contains("\"reason_code\":\"heuristic_enter_burst_rate\""));
2913 assert!(jsonl.contains("\"transition_reason_code\":"));
2914 }
2915
2916 #[test]
2917 fn regime_transition_sequence_is_deterministic_for_fixed_schedule() {
2918 let config = CoalescerConfig {
2919 burst_enter_rate: 5.0,
2920 burst_exit_rate: 2.0,
2921 cooldown_frames: 3,
2922 rate_window_size: 4,
2923 steady_delay_ms: 10,
2924 burst_delay_ms: 50,
2925 hard_deadline_ms: 5_000,
2926 enable_logging: true,
2927 enable_bocpd: false,
2928 heuristic_fallback: true,
2929 bocpd_config: None,
2930 };
2931 let base = Instant::now();
2932
2933 let run = || {
2934 let mut c = ResizeCoalescer::new(config.clone(), (80, 24)).with_last_render(base);
2935
2936 for i in 0..8u64 {
2938 let t = base + Duration::from_millis(30 * i);
2939 c.handle_resize_at(80 + i as u16, 24 + i as u16, t);
2940 }
2941
2942 let mut t = base + Duration::from_millis(280);
2944 let _ = c.tick_at(t);
2945 for i in 0..5u64 {
2946 t += Duration::from_secs(1);
2947 c.handle_resize_at(100 + i as u16, 30 + i as u16, t);
2948 let _ = c.tick_at(t + Duration::from_millis(60));
2949 }
2950
2951 t += Duration::from_millis(70);
2953 c.handle_resize_at(120, 35, t);
2954 for step in 1..=config.cooldown_frames {
2955 let _ = c.tick_at(t + Duration::from_millis(step as u64 * 5));
2956 }
2957
2958 c.transition_logs()
2959 .iter()
2960 .map(|entry| {
2961 (
2962 entry.from_regime,
2963 entry.to_regime,
2964 entry.reason_code,
2965 entry.event_idx,
2966 entry.cooldown_remaining,
2967 )
2968 })
2969 .collect::<Vec<_>>()
2970 };
2971
2972 let first = run();
2973 let second = run();
2974 assert_eq!(first, second);
2975 assert!(
2976 first.iter().any(|(_, to, reason, _, _)| {
2977 *to == Regime::Burst && *reason == TransitionReasonCode::HeuristicEnterBurstRate
2978 }),
2979 "expected steady->burst transition with heuristic reason"
2980 );
2981 assert!(
2982 first.iter().any(|(_, to, reason, _, _)| {
2983 *to == Regime::Steady && *reason == TransitionReasonCode::HeuristicExitBurstCooldown
2984 }),
2985 "expected burst->steady transition with cooldown reason"
2986 );
2987 }
2988
2989 #[test]
2990 fn bounded_oscillation_and_converges_to_steady() {
2991 let config = CoalescerConfig {
2992 burst_enter_rate: 5.0,
2993 burst_exit_rate: 2.0,
2994 cooldown_frames: 3,
2995 rate_window_size: 4,
2996 steady_delay_ms: 10,
2997 burst_delay_ms: 50,
2998 hard_deadline_ms: 5_000,
2999 enable_logging: true,
3000 enable_bocpd: false,
3001 heuristic_fallback: true,
3002 bocpd_config: None,
3003 };
3004 let base = Instant::now();
3005 let mut c = ResizeCoalescer::new(config.clone(), (80, 24)).with_last_render(base);
3006 let mut t = base;
3007
3008 for cycle in 0..30u64 {
3010 for pulse in 0..6u64 {
3011 t += Duration::from_millis(30);
3012 c.handle_resize_at(80 + ((cycle + pulse) % 40) as u16, 24 + pulse as u16, t);
3013 }
3014 t += Duration::from_millis(70);
3015 let _ = c.tick_at(t);
3016
3017 t += Duration::from_secs(1);
3018 c.handle_resize_at(120 + (cycle % 20) as u16, 30 + (cycle % 5) as u16, t);
3019 let _ = c.tick_at(t + Duration::from_millis(60));
3020 }
3021
3022 let transitions_before_convergence = c.regime_transition_count();
3023 assert!(
3024 transitions_before_convergence <= 4,
3025 "oscillation should stay bounded, transitions={}",
3026 transitions_before_convergence
3027 );
3028
3029 t += Duration::from_secs(1);
3031 c.handle_resize_at(160, 40, t);
3032 for step in 1..=config.cooldown_frames {
3033 let _ = c.tick_at(t + Duration::from_millis(step as u64 * 5));
3034 }
3035 assert_eq!(c.regime(), Regime::Steady);
3036 let last_transition = c
3037 .transition_logs()
3038 .last()
3039 .expect("expected at least one transition");
3040 assert_eq!(last_transition.to_regime, Regime::Steady);
3041 assert_eq!(
3042 last_transition.reason_code,
3043 TransitionReasonCode::HeuristicExitBurstCooldown
3044 );
3045 }
3046
3047 #[test]
3048 fn simulation_bocpd_vs_heuristic_metrics() {
3049 let tick_ms = 5;
3050 let mut heuristic_config = test_config();
3053 heuristic_config.burst_enter_rate = 60.0;
3054 heuristic_config.burst_exit_rate = 30.0;
3055 let mut bocpd_cfg = BocpdConfig::responsive();
3056 bocpd_cfg.burst_prior = 0.35;
3057 bocpd_cfg.steady_threshold = 0.2;
3058 bocpd_cfg.burst_threshold = 0.6;
3059 let bocpd_config = heuristic_config.clone().with_bocpd_config(bocpd_cfg);
3060 let patterns = vec![
3061 ("steady", steady_pattern()),
3062 ("burst", burst_pattern()),
3063 ("oscillatory", oscillatory_pattern()),
3064 ];
3065
3066 for (pattern, events) in patterns {
3067 let heuristic = run_simulation(&events, heuristic_config.clone(), tick_ms);
3068 let bocpd = run_simulation(&events, bocpd_config.clone(), tick_ms);
3069
3070 let heuristic_jsonl = heuristic.to_jsonl(pattern, "heuristic");
3071 let bocpd_jsonl = bocpd.to_jsonl(pattern, "bocpd");
3072 let comparison = SimulationComparison::from_metrics(heuristic, bocpd);
3073 let comparison_jsonl = comparison.to_jsonl(pattern);
3074
3075 eprintln!("{heuristic_jsonl}");
3076 eprintln!("{bocpd_jsonl}");
3077 eprintln!("{comparison_jsonl}");
3078
3079 assert!(heuristic_jsonl.contains("\"event\":\"simulation_summary\""));
3080 assert!(bocpd_jsonl.contains("\"event\":\"simulation_summary\""));
3081 assert!(comparison_jsonl.contains("\"event\":\"simulation_compare\""));
3082
3083 #[allow(clippy::cast_precision_loss)]
3084 let max_allowed = test_config().hard_deadline_ms as f64 + 1.0;
3085 assert!(
3086 heuristic.max_coalesce_ms <= max_allowed,
3087 "heuristic latency bounded for {pattern}"
3088 );
3089 assert!(
3090 bocpd.max_coalesce_ms <= max_allowed,
3091 "bocpd latency bounded for {pattern}"
3092 );
3093
3094 if pattern == "burst" {
3095 let event_count = as_u64(events.len());
3096 assert!(
3097 heuristic.apply_count < event_count,
3098 "heuristic should coalesce under burst pattern"
3099 );
3100 assert!(
3101 bocpd.apply_count < event_count,
3102 "bocpd should coalesce under burst pattern"
3103 );
3104 assert!(
3105 comparison.apply_delta >= 0,
3106 "BOCPD should not increase renders in burst (apply_delta={})",
3107 comparison.apply_delta
3108 );
3109 }
3110 }
3111 }
3112
3113 #[test]
3114 fn never_drops_final_size() {
3115 let config = test_config();
3116 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
3117
3118 let base = Instant::now();
3119
3120 let mut intermediate_applies = Vec::new();
3122 for i in 0..100 {
3123 let action = c.handle_resize_at(
3124 80 + (i % 50),
3125 24 + (i % 30),
3126 base + Duration::from_millis(i as u64 * 5),
3127 );
3128 if let CoalesceAction::ApplyResize { width, height, .. } = action {
3129 intermediate_applies.push((width, height));
3130 }
3131 }
3132
3133 let final_action = c.handle_resize_at(200, 100, base + Duration::from_millis(600));
3135
3136 let applied_size = if let CoalesceAction::ApplyResize { width, height, .. } = final_action {
3137 Some((width, height))
3138 } else {
3139 let mut result = None;
3141 for tick in 0..100 {
3142 let action = c.tick_at(base + Duration::from_millis(700 + tick * 20));
3143 if let CoalesceAction::ApplyResize { width, height, .. } = action {
3144 result = Some((width, height));
3145 break;
3146 }
3147 }
3148 result
3149 };
3150
3151 assert_eq!(
3152 applied_size,
3153 Some((200, 100)),
3154 "Must apply final size 200x100"
3155 );
3156 }
3157
3158 #[test]
3159 fn bounded_latency_invariant() {
3160 let config = test_config();
3161 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
3162
3163 let base = Instant::now();
3164 c.handle_resize_at(100, 40, base);
3165
3166 let mut applied_at = None;
3168 for ms in 0..200 {
3169 let now = base + Duration::from_millis(ms);
3170 let action = c.tick_at(now);
3171 if matches!(action, CoalesceAction::ApplyResize { .. }) {
3172 applied_at = Some(ms);
3173 break;
3174 }
3175 }
3176
3177 assert!(applied_at.is_some(), "Must apply within reasonable time");
3178 assert!(
3179 applied_at.unwrap() <= config.hard_deadline_ms,
3180 "Must apply within hard deadline"
3181 );
3182 }
3183
3184 mod property {
3189 use super::*;
3190 use proptest::prelude::*;
3191
3192 fn dimension() -> impl Strategy<Value = u16> {
3194 1u16..500
3195 }
3196
3197 fn resize_sequence(max_len: usize) -> impl Strategy<Value = Vec<(u16, u16, u64)>> {
3199 proptest::collection::vec((dimension(), dimension(), 0u64..200), 0..max_len)
3200 }
3201
3202 proptest! {
3203 #[test]
3207 fn determinism_across_sequences(
3208 events in resize_sequence(50),
3209 tick_offset in 100u64..500
3210 ) {
3211 let config = CoalescerConfig::default();
3212
3213 let results: Vec<_> = (0..2)
3214 .map(|_| {
3215 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
3216 let base = Instant::now();
3217
3218 for (i, (w, h, delay)) in events.iter().enumerate() {
3219 let offset = events[..i].iter().map(|(_, _, d)| *d).sum::<u64>() + delay;
3220 c.handle_resize_at(*w, *h, base + Duration::from_millis(offset));
3221 }
3222
3223 let total_time = events.iter().map(|(_, _, d)| d).sum::<u64>() + tick_offset;
3225 c.tick_at(base + Duration::from_millis(total_time))
3226 })
3227 .collect();
3228
3229 prop_assert_eq!(results[0], results[1], "Results must be deterministic");
3230 }
3231
3232 #[test]
3237 fn latest_wins_never_drops(
3238 events in resize_sequence(20),
3239 final_w in dimension(),
3240 final_h in dimension()
3241 ) {
3242 if events.is_empty() {
3243 return Ok(());
3245 }
3246
3247 let config = CoalescerConfig::default();
3248 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
3249 let base = Instant::now();
3250
3251 let mut offset = 0u64;
3253 for (w, h, delay) in &events {
3254 offset += delay;
3255 c.handle_resize_at(*w, *h, base + Duration::from_millis(offset));
3256 }
3257
3258 offset += 50;
3260 c.handle_resize_at(final_w, final_h, base + Duration::from_millis(offset));
3261
3262 let mut result = None;
3264 for tick in 0..200 {
3265 let action = c.tick_at(base + Duration::from_millis(offset + 10 + tick * 20));
3266 if let CoalesceAction::ApplyResize { width, height, .. } = action {
3267 result = Some((width, height));
3268 break;
3269 }
3270 }
3271
3272 if let Some((applied_w, applied_h)) = result {
3274 prop_assert_eq!(
3275 (applied_w, applied_h),
3276 (final_w, final_h),
3277 "Must apply the final size {} x {}",
3278 final_w,
3279 final_h
3280 );
3281 }
3282 }
3283
3284 #[test]
3288 fn bounded_latency_maintained(
3289 w in dimension(),
3290 h in dimension()
3291 ) {
3292 let config = CoalescerConfig::default();
3293 let mut c = ResizeCoalescer::new(config.clone(), (0, 0));
3295 let base = Instant::now();
3296
3297 c.handle_resize_at(w, h, base);
3298
3299 let mut applied_at = None;
3301 for ms in 0..=config.hard_deadline_ms + 50 {
3302 let action = c.tick_at(base + Duration::from_millis(ms));
3303 if matches!(action, CoalesceAction::ApplyResize { .. }) {
3304 applied_at = Some(ms);
3305 break;
3306 }
3307 }
3308
3309 prop_assert!(applied_at.is_some(), "Resize must be applied");
3310 prop_assert!(
3311 applied_at.unwrap() <= config.hard_deadline_ms,
3312 "Must apply within hard deadline ({}ms), took {}ms",
3313 config.hard_deadline_ms,
3314 applied_at.unwrap()
3315 );
3316 }
3317
3318 #[test]
3323 fn no_size_corruption(
3324 w in dimension(),
3325 h in dimension()
3326 ) {
3327 let config = CoalescerConfig::default();
3328 let mut c = ResizeCoalescer::new(config.clone(), (0, 0));
3330 let base = Instant::now();
3331
3332 c.handle_resize_at(w, h, base);
3333
3334 let mut result = None;
3336 for ms in 0..200 {
3337 let action = c.tick_at(base + Duration::from_millis(ms));
3338 if let CoalesceAction::ApplyResize { width, height, .. } = action {
3339 result = Some((width, height));
3340 break;
3341 }
3342 }
3343
3344 prop_assert!(result.is_some());
3345 let (applied_w, applied_h) = result.unwrap();
3346 prop_assert_eq!(applied_w, w, "Width must not be corrupted");
3347 prop_assert_eq!(applied_h, h, "Height must not be corrupted");
3348 }
3349
3350 #[test]
3354 fn regime_follows_event_rate(
3355 event_count in 1usize..30
3356 ) {
3357 let config = CoalescerConfig {
3360 burst_enter_rate: 10.0,
3361 burst_exit_rate: 5.0,
3362 ..CoalescerConfig::default().without_bocpd()
3363 };
3364 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
3365 let base = Instant::now();
3366
3367 for i in 0..event_count {
3369 c.handle_resize_at(
3370 80 + i as u16,
3371 24,
3372 base + Duration::from_millis(i as u64 * 50), );
3374 }
3375
3376 if event_count >= 10 {
3378 prop_assert_eq!(
3379 c.regime(),
3380 Regime::Burst,
3381 "Many rapid events should trigger burst mode"
3382 );
3383 }
3384 }
3385
3386 #[test]
3391 fn event_count_invariant(
3392 events in resize_sequence(100)
3393 ) {
3394 let config = CoalescerConfig::default();
3395 let mut c = ResizeCoalescer::new(config, (80, 24));
3396 let base = Instant::now();
3397
3398 for (w, h, delay) in &events {
3399 c.handle_resize_at(*w, *h, base + Duration::from_millis(*delay));
3400 }
3401
3402 let stats = c.stats();
3403 prop_assert_eq!(
3405 stats.event_count,
3406 events.len() as u64,
3407 "Event count should match total incoming events"
3408 );
3409 }
3410
3411 #[test]
3417 fn bocpd_determinism_across_sequences(
3418 events in resize_sequence(30),
3419 tick_offset in 100u64..400
3420 ) {
3421 let config = CoalescerConfig::default().with_bocpd();
3422
3423 let results: Vec<_> = (0..2)
3424 .map(|_| {
3425 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
3426 let base = Instant::now();
3427
3428 for (i, (w, h, delay)) in events.iter().enumerate() {
3429 let offset = events[..i].iter().map(|(_, _, d)| *d).sum::<u64>() + delay;
3430 c.handle_resize_at(*w, *h, base + Duration::from_millis(offset));
3431 }
3432
3433 let total_time = events.iter().map(|(_, _, d)| d).sum::<u64>() + tick_offset;
3434 let action = c.tick_at(base + Duration::from_millis(total_time));
3435 (action, c.regime(), c.bocpd_p_burst())
3436 })
3437 .collect();
3438
3439 prop_assert_eq!(results[0], results[1], "BOCPD results must be deterministic");
3440 }
3441
3442 #[test]
3444 fn bocpd_latest_wins_never_drops(
3445 events in resize_sequence(15),
3446 final_w in dimension(),
3447 final_h in dimension()
3448 ) {
3449 if events.is_empty() {
3450 return Ok(());
3451 }
3452
3453 let config = CoalescerConfig::default().with_bocpd();
3454 let mut c = ResizeCoalescer::new(config, (80, 24));
3455 let base = Instant::now();
3456
3457 let mut offset = 0u64;
3458 for (w, h, delay) in &events {
3459 offset += delay;
3460 c.handle_resize_at(*w, *h, base + Duration::from_millis(offset));
3461 }
3462
3463 offset += 50;
3464 c.handle_resize_at(final_w, final_h, base + Duration::from_millis(offset));
3465
3466 let mut final_applied = None;
3467 for tick in 0..200 {
3468 let action = c.tick_at(base + Duration::from_millis(offset + 10 + tick * 20));
3469 if let CoalesceAction::ApplyResize { width, height, .. } = action {
3470 final_applied = Some((width, height));
3471 }
3472 if !c.has_pending() && final_applied.is_some() {
3473 break;
3474 }
3475 }
3476
3477 if let Some((applied_w, applied_h)) = final_applied {
3478 prop_assert_eq!(
3479 (applied_w, applied_h),
3480 (final_w, final_h),
3481 "BOCPD must apply the final size"
3482 );
3483 }
3484 }
3485
3486 #[test]
3488 fn bocpd_bounded_latency_maintained(
3489 w in dimension(),
3490 h in dimension()
3491 ) {
3492 let config = CoalescerConfig::default().with_bocpd();
3493 let mut c = ResizeCoalescer::new(config.clone(), (0, 0));
3494 let base = Instant::now();
3495
3496 c.handle_resize_at(w, h, base);
3497
3498 let mut applied_at = None;
3499 for ms in 0..=config.hard_deadline_ms + 50 {
3500 let action = c.tick_at(base + Duration::from_millis(ms));
3501 if matches!(action, CoalesceAction::ApplyResize { .. }) {
3502 applied_at = Some(ms);
3503 break;
3504 }
3505 }
3506
3507 prop_assert!(applied_at.is_some(), "BOCPD resize must be applied");
3508 prop_assert!(
3509 applied_at.unwrap() <= config.hard_deadline_ms,
3510 "BOCPD must apply within hard deadline ({}ms), took {}ms",
3511 config.hard_deadline_ms,
3512 applied_at.unwrap()
3513 );
3514 }
3515
3516 #[test]
3518 fn bocpd_posterior_always_valid(
3519 events in resize_sequence(50)
3520 ) {
3521 if events.is_empty() {
3522 return Ok(());
3523 }
3524
3525 let config = CoalescerConfig::default().with_bocpd();
3526 let mut c = ResizeCoalescer::new(config, (80, 24));
3527 let base = Instant::now();
3528
3529 for (w, h, delay) in &events {
3530 c.handle_resize_at(*w, *h, base + Duration::from_millis(*delay));
3531
3532 if let Some(bocpd) = c.bocpd() {
3534 let sum: f64 = bocpd.run_length_posterior().iter().sum();
3535 prop_assert!(
3536 (sum - 1.0).abs() < 1e-8,
3537 "Posterior must sum to 1, got {}",
3538 sum
3539 );
3540 }
3541
3542 let p_burst = c.bocpd_p_burst().unwrap();
3543 prop_assert!(
3544 (0.0..=1.0).contains(&p_burst),
3545 "P(burst) must be in [0,1], got {}",
3546 p_burst
3547 );
3548 }
3549 }
3550 }
3551 }
3552
3553 #[test]
3558 fn telemetry_hooks_fire_on_resize_applied() {
3559 use std::sync::Arc;
3560 use std::sync::atomic::{AtomicU32, Ordering};
3561
3562 let applied_count = Arc::new(AtomicU32::new(0));
3563 let applied_count_clone = applied_count.clone();
3564
3565 let hooks = TelemetryHooks::new().on_resize_applied(move |_entry| {
3566 applied_count_clone.fetch_add(1, Ordering::SeqCst);
3567 });
3568
3569 let mut config = test_config();
3570 config.enable_logging = true;
3571 let mut c = ResizeCoalescer::new(config, (80, 24)).with_telemetry_hooks(hooks);
3572
3573 let base = Instant::now();
3574 c.handle_resize_at(100, 40, base);
3575 c.tick_at(base + Duration::from_millis(50));
3576
3577 assert_eq!(applied_count.load(Ordering::SeqCst), 1);
3578 }
3579
3580 #[test]
3581 fn telemetry_hooks_fire_on_regime_change() {
3582 use std::sync::Arc;
3583 use std::sync::atomic::{AtomicU32, Ordering};
3584
3585 let regime_changes = Arc::new(AtomicU32::new(0));
3586 let regime_changes_clone = regime_changes.clone();
3587
3588 let hooks = TelemetryHooks::new().on_regime_change(move |_from, _to| {
3589 regime_changes_clone.fetch_add(1, Ordering::SeqCst);
3590 });
3591
3592 let config = test_config();
3593 let mut c = ResizeCoalescer::new(config, (80, 24)).with_telemetry_hooks(hooks);
3594
3595 let base = Instant::now();
3596
3597 for i in 0..15 {
3599 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 10));
3600 }
3601
3602 assert!(regime_changes.load(Ordering::SeqCst) >= 1);
3604 }
3605
3606 #[test]
3607 fn regime_transition_count_tracks_changes() {
3608 let config = test_config();
3609 let mut c = ResizeCoalescer::new(config, (80, 24));
3610
3611 assert_eq!(c.regime_transition_count(), 0);
3612
3613 let base = Instant::now();
3614
3615 for i in 0..15 {
3617 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 10));
3618 }
3619
3620 assert!(c.regime_transition_count() >= 1);
3622 }
3623
3624 #[test]
3625 fn cycle_time_percentiles_calculated() {
3626 let mut config = test_config();
3627 config.enable_logging = true;
3628 let mut c = ResizeCoalescer::new(config, (80, 24));
3629
3630 assert!(c.cycle_time_percentiles().is_none());
3632
3633 let base = Instant::now();
3634
3635 for i in 0..5 {
3637 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 100));
3638 c.tick_at(base + Duration::from_millis(i as u64 * 100 + 50));
3639 }
3640
3641 let percentiles = c.cycle_time_percentiles();
3643 assert!(percentiles.is_some());
3644
3645 let p = percentiles.unwrap();
3646 assert!(p.count >= 1);
3647 assert!(p.mean_ms >= 0.0);
3648 assert!(p.p50_ms >= 0.0);
3649 assert!(p.p95_ms >= p.p50_ms);
3650 assert!(p.p99_ms >= p.p95_ms);
3651 }
3652
3653 #[test]
3654 fn cycle_time_percentiles_jsonl_format() {
3655 let percentiles = CycleTimePercentiles {
3656 p50_ms: 10.5,
3657 p95_ms: 25.3,
3658 p99_ms: 42.1,
3659 count: 100,
3660 mean_ms: 15.2,
3661 };
3662
3663 let jsonl = percentiles.to_jsonl();
3664 assert!(jsonl.contains("\"event\":\"cycle_time_percentiles\""));
3665 assert!(jsonl.contains("\"p50_ms\":10.500"));
3666 assert!(jsonl.contains("\"p95_ms\":25.300"));
3667 assert!(jsonl.contains("\"p99_ms\":42.100"));
3668 assert!(jsonl.contains("\"mean_ms\":15.200"));
3669 assert!(jsonl.contains("\"count\":100"));
3670 }
3671
3672 #[test]
3677 fn config_default_enables_bocpd_with_heuristic_fallback() {
3678 let config = CoalescerConfig::default();
3679 assert!(config.enable_bocpd);
3680 assert!(config.heuristic_fallback);
3681 assert!(
3682 config.bocpd_config.is_none(),
3683 "None means BocpdConfig::default()"
3684 );
3685 let jsonl = config.to_jsonl("run", ScreenMode::AltScreen, 80, 24, 0);
3686 assert!(jsonl.contains(r#""enable_bocpd":true"#), "{jsonl}");
3687 assert!(jsonl.contains(r#""heuristic_fallback":true"#), "{jsonl}");
3688
3689 let c = ResizeCoalescer::new(config, (80, 24));
3690 assert!(c.bocpd_enabled());
3691 assert!(c.bocpd().is_some());
3692 assert!(c.bocpd_p_burst().is_some());
3693 assert_eq!(
3694 c.last_detector(),
3695 RegimeDetector::Heuristic,
3696 "nothing decided yet"
3697 );
3698 assert_eq!(c.detector_decisions(), DetectorDecisions::default());
3699 }
3700
3701 #[test]
3705 fn first_event_uses_heuristic_then_bocpd() {
3706 let mut c = ResizeCoalescer::new(CoalescerConfig::default().with_logging(true), (80, 24));
3707 let base = Instant::now();
3708
3709 c.handle_resize_at(81, 24, base);
3710 assert_eq!(c.last_detector(), RegimeDetector::Heuristic);
3711 c.handle_resize_at(82, 24, base + Duration::from_millis(30));
3712 assert_eq!(c.last_detector(), RegimeDetector::Bocpd);
3713 c.handle_resize_at(83, 24, base + Duration::from_millis(60));
3714 assert_eq!(c.last_detector(), RegimeDetector::Bocpd);
3715
3716 let jsonl = c.decision_logs_jsonl();
3717 let decisions: Vec<&str> = jsonl
3718 .lines()
3719 .filter(|line| line.contains(r#""event":"decision""#))
3720 .collect();
3721 assert_eq!(decisions.len(), 3, "{jsonl}");
3722 assert!(
3723 decisions[0].contains(r#""detector":"heuristic""#),
3724 "{}",
3725 decisions[0]
3726 );
3727 assert!(decisions[0].contains(r#""p_burst":"#), "{}", decisions[0]);
3728 assert!(
3729 decisions[1].contains(r#""detector":"bocpd""#),
3730 "{}",
3731 decisions[1]
3732 );
3733 assert!(
3734 decisions[2].contains(r#""detector":"bocpd""#),
3735 "{}",
3736 decisions[2]
3737 );
3738 assert_eq!(
3739 c.detector_decisions(),
3740 DetectorDecisions {
3741 bocpd: 2,
3742 heuristic: 1
3743 }
3744 );
3745 }
3746
3747 #[test]
3750 fn clamped_observation_falls_back_to_heuristic() {
3751 let mut c = ResizeCoalescer::new(CoalescerConfig::default().with_logging(true), (80, 24));
3752 let base = Instant::now();
3753
3754 c.handle_resize_at(81, 24, base);
3755 c.handle_resize_at(82, 24, base + Duration::from_millis(30));
3756 assert_eq!(c.last_detector(), RegimeDetector::Bocpd);
3757
3758 c.handle_resize_at(83, 24, base + Duration::from_secs(20));
3759 assert_eq!(c.last_detector(), RegimeDetector::Heuristic);
3760 let last = c
3761 .decision_logs_jsonl()
3762 .lines()
3763 .rfind(|line| line.contains(r#""event":"decision""#))
3764 .map(str::to_owned)
3765 .expect("decision row");
3766 assert!(last.contains(r#""detector":"heuristic""#), "{last}");
3767
3768 c.handle_resize_at(
3770 84,
3771 24,
3772 base + Duration::from_secs(20) + Duration::from_micros(200),
3773 );
3774 assert_eq!(c.last_detector(), RegimeDetector::Heuristic);
3775
3776 c.handle_resize_at(
3778 85,
3779 24,
3780 base + Duration::from_secs(20) + Duration::from_millis(40),
3781 );
3782 assert_eq!(c.last_detector(), RegimeDetector::Bocpd);
3783 }
3784
3785 #[test]
3788 fn fallback_off_lets_bocpd_decide_the_first_event() {
3789 let config = CoalescerConfig::default().with_heuristic_fallback(false);
3790 let mut c = ResizeCoalescer::new(config, (80, 24));
3791 c.handle_resize_at(81, 24, Instant::now());
3792 assert_eq!(c.last_detector(), RegimeDetector::Bocpd);
3793 assert_eq!(c.detector_decisions().bocpd, 1);
3794 }
3795
3796 #[test]
3799 fn explicit_disable_keeps_heuristic_only() {
3800 let config = CoalescerConfig::default()
3801 .without_bocpd()
3802 .with_logging(true);
3803 assert!(!config.enable_bocpd);
3804 assert!(config.bocpd_config.is_none());
3805 let config_row = config.to_jsonl("run", ScreenMode::AltScreen, 80, 24, 0);
3806 assert!(
3807 config_row.contains(r#""enable_bocpd":false"#),
3808 "{config_row}"
3809 );
3810 let mut c = ResizeCoalescer::new(config, (80, 24));
3811 assert!(c.bocpd().is_none());
3812
3813 let base = Instant::now();
3814 for i in 0..12u64 {
3815 c.handle_resize_at(81 + i as u16, 24, base + Duration::from_millis(i * 20));
3816 }
3817 assert_eq!(c.regime(), Regime::Burst);
3818 assert_eq!(c.detector_decisions().bocpd, 0);
3819 assert_eq!(c.detector_decisions().heuristic, 12);
3820
3821 let jsonl = c.decision_logs_jsonl();
3822 assert!(!jsonl.contains(r#""detector":"bocpd""#), "{jsonl}");
3823 assert!(jsonl.contains(r#""detector":"heuristic""#), "{jsonl}");
3824 assert!(jsonl.contains(r#""p_burst":null"#), "{jsonl}");
3825
3826 let transitions = c.transition_logs();
3827 assert!(
3828 transitions.iter().any(|t| t.to_regime == Regime::Burst
3829 && t.reason_code == TransitionReasonCode::HeuristicEnterBurstRate),
3830 "{transitions:?}"
3831 );
3832 assert!(
3833 transitions
3834 .iter()
3835 .all(|t| t.detector == RegimeDetector::Heuristic),
3836 "{transitions:?}"
3837 );
3838 let row = transitions[0].to_jsonl("run", ScreenMode::AltScreen, 80, 24);
3839 assert!(row.contains(r#""detector":"heuristic""#), "{row}");
3840 }
3841
3842 #[test]
3846 fn bocpd_mode_exits_burst_on_idle_tick() {
3847 let mut c = ResizeCoalescer::new(CoalescerConfig::default(), (80, 24));
3848 let base = Instant::now();
3849 let mut now = base;
3850 for i in 0..40u16 {
3851 now += Duration::from_millis(5);
3852 let _ = c.handle_resize_at(100 + (i % 7), 40 + (i % 3), now);
3853 }
3854 assert_eq!(c.last_detector(), RegimeDetector::Bocpd);
3855 assert_eq!(
3856 c.regime(),
3857 Regime::Burst,
3858 "40 events at 200/s must be a burst"
3859 );
3860 let mu_steady = c
3861 .bocpd()
3862 .expect("bocpd on by default")
3863 .config()
3864 .mu_steady_ms;
3865
3866 let _ = c.tick_at(now + Duration::from_millis((mu_steady / 2.0) as u64));
3868 assert_eq!(c.regime(), Regime::Burst);
3869
3870 let _ = c.tick_at(now + Duration::from_millis(mu_steady as u64 + 1));
3872 assert_eq!(c.regime(), Regime::Steady);
3873 let last = c.transition_logs().last().expect("idle exit recorded");
3874 assert_eq!(last.reason_code, TransitionReasonCode::BocpdIdleExit);
3875 assert_eq!(last.detector, RegimeDetector::Bocpd);
3876 assert!(last.confidence > 0.99, "{last:?}");
3877 assert!(last.p_burst.is_some());
3878 let row = last.to_jsonl("run", ScreenMode::AltScreen, 80, 24);
3879 assert!(row.contains(r#""reason_code":"bocpd_idle_exit""#), "{row}");
3880 }
3881
3882 #[test]
3885 fn stats_counts_detector_decisions() {
3886 let mut c = ResizeCoalescer::new(CoalescerConfig::default(), (80, 24));
3887 let base = Instant::now();
3888 c.handle_resize_at(81, 24, base);
3889 c.handle_resize_at(82, 24, base + Duration::from_millis(25));
3890 c.handle_resize_at(83, 24, base + Duration::from_millis(50));
3891 let stats = c.stats();
3892 assert_eq!(stats.detector, RegimeDetector::Bocpd);
3893 assert_eq!(stats.detector_decisions.heuristic, 1);
3894 assert_eq!(stats.detector_decisions.bocpd, 2);
3895 assert_eq!(
3896 stats.detector_decisions.bocpd + stats.detector_decisions.heuristic,
3897 stats.event_count
3898 );
3899 }
3900
3901 #[test]
3902 fn bocpd_enabled_with_config() {
3903 let config = CoalescerConfig::default().with_bocpd();
3904 let c = ResizeCoalescer::new(config, (80, 24));
3905 assert!(c.bocpd_enabled());
3906 assert!(c.bocpd().is_some());
3907 }
3908
3909 #[test]
3910 fn bocpd_posterior_normalized() {
3911 let config = CoalescerConfig::default().with_bocpd();
3912 let mut c = ResizeCoalescer::new(config, (80, 24));
3913
3914 let base = Instant::now();
3915
3916 for i in 0..20 {
3918 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 50));
3919 }
3920
3921 let p_burst = c.bocpd_p_burst().expect("BOCPD should be enabled");
3923 assert!(
3924 (0.0..=1.0).contains(&p_burst),
3925 "P(burst) must be in [0,1], got {}",
3926 p_burst
3927 );
3928
3929 if let Some(bocpd) = c.bocpd() {
3931 let sum: f64 = bocpd.run_length_posterior().iter().sum();
3932 assert!(
3933 (sum - 1.0).abs() < 1e-9,
3934 "Posterior must sum to 1, got {}",
3935 sum
3936 );
3937 }
3938 }
3939
3940 #[test]
3941 fn bocpd_detects_burst_from_rapid_events() {
3942 use crate::bocpd::BocpdConfig;
3943
3944 let bocpd_config = BocpdConfig {
3946 mu_steady_ms: 200.0,
3947 mu_burst_ms: 20.0,
3948 burst_threshold: 0.6,
3949 steady_threshold: 0.4,
3950 ..BocpdConfig::default()
3951 };
3952
3953 let config = CoalescerConfig::default().with_bocpd_config(bocpd_config);
3954 let mut c = ResizeCoalescer::new(config, (80, 24));
3955
3956 let base = Instant::now();
3957
3958 for i in 0..30 {
3960 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 10));
3961 }
3962
3963 let p_burst = c.bocpd_p_burst().expect("BOCPD should be enabled");
3965 assert!(
3966 p_burst > 0.5,
3967 "Rapid events should yield high P(burst), got {}",
3968 p_burst
3969 );
3970 assert_eq!(
3971 c.regime(),
3972 Regime::Burst,
3973 "Regime should be Burst with rapid events"
3974 );
3975 }
3976
3977 #[test]
3978 fn bocpd_detects_steady_from_slow_events() {
3979 use crate::bocpd::BocpdConfig;
3980
3981 let bocpd_config = BocpdConfig {
3983 mu_steady_ms: 200.0,
3984 mu_burst_ms: 20.0,
3985 burst_threshold: 0.7,
3986 steady_threshold: 0.3,
3987 ..BocpdConfig::default()
3988 };
3989
3990 let config = CoalescerConfig::default().with_bocpd_config(bocpd_config);
3991 let mut c = ResizeCoalescer::new(config, (80, 24));
3992
3993 let base = Instant::now();
3994
3995 for i in 0..10 {
3997 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 300));
3998 }
3999
4000 let p_burst = c.bocpd_p_burst().expect("BOCPD should be enabled");
4002 assert!(
4003 p_burst < 0.5,
4004 "Slow events should yield low P(burst), got {}",
4005 p_burst
4006 );
4007 assert_eq!(
4008 c.regime(),
4009 Regime::Steady,
4010 "Regime should be Steady with slow events"
4011 );
4012 }
4013
4014 #[test]
4015 fn bocpd_recommended_delay_varies_with_regime() {
4016 let config = CoalescerConfig::default().with_bocpd();
4017 let mut c = ResizeCoalescer::new(config, (80, 24));
4018
4019 let base = Instant::now();
4020
4021 c.handle_resize_at(85, 30, base);
4023 let delay_initial = c.bocpd_recommended_delay().expect("BOCPD enabled");
4024
4025 for i in 1..30 {
4027 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 10));
4028 }
4029 let delay_burst = c.bocpd_recommended_delay().expect("BOCPD enabled");
4030
4031 assert!(delay_initial > 0, "Initial delay should be positive");
4033 assert!(delay_burst > 0, "Burst delay should be positive");
4034 }
4035
4036 #[test]
4037 fn bocpd_update_is_deterministic() {
4038 let config = CoalescerConfig::default().with_bocpd();
4039
4040 let base = Instant::now();
4041
4042 let results: Vec<_> = (0..2)
4044 .map(|_| {
4045 let mut c = ResizeCoalescer::new(config.clone(), (80, 24));
4046 for i in 0..20 {
4047 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(i as u64 * 25));
4048 }
4049 (c.regime(), c.bocpd_p_burst())
4050 })
4051 .collect();
4052
4053 assert_eq!(
4054 results[0], results[1],
4055 "BOCPD results must be deterministic"
4056 );
4057 }
4058
4059 #[test]
4060 fn bocpd_memory_bounded() {
4061 use crate::bocpd::BocpdConfig;
4062
4063 let bocpd_config = BocpdConfig {
4065 max_run_length: 50,
4066 ..BocpdConfig::default()
4067 };
4068
4069 let config = CoalescerConfig::default().with_bocpd_config(bocpd_config);
4070 let mut c = ResizeCoalescer::new(config, (80, 24));
4071
4072 let base = Instant::now();
4073
4074 for i in 0u64..200 {
4076 c.handle_resize_at(
4077 80 + (i as u16 % 100),
4078 24 + (i as u16 % 50),
4079 base + Duration::from_millis(i * 20),
4080 );
4081 }
4082
4083 if let Some(bocpd) = c.bocpd() {
4085 let posterior_len = bocpd.run_length_posterior().len();
4086 assert!(
4087 posterior_len <= 51, "Posterior length should be bounded, got {}",
4089 posterior_len
4090 );
4091 }
4092 }
4093
4094 #[test]
4095 fn bocpd_stable_under_mixed_traffic() {
4096 let config = CoalescerConfig::default().with_bocpd();
4097 let mut c = ResizeCoalescer::new(config, (80, 24));
4098
4099 let base = Instant::now();
4100 let mut offset = 0u64;
4101
4102 for i in 0..5 {
4104 offset += 200;
4105 c.handle_resize_at(80 + i, 24 + i, base + Duration::from_millis(offset));
4106 }
4107
4108 for i in 0..15 {
4110 offset += 15;
4111 c.handle_resize_at(90 + i, 30 + i, base + Duration::from_millis(offset));
4112 }
4113
4114 for i in 0..5 {
4116 offset += 250;
4117 c.handle_resize_at(100 + i, 40 + i, base + Duration::from_millis(offset));
4118 }
4119
4120 let p_burst = c.bocpd_p_burst().expect("BOCPD enabled");
4122 assert!(
4123 (0.0..=1.0).contains(&p_burst),
4124 "P(burst) must remain valid after mixed traffic"
4125 );
4126
4127 if let Some(bocpd) = c.bocpd() {
4128 let sum: f64 = bocpd.run_length_posterior().iter().sum();
4129 assert!((sum - 1.0).abs() < 1e-9, "Posterior must remain normalized");
4130 }
4131 }
4132
4133 #[test]
4138 fn evidence_decision_jsonl_contains_all_required_fields() {
4139 let log = DecisionLog {
4140 timestamp: Instant::now(),
4141 elapsed_ms: 16.5,
4142 event_idx: 1,
4143 dt_ms: 16.0,
4144 event_rate: 62.5,
4145 regime: Regime::Steady,
4146 action: "apply",
4147 pending_size: Some((100, 40)),
4148 applied_size: Some((100, 40)),
4149 time_since_render_ms: 16.2,
4150 coalesce_ms: Some(16.0),
4151 forced: false,
4152 transition_reason_code: None,
4153 transition_confidence: None,
4154 detector: RegimeDetector::Heuristic,
4155 p_burst: None,
4156 };
4157
4158 let jsonl = log.to_jsonl("test-run-1", ScreenMode::AltScreen, 100, 40);
4159 let parsed: serde_json::Value =
4160 serde_json::from_str(&jsonl).expect("Decision JSONL must be valid JSON");
4161
4162 assert_eq!(
4164 parsed["schema_version"].as_str().unwrap(),
4165 EVIDENCE_SCHEMA_VERSION
4166 );
4167 assert_eq!(parsed["run_id"].as_str().unwrap(), "test-run-1");
4168 assert_eq!(parsed["event_idx"].as_u64().unwrap(), 1);
4169 assert_eq!(parsed["screen_mode"].as_str().unwrap(), "altscreen");
4170 assert_eq!(parsed["cols"].as_u64().unwrap(), 100);
4171 assert_eq!(parsed["rows"].as_u64().unwrap(), 40);
4172
4173 assert_eq!(parsed["event"].as_str().unwrap(), "decision");
4175 assert!(parsed["elapsed_ms"].as_f64().is_some());
4176 assert!(parsed["dt_ms"].as_f64().is_some());
4177 assert!(parsed["event_rate"].as_f64().is_some());
4178 assert_eq!(parsed["regime"].as_str().unwrap(), "steady");
4179 assert_eq!(parsed["action"].as_str().unwrap(), "apply");
4180 assert_eq!(parsed["pending_w"].as_u64().unwrap(), 100);
4181 assert_eq!(parsed["pending_h"].as_u64().unwrap(), 40);
4182 assert_eq!(parsed["applied_w"].as_u64().unwrap(), 100);
4183 assert_eq!(parsed["applied_h"].as_u64().unwrap(), 40);
4184 assert!(parsed["time_since_render_ms"].as_f64().is_some());
4185 assert!(parsed["coalesce_ms"].as_f64().is_some());
4186 assert!(!parsed["forced"].as_bool().unwrap());
4187 assert!(parsed["transition_reason_code"].is_null());
4188 assert!(parsed["transition_confidence"].is_null());
4189 }
4190
4191 #[test]
4192 fn evidence_decision_jsonl_null_fields_when_no_pending() {
4193 let log = DecisionLog {
4194 timestamp: Instant::now(),
4195 elapsed_ms: 0.0,
4196 event_idx: 0,
4197 dt_ms: 0.0,
4198 event_rate: 0.0,
4199 regime: Regime::Steady,
4200 action: "skip_same_size",
4201 pending_size: None,
4202 applied_size: None,
4203 time_since_render_ms: 0.0,
4204 coalesce_ms: None,
4205 forced: false,
4206 transition_reason_code: None,
4207 transition_confidence: None,
4208 detector: RegimeDetector::Heuristic,
4209 p_burst: None,
4210 };
4211
4212 let jsonl = log.to_jsonl("test-run-2", ScreenMode::AltScreen, 80, 24);
4213 let parsed: serde_json::Value =
4214 serde_json::from_str(&jsonl).expect("Decision JSONL must be valid JSON");
4215
4216 assert!(parsed["pending_w"].is_null());
4217 assert!(parsed["pending_h"].is_null());
4218 assert!(parsed["applied_w"].is_null());
4219 assert!(parsed["applied_h"].is_null());
4220 assert!(parsed["coalesce_ms"].is_null());
4221 assert!(parsed["transition_reason_code"].is_null());
4222 assert!(parsed["transition_confidence"].is_null());
4223 }
4224
4225 #[test]
4226 fn evidence_config_jsonl_contains_all_fields() {
4227 let config = test_config();
4228 let jsonl = config.to_jsonl("cfg-run", ScreenMode::AltScreen, 80, 24, 0);
4229 let parsed: serde_json::Value =
4230 serde_json::from_str(&jsonl).expect("Config JSONL must be valid JSON");
4231
4232 assert_eq!(parsed["event"].as_str().unwrap(), "config");
4233 assert_eq!(
4234 parsed["schema_version"].as_str().unwrap(),
4235 EVIDENCE_SCHEMA_VERSION
4236 );
4237 assert_eq!(parsed["steady_delay_ms"].as_u64().unwrap(), 16);
4238 assert_eq!(parsed["burst_delay_ms"].as_u64().unwrap(), 40);
4239 assert_eq!(parsed["hard_deadline_ms"].as_u64().unwrap(), 100);
4240 assert!(parsed["burst_enter_rate"].as_f64().is_some());
4241 assert!(parsed["burst_exit_rate"].as_f64().is_some());
4242 assert_eq!(parsed["cooldown_frames"].as_u64().unwrap(), 3);
4243 assert_eq!(parsed["rate_window_size"].as_u64().unwrap(), 8);
4244 }
4245
4246 #[test]
4247 fn evidence_inline_screen_mode_string() {
4248 let log = DecisionLog {
4249 timestamp: Instant::now(),
4250 elapsed_ms: 0.0,
4251 event_idx: 0,
4252 dt_ms: 0.0,
4253 event_rate: 0.0,
4254 regime: Regime::Burst,
4255 action: "coalesce",
4256 pending_size: Some((120, 40)),
4257 applied_size: None,
4258 time_since_render_ms: 5.0,
4259 coalesce_ms: None,
4260 forced: false,
4261 transition_reason_code: None,
4262 transition_confidence: None,
4263 detector: RegimeDetector::Heuristic,
4264 p_burst: None,
4265 };
4266
4267 let jsonl = log.to_jsonl("inline-run", ScreenMode::Inline { ui_height: 12 }, 120, 40);
4268 let parsed: serde_json::Value =
4269 serde_json::from_str(&jsonl).expect("JSONL must be valid JSON");
4270
4271 assert_eq!(parsed["screen_mode"].as_str().unwrap(), "inline");
4272 assert_eq!(parsed["regime"].as_str().unwrap(), "burst");
4273 }
4274
4275 #[test]
4276 fn resize_scheduling_steady_applies_within_steady_delay() {
4277 let config = CoalescerConfig {
4278 steady_delay_ms: 20,
4279 burst_delay_ms: 50,
4280 hard_deadline_ms: 200,
4281 enable_logging: true,
4282 ..test_config()
4283 };
4284 let base = Instant::now();
4285 let mut c = ResizeCoalescer::new(config, (80, 24));
4286
4287 let action = c.handle_resize_at(100, 40, base);
4289 match action {
4291 CoalesceAction::ApplyResize { width, height, .. } => {
4292 assert_eq!(width, 100);
4293 assert_eq!(height, 40);
4294 }
4295 CoalesceAction::None => {
4296 let later = base + Duration::from_millis(25);
4298 let action = c.tick_at(later);
4299 if let CoalesceAction::ApplyResize { width, height, .. } = action {
4300 assert_eq!(width, 100);
4301 assert_eq!(height, 40);
4302 }
4303 }
4304 }
4305
4306 assert_eq!(c.last_applied(), (100, 40));
4308 }
4309
4310 #[test]
4311 fn resize_scheduling_burst_regime_coalesces_rapid_events() {
4312 let config = CoalescerConfig {
4313 steady_delay_ms: 16,
4314 burst_delay_ms: 40,
4315 hard_deadline_ms: 100,
4316 burst_enter_rate: 10.0,
4317 enable_logging: true,
4318 ..test_config()
4319 };
4320 let base = Instant::now();
4321 let mut c = ResizeCoalescer::new(config, (80, 24));
4322 let mut apply_count = 0u32;
4323
4324 for i in 0..20 {
4326 let t = base + Duration::from_millis(i * 50);
4327 let action = c.handle_resize_at(80 + (i as u16), 24, t);
4328 if matches!(action, CoalesceAction::ApplyResize { .. }) {
4329 apply_count += 1;
4330 }
4331 let tick_t = t + Duration::from_millis(10);
4333 let tick_action = c.tick_at(tick_t);
4334 if matches!(tick_action, CoalesceAction::ApplyResize { .. }) {
4335 apply_count += 1;
4336 }
4337 }
4338
4339 assert!(
4341 apply_count < 20,
4342 "Expected coalescing: {apply_count} applies for 20 events"
4343 );
4344 assert!(apply_count > 0, "Should have at least one apply");
4346 }
4347
4348 #[test]
4349 fn evidence_summary_jsonl_includes_checksum() {
4350 let config = CoalescerConfig {
4351 enable_logging: true,
4352 ..test_config()
4353 };
4354 let base = Instant::now();
4355 let mut c = ResizeCoalescer::new(config, (80, 24));
4356
4357 c.handle_resize_at(100, 40, base + Duration::from_millis(10));
4359 c.tick_at(base + Duration::from_millis(30));
4360
4361 let all_lines = c.evidence_to_jsonl();
4362 let summary_line = all_lines.lines().last().expect("Should have summary line");
4363 let parsed: serde_json::Value =
4364 serde_json::from_str(summary_line).expect("Summary JSONL line must be valid JSON");
4365
4366 assert_eq!(parsed["event"].as_str().unwrap(), "summary");
4367 assert!(parsed["decisions"].as_u64().is_some());
4368 assert!(parsed["applies"].as_u64().is_some());
4369 assert!(parsed["forced_applies"].as_u64().is_some());
4370 assert!(parsed["coalesces"].as_u64().is_some());
4371 assert!(parsed["skips"].as_u64().is_some());
4372 assert!(parsed["regime"].as_str().is_some());
4373 assert!(parsed["checksum"].as_str().is_some());
4374 }
4375
4376 #[test]
4381 fn decision_evidence_favor_apply_steady() {
4382 let ev = DecisionEvidence::favor_apply(Regime::Steady, 80.0, 2.0);
4383 assert!(ev.log_bayes_factor > 0.0, "Should favor apply");
4385 assert_eq!(ev.regime_contribution, 1.0);
4386 assert!((ev.timing_contribution - 1.6).abs() < 0.01);
4387 assert_eq!(ev.rate_contribution, 0.5);
4388 assert!(ev.is_strong());
4389 assert!(ev.is_decisive());
4390 }
4391
4392 #[test]
4393 fn decision_evidence_favor_apply_burst_regime() {
4394 let ev = DecisionEvidence::favor_apply(Regime::Burst, 10.0, 20.0);
4395 assert_eq!(ev.regime_contribution, -0.5);
4397 assert!((ev.timing_contribution - 0.2).abs() < 0.01);
4398 assert_eq!(ev.rate_contribution, -0.3);
4399 assert!(!ev.is_strong());
4401 }
4402
4403 #[test]
4404 fn decision_evidence_favor_coalesce_burst() {
4405 let ev = DecisionEvidence::favor_coalesce(Regime::Burst, 5.0, 15.0);
4406 assert!(ev.log_bayes_factor < 0.0, "Should favor coalesce");
4409 assert_eq!(ev.regime_contribution, 1.0);
4410 assert!((ev.timing_contribution - 2.0).abs() < 0.01);
4411 assert_eq!(ev.rate_contribution, 0.5);
4412 assert!(ev.is_strong());
4413 assert!(ev.is_decisive());
4414 }
4415
4416 #[test]
4417 fn decision_evidence_favor_coalesce_steady_regime() {
4418 let ev = DecisionEvidence::favor_coalesce(Regime::Steady, 100.0, 3.0);
4419 assert_eq!(ev.regime_contribution, -0.5);
4421 assert!((ev.timing_contribution - 0.2).abs() < 0.01);
4422 assert_eq!(ev.rate_contribution, -0.3);
4423 }
4424
4425 #[test]
4426 fn decision_evidence_forced_deadline() {
4427 let ev = DecisionEvidence::forced_deadline(100.0);
4428 assert!(ev.log_bayes_factor.is_infinite());
4429 assert_eq!(ev.regime_contribution, 0.0);
4430 assert!((ev.timing_contribution - 100.0).abs() < 0.01);
4431 assert_eq!(ev.rate_contribution, 0.0);
4432 assert!(ev.is_strong());
4433 assert!(ev.is_decisive());
4434 assert!(ev.explanation.contains("100.0ms"));
4435 }
4436
4437 #[test]
4438 fn decision_evidence_is_strong_boundary() {
4439 let ev = DecisionEvidence {
4441 log_bayes_factor: 1.0,
4442 regime_contribution: 0.0,
4443 timing_contribution: 0.0,
4444 rate_contribution: 0.0,
4445 explanation: String::new(),
4446 };
4447 assert!(!ev.is_strong());
4448
4449 let ev2 = DecisionEvidence {
4450 log_bayes_factor: 1.001,
4451 ..ev.clone()
4452 };
4453 assert!(ev2.is_strong());
4454
4455 let ev3 = DecisionEvidence {
4457 log_bayes_factor: -1.5,
4458 ..ev
4459 };
4460 assert!(ev3.is_strong());
4461 }
4462
4463 #[test]
4464 fn decision_evidence_is_decisive_boundary() {
4465 let ev = DecisionEvidence {
4466 log_bayes_factor: 2.0,
4467 regime_contribution: 0.0,
4468 timing_contribution: 0.0,
4469 rate_contribution: 0.0,
4470 explanation: String::new(),
4471 };
4472 assert!(!ev.is_decisive()); let ev2 = DecisionEvidence {
4475 log_bayes_factor: 2.001,
4476 ..ev
4477 };
4478 assert!(ev2.is_decisive());
4479 }
4480
4481 #[test]
4482 fn decision_evidence_to_jsonl_valid() {
4483 let ev = DecisionEvidence::favor_apply(Regime::Steady, 50.0, 3.0);
4484 let jsonl = ev.to_jsonl("test-run", ScreenMode::AltScreen, 80, 24, 5);
4485 let parsed: serde_json::Value =
4486 serde_json::from_str(&jsonl).expect("DecisionEvidence JSONL must be valid JSON");
4487
4488 assert_eq!(parsed["event"].as_str().unwrap(), "decision_evidence");
4489 assert!(parsed["log_bayes_factor"].as_f64().is_some());
4490 assert!(parsed["regime_contribution"].as_f64().is_some());
4491 assert!(parsed["timing_contribution"].as_f64().is_some());
4492 assert!(parsed["rate_contribution"].as_f64().is_some());
4493 assert!(parsed["explanation"].as_str().is_some());
4494 }
4495
4496 #[test]
4497 fn decision_evidence_to_jsonl_infinity() {
4498 let ev = DecisionEvidence::forced_deadline(100.0);
4499 let jsonl = ev.to_jsonl("test-run", ScreenMode::AltScreen, 80, 24, 0);
4500 assert!(jsonl.contains("\"inf\""));
4502 }
4503
4504 #[test]
4509 fn hard_deadline_zero_applies_immediately() {
4510 let config = CoalescerConfig {
4511 hard_deadline_ms: 0,
4512 enable_logging: true,
4513 ..test_config()
4514 };
4515 let mut c = ResizeCoalescer::new(config, (80, 24));
4516 let base = Instant::now();
4517
4518 let action = c.handle_resize_at(100, 40, base);
4520 assert!(
4521 matches!(action, CoalesceAction::ApplyResize { .. }),
4522 "hard_deadline_ms=0 should force immediate apply, got {action:?}"
4523 );
4524 }
4525
4526 #[test]
4527 fn rate_window_size_zero_returns_zero_rate() {
4528 let config = CoalescerConfig {
4529 rate_window_size: 0,
4530 enable_logging: true,
4531 ..test_config()
4532 };
4533 let mut c = ResizeCoalescer::new(config, (80, 24));
4534 let base = Instant::now();
4535
4536 for i in 0..5 {
4537 c.handle_resize_at(80 + i, 24, base + Duration::from_millis(i as u64 * 10));
4538 }
4539 let rate = c.calculate_event_rate(base + Duration::from_millis(50));
4541 assert_eq!(rate, 0.0, "rate_window_size=0 should yield 0 rate");
4542 }
4543
4544 #[test]
4545 fn tick_no_pending_returns_none() {
4546 let config = test_config();
4547 let mut c = ResizeCoalescer::new(config, (80, 24));
4548 let base = Instant::now();
4549
4550 let action = c.tick_at(base);
4552 assert_eq!(action, CoalesceAction::None);
4553 let action = c.tick_at(base + Duration::from_millis(500));
4554 assert_eq!(action, CoalesceAction::None);
4555 }
4556
4557 #[test]
4558 fn time_until_apply_none_when_no_pending() {
4559 let c = ResizeCoalescer::new(test_config(), (80, 24));
4560 assert!(c.time_until_apply(Instant::now()).is_none());
4561 }
4562
4563 #[test]
4564 fn time_until_apply_zero_when_past_delay() {
4565 let config = test_config();
4566 let mut c = ResizeCoalescer::new(config, (80, 24));
4567 let base = Instant::now();
4568
4569 c.handle_resize_at(100, 40, base);
4570 let result = c.time_until_apply(base + Duration::from_millis(500));
4572 assert_eq!(result, Some(Duration::ZERO));
4573 }
4574
4575 #[test]
4580 fn json_escape_special_characters() {
4581 assert_eq!(json_escape("hello"), "hello");
4582 assert_eq!(json_escape("a\"b"), "a\\\"b");
4583 assert_eq!(json_escape("a\\b"), "a\\\\b");
4584 assert_eq!(json_escape("a\nb"), "a\\nb");
4585 assert_eq!(json_escape("a\rb"), "a\\rb");
4586 assert_eq!(json_escape("a\tb"), "a\\tb");
4587 }
4588
4589 #[test]
4590 fn json_escape_control_characters() {
4591 let input = "a\x01b";
4593 let escaped = json_escape(input);
4594 assert_eq!(escaped, "a\\u0001b");
4595 }
4596
4597 #[test]
4598 fn json_escape_empty_string() {
4599 assert_eq!(json_escape(""), "");
4600 }
4601
4602 #[test]
4607 fn clear_logs_resets_state() {
4608 let mut config = test_config();
4609 config.enable_logging = true;
4610 let mut c = ResizeCoalescer::new(config, (80, 24));
4611
4612 c.handle_resize_at(100, 40, Instant::now());
4613 c.tick_at(Instant::now() + Duration::from_millis(50));
4614
4615 assert!(!c.logs().is_empty());
4616
4617 c.clear_logs();
4618 assert!(c.logs().is_empty());
4619
4620 c.handle_resize_at(120, 50, Instant::now());
4622 c.tick_at(Instant::now() + Duration::from_millis(50));
4623 assert!(!c.logs().is_empty());
4624 }
4625
4626 #[test]
4627 fn decision_logs_jsonl_each_line_valid() {
4628 let mut config = test_config();
4629 config.enable_logging = true;
4630 let base = Instant::now();
4631 let mut c = ResizeCoalescer::new(config, (80, 24))
4632 .with_evidence_run_id("jsonl-test")
4633 .with_screen_mode(ScreenMode::AltScreen);
4634
4635 c.handle_resize_at(100, 40, base);
4636 c.handle_resize_at(110, 50, base + Duration::from_millis(5));
4637 c.tick_at(base + Duration::from_millis(50));
4638
4639 let jsonl = c.decision_logs_jsonl();
4640 assert!(!jsonl.is_empty());
4641 for line in jsonl.lines() {
4642 let _: serde_json::Value =
4643 serde_json::from_str(line).expect("Each JSONL line must be valid JSON");
4644 }
4645 }
4646
4647 #[test]
4652 fn telemetry_hooks_has_methods() {
4653 let hooks = TelemetryHooks::new();
4654 assert!(!hooks.has_resize_applied());
4655 assert!(!hooks.has_regime_change());
4656 assert!(!hooks.has_decision());
4657
4658 let hooks = hooks.on_resize_applied(|_| {});
4659 assert!(hooks.has_resize_applied());
4660 assert!(!hooks.has_regime_change());
4661 assert!(!hooks.has_decision());
4662 }
4663
4664 #[test]
4665 fn telemetry_hooks_with_tracing() {
4666 let hooks = TelemetryHooks::new().with_tracing(true);
4667 let debug_str = format!("{:?}", hooks);
4668 assert!(debug_str.contains("emit_tracing: true"));
4669 }
4670
4671 #[test]
4672 fn telemetry_hooks_default_equals_new() {
4673 let h1 = TelemetryHooks::default();
4674 let h2 = TelemetryHooks::new();
4675 assert!(!h1.has_resize_applied());
4676 assert!(!h2.has_resize_applied());
4677 }
4678
4679 #[test]
4680 fn telemetry_hooks_on_decision_fires() {
4681 use std::sync::Arc;
4682 use std::sync::atomic::{AtomicU32, Ordering};
4683
4684 let count = Arc::new(AtomicU32::new(0));
4685 let count_clone = count.clone();
4686
4687 let hooks = TelemetryHooks::new().on_decision(move |_entry| {
4688 count_clone.fetch_add(1, Ordering::SeqCst);
4689 });
4690
4691 let mut config = test_config();
4692 config.enable_logging = true;
4693 let mut c = ResizeCoalescer::new(config, (80, 24)).with_telemetry_hooks(hooks);
4694
4695 let base = Instant::now();
4696 c.handle_resize_at(100, 40, base);
4697
4698 assert!(count.load(Ordering::SeqCst) >= 1);
4700 }
4701
4702 #[test]
4707 fn regime_as_str_values() {
4708 assert_eq!(Regime::Steady.as_str(), "steady");
4709 assert_eq!(Regime::Burst.as_str(), "burst");
4710 }
4711
4712 #[test]
4713 fn regime_default_is_steady() {
4714 assert_eq!(Regime::default(), Regime::Steady);
4715 }
4716
4717 #[test]
4722 fn decision_summary_checksum_hex_format() {
4723 let summary = DecisionSummary {
4724 checksum: 0x0123456789ABCDEF,
4725 ..DecisionSummary::default()
4726 };
4727 assert_eq!(summary.checksum_hex(), "0123456789abcdef");
4728 }
4729
4730 #[test]
4731 fn decision_summary_default_values() {
4732 let summary = DecisionSummary::default();
4733 assert_eq!(summary.decision_count, 0);
4734 assert_eq!(summary.apply_count, 0);
4735 assert_eq!(summary.forced_apply_count, 0);
4736 assert_eq!(summary.coalesce_count, 0);
4737 assert_eq!(summary.skip_count, 0);
4738 assert_eq!(summary.regime, Regime::Steady);
4739 assert_eq!(summary.last_applied, (0, 0));
4740 assert_eq!(summary.checksum, 0);
4741 }
4742
4743 #[test]
4744 fn decision_summary_to_jsonl_valid() {
4745 let summary = DecisionSummary {
4746 decision_count: 5,
4747 apply_count: 2,
4748 forced_apply_count: 1,
4749 coalesce_count: 2,
4750 skip_count: 1,
4751 regime: Regime::Burst,
4752 last_applied: (120, 40),
4753 checksum: 0xDEADBEEF,
4754 };
4755 let jsonl = summary.to_jsonl("run-1", ScreenMode::AltScreen, 120, 40, 5);
4756 let parsed: serde_json::Value =
4757 serde_json::from_str(&jsonl).expect("Summary JSONL must be valid JSON");
4758
4759 assert_eq!(parsed["event"].as_str().unwrap(), "summary");
4760 assert_eq!(parsed["decisions"].as_u64().unwrap(), 5);
4761 assert_eq!(parsed["applies"].as_u64().unwrap(), 2);
4762 assert_eq!(parsed["forced_applies"].as_u64().unwrap(), 1);
4763 assert_eq!(parsed["coalesces"].as_u64().unwrap(), 2);
4764 assert_eq!(parsed["skips"].as_u64().unwrap(), 1);
4765 assert_eq!(parsed["regime"].as_str().unwrap(), "burst");
4766 assert_eq!(parsed["last_w"].as_u64().unwrap(), 120);
4767 assert_eq!(parsed["last_h"].as_u64().unwrap(), 40);
4768 assert!(parsed["checksum"].as_str().unwrap().contains("deadbeef"));
4769 }
4770
4771 #[test]
4776 fn screen_mode_str_all_variants() {
4777 assert_eq!(screen_mode_str(ScreenMode::AltScreen), "altscreen");
4778 assert_eq!(
4779 screen_mode_str(ScreenMode::Inline { ui_height: 10 }),
4780 "inline"
4781 );
4782 assert_eq!(
4783 screen_mode_str(ScreenMode::InlineAuto {
4784 min_height: 5,
4785 max_height: 20,
4786 }),
4787 "inline_auto"
4788 );
4789 }
4790
4791 #[test]
4796 fn config_with_logging_chaining() {
4797 let config = CoalescerConfig::default().with_logging(true);
4798 assert!(config.enable_logging);
4799
4800 let config2 = config.with_logging(false);
4801 assert!(!config2.enable_logging);
4802 }
4803
4804 #[test]
4805 fn config_with_bocpd_chaining() {
4806 let config = CoalescerConfig::default().with_bocpd();
4807 assert!(config.enable_bocpd);
4808 assert!(config.bocpd_config.is_some());
4809 }
4810
4811 #[test]
4812 fn config_with_bocpd_config_chaining() {
4813 let bocpd_cfg = BocpdConfig {
4814 max_run_length: 42,
4815 ..BocpdConfig::default()
4816 };
4817 let config = CoalescerConfig::default().with_bocpd_config(bocpd_cfg);
4818 assert!(config.enable_bocpd);
4819 assert_eq!(config.bocpd_config.as_ref().unwrap().max_run_length, 42);
4820 }
4821
4822 #[test]
4827 fn coalescer_with_evidence_run_id() {
4828 let c = ResizeCoalescer::new(test_config(), (80, 24)).with_evidence_run_id("custom-run-id");
4829 let jsonl = c.evidence_to_jsonl();
4831 assert!(jsonl.contains("custom-run-id"));
4832 }
4833
4834 #[test]
4835 fn coalescer_with_screen_mode() {
4836 let mut config = test_config();
4837 config.enable_logging = true;
4838 let mut c = ResizeCoalescer::new(config, (80, 24))
4839 .with_screen_mode(ScreenMode::Inline { ui_height: 8 });
4840
4841 c.handle_resize(100, 40);
4842 let jsonl = c.evidence_to_jsonl();
4843 assert!(jsonl.contains("\"screen_mode\":\"inline\""));
4844 }
4845
4846 #[test]
4847 fn coalescer_set_evidence_sink_clears_config_logged() {
4848 let mut config = test_config();
4849 config.enable_logging = true;
4850 let mut c = ResizeCoalescer::new(config, (80, 24));
4851
4852 c.handle_resize(100, 40);
4854
4855 c.set_evidence_sink(None);
4857
4858 let jsonl = c.evidence_to_jsonl();
4860 assert!(jsonl.contains("\"event\":\"config\""));
4861 }
4862
4863 #[test]
4868 fn duration_since_or_zero_normal() {
4869 let earlier = Instant::now();
4870 std::thread::sleep(Duration::from_millis(1));
4871 let now = Instant::now();
4872 let result = duration_since_or_zero(now, earlier);
4873 assert!(result >= Duration::from_millis(1));
4874 }
4875
4876 #[test]
4877 fn duration_since_or_zero_same_instant() {
4878 let now = Instant::now();
4879 let result = duration_since_or_zero(now, now);
4880 assert_eq!(result, Duration::ZERO);
4881 }
4882
4883 #[test]
4888 fn resize_applied_event_fields() {
4889 let event = ResizeAppliedEvent {
4890 new_size: (100, 40),
4891 old_size: (80, 24),
4892 elapsed: Duration::from_millis(42),
4893 forced: true,
4894 };
4895 assert_eq!(event.new_size, (100, 40));
4896 assert_eq!(event.old_size, (80, 24));
4897 assert_eq!(event.elapsed, Duration::from_millis(42));
4898 assert!(event.forced);
4899 }
4900
4901 #[test]
4902 fn regime_change_event_fields() {
4903 let event = RegimeChangeEvent {
4904 from: Regime::Steady,
4905 to: Regime::Burst,
4906 event_idx: 42,
4907 reason_code: TransitionReasonCode::HeuristicEnterBurstRate,
4908 confidence: 0.91,
4909 };
4910 assert_eq!(event.from, Regime::Steady);
4911 assert_eq!(event.to, Regime::Burst);
4912 assert_eq!(event.event_idx, 42);
4913 assert_eq!(
4914 event.reason_code,
4915 TransitionReasonCode::HeuristicEnterBurstRate
4916 );
4917 assert!((event.confidence - 0.91).abs() < f64::EPSILON);
4918 }
4919
4920 #[test]
4925 fn coalesce_action_none_eq() {
4926 assert_eq!(CoalesceAction::None, CoalesceAction::None);
4927 assert_ne!(
4928 CoalesceAction::None,
4929 CoalesceAction::ApplyResize {
4930 width: 1,
4931 height: 1,
4932 coalesce_time: Duration::ZERO,
4933 forced_by_deadline: false,
4934 }
4935 );
4936 }
4937
4938 #[test]
4942 fn bocpd_mode_never_emits_heuristic_cooldown_exit() {
4943 let mut c = ResizeCoalescer::new(test_config().with_bocpd(), (80, 24));
4944 let base = Instant::now();
4945 let mut now = base;
4946 for i in 0..200u16 {
4948 now += Duration::from_millis(5);
4949 let _ = c.handle_resize_at(100 + (i % 7), 40 + (i % 3), now);
4950 }
4951 for _ in 0..100 {
4953 now += Duration::from_millis(16);
4954 let _ = c.tick_at(now);
4955 }
4956 let logs = c.transition_logs();
4957 assert!(
4958 logs.iter()
4959 .all(|t| t.reason_code != TransitionReasonCode::HeuristicExitBurstCooldown),
4960 "heuristic cooldown exit fired in BOCPD mode: {logs:?}"
4961 );
4962 for window in logs.windows(2) {
4963 assert_ne!(
4964 window[0].from_regime, window[0].to_regime,
4965 "a transition must change regime: {logs:?}"
4966 );
4967 assert_eq!(
4968 window[0].to_regime, window[1].from_regime,
4969 "consecutive transitions must chain: {logs:?}"
4970 );
4971 }
4972 assert_eq!(c.regime_transition_count(), logs.len() as u64);
4973 }
4974
4975 #[test]
4979 fn immediate_mode_regime_is_not_pinned_to_burst() {
4980 let mut c = ResizeCoalescer::new(test_config(), (80, 24));
4981 let mut now = Instant::now();
4982 assert_eq!(c.stats().regime, Regime::Steady);
4983 for i in 0..30u16 {
4985 now += Duration::from_millis(5);
4986 c.record_external_apply(100 + i, 40, now);
4987 }
4988 assert_eq!(c.stats().regime, Regime::Burst, "burst detected");
4989 let transitions_after_burst = c.regime_transition_count();
4990 now += Duration::from_secs(2);
4994 c.record_external_apply(90, 30, now);
4995 assert_eq!(
4996 c.stats().regime,
4997 Regime::Steady,
4998 "regime pinned to Burst after the burst ended"
4999 );
5000 assert_eq!(c.stats().last_applied, (90, 30));
5001 assert_eq!(c.regime_transition_count(), transitions_after_burst + 1);
5002 let last = c.transition_logs().last().expect("exit transition logged");
5003 assert_eq!(
5004 last.reason_code,
5005 TransitionReasonCode::HeuristicExitBurstRate
5006 );
5007 assert_eq!(
5008 (last.from_regime, last.to_regime),
5009 (Regime::Burst, Regime::Steady)
5010 );
5011 assert_eq!(last.reason_code.as_str(), "heuristic_exit_burst_rate");
5012 }
5013
5014 #[test]
5015 fn coalesce_action_apply_resize_eq() {
5016 let a = CoalesceAction::ApplyResize {
5017 width: 100,
5018 height: 40,
5019 coalesce_time: Duration::from_millis(16),
5020 forced_by_deadline: false,
5021 };
5022 let b = CoalesceAction::ApplyResize {
5023 width: 100,
5024 height: 40,
5025 coalesce_time: Duration::from_millis(16),
5026 forced_by_deadline: false,
5027 };
5028 assert_eq!(a, b);
5029
5030 let c = CoalesceAction::ApplyResize {
5031 width: 100,
5032 height: 40,
5033 coalesce_time: Duration::from_millis(16),
5034 forced_by_deadline: true,
5035 };
5036 assert_ne!(a, c);
5037 }
5038
5039 #[test]
5044 fn fnv_hash_deterministic() {
5045 let mut h1 = FNV_OFFSET_BASIS;
5046 fnv_hash_bytes(&mut h1, b"hello world");
5047
5048 let mut h2 = FNV_OFFSET_BASIS;
5049 fnv_hash_bytes(&mut h2, b"hello world");
5050
5051 assert_eq!(h1, h2);
5052 }
5053
5054 #[test]
5055 fn fnv_hash_different_inputs_different_hashes() {
5056 let mut h1 = FNV_OFFSET_BASIS;
5057 fnv_hash_bytes(&mut h1, b"hello");
5058
5059 let mut h2 = FNV_OFFSET_BASIS;
5060 fnv_hash_bytes(&mut h2, b"world");
5061
5062 assert_ne!(h1, h2);
5063 }
5064
5065 #[test]
5066 fn fnv_hash_empty_input_returns_basis() {
5067 let mut hash = FNV_OFFSET_BASIS;
5068 fnv_hash_bytes(&mut hash, b"");
5069 assert_eq!(hash, FNV_OFFSET_BASIS);
5070 }
5071}