Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

74.7 KB
Raw Blame
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;

pub const KEYBOARD_EVENTS_FILE_NAME: &str = "keyboard.bin";
pub const LEGACY_KEYBOARD_EVENTS_FILE_NAME: &str = "keyboard.json";
const KEYBOARD_EVENTS_MAGIC: &[u8; 6] = b"CPKB01";

#[cfg(test)]
mod projection_tests;

#[derive(Serialize, Deserialize, Clone, Type, Debug, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct KeyPressEvent {
    pub key: String,
    pub key_code: String,
    pub time_ms: f64,
    pub down: bool,
}

impl PartialOrd for KeyPressEvent {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.time_ms.partial_cmp(&other.time_ms)
    }
}

#[derive(Default, Serialize, Deserialize, Debug, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct KeyboardEvents {
    pub presses: Vec<KeyPressEvent>,
}

impl KeyboardEvents {
    pub fn load_from_file(path: &Path) -> Result<Self, String> {
        let bytes =
            std::fs::read(path).map_err(|e| format!("Failed to open keyboard events file: {e}"))?;
        Self::from_bytes(&bytes, path)
    }

    pub fn from_bytes(bytes: &[u8], source_path: &Path) -> Result<Self, String> {
        let config = bincode::config::standard();

        if let Some(payload) = bytes.strip_prefix(KEYBOARD_EVENTS_MAGIC) {
            return bincode::serde::decode_from_slice::<Self, _>(payload, config)
                .map(|(events, _)| events)
                .map_err(|e| format!("Failed to parse keyboard events binary payload: {e}"));
        }

        if source_path
            .extension()
            .and_then(|extension| extension.to_str())
            .is_some_and(|extension| extension == "bin")
            && let Ok((events, _)) = bincode::serde::decode_from_slice::<Self, _>(bytes, config)
        {
            return Ok(events);
        }

        serde_json::from_slice(bytes)
            .map_err(|e| format!("Failed to parse keyboard events legacy JSON: {e}"))
    }

    pub fn to_bytes(&self) -> Result<Vec<u8>, String> {
        let mut bytes = KEYBOARD_EVENTS_MAGIC.to_vec();
        bincode::serde::encode_into_std_write(self, &mut bytes, bincode::config::standard())
            .map_err(|e| format!("Failed to serialize keyboard events: {e}"))?;
        Ok(bytes)
    }

    pub fn write_to_file(&self, path: &Path) -> Result<(), String> {
        std::fs::write(path, self.to_bytes()?)
            .map_err(|e| format!("Failed to write keyboard events file: {e}"))
    }
}

const MODIFIER_KEYS: &[&str] = &[
    "LShift", "RShift", "LControl", "RControl", "LAlt", "RAlt", "LOption", "ROption", "LMeta",
    "RMeta", "Meta", "Command", "RCommand",
];

const SPECIAL_KEY_SYMBOLS: &[(&str, &str)] = &[
    ("Enter", "⏎"),
    ("Return", "⏎"),
    ("Tab", "⇥"),
    ("Backspace", "⌫"),
    ("Delete", "⌦"),
    ("Escape", "⎋"),
    ("Space", "␣"),
    ("Up", "↑"),
    ("Down", "↓"),
    ("Left", "←"),
    ("Right", "→"),
    ("Home", "⇱"),
    ("End", "⇲"),
    ("PageUp", "⇞"),
    ("PageDown", "⇟"),
];

fn is_modifier_key(key: &str) -> bool {
    MODIFIER_KEYS.contains(&key)
}

fn special_key_symbol(key: &str) -> Option<&'static str> {
    SPECIAL_KEY_SYMBOLS
        .iter()
        .find(|&&(k, _)| k == key)
        .map(|&(_, symbol)| symbol)
}

fn display_char_for_key(key: &str) -> Option<String> {
    if key.len() == 1 {
        return Some(key.to_string());
    }

    if let Some(symbol) = special_key_symbol(key) {
        return Some(symbol.to_string());
    }

    if is_modifier_key(key) {
        return None;
    }

    None
}

fn modifier_prefix(active_modifiers: &[String]) -> String {
    let mut parts = Vec::new();

    let has = |names: &[&str]| active_modifiers.iter().any(|m| names.contains(&m.as_str()));

    if has(&["LControl", "RControl"]) {
        parts.push("⌃");
    }
    if has(&["LAlt", "RAlt", "LOption", "ROption"]) {
        parts.push("⌥");
    }
    if has(&["LShift", "RShift"]) {
        parts.push("⇧");
    }
    if has(&["LMeta", "RMeta", "Meta", "Command", "RCommand"]) {
        parts.push("⌘");
    }

    if parts.is_empty() {
        String::new()
    } else {
        parts.join("")
    }
}

#[derive(Type, Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct KeyPressDisplay {
    pub key: String,
    pub time_offset: f64,
}

#[derive(Type, Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct KeyboardTrackSegment {
    pub id: String,
    pub start: f64,
    pub end: f64,
    pub display_text: String,
    #[serde(default)]
    pub keys: Vec<KeyPressDisplay>,
    #[serde(default)]
    pub fade_duration_override: Option<f32>,
    #[serde(default)]
    pub position_override: Option<String>,
    #[serde(default)]
    pub color_override: Option<String>,
    #[serde(default)]
    pub background_color_override: Option<String>,
    #[serde(default)]
    pub font_size_override: Option<u32>,
    #[serde(default)]
    pub uppercase_override: Option<bool>,
}

impl KeyboardTrackSegment {
    pub fn remap_times(&mut self, map: impl Fn(f64) -> f64) {
        let old_start = self.start;
        let new_start = map(old_start);
        for key in &mut self.keys {
            key.time_offset =
                ((map(old_start + key.time_offset / 1000.0) - new_start) * 1000.0).max(0.0);
        }
        self.start = new_start;
        self.end = map(self.end).max(new_start);
    }

    pub fn ripple_delete(&mut self, cut_start: f64, cut_end: f64, shift: f64) -> bool {
        if self.end <= cut_start {
            return true;
        }
        if self.start >= cut_start && self.end <= cut_end {
            return false;
        }
        let old_start = self.start;
        let retained: Vec<bool> = self
            .keys
            .iter()
            .map(|key| {
                let time = old_start + key.time_offset / 1000.0;
                time < cut_start || time >= cut_end
            })
            .collect();
        let removes_keys = retained.iter().any(|keep| !keep);
        let chars: Vec<char> = self.display_text.chars().collect();
        if removes_keys && chars.len() != self.keys.len() {
            return false;
        }
        if removes_keys {
            self.display_text = chars
                .into_iter()
                .zip(&retained)
                .filter_map(|(ch, keep)| keep.then_some(ch))
                .collect();
        }
        if self.start >= cut_end {
            self.start -= shift;
            self.end -= shift;
        } else if self.start < cut_start && self.end > cut_end {
            self.end -= shift;
        } else if self.start < cut_start {
            self.end = cut_start;
        } else {
            self.start = cut_end - shift;
            self.end = (self.end - shift).max(self.start);
        }
        let new_start = self.start;
        let mut index = 0;
        self.keys.retain_mut(|key| {
            let keep = retained[index];
            index += 1;
            if keep {
                let time = old_start + key.time_offset / 1000.0;
                let mapped = if time >= cut_end { time - shift } else { time };
                key.time_offset = ((mapped - new_start) * 1000.0).max(0.0);
            }
            keep
        });
        self.end > self.start && (!removes_keys || !self.keys.is_empty())
    }

    pub fn split_at(&self, at: f64) -> Option<(Self, Self)> {
        if !at.is_finite() || at <= self.start || at >= self.end {
            return None;
        }
        let mut left = self.clone();
        let mut right = self.clone();
        left.end = at;
        right.start = at;
        if self.keys.is_empty() {
            return Some((left, right));
        }
        let chars: Vec<char> = self.display_text.chars().collect();
        if chars.len() != self.keys.len() {
            return None;
        }
        left.keys.clear();
        right.keys.clear();
        left.display_text.clear();
        right.display_text.clear();
        for (key, ch) in self.keys.iter().zip(chars) {
            let absolute = self.start + key.time_offset / 1000.0;
            if absolute < at {
                left.keys.push(key.clone());
                left.display_text.push(ch);
            } else {
                right.keys.push(KeyPressDisplay {
                    key: key.key.clone(),
                    time_offset: (absolute - at) * 1000.0,
                });
                right.display_text.push(ch);
            }
        }
        if left.keys.is_empty() || right.keys.is_empty() {
            return None;
        }
        Some((left, right))
    }
}

