diff --git a/README.md b/README.md
index 1eed978..0cd51aa 100644
--- a/README.md
+++ b/README.md
@@ -38,6 +38,8 @@ Notable features:
 - two selectable rendering backends: `swash` (default) and `resvg`,
 - adjustable playback speed,
 - idle time limiting to skip periods of inactivity,
+- frame selection by time ranges, discrete positions, markers, percentages, and
+  event indexes,
 - looped or single-pass playback,
 - configurable FPS cap and last-frame duration,
 - terminal size override (cols/rows) for re-rendering at a different geometry.
diff --git a/src/asciicast.rs b/src/asciicast.rs
index a2c3757..e1dcafc 100644
--- a/src/asciicast.rs
+++ b/src/asciicast.rs
@@ -10,7 +10,7 @@ use crate::theme::Theme;
 
 pub struct Asciicast<'a> {
     pub header: Header,
-    pub events: Box<dyn Iterator<Item = Result<OutputEvent>> + 'a>,
+    pub events: Box<dyn Iterator<Item = Result<Event>> + 'a>,
 }
 
 pub struct Header {
@@ -20,7 +20,34 @@ pub struct Header {
     pub idle_time_limit: Option<f64>,
 }
 
-pub type OutputEvent = (f64, String);
+/// A single recording event. Every parsed event is preserved in file order so
+/// timing transforms, selection, and frame generation use the same timeline.
+/// `Other` covers input, resize, exit, and unknown events: their payload is not
+/// modeled, only their timestamp.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Event {
+    Output { time: f64, data: String },
+    Marker { time: f64, label: String },
+    Other { time: f64 },
+}
+
+impl Event {
+    pub fn time(&self) -> f64 {
+        match self {
+            Event::Output { time, .. } | Event::Marker { time, .. } | Event::Other { time } => {
+                *time
+            }
+        }
+    }
+
+    pub fn with_time(self, time: f64) -> Event {
+        match self {
+            Event::Output { data, .. } => Event::Output { time, data },
+            Event::Marker { label, .. } => Event::Marker { time, label },
+            Event::Other { .. } => Event::Other { time },
+        }
+    }
+}
 
 impl Default for Header {
     fn default() -> Self {
diff --git a/src/asciicast/v1.rs b/src/asciicast/v1.rs
index 0198d4c..7057b6e 100644
--- a/src/asciicast/v1.rs
+++ b/src/asciicast/v1.rs
@@ -1,7 +1,7 @@
 use anyhow::{bail, Result};
 use serde::Deserialize;
 
-use super::{Asciicast, Header};
+use super::{Asciicast, Event, Header};
 
 #[derive(Deserialize)]
 struct V1 {
@@ -34,7 +34,10 @@ pub fn load(json: String) -> Result<Asciicast<'static>> {
         let time = *prev_time + event.time;
         *prev_time = time;
 
-        Some(Ok((time, event.data)))
+        Some(Ok(Event::Output {
+            time,
+            data: event.data,
+        }))
     }));
 
     Ok(Asciicast { header, events })
@@ -63,9 +66,18 @@ mod tests {
         assert_eq!(
             events,
             vec![
-                (0.5, "a".to_string()),
-                (1.5, "b".to_string()),
-                (3.0, "c".to_string()),
+                Event::Output {
+                    time: 0.5,
+                    data: "a".to_string()
+                },
+                Event::Output {
+                    time: 1.5,
+                    data: "b".to_string()
+                },
+                Event::Output {
+                    time: 3.0,
+                    data: "c".to_string()
+                },
             ]
         );
     }
@@ -90,10 +102,22 @@ mod tests {
         assert_eq!(
             events,
             vec![
-                (0.0, "a".to_string()),
-                (0.5, "b".to_string()),
-                (0.5, "c".to_string()),
-                (1.0, "d".to_string()),
+                Event::Output {
+                    time: 0.0,
+                    data: "a".to_string()
+                },
+                Event::Output {
+                    time: 0.5,
+                    data: "b".to_string()
+                },
+                Event::Output {
+                    time: 0.5,
+                    data: "c".to_string()
+                },
+                Event::Output {
+                    time: 1.0,
+                    data: "d".to_string()
+                },
             ]
         );
     }
diff --git a/src/asciicast/v2.rs b/src/asciicast/v2.rs
index 9ad0e3e..c9df4b1 100644
--- a/src/asciicast/v2.rs
+++ b/src/asciicast/v2.rs
@@ -3,7 +3,7 @@ use std::io;
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Deserializer};
 
