diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00e1e40..6e6e422 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+# 4.0.0 (unreleased)
+## Features
+- `MidiFile::into_events` returns an iterator of `Timed<LiveEvent>`
+- `Micros` and `UMicros`: strongly typed microseconds
+- `DurationExt` for `core::time::Duration`. Converts the duration into `UMicros`
+
+## Breaking Changes
+- `Note` -> `Key`, and `Key` -> `Note`
+  - `key!` -> `note!`
+  - All variants that contained a `key` field have been replaced with a `note` field
+
+
 # 3.2.0
 ## `bevy_midix` (April 15, 2025)
 - feat: WASM compatability with example!
diff --git a/Cargo.toml b/Cargo.toml
index 54fd5b7..c161609 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "midix"
-version = "4.0.0-alpha.2"
+version = "4.0.0-alpha.5"
 authors = ["dsgallups <dsgallups@protonmail.com>"]
 edition = "2024"
 description = "MIDI structures designed for humans"
@@ -10,15 +10,16 @@ readme = "README.md"
 keywords = ["midi", "audio", "parser", "bevy"]
 categories = ["multimedia::audio", "multimedia::encoding", "multimedia"]
 license = "MIT OR Apache-2.0"
-exclude = ["assets/*"]
+exclude = ["assets/*", "test-asset"]
 
 
 [features]
 default = ["std"]
-std = ["thiserror/std"]
+std = ["thiserror/std", "tracing?/std", "bevy?/std"]
 web = ["bevy_platform/web"]
 bevy = ["dep:bevy"]
 bevy_asset = ["bevy/bevy_asset"]
+tracing = ["dep:tracing"]
 serde = ["dep:serde"]
 
 
@@ -34,6 +35,7 @@ bevy_platform = { version = "0.17.0-rc", optional = true, default-features = fal
     "alloc",
 ] }
 serde = {version = "1.0", features = ["derive"], optional = true}
