record-tab UX: paged recordings list with one-click play in mixer

The Record tab now follows the shape the user asked for: recorder
header at the top (existing controls — profile, device, source,
name, ⏺/⏹ transport, live waveform/spectrum/level meters), and a
paged "Recordings" list below showing every take in the persistent
recordings filespace.

Each entry has a ▶ Play button that swaps the active project to
the recordings project, switches to the Mix tab, solos that take,
and starts playback in one click. The "main mixer" stays the
single playback engine — recordings just route through it.

Concrete changes:

src/ui/record.rs:
  • New show_recordings_list() function rendered under the existing
    header. Loads the recordings project fresh on every frame
    (cheap — manifest only, no WAVs decoded). Page size 10, newest
    first (track-NNN ids ascend, so reverse iteration). Page nav
    in the header row when total > one page.
  • Per-entry columns: ▶ button | name (hover = relative file path)
    | duration | mode (stereo / Ch N / mix) | recording profile |
    🗑 delete button. Empty state: "No recordings yet — hit ⏺ above".

src/app.rs:
  • New TinyBoothApp fields:
      - recordings_page: usize     — Record-tab list pagination
      - mix_autoplay_pending: bool — set by ▶ click, consumed by
        Mix-tab show() once the player has rebuilt
      - mix_autoplay_solo_idx: Option<usize> — the entry to solo
  • New methods on TinyBoothApp:
      - play_recording_in_mixer(idx) — swaps project, sets tab,
        queues autoplay flags. Re-loads from disk first to guard
        against a stale idx if the manifest changed between frames.
      - delete_recording(idx) — removes the WAV from disk, removes
        the Track row from the recordings manifest, saves. If the
        recordings project happens to be the active project too,
        also drops that Track row + invalidates the player.

src/ui/mix.rs:
  • Auto-play hand-off block right after the lazy player rebuild:
    when mix_autoplay_pending is set, solo the target track,
    rewind to 0, and start playback. Clears the flag.

Tests: 44 pass, clippy clean, fmt clean.

Workflow now end-to-end:

  1. User has a Suno project open.
  2. Switch to Record tab. Header shows the recorder controls;
     the recordings list shows every prior take.
  3. Hit ⏺ → ⏹. New entry appears at the top of the list.
  4. Click ▶ on any entry → mixer switches to Recordings, solos
     the take, plays it. Suno project is preserved (in Recents).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ophiocus

src/app.rs