fn load_project_keyboard_events(
    meta: &crate::RecordingMeta,
) -> Result<Vec<(KeyboardEvents, f64)>, String> {
    let Some(crate::StudioRecordingMeta::MultipleSegments { inner }) = meta.studio_meta() else {
        return Ok(Vec::new());
    };
    inner
        .segments
        .iter()
        .map(|take| {
            let path = take.keyboard.clone().or_else(|| {
                let directory = take.display.path.parent()?;
                [KEYBOARD_EVENTS_FILE_NAME, LEGACY_KEYBOARD_EVENTS_FILE_NAME]
                    .into_iter()
                    .map(|name| directory.join(name))
                    .find(|path| meta.path(path).exists())
            });
            let events = match path {
                Some(path) => KeyboardEvents::load_from_file(&meta.path(&path))?,
                None => KeyboardEvents::default(),
            };
            Ok((events, take.latest_start_time().unwrap_or(0.0)))
        })
        .collect()
}

pub fn generate_project_keyboard_segments(
    meta: &crate::RecordingMeta,
    timeline: &crate::TimelineConfiguration,
    settings: &crate::KeyboardSettings,
) -> Result<Vec<KeyboardTrackSegment>, String> {
    let takes = load_project_keyboard_events(meta)?;
    Ok(project_keyboard_events(&takes, timeline, settings))
}

fn legacy_keyboard_capture_offset(meta: &crate::RecordingMeta, recording_clip: u32) -> f64 {
    match meta.studio_meta() {
        Some(crate::StudioRecordingMeta::MultipleSegments { inner }) => inner
            .segments
            .get(recording_clip as usize)
            .and_then(|take| take.latest_start_time())
            .unwrap_or(0.0),
        _ => 0.0,
    }
}

fn project_legacy_keyboard_track(
    meta: &crate::RecordingMeta,
    timeline: &crate::TimelineConfiguration,
    settings: &crate::KeyboardSettings,
) -> Vec<KeyboardTrackSegment> {
    let offsets = crate::caption_timing::clip_timeline_offsets(timeline);
    let holds = timeline.hold_windows();
    let to_output = |effective: f64, end: bool| {
        let mut output = effective;
        for (start, finish) in &holds {
            if output > *start || (!end && output == *start) {
                output += finish - start;
            } else {
                break;
            }
        }
        output
    };
    let mut result: Vec<_> = timeline
        .keyboard_segments
        .iter()
        .filter(|segment| segment.id.starts_with("kb-edit-"))
        .cloned()
        .collect();
    for (index, clip) in timeline.segments.iter().enumerate() {
        if !clip.timescale.is_finite() || clip.timescale <= 0.0 {
            continue;
        }
        let offset = legacy_keyboard_capture_offset(meta, clip.recording_clip);
        let source_start = clip.start + offset;
        let source_end = clip.end + offset;
        for previous in &timeline.keyboard_segments {
            if previous.id.starts_with("kb-edit-") {
                continue;
            }
            let start = previous.start.max(source_start);
            let end = previous.end.min(source_end);
            if !start.is_finite() || !end.is_finite() || end <= start {
                continue;
            }
            let map = |time: f64, end: bool| {
                to_output(offsets[index] + (time - source_start) / clip.timescale, end)
            };
            let mut segment = previous.clone();
            segment.id = format!("kb-edit-legacy-{index}-{}", previous.id);
            segment.start = map(start, false);
            segment.end = map(end, true);
            let retained: Vec<bool> = previous
                .keys
                .iter()
                .map(|key| {
                    let time = previous.start + key.time_offset / 1000.0;
                    time >= source_start && time < source_end
                })
                .collect();
            if retained.iter().any(|keep| !keep) {
                let chars: Vec<char> = previous.display_text.chars().collect();
                if chars.len() != previous.keys.len() || !retained.iter().any(|keep| *keep) {
                    continue;
                }
                segment.display_text = chars
                    .into_iter()
                    .zip(&retained)
                    .filter_map(|(ch, keep)| keep.then_some(ch))
                    .collect();
            }
            segment.keys = previous
                .keys
                .iter()
                .zip(retained)
                .filter(|(_, keep)| *keep)
                .map(|(key, _)| KeyPressDisplay {
                    key: key.key.clone(),
                    time_offset: ((map(previous.start + key.time_offset / 1000.0, false)
                        - segment.start)
                        * 1000.0)
                        .max(0.0),
                })
                .collect();
            segment.fade_duration_override = Some(
                previous
                    .fade_duration_override
                    .unwrap_or(settings.fade_duration)
                    / clip.timescale as f32,
            );
            result.push(segment);
        }
    }
    result.sort_by(|a, b| a.start.total_cmp(&b.start));
    result
}

fn legacy_keyboard_tracks_match(
    generated: &[KeyboardTrackSegment],
    saved: &[KeyboardTrackSegment],
) -> bool {
    generated.len() == saved.len()
        && generated.iter().zip(saved).all(|(generated, saved)| {
            generated.id == saved.id
                && (generated.start - saved.start).abs() <= 1e-6
                && (generated.end - saved.end).abs() <= 1e-6
                && generated.display_text == saved.display_text
                && generated.keys.len() == saved.keys.len()
                && generated
                    .keys
                    .iter()
                    .zip(&saved.keys)
                    .all(|(a, b)| a.key == b.key && (a.time_offset - b.time_offset).abs() <= 1e-3)
        })
}

fn legacy_keyboard_after_cuts(
    legacy: &[KeyboardTrackSegment],
    timeline: &crate::TimelineConfiguration,
) -> Option<Vec<KeyboardTrackSegment>> {
    if timeline.segments.is_empty()
        || !timeline.transitions.is_empty()
        || !timeline.hold_windows().is_empty()
        || timeline.segments.iter().any(|clip| {
            clip.recording_clip != 0
                || !clip.timescale.is_finite()
                || (clip.timescale - 1.0).abs() > 1e-6
                || !clip.start.is_finite()
                || clip.start < 0.0
                || !clip.end.is_finite()
                || clip.end <= clip.start
        })
        || timeline
            .segments
            .windows(2)
            .any(|pair| pair[0].end > pair[1].start)
    {
        return None;
    }
    let mut projected = legacy.to_vec();
    for index in (0..timeline.segments.len()).rev() {
        let cut_start = index
            .checked_sub(1)
            .map(|previous| timeline.segments[previous].end)
            .unwrap_or(0.0);
        let cut_end = timeline.segments[index].start;
        let shift = cut_end - cut_start;
        if shift <= 1e-6 {
            continue;
        }
        projected.retain_mut(|segment| {
            if segment.end <= cut_start {
                return true;
            }
            if segment.start >= cut_end {
                segment.start -= shift;
                segment.end -= shift;
            } else if segment.start >= cut_start && segment.end <= cut_end {
                return false;
            } else if segment.start < cut_start && segment.end > cut_end {
                segment.end -= shift;
            } else if segment.start < cut_start {
                segment.end = cut_start;
            } else {
                segment.start = cut_start;
                segment.end = (segment.end - shift).max(cut_start);
            }
            true
        });
    }
    Some(projected)
}

