From 37068784cbb2fcd265c4c812a0104ffc88c78965 Mon Sep 17 00:00:00 2001
From: stop screaming
 <AAAAAAAAAAAAAAAAAAAA@AAAAAAAAAAAAAAAAAAAAAAAAA.AAAAAAAAAAAAAAA>
Date: Sat, 21 Feb 2026 00:03:04 +0200
Subject: [PATCH] refactor(engine): flatten

- add `just stats`
- add basic doctests
---
 Justfile                         |  40 ++++
 app/tek_impls.rs                 |   2 +-
 app/tek_struct.rs                |  21 ++
 app/tek_test.rs                  |  72 ------
 device/editor.rs                 | 239 ++++++++++----------
 device/scene.rs                  |  26 ++-
 device/sequencer.rs              |   4 +-
 device/track.rs                  |  32 +--
 device/vst3.rs                   |   1 +
 engine/engine.rs                 | 149 ++++++++-----
 engine/engine_deps.rs            |  11 -
 engine/engine_impls.rs           | 363 +++++++++++++++++++++++++++++++
 engine/engine_structs.rs         | 156 +++++++++++++
 engine/engine_traits.rs          | 129 +++++++++++
 engine/jack.rs                   | 232 --------------------
 engine/jack_impls.rs             | 131 +++++++++++
 engine/jack_structs.rs           |  53 +++++
 engine/jack_traits.rs            | 104 +++++++++
 engine/jack_types.rs             |  27 +++
 engine/midi.rs                   |  35 ---
 engine/note.rs                   |   3 -
 engine/note/note_pitch.rs        |  23 --
 engine/note/note_point.rs        |  79 -------
 engine/note/note_range.rs        |  98 ---------
 engine/time.rs                   |   9 -
 engine/time/time_moment.rs       |  70 ------
 engine/time/time_note.rs         |  35 ---
 engine/time/time_perf.rs         |  23 --
 engine/time/time_pulse.rs        |  71 ------
 engine/time/time_sample_count.rs |   5 -
 engine/time/time_sample_rate.rs  |  23 --
 engine/time/time_timebase.rs     | 118 ----------
 engine/time/time_unit.rs         |  59 -----
 engine/time/time_usec.rs         |  15 --
 34 files changed, 1285 insertions(+), 1173 deletions(-)
 delete mode 100644 engine/engine_deps.rs
 create mode 100644 engine/engine_impls.rs
 create mode 100644 engine/engine_structs.rs
 create mode 100644 engine/engine_traits.rs
 delete mode 100644 engine/jack.rs
 create mode 100644 engine/jack_impls.rs
 create mode 100644 engine/jack_structs.rs
 create mode 100644 engine/jack_traits.rs
 create mode 100644 engine/jack_types.rs
 delete mode 100644 engine/midi.rs
 delete mode 100644 engine/note.rs
 delete mode 100644 engine/note/note_pitch.rs
 delete mode 100644 engine/note/note_point.rs
 delete mode 100644 engine/note/note_range.rs
 delete mode 100644 engine/time.rs
 delete mode 100644 engine/time/time_moment.rs
 delete mode 100644 engine/time/time_note.rs
 delete mode 100644 engine/time/time_perf.rs
 delete mode 100644 engine/time/time_pulse.rs
 delete mode 100644 engine/time/time_sample_count.rs
 delete mode 100644 engine/time/time_sample_rate.rs
 delete mode 100644 engine/time/time_timebase.rs
 delete mode 100644 engine/time/time_unit.rs
 delete mode 100644 engine/time/time_usec.rs

diff --git a/Justfile b/Justfile
index 94551690..eac680df 100644
--- a/Justfile
+++ b/Justfile
@@ -115,3 +115,43 @@ sampler:
   {{debug}} sampler
 plugin:
   {{debug}} plugin