@@ -117,6 +117,18 @@ pub struct TinyBoothApp {
     /// console deck (vs. the multitrack lane area).
     pub mix_console_fraction: f32,
 
+    /// Page index for the Record-tab "Recent recordings" list (10
+    /// entries per page, newest first). Survives tab switches.
+    pub recordings_page: usize,
+    /// When the user hits ▶ on a recording entry, we swap `project`
+    /// to the recordings project and queue this flag so the Mix-tab
+    /// view starts playback automatically on its next render. Cleared
+    /// once acted on. v0.4.0.
+    pub mix_autoplay_pending: bool,
+    /// Optional track index to solo on autoplay — the entry the user
+    /// actually clicked. `None` = autoplay without changing solos.
+    pub mix_autoplay_solo_idx: Option<usize>,
+
     // Self-update plumbing.
     pub update_state: UpdateState,
     pub update_error: Option<String>,
@@ -233,6 +245,9 @@ impl TinyBoothApp {
             import_conflict: None,
             recorder: crate::automation::Recorder::default(),
             mix_console_fraction: 0.42,
+            recordings_page: 0,
+            mix_autoplay_pending: false,
+            mix_autoplay_solo_idx: None,
             update_state: UpdateState::Checking,
             update_error: None,
             update_rx: Some(rx),
@@ -405,6 +420,79 @@ impl TinyBoothApp {
         }
     }
 
+    /// Send a recording to the main mixer for playback in one click:
+    /// swap `project` to the recordings project, switch to the Mix tab,
+    /// solo the selected take, and queue auto-play for the next Mix
+    /// render. The Mix-tab show() consumes the auto-play flags after
+    /// the player rebuilds itself for the new project.
+    ///
+    /// Called from the Record-tab recordings list ▶ buttons. `idx` is
+    /// the index in the recordings project's `tracks` list (loaded
+    /// fresh by the caller — we re-load here to guard against stale
+    /// indices if the file changed between frames).
+    pub fn play_recording_in_mixer(&mut self, idx: usize) {
+        let rec = match Project::open_or_create_recordings() {
+            Ok(p) => p,
+            Err(e) => {
+                self.status = Some(format!("could not open Recordings: {e:#}"));
+                return;
+            }
+        };
+        if idx >= rec.tracks.len() {
+            self.status = Some("recording entry no longer exists.".into());
+            return;
+        }
+        self.project = rec;
+        self.project_dirty = false;
+        self.player = None;
+        self.tab = Tab::Mix;
+        self.mix_autoplay_pending = true;
+        self.mix_autoplay_solo_idx = Some(idx);
+    }
+
+    /// Delete a recording by index in the recordings project's
+    /// `tracks` list. Removes the WAV from disk and the `Track` row
+    /// from the recordings manifest. Caller should refresh its view
+    /// of the recordings filespace afterward (the Record-tab list
+    /// re-loads on every frame, so just calling this is enough).
+    pub fn delete_recording(&mut self, idx: usize) {
+        let mut rec = match Project::open_or_create_recordings() {
+            Ok(p) => p,
+            Err(e) => {
+                self.status = Some(format!("could not open Recordings: {e:#}"));
+                return;
+            }
+        };
+        if idx >= rec.tracks.len() {
+            self.status = Some("recording entry no longer exists.".into());
+            return;
+        }
+        let removed = rec.tracks.remove(idx);
+        let abs = rec.root.join(&removed.file);
+        let _ = std::fs::remove_file(&abs);
+        match rec.save() {
+            Ok(()) => {
+                self.status = Some(format!("Deleted recording '{}'.", removed.name));
+                // If the user has the recordings project open as the
+                // active one, drop the player so it rebuilds without
+                // the deleted track on the next Mix visit.
+                if Config::recordings_root()
+                    .map(|root| self.project.root == root)
+                    .unwrap_or(false)
+                {
+                    // Reflect on the active project too.
+                    if let Some(pos) = self.project.tracks.iter().position(|t| t.id == removed.id) {
+                        self.project.tracks.remove(pos);
+                    }
+                    self.player = None;
+                }
+            }
+            Err(e) => {
+                self.status = Some(format!("recordings save error: {e:#}"));
+            }
+        }
+    }
+
     pub fn set_project_root(&mut self, root: PathBuf, name: String) {
         self.project = Project::new(name, root);
         self.project_dirty = true;

src/ui/mix.rs

@@ -69,6 +69,28 @@ pub fn show(app: &mut TinyBoothApp, ui: &mut egui::Ui) {
         return;
     }
 
+    // Auto-play hand-off from the Record-tab "▶" buttons. The Record
+    // tab swaps `app.project` to the recordings project and sets
+    // these flags; we consume them here once the player has rebuilt
+    // for the new project. Solo-and-play is the natural mode for
+    // "audition this single take through the main mixer".
+    if app.mix_autoplay_pending {
+        if let Some(player) = app.player.as_ref() {
+            if let Some(idx) = app.mix_autoplay_solo_idx.take() {
+                for (i, t) in player.state.tracks.iter().enumerate() {
+                    t.solo.store(i == idx, std::sync::atomic::Ordering::Relaxed);
+                }
+            }
+            // Position 0 on the freshly-loaded project.
+            player
+                .state
+                .position_frames
+                .store(0, std::sync::atomic::Ordering::Release);
+            player.state.set_play_state(PlayState::Playing);
+        }
+        app.mix_autoplay_pending = false;
+    }
+
     ui.separator();
 
     // Capture fader values for any armed strips while playing.

src/ui/record.rs

@@ -1,8 +1,14 @@
 use crate::app::TinyBoothApp;
 use crate::audio;
+use crate::project::Project;
 use crate::ui::viz;
 use eframe::egui;
 
+/// Page size for the recordings-list view. Small enough to fit on
+/// reasonable screen heights without scrolling, large enough to
+/// avoid constant page flipping after a few takes.
+const RECORDINGS_PAGE_SIZE: usize = 10;
+
 pub fn show(app: &mut TinyBoothApp, ui: &mut egui::Ui) {
     ui.heading("Record");
     ui.separator();
@@ -212,19 +218,139 @@ pub fn show(app: &mut TinyBoothApp, ui: &mut egui::Ui) {
 
     ui.add_space(8.0);
     ui.horizontal_wrapped(|ui| {
-        ui.label("Each take is saved into the persistent recordings filespace at");
+        ui.label("Each take saves to");
         let recordings_path = crate::config::Config::recordings_root()
             .map(|p| p.join("tracks").display().to_string())
             .unwrap_or_else(|| "(no platform config dir)".into());
         ui.monospace(recordings_path);
     });
-    ui.label(
-        egui::RichText::new(
-            "Recordings stay separate from any stem-mixing project. \
-             Use File → Open Recordings to review or mix them.",
-        )
-        .italics()
-        .weak(),
-    );
-    let _ = app; // keep arg used after the switch away from app.project
+
+    ui.add_space(10.0);
+    ui.separator();
+    show_recordings_list(app, ui);
+}
+
+/// "Recent recordings" — paged list of every take in the persistent
+/// recordings filespace, newest first. Each entry has play / delete
+/// actions; ▶ swaps the active project to the recordings project,
+/// switches to the Mix tab, solos that take, and starts playback.
+fn show_recordings_list(app: &mut TinyBoothApp, ui: &mut egui::Ui) {
+    // Load fresh from disk on every Record-tab frame. The recordings
+    // manifest is small (JSON only — WAV samples are not loaded by
+    // Project::load), so this costs microseconds and avoids any
+    // cache-staleness bugs around external edits / deletions.
+    let rec = match Project::open_or_create_recordings() {
+        Ok(p) => p,
+        Err(e) => {
+            ui.colored_label(
+                egui::Color32::LIGHT_RED,
+                format!("could not open recordings filespace: {e:#}"),
+            );
+            return;
+        }
+    };
+
+    let total = rec.tracks.len();
+    let total_pages = total.div_ceil(RECORDINGS_PAGE_SIZE).max(1);
+    if app.recordings_page >= total_pages {
+        app.recordings_page = total_pages - 1;
+    }
+
+    // Header row: title + count + page nav.
+    ui.horizontal(|ui| {
+        ui.heading(format!("Recordings ({total})"));
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if total_pages > 1 {
+                ui.add_enabled_ui(app.recordings_page + 1 < total_pages, |ui| {
+                    if ui.button("Next ▶").clicked() {
+                        app.recordings_page += 1;
+                    }
+                });
+                ui.label(format!(
+                    "page {} / {}",
+                    app.recordings_page + 1,
+                    total_pages
+                ));
+                ui.add_enabled_ui(app.recordings_page > 0, |ui| {
+                    if ui.button("◀ Prev").clicked() {
+                        app.recordings_page -= 1;
+                    }
+                });
+            }
+        });
+    });
+
+    if total == 0 {
+        ui.label(
+            egui::RichText::new("No recordings yet — hit ⏺ above to capture one.")
+                .italics()
+                .weak(),
+        );
+        return;
+    }
+
+    // Newest first: walk the project's tracks in reverse (track-NNN
+    // ids are minted ascending, so reverse iteration is newest-first).
+    // Pagination: skip and take across the reversed sequence.
+    let entries: Vec<(usize, &crate::project::Track)> =
+        rec.tracks.iter().enumerate().rev().collect();
+    let start = app.recordings_page * RECORDINGS_PAGE_SIZE;
+    let end = (start + RECORDINGS_PAGE_SIZE).min(entries.len());
+    let slice = &entries[start..end];
+
+    let mut click_play_idx: Option<usize> = None;
+    let mut click_delete_idx: Option<usize> = None;
+
+    egui::Grid::new("recordings_list_grid")
+        .num_columns(6)
+        .striped(true)
+        .spacing([10.0, 4.0])
+        .show(ui, |ui| {
+            ui.strong(""); // play
+            ui.strong("Name");
+            ui.strong("Duration");
+            ui.strong("Mode");
+            ui.strong("Profile");
+            ui.strong(""); // delete
+            ui.end_row();
+
+            for (idx, t) in slice {
+                if ui
+                    .button("▶")
+                    .on_hover_text("Play in mixer (switches to Mix tab)")
+                    .clicked()
+                {
+                    click_play_idx = Some(*idx);
+                }
+                ui.label(&t.name).on_hover_text(&t.file);
+                ui.label(format!("{:.1}s", t.duration_secs));
+                let mode = if t.stereo {
+                    "stereo".to_string()
+                } else {
+                    match t.channel_source {
+                        Some(c) => format!("Ch {}", c + 1),
+                        None => "mix".to_string(),
+                    }
+                };
+                ui.label(mode);
+                let prof = t.profile.as_ref().map(|p| p.name.as_str()).unwrap_or("—");
+                ui.label(prof);
+                if ui
+                    .button("🗑")
+                    .on_hover_text("Delete this take (removes the WAV)")
+                    .clicked()
+                {
+                    click_delete_idx = Some(*idx);
+                }
+                ui.end_row();
+            }
+        });
+
+    // Apply clicks AFTER the closure so we don't double-borrow `app`.
+    if let Some(i) = click_play_idx {
+        app.play_recording_in_mixer(i);
+    }
+    if let Some(i) = click_delete_idx {
+        app.delete_recording(i);
+    }
 }