From 9649b10a5714832ce2d74ab30af29efaca213870 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Fri, 26 Sep 2025 05:33:55 -0400
Subject: [PATCH 01/13] fix: add micros to prelude

---
 Cargo.toml | 2 +-
 src/lib.rs | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 54fd5b7..4f40d4b 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.3"
 authors = ["dsgallups <dsgallups@protonmail.com>"]
 edition = "2024"
 description = "MIDI structures designed for humans"
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::*;
 }

From 5d08487c5a3a2b00ccff2d0ad72abc8388c0a6f6 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Fri, 26 Sep 2025 05:44:17 -0400
Subject: [PATCH 02/13] fix: update docs

---
 README.md   | 124 ++--------------------------------------------------
 src/note.rs |  46 +++++++++----------
 2 files changed, 26 insertions(+), 144 deletions(-)

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/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)
     }
 }

From 5efd3138569b03f50d92672f16820087642a001e Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Fri, 26 Sep 2025 05:44:40 -0400
Subject: [PATCH 03/13] publish alpha.4

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4f40d4b..6550723 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "midix"
-version = "4.0.0-alpha.3"
+version = "4.0.0-alpha.4"
 authors = ["dsgallups <dsgallups@protonmail.com>"]
 edition = "2024"
 description = "MIDI structures designed for humans"

From 5ecd35416ae98b3be034be8c3265b7eed26a2dbe Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sat, 27 Sep 2025 09:49:54 -0400
Subject: [PATCH 04/13] add duration extension trait

---
 src/micros.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

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))]

From 548b687cf41548cdf42e7f13f82be1827e2ee26b Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:05:16 -0400
Subject: [PATCH 05/13] feat: new timed event iter

- Added tracing feature
- Added the ability to turn a parsed midi file into an iterator of live
  events
---
 Cargo.toml                   |   4 +-
 src/file/mod.rs              |  17 ++++
 src/file/timed_event_iter.rs | 173 +++++++++++++++++++++++++++++++++++
 src/file/track.rs            |   2 +-
 src/message/time.rs          |   2 +-
 5 files changed, 195 insertions(+), 3 deletions(-)
 create mode 100644 src/file/timed_event_iter.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6550723..8c4e11b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,10 +15,11 @@ exclude = ["assets/*"]
 
 [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/src/file/mod.rs b/src/file/mod.rs
index 759e116..3a3bdda 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},
 };
@@ -86,4 +91,16 @@ 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..c543be0
--- /dev/null
+++ b/src/file/timed_event_iter.rs
@@ -0,0 +1,173 @@
+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: ParsedMidiFile<'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;
+                //todo
+                (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> {
+        match self.cur_track.next() {
+            Some(event) => {
+                self.len_remaining -= 1;
+                Some(event)
+            }
+            None => {
+                let next_track = self.tracks.next()?;
+                let mut next_track =
+                    CurrentTrack::new(next_track, self.file_tempo, self.header.timing());
+                let next_ev = next_track.next()?;
+                self.len_remaining -= 1;
+                self.cur_track = next_track;
+                Some(next_ev)
+            }
+        }
+    }
+}
+
+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()
+    }
+}
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/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> {

From dedd3586fcd6ad02c1a2b771cf8762321a702de9 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:19:33 -0400
Subject: [PATCH 06/13] tests

---
 src/file/timed_event_iter.rs  | 376 +++++++++++++++++++++++++++++++++-
 src/file_repr/chunk/header.rs |   6 +-
 2 files changed, 378 insertions(+), 4 deletions(-)

diff --git a/src/file/timed_event_iter.rs b/src/file/timed_event_iter.rs
index c543be0..0ac760b 100644
--- a/src/file/timed_event_iter.rs
+++ b/src/file/timed_event_iter.rs
@@ -54,7 +54,6 @@ impl<'a> TimedEventIterator<'a> {
             Format::SingleMultiChannel(track) => {
                 let size = track.events.len();
                 let tempo = track.info().tempo;
-                //todo
                 (size, alloc::vec::Vec::new().into_iter(), track, Some(tempo))
             }
         };
@@ -171,3 +170,378 @@ impl<'a> Iterator for CurrentTrack<'a> {
         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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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 = ParsedMidiFile { 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_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 {

From 23a11847bc8fb68080255af9e5d1d7a2facaa6b4 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:29:52 -0400
Subject: [PATCH 07/13] fix: bug

---
 src/file/timed_event_iter.rs | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/file/timed_event_iter.rs b/src/file/timed_event_iter.rs
index 0ac760b..ad7a417 100644
--- a/src/file/timed_event_iter.rs
+++ b/src/file/timed_event_iter.rs
@@ -72,19 +72,18 @@ impl<'a> TimedEventIterator<'a> {
 impl<'a> Iterator for TimedEventIterator<'a> {
     type Item = Timed<LiveEvent<'a>>;
     fn next(&mut self) -> Option<Self::Item> {
-        match self.cur_track.next() {
-            Some(event) => {
-                self.len_remaining -= 1;
-                Some(event)
-            }
-            None => {
-                let next_track = self.tracks.next()?;
-                let mut next_track =
-                    CurrentTrack::new(next_track, self.file_tempo, self.header.timing());
-                let next_ev = next_track.next()?;
-                self.len_remaining -= 1;
-                self.cur_track = next_track;
-                Some(next_ev)
+        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;
+                }
             }
         }
     }

From 8ebaa72fc6243cb71d8c97719d422221edc8178c Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:30:49 -0400
Subject: [PATCH 08/13] exclude test-asset

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 8c4e11b..68e4c54 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,7 @@ 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]

From b42128b66a7471da68fc60f331d3ceacddec52ed Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:33:09 -0400
Subject: [PATCH 09/13] fix: add size hint to iterator

---
 src/file/timed_event_iter.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/file/timed_event_iter.rs b/src/file/timed_event_iter.rs
index ad7a417..c990427 100644
--- a/src/file/timed_event_iter.rs
+++ b/src/file/timed_event_iter.rs
@@ -87,6 +87,9 @@ impl<'a> Iterator for TimedEventIterator<'a> {
             }
         }
     }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len_remaining, Some(self.len_remaining))
+    }
 }
 
 struct CurrentTrack<'a> {