pub fn synchronize_legacy_keyboard(
    meta: &crate::RecordingMeta,
    project: &mut crate::ProjectConfiguration,
) {
    let Some(timeline) = &mut project.timeline else {
        return;
    };
    if timeline.keyboard_segments.is_empty()
        || timeline
            .keyboard_segments
            .iter()
            .all(|segment| segment.id.starts_with("kb-edit-"))
    {
        return;
    }
    let settings = project
        .keyboard
        .as_ref()
        .map(|keyboard| keyboard.settings.clone())
        .unwrap_or_default();
    let takes = load_project_keyboard_events(meta).ok();
    let mut events = KeyboardEvents {
        presses: takes
            .as_ref()
            .into_iter()
            .flatten()
            .flat_map(|(events, _)| events.presses.clone())
            .collect(),
    };
    events
        .presses
        .sort_by(|a, b| a.time_ms.total_cmp(&b.time_ms));
    let legacy = group_key_events(
        &events,
        settings.grouping_threshold_ms,
        f64::from(settings.linger_duration) * 1000.0,
        settings.show_modifiers,
        settings.show_special_keys,
    );
    let unchanged =
        takes.is_some() && legacy_keyboard_tracks_match(&legacy, &timeline.keyboard_segments);
    let stale_cut_track = takes.as_ref().is_some_and(|takes| takes.len() == 1)
        && legacy_keyboard_after_cuts(&legacy, timeline).is_some_and(|projected| {
            legacy_keyboard_tracks_match(&projected, &timeline.keyboard_segments)
        });
    if !unchanged && !stale_cut_track {
        timeline.keyboard_segments = project_legacy_keyboard_track(meta, timeline, &settings);
        return;
    }
    let mut generated =
        project_keyboard_events(takes.as_deref().unwrap_or_default(), timeline, &settings);
    let clip_offsets = crate::caption_timing::clip_timeline_offsets(timeline);
    let holds = timeline.hold_windows();
    for segment in &mut generated {
        let Some(index) = segment
            .id
            .strip_prefix("kb-edit-")
            .and_then(|id| id.split_once('-'))
            .and_then(|(index, _)| index.parse::<usize>().ok())
        else {
            continue;
        };
        let Some(clip) = timeline.segments.get(index) else {
            continue;
        };
        let held_time: f64 = holds
            .iter()
            .map(|(start, end)| (segment.start - start).clamp(0.0, end - start))
            .sum();
        let source_time =
            clip.start + (segment.start - held_time - clip_offsets[index]) * clip.timescale;
        let captured = source_time + legacy_keyboard_capture_offset(meta, clip.recording_clip);
        let Some(source) = legacy
            .iter()
            .rev()
            .find(|source| captured >= source.start && captured < source.end)
        else {
            continue;
        };
        let Some(previous) = timeline
            .keyboard_segments
            .iter()
            .find(|previous| previous.id == source.id)
        else {
            continue;
        };
        segment.fade_duration_override = previous.fade_duration_override;
        segment.position_override = previous.position_override.clone();
        segment.color_override = previous.color_override.clone();
        segment.background_color_override = previous.background_color_override.clone();
        segment.font_size_override = previous.font_size_override;
        segment.uppercase_override = previous.uppercase_override;
    }
    timeline.keyboard_segments = generated;
}

struct PreparedKeyboardEvents<'a> {
    ordered: Vec<&'a KeyPressEvent>,
    modifiers: Option<[Vec<usize>; MODIFIER_KEYS.len()]>,
    indexed_until: usize,
}

impl<'a> PreparedKeyboardEvents<'a> {
    fn new(events: &'a KeyboardEvents) -> Self {
        let mut ordered: Vec<_> = events
            .presses
            .iter()
            .filter(|event| event.time_ms.is_finite())
            .collect();
        ordered.sort_by(|a, b| a.time_ms.total_cmp(&b.time_ms));
        Self {
            ordered,
            modifiers: None,
            indexed_until: 0,
        }
    }

    fn for_clip(
        &mut self,
        source_start: f64,
        source_end: f64,
    ) -> impl Iterator<Item = (&KeyPressEvent, bool)> {
        let first = self
            .ordered
            .partition_point(|event| event.time_ms / 1000.0 < source_start);
        let last = self
            .ordered
            .partition_point(|event| event.time_ms / 1000.0 < source_end)
            .max(first);
        let mut held = [None; MODIFIER_KEYS.len()];
        if first > 0 && first < last {
            let modifiers = self
                .modifiers
                .get_or_insert_with(|| std::array::from_fn(|_| Vec::new()));
            for (index, event) in self
                .ordered
                .iter()
                .enumerate()
                .take(first)
                .skip(self.indexed_until)
            {
                if let Some(modifier) = MODIFIER_KEYS.iter().position(|key| *key == event.key) {
                    modifiers[modifier].push(index);
                }
            }
            self.indexed_until = self.indexed_until.max(first);
            for (history, held) in modifiers.iter().zip(&mut held) {
                if let Some(previous) = history
                    .partition_point(|index| *index < first)
                    .checked_sub(1)
                {
                    let index = history[previous];
                    *held = self.ordered[index].down.then_some(index);
                }
            }
            held.sort_unstable();
        }
        let ordered = &self.ordered;
        held.into_iter()
            .flatten()
            .map(|index| (ordered[index], true))
            .chain(ordered[first..last].iter().map(|event| (*event, false)))
    }
}

fn project_keyboard_events(
    takes: &[(KeyboardEvents, f64)],
    timeline: &crate::TimelineConfiguration,
    settings: &crate::KeyboardSettings,
) -> Vec<KeyboardTrackSegment> {
    let holds = timeline.hold_windows();
    let output_time = |time: f64, end: bool| {
        let mut output = time;
        for (start, finish) in &holds {
            if output > *start || (!end && output == *start) {
                output += finish - start;
            } else {
                break;
            }
        }
        output
    };
    let mut edited_start = 0.0;
    let mut result = Vec::new();
    let mut prepared: Vec<Option<PreparedKeyboardEvents>> =
        (0..takes.len()).map(|_| None).collect();
    for (index, clip) in timeline.segments.iter().enumerate() {
        if !clip.start.is_finite()
            || !clip.end.is_finite()
            || !clip.timescale.is_finite()
            || clip.timescale <= 0.0
            || clip.end <= clip.start
        {
            continue;
        }
        edited_start -= timeline
            .effective_transition(index)
            .map_or(0.0, |transition| transition.duration);
        let edited_end = edited_start + clip.duration();
        if let Some((events, capture_offset)) = takes.get(clip.recording_clip as usize)
            && capture_offset.is_finite()
        {
            let source_start = clip.start + capture_offset;
            let source_end = clip.end + capture_offset;
            let mut presses = Vec::new();
            let ordered = prepared[clip.recording_clip as usize]
                .get_or_insert_with(|| PreparedKeyboardEvents::new(events));
            for (event, held) in ordered.for_clip(source_start, source_end) {
                let mut projected = event.clone();
                let time = if held {
                    edited_start
                } else {
                    edited_start + (event.time_ms / 1000.0 - source_start) / clip.timescale
                };
                projected.time_ms = output_time(time, false) * 1000.0;
                presses.push(projected);
            }
            let mut grouped = group_key_events(
                &KeyboardEvents { presses },
                settings.grouping_threshold_ms,
                f64::from(settings.linger_duration) * 1000.0,
                settings.show_modifiers,
                settings.show_special_keys,
            );
            for segment in &mut grouped {
                segment.id = format!("kb-edit-{index}-{}", segment.id);
                segment.end = segment.end.min(output_time(edited_end, true));
            }
            result.extend(
                grouped
                    .into_iter()
                    .filter(|segment| segment.end > segment.start),
            );
        }
        edited_start = edited_end;
    }
    result.sort_by(|a, b| a.start.total_cmp(&b.start));
    result
}