+tracing = { version = "0.1.41", default-features = false, optional = true }
 
 [dev-dependencies]
 pretty_assertions = { default-features = false, features = [
diff --git a/README.md b/README.md
index d2086ce..258be02 100644
--- a/README.md
+++ b/README.md
@@ -71,135 +71,17 @@ let Ok(LiveEvent::ChannelVoice(channel_voice_msg)) = LiveEvent::from_bytes(&note
     panic!("Expected a channel voice event");
 };
 
-let VoiceEvent::NoteOn { key, velocity } = channel_voice_msg.event() else {
+let VoiceEvent::NoteOn { note, velocity } = channel_voice_msg.event() else {
     panic!("Expected a note on event");
 };
 
 assert_eq!(channel_voice_msg.channel(), Channel::Three);
-assert_eq!(key.note(), Note::C);
-assert_eq!(key.octave(), Octave::new(4));
+assert_eq!(note.key(), Key::C);
+assert_eq!(note.octave(), Octave::new(4));
 assert_eq!(velocity.byte(), 96);
 ```
 
 
-
-
-
-## Bevy Support
-
-Midix has been built with the bevy engine in mind. this feature uses `rustysynth` to play midi sounds under the hood!
-
-### Note
-When running the examples, try using `cargo run --example <EXAMPLE_NAME> --features example --release` for the best results!
-
-###  Example
-```rust, no_run
-use bevy_platform::prelude::*;
-use std::time::Duration;
-use bevy::{
-    log::{Level, LogPlugin},
-    prelude::*,
-};
-use midix::prelude::*;
-fn main() {
-    App::new()
-        .add_plugins((
-            DefaultPlugins.set(LogPlugin {
-                level: Level::INFO,
-                ..default()
-            }),
-            MidiPlugin {
-                input: None,
-                ..Default::default()
-            },
-        ))
-        .add_systems(Startup, load_sf2)
-        .add_systems(Update, scale_me)
-        .run();
-}
-/// Take a look here for some soundfonts:
-///
-/// <https://sites.google.com/site/soundfonts4u/>
-fn load_sf2(asset_server: Res<AssetServer>, mut synth: ResMut<Synth>) {
-    synth.use_soundfont(asset_server.load("soundfont.sf2"));
-}
-
-struct Scale {
-    timer: Timer,
-    current_key: Key,
-    note_on: bool,
-    forward: bool,
-    incremented_by: u8,
-    max_increment: u8,
-}
-
-impl Scale {
-    pub fn calculate_next_key(&mut self) {
-        if self.forward {
-            if self.incremented_by == self.max_increment {
-                self.forward = false;
-                self.incremented_by -= 1;
-                self.current_key -= 1;
-            } else {
-                self.incremented_by += 1;
-                self.current_key += 1;
-            }
-        } else if self.incremented_by == 0 {
-            self.forward = true;
-            self.incremented_by += 1;
-            self.current_key += 1;
-        } else {
-            self.incremented_by -= 1;
-            self.current_key -= 1;
-        }
-    }
-}
-
-impl Default for Scale {
-    fn default() -> Self {
-        let timer = Timer::new(Duration::from_millis(200), TimerMode::Repeating);
-        Scale {
-            timer,
-            current_key: Key::new(Note::C, Octave::new(2)),
-            note_on: true,
-            forward: true,
-            incremented_by: 0,
-            max_increment: 11,
-        }
-    }
-}
-
-fn scale_me(synth: Res<Synth>, time: Res<Time>, mut scale: Local<Scale>) {
-    // don't do anything until the soundfont has been loaded
-    if !synth.is_ready() {
-        return;
-    }
-    scale.timer.tick(time.delta());
-    if !scale.timer.just_finished() {
-        return;
-    }
-    if scale.note_on {
-        //play note on
-        _ = synth.push_event(ChannelVoiceMessage::new(
-            Channel::One,
-            VoiceEvent::note_on(scale.current_key, Velocity::MAX),
-        ));
-    } else {
-        //turn off the note
-        _ = synth.push_event(ChannelVoiceMessage::new(
-            Channel::One,
-            VoiceEvent::note_off(scale.current_key, Velocity::MAX),
-        ));
-        scale.calculate_next_key()
-    }
-
-    scale.note_on = !scale.note_on;
-}
-```
-
-See `/examples` for details.
-
-
 ## Semantic Versioning and Support
 `midix` will adhere to semantic versioning. This means that I've opted to use major versions, even if this crate does not consider itself feature complete (you might get a midix `v29.3.1` someday)
 
diff --git a/src/file/builder.rs b/src/file/builder.rs
index ee4000b..edfbbf9 100644
--- a/src/file/builder.rs
+++ b/src/file/builder.rs
@@ -5,7 +5,7 @@ use crate::{
     reader::{ReadError, ReaderErrorKind},
 };
 
-use super::ParsedMidiFile;
+use super::MidiFile;
 
 #[derive(Default)]
 pub enum FormatStage<'a> {
@@ -112,7 +112,7 @@ impl<'a> MidiFileBuilder<'a> {
             EOF => Err(ReaderErrorKind::ReadError(ReadError::OutOfBounds)),
         }
     }
-    pub fn build(self) -> Result<ParsedMidiFile<'a>, FileError> {
+    pub fn build(self) -> Result<MidiFile<'a>, FileError> {
         let FormatStage::Formatted(format) = self.format else {
             return Err(FileError::NoFormat);
         };
@@ -120,7 +120,7 @@ impl<'a> MidiFileBuilder<'a> {
             return Err(FileError::NoTiming);
         };
 
-        Ok(ParsedMidiFile {
+        Ok(MidiFile {
             format,
             header: Header::new(timing),
         })
diff --git a/src/file/header.rs b/src/file/header.rs
index c8a4e8d..295b025 100644
--- a/src/file/header.rs
+++ b/src/file/header.rs
@@ -3,6 +3,7 @@ use crate::prelude::*;
 #[doc = r#"
    Information about the timing of the MIDI file
 "#]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct Header {
     timing: Timing,
diff --git a/src/file/mod.rs b/src/file/mod.rs
index 759e116..a3d789e 100644
--- a/src/file/mod.rs
+++ b/src/file/mod.rs
@@ -15,8 +15,13 @@ pub use header::*;
 mod track;
 pub use track::*;
 
+mod timed_event_iter;
+pub use timed_event_iter::*;
+
 use crate::{
     ParseError,
+    events::LiveEvent,
+    message::Timed,
     prelude::FormatType,
     reader::{ReadResult, Reader, ReaderError, ReaderErrorKind},
 };
@@ -24,20 +29,21 @@ use crate::{
 #[doc = r#"
 TODO
 "#]
+#[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
-pub struct ParsedMidiFile<'a> {
+pub struct MidiFile<'a> {
     header: Header,
     format: Format<'a>,
 }
 #[cfg(feature = "bevy_asset")]
-impl bevy::asset::Asset for ParsedMidiFile<'static> {}
+impl bevy::asset::Asset for MidiFile<'static> {}
 
 #[cfg(feature = "bevy_asset")]
-impl bevy::asset::VisitAssetDependencies for ParsedMidiFile<'static> {
+impl bevy::asset::VisitAssetDependencies for MidiFile<'static> {
     fn visit_dependencies(&self, _visit: &mut impl FnMut(bevy::asset::UntypedAssetId)) {}
 }
 
-impl<'a> ParsedMidiFile<'a> {
+impl<'a> MidiFile<'a> {
     /// Parse a set of bytes into a file struct
     pub fn parse<B>(bytes: B) -> ReadResult<Self>
     where
@@ -86,4 +92,12 @@ impl<'a> ParsedMidiFile<'a> {
             Format::SingleMultiChannel(_) => FormatType::SingleMultiChannel,
         }
     }
+
+    /// Returns a set of timed events from the midi file.
+    pub fn into_events(self) -> impl Iterator<Item = Timed<LiveEvent<'a>>> {
+        match TimedEventIterator::new(self) {
+            Some(iter) => OptTimedEventIterator::Some(iter),
+            None => OptTimedEventIterator::None,
+        }
+    }
 }
diff --git a/src/file/timed_event_iter.rs b/src/file/timed_event_iter.rs
new file mode 100644
index 0000000..ed56c3a
--- /dev/null
+++ b/src/file/timed_event_iter.rs
@@ -0,0 +1,549 @@
+use crate::prelude::*;
+
+/// An iterator returned from [`ParsedMidiFile::into_events`].
+pub enum OptTimedEventIterator<'a> {
+    /// No tracks in the file
+    None,
+    /// Iterator over tracks in the file
+    Some(TimedEventIterator<'a>),
+}
+impl<'a> Iterator for OptTimedEventIterator<'a> {
+    type Item = Timed<LiveEvent<'a>>;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            OptTimedEventIterator::Some(iter) => iter.next(),
+            OptTimedEventIterator::None => None,
+        }
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            OptTimedEventIterator::None => (0, Some(0)),
+            OptTimedEventIterator::Some(iter) => iter.size_hint(),
+        }
+    }
+}
+
+/// An iterator returned from [`ParsedMidiFile::into_events`]
+pub struct TimedEventIterator<'a> {
+    len_remaining: usize,
+    header: Header,
+    tracks: alloc::vec::IntoIter<Track<'a>>,
+    cur_track: CurrentTrack<'a>,
+    file_tempo: Option<Tempo>,
+}
+impl<'a> TimedEventIterator<'a> {
+    pub(super) fn new(file: MidiFile<'a>) -> Option<Self> {
+        let header = file.header;
+
+        let (size, tracks, next, file_tempo) = match file.format {
+            Format::SequentiallyIndependent(t) => {
+                let size = t.iter().fold(0, |acc, b| acc + b.events.len());
+
+                let mut iter = t.into_iter();
+                let cur_track = iter.next()?;
+                (size, iter, cur_track, None)
+            }
+
+            Format::Simultaneous(t) => {
+                let size = t.iter().fold(0, |acc, b| acc + b.events.len());
+                let mut iter = t.into_iter();
+                let cur_track = iter.next()?;
+                let tempo = cur_track.info().tempo;
+                (size, iter, cur_track, Some(tempo))
+            }
+            Format::SingleMultiChannel(track) => {
+                let size = track.events.len();
+                let tempo = track.info().tempo;
+                (size, alloc::vec::Vec::new().into_iter(), track, Some(tempo))
+            }
+        };
+        let cur_track = CurrentTrack::new(next, file_tempo, header.timing());
+
+        Some(Self {
+            len_remaining: size,
+            header,
+            tracks,
+            cur_track,
+            file_tempo,
+        })
+    }
+}
+
+impl<'a> Iterator for TimedEventIterator<'a> {
+    type Item = Timed<LiveEvent<'a>>;
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.cur_track.next() {
+                Some(event) => {
+                    self.len_remaining -= 1;
+                    return Some(event);
+                }
+                None => {
+                    let next_track = self.tracks.next()?;
+                    let next_track =
+                        CurrentTrack::new(next_track, self.file_tempo, self.header.timing());
+                    self.cur_track = next_track;
+                }
+            }
+        }
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len_remaining, Some(self.len_remaining))
+    }
+}
+
+struct CurrentTrack<'a> {
+    micros_per_tick: f64,
+    offset_in_micros: f64,
+    event: alloc::vec::IntoIter<Ticked<LiveEvent<'a>>>,
+}
+
+impl<'a> CurrentTrack<'a> {
+    fn new(track: Track<'a>, file_tempo: Option<Tempo>, timing: &Timing) -> Self {
+        let track_tempo = file_tempo.unwrap_or(track.info().tempo);
+        let micros_per_quarter_note = track_tempo.micros_per_quarter_note();
+
+        let (micros_per_tick, offset_in_micros) = match timing {
+            Timing::Smpte(v) => {
+                //µs_per_tick = 1 000 000 / (fps × ticks_per_frame)
+                //FPS is −24/−25/−29/−30 in the high byte of division;
+                // ticks per frame is the low byte.
+
+                let frames_per_second = v.fps().as_division() as u32;
+                let ticks_per_frame = v.ticks_per_frame() as u32;
+                let ticks_per_second = frames_per_second * ticks_per_frame;
+                let micros_per_tick = 1_000_000. / ticks_per_second as f64;
+
+                //NOTE: if the file header uses smpte, that overrides any track smpte offset.
+                let offset_in_micros = track
+                    .info()
+                    .smpte_offset
+                    .as_ref()
+                    .map(|offset| {
+                        if offset.fps != v.fps() {
+                            #[cfg(feature = "tracing")]
+                            tracing::warn!(
+                                "Header's fps({}) does not align with track's fps({}). \
+                                            The file's fps will override the track's!",
+                                v.fps().as_f64(),
+                                offset.fps.as_f64()
+                            );
+                        }
+                        offset.as_micros_with_override(v.fps())
+                    })
+                    .unwrap_or(0.);
+
+                (micros_per_tick, offset_in_micros)
+            }
+            Timing::TicksPerQuarterNote(tpqn) => {
+                // µs_per_tick = tempo_meta / TPQN
+                // micro_seconds/quarternote * quarternote_per_tick (1/ticks per qn)
+                let micros_per_tick =
+                    micros_per_quarter_note as f64 / tpqn.ticks_per_quarter_note() as f64;
+
+                let offset_in_micros = track
+                    .info()
+                    .smpte_offset
+                    .as_ref()
+                    .map(|offset| offset.as_micros())
+                    .unwrap_or(0.);
+
+                (micros_per_tick, offset_in_micros)
+            }
+        };
+
+        Self {
+            micros_per_tick,
+            offset_in_micros,
+            event: track.events.into_iter(),
+        }
+    }
+}
+
+impl<'a> Iterator for CurrentTrack<'a> {
+    type Item = Timed<LiveEvent<'a>>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let event = self.event.next()?;
+        let tick = event.accumulated_ticks();
+        let micros = self.micros_per_tick * tick as f64 + self.offset_in_micros;
+        Some(Timed::new(micros as u64, event.event))
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.event.size_hint()
+    }
+}
+
+#[cfg(test)]
+fn channel_from_num(num: u8) -> Channel {
+    match num {
+        0 => Channel::One,
+        1 => Channel::Two,
+        2 => Channel::Three,
+        3 => Channel::Four,
+        4 => Channel::Five,
+        5 => Channel::Six,
+        6 => Channel::Seven,
+        7 => Channel::Eight,
+        8 => Channel::Nine,
+        9 => Channel::Ten,
+        10 => Channel::Eleven,
+        11 => Channel::Twelve,
+        12 => Channel::Thirteen,
+        13 => Channel::Fourteen,
+        14 => Channel::Fifteen,
+        15 => Channel::Sixteen,
+        _ => Channel::One,
+    }
+}
+
+#[cfg(test)]
+fn note_from_midi_number(num: u8) -> Note {
+    Note::from_databyte(num).unwrap()
+}
+
+#[cfg(test)]
+fn note_on_event(delta_ticks: u32, note: u8, velocity: u8, channel: u8) -> TrackEvent<'static> {
+    TrackEvent::new(
+        delta_ticks,
+        TrackMessage::ChannelVoice(ChannelVoiceMessage::new(
+            channel_from_num(channel),
+            VoiceEvent::NoteOn {
+                note: note_from_midi_number(note),
+                velocity: Velocity::new(velocity).unwrap(),
+            },
+        )),
+    )
+}
+
+#[cfg(test)]
+fn note_off_event(delta_ticks: u32, note: u8, channel: u8) -> TrackEvent<'static> {
+    TrackEvent::new(
+        delta_ticks,
+        TrackMessage::ChannelVoice(ChannelVoiceMessage::new(
+            channel_from_num(channel),
+            VoiceEvent::NoteOff {
+                note: note_from_midi_number(note),
+                velocity: Velocity::new(0).unwrap(),
+            },
+        )),
+    )
+}
+
+#[cfg(test)]
+fn tempo_event(delta_ticks: u32, micros_per_quarter: u32) -> TrackEvent<'static> {
+    let bytes = [
+        (micros_per_quarter >> 16) as u8,
+        (micros_per_quarter >> 8) as u8,
+        micros_per_quarter as u8,
+    ];
+    TrackEvent::new(
+        delta_ticks,
+        TrackMessage::Meta(MetaMessage::Tempo(Tempo::new_from_bytes(&bytes))),
+    )
+}
+
+#[test]
+fn test_empty_file_returns_none_iterator() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+    let format = Format::Simultaneous(alloc::vec![]);
+    let file = MidiFile { header, format };
+
+    let mut iter = file.into_events();
+    assert_eq!(iter.next(), None);
+}
+
+#[test]
+fn test_single_track_single_event() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+    let events = alloc::vec![tempo_event(0, 500_000), note_on_event(0, 60, 100, 0),];
+    let track = Track::new(events);
+    let format = Format::SingleMultiChannel(track);
+    let file = MidiFile { header, format };
+
+    let mut iter = file.into_events();
+    let event = iter.next().unwrap();
+
+    assert_eq!(event.timestamp, 0);
+    assert!(matches!(
+        event.event,
+        LiveEvent::ChannelVoice(ChannelVoiceMessage {
+            event: VoiceEvent::NoteOn { .. },
+            ..
+        })
+    ));
+
+    assert_eq!(iter.next(), None);
+}
+
+#[test]
+fn test_single_track_multiple_events_with_delta_time() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+    let events = alloc::vec![
+        tempo_event(0, 500_000),
+        note_on_event(0, 60, 100, 0),
+        note_off_event(480, 60, 0),
+        note_on_event(240, 62, 80, 0),
+    ];
+    let track = Track::new(events);
+    let format = Format::SingleMultiChannel(track);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 3);
+
+    assert_eq!(events[0].timestamp, 0);
+
+    assert_eq!(events[1].timestamp, 500_000);
+
+    assert_eq!(events[2].timestamp, 750_000);
+}
+
+#[test]
+fn test_simultaneous_format_multiple_tracks() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+
+    let track1_events = alloc::vec![
+        tempo_event(0, 500_000),
+        note_on_event(0, 60, 100, 0),
+        note_off_event(480, 60, 0),
+    ];
+    let track1 = Track::new(track1_events);
+
+    let track2_events = alloc::vec![note_on_event(240, 36, 80, 1), note_off_event(480, 36, 1),];
+    let track2 = Track::new(track2_events);
+
+    let format = Format::Simultaneous(alloc::vec![track1, track2]);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 4);
+
+    assert_eq!(events[0].timestamp, 0);
+    assert_eq!(events[1].timestamp, 500_000);
+    assert_eq!(events[2].timestamp, 250_000);
+    assert_eq!(events[3].timestamp, 750_000);
+}
+
+#[test]
+fn test_sequentially_independent_format() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x03, 0xC0],
+    }));
+
+    let track1_events = alloc::vec![
+        tempo_event(0, 1_000_000),
+        note_on_event(0, 60, 100, 0),
+        note_off_event(960, 60, 0),
+    ];
+    let track1 = Track::new(track1_events);
+
+    let track2_events = alloc::vec![
+        tempo_event(0, 500_000),
+        note_on_event(0, 48, 90, 1),
+        note_off_event(480, 48, 1),
+    ];
+    let track2 = Track::new(track2_events);
+
+    let format = Format::SequentiallyIndependent(alloc::vec![track1, track2]);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 4);
+
+    assert_eq!(events[0].timestamp, 0);
+    assert_eq!(events[1].timestamp, 1_000_000);
+    assert_eq!(events[2].timestamp, 0);
+    assert_eq!(events[3].timestamp, 250_000);
+}
+
+#[test]
+fn test_smpte_timing() {
+    let smpte = SmpteHeader {
+        fps: SmpteFps::Thirty,
+        ticks_per_frame: DataByte::new(40).unwrap(),
+    };
+    let header = Header::new(Timing::Smpte(smpte));
+
+    let events = alloc::vec![
+        note_on_event(0, 60, 100, 0),
+        note_off_event(1200, 60, 0),
+        note_on_event(600, 62, 80, 0),
+    ];
+    let track = Track::new(events);
+    let format = Format::SingleMultiChannel(track);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 3);
+
+    assert_eq!(events[0].timestamp, 0);
+    assert_eq!(events[1].timestamp, 1_000_000);
+    assert_eq!(events[2].timestamp, 1_500_000);
+}
+
+#[test]
+fn test_mixed_event_types() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+
+    let events = alloc::vec![
+        tempo_event(0, 500_000),
+        note_on_event(0, 60, 100, 0),
+        TrackEvent::new(
+            240,
+            TrackMessage::ChannelVoice(ChannelVoiceMessage::new(
+                Channel::One,
+                VoiceEvent::ControlChange(Controller::other(
+                    DataByte::new(64).unwrap(),
+                    DataByte::new(127).unwrap(),
+                )),
+            )),
+        ),
+        TrackEvent::new(
+            240,
+            TrackMessage::ChannelVoice(ChannelVoiceMessage::new(
+                Channel::One,
+                VoiceEvent::ProgramChange {
+                    program: Program::new(1).unwrap(),
+                },
+            )),
+        ),
+        note_off_event(480, 60, 0),
+    ];
+
+    let track = Track::new(events);
+    let format = Format::SingleMultiChannel(track);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 4);
+
+    assert!(matches!(
+        &events[0].event,
+        LiveEvent::ChannelVoice(ChannelVoiceMessage {
+            event: VoiceEvent::NoteOn { .. },
+            ..
+        })
+    ));
+    assert!(matches!(
+        &events[1].event,
+        LiveEvent::ChannelVoice(ChannelVoiceMessage {
+            event: VoiceEvent::ControlChange(_),
+            ..
+        })
+    ));
+    assert!(matches!(
+        &events[2].event,
+        LiveEvent::ChannelVoice(ChannelVoiceMessage {
+            event: VoiceEvent::ProgramChange { .. },
+            ..
+        })
+    ));
+    assert!(matches!(
+        &events[3].event,
+        LiveEvent::ChannelVoice(ChannelVoiceMessage {
+            event: VoiceEvent::NoteOff { .. },
+            ..
+        })
+    ));
+
+    assert_eq!(events[0].timestamp, 0);
+    assert_eq!(events[1].timestamp, 250_000);
+    assert_eq!(events[2].timestamp, 500_000);
+    assert_eq!(events[3].timestamp, 1_000_000);
+}
+
+#[test]
+fn test_system_exclusive_events() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+
+    let sysex_data = alloc::vec![0xF0, 0x43, 0x12, 0x00, 0xF7];
+    let events = alloc::vec![
+        tempo_event(0, 500_000),
+        note_on_event(0, 60, 100, 0),
+        TrackEvent::new(
+            480,
+            TrackMessage::SystemExclusive(SystemExclusiveMessage::new(sysex_data.as_slice())),
+        ),
+        note_off_event(480, 60, 0),
+    ];
+
+    let track = Track::new(events);
+    let format = Format::SingleMultiChannel(track);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 3);
+
+    assert!(matches!(
+        &events[1].event,
+        LiveEvent::SysCommon(SystemCommonMessage::SystemExclusive(_))
+    ));
+    assert_eq!(events[1].timestamp, 500_000);
+}
+
+#[test]
+fn test_file_tempo_override_in_simultaneous_format() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+
+    let track1_events = alloc::vec![tempo_event(0, 600_000), note_on_event(0, 60, 100, 0),];
+    let track1 = Track::new(track1_events);
+
+    let track2_events = alloc::vec![tempo_event(0, 400_000), note_on_event(480, 48, 90, 1),];
+    let track2 = Track::new(track2_events);
+
+    let format = Format::Simultaneous(alloc::vec![track1, track2]);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+    assert_eq!(events.len(), 2);
+
+    assert_eq!(events[0].timestamp, 0);
+    assert_eq!(events[1].timestamp, 600_000);
+}
+
+#[test]
+fn test_empty_track_handling() {
+    let header = Header::new(Timing::TicksPerQuarterNote(TicksPerQuarterNote {
+        inner: [0x01, 0xE0],
+    }));
+
+    let track1_events = alloc::vec![
+        tempo_event(0, 500_000),
+        note_on_event(0, 60, 100, 0),
+        note_off_event(480, 60, 0),
+    ];
+    let track1 = Track::new(track1_events);
+
+    let track2 = Track::new(alloc::vec![]);
+
+    let track3_events = alloc::vec![note_on_event(0, 48, 90, 2)];
+    let track3 = Track::new(track3_events);
+
+    let format = Format::Simultaneous(alloc::vec![track1, track2, track3]);
+    let file = MidiFile { header, format };
+
+    let events: alloc::vec::Vec<_> = file.into_events().collect();
+
+    assert_eq!(events.len(), 3);
+
+    if let LiveEvent::ChannelVoice(msg) = &events[0].event {
+        assert_eq!(msg.channel(), Channel::One);
+    }
+    if let LiveEvent::ChannelVoice(msg) = &events[2].event {
+        assert_eq!(msg.channel(), Channel::Three);
+    }
+}
diff --git a/src/file/track.rs b/src/file/track.rs
index 5e87b18..4105181 100644
--- a/src/file/track.rs
+++ b/src/file/track.rs
@@ -14,7 +14,7 @@ A set of track events
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct Track<'a> {
     info: TrackInfo<'a>,
-    events: Vec<Ticked<LiveEvent<'a>>>,
+    pub(crate) events: Vec<Ticked<LiveEvent<'a>>>,
 }
 
 impl<'a> Track<'a> {
diff --git a/src/file_repr/chunk/header.rs b/src/file_repr/chunk/header.rs
index e69eb22..dbccc0d 100644
--- a/src/file_repr/chunk/header.rs
+++ b/src/file_repr/chunk/header.rs
@@ -126,7 +126,7 @@ pub enum Timing {
 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct TicksPerQuarterNote {
-    inner: [u8; 2],
+    pub(crate) inner: [u8; 2],
 }
 impl TicksPerQuarterNote {
     /// Returns the ticks per quarter note for the file.
@@ -140,8 +140,8 @@ impl TicksPerQuarterNote {
 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct SmpteHeader {
-    fps: SmpteFps,
-    ticks_per_frame: DataByte,
+    pub(crate) fps: SmpteFps,
+    pub(crate) ticks_per_frame: DataByte,
 }
 
 impl SmpteHeader {
diff --git a/src/lib.rs b/src/lib.rs
index be2d5ae..fb503ce 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -63,6 +63,7 @@ pub mod prelude {
         file::*,
         file_repr::{chunk::*, meta::*, track::*, *},
         message::{MidiMessage, channel::*, system::*, time::*},
+        micros::*,
         note,
     };
 
@@ -72,7 +73,4 @@ pub mod prelude {
     pub(crate) use crate::reader::inv_data;
 
     pub use core::fmt::Display;
-
-    //#[cfg(feature = "bevy")]
-    //pub use crate::bevy::prelude::*;
 }
diff --git a/src/message/time.rs b/src/message/time.rs
index 063cd32..7fca113 100644
--- a/src/message/time.rs
+++ b/src/message/time.rs
@@ -10,7 +10,7 @@ A wrapper around some type with an associated accumulated tick
 pub struct Ticked<T> {
     /// In ticks
     accumulated_ticks: u32,
-    event: T,
+    pub(crate) event: T,
 }
 
 impl<T> Ticked<T> {
diff --git a/src/micros.rs b/src/micros.rs
index aea04e0..20413e2 100644
--- a/src/micros.rs
+++ b/src/micros.rs
@@ -1,5 +1,17 @@
 use core::ops::{Add, AddAssign, Mul, Sub, SubAssign};
 
+/// An extension trait to convert a `Duration` to `UMicros`
+pub trait DurationExt {
+    /// Convert a `Duration` to `UMicros`
+    fn to_micros(&self) -> UMicros;
+}
+
+impl DurationExt for std::time::Duration {
+    fn to_micros(&self) -> UMicros {
+        UMicros(self.as_micros() as u64)
+    }
+}
+
 /// Signed Microseconds
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy, Default)]
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
diff --git a/src/note.rs b/src/note.rs
index d9c03c6..0380629 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -16,12 +16,12 @@ Each value corresponds to some [`Note`] and [`Octave`].
 ```rust
 # use midix::prelude::*;
 
-let key_byte = 63;
+let note_byte = 63;
 
-let key = Key::from_databyte(key_byte).unwrap(); // 63 is between 0-127
+let note = Note::from_databyte(note_byte).unwrap(); // 63 is between 0-127
 
-assert_eq!(key.note(), Note::DSharp);
-assert_eq!(key.octave(), Octave::new(4))
+assert_eq!(note.key(), Key::DSharp);
+assert_eq!(note.octave(), Octave::new(4))
 ```
 "#]
 #[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug, Hash)]
@@ -118,9 +118,9 @@ impl Note {
 #[macro_export]
 macro_rules! note {
     ($key:ident, $oct:literal) => {
-        ::midix::prelude::Note::new(
-            ::midix::prelude::Key::$key,
-            ::midix::prelude::Octave::new($oct),
+        $crate::prelude::Note::new(
+            $crate::prelude::Key::$key,
+            $crate::prelude::Octave::new($oct),
         )
     };
 }
@@ -234,14 +234,14 @@ Identifies some note for a [`Key`]
 ```rust
 # use midix::prelude::*;
 
-let note = Note::FSharp;
+let key = Key::FSharp;
 
 
-let key = note.with_octave(Octave::new(4));
+let note = key.with_octave(Octave::new(4));
 
 
-assert_eq!(key.octave().value(), 4);
-assert_eq!(key.note(), Note::FSharp);
+assert_eq!(note.octave().value(), 4);
+assert_eq!(note.key(), Key::FSharp);
 ```
 "#]
 pub enum Key {
@@ -299,10 +299,10 @@ impl Key {
     /// # Example
     /// ```rust
     /// # use midix::prelude::*;
-    /// let note = Note::C;
-    /// assert!(!note.is_sharp());
-    /// let note = Note::FSharp;
-    /// assert!(note.is_sharp());
+    /// let key = Key::C;
+    /// assert!(!key.is_sharp());
+    /// let key = Key::FSharp;
+    /// assert!(key.is_sharp());
     /// ```
     #[inline]
     pub const fn is_sharp(&self) -> bool {
@@ -315,10 +315,10 @@ impl Key {
     /// # Example
     /// ```rust
     /// # use midix::prelude::*;
-    /// let note = Note::A;
-    /// assert!(!note.is_flat());
-    /// let note = Note::CSharp;
-    /// assert!(note.is_flat());
+    /// let key = Key::A;
+    /// assert!(!key.is_flat());
+    /// let key = Key::CSharp;
+    /// assert!(key.is_flat());
     /// ```
     #[inline]
     pub const fn is_flat(&self) -> bool {
@@ -402,11 +402,11 @@ let octave = Octave::new(12); // clamps to 9
 
 assert_eq!(octave.value(), 9);
 
-let key = octave.with_note(Note::C);
+let note = octave.with_key(Key::C);
 
 
-assert_eq!(key.octave().value(), 9);
-assert_eq!(key.note(), Note::C);
+assert_eq!(note.octave().value(), 9);
+assert_eq!(note.key(), Key::C);
 ```
 "#]
 #[derive(PartialEq, Debug, Clone, Copy)]
@@ -436,7 +436,7 @@ impl Octave {
     }
 
     /// Create a [`Key`] given this octave and a provided [`Note`]
-    pub fn with_note(self, note: Key) -> Note {
+    pub fn with_key(self, note: Key) -> Note {
         Note::new(note, self)
     }
 }
diff --git a/tests/simple_midi/parsed.rs b/tests/simple_midi/parsed.rs
index 21b90bd..911bfee 100644
--- a/tests/simple_midi/parsed.rs
+++ b/tests/simple_midi/parsed.rs
@@ -2,7 +2,7 @@ use midix::{Dynamic, Key, Octave, events::LiveEvent, prelude::*};
 
 #[test]
 fn test_parse() {
-    let parsed = ParsedMidiFile::parse(include_bytes!("./simple.mid")).unwrap();
+    let parsed = MidiFile::parse(include_bytes!("./simple.mid")).unwrap();
 
     assert_eq!(parsed.tracks().len(), 1);