-use super::{Asciicast, Header, Theme};
+use super::{Asciicast, Event, Header, Theme};
 
 #[derive(Deserialize)]
 struct V2Header {
@@ -35,7 +35,7 @@ struct V2Event {
     time: f64,
     #[serde(deserialize_with = "deserialize_code")]
     code: V2EventCode,
-    data: String,
+    data: serde_json::Value,
 }
 
 #[derive(PartialEq, Debug)]
@@ -47,6 +47,33 @@ enum V2EventCode {
     Other(char),
 }
 
+impl V2EventCode {
+    fn into_event(self, time: f64, data: serde_json::Value) -> Result<Event> {
+        match self {
+            V2EventCode::Output => Ok(Event::Output {
+                time,
+                data: require_string(data, "output")?,
+            }),
+
+            V2EventCode::Marker => Ok(Event::Marker {
+                time,
+                label: require_string(data, "marker")?,
+            }),
+
+            // Ignored events carry no domain payload, so a non-string value is
+            // tolerated rather than rejected during parsing.
+            _ => Ok(Event::Other { time }),
+        }
+    }
+}
+
+fn require_string(data: serde_json::Value, kind: &str) -> Result<String> {
+    match data {
+        serde_json::Value::String(s) => Ok(s),
+        _ => bail!("{kind} event data must be a string"),
+    }
+}
+
 pub struct Parser(V2Header);
 
 pub fn open(header_line: &str) -> Result<Parser> {
@@ -76,13 +103,13 @@ impl Parser {
     }
 }
 
-fn parse_line(line: io::Result<String>) -> Option<Result<(f64, String)>> {
+fn parse_line(line: io::Result<String>) -> Option<Result<Event>> {
     match line {
         Ok(line) => {
             if line.is_empty() {
                 None
             } else {
-                parse_event(line).transpose()
+                Some(parse_event(line))
             }
         }
 
@@ -90,16 +117,10 @@ fn parse_line(line: io::Result<String>) -> Option<Result<(f64, String)>> {
     }
 }
 
-fn parse_event(line: String) -> Result<Option<(f64, String)>> {
+fn parse_event(line: String) -> Result<Event> {
     let event = serde_json::from_str::<V2Event>(&line).context("asciicast parse error")?;
 
-    let output = if let V2EventCode::Output = event.code {
-        Some((event.time, event.data))
-    } else {
-        None
-    };
-
-    Ok(output)
+    event.code.into_event(event.time, event.data)
 }
 
 fn deserialize_code<'de, D>(deserializer: D) -> Result<V2EventCode, D::Error>
@@ -174,6 +195,96 @@ impl From<&V2Theme> for Theme {
 mod tests {
     use super::*;
 
+    fn ok_lines(lines: Vec<&str>) -> Vec<io::Result<String>> {
+        lines.into_iter().map(|s| Ok(s.to_string())).collect()
+    }
+
+    #[test]
+    fn preserves_events_with_absolute_times() {
+        let parser = open(r#"{"version":2,"width":80,"height":24}"#).unwrap();
+
+        let lines = ok_lines(vec![
+            r#"[0.5,"o","a"]"#,
+            r#"[1.0,"m","label"]"#,
+            r#"[1.5,"o","b"]"#,
+            r#"[2.0,"r","100x40"]"#,
+        ]);
+
+        let events = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(
+            events,
+            vec![
+                Event::Output {
+                    time: 0.5,
+                    data: "a".to_string()
+                },
+                Event::Marker {
+                    time: 1.0,
+                    label: "label".to_string()
+                },
+                Event::Output {
+                    time: 1.5,
+                    data: "b".to_string()
+                },
+                Event::Other { time: 2.0 },
+            ]
+        );
+    }
+
+    #[test]
+    fn tolerates_non_string_payload_on_ignored_events() {
+        let parser = open(r#"{"version":2,"width":80,"height":24}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.5,"r",0]"#, r#"[1.0,"o","a"]"#]);
+
+        let events = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(
+            events,
+            vec![
+                Event::Other { time: 0.5 },
+                Event::Output {
+                    time: 1.0,
+                    data: "a".to_string()
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn rejects_non_string_output_data() {
+        let parser = open(r#"{"version":2,"width":80,"height":24}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.1,"o",123]"#]);
+
+        let result = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>();
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn rejects_non_string_marker_label() {
+        let parser = open(r#"{"version":2,"width":80,"height":24}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.1,"m",123]"#]);
+
+        let result = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>();
+
+        assert!(result.is_err());
+    }
+
     fn header_with_palette(colors: &[&str]) -> String {
         let palette = colors.join(":");
 
diff --git a/src/asciicast/v3.rs b/src/asciicast/v3.rs
index 743a2a6..25ec4a8 100644
--- a/src/asciicast/v3.rs
+++ b/src/asciicast/v3.rs
@@ -3,7 +3,7 @@ use std::io;
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Deserializer};
 
-use super::{Asciicast, Header, Theme};
+use super::{Asciicast, Event, Header, Theme};
 
 #[derive(Deserialize)]
 struct V3Header {
@@ -40,7 +40,7 @@ struct V3Event {
     time: f64,
     #[serde(deserialize_with = "deserialize_code")]
     code: V3EventCode,
-    data: String,
+    data: serde_json::Value,
 }
 
 #[derive(PartialEq, Debug)]
@@ -53,6 +53,33 @@ enum V3EventCode {
     Other(char),
 }
 
+impl V3EventCode {
+    fn into_event(self, time: f64, data: serde_json::Value) -> Result<Event> {
+        match self {
+            V3EventCode::Output => Ok(Event::Output {
+                time,
+                data: require_string(data, "output")?,
+            }),
+
+            V3EventCode::Marker => Ok(Event::Marker {
+                time,
+                label: require_string(data, "marker")?,
+            }),
+
+            // Ignored events carry no domain payload, so a non-string value is
+            // tolerated rather than rejected during parsing.
+            _ => Ok(Event::Other { time }),
+        }
+    }
+}
+
+fn require_string(data: serde_json::Value, kind: &str) -> Result<String> {
+    match data {
+        serde_json::Value::String(s) => Ok(s),
+        _ => bail!("{kind} event data must be a string"),
+    }
+}
+
 pub struct Parser {
     header: V3Header,
     prev_time: f64,
@@ -90,13 +117,13 @@ impl Parser {
         Asciicast { header, events }
     }
 
-    fn parse_line(&mut self, line: io::Result<String>) -> Option<Result<(f64, String)>> {
+    fn parse_line(&mut self, line: io::Result<String>) -> Option<Result<Event>> {
         match line {
             Ok(line) => {
                 if line.is_empty() || line.starts_with('#') {
                     None
                 } else {
-                    self.parse_event(line).transpose()
+                    Some(self.parse_event(line))
                 }
             }
 
@@ -104,19 +131,14 @@ impl Parser {
         }
     }
 
-    fn parse_event(&mut self, line: String) -> Result<Option<(f64, String)>> {
+    fn parse_event(&mut self, line: String) -> Result<Event> {
         let event = serde_json::from_str::<V3Event>(&line).context("asciicast parse error")?;
 
+        // v3 timestamps are intervals; accumulate into an absolute timeline.
         let time = self.prev_time + event.time;
         self.prev_time = time;
 
-        let output = if let V3EventCode::Output = event.code {
-            Some((time, event.data))
-        } else {
-            None
-        };
-
-        Ok(output)
+        event.code.into_event(time, event.data)
     }
 }
 
@@ -216,21 +238,31 @@ mod tests {
         assert_eq!(
             events,
             vec![
-                (0.5, "a".to_string()),
-                (1.5, "b".to_string()),
-                (3.0, "c".to_string()),
+                Event::Output {
+                    time: 0.5,
+                    data: "a".to_string()
+                },
+                Event::Output {
+                    time: 1.5,
+                    data: "b".to_string()
+                },
+                Event::Output {
+                    time: 3.0,
+                    data: "c".to_string()
+                },
             ]
         );
     }
 
     #[test]
-    fn non_output_events_advance_clock_but_are_filtered() {
+    fn preserves_non_output_events_on_the_timeline() {
         let parser = open(r#"{"version":3,"term":{"cols":80,"rows":24}}"#).unwrap();
 
         let lines = ok_lines(vec![
             r#"[0.5,"o","a"]"#,
             r#"[1.0,"m","label"]"#,
-            r#"[1.5,"o","b"]"#,
+            r#"[0.25,"r","100x40"]"#,
+            r#"[0.25,"o","b"]"#,
         ]);
 
         let events = parser
@@ -241,10 +273,93 @@ mod tests {
 
         assert_eq!(
             events,
-            vec![(0.5, "a".to_string()), (3.0, "b".to_string()),]
+            vec![
+                Event::Output {
+                    time: 0.5,
+                    data: "a".to_string()
+                },
+                Event::Marker {
+                    time: 1.5,
+                    label: "label".to_string()
+                },
+                Event::Other { time: 1.75 },
+                Event::Output {
+                    time: 2.0,
+                    data: "b".to_string()
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn tolerates_non_string_payload_on_ignored_events() {
+        let parser = open(r#"{"version":3,"term":{"cols":80,"rows":24}}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.5,"x",0]"#, r#"[0.5,"o","a"]"#]);
+
+        let events = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(
+            events,
+            vec![
+                Event::Other { time: 0.5 },
+                Event::Output {
+                    time: 1.0,
+                    data: "a".to_string()
+                },
+            ]
         );
     }
 
+    #[test]
+    fn unlabeled_marker_has_empty_label() {
+        let parser = open(r#"{"version":3,"term":{"cols":80,"rows":24}}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.5,"m",""]"#]);
+
+        let events = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(
+            events,
+            vec![Event::Marker {
+                time: 0.5,
+                label: "".to_string()
+            }]
+        );
+    }
+
+    #[test]
+    fn rejects_non_string_output_data() {
+        let parser = open(r#"{"version":3,"term":{"cols":80,"rows":24}}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.1,"o",123]"#]);
+
+        let result = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>();
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn rejects_non_string_marker_label() {
+        let parser = open(r#"{"version":3,"term":{"cols":80,"rows":24}}"#).unwrap();
+        let lines = ok_lines(vec![r#"[0.1,"m",123]"#]);
+
+        let result = parser
+            .parse(lines.into_iter())
+            .events
+            .collect::<Result<Vec<_>>>();
+
+        assert!(result.is_err());
+    }
+
     #[test]
     fn empty_event_code_errors() {
         let parser = open(r#"{"version":3,"term":{"cols":80,"rows":24}}"#).unwrap();
diff --git a/src/events.rs b/src/events.rs
deleted file mode 100644
index 08ae6ea..0000000
--- a/src/events.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use anyhow::Result;
-
-use crate::asciicast::OutputEvent;
-
-struct Batch<I>
-where
-    I: Iterator<Item = Result<OutputEvent>>,
-{
-    iter: I,
-    prev_time: f64,
-    prev_data: String,
-    max_frame_time: f64,
-}
-
-impl<I: Iterator<Item = Result<OutputEvent>>> Iterator for Batch<I> {
-    type Item = Result<OutputEvent>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.iter.next() {
-            Some(Ok((time, data))) => {
-                if time - self.prev_time < self.max_frame_time {
-                    self.prev_data.push_str(&data);
-
-                    self.next()
-                } else if !self.prev_data.is_empty() || self.prev_time == 0.0 {
-                    let prev_time = self.prev_time;
-                    self.prev_time = time;
-                    let prev_data = std::mem::replace(&mut self.prev_data, data);
-
-                    Some(Ok((prev_time, prev_data)))
-                } else {
-                    self.prev_time = time;
-                    self.prev_data = data;
-
-                    self.next()
-                }
-            }
-
-            Some(Err(e)) => Some(Err(e)),
-
-            None => {
-                if !self.prev_data.is_empty() {
-                    let prev_time = self.prev_time;
-                    let prev_data = std::mem::replace(&mut self.prev_data, "".to_owned());
-
-                    Some(Ok((prev_time, prev_data)))
-                } else {
-                    None
-                }
-            }
-        }
-    }
-}
-
-pub fn batch(
-    iter: impl Iterator<Item = Result<OutputEvent>>,
-    fps_cap: u8,
-) -> impl Iterator<Item = Result<OutputEvent>> {
-    Batch {
-        iter,
-        prev_data: "".to_owned(),
-        prev_time: 0.0,
-        max_frame_time: 1.0 / (fps_cap as f64),
-    }
-}
-
-pub fn accelerate(
-    events: impl Iterator<Item = Result<OutputEvent>>,
-    speed: f64,
-) -> impl Iterator<Item = Result<OutputEvent>> {
-    events.map(move |event| event.map(|(time, data)| (time / speed, data)))
-}
-
-pub fn limit_idle_time(
-    events: impl Iterator<Item = Result<OutputEvent>>,
-    limit: f64,
-) -> impl Iterator<Item = Result<OutputEvent>> {
-    let mut prev_time = 0.0;
-    let mut offset = 0.0;
-
-    events.map(move |event| {
-        event.map(|(time, data)| {
-            let delay = time - prev_time;
-            let excess = delay - limit;
-
-            if excess > 0.0 {
-                offset += excess;
-            }
-
-            prev_time = time;
-
-            (time - offset, data)
-        })
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-
-    #[test]
-    fn accelerate() {
-        let stdout = [
-            (0.0, "foo".to_owned()),
-            (1.0, "bar".to_owned()),
-            (2.0, "baz".to_owned()),
-        ];
-
-        let stdout = super::accelerate(stdout.into_iter().map(Ok), 2.0)
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(&stdout[0], &(0.0, "foo".to_owned()));
-        assert_eq!(&stdout[1], &(0.5, "bar".to_owned()));
-        assert_eq!(&stdout[2], &(1.0, "baz".to_owned()));
-    }
-
-    #[test]
-    fn batch() {
-        let stdout = [
-            (0.0, "foo".to_owned()),
-            (1.0, "bar".to_owned()),
-            (2.0, "baz".to_owned()),
-        ];
-
-        let stdout = super::batch(stdout.into_iter().map(Ok), 30)
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(&stdout[0], &(0.0, "foo".to_owned()));
-        assert_eq!(&stdout[1], &(1.0, "bar".to_owned()));
-        assert_eq!(&stdout[2], &(2.0, "baz".to_owned()));
-
-        let stdout = [
-            (0.0, "foo".to_owned()),
-            (0.033, "bar".to_owned()),
-            (0.066, "baz".to_owned()),
-            (1.0, "qux".to_owned()),
-        ];
-
-        let stdout = super::batch(stdout.into_iter().map(Ok), 30)
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(&stdout[0], &(0.0, "foobar".to_owned()));
-        assert_eq!(&stdout[1], &(0.066, "baz".to_owned()));
-        assert_eq!(&stdout[2], &(1.0, "qux".to_owned()));
-
-        let stdout = [
-            (0.0, "".to_owned()),
-            (1.0, "foo".to_owned()),
-            (2.0, "bar".to_owned()),
-        ];
-
-        let stdout = super::batch(stdout.into_iter().map(Ok), 30)
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(&stdout[0], &(0.0, "".to_owned()));
-        assert_eq!(&stdout[1], &(1.0, "foo".to_owned()));
-        assert_eq!(&stdout[2], &(2.0, "bar".to_owned()));
-    }
-
-    #[test]
-    fn limit_idle_time() {
-        let stdout = [
-            (0.0, "foo".to_owned()),
-            (1.0, "bar".to_owned()),
-            (3.5, "baz".to_owned()),
-            (4.0, "qux".to_owned()),
-            (7.5, "quux".to_owned()),
-        ];
-
-        let stdout = super::limit_idle_time(stdout.into_iter().map(Ok), 2.0)
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(&stdout[0], &(0.0, "foo".to_owned()));
-        assert_eq!(&stdout[1], &(1.0, "bar".to_owned()));
-        assert_eq!(&stdout[2], &(3.0, "baz".to_owned()));
-        assert_eq!(&stdout[3], &(3.5, "qux".to_owned()));
-        assert_eq!(&stdout[4], &(5.5, "quux".to_owned()));
-    }
-}
diff --git a/src/frames.rs b/src/frames.rs
new file mode 100644
index 0000000..8f151a6
--- /dev/null
+++ b/src/frames.rs
@@ -0,0 +1,333 @@
+//! Terminal frame generation.
+//!
+//! Frame production runs as a single forward pass over the adjusted event
+//! timeline. A [`FrameEmitter`] is shown one candidate frame per event and
+//! decides which frames end up in the output.
+
+use crate::asciicast::Event;
+use crate::terminal::{self, Snapshot};
+
+/// A terminal state at a point in time. Holds terminal cells, not rendered
+/// pixels.
+#[derive(Clone)]
+pub struct Frame {
+    pub time: f64,
+    pub snapshot: Snapshot,
+}
+
+impl Frame {
+    fn from_vt(time: f64, vt: &avt::Vt) -> Frame {
+        Frame {
+            time,
+            snapshot: Snapshot::from_vt(vt),
+        }
+    }
+
+    pub fn same_visual(&self, other: &Frame) -> bool {
+        self.snapshot.same_visual(&other.snapshot)
+    }
+}
+
+trait FrameEmitter {
+    fn emit(&mut self, frame: Frame, event: &Event) -> Vec<Frame>;
+
+    fn finish(&mut self) -> Vec<Frame> {
+        Vec::new()
+    }
+}
+
+/// Generate frames for a contiguous time range. `start`/`end` are absolute
+/// timeline timestamps; `None` means open-ended.
+pub fn from_range(
+    events: &[Event],
+    terminal_size: (usize, usize),
+    start: Option<f64>,
+    end: Option<f64>,
+) -> Vec<Frame> {
+    let mut vt = terminal::build(terminal_size);
+    let blank = Frame::from_vt(0.0, &vt);
+
+    generate_with(&mut vt, events, RangeEmitter::new(start, end, blank))
+}
+
+/// Generate terminal states at each resolved timestamp, using player seek
+/// semantics. `positions` must be sorted ascending and deduplicated.
+pub fn at_positions(
+    events: &[Event],
+    terminal_size: (usize, usize),
+    positions: Vec<f64>,
+) -> Vec<Frame> {
+    let mut vt = terminal::build(terminal_size);
+    let blank = Frame::from_vt(0.0, &vt);
+
+    generate_with(&mut vt, events, PositionEmitter::new(positions, blank))
+}
+
+/// Replay the timeline through `vt`, feeding the emitter one candidate frame
+/// per event. Only output events mutate the terminal; marker and `Other` events
+/// still produce a candidate frame so the emitter can detect crossings.
+fn generate_with<E: FrameEmitter>(
+    vt: &mut avt::Vt,
+    events: &[Event],
+    mut emitter: E,
+) -> Vec<Frame> {
+    let mut selected = Vec::new();
+
+    for event in events {
+        if let Event::Output { data, .. } = event {
+            terminal::feed_str(vt, data);
+        }
+
+        let frame = Frame::from_vt(event.time(), vt);
+        selected.extend(emitter.emit(frame, event));
+    }
+
+    selected.extend(emitter.finish());
+
+    selected
+}
+
+struct RangeEmitter {
+    start: f64,
+    end: Option<f64>,
+    /// Latest frame at or before `start`, the source for a synthetic range-start
+    /// frame. Initialized to the blank frame and updated while replay is still
+    /// before the range.
+    saved: Option<Frame>,
+    started: bool,
+}
+
+impl RangeEmitter {
+    fn new(start: Option<f64>, end: Option<f64>, blank: Frame) -> Self {
+        RangeEmitter {
+            start: start.unwrap_or(0.0),
+            end,
+            saved: Some(blank),
+            started: false,
+        }
+    }
+}
+
+impl FrameEmitter for RangeEmitter {
+    fn emit(&mut self, frame: Frame, event: &Event) -> Vec<Frame> {
+        let time = frame.time;
+        let mut out = Vec::new();
+
+        if !self.started {
+            if time < self.start {
+                self.saved = Some(frame);
+                return out;
+            }
+
+            // First event at or past the range start: enter the range. Unless an
+            // output event lands exactly on the start, emit a synthetic frame
+            // carrying the pre-start terminal state, retimed to the start.
+            self.started = true;
+            let output_at_start = time == self.start && matches!(event, Event::Output { .. });
+
+            if !output_at_start {
+                if let Some(mut saved) = self.saved.take() {
+                    saved.time = self.start;
+                    out.push(saved);
+                }
+            }
+        }
+
+        if self.end.is_none_or(|end| time <= end) && matches!(event, Event::Output { .. }) {
+            out.push(frame);
+        }
+
+        out
+    }
+}
+
+struct PositionEmitter {
+    positions: Vec<f64>,
+    next: usize,
+    /// Terminal state after the last processed event, the source for the next
+    /// crossed position. Initialized to the blank frame.
+    last: Frame,
+}
+
+impl PositionEmitter {
+    fn new(positions: Vec<f64>, blank: Frame) -> Self {
+        PositionEmitter {
+            positions,
+            next: 0,
+            last: blank,
+        }
+    }
+
+    /// Emit every pending position strictly before `boundary`, each carrying the
+    /// current `last` state retimestamped to the requested position.
+    fn emit_before(&mut self, boundary: f64, out: &mut Vec<Frame>) {
+        while self.next < self.positions.len() && self.positions[self.next] < boundary {
+            let mut frame = self.last.clone();
+            frame.time = self.positions[self.next];
+            out.push(frame);
+            self.next += 1;
+        }
+    }
+}
+
+impl FrameEmitter for PositionEmitter {
+    fn emit(&mut self, frame: Frame, _event: &Event) -> Vec<Frame> {
+        let mut out = Vec::new();
+
+        // Positions before this event's time are now final; events sharing a
+        // position's timestamp are applied first, so the boundary is exclusive.
+        self.emit_before(frame.time, &mut out);
+        self.last = frame;
+
+        out
+    }
+
+    fn finish(&mut self) -> Vec<Frame> {
+        let mut out = Vec::new();
+        self.emit_before(f64::INFINITY, &mut out);
+
+        out
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn output(time: f64, data: &str) -> Event {
+        Event::Output {
+            time,
+            data: data.to_owned(),
+        }
+    }
+
+    fn marker(time: f64) -> Event {
+        Event::Marker {
+            time,
+            label: "m".to_owned(),
+        }
+    }
+
+    fn times(frames: &[Frame]) -> Vec<f64> {
+        frames.iter().map(|f| f.time).collect()
+    }
+
+    fn texts(frames: &[Frame]) -> Vec<String> {
+        frames
+            .iter()
+            .map(|f| {
+                f.snapshot
+                    .lines
+                    .iter()
+                    .map(|l| l.text())
+                    .collect::<String>()
+            })
+            .collect()
+    }
+
+    #[test]
+    fn default_range_emits_blank_then_output_frames() {
+        let events = [output(0.5, "a"), output(1.0, "b")];
+        let frames = from_range(&events, (4, 1), None, None);
+
+        assert_eq!(times(&frames), vec![0.0, 0.5, 1.0]);
+        assert_eq!(texts(&frames), vec!["    ", "a   ", "ab  "]);
+    }
+
+    #[test]
+    fn range_ignores_marker_candidates() {
+        let events = [output(0.5, "a"), marker(0.7), output(1.0, "b")];
+        let frames = from_range(&events, (4, 1), None, None);
+
+        assert_eq!(times(&frames), vec![0.0, 0.5, 1.0]);
+        assert_eq!(texts(&frames), vec!["    ", "a   ", "ab  "]);
+    }
+
+    #[test]
+    fn open_start_range_synthesizes_start_frame_from_prior_state() {
+        let events = [output(3.0, "a"), output(8.0, "b")];
+        let frames = from_range(&events, (4, 1), Some(5.0), None);
+
+        assert_eq!(times(&frames), vec![5.0, 8.0]);
+        assert_eq!(texts(&frames), vec!["a   ", "ab  "]);
+    }
+
+    #[test]
+    fn open_start_range_uses_blank_when_no_prior_event() {
+        let events = [output(8.0, "b")];
+        let frames = from_range(&events, (4, 1), Some(5.0), None);
+
+        assert_eq!(times(&frames), vec![5.0, 8.0]);
+        assert_eq!(texts(&frames), vec!["    ", "b   "]);
+    }
+
+    #[test]
+    fn output_exactly_at_start_is_not_duplicated_by_a_synthetic_frame() {
+        let events = [output(1.0, "a"), output(2.0, "b"), output(3.0, "c")];
+        let frames = from_range(&events, (4, 1), Some(2.0), Some(2.0));
+
+        assert_eq!(times(&frames), vec![2.0]);
+        assert_eq!(texts(&frames), vec!["ab  "]);
+    }
+
+    #[test]
+    fn startless_range_ending_at_zero_includes_output_at_zero() {
+        let events = [output(0.0, "a"), output(1.0, "b")];
+        let frames = from_range(&events, (4, 1), None, Some(0.0));
+
+        assert_eq!(times(&frames), vec![0.0]);
+        assert_eq!(texts(&frames), vec!["a   "]);
+    }
+
+    #[test]
+    fn range_end_is_inclusive_for_exact_matches() {
+        let events = [output(1.0, "a"), output(2.0, "b"), output(3.0, "c")];
+        let frames = from_range(&events, (4, 1), None, Some(2.0));
+
+        assert_eq!(times(&frames), vec![0.0, 1.0, 2.0]);
+        assert_eq!(texts(&frames), vec!["    ", "a   ", "ab  "]);
+    }
+
+    #[test]
+    fn positions_capture_seek_state_at_each_timestamp() {
+        let events = [output(1.0, "a"), output(2.0, "b"), output(3.0, "c")];
+
+        let frames = at_positions(&events, (4, 1), vec![2.0]);
+        assert_eq!(times(&frames), vec![2.0]);
+        assert_eq!(texts(&frames), vec!["ab  "]);
+
+        let frames = at_positions(&events, (4, 1), vec![3.0]);
+        assert_eq!(texts(&frames), vec!["abc "]);
+    }
+
+    #[test]
+    fn position_before_first_event_emits_blank() {
+        let events = [output(1.0, "a")];
+        let frames = at_positions(&events, (4, 1), vec![0.5]);
+
+        assert_eq!(times(&frames), vec![0.5]);
+        assert_eq!(texts(&frames), vec!["    "]);
+    }
+
+    #[test]
+    fn one_event_crossing_multiple_positions_shares_state() {
+        let events = [output(1.0, "a"), output(3.0, "b")];
+        let frames = at_positions(&events, (4, 1), vec![1.5, 2.5]);
+
+        assert_eq!(times(&frames), vec![1.5, 2.5]);
+        assert_eq!(texts(&frames), vec!["a   ", "a   "]);
+    }
+
+    #[test]
+    fn exact_match_applies_all_events_at_that_timestamp() {
+        let events = [
+            output(1.0, "a"),
+            output(2.0, "b"),
+            output(2.0, "c"),
+            output(5.0, "d"),
+        ];
+        let frames = at_positions(&events, (4, 1), vec![2.0]);
+
+        assert_eq!(texts(&frames), vec!["abc "]);
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index dc2940a..655e992 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,13 +1,16 @@
 mod asciicast;
-mod events;
 mod fonts;
+mod frames;
+mod output;
 mod renderer;
+mod selection;
+mod terminal;
 mod theme;
-mod vt;
+mod timeline;
 
 use std::fmt::{Debug, Display};
 use std::io::{BufRead, Write};
-use std::{iter, thread, time::Instant};
+use std::{thread, time::Instant};
 
 use anyhow::{anyhow, Result};
 use clap::ValueEnum;
@@ -15,6 +18,8 @@ use log::{info, warn};
 
 use crate::asciicast::Asciicast;
 
+pub use crate::selection::SelectionSpec;
+
 pub const DEFAULT_BOLD_IS_BRIGHT: bool = false;
 pub const DEFAULT_TEXT_FONT_FAMILY: &str =
     "JetBrains Mono,Fira Code,SF Mono,Menlo,Consolas,DejaVu Sans Mono,Liberation Mono";
@@ -42,6 +47,7 @@ pub struct Config {
     pub no_loop: bool,
     pub renderer: Renderer,
     pub rows: Option<usize>,
+    pub selection: SelectionSpec,
     pub speed: f64,
     pub text_font_family: String,
     pub theme: Option<Theme>,
@@ -64,6 +70,7 @@ impl Default for Config {
             no_loop: DEFAULT_NO_LOOP,
             renderer: Default::default(),
             rows: None,
+            selection: SelectionSpec::default(),
             speed: DEFAULT_SPEED,
             text_font_family: String::from(DEFAULT_TEXT_FONT_FAMILY),
             theme: Default::default(),
@@ -160,13 +167,32 @@ pub fn run<I: BufRead, O: Write + Send>(input: I, output: O, config: Config) ->
         .or(header.idle_time_limit)
         .unwrap_or(DEFAULT_IDLE_TIME_LIMIT);
 
-    let events = iter::once(Ok((0.0, "".to_owned()))).chain(events);
-    let events = events::limit_idle_time(events, itl);
-    let events = events::accelerate(events, config.speed);
-    let events = events::batch(events, config.fps_cap);
-    let events = events.collect::<Vec<_>>();
-    let count = events.len() as u64;
-    let frames = vt::frames(events.into_iter(), terminal_size);
+    let events = timeline::limit_idle_time(events, itl);
+    let events = timeline::accelerate(events, config.speed);
+    let events = events.collect::<Result<Vec<_>>>()?;
+
+    let summary = timeline::Summary::from_events(&events);
+    let plan = selection::resolve(&config.selection, &summary)?;
+
+    let frames = match plan {
+        // Range selections produce time-based animation frames: dedupe duplicate
+        // states, normalize the first frame to t=0, then cap FPS.
+        selection::SelectionPlan::Range { start, end } => {
+            let frames = frames::from_range(&events, terminal_size, start, end);
+            let frames = output::dedupe_visual_changes(frames);
+            let frames = output::adjust_timeline_timestamps(frames);
+            output::cap_fps(frames, config.fps_cap)
+        }
+
+        // Discrete selections: keep every resolved position, with no visual
+        // dedupe or FPS capping, spaced by a fixed per-frame duration.
+        selection::SelectionPlan::Positions(positions) => {
+            let frames = frames::at_positions(&events, terminal_size, positions);
+            output::adjust_discrete_timestamps(frames, config.last_frame_duration)
+        }
+    };
+
+    let count = frames.len() as u64;
 
     info!(
         "recording terminal size: {}x{}",
@@ -257,11 +283,9 @@ pub fn run<I: BufRead, O: Write + Send>(input: I, output: O, config: Config) ->
             }
         });
 
-        for (i, frame) in frames.enumerate() {
-            let (time, lines, cursor) = frame?;
-            let image = renderer.render(&lines, cursor);
-            let time = if i == 0 { 0.0 } else { time };
-            collector.add_frame_rgba(i, image, time + config.last_frame_duration)?;
+        for (i, frame) in frames.into_iter().enumerate() {
+            let image = renderer.render(&frame.snapshot);
+            collector.add_frame_rgba(i, image, frame.time + config.last_frame_duration)?;
         }
 
         drop(collector);
diff --git a/src/main.rs b/src/main.rs
index d11f194..3322c7f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -46,6 +46,50 @@ impl clap::builder::TypedValueParser for ThemeValueParser {
     }
 }
 
+#[derive(Clone)]
+pub struct SelectValueParser;
+
+impl clap::builder::TypedValueParser for SelectValueParser {
+    type Value = agg::SelectionSpec;
+
+    fn parse_ref(
+        &self,
+        cmd: &clap::Command,
+        _arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        value
+            .to_string_lossy()
+            .parse::<agg::SelectionSpec>()
+            .map_err(|msg| {
+                cmd.clone()
+                    .error(clap::error::ErrorKind::ValueValidation, msg)
+            })
+    }
+}
+
+const SELECT_LONG_HELP: &str = "\
+Select frames to render.
+
+A selector is one of:
+  .., POS.., ..POS, POS..POS      time range
+  POS, POS,POS,...                discrete positions
+  markers                         all marker positions
+
+POS may be:
+  12.5, 12.5s, 1m20s, 1:20        time
+  50%                             percent of adjusted duration
+  marker:build, marker:3          marker label prefix or 0-based marker index
+  event:100                       0-based event index
+
+Times are on the adjusted output timeline, after --idle-time-limit and --speed.
+The `markers` selector is standalone; use `marker:<label>` in ranges or lists.
+
+Examples:
+  --select 5..100%
+  --select marker:build..marker:test
+  --select 1,50%,marker:build,event:100";
+
 fn parse_line_height(s: &str) -> Result<f64, String> {
     let v: f64 = s.parse().map_err(|e: ParseFloatError| e.to_string())?;
 
@@ -117,6 +161,10 @@ struct Cli {
     #[clap(long, default_value_t = agg::DEFAULT_LAST_FRAME_DURATION)]
     last_frame_duration: f64,
 
+    /// Select frames to render (see --help for details)
+    #[clap(long, value_name = "SELECTOR", value_parser = SelectValueParser, long_help = SELECT_LONG_HELP)]
+    select: Option<agg::SelectionSpec>,
+
     /// Override terminal width (number of columns)
     #[clap(long)]
     cols: Option<usize>,
@@ -214,6 +262,7 @@ fn main() -> Result<()> {
         no_loop: cli.no_loop,
         renderer: cli.renderer,
         rows: cli.rows,
+        selection: cli.select.unwrap_or_default(),
         speed: cli.speed,
         text_font_family: cli.text_font_family,
         theme: cli.theme.map(|theme| theme.0),
@@ -285,4 +334,27 @@ mod tests {
         assert_eq!(cli.text_font_family, agg::DEFAULT_TEXT_FONT_FAMILY);
         assert_eq!(cli.emoji_font_family, agg::DEFAULT_EMOJI_FONT_FAMILY);
     }
+
+    #[test]
+    fn select_accepts_valid_selector() {
+        use agg::SelectionSpec;
+
+        let cli =
+            Cli::try_parse_from(["agg", "--select", "5..30", "input.cast", "output.gif"]).unwrap();
+        let expected = "5..30".parse::<SelectionSpec>().unwrap();
+
+        assert_eq!(cli.select, Some(expected));
+    }
+
+    #[test]
+    fn select_rejects_invalid_selector() {
+        let err =
+            match Cli::try_parse_from(["agg", "--select", "5..10..15", "input.cast", "output.gif"])
+            {
+                Ok(_) => panic!("expected validation error"),
+                Err(err) => err,
+            };
+
+        assert_eq!(err.kind(), ErrorKind::ValueValidation);
+    }
 }
diff --git a/src/output.rs b/src/output.rs
new file mode 100644
index 0000000..a0b365e
--- /dev/null
+++ b/src/output.rs
@@ -0,0 +1,154 @@
+//! Output frame preparation.
+
+use crate::frames::Frame;
+
+/// Drop frames whose terminal state matches the previously kept frame. Kept
+/// frames keep their original timestamps, so the delay to the next change is
+/// preserved.
+pub fn dedupe_visual_changes(frames: Vec<Frame>) -> Vec<Frame> {
+    let mut out: Vec<Frame> = Vec::new();
+
+    for frame in frames {
+        if out.last().is_none_or(|last| !last.same_visual(&frame)) {
+            out.push(frame);
+        }
+    }
+
+    out
+}
+
+/// Shift timestamps so the first selected frame starts at `0`, preserving the
+/// spacing between later frames.
+pub fn adjust_timeline_timestamps(mut frames: Vec<Frame>) -> Vec<Frame> {
+    if let Some(offset) = frames.first().map(|f| f.time) {
+        for frame in &mut frames {
+            frame.time -= offset;
+        }
+    }
+
+    frames
+}
+
+/// Assign sequential output timestamps using a fixed per-frame duration. This
+/// preserves selection order rather than source-time spacing.
+pub fn adjust_discrete_timestamps(mut frames: Vec<Frame>, frame_duration: f64) -> Vec<Frame> {
+    for (i, frame) in frames.iter_mut().enumerate() {
+        frame.time = i as f64 * frame_duration;
+    }
+
+    frames
+}
+
+/// Reduce frames to at most one per `1/fps_cap` interval. Each window keeps the
+/// latest terminal state, timestamped at the window's start.
+pub fn cap_fps(frames: Vec<Frame>, fps_cap: u8) -> Vec<Frame> {
+    let max_frame_time = 1.0 / (fps_cap as f64);
+    let mut out = Vec::new();
+    let mut window: Option<Frame> = None;
+
+    for frame in frames {
+        match &mut window {
+            None => window = Some(frame),
+
+            Some(window_frame) if frame.time - window_frame.time < max_frame_time => {
+                window_frame.snapshot = frame.snapshot;
+            }
+
+            Some(_) => out.push(window.replace(frame).unwrap()),
+        }
+    }
+
+    out.extend(window);
+
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::terminal::Snapshot;
+
+    /// A frame tagged via its cursor, for time/order assertions where terminal
+    /// content is irrelevant.
+    fn tagged(time: f64, tag: usize) -> Frame {
+        Frame {
+            time,
+            snapshot: Snapshot {
+                lines: Vec::new(),
+                cursor: Some((tag, 0)),
+            },
+        }
+    }
+
+    fn times(frames: &[Frame]) -> Vec<f64> {
+        frames.iter().map(|f| f.time).collect()
+    }
+
+    fn tags(frames: &[Frame]) -> Vec<usize> {
+        frames
+            .iter()
+            .map(|f| f.snapshot.cursor.unwrap().0)
+            .collect()
+    }
+
+    #[test]
+    fn dedupe_keeps_first_of_each_visual_run() {
+        let frames = vec![
+            tagged(0.0, 0),
+            tagged(1.0, 0),
+            tagged(2.0, 1),
+            tagged(3.0, 1),
+        ];
+        let frames = dedupe_visual_changes(frames);
+
+        assert_eq!(times(&frames), vec![0.0, 2.0]);
+        assert_eq!(tags(&frames), vec![0, 1]);
+    }
+
+    #[test]
+    fn empty_input_yields_empty_output() {
+        assert!(dedupe_visual_changes(Vec::new()).is_empty());
+        assert!(adjust_timeline_timestamps(Vec::new()).is_empty());
+        assert!(adjust_discrete_timestamps(Vec::new(), 3.0).is_empty());
+        assert!(cap_fps(Vec::new(), 30).is_empty());
+    }
+
+    #[test]
+    fn timeline_adjustment_subtracts_first_timestamp() {
+        let frames = vec![tagged(5.0, 0), tagged(8.0, 1), tagged(10.0, 2)];
+        let frames = adjust_timeline_timestamps(frames);
+
+        assert_eq!(times(&frames), vec![0.0, 3.0, 5.0]);
+    }
+
+    #[test]
+    fn cap_fps_keeps_latest_state_per_interval_at_window_start() {
+        let frames = vec![
+            tagged(0.0, 0),
+            tagged(0.033, 1),
+            tagged(0.066, 2),
+            tagged(1.0, 3),
+        ];
+        let frames = cap_fps(frames, 30);
+
+        assert_eq!(times(&frames), vec![0.0, 0.066, 1.0]);
+        assert_eq!(tags(&frames), vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn cap_fps_keeps_widely_spaced_frames() {
+        let frames = vec![tagged(0.0, 0), tagged(1.0, 1), tagged(2.0, 2)];
+        let frames = cap_fps(frames, 30);
+
+        assert_eq!(times(&frames), vec![0.0, 1.0, 2.0]);
+        assert_eq!(tags(&frames), vec![0, 1, 2]);
+    }
+
+    #[test]
+    fn discrete_timestamps_are_sequential() {
+        let frames = vec![tagged(2.0, 0), tagged(5.0, 1), tagged(10.0, 2)];
+        let frames = adjust_discrete_timestamps(frames, 3.0);
+
+        assert_eq!(times(&frames), vec![0.0, 3.0, 6.0]);
+    }
+}
diff --git a/src/renderer.rs b/src/renderer.rs
index f199c43..f3723bd 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -4,10 +4,11 @@ mod swash;
 use imgref::ImgVec;
 use rgb::{RGB8, RGBA8};
 
+use crate::terminal::Snapshot;
 use crate::theme::Theme;
 
 pub trait Renderer {
-    fn render(&mut self, lines: &[avt::Line], cursor: Option<(usize, usize)>) -> ImgVec<RGBA8>;
+    fn render(&mut self, snapshot: &Snapshot) -> ImgVec<RGBA8>;
     fn pixel_size(&self) -> (usize, usize);
 }
 
@@ -204,12 +205,12 @@ mod tests {
         let mut renderer = resvg(settings(false));
         let lines = vt_lines();
 
-        let mut render = |cur| renderer.render(&lines, cur);
+        let mut render_frame = |cur| render(&mut renderer, lines.clone(), cur);
 
         // First render: cursor over (0, 5) — covers every assertion except
         // the two alternate-cursor-position cases (cursor-over-plain-colored,
         // cursor-over-reverse-colored) which need their own renders below.
-        let image = render(Some((0, 5)));
+        let image = render_frame(Some((0, 5)));
 
         // ── color paths ──
         // Cube/grayscale solid fills use threshold 0 (tighter than the resvg
@@ -282,12 +283,12 @@ mod tests {
         assert_rgb_close(cell_center(&image, 2, 11), FG, 3);
 
         // Second render: cursor over the plain colored cell — swap.
-        let image = render(Some((4, 5)));
+        let image = render_frame(Some((4, 5)));
         assert_rgb_close(cell_center(&image, 4, 5), PALETTE[BLUE], 3);
 
         // Third render: cursor over the reverse colored cell — XOR cancels,
         // cell renders with its original (un-swapped) bg color.
-        let image = render(Some((6, 5)));
+        let image = render_frame(Some((6, 5)));
         assert_rgb_close(cell_center(&image, 6, 5), PALETTE[YELLOW], 3);
     }
 
@@ -296,8 +297,8 @@ mod tests {
         let mut renderer = swash(settings(false));
         let lines = vt_lines();
 
-        let mut render = |cur| renderer.render(&lines, cur);
-        let image = render(Some((0, 5)));
+        let mut render_frame = |cur| render(&mut renderer, lines.clone(), cur);
+        let image = render_frame(Some((0, 5)));
 
         // ── color paths ──
         assert_rgb_close(cell_center(&image, 38, 0), BG, 0);
@@ -353,10 +354,10 @@ mod tests {
         assert_rgb_close(cell_center(&image, 0, 11), PALETTE[RED], 4);
         assert_rgb_close(cell_center(&image, 2, 11), FG, 4);
 
-        let image = render(Some((4, 5)));
+        let image = render_frame(Some((4, 5)));
         assert_rgb_close(cell_center(&image, 4, 5), PALETTE[BLUE], 0);
 
-        let image = render(Some((6, 5)));
+        let image = render_frame(Some((6, 5)));
         assert_rgb_close(cell_center(&image, 6, 5), PALETTE[YELLOW], 0);
     }
 
@@ -382,7 +383,7 @@ mod tests {
             "\r\n",
             "\x1b[38;5;3m┡┩┳┴╇\x1b[39m",
         );
-        let image = renderer.render(&lines_for(input), None);
+        let image = render(&mut renderer, lines_for(input), None);
 
         // Heavy vertical and half-lines use centered crisp strokes.
         assert_rgb_close(cell_pixel(&image, 0, 0, 0.5, 0.5), PALETTE[GREEN], 0);
@@ -496,8 +497,9 @@ mod tests {
     fn swash_renders_powerline_symbols_as_cell_geometry() {
         let mut renderer = swash(settings_without_symbol_fallback());
 
-        let image = renderer.render(
-            &lines_for(concat!(
+        let image = render(
+            &mut renderer,
+            lines_for(concat!(
                 "\x1b[38;5;2m",
                 "\u{e0b0}\u{e0b1}\u{e0b2}\u{e0b3}",
                 "\u{e0b4}\u{e0b5}\u{e0b6}\u{e0b7}",
@@ -567,7 +569,7 @@ mod tests {
         let mut settings = settings(false);
         settings.font_size = 40;
         let mut renderer = swash(settings);
-        let image = renderer.render(&lines_for("\x1b[38;5;2m┏\x1b[39m"), None);
+        let image = render(&mut renderer, lines_for("\x1b[38;5;2m┏\x1b[39m"), None);
 
         assert_rgb_close(cell_pixel(&image, 0, 0, 0.42, 0.5), PALETTE[GREEN], 0);
         assert_rgb_close(cell_pixel(&image, 0, 0, 0.5, 0.46), PALETTE[GREEN], 0);
@@ -577,7 +579,11 @@ mod tests {
     #[test]
     fn resvg_renders_nerd_font_symbols() {
         let mut renderer = resvg(settings(false));
-        let image = renderer.render(&lines_for("\x1b[38;5;2m\u{f43a}\x1b[39m"), None);
+        let image = render(
+            &mut renderer,
+            lines_for("\x1b[38;5;2m\u{f43a}\x1b[39m"),
+            None,
+        );
 
         assert_nerd_font_symbol_rendered(&image, 3);
     }
@@ -607,7 +613,11 @@ mod tests {
         };
 
         let mut renderer = resvg(settings);
-        let image = renderer.render(&lines_for("\x1b[38;5;2m\u{f43a}\x1b[39m"), None);
+        let image = render(
+            &mut renderer,
+            lines_for("\x1b[38;5;2m\u{f43a}\x1b[39m"),
+            None,
+        );
 
         assert_nerd_font_symbol_rendered(&image, 3);
     }
@@ -615,7 +625,11 @@ mod tests {
     #[test]
     fn swash_renders_nerd_font_symbols() {
         let mut renderer = swash(settings(false));
-        let image = renderer.render(&lines_for("\x1b[38;5;2m\u{f43a}\x1b[39m"), None);
+        let image = render(
+            &mut renderer,
+            lines_for("\x1b[38;5;2m\u{f43a}\x1b[39m"),
+            None,
+        );
 
         assert_nerd_font_symbol_rendered(&image, 0);
     }
@@ -624,8 +638,9 @@ mod tests {
     fn swash_preserves_nerd_font_symbol_overhang() {
         let mut renderer = swash(settings(false));
 
-        let image = renderer.render(
-            &lines_for("\x1b[38;5;2m\u{f03d}\x1b[39m\x1b[48;5;3m \x1b[49m"),
+        let image = render(
+            &mut renderer,
+            lines_for("\x1b[38;5;2m\u{f03d}\x1b[39m\x1b[48;5;3m \x1b[49m"),
             None,
         );
 
@@ -650,7 +665,7 @@ mod tests {
         };
 
         let mut renderer = swash(settings);
-        let image = renderer.render(&lines_for("\x1b[48;5;3m日\x1b[49m"), None);
+        let image = render(&mut renderer, lines_for("\x1b[48;5;3m日\x1b[49m"), None);
 
         assert_closer_to(cell_pixel(&image, 1, 0, 0.3, 0.5), FG, PALETTE[YELLOW]);
     }
@@ -677,13 +692,13 @@ mod tests {
         };
 
         let mut fallback_renderer = swash(settings(make_db(), vec![]));
-        let fallback_image = fallback_renderer.render(&lines_for("M"), None);
+        let fallback_image = render(&mut fallback_renderer, lines_for("M"), None);
 
         let mut regular_renderer = swash(settings(make_db(), vec![FONT_FAMILY.to_owned()]));
-        let regular_image = regular_renderer.render(&lines_for("M"), None);
+        let regular_image = render(&mut regular_renderer, lines_for("M"), None);
 
         let mut italic_renderer = swash(settings(make_db(), vec![FONT_FAMILY.to_owned()]));
-        let italic_image = italic_renderer.render(&lines_for("\x1b[3mM"), None);
+        let italic_image = render(&mut italic_renderer, lines_for("\x1b[3mM"), None);
 
         assert_images_equal(&fallback_image, &regular_image);
         assert_images_differ(&fallback_image, &italic_image);
@@ -696,7 +711,7 @@ mod tests {
     fn resvg_bold_is_bright_brightens() {
         let mut renderer = resvg(settings(true));
         let lines = vt_lines();
-        let image = renderer.render(&lines, None);
+        let image = render(&mut renderer, lines.clone(), None);
         assert_rgb_close(cell_center(&image, 0, 11), PALETTE[BRIGHT_RED], 3);
         assert_rgb_close(cell_center(&image, 2, 11), PALETTE[BRIGHT_WHITE], 3);
     }
@@ -705,7 +720,7 @@ mod tests {
     fn swash_bold_is_bright_brightens() {
         let mut renderer = swash(settings(true));
         let lines = vt_lines();
-        let image = renderer.render(&lines, None);
+        let image = render(&mut renderer, lines.clone(), None);
         assert_rgb_close(cell_center(&image, 0, 11), PALETTE[BRIGHT_RED], 4);
         assert_rgb_close(cell_center(&image, 2, 11), PALETTE[BRIGHT_WHITE], 4);
     }
@@ -737,7 +752,7 @@ mod tests {
         };
 
         let mut renderer = swash(settings);
-        let image = renderer.render(&lines_for("😀"), None);
+        let image = render(&mut renderer, lines_for("😀"), None);
 
         assert_cell_has_ink(&image, 0, 0, 2);
     }
@@ -769,11 +784,19 @@ mod tests {
 
         let mut renderer = swash(settings);
         let lines = lines_for("⭐");
-        let image = renderer.render(&lines, None);
+        let image = render(&mut renderer, lines.clone(), None);
 
         assert_color_emoji_rendered(&image, 0, 0, 2);
     }
 
+    fn render<R: Renderer>(
+        renderer: &mut R,
+        lines: Vec<avt::Line>,
+        cursor: Option<(usize, usize)>,
+    ) -> ImgVec<RGBA8> {
+        renderer.render(&Snapshot { lines, cursor })
+    }
+
     fn settings(bold_is_bright: bool) -> Settings {
         let mut font_db = fontdb::Database::new();
         font_db.load_font_data(include_bytes!("../fonts/JetBrainsMono-Regular.ttf").to_vec());
diff --git a/src/renderer/resvg.rs b/src/renderer/resvg.rs
index fc9991f..819ee8d 100644
--- a/src/renderer/resvg.rs
+++ b/src/renderer/resvg.rs
@@ -4,6 +4,7 @@ use imgref::ImgVec;
 use rgb::{FromSlice, RGBA8};
 
 use super::{color_to_rgb, text_attrs, Renderer, Settings, TextAttrs};
+use crate::terminal::Snapshot;
 use crate::theme::Theme;
 
 pub struct ResvgRenderer<'a> {
@@ -392,8 +393,8 @@ impl<'a> ResvgRenderer<'a> {
 }
 
 impl<'a> Renderer for ResvgRenderer<'a> {
-    fn render(&mut self, lines: &[avt::Line], cursor: Option<(usize, usize)>) -> ImgVec<RGBA8> {
-        let svg = self.svg_for_frame(lines, cursor);
+    fn render(&mut self, snapshot: &Snapshot) -> ImgVec<RGBA8> {
+        let svg = self.svg_for_frame(&snapshot.lines, snapshot.cursor);
         let tree = usvg::Tree::from_str(&svg, &self.options).unwrap();
 
         let mut pixmap =
diff --git a/src/renderer/swash.rs b/src/renderer/swash.rs
index 12dac55..5f30aad 100644
--- a/src/renderer/swash.rs
+++ b/src/renderer/swash.rs
@@ -10,6 +10,7 @@ use swash::scale::{Render, ScaleContext, Source, StrikeWith};
 use swash::FontRef;
 
 use crate::renderer::{color_to_rgb, text_attrs, Renderer, Settings, TextAttrs};
+use crate::terminal::Snapshot;
 use crate::theme::Theme;
 
 type CharVariant = (char, bool, bool);
@@ -1216,13 +1217,13 @@ fn sextant_mask(cp: u32) -> Option<u8> {
 }
 
 impl Renderer for SwashRenderer {
-    fn render(&mut self, lines: &[avt::Line], cursor: Option<(usize, usize)>) -> ImgVec<RGBA8> {
+    fn render(&mut self, snapshot: &Snapshot) -> ImgVec<RGBA8> {
         let mut buf = self.new_frame();
         let margin_l = self.col_width;
         let margin_t = (self.row_height / 2.0).round() as usize;
         let mut cells = Vec::new();
 
-        for (row, line) in lines.iter().enumerate() {
+        for (row, line) in snapshot.lines.iter().enumerate() {
             let mut col = 0;
 
             for cell in line.cells() {
@@ -1232,7 +1233,7 @@ impl Renderer for SwashRenderer {
 
                 let attrs = text_attrs(
                     cell.pen(),
-                    &cursor,
+                    &snapshot.cursor,
                     col,
                     row,
                     &self.theme,
diff --git a/src/selection.rs b/src/selection.rs
new file mode 100644
index 0000000..c9dc97e
--- /dev/null
+++ b/src/selection.rs
@@ -0,0 +1,306 @@
+//! Selection parsing and resolution.
+
+mod spec;
+
+pub use spec::{SelectionSpec, TimelinePosition};
+
+use anyhow::{anyhow, bail, Result};
+
+use crate::timeline;
+
+/// A recording-resolved selection, ready for replay. Every timeline position has
+/// been resolved to an absolute timestamp.
+#[derive(Debug, PartialEq)]
+pub enum SelectionPlan {
+    Range {
+        start: Option<f64>,
+        end: Option<f64>,
+    },
+    Positions(Vec<f64>),
+}
+
+/// Resolve a parsed spec against a recording, applying all recording-dependent
+/// validation. Returned timestamps for `Positions` are sorted and deduplicated.
+pub fn resolve(spec: &SelectionSpec, summary: &timeline::Summary) -> Result<SelectionPlan> {
+    if !summary.has_output() {
+        bail!("the recording has no output events");
+    }
+
+    match spec {
+        SelectionSpec::Markers => {
+            if summary.markers().is_empty() {
+                bail!("the recording has no markers");
+            }
+
+            let timestamps = summary.markers().iter().map(|(t, _)| *t).collect();
+
+            Ok(SelectionPlan::Positions(sorted_deduped(timestamps)))
+        }
+
+        SelectionSpec::Positions(positions) => {
+            let timestamps = positions
+                .iter()
+                .map(|p| resolve_position(p, summary))
+                .collect::<Result<Vec<_>>>()?;
+
+            Ok(SelectionPlan::Positions(sorted_deduped(timestamps)))
+        }
+
+        SelectionSpec::Range { start, end } => {
+            let start = start
+                .as_ref()
+                .map(|p| resolve_position(p, summary))
+                .transpose()?;
+
+            let end = end
+                .as_ref()
+                .map(|p| resolve_position(p, summary))
+                .transpose()?;
+
+            if let (Some(start), Some(end)) = (start, end) {
+                if start > end {
+                    bail!("range start ({start:.3}s) is after range end ({end:.3}s)");
+                }
+            }
+
+            Ok(SelectionPlan::Range { start, end })
+        }
+    }
+}
+
+fn resolve_position(position: &TimelinePosition, summary: &timeline::Summary) -> Result<f64> {
+    match position {
+        TimelinePosition::Time(t) => {
+            if *t > summary.duration() {
+                bail!(
+                    "position {t}s is beyond the recording duration ({:.3}s)",
+                    summary.duration()
+                );
+            }
+
+            Ok(*t)
+        }
+
+        TimelinePosition::Percent(p) => {
+            if !(0.0..=100.0).contains(p) {
+                bail!("percentage {p}% is outside the range 0%..100%");
+            }
+
+            Ok(summary.duration() * p / 100.0)
+        }
+
+        TimelinePosition::MarkerIndex(i) => {
+            summary.markers().get(*i).map(|(t, _)| *t).ok_or_else(|| {
+                anyhow!(
+                    "marker index {i} is out of range (recording has {} markers)",
+                    summary.markers().len()
+                )
+            })
+        }
+
+        TimelinePosition::MarkerPrefix(prefix) => {
+            let prefix = prefix.to_lowercase();
+
+            // Unlabeled markers have an empty label and never match a prefix.
+            let mut matches = summary
+                .markers()
+                .iter()
+                .filter(|(_, label)| label.to_lowercase().starts_with(&prefix))
+                .map(|(t, _)| *t);
+
+            match (matches.next(), matches.next()) {
+                (Some(t), None) => Ok(t),
+                (None, _) => bail!("no marker label matches prefix {prefix:?}"),
+                (Some(_), Some(_)) => bail!("marker prefix {prefix:?} matches multiple markers"),
+            }
+        }
+
+        TimelinePosition::EventIndex(i) => {
+            summary.event_times().get(*i).copied().ok_or_else(|| {
+                anyhow!(
+                    "event index {i} is out of range (recording has {} events)",
+                    summary.event_times().len()
+                )
+            })
+        }
+    }
+}
+
+fn sorted_deduped(mut timestamps: Vec<f64>) -> Vec<f64> {
+    timestamps.sort_by(f64::total_cmp);
+    timestamps.dedup();
+
+    timestamps
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::asciicast::Event;
+
+    fn output(time: f64, data: &str) -> Event {
+        Event::Output {
+            time,
+            data: data.to_owned(),
+        }
+    }
+
+    fn marker(time: f64) -> Event {
+        labeled_marker(time, "m")
+    }
+
+    fn labeled_marker(time: f64, label: &str) -> Event {
+        Event::Marker {
+            time,
+            label: label.to_owned(),
+        }
+    }
+
+    fn plan(selector: &str, events: &[Event]) -> Result<SelectionPlan> {
+        resolve(
+            &selector.parse::<SelectionSpec>().unwrap(),
+            &timeline::Summary::from_events(events),
+        )
+    }
+
+    #[test]
+    fn resolve_rejects_recording_with_no_output() {
+        let events = [marker(1.0)];
+        assert!(plan("..", &events).is_err());
+        assert!(plan("markers", &events).is_err());
+    }
+
+    #[test]
+    fn resolve_rejects_positions_beyond_duration() {
+        let events = [output(2.0, "a"), output(10.0, "b")];
+
+        assert!(plan("999", &events).is_err());
+        assert!(plan("..999", &events).is_err());
+        assert!(plan("5", &events).is_ok());
+
+        assert_eq!(
+            plan("..0", &events).unwrap(),
+            SelectionPlan::Range {
+                start: None,
+                end: Some(0.0)
+            }
+        );
+    }
+
+    #[test]
+    fn resolve_percent_against_adjusted_duration() {
+        let events = [output(2.0, "a"), output(10.0, "b")];
+
+        assert_eq!(
+            plan("50%", &events).unwrap(),
+            SelectionPlan::Positions(vec![5.0])
+        );
+
+        assert_eq!(
+            plan("100%", &events).unwrap(),
+            SelectionPlan::Positions(vec![10.0])
+        );
+
+        assert!(plan("150%", &events).is_err());
+    }
+
+    #[test]
+    fn resolve_marker_index_and_prefix() {
+        let events = [
+            output(1.0, "a"),
+            labeled_marker(2.0, "build"),
+            labeled_marker(3.0, "test"),
+            output(4.0, "b"),
+        ];
+
+        assert_eq!(
+            plan("marker:0", &events).unwrap(),
+            SelectionPlan::Positions(vec![2.0])
+        );
+
+        assert!(plan("marker:2", &events).is_err());
+
+        assert_eq!(
+            plan("marker:BUI", &events).unwrap(),
+            SelectionPlan::Positions(vec![2.0])
+        );
+
+        assert!(plan("marker:nope", &events).is_err());
+    }
+
+    #[test]
+    fn resolve_ambiguous_marker_prefix_is_invalid() {
+        let events = [
+            output(1.0, "a"),
+            labeled_marker(2.0, "build"),
+            labeled_marker(3.0, "builder"),
+        ];
+
+        assert!(plan("marker:build", &events).is_err());
+    }
+
+    #[test]
+    fn resolve_unlabeled_marker_does_not_match_prefix() {
+        let events = [output(1.0, "a"), labeled_marker(2.0, "")];
+
+        assert!(plan("marker:x", &events).is_err());
+
+        // The empty-labeled marker is still reachable by index and by `markers`.
+        assert_eq!(
+            plan("marker:0", &events).unwrap(),
+            SelectionPlan::Positions(vec![2.0])
+        );
+    }
+
+    #[test]
+    fn resolve_event_index_against_file_order() {
+        let events = [output(1.0, "a"), marker(2.0), output(3.0, "b")];
+
+        assert_eq!(
+            plan("event:1", &events).unwrap(),
+            SelectionPlan::Positions(vec![2.0])
+        );
+
+        assert!(plan("event:3", &events).is_err());
+    }
+
+    #[test]
+    fn resolve_markers_keyword_sorted_and_deduped() {
+        let events = [
+            output(1.0, "a"),
+            labeled_marker(6.0, "x"),
+            labeled_marker(2.0, "y"),
+            labeled_marker(2.0, "z"),
+        ];
+
+        assert_eq!(
+            plan("markers", &events).unwrap(),
+            SelectionPlan::Positions(vec![2.0, 6.0])
+        );
+    }
+
+    #[test]
+    fn resolve_markers_keyword_requires_at_least_one_marker() {
+        let events = [output(1.0, "a"), output(2.0, "b")];
+
+        assert!(plan("markers", &events).is_err());
+    }
+
+    #[test]
+    fn resolve_positions_sorted_and_deduped() {
+        let events = [output(2.0, "a"), output(10.0, "b")];
+
+        assert_eq!(
+            plan("10,5,5,2", &events).unwrap(),
+            SelectionPlan::Positions(vec![2.0, 5.0, 10.0])
+        );
+    }
+
+    #[test]
+    fn resolve_rejects_range_start_after_end() {
+        let events = [output(2.0, "a"), output(10.0, "b")];
+
+        assert!(plan("8..3", &events).is_err());
+        assert!(plan("3..8", &events).is_ok());
+    }
+}
diff --git a/src/selection/spec.rs b/src/selection/spec.rs
new file mode 100644
index 0000000..11a9696
--- /dev/null
+++ b/src/selection/spec.rs
@@ -0,0 +1,393 @@
+//! Parsing of `--select` values into a [`SelectionSpec`].
+//!
+//! This stage is recording-independent: it validates syntax and shape only.
+//! Resolving positions to timestamps and all duration/marker/event checks happen
+//! later, against the adjusted timeline (see [`super::resolve`]).
+
+use std::str::FromStr;
+
+/// A parsed `--select` value, before resolution against a recording.
+#[derive(Debug, Clone, PartialEq)]
+pub enum SelectionSpec {
+    Range {
+        start: Option<TimelinePosition>,
+        end: Option<TimelinePosition>,
+    },
+    Positions(Vec<TimelinePosition>),
+    Markers,
+}
+
+/// A position on the recording timeline, resolved to a timestamp during
+/// validation.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TimelinePosition {
+    Time(f64),
+    Percent(f64),
+    MarkerIndex(usize),
+    MarkerPrefix(String),
+    EventIndex(usize),
+}
+
+/// The default selection is the whole recording.
+impl Default for SelectionSpec {
+    fn default() -> Self {
+        SelectionSpec::Range {
+            start: None,
+            end: None,
+        }
+    }
+}
+
+impl FromStr for SelectionSpec {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.contains("..") {
+            let parts: Vec<&str> = s.split("..").collect();
+
+            if parts.len() != 2 {
+                return Err(format!("a range may contain only one '..': {s:?}"));
+            }
+
+            Ok(SelectionSpec::Range {
+                start: parse_bound(parts[0])?,
+                end: parse_bound(parts[1])?,
+            })
+        } else if s == "markers" {
+            Ok(SelectionSpec::Markers)
+        } else {
+            // A discrete list. `markers` is not a valid list item; it fails to
+            // parse as a position, which rejects values like `markers,5`.
+            let positions = s
+                .split(',')
+                .map(parse_position)
+                .collect::<Result<Vec<_>, _>>()?;
+
+            Ok(SelectionSpec::Positions(positions))
+        }
+    }
+}
+
+fn parse_bound(s: &str) -> Result<Option<TimelinePosition>, String> {
+    if s.is_empty() {
+        Ok(None)
+    } else {
+        parse_position(s).map(Some)
+    }
+}
+
+fn parse_position(s: &str) -> Result<TimelinePosition, String> {
+    if let Some(value) = s.strip_prefix("marker:") {
+        if value.is_empty() {
+            return Err("empty marker value".to_string());
+        }
+
+        // All-digit values are 0-based marker indexes; anything else is a label
+        // prefix (matched case-insensitively during resolution).
+        if value.bytes().all(|b| b.is_ascii_digit()) {
+            let index = value
+                .parse()
+                .map_err(|_| format!("invalid marker index: {value:?}"))?;
+
+            return Ok(TimelinePosition::MarkerIndex(index));
+        }
+
+        return Ok(TimelinePosition::MarkerPrefix(value.to_string()));
+    }
+
+    if let Some(value) = s.strip_prefix("event:") {
+        let index = value
+            .parse()
+            .map_err(|_| format!("invalid event index: {value:?}"))?;
+
+        return Ok(TimelinePosition::EventIndex(index));
+    }
+
+    if let Some(value) = s.strip_suffix('%') {
+        let percent: f64 = value
+            .parse()
+            .map_err(|_| format!("invalid percentage: {s:?}"))?;
+
+        if !percent.is_finite() {
+            return Err(format!("invalid percentage: {s:?}"));
+        }
+
+        return Ok(TimelinePosition::Percent(percent));
+    }
+
+    Ok(TimelinePosition::Time(parse_time(s)?))
+}
+
+/// Parse a time value: bare seconds, unit-suffixed (`1h2m3s`), or a clock value
+/// (`MM:SS` / `HH:MM:SS`).
+fn parse_time(s: &str) -> Result<f64, String> {
+    if s.is_empty() {
+        Err("empty time".to_string())
+    } else if s.contains(':') {
+        parse_clock(s)
+    } else if s.ends_with(['h', 'm', 's']) {
+        parse_units(s)
+    } else {
+        parse_seconds(s)
+    }
+}
+
+fn parse_seconds(s: &str) -> Result<f64, String> {
+    match s.parse::<f64>() {
+        Ok(v) if v.is_finite() && v >= 0.0 => Ok(v),
+        _ => Err(format!("invalid time: {s:?}")),
+    }
+}
+
+/// Parse `Nh`/`Nm`/`Ns` components: any non-empty ordered subset, no repeats,
+/// integer hours and minutes, optional fractional seconds.
+fn parse_units(s: &str) -> Result<f64, String> {
+    let mut total = 0.0;
+    let mut num = String::new();
+    let mut last_rank = 0u8;
+
+    for ch in s.chars() {
+        if ch.is_ascii_digit() || ch == '.' {
+            num.push(ch);
+            continue;
+        }
+
+        let (rank, mult) = match ch {
+            'h' => (1u8, 3600.0),
+            'm' => (2, 60.0),
+            's' => (3, 1.0),
+            _ => return Err(format!("invalid time unit {ch:?} in {s:?}")),
+        };
+
+        if rank <= last_rank {
+            return Err(format!("time units must be ordered h, m, s in {s:?}"));
+        }
+
+        if num.is_empty() {
+            return Err(format!("missing number before {ch:?} in {s:?}"));
+        }
+
+        if ch != 's' && num.contains('.') {
+            return Err(format!("fractional {ch} component not allowed in {s:?}"));
+        }
+
+        let value: f64 = num
+            .parse()
+            .map_err(|_| format!("invalid number in {s:?}"))?;
+
+        total += value * mult;
+        last_rank = rank;
+        num.clear();
+    }
+
+    debug_assert!(num.is_empty());
+
+    Ok(total)
+}
+
+fn parse_clock(s: &str) -> Result<f64, String> {
+    let parts: Vec<&str> = s.split(':').collect();
+
+    let mults: &[f64] = match parts.len() {
+        2 => &[60.0, 1.0],
+        3 => &[3600.0, 60.0, 1.0],
+        _ => return Err(format!("expected MM:SS or HH:MM:SS: {s:?}")),
+    };
+
+    let last = parts.len() - 1;
+    let mut total = 0.0;
+
+    for (i, part) in parts.iter().enumerate() {
+        let value = if i == last {
+            // Only the final component may be fractional.
+            match part.parse::<f64>() {
+                Ok(v) if v.is_finite() && v >= 0.0 => v,
+                _ => return Err(format!("invalid time component {part:?} in {s:?}")),
+            }
+        } else {
+            part.parse::<u64>()
+                .map_err(|_| format!("invalid time component {part:?} in {s:?}"))?
+                as f64
+        };
+
+        // Components after the first represent minutes or seconds.
+        if i != 0 && value >= 60.0 {
+            return Err(format!("time component {part:?} must be < 60 in {s:?}"));
+        }
+
+        total += value * mults[i];
+    }
+
+    Ok(total)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::TimelinePosition::*;
+    use super::*;
+
+    fn spec(s: &str) -> SelectionSpec {
+        s.parse().unwrap()
+    }
+
+    fn time(s: &str) -> f64 {
+        match parse_position(s).unwrap() {
+            Time(t) => t,
+            other => panic!("expected time, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn classifies_range_markers_and_positions() {
+        assert_eq!(
+            spec(".."),
+            SelectionSpec::Range {
+                start: None,
+                end: None
+            }
+        );
+        assert_eq!(
+            spec("5.."),
+            SelectionSpec::Range {
+                start: Some(Time(5.0)),
+                end: None
+            }
+        );
+        assert_eq!(
+            spec("..30"),
+            SelectionSpec::Range {
+                start: None,
+                end: Some(Time(30.0))
+            }
+        );
+        assert_eq!(
+            spec("5..30"),
+            SelectionSpec::Range {
+                start: Some(Time(5.0)),
+                end: Some(Time(30.0))
+            }
+        );
+        assert_eq!(spec("markers"), SelectionSpec::Markers);
+        assert_eq!(spec("12.5"), SelectionSpec::Positions(vec![Time(12.5)]));
+        assert_eq!(
+            spec("5,10,15"),
+            SelectionSpec::Positions(vec![Time(5.0), Time(10.0), Time(15.0)])
+        );
+    }
+
+    #[test]
+    fn parses_mixed_position_kinds() {
+        assert_eq!(
+            spec("1,50%,marker:build,event:100"),
+            SelectionSpec::Positions(vec![
+                Time(1.0),
+                Percent(50.0),
+                MarkerPrefix("build".to_string()),
+                EventIndex(100),
+            ])
+        );
+        assert_eq!(
+            spec("marker:build..marker:test"),
+            SelectionSpec::Range {
+                start: Some(MarkerPrefix("build".to_string())),
+                end: Some(MarkerPrefix("test".to_string())),
+            }
+        );
+        assert_eq!(
+            spec("event:100..marker:3"),
+            SelectionSpec::Range {
+                start: Some(EventIndex(100)),
+                end: Some(MarkerIndex(3)),
+            }
+        );
+    }
+
+    #[test]
+    fn parses_marker_index_vs_prefix() {
+        assert_eq!(parse_position("marker:3").unwrap(), MarkerIndex(3));
+        assert_eq!(
+            parse_position("marker:3d").unwrap(),
+            MarkerPrefix("3d".to_string())
+        );
+        assert_eq!(
+            parse_position("marker:Build").unwrap(),
+            MarkerPrefix("Build".to_string())
+        );
+    }
+
+    #[test]
+    fn parses_percent_positions() {
+        assert_eq!(parse_position("0%").unwrap(), Percent(0.0));
+        assert_eq!(parse_position("100%").unwrap(), Percent(100.0));
+        assert_eq!(parse_position("50.5%").unwrap(), Percent(50.5));
+    }
+
+    #[test]
+    fn parses_bare_and_unit_times() {
+        assert_eq!(time("12.5"), 12.5);
+        assert_eq!(time("12.5s"), 12.5);
+        assert_eq!(time("1h"), 3600.0);
+        assert_eq!(time("2m"), 120.0);
+        assert_eq!(time("1h2m"), 3720.0);
+        assert_eq!(time("1m20s"), 80.0);
+        assert_eq!(time("1h2m3s"), 3723.0);
+        assert_eq!(time("1m20.5s"), 80.5);
+        assert_eq!(time("1h3s"), 3603.0);
+    }
+
+    #[test]
+    fn parses_clock_times() {
+        assert_eq!(time("1:20"), 80.0);
+        assert_eq!(time("1:20.5"), 80.5);
+        assert_eq!(time("00:01:20"), 80.0);
+        assert_eq!(time("1:00:00"), 3600.0);
+    }
+
+    #[test]
+    fn rejects_malformed_ranges() {
+        assert!("5..10..15".parse::<SelectionSpec>().is_err());
+        assert!("5....10".parse::<SelectionSpec>().is_err());
+    }
+
+    #[test]
+    fn rejects_markers_inside_a_list() {
+        assert!("markers,5".parse::<SelectionSpec>().is_err());
+        assert!("5,markers".parse::<SelectionSpec>().is_err());
+    }
+
+    #[test]
+    fn rejects_empty_marker_value() {
+        assert!(parse_position("marker:").is_err());
+        assert!("marker:..5".parse::<SelectionSpec>().is_err());
+    }
+
+    #[test]
+    fn rejects_empty_list_items() {
+        assert!("5,,10".parse::<SelectionSpec>().is_err());
+        assert!("5,".parse::<SelectionSpec>().is_err());
+        assert!("".parse::<SelectionSpec>().is_err());
+    }
+
+    #[test]
+    fn rejects_invalid_event_index() {
+        assert!(parse_position("event:").is_err());
+        assert!(parse_position("event:1.5").is_err());
+        assert!(parse_position("event:-1").is_err());
+    }
+
+    #[test]
+    fn rejects_invalid_times() {
+        assert!(parse_time("-5").is_err());
+        assert!(parse_time("-5s").is_err());
+        assert!(parse_time("1.5h").is_err());
+        assert!(parse_time("1.5m").is_err());
+        assert!(parse_time("1s2h").is_err());
+        assert!(parse_time("5ss").is_err());
+        assert!(parse_time("abc").is_err());
+        assert!(parse_time("1:80").is_err());
+        assert!(parse_time("1:20:80").is_err());
+        assert!(parse_time("1.5:20").is_err());
+        assert!(parse_time("1:2.5:03").is_err());
+        assert!(parse_time("1:2:3:4").is_err());
+    }
+}
diff --git a/src/terminal.rs b/src/terminal.rs
new file mode 100644
index 0000000..1b79436
--- /dev/null
+++ b/src/terminal.rs
@@ -0,0 +1,31 @@
+use avt::Vt;
+
+pub fn build(terminal_size: (usize, usize)) -> Vt {
+    Vt::builder()
+        .size(terminal_size.0, terminal_size.1)
+        .scrollback_limit(0)
+        .build()
+}
+
+pub fn feed_str(vt: &mut Vt, data: &str) {
+    vt.feed_str(data);
+}
+
+#[derive(Clone)]
+pub struct Snapshot {
+    pub lines: Vec<avt::Line>,
+    pub cursor: Option<(usize, usize)>,
+}
+
+impl Snapshot {
+    pub fn from_vt(vt: &Vt) -> Self {
+        Snapshot {
+            lines: vt.view().cloned().collect(),
+            cursor: vt.cursor().into(),
+        }
+    }
+
+    pub fn same_visual(&self, other: &Snapshot) -> bool {
+        self.lines == other.lines && self.cursor == other.cursor
+    }
+}
diff --git a/src/timeline.rs b/src/timeline.rs
new file mode 100644
index 0000000..ab2f6cb
--- /dev/null
+++ b/src/timeline.rs
@@ -0,0 +1,178 @@
+use anyhow::Result;
+
+use crate::asciicast::Event;
+
+/// The slice of an adjusted recording timeline needed to resolve selections.
+pub struct Summary {
+    duration: f64,
+    has_output: bool,
+    markers: Vec<(f64, String)>,
+    event_times: Vec<f64>,
+}
+
+impl Summary {
+    pub fn from_events(events: &[Event]) -> Self {
+        let markers = events
+            .iter()
+            .filter_map(|e| match e {
+                Event::Marker { time, label } => Some((*time, label.clone())),
+                _ => None,
+            })
+            .collect();
+
+        Summary {
+            // Adjusted duration is the timestamp of the last timeline event,
+            // including non-visual events such as markers and exits.
+            duration: events.last().map_or(0.0, Event::time),
+            has_output: events.iter().any(|e| matches!(e, Event::Output { .. })),
+            markers,
+            event_times: events.iter().map(Event::time).collect(),
+        }
+    }
+
+    pub fn duration(&self) -> f64 {
+        self.duration
+    }
+
+    pub fn has_output(&self) -> bool {
+        self.has_output
+    }
+
+    pub fn markers(&self) -> &[(f64, String)] {
+        &self.markers
+    }
+
+    pub fn event_times(&self) -> &[f64] {
+        &self.event_times
+    }
+}
+
+pub fn accelerate(
+    events: impl Iterator<Item = Result<Event>>,
+    speed: f64,
+) -> impl Iterator<Item = Result<Event>> {
+    events.map(move |event| {
+        event.map(|e| {
+            let time = e.time();
+            e.with_time(time / speed)
+        })
+    })
+}
+
+pub fn limit_idle_time(
+    events: impl Iterator<Item = Result<Event>>,
+    limit: f64,
+) -> impl Iterator<Item = Result<Event>> {
+    let mut prev_time = 0.0;
+    let mut offset = 0.0;
+
+    events.map(move |event| {
+        event.map(|e| {
+            let time = e.time();
+            let excess = (time - prev_time) - limit;
+
+            if excess > 0.0 {
+                offset += excess;
+            }
+
+            prev_time = time;
+
+            e.with_time(time - offset)
+        })
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::asciicast::Event;
+    use anyhow::Result;
+
+    fn output(time: f64) -> Event {
+        Event::Output {
+            time,
+            data: "x".to_owned(),
+        }
+    }
+
+    fn times(events: Vec<Event>) -> Vec<f64> {
+        events.into_iter().map(|e| e.time()).collect()
+    }
+
+    #[test]
+    fn summary_duration_includes_trailing_non_output_event() {
+        // Duration is the timestamp of the last timeline event even when it is a
+        // non-output event such as a marker.
+        let events = [
+            output(1.0),
+            Event::Marker {
+                time: 5.0,
+                label: "end".to_owned(),
+            },
+        ];
+
+        let summary = super::Summary::from_events(&events);
+
+        assert_eq!(summary.duration(), 5.0);
+        assert!(summary.has_output());
+        assert_eq!(summary.markers(), &[(5.0, "end".to_owned())]);
+        assert_eq!(summary.event_times(), &[1.0, 5.0]);
+    }
+
+    #[test]
+    fn summary_of_empty_timeline_has_zero_duration_and_no_output() {
+        let summary = super::Summary::from_events(&[]);
+
+        assert_eq!(summary.duration(), 0.0);
+        assert!(!summary.has_output());
+        assert!(summary.markers().is_empty());
+        assert!(summary.event_times().is_empty());
+    }
+
+    #[test]
+    fn accelerate_scales_event_timestamps() {
+        let events = [output(0.0), output(1.0), output(2.0)];
+
+        let events = super::accelerate(events.into_iter().map(Ok), 2.0)
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(times(events), vec![0.0, 0.5, 1.0]);
+    }
+
+    #[test]
+    fn limit_idle_time_collapses_long_gaps() {
+        let events = [
+            output(0.0),
+            output(1.0),
+            output(3.5),
+            output(4.0),
+            output(7.5),
+        ];
+
+        let events = super::limit_idle_time(events.into_iter().map(Ok), 2.0)
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(times(events), vec![0.0, 1.0, 3.0, 3.5, 5.5]);
+    }
+
+    #[test]
+    fn limit_idle_time_collapses_gaps_around_non_output_events() {
+        // The marker sits inside a long idle gap and participates in idle-gap
+        // calculation, so the gap is collapsed on both sides of it.
+        let events = [
+            output(1.0),
+            Event::Marker {
+                time: 10.0,
+                label: "m".to_owned(),
+            },
+            output(20.0),
+        ];
+
+        let events = super::limit_idle_time(events.into_iter().map(Ok), 2.0)
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(times(events), vec![1.0, 3.0, 5.0]);
+    }
+}
diff --git a/src/vt.rs b/src/vt.rs
deleted file mode 100644
index a8faa8d..0000000
--- a/src/vt.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use anyhow::Result;
-use log::debug;
-
-type Frame = (f64, Vec<avt::Line>, Option<(usize, usize)>);
-
-pub fn frames(
-    stdout: impl Iterator<Item = Result<(f64, String)>>,
-    terminal_size: (usize, usize),
-) -> impl Iterator<Item = Result<Frame>> {
-    let mut vt = avt::Vt::builder()
-        .size(terminal_size.0, terminal_size.1)
-        .scrollback_limit(0)
-        .build();
-
-    let mut prev_cursor = None;
-
-    stdout.filter_map(move |event| {
-        event
-            .map(|(time, data)| {
-                let changed_lines = vt.feed_str(&data).lines;
-                let cursor: Option<(usize, usize)> = vt.cursor().into();
-
-                if !changed_lines.is_empty() || cursor != prev_cursor {
-                    prev_cursor = cursor;
-                    let lines = vt.view().cloned().collect();
-
-                    Some((time, lines, cursor))
-                } else {
-                    prev_cursor = cursor;
-                    debug!("skipping frame with no visual changes: {:?}", data);
-
-                    None
-                }
-            })
-            .transpose()
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-
-    #[test]
-    fn frames() {
-        let stdout = [
-            (0.0, "foo".to_owned()),
-            (1.0, "\x1b[0m".to_owned()),
-            (2.0, "bar".to_owned()),
-            (3.0, "!".to_owned()),
-        ];
-
-        let fs = super::frames(stdout.into_iter().map(Ok), (4, 2))
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(fs.len(), 3);
-
-        let (time, lines, cursor) = &fs[0];
-        let lines: Vec<String> = lines.iter().map(|l| l.text()).collect();
-
-        assert_eq!(*time, 0.0);
-        assert_eq!(*cursor, Some((3, 0)));
-        assert_eq!(lines[0], "foo ");
-        assert_eq!(lines[1], "    ");
-
-        let (time, lines, cursor) = &fs[1];
-        let lines: Vec<String> = lines.iter().map(|l| l.text()).collect();
-
-        assert_eq!(*time, 2.0);
-        assert_eq!(*cursor, Some((2, 1)));
-        assert_eq!(lines[0], "foob");
-        assert_eq!(lines[1], "ar  ");
-
-        let (time, lines, cursor) = &fs[2];
-        let lines: Vec<String> = lines.iter().map(|l| l.text()).collect();
-
-        assert_eq!(*time, 3.0);
-        assert_eq!(*cursor, Some((3, 1)));
-        assert_eq!(lines[0], "foob");
-        assert_eq!(lines[1], "ar! ");
-    }
-}