pub fn group_key_events(
    events: &KeyboardEvents,
    grouping_threshold_ms: f64,
    linger_duration_ms: f64,
    show_modifiers: bool,
    show_special_keys: bool,
) -> Vec<KeyboardTrackSegment> {
    let mut segments: Vec<KeyboardTrackSegment> = Vec::new();

    let down_events: Vec<&KeyPressEvent> = events.presses.iter().filter(|e| e.down).collect();

    if down_events.is_empty() {
        return segments;
    }

    let ordered = events.presses.iter().all(|event| event.time_ms.is_finite())
        && events
            .presses
            .windows(2)
            .all(|pair| pair[0].time_ms <= pair[1].time_ms);
    let mut next_modifier_event = 0;
    let mut active = Vec::new();
    let mut active_modifiers_at = |time_ms: f64| -> Vec<String> {
        if !ordered {
            next_modifier_event = 0;
            active.clear();
        }
        while let Some(event) = events.presses.get(next_modifier_event) {
            if event.time_ms > time_ms {
                break;
            }
            // Equal-time releases after this press still affect its modifier state.
            next_modifier_event += 1;
            if is_modifier_key(&event.key) {
                if event.down {
                    if !active.contains(&event.key) {
                        active.push(event.key.clone());
                    }
                } else {
                    active.retain(|k| k != &event.key);
                }
            }
        }
        active.clone()
    };

    let mut current_group_start: Option<f64> = None;
    let mut current_display = String::new();
    let mut current_keys: Vec<KeyPressDisplay> = Vec::new();
    let mut last_key_time: f64 = 0.0;
    let mut segment_counter: u64 = 0;

    for event in &down_events {
        let is_modifier = is_modifier_key(&event.key);

        if is_modifier && !show_modifiers {
            continue;
        }

        let is_special = special_key_symbol(&event.key).is_some() && event.key != "Space";

        if is_special && !show_special_keys && !is_modifier {
            continue;
        }

        if event.key == "Space" {
            let typing_active = current_group_start.is_some()
                && !current_display.is_empty()
                && (event.time_ms - last_key_time) <= grouping_threshold_ms;

            if typing_active {
                if let Some(start) = current_group_start {
                    segment_counter += 1;
                    segments.push(KeyboardTrackSegment {
                        id: format!("kb-{segment_counter}"),
                        start: start / 1000.0,
                        end: (event.time_ms + linger_duration_ms) / 1000.0,
                        display_text: current_display.clone(),
                        keys: take_group_keys(&mut current_keys),
                        fade_duration_override: None,
                        position_override: None,
                        color_override: None,
                        background_color_override: None,
                        font_size_override: None,
                        uppercase_override: None,
                    });
                }
                current_display.clear();
                current_keys.clear();
                current_group_start = None;
                last_key_time = event.time_ms;
                continue;
            }

            if let Some(start) = current_group_start
                && !current_display.is_empty()
            {
                segment_counter += 1;
                segments.push(KeyboardTrackSegment {
                    id: format!("kb-{segment_counter}"),
                    start: start / 1000.0,
                    end: (last_key_time + linger_duration_ms) / 1000.0,
                    display_text: current_display.clone(),
                    keys: take_group_keys(&mut current_keys),
                    fade_duration_override: None,
                    position_override: None,
                    color_override: None,
                    background_color_override: None,
                    font_size_override: None,
                    uppercase_override: None,
                });
                current_display.clear();
                current_keys.clear();
                current_group_start = None;
            }

            if (event.time_ms - last_key_time) > grouping_threshold_ms {
                segment_counter += 1;
                segments.push(KeyboardTrackSegment {
                    id: format!("kb-{segment_counter}"),
                    start: event.time_ms / 1000.0,
                    end: (event.time_ms + linger_duration_ms) / 1000.0,
                    display_text: "␣".to_string(),
                    keys: vec![KeyPressDisplay {
                        key: event.key.clone(),
                        time_offset: 0.0,
                    }],
                    fade_duration_override: None,
                    position_override: None,
                    color_override: None,
                    background_color_override: None,
                    font_size_override: None,
                    uppercase_override: None,
                });
            }

            last_key_time = event.time_ms;
            continue;
        }

        let should_start_new_group = current_group_start.is_none()
            || (event.time_ms - last_key_time) > grouping_threshold_ms
            || is_modifier;

        if should_start_new_group && let Some(start) = current_group_start {
            if !current_display.is_empty() {
                segment_counter += 1;
                segments.push(KeyboardTrackSegment {
                    id: format!("kb-{segment_counter}"),
                    start: start / 1000.0,
                    end: (last_key_time + linger_duration_ms) / 1000.0,
                    display_text: current_display.clone(),
                    keys: take_group_keys(&mut current_keys),
                    fade_duration_override: None,
                    position_override: None,
                    color_override: None,
                    background_color_override: None,
                    font_size_override: None,
                    uppercase_override: None,
                });
            }
            current_display.clear();
            current_keys.clear();
            current_group_start = None;
        }

        if is_modifier {
            let modifiers = active_modifiers_at(event.time_ms);
            let prefix = modifier_prefix(&modifiers);
            if !prefix.is_empty() {
                current_group_start = Some(event.time_ms);
                current_display = prefix;
                current_keys.push(KeyPressDisplay {
                    key: event.key.clone(),
                    time_offset: 0.0,
                });
                last_key_time = event.time_ms;
            }
            continue;
        }

        if event.key == "Backspace" && !current_display.is_empty() {
            current_display.pop();
            let _ = current_keys.pop();
            if current_display.is_empty() {
                current_group_start = None;
            }
            last_key_time = event.time_ms;
            continue;
        }

        let active_mods = active_modifiers_at(event.time_ms);
        let has_command_mod = active_mods.iter().any(|m| {
            matches!(
                m.as_str(),
                "LMeta" | "RMeta" | "Meta" | "Command" | "RCommand" | "LControl" | "RControl"
            )
        });

        if has_command_mod && show_modifiers {
            let prefix = modifier_prefix(&active_mods);
            let key_display = display_char_for_key(&event.key).unwrap_or_else(|| event.key.clone());
            let combo = format!("{prefix}{}", key_display.to_uppercase());

            segment_counter += 1;
            segments.push(KeyboardTrackSegment {
                id: format!("kb-{segment_counter}"),
                start: event.time_ms / 1000.0,
                end: (event.time_ms + linger_duration_ms) / 1000.0,
                display_text: combo,
                keys: vec![KeyPressDisplay {
                    key: event.key.clone(),
                    time_offset: 0.0,
                }],
                fade_duration_override: None,
                position_override: None,
                color_override: None,
                background_color_override: None,
                font_size_override: None,
                uppercase_override: None,
            });

            current_display.clear();
            current_keys.clear();
            current_group_start = None;
            last_key_time = event.time_ms;
            continue;
        }

        if let Some(display_char) = display_char_for_key(&event.key) {
            if current_group_start.is_none() {
                current_group_start = Some(event.time_ms);
            }

            let offset = event.time_ms - current_group_start.unwrap();
            current_display.push_str(&display_char);
            current_keys.push(KeyPressDisplay {
                key: event.key.clone(),
                time_offset: offset,
            });
            last_key_time = event.time_ms;
        }
    }

    if let Some(start) = current_group_start
        && !current_display.is_empty()
    {
        segment_counter += 1;
        segments.push(KeyboardTrackSegment {
            id: format!("kb-{segment_counter}"),
            start: start / 1000.0,
            end: (last_key_time + linger_duration_ms) / 1000.0,
            display_text: current_display,
            keys: current_keys,
            fade_duration_override: None,
            position_override: None,
            color_override: None,
            background_color_override: None,
            font_size_override: None,
            uppercase_override: None,
        });
    }

    segments
}

fn take_group_keys(keys: &mut Vec<KeyPressDisplay>) -> Vec<KeyPressDisplay> {
    let mut completed = Vec::with_capacity(keys.len());
    completed.append(keys);
    completed
}

#[cfg(test)]
mod tests {
    use super::*;

    fn key_down(key: &str, time_ms: f64) -> KeyPressEvent {
        KeyPressEvent {
            key: key.to_string(),
            key_code: key.to_string(),
            time_ms,
            down: true,
        }
    }

    fn key_up(key: &str, time_ms: f64) -> KeyPressEvent {
        KeyPressEvent {
            key: key.to_string(),
            key_code: key.to_string(),
            time_ms,
            down: false,
        }
    }

    #[test]
    fn completed_groups_preserve_text_keys_and_times_after_reusing_the_accumulator() {
        for (terminator, time, end) in [
            ("Space", 300.0, 0.8),
            ("Space", 1000.0, 0.7),
            ("x", 1000.0, 0.7),
            ("LShift", 300.0, 0.7),
        ] {
            let events = KeyboardEvents {
                presses: vec![
                    key_down("h", 100.0),
                    key_down("i", 200.0),
                    key_down(terminator, time),
                    key_down("a", time + 100.0),
                    key_down("Space", time + 200.0),
                    key_down("z", time + 300.0),
                ],
            };
            let before = events.to_bytes().unwrap();
            let grouped = group_key_events(&events, 300.0, 500.0, true, true);
            assert_eq!(
                serde_json::to_value(&grouped[0]).unwrap(),
                serde_json::json!({
                    "id": "kb-1", "start": 0.1, "end": end, "displayText": "hi",
                    "keys": [{"key": "h", "timeOffset": 0.0}, {"key": "i", "timeOffset": 100.0}],
                    "fadeDurationOverride": null, "positionOverride": null, "colorOverride": null,
                    "backgroundColorOverride": null, "fontSizeOverride": null, "uppercaseOverride": null
                }),
                "{terminator} at {time}"
            );
            assert_eq!(grouped.last().unwrap().display_text, "z");
            assert_eq!(events.to_bytes().unwrap(), before);
        }
    }