+
+
+@stats:
+  echo
+
+  for file in $(ls app/*.rs); do echo $file; cloc $file | grep Rust; done
+  echo
+  cloc app | grep Rust
+  rg 'pub struct ' app/ | cat
+  rg 'pub struct ' app/ | wc -l
+  rg 'pub trait ' app/ | cat
+  rg 'pub trait ' app/ | wc -l
+  echo
+  rg 'TODO' app/ | cat
+  rg 'TODO' app/ | wc -l
+  echo
+
+  for file in $(ls engine/*.rs); do echo $file; cloc $file | grep Rust; done
+  echo
+  cloc engine | grep Rust
+  rg 'pub struct ' engine/ | cat
+  rg 'pub struct ' engine/ | wc -l
+  rg 'pub trait ' engine/ | cat
+  rg 'pub trait ' engine/ | wc -l
+  echo
+  rg 'TODO' engine/ | cat
+  rg 'TODO' engine/ | wc -l
+  echo
+
+  for file in $(ls device/*.rs); do echo $file; cloc $file | grep Rust; done
+  echo
+  cloc device | grep Rust
+  rg 'pub struct ' device/ | cat
+  rg 'pub struct ' device/ | wc -l
+  rg 'pub trait ' device/ | cat
+  rg 'pub trait ' device/ | wc -l
+  echo
+  rg 'TODO' device/ | cat
+  rg 'TODO' device/ | wc -l
+  echo
diff --git a/app/tek_impls.rs b/app/tek_impls.rs
index 035a0923..dd542cd8 100644
--- a/app/tek_impls.rs
+++ b/app/tek_impls.rs
@@ -510,7 +510,7 @@ impl App {
             && slot.is_none()
             && let Some(track) = self.project.tracks.get_mut(track)
             {
-                let (index, mut clip) = self.pool.add_new_clip();
+                let (_index, mut clip) = self.pool.add_new_clip();
                 // autocolor: new clip colors from scene and track color
                 let color = track.color.base.mix(scene.color.base, 0.5);
                 clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into();
diff --git a/app/tek_struct.rs b/app/tek_struct.rs
index 98679693..29f475e1 100644
--- a/app/tek_struct.rs
+++ b/app/tek_struct.rs
@@ -5,7 +5,25 @@ use builder_pattern::Builder;
 /// Total state
 ///
 /// ```
+/// use tek::tek_device::TracksView;
 /// let app: tek::App = Default::default();
+/// let _ = app.scene_add(None, None)?;
+/// let _ = app.update_clock();
+/// app.project.editor = Some(Default::default());
+/// //let _: Vec<_> = app.project.inputs_with_sizes().collect();
+/// //let _: Vec<_> = app.project.outputs_with_sizes().collect();
+/// let _: Vec<_> = app.project.tracks_with_sizes().collect();
+/// //let _: Vec<_> = app.project.scenes_with_sizes(true, 10, 10).collect();
+/// //let _: Vec<_> = app.scenes_with_colors(true, 10).collect();
+/// //let _: Vec<_> = app.scenes_with_track_colors(true, 10, 10).collect();
+/// let _ = app.project.w();
+/// //let _ = app.project.w_sidebar();
+/// //let _ = app.project.w_tracks_area();
+/// let _ = app.project.h();
+/// //let _ = app.project.h_tracks_area();
+/// //let _ = app.project.h_inputs();
+/// //let _ = app.project.h_outputs();
+/// let _ = app.project.h_scenes();
 /// ```
 #[derive(Default, Debug)] pub struct App {
     /// Base color.
@@ -120,6 +138,9 @@ use builder_pattern::Builder;
 ///
 /// ```
 /// let cli: tek::Cli = Default::default();
+///
+/// use clap::CommandFactory;
+/// tek::Cli::command().debug_assert();
 /// ```
 #[derive(Debug, Parser, Default)]
 #[command(name = "tek", version, about = Some(HEADER), long_about = Some(HEADER))]
diff --git a/app/tek_test.rs b/app/tek_test.rs
index 16c4a66d..4bd2b882 100644
--- a/app/tek_test.rs
+++ b/app/tek_test.rs
@@ -25,31 +25,6 @@ use crate::*;
 
 }
 
-#[cfg(test)] #[test] fn test_cli () {
-    use clap::CommandFactory;
-    Cli::command().debug_assert();
-    //let jack = Jack::default();
-}
-
-#[cfg(test)] #[test] fn test_app () -> Usually<()> {
-    let mut app = App::default();
-    let _ = app.scene_add(None, None)?;
-    let _ = app.update_clock();
-    Ok(())
-}
-
-#[cfg(test)] #[test] fn test_track () -> Usually<()> {
-    let track = Track::default();
-    Ok(())
-}
-
-#[cfg(test)] #[test] fn test_scene () -> Usually<()> {
-    let scene = Scene::default();
-    let _ = scene.pulses();
-    let _ = scene.is_playing(&[]);
-    Ok(())
-}
-
 #[cfg(test)] #[test] fn test_view_layout () {
     let _ = button_play_pause(true);
     let _ = button_2("", "", true);
@@ -83,52 +58,5 @@ use crate::*;
     }
 }
 
-#[cfg(test)] #[test] fn test_view_iter () {
-    let mut app = App::default();
-    app.project.editor = Some(Default::default());
-    //let _: Vec<_> = app.project.inputs_with_sizes().collect();
-    //let _: Vec<_> = app.project.outputs_with_sizes().collect();
-    let _: Vec<_> = app.project.tracks_with_sizes().collect();
-    //let _: Vec<_> = app.project.scenes_with_sizes(true, 10, 10).collect();
-    //let _: Vec<_> = app.scenes_with_colors(true, 10).collect();
-    //let _: Vec<_> = app.scenes_with_track_colors(true, 10, 10).collect();
-}
-
-#[cfg(test)] #[test] fn test_view_sizes () {
-    let app = App::default();
-    let _ = app.project.w();
-    //let _ = app.project.w_sidebar();
-    //let _ = app.project.w_tracks_area();
-    let _ = app.project.h();
-    //let _ = app.project.h_tracks_area();
-    //let _ = app.project.h_inputs();
-    //let _ = app.project.h_outputs();
-    let _ = app.project.h_scenes();
-}
-
 #[cfg(test)] #[test] fn test_midi_edit () {
-    let _editor = MidiEditor::default();
-    let mut editor = MidiEditor {
-        mode: PianoHorizontal::new(Some(&Arc::new(RwLock::new(MidiClip::stop_all())))),
-        size: Default::default(),
-        //keys: Default::default(),
-    };
-    let _ = editor.put_note(true);
-    let _ = editor.put_note(false);
-    let _ = editor.clip_status();
-    let _ = editor.edit_status();
-    struct TestEditorHost(Option<MidiEditor>);
-    has!(Option<MidiEditor>: |self: TestEditorHost|self.0);
-    //has_editor!(|self: TestEditorHost|{
-        //editor = self.0;
-        //editor_w = 0;
-        //editor_h = 0;
-        //is_editing = false;
-    //});
-    let mut host = TestEditorHost(Some(editor));
-    let _ = host.editor();
-    let _ = host.editor_mut();
-    let _ = host.is_editing();
-    let _ = host.editor_w();
-    let _ = host.editor_h();
 }
diff --git a/device/editor.rs b/device/editor.rs
index 5cdd290d..30e6f5c8 100644
--- a/device/editor.rs
+++ b/device/editor.rs
@@ -1,6 +1,58 @@
 use crate::*;
 
-impl<T: Has<Option<MidiEditor>>> HasEditor for T {}
+/// Contains state for viewing and editing a clip.
+///
+/// ```
+/// let mut editor = tek_device::MidiEditor {
+///     mode: PianoHorizontal::new(Some(&Arc::new(RwLock::new(MidiClip::stop_all())))),
+///     size: Default::default(),
+///     //keys: Default::default(),
+/// };
+/// let _ = editor.put_note(true);
+/// let _ = editor.put_note(false);
+/// let _ = editor.clip_status();
+/// let _ = editor.edit_status();
+/// ```
+pub struct MidiEditor {
+    /// Size of editor on screen
+    pub size: Measure<TuiOut>,
+    /// View mode and state of editor
+    pub mode: PianoHorizontal,
+}
+
+/// A clip, rendered as a horizontal piano roll.
+///
+/// ```
+/// let piano: tek_device::PianoHorizontal = Default::default();
+/// ```
+#[derive(Clone, Default)] pub struct PianoHorizontal {
+    pub clip: Option<Arc<RwLock<MidiClip>>>,
+    /// Buffer where the whole clip is rerendered on change
+    pub buffer: Arc<RwLock<BigBuffer>>,
+    /// Size of actual notes area
+    pub size:   Measure<TuiOut>,
+    /// The display window
+    pub range:  MidiSelection,
+    /// The note cursor
+    pub point:  MidiCursor,
+    /// The highlight color palette
+    pub color:  ItemTheme,
+    /// Width of the keyboard
+    pub keys_width: u16,
+}
+
+pub struct OctaveVertical { on: [bool; 12], colors: [Color; 3] }
+
+/// ```
+/// struct TestEditorHost(Option<MidiEditor>);
+/// has!(Option<MidiEditor>: |self: TestEditorHost|self.0);
+/// let mut host = TestEditorHost(Some(MidiEditor::default()));
+/// let _ = host.editor();
+/// let _ = host.editor_mut();
+/// let _ = host.is_editing();
+/// let _ = host.editor_w();
+/// let _ = host.editor_h();
+/// ```
 pub trait HasEditor: Has<Option<MidiEditor>> {
     fn editor (&self) -> Option<&MidiEditor> {
         self.get().as_ref()
@@ -18,32 +70,11 @@ pub trait HasEditor: Has<Option<MidiEditor>> {
         self.editor().map(|e|e.size.h()).unwrap_or(0) as usize
     }
 }
-#[macro_export] macro_rules! has_editor {
-    (|$self:ident: $Struct:ident|{
-        editor     = $e0:expr;
-        editor_w   = $e1:expr;
-        editor_h   = $e2:expr;
-        is_editing = $e3:expr;
-    }) => {
-        impl HasEditor for $Struct {
-            fn editor (&$self) -> Option<&MidiEditor> { $e0.as_ref() }
-            fn editor_mut (&mut $self) -> Option<&mut MidiEditor> { $e0.as_mut() }
-            fn editor_w (&$self) -> usize { $e1 }
-            fn editor_h (&$self) -> usize { $e2 }
-            fn is_editing (&$self) -> bool { $e3 }
-        }
-    };
-}
 
-/// Contains state for viewing and editing a clip
-pub struct MidiEditor {
-    /// Size of editor on screen
-    pub size: Measure<TuiOut>,
-    /// View mode and state of editor
-    pub mode: PianoHorizontal,
-}
+impl<T: Has<Option<MidiEditor>>> HasEditor for T {}
 
 has!(Measure<TuiOut>: |self: MidiEditor|self.size);
+
 impl Default for MidiEditor {
     fn default () -> Self {
         Self {
@@ -52,16 +83,19 @@ impl Default for MidiEditor {
         }
     }
 }
+
 impl std::fmt::Debug for MidiEditor {
     fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         f.debug_struct("MidiEditor").field("mode", &self.mode).finish()
     }
 }
+
 from!(MidiEditor: |clip: &Arc<RwLock<MidiClip>>| {
     let model = Self::from(Some(clip.clone()));
     model.redraw();
     model
 });
+
 from!(MidiEditor: |clip: Option<Arc<RwLock<MidiClip>>>| {
     let mut model = Self::default();
     *model.clip_mut() = clip;
@@ -100,58 +134,6 @@ impl MidiEditor {
             self.mode.redraw();
         }
     }
-}
-impl TimeRange for MidiEditor {
-    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
-    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
-    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
-    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
-    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
-}
-impl NoteRange for MidiEditor {
-    fn note_lo   (&self) -> &AtomicUsize { self.mode.note_lo()   }
-    fn note_axis (&self) -> &AtomicUsize { self.mode.note_axis() }
-}
-impl NotePoint for MidiEditor {
-    fn note_len (&self) -> &AtomicUsize { self.mode.note_len() }
-    fn note_pos (&self) -> &AtomicUsize { self.mode.note_pos() }
-}
-impl TimePoint for MidiEditor {
-    fn time_pos (&self) -> &AtomicUsize { self.mode.time_pos() }
-}
-impl MidiViewer for MidiEditor {
-    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
-    fn redraw      (&self) { self.mode.redraw() }
-    fn clip        (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
-    fn clip_mut    (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
-    fn set_clip    (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
-}
-
-def_command!(MidiEditCommand: |editor: MidiEditor| {
-    Show { clip: Option<Arc<RwLock<MidiClip>>> } => {
-        editor.set_clip(clip.as_ref()); editor.redraw(); Ok(None) },
-    DeleteNote => {
-        editor.redraw(); todo!() },
-    AppendNote    { advance: bool } => {
-        editor.put_note(*advance); editor.redraw(); Ok(None) },
-    SetNotePos    { pos:    usize } => {
-        editor.set_note_pos((*pos).min(127)); editor.redraw(); Ok(None) },
-    SetNoteLen    { len:    usize } => {
-        editor.set_note_len(*len); editor.redraw(); Ok(None) },
-    SetNoteScroll { scroll: usize } => {
-        editor.set_note_lo((*scroll).min(127)); editor.redraw(); Ok(None) },
-    SetTimePos    { pos:    usize } => {
-        editor.set_time_pos(*pos); editor.redraw(); Ok(None) },
-    SetTimeScroll { scroll: usize } => {
-        editor.set_time_start(*scroll); editor.redraw(); Ok(None) },
-    SetTimeZoom   { zoom:   usize } => {
-        editor.set_time_zoom(*zoom); editor.redraw(); Ok(None) },
-    SetTimeLock   { lock:   bool  } => {
-        editor.set_time_lock(*lock); editor.redraw(); Ok(None) },
-    // TODO: 1-9 seek markers that by default start every 8th of the clip
-});
-
-impl MidiEditor {
     fn _todo_opt_clip_stub (&self) -> Option<Arc<RwLock<MidiClip>>> { todo!() }
     fn clip_length (&self) -> usize { self.clip().as_ref().map(|p|p.read().unwrap().length).unwrap_or(1) }
     fn note_length (&self) -> usize { self.get_note_len() }
@@ -185,19 +167,6 @@ impl MidiEditor {
         self.get_time_pos().overflowing_sub(1)
             .0.min(self.clip_length().saturating_sub(1))
     }
-}
-
-impl Draw<TuiOut> for MidiEditor {
-    fn draw (&self, to: &mut TuiOut) { self.content().draw(to) }
-}
-impl Layout<TuiOut> for MidiEditor {
-    fn layout (&self, to: XYWH<u16>) -> XYWH<u16> { self.content().layout(to) }
-}
-impl HasContent<TuiOut> for MidiEditor {
-    fn content (&self) -> impl Content<TuiOut> { self.autoscroll(); /*self.autozoom();*/ self.size.of(&self.mode) }
-}
-
-impl MidiEditor {
     pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
         let (_color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
             (clip.color, clip.name.clone(), clip.length, clip.looped)
@@ -222,7 +191,7 @@ impl MidiEditor {
         let time_zoom = self.get_time_zoom();
         let time_lock = if self.get_time_lock() { "[lock]" } else { "      " };
         let note_pos  = self.get_note_pos();
-        let note_name = format!("{:4}",  Note::pitch_to_name(note_pos));
+        let note_name = format!("{:4}",  note_pitch_to_name(note_pos));
         let note_pos  = format!("{:>3}", note_pos);
         let note_len  = format!("{:>4}", self.get_note_len());
         Fixed::X(20, col!(
@@ -242,30 +211,79 @@ impl MidiEditor {
     }
 }
 
-/// A clip, rendered as a horizontal piano roll.
-#[derive(Clone)]
-pub struct PianoHorizontal {
-    pub clip: Option<Arc<RwLock<MidiClip>>>,
-    /// Buffer where the whole clip is rerendered on change
-    pub buffer: Arc<RwLock<BigBuffer>>,
-    /// Size of actual notes area
-    pub size:   Measure<TuiOut>,
-    /// The display window
-    pub range:  MidiRangeModel,
-    /// The note cursor
-    pub point:  MidiPointModel,
-    /// The highlight color palette
-    pub color:  ItemTheme,
-    /// Width of the keyboard
-    pub keys_width: u16,
+impl TimeRange for MidiEditor {
+    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
 }
 
+impl NoteRange for MidiEditor {
+    fn note_lo   (&self) -> &AtomicUsize { self.mode.note_lo()   }
+    fn note_axis (&self) -> &AtomicUsize { self.mode.note_axis() }
+}
+
+impl NotePoint for MidiEditor {
+    fn note_len (&self) -> &AtomicUsize { self.mode.note_len() }
+    fn note_pos (&self) -> &AtomicUsize { self.mode.note_pos() }
+}
+
+impl TimePoint for MidiEditor {
+    fn time_pos (&self) -> &AtomicUsize { self.mode.time_pos() }
+}
+
+impl MidiViewer for MidiEditor {
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
+    fn redraw      (&self) { self.mode.redraw() }
+    fn clip        (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
+    fn clip_mut    (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
+    fn set_clip    (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
+}
+
+def_command!(MidiEditCommand: |editor: MidiEditor| {
+    Show { clip: Option<Arc<RwLock<MidiClip>>> } => {
+        editor.set_clip(clip.as_ref()); editor.redraw(); Ok(None) },
+    DeleteNote => {
+        editor.redraw(); todo!() },
+    AppendNote    { advance: bool } => {
+        editor.put_note(*advance); editor.redraw(); Ok(None) },
+    SetNotePos    { pos:    usize } => {
+        editor.set_note_pos((*pos).min(127)); editor.redraw(); Ok(None) },
+    SetNoteLen    { len:    usize } => {
+        editor.set_note_len(*len); editor.redraw(); Ok(None) },
+    SetNoteScroll { scroll: usize } => {
+        editor.set_note_lo((*scroll).min(127)); editor.redraw(); Ok(None) },
+    SetTimePos    { pos:    usize } => {
+        editor.set_time_pos(*pos); editor.redraw(); Ok(None) },
+    SetTimeScroll { scroll: usize } => {
+        editor.set_time_start(*scroll); editor.redraw(); Ok(None) },
+    SetTimeZoom   { zoom:   usize } => {
+        editor.set_time_zoom(*zoom); editor.redraw(); Ok(None) },
+    SetTimeLock   { lock:   bool  } => {
+        editor.set_time_lock(*lock); editor.redraw(); Ok(None) },
+    // TODO: 1-9 seek markers that by default start every 8th of the clip
+});
+
+impl Draw<TuiOut> for MidiEditor {
+    fn draw (&self, to: &mut TuiOut) { self.content().draw(to) }
+}
+
+impl Layout<TuiOut> for MidiEditor {
+    fn layout (&self, to: XYWH<u16>) -> XYWH<u16> { self.content().layout(to) }
+}
+
+impl HasContent<TuiOut> for MidiEditor {
+    fn content (&self) -> impl Content<TuiOut> { self.autoscroll(); /*self.autozoom();*/ self.size.of(&self.mode) }
+}
+
+
 has!(Measure<TuiOut>:|self:PianoHorizontal|self.size);
 
 impl PianoHorizontal {
     pub fn new (clip: Option<&Arc<RwLock<MidiClip>>>) -> Self {
         let size = Measure::new(0, 0);
-        let mut range = MidiRangeModel::from((12, true));
+        let mut range = MidiSelection::from((12, true));
         range.time_axis = size.x.clone();
         range.note_axis = size.y.clone();
         let piano = Self {
@@ -273,7 +291,7 @@ impl PianoHorizontal {
             size,
             range,
             buffer: RwLock::new(Default::default()).into(),
-            point:  MidiPointModel::default(),
+            point:  MidiCursor::default(),
             clip: clip.cloned(),
             color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]),
         };
@@ -454,9 +472,9 @@ impl PianoHorizontal {
                     continue
                 }
                 if note == note_pos {
-                    to.blit(&format!("{:<5}", Note::pitch_to_name(note)), x, screen_y, on_style)
+                    to.blit(&format!("{:<5}", note_pitch_to_name(note)), x, screen_y, on_style)
                 } else {
-                    to.blit(&Note::pitch_to_name(note), x, screen_y, off_style)
+                    to.blit(&note_pitch_to_name(note), x, screen_y, off_style)
                 };
             }
         })))
@@ -542,7 +560,6 @@ fn to_key (note: usize) -> &'static str {
     }
 }
 
-pub struct OctaveVertical { on: [bool; 12], colors: [Color; 3] }
 impl Default for OctaveVertical {
     fn default () -> Self {
         Self { on: [false; 12], colors: [Rgb(255,255,255), Rgb(0,0,0), Rgb(255,0,0)] }
diff --git a/device/scene.rs b/device/scene.rs
index 115bc7ed..334fefe9 100644
--- a/device/scene.rs
+++ b/device/scene.rs
@@ -1,5 +1,21 @@
 use crate::*;
 
+/// A scene consists of a set of clips to play together.
+///
+/// ```
+/// let scene: tek_device::Scene = Default::default();
+/// let _ = scene.pulses();
+/// let _ = scene.is_playing(&[]);
+/// ```
+#[derive(Debug, Default)] pub struct Scene {
+    /// Name of scene
+    pub name:  Arc<str>,
+    /// Identifying color of scene
+    pub color: ItemTheme,
+    /// Clips in scene, one per track
+    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
+}
+
 def_sizes_iter!(ScenesSizes => Scene);
 
 impl<T: Has<Vec<Scene>> + Send + Sync> HasScenes for T {}
@@ -143,16 +159,6 @@ pub trait ScenesView:
     }
 }
 
-#[derive(Debug, Default)]
-pub struct Scene {
-    /// Name of scene
-    pub name:  Arc<str>,
-    /// Identifying color of scene
-    pub color: ItemTheme,
-    /// Clips in scene, one per track
-    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
-}
-
 impl Scene {
     /// Returns the pulse length of the longest clip in the scene
     pub fn pulses (&self) -> usize {
diff --git a/device/sequencer.rs b/device/sequencer.rs
index f7b2145e..a722e810 100644
--- a/device/sequencer.rs
+++ b/device/sequencer.rs
@@ -416,7 +416,7 @@ pub trait MidiViewer: Measured<TuiOut> + MidiRange + MidiPoint + Debug + Send +
                 let time_zoom = self.time_zoom().get();
                 let time_area = time_axis * time_zoom;
                 if time_area > time_len {
-                    let next_time_zoom = NoteDuration::prev(time_zoom);
+                    let next_time_zoom = note_duration_prev(time_zoom);
                     if next_time_zoom <= 1 {
                         break
                     }
@@ -427,7 +427,7 @@ pub trait MidiViewer: Measured<TuiOut> + MidiRange + MidiPoint + Debug + Send +
                         break
                     }
                 } else if time_area < time_len {
-                    let prev_time_zoom = NoteDuration::next(time_zoom);
+                    let prev_time_zoom = note_duration_next(time_zoom);
                     if prev_time_zoom > 384 {
                         break
                     }
diff --git a/device/track.rs b/device/track.rs
index 3714ec25..70ef42c7 100644
--- a/device/track.rs
+++ b/device/track.rs
@@ -1,5 +1,23 @@
 use crate::*;
 
+/// A track consists of a sequencer and zero or more devices chained after it.
+///
+/// ```
+/// let track: tek_device::Track = Default::default();
+/// ```
+#[derive(Debug, Default)] pub struct Track {
+    /// Name of track
+    pub name:      Arc<str>,
+    /// Identifying color of track
+    pub color:     ItemTheme,
+    /// Preferred width of track column
+    pub width:     usize,
+    /// MIDI sequencer state
+    pub sequencer: Sequencer,
+    /// Device chain
+    pub devices:   Vec<Device>,
+}
+
 def_sizes_iter!(TracksSizes => Track);
 
 impl<T: Has<Vec<Track>> + Send + Sync> HasTracks for T {}
@@ -72,20 +90,6 @@ impl<T: MaybeHas<Track>> HasTrack for T {
     }
 }
 
-#[derive(Debug, Default)]
-pub struct Track {
-    /// Name of track
-    pub name:      Arc<str>,
-    /// Identifying color of track
-    pub color:     ItemTheme,
-    /// Preferred width of track column
-    pub width:     usize,
-    /// MIDI sequencer state
-    pub sequencer: Sequencer,
-    /// Device chain
-    pub devices:   Vec<Device>,
-}
-
 has!(Clock:     |self: Track|self.sequencer.clock);
 has!(Sequencer: |self: Track|self.sequencer);
 impl Track {
diff --git a/device/vst3.rs b/device/vst3.rs
index e69de29b..74e120f6 100644
--- a/device/vst3.rs
+++ b/device/vst3.rs
@@ -0,0 +1 @@
+struct Vst3; // TODO
diff --git a/engine/engine.rs b/engine/engine.rs
index f7beba37..0299c67b 100644
--- a/engine/engine.rs
+++ b/engine/engine.rs
@@ -1,74 +1,115 @@
-mod engine_deps; pub use self::engine_deps::*;
-mod time; pub use self::time::*;
-mod note; pub use self::note::*;
-mod jack; pub use self::jack::*;
-mod midi; pub use self::midi::*;
+pub extern crate jack;
+pub extern crate midly;
+pub extern crate tengri;
+mod engine_structs; pub use self::engine_structs::*;
+mod engine_traits; pub use self::engine_traits::*;
+mod engine_impls;
+mod jack_structs; pub use self::jack_structs::*;
+mod jack_traits; pub use self::jack_traits::*;
+mod jack_types; pub use self::jack_types::*;
+mod jack_impls;
+pub(crate) use ::{
+    tengri::{Usually, from, output::PerfModel},
+    atomic_float::AtomicF64,
+    std::{
+        fmt::Debug, ops::{Add, Sub, Mul, Div, Rem},
+        sync::{Arc, RwLock, atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed}},
+    },
+};
+pub use ::{
+    jack::{*, contrib::{*, ClosureProcessHandler}},
+    midly::{Smf, TrackEventKind, MidiMessage, Error as MidiError, num::*, live::*,}
+};
 
-//pub trait MaybeHas<T>: Send + Sync {
-    //fn get (&self) -> Option<&T>;
-//}
+pub const DEFAULT_PPQ: f64 = 96.0;
 
-//impl<T, U: Has<Option<T>>> MaybeHas<T> for U {
-    //fn get (&self) -> Option<&T> {
-        //Has::<Option<T>>::get(self).as_ref()
-    //}
-//}
+/// FIXME: remove this and use PPQ from timebase everywhere:
+pub const PPQ: usize = 96;
 
-pub trait HasN<T>: Send + Sync {
-    fn get_nth     (&self,     key: usize) -> &T;
-    fn get_nth_mut (&mut self, key: usize) -> &mut T;
+/// (pulses, name), assuming 96 PPQ
+pub const NOTE_DURATIONS: [(usize, &str);26] = [
+    (1,    "1/384"), (2,    "1/192"),
+    (3,    "1/128"), (4,    "1/96"),
+    (6,    "1/64"),  (8,    "1/48"),
+    (12,   "1/32"),  (16,   "1/24"),
+    (24,   "1/16"),  (32,   "1/12"),
+    (48,   "1/8"),   (64,   "1/6"),
+    (96,   "1/4"),   (128,  "1/3"),
+    (192,  "1/2"),   (256,  "2/3"),
+    (384,  "1/1"),   (512,  "4/3"),
+    (576,  "3/2"),   (768,  "2/1"),
+    (1152, "3/1"),   (1536, "4/1"),
+    (2304, "6/1"),   (3072, "8/1"),
+    (3456, "9/1"),   (6144, "16/1"),
+];
+
+pub const NOTE_NAMES: [&str; 128] = [
+    "C0",  "C#0",  "D0",  "D#0",  "E0",  "F0",  "F#0",  "G0", "G#0", "A0", "A#0", "B0",
+    "C1",  "C#1",  "D1",  "D#1",  "E1",  "F1",  "F#1",  "G1", "G#1", "A1", "A#1", "B1",
+    "C2",  "C#2",  "D2",  "D#2",  "E2",  "F2",  "F#2",  "G2", "G#2", "A2", "A#2", "B2",
+    "C3",  "C#3",  "D3",  "D#3",  "E3",  "F3",  "F#3",  "G3", "G#3", "A3", "A#3", "B3",
+    "C4",  "C#4",  "D4",  "D#4",  "E4",  "F4",  "F#4",  "G4", "G#4", "A4", "A#4", "B4",
+    "C5",  "C#5",  "D5",  "D#5",  "E5",  "F5",  "F#5",  "G5", "G#5", "A5", "A#5", "B5",
+    "C6",  "C#6",  "D6",  "D#6",  "E6",  "F6",  "F#6",  "G6", "G#6", "A6", "A#6", "B6",
+    "C7",  "C#7",  "D7",  "D#7",  "E7",  "F7",  "F#7",  "G7", "G#7", "A7", "A#7", "B7",
+    "C8",  "C#8",  "D8",  "D#8",  "E8",  "F8",  "F#8",  "G8", "G#8", "A8", "A#8", "B8",
+    "C9",  "C#9",  "D9",  "D#9",  "E9",  "F9",  "F#9",  "G9", "G#9", "A9", "A#9", "B9",
+    "C10", "C#10", "D10", "D#10", "E10", "F10", "F#10", "G10",
+];
+
+/// Return boxed iterator of MIDI events
+pub fn parse_midi_input <'a> (input: ::jack::MidiIter<'a>)
+    -> Box<dyn Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> + 'a>
+{
+    Box::new(input.map(|::jack::RawMidi { time, bytes }|(
+        time as usize,
+        LiveEvent::parse(bytes).unwrap(),
+        bytes
+    )))
 }
 
-pub trait Gettable<T> {
-    /// Returns current value
-    fn get (&self) -> T;
+/// Add "all notes off" to the start of a buffer.
+pub fn all_notes_off (output: &mut [Vec<Vec<u8>>]) {
+    let mut buf = vec![];
+    let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
+    let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
+    evt.write(&mut buf).unwrap();
+    output[0].push(buf);
 }
 
-pub trait Mutable<T>: Gettable<T> {
-    /// Sets new value, returns old
-    fn set (&mut self, value: T) -> T;
+/// Update notes_in array
+pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
+    match message {
+        MidiMessage::NoteOn  { key, .. } => { keys[key.as_int() as usize] = true; }
+        MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
+        _ => {}
+    }
 }
 
-pub trait InteriorMutable<T>: Gettable<T> {
-    /// Sets new value, returns old
-    fn set (&self, value: T) -> T;
+/// Returns the next shorter length
+pub fn note_duration_prev (pulses: usize) -> usize {
+    for (length, _) in NOTE_DURATIONS.iter().rev() { if *length < pulses { return *length } }
+    pulses
 }
 
-impl Gettable<bool> for AtomicBool {
-    fn get (&self) -> bool { self.load(Relaxed) }
+/// Returns the next longer length
+pub fn note_duration_next (pulses: usize) -> usize {
+    for (length, _) in NOTE_DURATIONS.iter() { if *length > pulses { return *length } }
+    pulses
 }
 
-impl InteriorMutable<bool> for AtomicBool {
-    fn set (&self, value: bool) -> bool { self.swap(value, Relaxed) }
+pub fn note_duration_to_name (pulses: usize) -> &'static str {
+    for (length, name) in NOTE_DURATIONS.iter() { if *length == pulses { return name } }
+    ""
 }
 
-impl Gettable<usize> for AtomicUsize {
-    fn get (&self) -> usize { self.load(Relaxed) }
+pub fn note_pitch_to_name (n: usize) -> &'static str {
+    if n > 127 {
+        panic!("to_note_name({n}): must be 0-127");
+    }
+    NOTE_NAMES[n]
 }
 
-impl InteriorMutable<usize> for AtomicUsize {
-    fn set (&self, value: usize) -> usize { self.swap(value, Relaxed) }
-}
-
-#[cfg(test)] #[test] fn test_time () -> Usually<()> {
-    // TODO!
-    Ok(())
-}
-
-#[cfg(test)] #[test] fn test_midi_range () {
-    let model = MidiRangeModel::from((1, false));
-
-    let _ = model.get_time_len();
-    let _ = model.get_time_zoom();
-    let _ = model.get_time_lock();
-    let _ = model.get_time_start();
-    let _ = model.get_time_axis();
-    let _ = model.get_time_end();
-
-    let _ = model.get_note_lo();
-    let _ = model.get_note_axis();
-    let _ = model.get_note_hi();
-}
 
 //macro_rules! impl_port {
     //($Name:ident : $Spec:ident -> $Pair:ident |$jack:ident, $name:ident|$port:expr) => {
diff --git a/engine/engine_deps.rs b/engine/engine_deps.rs
deleted file mode 100644
index 1284b0f2..00000000
--- a/engine/engine_deps.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-pub use ::tengri;
-pub(crate) use ::{
-    tengri::{Usually, from},
-    atomic_float::AtomicF64,
-    std::{
-        cmp::Ord,
-        fmt::Debug,
-        ops::{Add, Sub, Mul, Div, Rem},
-        sync::{Arc, RwLock, atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed}},
-    },
-};
diff --git a/engine/engine_impls.rs b/engine/engine_impls.rs
new file mode 100644
index 00000000..42f2d9e9
--- /dev/null
+++ b/engine/engine_impls.rs
@@ -0,0 +1,363 @@
+use crate::*;
+
+impl Gettable<bool> for AtomicBool {
+    fn get (&self) -> bool {
+        self.load(Relaxed)
+    }
+}
+
+impl InteriorMutable<bool> for AtomicBool {
+    fn set (&self, value: bool) -> bool {
+        self.swap(value, Relaxed)
+    }
+}
+
+impl Gettable<usize> for AtomicUsize {
+    fn get (&self) -> usize {
+        self.load(Relaxed)
+    }
+}
+
+impl InteriorMutable<usize> for AtomicUsize {
+    fn set (&self, value: usize) -> usize {
+        self.swap(value, Relaxed)
+    }
+}
+
+//impl<T, U: Has<Option<T>>> MaybeHas<T> for U {
+    //fn get (&self) -> Option<&T> {
+        //Has::<Option<T>>::get(self).as_ref()
+    //}
+//}
+
+impl Default for MidiCursor {
+    fn default () -> Self {
+        Self {
+            time_pos: Arc::new(0.into()),
+            note_pos: Arc::new(36.into()),
+            note_len: Arc::new(24.into()),
+        }
+    }
+}
+
+impl NotePoint for MidiCursor {
+    fn note_len (&self) -> &AtomicUsize {
+        &self.note_len
+    }
+    fn note_pos (&self) -> &AtomicUsize {
+        &self.note_pos
+    }
+}
+
+impl TimePoint for MidiCursor {
+    fn time_pos (&self) -> &AtomicUsize {
+        self.time_pos.as_ref()
+    }
+}
+
+impl<T: NotePoint + TimePoint> MidiPoint for T {}
+
+from!(MidiSelection: |data:(usize, bool)| Self {
+    time_len:   Arc::new(0.into()),
+    note_axis:  Arc::new(0.into()),
+    note_lo:    Arc::new(0.into()),
+    time_axis:  Arc::new(0.into()),
+    time_start: Arc::new(0.into()),
+    time_zoom:  Arc::new(data.0.into()),
+    time_lock:  Arc::new(data.1.into()),
+});
+
+impl<T: TimeRange + NoteRange> MidiRange for T {}
+
+impl TimeRange for MidiSelection {
+    fn time_len   (&self) -> &AtomicUsize { &self.time_len   }
+    fn time_zoom  (&self) -> &AtomicUsize { &self.time_zoom  }
+    fn time_lock  (&self) -> &AtomicBool  { &self.time_lock  }
+    fn time_start (&self) -> &AtomicUsize { &self.time_start }
+    fn time_axis  (&self) -> &AtomicUsize { &self.time_axis  }
+}
+
+impl NoteRange for MidiSelection {
+    fn note_lo    (&self) -> &AtomicUsize { &self.note_lo    }
+    fn note_axis  (&self) -> &AtomicUsize { &self.note_axis  }
+}
+
+impl Moment {
+    pub fn zero (timebase: &Arc<Timebase>) -> Self {
+        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
+    }
+    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
+        Self {
+            usec:     usec.into(),
+            sample:   timebase.sr.usecs_to_sample(usec).into(),
+            pulse:    timebase.usecs_to_pulse(usec).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
+        Self {
+            sample:   sample.into(),
+            usec:     timebase.sr.samples_to_usec(sample).into(),
+            pulse:    timebase.samples_to_pulse(sample).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
+        Self {
+            pulse:    pulse.into(),
+            sample:   timebase.pulses_to_sample(pulse).into(),
+            usec:     timebase.pulses_to_usec(pulse).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    #[inline] pub fn update_from_usec (&self, usec: f64) {
+        self.usec.set(usec);
+        self.pulse.set(self.timebase.usecs_to_pulse(usec));
+        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
+    }
+    #[inline] pub fn update_from_sample (&self, sample: f64) {
+        self.usec.set(self.timebase.sr.samples_to_usec(sample));
+        self.pulse.set(self.timebase.samples_to_pulse(sample));
+        self.sample.set(sample);
+    }
+    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
+        self.usec.set(self.timebase.pulses_to_usec(pulse));
+        self.pulse.set(pulse);
+        self.sample.set(self.timebase.pulses_to_sample(pulse));
+    }
+    #[inline] pub fn format_beat (&self) -> Arc<str> {
+        self.timebase.format_beats_1(self.pulse.get()).into()
+    }
+}
+
+impl LaunchSync {
+    pub fn next (&self) -> f64 {
+        note_duration_next(self.get() as usize) as f64
+    }
+    pub fn prev (&self) -> f64 {
+        note_duration_prev(self.get() as usize) as f64
+    }
+}
+
+impl Quantize {
+    pub fn next (&self) -> f64 {
+        note_duration_next(self.get() as usize) as f64
+    }
+    pub fn prev (&self) -> f64 {
+        note_duration_prev(self.get() as usize) as f64
+    }
+}
+
+impl Iterator for TicksIterator {
+    type Item = (usize, usize);
+    fn next (&mut self) -> Option<Self::Item> {
+        loop {
+            if self.sample > self.end { return None }
+            let spp    = self.spp;
+            let sample = self.sample as f64;
+            let start  = self.start;
+            let end    = self.end;
+            self.sample += 1;
+            //println!("{spp} {sample} {start} {end}");
+            let jitter = sample.rem_euclid(spp); // ramps
+            let next_jitter = (sample + 1.0).rem_euclid(spp);
+            if jitter > next_jitter { // at crossing:
+                let time = (sample as usize) % (end as usize-start as usize);
+                let tick = (sample / spp) as usize;
+                return Some((time, tick))
+            }
+        }
+    }
+}
+
+impl Timebase {
+    /// Specify sample rate, BPM and PPQ
+    pub fn new (
+        s: impl Into<SampleRate>,
+        b: impl Into<BeatsPerMinute>,
+        p: impl Into<PulsesPerQuaver>
+    ) -> Self {
+        Self { sr: s.into(), bpm: b.into(), ppq: p.into() }
+    }
+    /// Iterate over ticks between start and end.
+    #[inline] pub fn pulses_between_samples (&self, start: usize, end: usize) -> TicksIterator {
+        TicksIterator { spp: self.samples_per_pulse(), sample: start, start, end }
+    }
+    /// Return the duration fo a beat in microseconds
+    #[inline] pub fn usec_per_beat (&self) -> f64 { 60_000_000f64 / self.bpm.get() }
+    /// Return the number of beats in a second
+    #[inline] pub fn beat_per_second (&self) -> f64 { self.bpm.get() / 60f64 }
+    /// Return the number of microseconds corresponding to a note of the given duration
+    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
+        4.0 * self.usec_per_beat() * num / den
+    }
+    /// Return duration of a pulse in microseconds (BPM-dependent)
+    #[inline] pub fn pulse_per_usec (&self) -> f64 { self.ppq.get() / self.usec_per_beat() }
+    /// Return duration of a pulse in microseconds (BPM-dependent)
+    #[inline] pub fn usec_per_pulse (&self) -> f64 { self.usec_per_beat() / self.ppq.get() }
+    /// Return number of pulses to which a number of microseconds corresponds (BPM-dependent)
+    #[inline] pub fn usecs_to_pulse (&self, usec: f64) -> f64 { usec * self.pulse_per_usec() }
+    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
+    #[inline] pub fn pulses_to_usec (&self, pulse: f64) -> f64 { pulse / self.usec_per_pulse() }
+    /// Return number of pulses in a second (BPM-dependent)
+    #[inline] pub fn pulses_per_second (&self) -> f64 { self.beat_per_second() * self.ppq.get() }
+    /// Return fraction of a pulse to which a sample corresponds (SR- and BPM-dependent)
+    #[inline] pub fn pulses_per_sample (&self) -> f64 {
+        self.usec_per_pulse() / self.sr.usec_per_sample()
+    }
+    /// Return number of samples in a pulse (SR- and BPM-dependent)
+    #[inline] pub fn samples_per_pulse (&self) -> f64 {
+        self.sr.get() / self.pulses_per_second()
+    }
+    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
+    #[inline] pub fn pulses_to_sample (&self, p: f64) -> f64 {
+        self.pulses_per_sample() * p
+    }
+    /// Convert a number of samples to a pulse number (SR- and BPM-dependent)
+    #[inline] pub fn samples_to_pulse (&self, s: f64) -> f64 {
+        s / self.pulses_per_sample()
+    }
+    /// Return the number of samples corresponding to a note of the given duration
+    #[inline] pub fn note_to_samples (&self, note: (f64, f64)) -> f64 {
+        self.usec_to_sample(self.note_to_usec(note))
+    }
+    /// Return the number of samples corresponding to the given number of microseconds
+    #[inline] pub fn usec_to_sample (&self, usec: f64) -> f64 {
+        usec * self.sr.get() / 1000f64
+    }
+    /// Return the quantized position of a moment in time given a step
+    #[inline] pub fn quantize (&self, step: (f64, f64), time: f64) -> (f64, f64) {
+        let step = self.note_to_usec(step);
+        (time / step, time % step)
+    }
+    /// Quantize a collection of events
+    #[inline] pub fn quantize_into <E: Iterator<Item=(f64, f64)> + Sized, T> (
+        &self, step: (f64, f64), events: E
+    ) -> Vec<(f64, f64)> {
+        events.map(|(time, event)|(self.quantize(step, time).0, event)).collect()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 0
+    #[inline] pub fn format_beats_0 (&self, pulse: f64) -> Arc<str> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
+        format!("{}.{}.{pulses:02}", beats / 4, beats % 4).into()
+    }
+    /// Format a number of pulses into Beat.Bar starting from 0
+    #[inline] pub fn format_beats_0_short (&self, pulse: f64) -> Arc<str> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let beats = if ppq > 0 { pulse / ppq } else { 0 };
+        format!("{}.{}", beats / 4, beats % 4).into()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1 (&self, pulse: f64) -> Arc<str> {
+        let mut string = String::with_capacity(16);
+        self.format_beats_1_to(&mut string, pulse).expect("failed to format {pulse} into beat");
+        string.into()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1_to (&self, w: &mut impl std::fmt::Write, pulse: f64) -> Result<(), std::fmt::Error> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
+        write!(w, "{}.{}.{pulses:02}", beats / 4 + 1, beats % 4 + 1)
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1_short (&self, pulse: f64) -> Arc<str> {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let beats = if ppq > 0 { pulse / ppq } else { 0 };
+        format!("{}.{}", beats / 4 + 1, beats % 4 + 1).into()
+    }
+}
+
+impl Default for Timebase {
+    fn default () -> Self { Self::new(48000f64, 150f64, DEFAULT_PPQ) }
+}
+impl SampleRate {
+    /// Return the duration of a sample in microseconds (floating)
+    #[inline] pub fn usec_per_sample (&self) -> f64 {
+        1_000_000f64 / self.get()
+    }
+    /// Return the duration of a sample in microseconds (floating)
+    #[inline] pub fn sample_per_usec (&self) -> f64 {
+        self.get() / 1_000_000f64
+    }
+    /// Convert a number of samples to microseconds (floating)
+    #[inline] pub fn samples_to_usec (&self, samples: f64) -> f64 {
+        self.usec_per_sample() * samples
+    }
+    /// Convert a number of microseconds to samples (floating)
+    #[inline] pub fn usecs_to_sample (&self, usecs:   f64) -> f64 {
+        self.sample_per_usec() * usecs
+    }
+}
+
+impl Microsecond {
+    #[inline] pub fn format_msu (&self) -> Arc<str> {
+        let usecs              = self.get() as usize;
+        let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
+        let (minutes, seconds) = (seconds / 60, seconds % 60);
+        format!("{minutes}:{seconds:02}:{msecs:03}").into()
+    }
+}
+
+/// Implement an arithmetic operation for a unit of time
+#[macro_export] macro_rules! impl_op {
+    ($T:ident, $Op:ident, $method:ident, |$a:ident,$b:ident|{$impl:expr}) => {
+        impl $Op<Self> for $T {
+            type Output = Self; #[inline] fn $method (self, other: Self) -> Self::Output {
+                let $a = self.get(); let $b = other.get(); Self($impl.into())
+            }
+        }
+        impl $Op<usize> for $T {
+            type Output = Self; #[inline] fn $method (self, other: usize) -> Self::Output {
+                let $a = self.get(); let $b = other as f64; Self($impl.into())
+            }
+        }
+        impl $Op<f64> for $T {
+            type Output = Self; #[inline] fn $method (self, other: f64) -> Self::Output {
+                let $a = self.get(); let $b = other; Self($impl.into())
+            }
+        }
+    }
+}
+
+/// Define and implement a unit of time
+#[macro_export] macro_rules! impl_time_unit {
+    ($T:ident) => {
+        impl Gettable<f64> for $T {
+            fn get (&self) -> f64 { self.0.load(Relaxed) }
+        }
+        impl InteriorMutable<f64> for $T {
+            fn set (&self, value: f64) -> f64 {
+                let old = self.get();
+                self.0.store(value, Relaxed);
+                old
+            }
+        }
+        impl TimeUnit for $T {}
+        impl_op!($T, Add, add, |a, b|{a + b});
+        impl_op!($T, Sub, sub, |a, b|{a - b});
+        impl_op!($T, Mul, mul, |a, b|{a * b});
+        impl_op!($T, Div, div, |a, b|{a / b});
+        impl_op!($T, Rem, rem, |a, b|{a % b});
+        impl From<f64>   for $T    { fn from (value: f64)   -> Self { Self(value.into()) } }
+        impl From<usize> for $T    { fn from (value: usize) -> Self { Self((value as f64).into()) } }
+        impl From<$T>    for f64   { fn from (value: $T)    -> Self { value.get() } }
+        impl From<$T>    for usize { fn from (value: $T)    -> Self { value.get() as usize } }
+        impl From<&$T>   for f64   { fn from (value: &$T)   -> Self { value.get() } }
+        impl From<&$T>   for usize { fn from (value: &$T)   -> Self { value.get() as usize } }
+        impl Clone for $T { fn clone (&self) -> Self { Self(self.get().into()) } }
+    }
+}
+
+impl_time_unit!(SampleCount);
+impl_time_unit!(SampleRate);
+impl_time_unit!(Microsecond);
+impl_time_unit!(Quantize);
+impl_time_unit!(PulsesPerQuaver);
+impl_time_unit!(Pulse);
+impl_time_unit!(BeatsPerMinute);
+impl_time_unit!(LaunchSync);
diff --git a/engine/engine_structs.rs b/engine/engine_structs.rs
new file mode 100644
index 00000000..f47c64ca
--- /dev/null
+++ b/engine/engine_structs.rs
@@ -0,0 +1,156 @@
+use crate::*;
+
+/// Temporal resolutions: sample rate, tempo, MIDI pulses per quaver (beat)
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Clone)] pub struct Timebase {
+    /// Audio samples per second
+    pub sr:  SampleRate,
+    /// MIDI beats per minute
+    pub bpm: BeatsPerMinute,
+    /// MIDI ticks per beat
+    pub ppq: PulsesPerQuaver,
+}
+
+/// Iterator that emits subsequent ticks within a range.
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct TicksIterator {
+    pub spp:    f64,
+    pub sample: usize,
+    pub start:  usize,
+    pub end:    usize,
+}
+
+///
+/// ```
+/// let model = MidiSelection::from((1, false));
+///
+/// let _ = model.get_time_len();
+/// let _ = model.get_time_zoom();
+/// let _ = model.get_time_lock();
+/// let _ = model.get_time_start();
+/// let _ = model.get_time_axis();
+/// let _ = model.get_time_end();
+///
+/// let _ = model.get_note_lo();
+/// let _ = model.get_note_axis();
+/// let _ = model.get_note_hi();
+/// ```
+#[derive(Debug, Clone)] pub struct MidiCursor {
+    /// Time coordinate of cursor
+    pub time_pos: Arc<AtomicUsize>,
+    /// Note coordinate of cursor
+    pub note_pos: Arc<AtomicUsize>,
+    /// Length of note that will be inserted, in pulses
+    pub note_len: Arc<AtomicUsize>,
+}
+
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Clone, Default)] pub struct MidiSelection {
+    pub time_len:   Arc<AtomicUsize>,
+    /// Length of visible time axis
+    pub time_axis:  Arc<AtomicUsize>,
+    /// Earliest time displayed
+    pub time_start: Arc<AtomicUsize>,
+    /// Time step
+    pub time_zoom:  Arc<AtomicUsize>,
+    /// Auto rezoom to fit in time axis
+    pub time_lock:  Arc<AtomicBool>,
+    /// Length of visible note axis
+    pub note_axis:  Arc<AtomicUsize>,
+    // Lowest note displayed
+    pub note_lo:    Arc<AtomicUsize>,
+}
+
+/// A point in time in all time scales (microsecond, sample, MIDI pulse)
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default, Clone)]
+pub struct Moment {
+    pub timebase: Arc<Timebase>,
+    /// Current time in microseconds
+    pub usec:   Microsecond,
+    /// Current time in audio samples
+    pub sample: SampleCount,
+    /// Current time in MIDI pulses
+    pub pulse:  Pulse,
+}
+
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Clone, Default)]
+pub enum Moment2 {
+    #[default] None,
+    Zero,
+    Usec(Microsecond),
+    Sample(SampleCount),
+    Pulse(Pulse),
+}
+
+/// MIDI resolution in PPQ (pulses per quarter note)
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct PulsesPerQuaver (pub(crate) AtomicF64);
+
+/// Timestamp in MIDI pulses
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Pulse (pub(crate) AtomicF64);
+
+/// Tempo in beats per minute
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct BeatsPerMinute (pub(crate) AtomicF64);
+
+/// Quantization setting for launching clips
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct LaunchSync (pub(crate) AtomicF64);
+
+/// Quantization setting for notes
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Quantize (pub(crate) AtomicF64);
+
+/// Timestamp in audio samples
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct SampleCount (pub(crate) AtomicF64);
+
+/// Audio sample rate in Hz (samples per second)
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct SampleRate (pub(crate) AtomicF64);
+
+/// Timestamp in microseconds
+///
+/// ```
+///
+/// ```
+#[derive(Debug, Default)] pub struct Microsecond (pub(crate) AtomicF64);
diff --git a/engine/engine_traits.rs b/engine/engine_traits.rs
new file mode 100644
index 00000000..2871e0d8
--- /dev/null
+++ b/engine/engine_traits.rs
@@ -0,0 +1,129 @@
+use crate::*;
+use std::sync::atomic::Ordering;
+
+//pub trait MaybeHas<T>: Send + Sync {
+    //fn get (&self) -> Option<&T>;
+//}
+
+pub trait HasN<T>: Send + Sync {
+    fn get_nth     (&self,     key: usize) -> &T;
+    fn get_nth_mut (&mut self, key: usize) -> &mut T;
+}
+
+pub trait Gettable<T> {
+    /// Returns current value
+    fn get (&self) -> T;
+}
+
+pub trait Mutable<T>: Gettable<T> {
+    /// Sets new value, returns old
+    fn set (&mut self, value: T) -> T;
+}
+
+pub trait InteriorMutable<T>: Gettable<T> {
+    /// Sets new value, returns old
+    fn set (&self, value: T) -> T;
+}
+
+pub trait NotePoint {
+    fn note_len (&self) -> &AtomicUsize;
+    /// Get the current length of the note cursor.
+    fn get_note_len (&self) -> usize {
+        self.note_len().load(Relaxed)
+    }
+    /// Set the length of the note cursor, returning the previous value.
+    fn set_note_len (&self, x: usize) -> usize {
+        self.note_len().swap(x, Relaxed)
+    }
+
+    fn note_pos (&self) -> &AtomicUsize;
+    /// Get the current pitch of the note cursor.
+    fn get_note_pos (&self) -> usize {
+        self.note_pos().load(Relaxed).min(127)
+    }
+    /// Set the current pitch fo the note cursor, returning the previous value.
+    fn set_note_pos (&self, x: usize) -> usize {
+        self.note_pos().swap(x.min(127), Relaxed)
+    }
+}
+
+pub trait TimePoint {
+    fn time_pos (&self) -> &AtomicUsize;
+    /// Get the current time position of the note cursor.
+    fn get_time_pos (&self) -> usize {
+        self.time_pos().load(Relaxed)
+    }
+    /// Set the current time position of the note cursor, returning the previous value.
+    fn set_time_pos (&self, x: usize) -> usize {
+        self.time_pos().swap(x, Relaxed)
+    }
+}
+
+pub trait MidiPoint: NotePoint + TimePoint {
+    /// Get the current end of the note cursor.
+    fn get_note_end (&self) -> usize {
+        self.get_time_pos() + self.get_note_len()
+    }
+}
+
+pub trait TimeRange {
+    fn time_len (&self) -> &AtomicUsize;
+    fn get_time_len (&self) -> usize {
+        self.time_len().load(Ordering::Relaxed)
+    }
+    fn time_zoom (&self) -> &AtomicUsize;
+    fn get_time_zoom (&self) -> usize {
+        self.time_zoom().load(Ordering::Relaxed)
+    }
+    fn set_time_zoom (&self, value: usize) -> usize {
+        self.time_zoom().swap(value, Ordering::Relaxed)
+    }
+    fn time_lock (&self) -> &AtomicBool;
+    fn get_time_lock (&self) -> bool {
+        self.time_lock().load(Ordering::Relaxed)
+    }
+    fn set_time_lock (&self, value: bool) -> bool {
+        self.time_lock().swap(value, Ordering::Relaxed)
+    }
+    fn time_start (&self) -> &AtomicUsize;
+    fn get_time_start (&self) -> usize {
+        self.time_start().load(Ordering::Relaxed)
+    }
+    fn set_time_start (&self, value: usize) -> usize {
+        self.time_start().swap(value, Ordering::Relaxed)
+    }
+    fn time_axis (&self) -> &AtomicUsize;
+    fn get_time_axis (&self) -> usize {
+        self.time_axis().load(Ordering::Relaxed)
+    }
+    fn get_time_end (&self) -> usize {
+        self.time_start().get() + self.time_axis().get() * self.time_zoom().get()
+    }
+}
+
+pub trait NoteRange {
+    fn note_lo (&self) -> &AtomicUsize;
+    fn get_note_lo (&self) -> usize {
+        self.note_lo().load(Ordering::Relaxed)
+    }
+    fn set_note_lo (&self, x: usize) -> usize {
+        self.note_lo().swap(x, Ordering::Relaxed)
+    }
+    fn note_axis (&self) -> &AtomicUsize;
+    fn get_note_axis (&self) -> usize {
+        self.note_axis().load(Ordering::Relaxed)
+    }
+    fn get_note_hi (&self) -> usize {
+        (self.note_lo().get() + self.note_axis().get().saturating_sub(1)).min(127)
+    }
+}
+
+pub trait MidiRange: TimeRange + NoteRange {}
+
+/// A unit of time, represented as an atomic 64-bit float.
+///
+/// According to https://stackoverflow.com/a/873367, as per IEEE754,
+/// every integer between 1 and 2^53 can be represented exactly.
+/// This should mean that, even at 192kHz sampling rate, over 1 year of audio
+/// can be clocked in microseconds with f64 without losing precision.
+pub trait TimeUnit: InteriorMutable<f64> {}
diff --git a/engine/jack.rs b/engine/jack.rs
deleted file mode 100644
index aa2ae22d..00000000
--- a/engine/jack.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-use crate::*;
-pub use ::jack::{*, contrib::{*, ClosureProcessHandler}};
-/// Wraps [JackState] and through it [jack::Client] when connected.
-#[derive(Clone, Debug, Default)]
-pub struct Jack<'j>(Arc<RwLock<JackState<'j>>>);
-/// Implement [Jack] constructor and methods
-impl<'j> Jack<'j> {
-    /// Register new [Client] and wrap it for shared use.
-    pub fn new_run <T: HasJack<'j> + Audio + Send + Sync + 'static> (
-        name: &impl AsRef<str>,
-        init: impl FnOnce(Jack<'j>)->Usually<T>
-    ) -> Usually<Arc<RwLock<T>>> {
-        Jack::new(name)?.run(init)
-    }
-    pub fn new (name: &impl AsRef<str>) -> Usually<Self> {
-        let client = Client::new(name.as_ref(), ClientOptions::NO_START_SERVER)?.0;
-        Ok(Jack(Arc::new(RwLock::new(JackState::Inactive(client)))))
-    }
-    pub fn run <T: HasJack<'j> + Audio + Send + Sync + 'static>
-        (self, init: impl FnOnce(Self)->Usually<T>) -> Usually<Arc<RwLock<T>>>
-    {
-        let client_state = self.0.clone();
-        let app: Arc<RwLock<T>> = Arc::new(RwLock::new(init(self)?));
-        let mut state = Activating;
-        std::mem::swap(&mut*client_state.write().unwrap(), &mut state);
-        if let Inactive(client) = state {
-            let client = client.activate_async(
-                // This is the misc notifications handler. It's a struct that wraps a [Box]
-                // which performs type erasure on a callback that takes [JackEvent], which is
-                // one of the available misc notifications.
-                Notifications(Box::new({
-                    let app = app.clone();
-                    move|event|(&mut*app.write().unwrap()).handle(event)
-                }) as BoxedJackEventHandler),
-                // This is the main processing handler. It's a struct that wraps a [Box]
-                // which performs type erasure on a callback that takes [Client] and [ProcessScope]
-                // and passes them down to the `app`'s `process` callback, which in turn
-                // implements audio and MIDI input and output on a realtime basis.
-                ClosureProcessHandler::new(Box::new({
-                    let app = app.clone();
-                    move|c: &_, s: &_|if let Ok(mut app) = app.write() {
-                        app.process(c, s)
-                    } else {
-                        Control::Quit
-                    }
-                }) as BoxedAudioHandler),
-            )?;
-            *client_state.write().unwrap() = Active(client);
-        } else {
-            unreachable!();
-        }
-        Ok(app)
-    }
-    /// Run something with the client.
-    pub fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
-        match &*self.0.read().unwrap() {
-            Inert            => panic!("jack client not activated"),
-            Inactive(client) => op(client),
-            Activating       => panic!("jack client has not finished activation"),
-            Active(client)   => op(client.as_client()),
-        }
-    }
-}
-impl<'j> HasJack<'j> for Jack<'j> {
-    fn jack (&self) -> &Jack<'j> {
-        self
-    }
-}
-impl<'j> HasJack<'j> for &Jack<'j> {
-    fn jack (&self) -> &Jack<'j> {
-        self
-    }
-}
-/// This is a connection which may be [Inactive], [Activating], or [Active].
-/// In the [Active] and [Inactive] states, [JackState::client] returns a
-/// [jack::Client], which you can use to talk to the JACK API.
-#[derive(Debug, Default)]
-pub enum JackState<'j> {
-    /// Unused
-    #[default] Inert,
-    /// Before activation.
-    Inactive(Client),
-    /// During activation.
-    Activating,
-    /// After activation. Must not be dropped for JACK thread to persist.
-    Active(DynamicAsyncClient<'j>),
-}
-/// Things that can provide a [jack::Client] reference.
-pub trait HasJack<'j>: Send + Sync {
-    /// Return the internal [jack::Client] handle
-    /// that lets you call the JACK API.
-    fn jack (&self) -> &Jack<'j>;
-    fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
-        self.jack().with_client(op)
-    }
-    fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
-        self.with_client(|client|client.port_by_name(name))
-    }
-    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
-        self.with_client(|c|c.port_by_id(id))
-    }
-    fn register_port <PS: PortSpec + Default> (&self, name: impl AsRef<str>) -> Usually<Port<PS>> {
-        self.with_client(|client|Ok(client.register_port(name.as_ref(), PS::default())?))
-    }
-    fn sync_lead (&self, enable: bool, callback: impl Fn(TimebaseInfo)->Position) -> Usually<()> {
-        if enable {
-            self.with_client(|client|match client.register_timebase_callback(false, callback) {
-               Ok(_) => Ok(()),
-                Err(e) => Err(e)
-            })?
-        }
-        Ok(())
-    }
-    fn sync_follow (&self, _enable: bool) -> Usually<()> {
-        // TODO: sync follow
-        Ok(())
-    }
-}
-/// Trait for thing that has a JACK process callback.
-pub trait Audio {
-    /// Handle a JACK event.
-    fn handle (&mut self, _event: JackEvent) {}
-    /// Projecss a JACK chunk.
-    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
-        Control::Continue
-    }
-    /// The JACK process callback function passed to the server.
-    fn callback (
-        state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope
-    ) -> Control where Self: Sized {
-        if let Ok(mut state) = state.write() {
-            state.process(client, scope)
-        } else {
-            Control::Quit
-        }
-    }
-}
-/// Implement [Audio]: provide JACK callbacks.
-#[macro_export] macro_rules! audio {
-    (|
-        $self1:ident:
-        $Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?,$c:ident,$s:ident
-    |$cb:expr$(;|$self2:ident,$e:ident|$cb2:expr)?) => {
-        impl $(<$($L),*$($T $(: $U)?),*>)? Audio for $Struct $(<$($L),*$($T),*>)? {
-            #[inline] fn process (&mut $self1, $c: &Client, $s: &ProcessScope) -> Control { $cb }
-            $(#[inline] fn handle (&mut $self2, $e: JackEvent) { $cb2 })?
-        }
-    };
-    ($Struct:ident: $process:ident, $handle:ident) => {
-        impl Audio for $Struct {
-            #[inline] fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
-                $process(self, c, s)
-            }
-            #[inline] fn handle (&mut self, e: JackEvent) {
-                $handle(self, e)
-            }
-        }
-    };
-}
-/// Event enum for JACK events.
-#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
-    ThreadInit,
-    Shutdown(ClientStatus, Arc<str>),
-    Freewheel(bool),
-    SampleRate(Frames),
-    ClientRegistration(Arc<str>, bool),
-    PortRegistration(PortId, bool),
-    PortRename(PortId, Arc<str>, Arc<str>),
-    PortsConnected(PortId, PortId, bool),
-    GraphReorder,
-    XRun,
-}
-/// Generic notification handler that emits [JackEvent]
-pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
-
-impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
-    fn thread_init(&self, _: &Client) {
-        self.0(JackEvent::ThreadInit);
-    }
-    unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
-        self.0(JackEvent::Shutdown(status, reason.into()));
-    }
-    fn freewheel(&mut self, _: &Client, enabled: bool) {
-        self.0(JackEvent::Freewheel(enabled));
-    }
-    fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
-        self.0(JackEvent::SampleRate(frames));
-        Control::Quit
-    }
-    fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
-        self.0(JackEvent::ClientRegistration(name.into(), reg));
-    }
-    fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
-        self.0(JackEvent::PortRegistration(id, reg));
-    }
-    fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
-        self.0(JackEvent::PortRename(id, old.into(), new.into()));
-        Control::Continue
-    }
-    fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
-        self.0(JackEvent::PortsConnected(a, b, are));
-    }
-    fn graph_reorder(&mut self, _: &Client) -> Control {
-        self.0(JackEvent::GraphReorder);
-        Control::Continue
-    }
-    fn xrun(&mut self, _: &Client) -> Control {
-        self.0(JackEvent::XRun);
-        Control::Continue
-    }
-}
-
-/// This is a running JACK [AsyncClient] with maximum type erasure.
-/// It has one [Box] containing a function that handles [JackEvent]s,
-/// and another [Box] containing a function that handles realtime IO,
-/// and that's all it knows about them.
-pub type DynamicAsyncClient<'j>
-    = AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
-/// This is the notification handler wrapper for a boxed realtime callback.
-pub type DynamicAudioHandler<'j> =
-    ClosureProcessHandler<(), BoxedAudioHandler<'j>>;
-/// This is a boxed realtime callback.
-pub type BoxedAudioHandler<'j> =
-    Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + Sync + 'j>;
-/// This is the notification handler wrapper for a boxed [JackEvent] callback.
-pub type DynamicNotifications<'j> =
-    Notifications<BoxedJackEventHandler<'j>>;
-/// This is a boxed [JackEvent] callback.
-pub type BoxedJackEventHandler<'j> =
-    Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
-use self::JackState::*;
-
diff --git a/engine/jack_impls.rs b/engine/jack_impls.rs
new file mode 100644
index 00000000..e6ae7f70
--- /dev/null
+++ b/engine/jack_impls.rs
@@ -0,0 +1,131 @@
+use crate::*;
+use JackState::*;
+
+/// Implement [Jack] constructor and methods
+impl<'j> Jack<'j> {
+
+    /// Register new [Client] and wrap it for shared use.
+    pub fn new_run <T: HasJack<'j> + Audio + Send + Sync + 'static> (
+        name: &impl AsRef<str>,
+        init: impl FnOnce(Jack<'j>)->Usually<T>
+    ) -> Usually<Arc<RwLock<T>>> {
+        Jack::new(name)?.run(init)
+    }
+
+    pub fn new (name: &impl AsRef<str>) -> Usually<Self> {
+        let client = Client::new(name.as_ref(), ClientOptions::NO_START_SERVER)?.0;
+        Ok(Jack(Arc::new(RwLock::new(JackState::Inactive(client)))))
+    }
+
+    pub fn run <T: HasJack<'j> + Audio + Send + Sync + 'static>
+        (self, init: impl FnOnce(Self)->Usually<T>) -> Usually<Arc<RwLock<T>>>
+    {
+        let client_state = self.0.clone();
+        let app: Arc<RwLock<T>> = Arc::new(RwLock::new(init(self)?));
+        let mut state = Activating;
+        std::mem::swap(&mut*client_state.write().unwrap(), &mut state);
+        if let Inactive(client) = state {
+            // This is the misc notifications handler. It's a struct that wraps a [Box]
+            // which performs type erasure on a callback that takes [JackEvent], which is
+            // one of the available misc notifications.
+            let notify = JackNotify(Box::new({
+                let app = app.clone();
+                move|event|(&mut*app.write().unwrap()).handle(event)
+            }) as BoxedJackEventHandler);
+            // This is the main processing handler. It's a struct that wraps a [Box]
+            // which performs type erasure on a callback that takes [Client] and [ProcessScope]
+            // and passes them down to the `app`'s `process` callback, which in turn
+            // implements audio and MIDI input and output on a realtime basis.
+            let process = ClosureProcessHandler::new(Box::new({
+                let app = app.clone();
+                move|c: &_, s: &_|if let Ok(mut app) = app.write() {
+                    app.process(c, s)
+                } else {
+                    Control::Quit
+                }
+            }) as BoxedAudioHandler);
+            // Launch a client with the two handlers.
+            *client_state.write().unwrap() = Active(
+                client.activate_async(notify, process)?
+            );
+        } else {
+            unreachable!();
+        }
+        Ok(app)
+    }
+
+    /// Run something with the client.
+    pub fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
+        match &*self.0.read().unwrap() {
+            Inert            => panic!("jack client not activated"),
+            Inactive(client) => op(client),
+            Activating       => panic!("jack client has not finished activation"),
+            Active(client)   => op(client.as_client()),
+        }
+    }
+}
+
+impl<'j> HasJack<'j> for Jack<'j> {
+    fn jack (&self) -> &Jack<'j> {
+        self
+    }
+}
+
+impl<'j> HasJack<'j> for &Jack<'j> {
+    fn jack (&self) -> &Jack<'j> {
+        self
+    }
+}
+
+impl<T: Fn(JackEvent) + Send> NotificationHandler for JackNotify<T> {
+    fn thread_init(&self, _: &Client) {
+        self.0(JackEvent::ThreadInit);
+    }
+    unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
+        self.0(JackEvent::Shutdown(status, reason.into()));
+    }
+    fn freewheel(&mut self, _: &Client, enabled: bool) {
+        self.0(JackEvent::Freewheel(enabled));
+    }
+    fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(JackEvent::SampleRate(frames));
+        Control::Quit
+    }
+    fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(JackEvent::ClientRegistration(name.into(), reg));
+    }
+    fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(JackEvent::PortRegistration(id, reg));
+    }
+    fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(JackEvent::PortRename(id, old.into(), new.into()));
+        Control::Continue
+    }
+    fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(JackEvent::PortsConnected(a, b, are));
+    }
+    fn graph_reorder(&mut self, _: &Client) -> Control {
+        self.0(JackEvent::GraphReorder);
+        Control::Continue
+    }
+    fn xrun(&mut self, _: &Client) -> Control {
+        self.0(JackEvent::XRun);
+        Control::Continue
+    }
+}
+
+impl JackPerfModel for PerfModel {
+    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope) {
+        if let Some(t0) = t0 {
+            let t1 = self.clock.raw();
+            self.used.store(
+                self.clock.delta_as_nanos(t0, t1) as f64,
+                Relaxed,
+            );
+            self.window.store(
+                scope.cycle_times().unwrap().period_usecs as f64,
+                Relaxed,
+            );
+        }
+    }
+}
diff --git a/engine/jack_structs.rs b/engine/jack_structs.rs
new file mode 100644
index 00000000..5cefc9b6
--- /dev/null
+++ b/engine/jack_structs.rs
@@ -0,0 +1,53 @@
+use crate::*;
+
+/// Wraps [JackState], and through it [jack::Client] when connected.
+///
+/// ```
+/// let jack: tek_engine::Jack = Default::default();
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct Jack<'j> (pub(crate) Arc<RwLock<JackState<'j>>>);
+
+/// This is a connection which may be [Inactive], [Activating], or [Active].
+/// In the [Active] and [Inactive] states, [JackState::client] returns a
+/// [jack::Client], which you can use to talk to the JACK API.
+///
+/// ```
+/// let state: tek_engine::JackState = Default::default();
+/// ```
+#[derive(Debug, Default)]
+pub enum JackState<'j> {
+    /// Unused
+    #[default] Inert,
+    /// Before activation.
+    Inactive(Client),
+    /// During activation.
+    Activating,
+    /// After activation. Must not be dropped for JACK thread to persist.
+    Active(DynamicAsyncClient<'j>),
+}
+
+/// Event enum for JACK events.
+///
+/// ```
+/// let event: tek_engine::JackState = JackEvent::XRun;
+/// ```
+#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, Arc<str>),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(Arc<str>, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, Arc<str>, Arc<str>),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+/// Generic notification handler that emits [JackEvent]
+///
+/// ```
+/// let notify = tek_engine::JackNotify(|_: JackEvent|{});
+/// ```
+pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);
diff --git a/engine/jack_traits.rs b/engine/jack_traits.rs
new file mode 100644
index 00000000..5614747a
--- /dev/null
+++ b/engine/jack_traits.rs
@@ -0,0 +1,104 @@
+use crate::*;
+
+/// Things that can provide a [jack::Client] reference.
+///
+/// ```
+/// #[derive(Default)] struct Jacked<'j>(tek_engine::Jack<'j>);
+///
+/// impl tek_engine::HasJack<'j> for Jacked<'j> {
+///     fn jack (&self) -> &Jack<'j> { &self.0 }
+/// }
+///
+/// let jack: &Jack<'j> = Jacked::default().jack();
+/// ```
+pub trait HasJack<'j>: Send + Sync {
+
+    /// Return the internal [jack::Client] handle
+    /// that lets you call the JACK API.
+    fn jack (&self) -> &Jack<'j>;
+
+    fn with_client <T> (&self, op: impl FnOnce(&Client)->T) -> T {
+        self.jack().with_client(op)
+    }
+
+    fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
+        self.with_client(|client|client.port_by_name(name))
+    }
+
+    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
+        self.with_client(|c|c.port_by_id(id))
+    }
+
+    fn register_port <PS: PortSpec + Default> (&self, name: impl AsRef<str>) -> Usually<Port<PS>> {
+        self.with_client(|client|Ok(client.register_port(name.as_ref(), PS::default())?))
+    }
+
+    fn sync_lead (&self, enable: bool, callback: impl Fn(TimebaseInfo)->Position) -> Usually<()> {
+        if enable {
+            self.with_client(|client|match client.register_timebase_callback(false, callback) {
+               Ok(_) => Ok(()),
+                Err(e) => Err(e)
+            })?
+        }
+        Ok(())
+    }
+
+    fn sync_follow (&self, _enable: bool) -> Usually<()> {
+        // TODO: sync follow
+        Ok(())
+    }
+}
+
+/// Trait for thing that has a JACK process callback.
+pub trait Audio {
+
+    /// Handle a JACK event.
+    fn handle (&mut self, _event: JackEvent) {}
+
+    /// Projecss a JACK chunk.
+    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
+        Control::Continue
+    }
+
+    /// The JACK process callback function passed to the server.
+    fn callback (
+        state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope
+    ) -> Control where Self: Sized {
+        if let Ok(mut state) = state.write() {
+            state.process(client, scope)
+        } else {
+            Control::Quit
+        }
+    }
+
+}
+
+/// Implement [Audio]: provide JACK callbacks.
+#[macro_export] macro_rules! audio {
+
+    (|
+        $self1:ident:
+        $Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?,$c:ident,$s:ident
+    |$cb:expr$(;|$self2:ident,$e:ident|$cb2:expr)?) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? Audio for $Struct $(<$($L),*$($T),*>)? {
+            #[inline] fn process (&mut $self1, $c: &Client, $s: &ProcessScope) -> Control { $cb }
+            $(#[inline] fn handle (&mut $self2, $e: JackEvent) { $cb2 })?
+        }
+    };
+
+    ($Struct:ident: $process:ident, $handle:ident) => {
+        impl Audio for $Struct {
+            #[inline] fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
+                $process(self, c, s)
+            }
+            #[inline] fn handle (&mut self, e: JackEvent) {
+                $handle(self, e)
+            }
+        }
+    };
+
+}
+
+pub trait JackPerfModel {
+    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope);
+}
diff --git a/engine/jack_types.rs b/engine/jack_types.rs
new file mode 100644
index 00000000..a64cd1d9
--- /dev/null
+++ b/engine/jack_types.rs
@@ -0,0 +1,27 @@
+use crate::*;
+
+/// Running JACK [AsyncClient] with maximum type erasure.
+///
+/// One [Box] contains function that handles [JackEvent]s.
+///
+/// Another [Box] containing a function that handles realtime IO.
+///
+/// That's all it knows about them.
+pub type DynamicAsyncClient<'j>
+    = AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
+
+/// Notification handler wrapper for [BoxedAudioHandler].
+pub type DynamicAudioHandler<'j> =
+    ClosureProcessHandler<(), BoxedAudioHandler<'j>>;
+
+/// Boxed realtime callback.
+pub type BoxedAudioHandler<'j> =
+    Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + Sync + 'j>;
+
+/// Notification handler wrapper for [BoxedJackEventHandler].
+pub type DynamicNotifications<'j> =
+    JackNotify<BoxedJackEventHandler<'j>>;
+
+/// Boxed [JackEvent] callback.
+pub type BoxedJackEventHandler<'j> =
+    Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
diff --git a/engine/midi.rs b/engine/midi.rs
deleted file mode 100644
index 55835404..00000000
--- a/engine/midi.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-pub use ::midly::{
-    Smf,
-    TrackEventKind,
-    MidiMessage,
-    Error as MidiError,
-    num::*,
-    live::*,
-};
-
-/// Return boxed iterator of MIDI events
-pub fn parse_midi_input <'a> (input: ::jack::MidiIter<'a>) -> Box<dyn Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> + 'a> {
-    Box::new(input.map(|::jack::RawMidi { time, bytes }|(
-        time as usize,
-        LiveEvent::parse(bytes).unwrap(),
-        bytes
-    )))
-}
-
-/// Add "all notes off" to the start of a buffer.
-pub fn all_notes_off (output: &mut [Vec<Vec<u8>>]) {
-    let mut buf = vec![];
-    let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
-    let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
-    evt.write(&mut buf).unwrap();
-    output[0].push(buf);
-}
-
-/// Update notes_in array
-pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
-    match message {
-        MidiMessage::NoteOn  { key, .. } => { keys[key.as_int() as usize] = true; }
-        MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
-        _ => {}
-    }
-}
diff --git a/engine/note.rs b/engine/note.rs
deleted file mode 100644
index e7e35888..00000000
--- a/engine/note.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod note_pitch; pub use self::note_pitch::*;
-mod note_point; pub use self::note_point::*;
-mod note_range; pub use self::note_range::*;
diff --git a/engine/note/note_pitch.rs b/engine/note/note_pitch.rs
deleted file mode 100644
index 06e455ce..00000000
--- a/engine/note/note_pitch.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-pub struct Note;
-
-impl Note {
-    pub const NAMES: [&str; 128] = [
-        "C0",  "C#0",  "D0",  "D#0",  "E0",  "F0",  "F#0",  "G0", "G#0", "A0", "A#0", "B0",
-        "C1",  "C#1",  "D1",  "D#1",  "E1",  "F1",  "F#1",  "G1", "G#1", "A1", "A#1", "B1",
-        "C2",  "C#2",  "D2",  "D#2",  "E2",  "F2",  "F#2",  "G2", "G#2", "A2", "A#2", "B2",
-        "C3",  "C#3",  "D3",  "D#3",  "E3",  "F3",  "F#3",  "G3", "G#3", "A3", "A#3", "B3",
-        "C4",  "C#4",  "D4",  "D#4",  "E4",  "F4",  "F#4",  "G4", "G#4", "A4", "A#4", "B4",
-        "C5",  "C#5",  "D5",  "D#5",  "E5",  "F5",  "F#5",  "G5", "G#5", "A5", "A#5", "B5",
-        "C6",  "C#6",  "D6",  "D#6",  "E6",  "F6",  "F#6",  "G6", "G#6", "A6", "A#6", "B6",
-        "C7",  "C#7",  "D7",  "D#7",  "E7",  "F7",  "F#7",  "G7", "G#7", "A7", "A#7", "B7",
-        "C8",  "C#8",  "D8",  "D#8",  "E8",  "F8",  "F#8",  "G8", "G#8", "A8", "A#8", "B8",
-        "C9",  "C#9",  "D9",  "D#9",  "E9",  "F9",  "F#9",  "G9", "G#9", "A9", "A#9", "B9",
-        "C10", "C#10", "D10", "D#10", "E10", "F10", "F#10", "G10",
-    ];
-    pub fn pitch_to_name (n: usize) -> &'static str {
-        if n > 127 {
-            panic!("to_note_name({n}): must be 0-127");
-        }
-        Self::NAMES[n]
-    }
-}
diff --git a/engine/note/note_point.rs b/engine/note/note_point.rs
deleted file mode 100644
index 310cef87..00000000
--- a/engine/note/note_point.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use crate::*;
-
-#[derive(Debug, Clone)]
-pub struct MidiPointModel {
-    /// Time coordinate of cursor
-    pub time_pos: Arc<AtomicUsize>,
-    /// Note coordinate of cursor
-    pub note_pos: Arc<AtomicUsize>,
-    /// Length of note that will be inserted, in pulses
-    pub note_len: Arc<AtomicUsize>,
-}
-
-impl Default for MidiPointModel {
-    fn default () -> Self {
-        Self {
-            time_pos: Arc::new(0.into()),
-            note_pos: Arc::new(36.into()),
-            note_len: Arc::new(24.into()),
-        }
-    }
-}
-
-impl NotePoint for MidiPointModel {
-    fn note_len (&self) -> &AtomicUsize {
-        &self.note_len
-    }
-    fn note_pos (&self) -> &AtomicUsize {
-        &self.note_pos
-    }
-}
-
-impl TimePoint for MidiPointModel {
-    fn time_pos (&self) -> &AtomicUsize {
-        self.time_pos.as_ref()
-    }
-}
-
-pub trait NotePoint {
-    fn note_len (&self) -> &AtomicUsize;
-    /// Get the current length of the note cursor.
-    fn get_note_len (&self) -> usize {
-        self.note_len().load(Relaxed)
-    }
-    /// Set the length of the note cursor, returning the previous value.
-    fn set_note_len (&self, x: usize) -> usize {
-        self.note_len().swap(x, Relaxed)
-    }
-
-    fn note_pos (&self) -> &AtomicUsize;
-    /// Get the current pitch of the note cursor.
-    fn get_note_pos (&self) -> usize {
-        self.note_pos().load(Relaxed).min(127)
-    }
-    /// Set the current pitch fo the note cursor, returning the previous value.
-    fn set_note_pos (&self, x: usize) -> usize {
-        self.note_pos().swap(x.min(127), Relaxed)
-    }
-}
-
-pub trait TimePoint {
-    fn time_pos (&self) -> &AtomicUsize;
-    /// Get the current time position of the note cursor.
-    fn get_time_pos (&self) -> usize {
-        self.time_pos().load(Relaxed)
-    }
-    /// Set the current time position of the note cursor, returning the previous value.
-    fn set_time_pos (&self, x: usize) -> usize {
-        self.time_pos().swap(x, Relaxed)
-    }
-}
-
-pub trait MidiPoint: NotePoint + TimePoint {
-    /// Get the current end of the note cursor.
-    fn get_note_end (&self) -> usize {
-        self.get_time_pos() + self.get_note_len()
-    }
-}
-
-impl<T: NotePoint + TimePoint> MidiPoint for T {}
diff --git a/engine/note/note_range.rs b/engine/note/note_range.rs
deleted file mode 100644
index 16eab7a4..00000000
--- a/engine/note/note_range.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use crate::*;
-use std::sync::atomic::Ordering;
-
-#[derive(Debug, Clone)]
-pub struct MidiRangeModel {
-    pub time_len:   Arc<AtomicUsize>,
-    /// Length of visible time axis
-    pub time_axis:  Arc<AtomicUsize>,
-    /// Earliest time displayed
-    pub time_start: Arc<AtomicUsize>,
-    /// Time step
-    pub time_zoom:  Arc<AtomicUsize>,
-    /// Auto rezoom to fit in time axis
-    pub time_lock:  Arc<AtomicBool>,
-    /// Length of visible note axis
-    pub note_axis:  Arc<AtomicUsize>,
-    // Lowest note displayed
-    pub note_lo:    Arc<AtomicUsize>,
-}
-
-from!(MidiRangeModel: |data:(usize, bool)| Self {
-    time_len:   Arc::new(0.into()),
-    note_axis:  Arc::new(0.into()),
-    note_lo:    Arc::new(0.into()),
-    time_axis:  Arc::new(0.into()),
-    time_start: Arc::new(0.into()),
-    time_zoom:  Arc::new(data.0.into()),
-    time_lock:  Arc::new(data.1.into()),
-});
-
-pub trait TimeRange {
-    fn time_len (&self) -> &AtomicUsize;
-    fn get_time_len (&self) -> usize {
-        self.time_len().load(Ordering::Relaxed)
-    }
-    fn time_zoom (&self) -> &AtomicUsize;
-    fn get_time_zoom (&self) -> usize {
-        self.time_zoom().load(Ordering::Relaxed)
-    }
-    fn set_time_zoom (&self, value: usize) -> usize {
-        self.time_zoom().swap(value, Ordering::Relaxed)
-    }
-    fn time_lock (&self) -> &AtomicBool;
-    fn get_time_lock (&self) -> bool {
-        self.time_lock().load(Ordering::Relaxed)
-    }
-    fn set_time_lock (&self, value: bool) -> bool {
-        self.time_lock().swap(value, Ordering::Relaxed)
-    }
-    fn time_start (&self) -> &AtomicUsize;
-    fn get_time_start (&self) -> usize {
-        self.time_start().load(Ordering::Relaxed)
-    }
-    fn set_time_start (&self, value: usize) -> usize {
-        self.time_start().swap(value, Ordering::Relaxed)
-    }
-    fn time_axis (&self) -> &AtomicUsize;
-    fn get_time_axis (&self) -> usize {
-        self.time_axis().load(Ordering::Relaxed)
-    }
-    fn get_time_end (&self) -> usize {
-        self.time_start().get() + self.time_axis().get() * self.time_zoom().get()
-    }
-}
-
-pub trait NoteRange {
-    fn note_lo (&self) -> &AtomicUsize;
-    fn get_note_lo (&self) -> usize {
-        self.note_lo().load(Ordering::Relaxed)
-    }
-    fn set_note_lo (&self, x: usize) -> usize {
-        self.note_lo().swap(x, Ordering::Relaxed)
-    }
-    fn note_axis (&self) -> &AtomicUsize;
-    fn get_note_axis (&self) -> usize {
-        self.note_axis().load(Ordering::Relaxed)
-    }
-    fn get_note_hi (&self) -> usize {
-        (self.note_lo().get() + self.note_axis().get().saturating_sub(1)).min(127)
-    }
-}
-
-pub trait MidiRange: TimeRange + NoteRange {}
-
-impl<T: TimeRange + NoteRange> MidiRange for T {}
-
-impl TimeRange for MidiRangeModel {
-    fn time_len   (&self) -> &AtomicUsize { &self.time_len   }
-    fn time_zoom  (&self) -> &AtomicUsize { &self.time_zoom  }
-    fn time_lock  (&self) -> &AtomicBool  { &self.time_lock  }
-    fn time_start (&self) -> &AtomicUsize { &self.time_start }
-    fn time_axis  (&self) -> &AtomicUsize { &self.time_axis  }
-}
-
-impl NoteRange for MidiRangeModel {
-    fn note_lo    (&self) -> &AtomicUsize { &self.note_lo    }
-    fn note_axis  (&self) -> &AtomicUsize { &self.note_axis  }
-}
diff --git a/engine/time.rs b/engine/time.rs
deleted file mode 100644
index 9d4e7459..00000000
--- a/engine/time.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-mod time_moment;       pub use self::time_moment::*;
-mod time_note;         pub use self::time_note::*;
-mod time_perf;         pub use self::time_perf::*;
-mod time_pulse;        pub use self::time_pulse::*;
-mod time_sample_count; pub use self::time_sample_count::*;
-mod time_sample_rate;  pub use self::time_sample_rate::*;
-mod time_timebase;     pub use self::time_timebase::*;
-mod time_unit;         pub use self::time_unit::*;
-mod time_usec;         pub use self::time_usec::*;
diff --git a/engine/time/time_moment.rs b/engine/time/time_moment.rs
deleted file mode 100644
index 000696a3..00000000
--- a/engine/time/time_moment.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use crate::*;
-
-#[derive(Debug, Clone)]
-pub enum Moment2 {
-    None,
-    Zero,
-    Usec(Microsecond),
-    Sample(SampleCount),
-    Pulse(Pulse),
-}
-
-/// A point in time in all time scales (microsecond, sample, MIDI pulse)
-#[derive(Debug, Default, Clone)]
-pub struct Moment {
-    pub timebase: Arc<Timebase>,
-    /// Current time in microseconds
-    pub usec:   Microsecond,
-    /// Current time in audio samples
-    pub sample: SampleCount,
-    /// Current time in MIDI pulses
-    pub pulse:  Pulse,
-}
-
-impl Moment {
-    pub fn zero (timebase: &Arc<Timebase>) -> Self {
-        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
-    }
-    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
-        Self {
-            usec:     usec.into(),
-            sample:   timebase.sr.usecs_to_sample(usec).into(),
-            pulse:    timebase.usecs_to_pulse(usec).into(),
-            timebase: timebase.clone(),
-        }
-    }
-    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
-        Self {
-            sample:   sample.into(),
-            usec:     timebase.sr.samples_to_usec(sample).into(),
-            pulse:    timebase.samples_to_pulse(sample).into(),
-            timebase: timebase.clone(),
-        }
-    }
-    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
-        Self {
-            pulse:    pulse.into(),
-            sample:   timebase.pulses_to_sample(pulse).into(),
-            usec:     timebase.pulses_to_usec(pulse).into(),
-            timebase: timebase.clone(),
-        }
-    }
-    #[inline] pub fn update_from_usec (&self, usec: f64) {
-        self.usec.set(usec);
-        self.pulse.set(self.timebase.usecs_to_pulse(usec));
-        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
-    }
-    #[inline] pub fn update_from_sample (&self, sample: f64) {
-        self.usec.set(self.timebase.sr.samples_to_usec(sample));
-        self.pulse.set(self.timebase.samples_to_pulse(sample));
-        self.sample.set(sample);
-    }
-    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
-        self.usec.set(self.timebase.pulses_to_usec(pulse));
-        self.pulse.set(pulse);
-        self.sample.set(self.timebase.pulses_to_sample(pulse));
-    }
-    #[inline] pub fn format_beat (&self) -> Arc<str> {
-        self.timebase.format_beats_1(self.pulse.get()).into()
-    }
-}
diff --git a/engine/time/time_note.rs b/engine/time/time_note.rs
deleted file mode 100644
index 5f92e0bd..00000000
--- a/engine/time/time_note.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-pub struct NoteDuration;
-
-/// (pulses, name), assuming 96 PPQ
-pub const NOTE_DURATIONS: [(usize, &str);26] = [
-    (1,    "1/384"), (2,    "1/192"),
-    (3,    "1/128"), (4,    "1/96"),
-    (6,    "1/64"),  (8,    "1/48"),
-    (12,   "1/32"),  (16,   "1/24"),
-    (24,   "1/16"),  (32,   "1/12"),
-    (48,   "1/8"),   (64,   "1/6"),
-    (96,   "1/4"),   (128,  "1/3"),
-    (192,  "1/2"),   (256,  "2/3"),
-    (384,  "1/1"),   (512,  "4/3"),
-    (576,  "3/2"),   (768,  "2/1"),
-    (1152, "3/1"),   (1536, "4/1"),
-    (2304, "6/1"),   (3072, "8/1"),
-    (3456, "9/1"),   (6144, "16/1"),
-];
-
-impl NoteDuration {
-    /// Returns the next shorter length
-    pub fn prev (pulses: usize) -> usize {
-        for (length, _) in NOTE_DURATIONS.iter().rev() { if *length < pulses { return *length } }
-        pulses
-    }
-    /// Returns the next longer length
-    pub fn next (pulses: usize) -> usize {
-        for (length, _) in NOTE_DURATIONS.iter() { if *length > pulses { return *length } }
-        pulses
-    }
-    pub fn pulses_to_name (pulses: usize) -> &'static str {
-        for (length, name) in NOTE_DURATIONS.iter() { if *length == pulses { return name } }
-        ""
-    }
-}
diff --git a/engine/time/time_perf.rs b/engine/time/time_perf.rs
deleted file mode 100644
index f14bcc66..00000000
--- a/engine/time/time_perf.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use crate::*;
-use tengri::tui::PerfModel;
-use ::jack::ProcessScope;
-
-pub trait JackPerfModel {
-    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope);
-}
-
-impl JackPerfModel for PerfModel {
-    fn update_from_jack_scope (&self, t0: Option<u64>, scope: &ProcessScope) {
-        if let Some(t0) = t0 {
-            let t1 = self.clock.raw();
-            self.used.store(
-                self.clock.delta_as_nanos(t0, t1) as f64,
-                Relaxed,
-            );
-            self.window.store(
-                scope.cycle_times().unwrap().period_usecs as f64,
-                Relaxed,
-            );
-        }
-    }
-}
diff --git a/engine/time/time_pulse.rs b/engine/time/time_pulse.rs
deleted file mode 100644
index 5505bd03..00000000
--- a/engine/time/time_pulse.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use crate::*;
-
-pub const DEFAULT_PPQ: f64 = 96.0;
-
-/// FIXME: remove this and use PPQ from timebase everywhere:
-pub const PPQ: usize = 96;
-
-/// MIDI resolution in PPQ (pulses per quarter note)
-#[derive(Debug, Default)] pub struct PulsesPerQuaver(AtomicF64);
-impl_time_unit!(PulsesPerQuaver);
-
-/// Timestamp in MIDI pulses
-#[derive(Debug, Default)] pub struct Pulse(AtomicF64);
-impl_time_unit!(Pulse);
-
-/// Tempo in beats per minute
-#[derive(Debug, Default)] pub struct BeatsPerMinute(AtomicF64);
-impl_time_unit!(BeatsPerMinute);
-
-/// Quantization setting for launching clips
-#[derive(Debug, Default)] pub struct LaunchSync(AtomicF64);
-impl_time_unit!(LaunchSync);
-impl LaunchSync {
-    pub fn next (&self) -> f64 {
-        NoteDuration::next(self.get() as usize) as f64
-    }
-    pub fn prev (&self) -> f64 {
-        NoteDuration::prev(self.get() as usize) as f64
-    }
-}
-
-/// Quantization setting for notes
-#[derive(Debug, Default)] pub struct Quantize(AtomicF64);
-impl_time_unit!(Quantize);
-impl Quantize {
-    pub fn next (&self) -> f64 {
-        NoteDuration::next(self.get() as usize) as f64
-    }
-    pub fn prev (&self) -> f64 {
-        NoteDuration::prev(self.get() as usize) as f64
-    }
-}
-
-/// Iterator that emits subsequent ticks within a range.
-pub struct TicksIterator {
-    pub spp:    f64,
-    pub sample: usize,
-    pub start:  usize,
-    pub end:    usize,
-}
-impl Iterator for TicksIterator {
-    type Item = (usize, usize);
-    fn next (&mut self) -> Option<Self::Item> {
-        loop {
-            if self.sample > self.end { return None }
-            let spp    = self.spp;
-            let sample = self.sample as f64;
-            let start  = self.start;
-            let end    = self.end;
-            self.sample += 1;
-            //println!("{spp} {sample} {start} {end}");
-            let jitter = sample.rem_euclid(spp); // ramps
-            let next_jitter = (sample + 1.0).rem_euclid(spp);
-            if jitter > next_jitter { // at crossing:
-                let time = (sample as usize) % (end as usize-start as usize);
-                let tick = (sample / spp) as usize;
-                return Some((time, tick))
-            }
-        }
-    }
-}
diff --git a/engine/time/time_sample_count.rs b/engine/time/time_sample_count.rs
deleted file mode 100644
index f91ebeba..00000000
--- a/engine/time/time_sample_count.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use crate::*;
-
-/// Timestamp in audio samples
-#[derive(Debug, Default)] pub struct SampleCount(AtomicF64);
-impl_time_unit!(SampleCount);
diff --git a/engine/time/time_sample_rate.rs b/engine/time/time_sample_rate.rs
deleted file mode 100644
index 40617728..00000000
--- a/engine/time/time_sample_rate.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use crate::*;
-
-/// Audio sample rate in Hz (samples per second)
-#[derive(Debug, Default)] pub struct SampleRate(AtomicF64);
-impl_time_unit!(SampleRate);
-impl SampleRate {
-    /// Return the duration of a sample in microseconds (floating)
-    #[inline] pub fn usec_per_sample (&self) -> f64 {
-        1_000_000f64 / self.get()
-    }
-    /// Return the duration of a sample in microseconds (floating)
-    #[inline] pub fn sample_per_usec (&self) -> f64 {
-        self.get() / 1_000_000f64
-    }
-    /// Convert a number of samples to microseconds (floating)
-    #[inline] pub fn samples_to_usec (&self, samples: f64) -> f64 {
-        self.usec_per_sample() * samples
-    }
-    /// Convert a number of microseconds to samples (floating)
-    #[inline] pub fn usecs_to_sample (&self, usecs:   f64) -> f64 {
-        self.sample_per_usec() * usecs
-    }
-}
diff --git a/engine/time/time_timebase.rs b/engine/time/time_timebase.rs
deleted file mode 100644
index 8843f95f..00000000
--- a/engine/time/time_timebase.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-use crate::*;
-
-/// Temporal resolutions: sample rate, tempo, MIDI pulses per quaver (beat)
-#[derive(Debug, Clone)]
-pub struct Timebase {
-    /// Audio samples per second
-    pub sr:  SampleRate,
-    /// MIDI beats per minute
-    pub bpm: BeatsPerMinute,
-    /// MIDI ticks per beat
-    pub ppq: PulsesPerQuaver,
-}
-
-impl Timebase {
-    /// Specify sample rate, BPM and PPQ
-    pub fn new (
-        s: impl Into<SampleRate>,
-        b: impl Into<BeatsPerMinute>,
-        p: impl Into<PulsesPerQuaver>
-    ) -> Self {
-        Self { sr: s.into(), bpm: b.into(), ppq: p.into() }
-    }
-    /// Iterate over ticks between start and end.
-    #[inline] pub fn pulses_between_samples (&self, start: usize, end: usize) -> TicksIterator {
-        TicksIterator { spp: self.samples_per_pulse(), sample: start, start, end }
-    }
-    /// Return the duration fo a beat in microseconds
-    #[inline] pub fn usec_per_beat (&self) -> f64 { 60_000_000f64 / self.bpm.get() }
-    /// Return the number of beats in a second
-    #[inline] pub fn beat_per_second (&self) -> f64 { self.bpm.get() / 60f64 }
-    /// Return the number of microseconds corresponding to a note of the given duration
-    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
-        4.0 * self.usec_per_beat() * num / den
-    }
-    /// Return duration of a pulse in microseconds (BPM-dependent)
-    #[inline] pub fn pulse_per_usec (&self) -> f64 { self.ppq.get() / self.usec_per_beat() }
-    /// Return duration of a pulse in microseconds (BPM-dependent)
-    #[inline] pub fn usec_per_pulse (&self) -> f64 { self.usec_per_beat() / self.ppq.get() }
-    /// Return number of pulses to which a number of microseconds corresponds (BPM-dependent)
-    #[inline] pub fn usecs_to_pulse (&self, usec: f64) -> f64 { usec * self.pulse_per_usec() }
-    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
-    #[inline] pub fn pulses_to_usec (&self, pulse: f64) -> f64 { pulse / self.usec_per_pulse() }
-    /// Return number of pulses in a second (BPM-dependent)
-    #[inline] pub fn pulses_per_second (&self) -> f64 { self.beat_per_second() * self.ppq.get() }
-    /// Return fraction of a pulse to which a sample corresponds (SR- and BPM-dependent)
-    #[inline] pub fn pulses_per_sample (&self) -> f64 {
-        self.usec_per_pulse() / self.sr.usec_per_sample()
-    }
-    /// Return number of samples in a pulse (SR- and BPM-dependent)
-    #[inline] pub fn samples_per_pulse (&self) -> f64 {
-        self.sr.get() / self.pulses_per_second()
-    }
-    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
-    #[inline] pub fn pulses_to_sample (&self, p: f64) -> f64 {
-        self.pulses_per_sample() * p
-    }
-    /// Convert a number of samples to a pulse number (SR- and BPM-dependent)
-    #[inline] pub fn samples_to_pulse (&self, s: f64) -> f64 {
-        s / self.pulses_per_sample()
-    }
-    /// Return the number of samples corresponding to a note of the given duration
-    #[inline] pub fn note_to_samples (&self, note: (f64, f64)) -> f64 {
-        self.usec_to_sample(self.note_to_usec(note))
-    }
-    /// Return the number of samples corresponding to the given number of microseconds
-    #[inline] pub fn usec_to_sample (&self, usec: f64) -> f64 {
-        usec * self.sr.get() / 1000f64
-    }
-    /// Return the quantized position of a moment in time given a step
-    #[inline] pub fn quantize (&self, step: (f64, f64), time: f64) -> (f64, f64) {
-        let step = self.note_to_usec(step);
-        (time / step, time % step)
-    }
-    /// Quantize a collection of events
-    #[inline] pub fn quantize_into <E: Iterator<Item=(f64, f64)> + Sized, T> (
-        &self, step: (f64, f64), events: E
-    ) -> Vec<(f64, f64)> {
-        events.map(|(time, event)|(self.quantize(step, time).0, event)).collect()
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 0
-    #[inline] pub fn format_beats_0 (&self, pulse: f64) -> Arc<str> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
-        format!("{}.{}.{pulses:02}", beats / 4, beats % 4).into()
-    }
-    /// Format a number of pulses into Beat.Bar starting from 0
-    #[inline] pub fn format_beats_0_short (&self, pulse: f64) -> Arc<str> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let beats = if ppq > 0 { pulse / ppq } else { 0 };
-        format!("{}.{}", beats / 4, beats % 4).into()
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
-    #[inline] pub fn format_beats_1 (&self, pulse: f64) -> Arc<str> {
-        let mut string = String::with_capacity(16);
-        self.format_beats_1_to(&mut string, pulse).expect("failed to format {pulse} into beat");
-        string.into()
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
-    #[inline] pub fn format_beats_1_to (&self, w: &mut impl std::fmt::Write, pulse: f64) -> Result<(), std::fmt::Error> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
-        write!(w, "{}.{}.{pulses:02}", beats / 4 + 1, beats % 4 + 1)
-    }
-    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
-    #[inline] pub fn format_beats_1_short (&self, pulse: f64) -> Arc<str> {
-        let pulse = pulse as usize;
-        let ppq   = self.ppq.get() as usize;
-        let beats = if ppq > 0 { pulse / ppq } else { 0 };
-        format!("{}.{}", beats / 4 + 1, beats % 4 + 1).into()
-    }
-}
-
-impl Default for Timebase {
-    fn default () -> Self { Self::new(48000f64, 150f64, DEFAULT_PPQ) }
-}
diff --git a/engine/time/time_unit.rs b/engine/time/time_unit.rs
deleted file mode 100644
index 46e218fd..00000000
--- a/engine/time/time_unit.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use crate::*;
-
-/// A unit of time, represented as an atomic 64-bit float.
-///
-/// According to https://stackoverflow.com/a/873367, as per IEEE754,
-/// every integer between 1 and 2^53 can be represented exactly.
-/// This should mean that, even at 192kHz sampling rate, over 1 year of audio
-/// can be clocked in microseconds with f64 without losing precision.
-pub trait TimeUnit: InteriorMutable<f64> {}
-
-/// Implement an arithmetic operation for a unit of time
-#[macro_export] macro_rules! impl_op {
-    ($T:ident, $Op:ident, $method:ident, |$a:ident,$b:ident|{$impl:expr}) => {
-        impl $Op<Self> for $T {
-            type Output = Self; #[inline] fn $method (self, other: Self) -> Self::Output {
-                let $a = self.get(); let $b = other.get(); Self($impl.into())
-            }
-        }
-        impl $Op<usize> for $T {
-            type Output = Self; #[inline] fn $method (self, other: usize) -> Self::Output {
-                let $a = self.get(); let $b = other as f64; Self($impl.into())
-            }
-        }
-        impl $Op<f64> for $T {
-            type Output = Self; #[inline] fn $method (self, other: f64) -> Self::Output {
-                let $a = self.get(); let $b = other; Self($impl.into())
-            }
-        }
-    }
-}
-
-/// Define and implement a unit of time
-#[macro_export] macro_rules! impl_time_unit {
-    ($T:ident) => {
-        impl Gettable<f64> for $T {
-            fn get (&self) -> f64 { self.0.load(Relaxed) }
-        }
-        impl InteriorMutable<f64> for $T {
-            fn set (&self, value: f64) -> f64 {
-                let old = self.get();
-                self.0.store(value, Relaxed);
-                old
-            }
-        }
-        impl TimeUnit for $T {}
-        impl_op!($T, Add, add, |a, b|{a + b});
-        impl_op!($T, Sub, sub, |a, b|{a - b});
-        impl_op!($T, Mul, mul, |a, b|{a * b});
-        impl_op!($T, Div, div, |a, b|{a / b});
-        impl_op!($T, Rem, rem, |a, b|{a % b});
-        impl From<f64>   for $T    { fn from (value: f64)   -> Self { Self(value.into()) } }
-        impl From<usize> for $T    { fn from (value: usize) -> Self { Self((value as f64).into()) } }
-        impl From<$T>    for f64   { fn from (value: $T)    -> Self { value.get() } }
-        impl From<$T>    for usize { fn from (value: $T)    -> Self { value.get() as usize } }
-        impl From<&$T>   for f64   { fn from (value: &$T)   -> Self { value.get() } }
-        impl From<&$T>   for usize { fn from (value: &$T)   -> Self { value.get() as usize } }
-        impl Clone for $T { fn clone (&self) -> Self { Self(self.get().into()) } }
-    }
-}
diff --git a/engine/time/time_usec.rs b/engine/time/time_usec.rs
deleted file mode 100644
index 3fc868f7..00000000
--- a/engine/time/time_usec.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::*;
-
-/// Timestamp in microseconds
-#[derive(Debug, Default)] pub struct Microsecond(AtomicF64);
-
-impl_time_unit!(Microsecond);
-
-impl Microsecond {
-    #[inline] pub fn format_msu (&self) -> Arc<str> {
-        let usecs              = self.get() as usize;
-        let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
-        let (minutes, seconds) = (seconds / 60, seconds % 60);
-        format!("{minutes}:{seconds:02}:{msecs:03}").into()
-    }
-}