From e660de60153a5e96347cb5caca53d069a59b0f20 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:35:31 -0400
Subject: [PATCH 10/13] fix: derives on parsed file

---
 src/file/header.rs | 1 +
 src/file/mod.rs    | 5 +----
 2 files changed, 2 insertions(+), 4 deletions(-)

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 3a3bdda..3359382 100644
--- a/src/file/mod.rs
+++ b/src/file/mod.rs
@@ -29,6 +29,7 @@ use crate::{
 #[doc = r#"
 TODO
 "#]
+#[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct ParsedMidiFile<'a> {
     header: Header,
@@ -100,7 +101,3 @@ impl<'a> ParsedMidiFile<'a> {
         }
     }
 }
-/*
-
-
-*/

From 382954b787eef75d130b2c188cc4d5d768712b67 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 10:35:51 -0400
Subject: [PATCH 11/13] rename parsemidifile

---
 src/file/builder.rs          |  6 +++---
 src/file/mod.rs              |  8 ++++----
 src/file/timed_event_iter.rs | 22 +++++++++++-----------
 tests/simple_midi/parsed.rs  |  2 +-
 4 files changed, 19 insertions(+), 19 deletions(-)

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/mod.rs b/src/file/mod.rs
index 3359382..a3d789e 100644
--- a/src/file/mod.rs
+++ b/src/file/mod.rs
@@ -31,19 +31,19 @@ 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
diff --git a/src/file/timed_event_iter.rs b/src/file/timed_event_iter.rs
index c990427..ed56c3a 100644
--- a/src/file/timed_event_iter.rs
+++ b/src/file/timed_event_iter.rs
@@ -32,7 +32,7 @@ pub struct TimedEventIterator<'a> {
     file_tempo: Option<Tempo>,
 }
 impl<'a> TimedEventIterator<'a> {
-    pub(super) fn new(file: ParsedMidiFile<'a>) -> Option<Self> {
+    pub(super) fn new(file: MidiFile<'a>) -> Option<Self> {
         let header = file.header;
 
         let (size, tracks, next, file_tempo) = match file.format {
@@ -248,7 +248,7 @@ fn test_empty_file_returns_none_iterator() {
         inner: [0x01, 0xE0],
     }));
     let format = Format::Simultaneous(alloc::vec![]);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let mut iter = file.into_events();
     assert_eq!(iter.next(), None);
@@ -262,7 +262,7 @@ fn test_single_track_single_event() {
     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 = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let mut iter = file.into_events();
     let event = iter.next().unwrap();
@@ -292,7 +292,7 @@ fn test_single_track_multiple_events_with_delta_time() {
     ];
     let track = Track::new(events);
     let format = Format::SingleMultiChannel(track);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 3);
@@ -321,7 +321,7 @@ fn test_simultaneous_format_multiple_tracks() {
     let track2 = Track::new(track2_events);
 
     let format = Format::Simultaneous(alloc::vec![track1, track2]);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 4);
@@ -353,7 +353,7 @@ fn test_sequentially_independent_format() {
     let track2 = Track::new(track2_events);
 
     let format = Format::SequentiallyIndependent(alloc::vec![track1, track2]);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 4);
@@ -379,7 +379,7 @@ fn test_smpte_timing() {
     ];
     let track = Track::new(events);
     let format = Format::SingleMultiChannel(track);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 3);
@@ -422,7 +422,7 @@ fn test_mixed_event_types() {
 
     let track = Track::new(events);
     let format = Format::SingleMultiChannel(track);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 4);
@@ -481,7 +481,7 @@ fn test_system_exclusive_events() {
 
     let track = Track::new(events);
     let format = Format::SingleMultiChannel(track);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 3);
@@ -506,7 +506,7 @@ fn test_file_tempo_override_in_simultaneous_format() {
     let track2 = Track::new(track2_events);
 
     let format = Format::Simultaneous(alloc::vec![track1, track2]);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
     assert_eq!(events.len(), 2);
@@ -534,7 +534,7 @@ fn test_empty_track_handling() {
     let track3 = Track::new(track3_events);
 
     let format = Format::Simultaneous(alloc::vec![track1, track2, track3]);
-    let file = ParsedMidiFile { header, format };
+    let file = MidiFile { header, format };
 
     let events: alloc::vec::Vec<_> = file.into_events().collect();
 
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);
 

From 260be29e7df3745d71a8dcc77f047addfb1d4a43 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 12:12:34 -0400
Subject: [PATCH 12/13] bump version

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 68e4c54..c161609 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "midix"
-version = "4.0.0-alpha.4"
+version = "4.0.0-alpha.5"
 authors = ["dsgallups <dsgallups@protonmail.com>"]
 edition = "2024"
 description = "MIDI structures designed for humans"

From 6081b1dd8537a060d73afda240fd9042dcdba1d0 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Sun, 28 Sep 2025 12:16:35 -0400
Subject: [PATCH 13/13] add changelog

---
 CHANGELOG.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

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!