    #[test]
    fn groups_rapid_typing_into_word() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("h", 100.0),
                key_up("h", 150.0),
                key_down("e", 200.0),
                key_up("e", 250.0),
                key_down("l", 300.0),
                key_up("l", 350.0),
                key_down("l", 400.0),
                key_up("l", 450.0),
                key_down("o", 500.0),
                key_up("o", 550.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "hello");
        assert_eq!(segments[0].keys.len(), 5);
    }

    #[test]
    fn splits_on_long_pause() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("h", 100.0),
                key_up("h", 150.0),
                key_down("i", 200.0),
                key_up("i", 250.0),
                key_down("b", 1000.0),
                key_up("b", 1050.0),
                key_down("y", 1100.0),
                key_up("y", 1150.0),
                key_down("e", 1200.0),
                key_up("e", 1250.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "hi");
        assert_eq!(segments[1].display_text, "bye");
    }

    #[test]
    fn backspace_removes_last_char() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("h", 100.0),
                key_up("h", 150.0),
                key_down("e", 200.0),
                key_up("e", 250.0),
                key_down("Backspace", 300.0),
                key_up("Backspace", 350.0),
                key_down("a", 400.0),
                key_up("a", 450.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "ha");
    }

    #[test]
    fn backspace_keeps_display_and_key_timing_aligned() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("h", 100.0),
                key_down("e", 200.0),
                key_down("Backspace", 300.0),
                key_down("a", 400.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "ha");
        assert_eq!(segments[0].keys.len(), 2);
        assert_eq!(segments[0].keys[0].key, "h");
        assert_eq!(segments[0].keys[1].key, "a");
        assert_eq!(segments[0].keys[1].time_offset, 300.0);
        assert!(segments[0].split_at(0.35).is_some());
    }

    #[test]
    fn backspace_to_empty_does_not_emit_blank_segment() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("a", 100.0),
                key_up("a", 150.0),
                key_down("Backspace", 200.0),
                key_up("Backspace", 250.0),
                key_down("x", 1000.0),
                key_up("x", 1050.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "x");
    }

    #[test]
    fn backspace_to_empty_rebases_the_next_character() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("a", 100.0),
                key_down("Backspace", 200.0),
                key_down("x", 250.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].start, 0.25);
        assert_eq!(segments[0].display_text, "x");
        assert_eq!(segments[0].keys.len(), 1);
        assert_eq!(segments[0].keys[0].key, "x");
        assert_eq!(segments[0].keys[0].time_offset, 0.0);
    }

    #[test]
    fn empty_events_returns_empty() {
        let events = KeyboardEvents { presses: vec![] };
        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert!(segments.is_empty());
    }

    #[test]
    fn special_keys_show_symbols() {
        let events = KeyboardEvents {
            presses: vec![key_down("Enter", 100.0), key_up("Enter", 150.0)],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "⏎");
    }

    #[test]
    fn keyboard_encoding_matches_the_original_payload_copy() {
        for count in [0, 1, 250, 251, 65_535, 65_536] {
            let events = KeyboardEvents {
                presses: (0..count)
                    .map(|index| KeyPressEvent {
                        key: ["", "a", "文字🖱", "LControl"][index % 4].into(),
                        key_code: "KeyA".into(),
                        time_ms: [
                            f64::NEG_INFINITY,
                            -0.0,
                            f64::from_bits(0x7ff8_0000_0000_1234),
                            1.25,
                            f64::INFINITY,
                        ][index % 5],
                        down: index % 2 == 0,
                    })
                    .collect(),
            };
            let mut expected = KEYBOARD_EVENTS_MAGIC.to_vec();
            expected.extend(
                bincode::serde::encode_to_vec(&events, bincode::config::standard()).unwrap(),
            );
            let actual = events.to_bytes().unwrap();
            assert_eq!(actual, expected, "{count} events");
            let decoded = KeyboardEvents::from_bytes(&actual, Path::new("keyboard.bin")).unwrap();
            assert_eq!(decoded.presses.len(), events.presses.len());
            for (decoded, source) in decoded.presses.iter().zip(&events.presses) {
                assert_eq!(decoded.key, source.key);
                assert_eq!(decoded.key_code, source.key_code);
                assert_eq!(decoded.time_ms.to_bits(), source.time_ms.to_bits());
                assert_eq!(decoded.down, source.down);
            }
        }
        for length in [0, 1, 250, 251, 65_535, 65_536] {
            let events = KeyboardEvents {
                presses: vec![key_down(&"x".repeat(length), 1.25)],
            };
            let mut expected = KEYBOARD_EVENTS_MAGIC.to_vec();
            expected.extend(
                bincode::serde::encode_to_vec(&events, bincode::config::standard()).unwrap(),
            );
            assert_eq!(events.to_bytes().unwrap(), expected, "key length {length}");
        }
    }

    #[test]
    fn roundtrips_binary_keyboard_events() {
        let events = KeyboardEvents {
            presses: vec![key_down("a", 100.0), key_up("a", 150.0)],
        };
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join(KEYBOARD_EVENTS_FILE_NAME);

        events.write_to_file(&path).unwrap();

        let loaded = KeyboardEvents::load_from_file(&path).unwrap();
        assert_eq!(loaded.presses, events.presses);
    }

    #[test]
    fn loads_legacy_json_keyboard_events() {
        let events = KeyboardEvents {
            presses: vec![key_down("b", 100.0), key_up("b", 150.0)],
        };
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join(LEGACY_KEYBOARD_EVENTS_FILE_NAME);

        std::fs::write(&path, serde_json::to_vec(&events).unwrap()).unwrap();

        let loaded = KeyboardEvents::load_from_file(&path).unwrap();
        assert_eq!(loaded.presses, events.presses);
    }

    #[test]
    fn keyboard_bytes_preserve_versioned_unversioned_and_json_dispatch() {
        let expected = KeyboardEvents {
            presses: vec![key_down("文字🖱", 12.5), key_up("文字🖱", 19.75)],
        };
        let binary = bincode::serde::encode_to_vec(&expected, bincode::config::standard()).unwrap();
        let mut versioned = KEYBOARD_EVENTS_MAGIC.to_vec();
        versioned.extend(&binary);
        let json = serde_json::to_vec(&expected).unwrap();
        for (bytes, path) in [
            (&versioned, "keyboard.bin"),
            (&versioned, "keyboard.json"),
            (&binary, "keyboard.bin"),
            (&json, "keyboard.bin"),
            (&json, "keyboard.json"),
            (&json, "keyboard.BIN"),
        ] {
            let events = KeyboardEvents::from_bytes(bytes, Path::new(path)).unwrap();
            assert_eq!(events.presses, expected.presses);
        }
        assert!(KeyboardEvents::from_bytes(&binary, Path::new("keyboard.BIN")).is_err());
    }

    #[test]
    fn keyboard_bytes_keep_existing_trailing_data_and_error_behavior() {
        let expected = KeyboardEvents {
            presses: vec![key_down("a", 1.0)],
        };
        let mut binary =
            bincode::serde::encode_to_vec(&expected, bincode::config::standard()).unwrap();
        binary.extend(b"trailing bytes");
        assert_eq!(
            KeyboardEvents::from_bytes(&binary, Path::new("keyboard.bin"))
                .unwrap()
                .presses,
            expected.presses
        );
        let mut versioned = KEYBOARD_EVENTS_MAGIC.to_vec();
        versioned.extend(b"{\"presses\":[]}");
        assert!(
            KeyboardEvents::from_bytes(&versioned, Path::new("keyboard.json"))
                .unwrap_err()
                .starts_with("Failed to parse keyboard events binary payload: ")
        );
        assert!(
            KeyboardEvents::from_bytes(b"{\"presses\":[]} trailing", Path::new("keyboard.bin"))
                .unwrap_err()
                .starts_with("Failed to parse keyboard events legacy JSON: ")
        );
    }

    #[test]
    fn space_splits_continuous_typing_into_words() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("h", 100.0),
                key_up("h", 150.0),
                key_down("i", 200.0),
                key_up("i", 250.0),
                key_down("Space", 300.0),
                key_up("Space", 350.0),
                key_down("b", 400.0),
                key_up("b", 450.0),
                key_down("y", 500.0),
                key_up("y", 550.0),
                key_down("e", 600.0),
                key_up("e", 650.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "hi");
        assert_eq!(segments[1].display_text, "bye");
    }

    #[test]
    fn consecutive_spaces_do_not_create_empty_segments() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("a", 100.0),
                key_up("a", 150.0),
                key_down("Space", 200.0),
                key_up("Space", 250.0),
                key_down("Space", 300.0),
                key_up("Space", 350.0),
                key_down("b", 400.0),
                key_up("b", 450.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "a");
        assert_eq!(segments[1].display_text, "b");
    }

    #[test]
    fn space_at_start_is_ignored() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("Space", 100.0),
                key_up("Space", 150.0),
                key_down("h", 200.0),
                key_up("h", 250.0),
                key_down("i", 300.0),
                key_up("i", 350.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "hi");
    }

    #[test]
    fn long_sentence_splits_into_word_segments() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("s", 100.0),
                key_up("s", 120.0),
                key_down("e", 150.0),
                key_up("e", 170.0),
                key_down("e", 200.0),
                key_up("e", 220.0),
                key_down("m", 250.0),
                key_up("m", 270.0),
                key_down("Space", 300.0),
                key_up("Space", 320.0),
                key_down("m", 350.0),
                key_up("m", 370.0),
                key_down("u", 400.0),
                key_up("u", 420.0),
                key_down("s", 450.0),
                key_up("s", 470.0),
                key_down("t", 500.0),
                key_up("t", 520.0),
                key_down("Space", 550.0),
                key_up("Space", 570.0),
                key_down("o", 600.0),
                key_up("o", 620.0),
                key_down("r", 650.0),
                key_up("r", 670.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 3);
        assert_eq!(segments[0].display_text, "seem");
        assert_eq!(segments[1].display_text, "must");
        assert_eq!(segments[2].display_text, "or");
    }

    #[test]
    fn standalone_space_after_gap_shows_symbol() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("a", 100.0),
                key_up("a", 150.0),
                key_down("Space", 2000.0),
                key_up("Space", 2050.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "a");
        assert_eq!(segments[1].display_text, "␣");
    }

    #[test]
    fn space_after_gap_with_stale_group_finalizes_both() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("h", 100.0),
                key_up("h", 150.0),
                key_down("i", 200.0),
                key_up("i", 250.0),
                key_down("Space", 2000.0),
                key_up("Space", 2050.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "hi");
        assert_eq!(segments[1].display_text, "␣");
    }

    #[test]
    fn loads_unversioned_binary_keyboard_events() {
        let events = KeyboardEvents {
            presses: vec![key_down("c", 100.0), key_up("c", 150.0)],
        };
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join(KEYBOARD_EVENTS_FILE_NAME);
        let bytes = bincode::serde::encode_to_vec(&events, bincode::config::standard()).unwrap();

        std::fs::write(&path, bytes).unwrap();

        let loaded = KeyboardEvents::load_from_file(&path).unwrap();
        assert_eq!(loaded.presses, events.presses);
    }

    #[test]
    fn modifier_combos_uppercase_the_key() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("LMeta", 100.0),
                key_down("w", 150.0),
                key_up("w", 200.0),
                key_up("LMeta", 250.0),
            ],
        };

        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "⌘W");
    }

    #[test]
    fn macos_option_and_right_command_count_as_modifiers() {
        for (presses, expected) in [
            (
                vec![
                    key_down("Command", 100.0),
                    key_down("LOption", 110.0),
                    key_down("Left", 150.0),
                ],
                vec!["⌘", "⌥⌘←"],
            ),
            (
                vec![
                    key_down("RCommand", 100.0),
                    key_down("ROption", 110.0),
                    key_down("LShift", 120.0),
                    key_down("LControl", 130.0),
                    key_down("z", 150.0),
                ],
                vec!["⌘", "⌥⌘", "⌥⇧⌘", "⌃⌥⇧⌘Z"],
            ),
        ] {
            let segments = group_key_events(&KeyboardEvents { presses }, 300.0, 500.0, true, true);
            assert_eq!(
                segments
                    .iter()
                    .map(|segment| segment.display_text.as_str())
                    .collect::<Vec<_>>(),
                expected
            );
        }
    }

    #[test]
    fn modifiers_at_the_same_timestamp_include_later_presses_and_releases() {
        for (presses, expected) in [
            (
                vec![
                    key_down("a", 100.0),
                    key_down("LMeta", 100.0),
                    key_down("b", 200.0),
                    key_up("LMeta", 250.0),
                ],
                vec!["⌘A", "⌘B"],
            ),
            (
                vec![
                    key_down("LMeta", 100.0),
                    key_down("a", 100.0),
                    key_up("LMeta", 100.0),
                ],
                vec!["a"],
            ),
        ] {
            let segments = group_key_events(&KeyboardEvents { presses }, 300.0, 500.0, true, true);
            assert_eq!(
                segments
                    .iter()
                    .map(|segment| segment.display_text.as_str())
                    .collect::<Vec<_>>(),
                expected
            );
        }
    }

    #[test]
    fn signed_zero_timestamps_preserve_duplicate_modifier_release_and_start_bits() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("LMeta", -0.0),
                key_down("LMeta", 0.0),
                key_down("a", -0.0),
                key_up("LMeta", 0.0),
                key_down("b", 20.0),
            ],
        };
        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "ab");
        assert_eq!(segments[0].start.to_bits(), (-0.0_f64).to_bits());
        assert_eq!(segments[0].keys.len(), 2);
        assert_eq!(segments[0].keys[1].time_offset, 20.0);
    }

    #[test]
    fn hidden_keys_do_not_hide_modifier_releases() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("LMeta", 100.0),
                key_down("a", 150.0),
                key_up("a", 180.0),
                key_up("LMeta", 200.0),
                key_down("Tab", 250.0),
                key_up("Tab", 260.0),
                key_down("b", 300.0),
            ],
        };
        for (show_modifiers, expected) in [(true, vec!["⌘A", "b"]), (false, vec!["ab"])] {
            let segments = group_key_events(&events, 300.0, 500.0, show_modifiers, false);
            assert_eq!(
                segments
                    .iter()
                    .map(|segment| segment.display_text.as_str())
                    .collect::<Vec<_>>(),
                expected
            );
        }
    }

    #[test]
    fn unordered_keys_preserve_modifier_lookup_from_the_original_prefix() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("a", 100.0),
                key_down("LMeta", 300.0),
                key_down("b", 200.0),
                key_up("LMeta", 400.0),
            ],
        };
        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "a");
        assert_eq!(segments[1].display_text, "⌘b");
        assert_eq!(segments[1].start, 0.3);
        assert_eq!(segments[1].keys[1].time_offset, -100.0);
    }

    #[test]
    fn non_finite_keys_preserve_modifier_lookup_through_the_original_prefix() {
        let events = KeyboardEvents {
            presses: vec![
                key_down("LMeta", 100.0),
                key_down("a", f64::NAN),
                key_up("LMeta", 200.0),
                key_down("b", 300.0),
            ],
        };
        let segments = group_key_events(&events, 300.0, 500.0, true, true);
        assert_eq!(segments.len(), 1);
        assert_eq!(segments[0].display_text, "⌘ab");
        assert_eq!(segments[0].start, 0.1);
        assert_eq!(segments[0].end, 0.8);
        assert!(segments[0].keys[1].time_offset.is_nan());
    }
}

#[cfg(test)]
mod timing_tests {
    use super::*;
    use crate::{KeyboardSettings, TimelineConfiguration};

    fn timeline(segments: serde_json::Value) -> TimelineConfiguration {
        serde_json::from_value(serde_json::json!({"segments": segments, "zoomSegments": []}))
            .unwrap()
    }

    fn events(keys: &[(&str, f64)]) -> KeyboardEvents {
        KeyboardEvents {
            presses: keys
                .iter()
                .map(|(key, time)| KeyPressEvent {
                    key: (*key).into(),
                    key_code: (*key).into(),
                    time_ms: time * 1000.0,
                    down: true,
                })
                .collect(),
        }
    }

    #[test]
    fn legacy_tracks_migrate_once_and_preserve_authored_payloads() {
        let directory = tempfile::tempdir().unwrap();
        let captured = events(&[("a", 8.2)]);
        captured
            .write_to_file(&directory.path().join("keyboard.bin"))
            .unwrap();
        let mut meta: crate::RecordingMeta = serde_json::from_value(serde_json::json!({
            "pretty_name":"legacy", "segments":[{"display":{"path":"display.mp4","fps":30,"start_time":0.2},"keyboard":"keyboard.bin"}],"cursors":{}
        })).unwrap();
        meta.project_path = directory.path().to_path_buf();
        let mut project = crate::ProjectConfiguration {
            keyboard: Some(crate::KeyboardData::default()),
            timeline: Some(timeline(serde_json::json!([
                {"start":0.0,"end":5.0,"timescale":1.0},
                {"start":6.0,"end":10.0,"timescale":1.0}
            ]))),
            ..Default::default()
        };
        project.timeline.as_mut().unwrap().keyboard_segments =
            group_key_events(&captured, 500.0, 800.0, true, true);
        project.timeline.as_mut().unwrap().keyboard_segments[0].color_override =
            Some("#123456".into());
        let mut manual = project.clone();
        manual.timeline.as_mut().unwrap().keyboard_segments[0].start += 0.1;
        synchronize_legacy_keyboard(&meta, &mut manual);
        let migrated_manual = &manual.timeline.as_ref().unwrap().keyboard_segments[0];
        assert!((migrated_manual.start - 7.1).abs() < 1e-9);
        assert_eq!(migrated_manual.display_text, "a");
        assert_eq!(migrated_manual.color_override.as_deref(), Some("#123456"));
        let original_manual = serde_json::to_string(&manual).unwrap();
        synchronize_legacy_keyboard(&meta, &mut manual);
        assert_eq!(serde_json::to_string(&manual).unwrap(), original_manual);
        synchronize_legacy_keyboard(&meta, &mut project);
        let segment = &project.timeline.as_ref().unwrap().keyboard_segments[0];
        assert!((segment.start - 7.0).abs() < 1e-9);
        assert_eq!(segment.color_override.as_deref(), Some("#123456"));
        let migrated = serde_json::to_string(&project).unwrap();
        synchronize_legacy_keyboard(&meta, &mut project);
        assert_eq!(serde_json::to_string(&project).unwrap(), migrated);
        assert_eq!(
            KeyboardEvents::load_from_file(&directory.path().join("keyboard.bin"))
                .unwrap()
                .presses,
            captured.presses
        );
    }

    #[test]
    fn legacy_generated_tracks_already_rippled_by_a_cut_are_not_shifted_twice() {
        let directory = tempfile::tempdir().unwrap();
        let captured = events(&[("a", 8.2)]);
        captured
            .write_to_file(&directory.path().join("keyboard.bin"))
            .unwrap();
        let mut meta: crate::RecordingMeta = serde_json::from_value(serde_json::json!({
            "pretty_name":"old cut", "segments":[
                {"display":{"path":"display.mp4","fps":30,"start_time":0.2},"keyboard":"keyboard.bin"}
            ],"cursors":{}
        })).unwrap();
        meta.project_path = directory.path().to_path_buf();
        let mut project = crate::ProjectConfiguration {
            keyboard: Some(crate::KeyboardData::default()),
            timeline: Some(timeline(serde_json::json!([
                {"start":0.0,"end":5.0,"timescale":1.0},
                {"start":6.0,"end":10.0,"timescale":1.0}
            ]))),
            ..Default::default()
        };
        let mut track = group_key_events(&captured, 500.0, 800.0, true, true).remove(0);
        track.start -= 1.0;
        track.end -= 1.0;
        track.color_override = Some("#123456".into());
        project
            .timeline
            .as_mut()
            .unwrap()
            .keyboard_segments
            .push(track);
        let mut prefix_cut = project.clone();
        prefix_cut.timeline.as_mut().unwrap().segments = timeline(serde_json::json!([
            {"start":1.0,"end":10.0,"timescale":1.0}
        ]))
        .segments;
        synchronize_legacy_keyboard(&meta, &mut prefix_cut);
        assert!(
            (prefix_cut.timeline.as_ref().unwrap().keyboard_segments[0].start - 7.0).abs() < 1e-9
        );
        synchronize_legacy_keyboard(&meta, &mut project);
        let segment = &project.timeline.as_ref().unwrap().keyboard_segments[0];
        assert!((segment.start - 7.0).abs() < 1e-9);
        assert!((segment.end - 7.8).abs() < 1e-6);
        assert_eq!(segment.display_text, "a");
        assert_eq!(segment.color_override.as_deref(), Some("#123456"));
        let saved = serde_json::to_string(&project).unwrap();
        synchronize_legacy_keyboard(&meta, &mut project);
        assert_eq!(serde_json::to_string(&project).unwrap(), saved);
    }

    #[test]
    fn legacy_styles_follow_their_take_during_a_transition() {
        let directory = tempfile::tempdir().unwrap();
        let first = events(&[("a", 4.5)]);
        let second = events(&[("b", 0.5)]);
        first
            .write_to_file(&directory.path().join("first.bin"))
            .unwrap();
        second
            .write_to_file(&directory.path().join("second.bin"))
            .unwrap();
        let mut meta: crate::RecordingMeta = serde_json::from_value(serde_json::json!({
            "pretty_name":"transition", "segments":[
                {"display":{"path":"first.mp4","fps":30},"keyboard":"first.bin"},
                {"display":{"path":"second.mp4","fps":30},"keyboard":"second.bin"}
            ],"cursors":{}
        }))
        .unwrap();
        meta.project_path = directory.path().to_path_buf();
        let timeline = serde_json::from_value(serde_json::json!({
            "segments":[
                {"recordingSegment":0,"start":0.0,"end":5.0,"timescale":1.0},
                {"recordingSegment":1,"start":0.0,"end":5.0,"timescale":1.0}
            ], "zoomSegments":[],
            "transitions":[{"segmentIndex":1,"type":"cross-fade","duration":1.0}]
        }))
        .unwrap();
        let mut project = crate::ProjectConfiguration {
            keyboard: Some(crate::KeyboardData::default()),
            timeline: Some(timeline),
            ..Default::default()
        };
        let mut legacy =
            group_key_events(&events(&[("b", 0.5), ("a", 4.5)]), 500.0, 800.0, true, true);
        legacy[0].color_override = Some("#222222".into());
        legacy[1].color_override = Some("#111111".into());
        project.timeline.as_mut().unwrap().keyboard_segments = legacy;
        synchronize_legacy_keyboard(&meta, &mut project);
        let segments = &project.timeline.unwrap().keyboard_segments;
        assert_eq!(segments.len(), 2);
        for segment in segments {
            assert!((segment.start - 4.5).abs() < 1e-9);
            assert_eq!(
                segment.color_override.as_deref(),
                Some(if segment.display_text == "a" {
                    "#111111"
                } else {
                    "#222222"
                })
            );
        }
    }

    #[test]
    fn authored_legacy_keyboard_projects_speed_holds_and_repeated_takes_without_logs() {
        let meta: crate::RecordingMeta = serde_json::from_value(serde_json::json!({
            "pretty_name":"manual", "segments":[
                {"display":{"path":"display.mp4","fps":30,"start_time":0.2}}
            ],"cursors":{}
        }))
        .unwrap();
        let mut project = crate::ProjectConfiguration {
            timeline: Some(timeline(serde_json::json!([
                {"start":2.0,"end":6.0,"timescale":2.0},
                {"start":2.0,"end":6.0,"timescale":1.0}
            ]))),
            ..Default::default()
        };
        let mut track = group_key_events(
            &events(&[("a", 2.8), ("b", 3.6)]),
            1000.0,
            1000.0,
            true,
            true,
        )
        .remove(0);
        track.id = "kb-split-authored".into();
        track.color_override = Some("#123456".into());
        project
            .timeline
            .as_mut()
            .unwrap()
            .keyboard_segments
            .push(track);
        project.timeline.as_mut().unwrap().text_segments =
            serde_json::from_value(serde_json::json!([
                {"start":0.5,"end":1.5,"layout":"fullscreen","enabled":true}
            ]))
            .unwrap();
        synchronize_legacy_keyboard(&meta, &mut project);
        let segments = &project.timeline.as_ref().unwrap().keyboard_segments;
        assert_eq!(segments.len(), 2);
        assert!((segments[0].start - 0.3).abs() < 1e-9);
        assert!((segments[0].keys[1].time_offset - 1400.0).abs() < 1e-6);
        assert!((segments[1].start - 3.6).abs() < 1e-9);
        assert!((segments[1].keys[1].time_offset - 800.0).abs() < 1e-6);
        assert!(
            segments
                .iter()
                .all(|segment| segment.id.starts_with("kb-edit-")
                    && segment.display_text == "ab"
                    && segment.color_override.as_deref() == Some("#123456"))
        );
        let saved = serde_json::to_string(&project).unwrap();
        let mut reopened = serde_json::from_str(&saved).unwrap();
        synchronize_legacy_keyboard(&meta, &mut reopened);
        assert_eq!(serde_json::to_string(&reopened).unwrap(), saved);
    }

    #[test]
    fn authored_legacy_keyboard_discards_keys_from_deleted_footage() {
        let meta: crate::RecordingMeta = serde_json::from_value(serde_json::json!({
            "pretty_name":"manual cut", "segments":[
                {"display":{"path":"display.mp4","fps":30}}
            ],"cursors":{}
        }))
        .unwrap();
        let mut project = crate::ProjectConfiguration {
            timeline: Some(timeline(serde_json::json!([
                {"start":1.0,"end":4.0,"timescale":1.0},
                {"start":6.0,"end":9.0,"timescale":1.0}
            ]))),
            ..Default::default()
        };
        let mut track = group_key_events(
            &events(&[("a", 1.0), ("b", 5.0), ("c", 8.0)]),
            5000.0,
            1000.0,
            true,
            true,
        )
        .remove(0);
        track.id = "authored".into();
        track.display_text = "abé".into();
        track.color_override = Some("#123456".into());
        project
            .timeline
            .as_mut()
            .unwrap()
            .keyboard_segments
            .push(track);
        synchronize_legacy_keyboard(&meta, &mut project);
        let segments = &project.timeline.as_ref().unwrap().keyboard_segments;
        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].display_text, "a");
        assert_eq!(segments[1].display_text, "é");
        assert_eq!(segments[1].start, 3.0);
        assert_eq!(segments[1].keys[0].time_offset, 2000.0);
        assert!(segments.iter().all(|segment| segment.keys.len() == 1
            && segment.color_override.as_deref() == Some("#123456")));
    }

    #[test]
    fn regeneration_reports_corrupt_capture_logs() {
        let directory = tempfile::tempdir().unwrap();
        std::fs::write(
            directory.path().join("keyboard.bin"),
            b"invalid capture log",
        )
        .unwrap();
        let mut meta: crate::RecordingMeta = serde_json::from_value(serde_json::json!({"pretty_name":"corrupt", "segments":[{"display":{"path":"display.mp4","fps":30,"start_time":0.0},"keyboard":"keyboard.bin"}],"cursors":{}})).unwrap();
        meta.project_path = directory.path().to_path_buf();
        let timeline = timeline(serde_json::json!([{ "start":0.0,"end":10.0,"timescale":1.0 }]));
        assert!(
            generate_project_keyboard_segments(&meta, &timeline, &KeyboardSettings::default())
                .is_err()
        );
    }

    #[test]
    fn regeneration_uses_retained_frames_and_capture_start_offset() {
        let timeline = timeline(serde_json::json!([
            {"start":0.0,"end":5.0,"timescale":1.0},
            {"start":6.0,"end":10.0,"timescale":1.0}
        ]));
        let takes = [(events(&[("x", 5.7), ("a", 8.2)]), 0.2)];
        let result = project_keyboard_events(&takes, &timeline, &KeyboardSettings::default());
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].display_text, "a");
        assert!((result[0].start - 7.0).abs() < 1e-9);
        let (source_time, _) = timeline.get_segment_time(result[0].start).unwrap();
        assert!((source_time + takes[0].1 - 8.2).abs() < 1e-9);
    }

    #[test]
    fn regeneration_keeps_take_identity_and_repeated_clip_ids() {
        let timeline = timeline(serde_json::json!([
            {"recordingSegment":1,"start":0.0,"end":3.0,"timescale":1.0},
            {"recordingSegment":0,"start":0.0,"end":3.0,"timescale":1.0},
            {"recordingSegment":1,"start":0.0,"end":3.0,"timescale":1.0}
        ]));
        let result = project_keyboard_events(
            &[(events(&[("a", 1.0)]), 0.0), (events(&[("b", 1.0)]), 0.0)],
            &timeline,
            &KeyboardSettings::default(),
        );
        assert_eq!(
            result
                .iter()
                .map(|s| (s.display_text.as_str(), s.start))
                .collect::<Vec<_>>(),
            vec![("b", 1.0), ("a", 4.0), ("b", 7.0)]
        );
        assert_ne!(result[0].id, result[2].id);
    }

    #[test]
    fn regeneration_uses_transition_adjusted_clip_offsets() {
        let mut timeline = timeline(serde_json::json!([
            {"recordingSegment":0,"start":0.0,"end":5.0,"timescale":1.0},
            {"recordingSegment":1,"start":0.0,"end":5.0,"timescale":1.0}
        ]));
        timeline.transitions = serde_json::from_value(
            serde_json::json!([{"segmentIndex":1,"type":"cross-fade","duration":1.0}]),
        )
        .unwrap();
        let result = project_keyboard_events(
            &[
                (KeyboardEvents::default(), 0.0),
                (events(&[("b", 1.0)]), 0.0),
            ],
            &timeline,
            &KeyboardSettings::default(),
        );
        assert_eq!(result[0].start, 5.0);
        let (source, clip) = timeline.get_segment_time(result[0].start).unwrap();
        assert_eq!(source, 1.0);
        assert_eq!(clip.recording_clip, 1);
    }

    #[test]
    fn regeneration_scales_individual_key_offsets() {
        let timeline = timeline(serde_json::json!([{ "start":7.0,"end":10.0,"timescale":2.0 }]));
        let result = project_keyboard_events(
            &[(events(&[("a", 8.0), ("b", 8.4)]), 0.0)],
            &timeline,
            &KeyboardSettings::default(),
        );
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].start, 0.5);
        assert!((result[0].keys[1].time_offset - 200.0).abs() < 1e-9);
    }

    #[test]
    fn regeneration_does_not_type_during_fullscreen_holds() {
        let mut timeline =
            timeline(serde_json::json!([{ "start":0.0,"end":10.0,"timescale":1.0 }]));
        timeline.text_segments.push(
            serde_json::from_value(
                serde_json::json!({"start":2.0,"end":4.0,"layout":"fullscreen"}),
            )
            .unwrap(),
        );
        let result = project_keyboard_events(
            &[(events(&[("a", 2.0), ("b", 3.0)]), 0.0)],
            &timeline,
            &KeyboardSettings::default(),
        );
        assert_eq!(result[0].start, 4.0);
        assert_eq!(result[1].start, 5.0);
    }

    #[test]
    fn regeneration_preserves_modifiers_held_across_trim() {
        let timeline = timeline(serde_json::json!([{ "start":2.0,"end":5.0,"timescale":1.0 }]));
        let result = project_keyboard_events(
            &[(events(&[("LMeta", 1.0), ("w", 2.2)]), 0.0)],
            &timeline,
            &KeyboardSettings::default(),
        );
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].display_text, "⌘W");
        assert!((result[0].start - 0.2).abs() < 1e-9);
    }

    fn typed_segment() -> KeyboardTrackSegment {
        group_key_events(
            &events(&[("a", 10.0), ("b", 11.0), ("c", 12.0)]),
            1500.0,
            1000.0,
            true,
            true,
        )
        .remove(0)
    }

    #[test]
    fn ripple_removes_cut_keys_and_rebases_survivors() {
        let mut segment = typed_segment();
        assert!(segment.ripple_delete(10.5, 11.5, 1.0));
        assert_eq!(segment.display_text, "ac");
        assert_eq!(segment.start, 10.0);
        assert_eq!(segment.end, 12.0);
        assert_eq!(segment.keys[1].time_offset, 1000.0);
    }

    #[test]
    fn ripple_right_tail_uses_actual_duration_shift() {
        let mut segment = typed_segment();
        assert!(segment.ripple_delete(9.5, 11.5, 1.0));
        assert_eq!(segment.start, 10.5);
        assert_eq!(segment.end, 12.0);
        assert_eq!(segment.display_text, "c");
        assert_eq!(segment.keys[0].time_offset, 500.0);
    }

    #[test]
    fn speed_remaps_key_times_with_segment_bounds() {
        let mut segment = typed_segment();
        segment.remap_times(|time| 10.0 + (time - 10.0) / 2.0);
        assert_eq!(segment.end, 11.5);
        assert_eq!(segment.keys[1].time_offset, 500.0);
        assert_eq!(segment.keys[2].time_offset, 1000.0);
    }

    #[test]
    fn split_partitions_and_rebases_generated_keys() {
        let segment = typed_segment();
        let (left, right) = segment.split_at(11.0).unwrap();
        assert_eq!(left.display_text, "a");
        assert_eq!(right.display_text, "bc");
        assert_eq!(right.keys[0].time_offset, 0.0);
        assert_eq!(right.keys[1].time_offset, 1000.0);
    }

    #[test]
    fn atomic_shortcuts_are_preserved_or_removed_without_corruption() {
        let mut segment = typed_segment();
        segment.display_text = "⌘W".into();
        assert!(segment.split_at(11.0).is_none());
        assert!(!segment.ripple_delete(10.5, 11.5, 1.0));
    }
}