@pro-gram/flux 1.6.2 → 1.6.4

package/README.md

@@ -44,7 +44,7 @@ Editor opens by default. File contains New, Open session, Save, Save as and Add
 
 The compact header puts navigation beside the logo. Grid and zoom share one toolbar, and playback/output selection share the bottom strip. Export settings and extra range/import options expand when needed, keeping more tracks visible on smaller displays.
 
-The editor supports 16 tracks, multiple audio regions, selected/all-track edits, mute/solo, levels, split, cut/copy/paste, undo/redo, saved `.dbedit` sessions and PCM/float mix export. Original audio stays unchanged.
+The editor supports 16 tracks, multiple audio regions, selected/all-track edits, a live mixer, split, cut/copy/paste, undo/redo, saved `.dbedit` sessions and PCM/float mix export. Original audio stays unchanged.
 
 Select audio, press **Ctrl+C**, press **Backspace** to delete that section, place the playhead and press **Ctrl+V**. Deleting preserves the timeline gap and the internal audio clipboard. Delete is also available as an editable alternate; Ctrl+X still cuts. Paste starts exactly at the playhead. The Cut/Copy/Paste toolbar buttons are removed.
 
@@ -56,6 +56,18 @@ Drag a clip's header to move it; selected groups retain their time/track offsets
 
 Moves, trims, slip, clip mute and fades are non-destructive and undoable. Fades affect playback and exported mixes; splitting/copying inside a fade preserves the original envelope. Escape cancels a clip drag. The editor's select/slip/fade modes and all default commands have editable keybindings.
 
+**Ctrl+Left / Ctrl+Right** moves the playhead to the nearest bar line strictly left/right using the project tempo and time signature. From an exact bar line, it moves to the previous/next bar. Playback continues when jumping within the audio; a paused jump stays silent. **Enter** returns to the beginning, and **Home** remains available. These bindings appear in Settings > Keybinds. Text fields retain their normal editing keys.
+
+### Mixer
+
+Open **Mixer** from the editor toolbar or **View > Mixer**. Each of the 16 tracks has a **−60 to +24 dB fader**, numeric gain entry, pan/stereo balance, mute and solo. A pinned master strip provides **−60 to +12 dB gain**, mute and stereo output metering. Changes take effect while playback continues, support undo/redo, save with the session and apply to exported mixes. Original audio stays unchanged.
+
+**File peak** shows the loaded source level independently of mixer gain. Choose **Before fader** to inspect incoming track levels, including muted tracks, or **After fader** to see the adjusted signal. Stereo peak readouts turn red at 0 dBFS and stay latched until cleared. **Monitor** controls listening volume only; it changes neither exports nor mixer readings.
+
+During recording, the registered strips show the selected raw input channels. Set capture gain on the input device. The mixer changes playback/export levels after recording; use hardware direct monitoring during capture.
+
+Scroll across the tracks while the master remains visible. Resize the panel, choose Side/Bottom, or collapse it to recover timeline space.
+
 ### Editor zoom
 
 The visible **- / + buttons and slider** zoom the timeline from a full-project overview to individual samples. **Ctrl+mouse wheel** zooms around the time under the pointer; **Shift+wheel** scrolls sideways. **Fit** shows the full project, and **Selection** fills the pane with the selected time range.
@@ -120,7 +132,8 @@ The Zoom R16 conversion preset writes classic 44.1 kHz 16/24-bit PCM WAV with sh
 | Save / save as | Ctrl+S / Ctrl+Shift+S |
 | Open / new session | Ctrl+O / Ctrl+N |
 | Import / export | Ctrl+I / Ctrl+E |
-| Start / end | Home / End |
+| Start / end | Enter or Home / End |
+| Previous / next bar | Ctrl+Left / Ctrl+Right |
 | Zoom in / out | Ctrl+= / Ctrl+- |
 | Fit project / selection | Ctrl+0 / Ctrl+Shift+0 |
 | Home / Editor / Converter / Player | Ctrl+1 / Ctrl+2 / Ctrl+3 / Ctrl+4 |

package/dependencies.json

@@ -10,6 +10,6 @@
     "sha256": "315a71e8942a445c903b2d1aedb703b64aab30f054e46199a2bac447d3d03cb2",
     "alternateSha256": "5564fa622f101dc27ea402c399c5b9b1e1e039b8771daf40b185dab9772adf38"
   },
-  "installerSha256": "1d54666d43c987d0200d70634cec75da7e7cc269aaee224603c5cc7139a2cb81",
+  "installerSha256": "c30e7d28feca44ba1116d70e2cd1a66443b5fbf2296d3a800ec59320d75c0a77",
   "bundledAssets": true
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pro-gram/flux",
-  "version": "1.6.2",
-  "description": "Flux: a 16-track Windows audio studio with native shared playback, float/PCM recording, clip editing tools, tempo grids and bundled audio codecs.",
+  "version": "1.6.4",
+  "description": "Flux: a 16-track Windows audio studio with a live mixer, float/PCM recording, clip editing, tempo grids and bundled audio codecs.",
   "license": "MIT",
   "author": "pro-gram",
   "os": [
@@ -50,7 +50,8 @@
     "flux",
     "tempo-grid",
     "beat-grid",
-    "snap-to-grid"
+    "snap-to-grid",
+    "mixer"
   ],
   "publishConfig": {
     "access": "public",

package/payload/DrumBuddy-Setup.exe

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/payload/DrumBuddy-Setup.exe
-size: 41726976 bytes
-sha256: 1d54666d43c987d0200d70634cec75da7e7cc269aaee224603c5cc7139a2cb81
+size: 41809920 bytes
+sha256: c30e7d28feca44ba1116d70e2cd1a66443b5fbf2296d3a800ec59320d75c0a77

package/source/AssetBootstrap.cs

@@ -21,7 +21,7 @@ namespace DrumBuddySetup
             if(File.Exists(target) && expected.Contains(Hash(target),StringComparer.OrdinalIgnoreCase))return target;
             string temporary=target+"."+Guid.NewGuid().ToString("N")+".partial";
             try {
-                using(var client=new WebClient()) { client.Headers[HttpRequestHeader.UserAgent]="DrumBuddy/1.6.2";client.DownloadFile(url,temporary); }
+                using(var client=new WebClient()) { client.Headers[HttpRequestHeader.UserAgent]="DrumBuddy/1.6.4";client.DownloadFile(url,temporary); }
                 if(!expected.Contains(Hash(temporary),StringComparer.OrdinalIgnoreCase))throw new IOException("A downloaded component failed its integrity check. Please retry setup or obtain a newer Drum Buddy release.");
                 File.Copy(temporary,target,true);return target;
             }finally { if(File.Exists(temporary))File.Delete(temporary); }

package/source/Audio Decoders.txt

@@ -1,4 +1,4 @@
-Flux 1.6.2 bundled FFmpeg audio decoders
+Flux 1.6.4 bundled FFmpeg audio decoders
 These decode imported files without Windows Media Player codecs.
 
  A..... = Audio

package/source/Build Instructions.txt

@@ -1,4 +1,4 @@
-FLUX SOURCE (DRUM BUDDY COMPATIBLE UPDATE)
+FLUX SOURCE
 
 Build on Windows 10/11 x64 with .NET Framework 4.8.
 No Visual Studio or .NET SDK is required: Build.ps1 uses the C# compiler
@@ -18,6 +18,7 @@ Verification:
   DrumBuddy.exe --tools-self-test "C:\path\to\new-tool-test-folder"
   DrumBuddy.exe --workspace-self-test "C:\path\to\new-editor-test-folder"
   DrumBuddy.exe --float-self-test "C:\path\to\new-float-test-folder"
+  DrumBuddy.exe --mixer-self-test "C:\path\to\new-mixer-test-folder"
   DrumBuddy.exe --recording-self-test "C:\path\to\new-recording-test-folder"
   DrumBuddy.exe --output-self-test "C:\path\to\new-output-test-folder"
   DrumBuddy.exe --editor-playback-self-test "C:\path\to\new-playback-test-folder"
@@ -44,6 +45,9 @@ Windows microphone buffer tests cover routing, saved samples and queue draining.
 The recording suite covers count-in timing/cancellation, frozen input and track
 routing, captured-frame playhead progress, recording visuals, take insertion
 and preserved originals using generated input buffers.
+The mixer suite checks live track/master gain, pan, mute/solo, source/output
+meters, session compatibility, undo, exported levels and dark/light layouts.
+It exercises native playback with the monitor volume at zero.
 The interface suite checks keybind capture, saved/unsaved settings, theme
 switching, integrated recording insertion and dark/light/compact layouts.
 The general-conversion suite checks original-rate float/PCM WAV, FLAC,

package/source/Build.ps1

@@ -101,6 +101,7 @@ $appArgs += @('EditorTools.cs','EditorToolInteractions.cs') | ForEach-Object { J
 $appArgs += Join-Path $PSScriptRoot 'EditorToolsTests.cs'
 $appArgs += Join-Path $PSScriptRoot 'EditorCompactLayout.cs'
 $appArgs += @('RecordingSession.cs','EditorRecording.cs','RecordingTests.cs') | ForEach-Object { Join-Path $PSScriptRoot $_ }
+$appArgs += @('TimelineMixer.cs','EditorMixer.cs','EditorMixerTests.cs') | ForEach-Object { Join-Path $PSScriptRoot $_ }
 & $compiler @appArgs
 if ($LASTEXITCODE -ne 0) { throw 'App compilation failed.' }
 $iconVersion = [Reflection.AssemblyName]::GetAssemblyName((Join-Path $package 'DrumBuddy.exe')).Version.ToString(3)

package/source/EditorCompactLayout.cs

@@ -26,7 +26,7 @@ namespace DrumBuddy
             play.MinWidth = 52;
             foreach (var button in transport.Children.OfType<Button>()) { button.FontSize = 12; button.MinHeight = 26; button.Padding = new Thickness(6, 2, 6, 2); button.Margin = new Thickness(0, 0, 4, 4); }
             positionText.FontSize = 12; positionText.Margin = new Thickness(3, 0, 9, 4); volume.Width = 80; volume.Margin = new Thickness(0, 0, 8, 4);
-            foreach (var text in transport.Children.OfType<TextBlock>().Where(t => t != positionText)) { text.FontSize = 12; if (text.Text.StartsWith("Listen")) text.Text = "Volume "; }
+            foreach (var text in transport.Children.OfType<TextBlock>().Where(t => t != positionText)) { text.FontSize = 12; if (text.Text.StartsWith("Monitor")) text.Text = "Monitor "; }
             bottom.Children.Remove(outputPicker); outputPicker.UseCompactLayout(); transport.Children.Add(outputPicker);
             selectionText.FontSize = 11; selectionText.MaxWidth = 220; selectionText.Margin = new Thickness(5, 0, 0, 4); transport.Children.Add(selectionText);
             foreach (var control in exports.Children.OfType<Control>()) { control.FontSize = 12; control.MinHeight = 26; control.Margin = new Thickness(0, 0, 8, 3); }

package/source/EditorMixer.cs

@@ -0,0 +1,267 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace DrumBuddy
+{
+    public sealed class StereoLevelMeter : FrameworkElement
+    {
+        private float left, right;
+        public StereoLevelMeter() { Width = 21; Height = 96; IsHitTestVisible = false; }
+        public static double Level(float sample) { return sample <= .001f ? 0 : Math.Max(0, Math.Min(1, (20 * Math.Log10(sample) + 60) / 60)); }
+        public void SetLevels(float l, float r) { left = Math.Max(0, l); right = Math.Max(0, r); InvalidateVisual(); }
+        protected override void OnRender(DrawingContext drawing)
+        {
+            base.OnRender(drawing); double width = (ActualWidth - 3) / 2, height = ActualHeight;
+            for (int channel = 0; channel < 2; channel++) {
+                double level = Level(channel == 0 ? left : right);
+                for (int segment = 0; segment < 24; segment++) {
+                    bool lit = (segment + 1) / 24.0 <= level;
+                    var color = !lit ? "#D6E1DF" : segment >= 23 ? "#B52C36" : segment >= 19 ? "#D0772C" : "#007A6B";
+                    drawing.PushOpacity(lit ? 1 : .3);
+                    drawing.DrawRectangle(WorkspaceUi.Color(color), null, new Rect(channel * (width + 3), height - (segment + 1) * height / 24, width, Math.Max(1, height / 24 - 1)));
+                    drawing.Pop();
+                }
+            }
+        }
+    }
+
+    public sealed partial class EditorView
+    {
+        private sealed class MixerStrip
+        {
+            public Border Frame;
+            public Button Name, Peak;
+            public TextBlock NameText;
+            public StereoLevelMeter Meter;
+            public Slider Gain, Pan;
+            public TextBox GainText;
+            public ToggleButton Mute, Solo;
+            public TextBlock Source;
+            public float Left, Right, Hold;
+            public DateTime HoldUntil;
+            public bool Over;
+        }
+        private DockablePane mixerPane;
+        private readonly MixerStrip[] mixerStrips = new MixerStrip[16];
+        private MixerStrip masterStrip;
+        private ScrollViewer mixerTrackScroll;
+        private ComboBox mixerMeterMode;
+        private TextBlock mixerContext;
+        private readonly ToggleButton[] headerMutes = new ToggleButton[16], headerSolos = new ToggleButton[16];
+        private readonly ComboBox[] headerLevels = new ComboBox[16];
+        private bool updatingMixer;
+        private string mixerUndoKey;
+        private DateTime mixerUndoUntil, inputMeterUntil;
+        private readonly float[] recordingMixerPeaks = new float[16];
+        private readonly float[] recordingMixerLeft = new float[16], recordingMixerRight = new float[16];
+        private int lastMixerSelection = -1;
+        public bool MixerVisible { get { return mixerPane != null && mixerPane.IsPaneVisible; } }
+        public void ToggleMixer() { ShowMixer(!MixerVisible); }
+        public void ShowMixer(bool visible)
+        {
+            mixerPane.ShowPane(visible);
+            if (visible) { if (mix != null) mix.DrainMeters(); RefreshMixerControls(); }
+        }
+        private FrameworkElement CreateMixer()
+        {
+            var root = new Grid { Margin = new Thickness(7, 0, 7, 5) };
+            root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto }); root.RowDefinitions.Add(new RowDefinition()); root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+            var toolbar = new WrapPanel(); root.Children.Add(toolbar);
+            mixerContext = WorkspaceUi.Text("Meters", 12); mixerContext.Margin = new Thickness(0, 0, 7, 4); toolbar.Children.Add(mixerContext);
+            mixerMeterMode = new ComboBox { ItemsSource = new[] { "After fader", "Before fader" }, SelectedIndex = 0, Width = 116, MinHeight = 25, FontSize = 11, Margin = new Thickness(0, 0, 8, 4) };
+            toolbar.Children.Add(mixerMeterMode);
+            mixerMeterMode.SelectionChanged += delegate { ResetMixerMeters(); };
+            var clear = WorkspaceUi.Button("Clear peaks", delegate { ResetMixerMeters(); }); clear.MinHeight = 25; clear.FontSize = 11; clear.Padding = new Thickness(6, 2, 6, 2); toolbar.Children.Add(clear);
+            var reset = WorkspaceUi.Button("Reset mix", delegate { ResetMixer(); }); reset.MinHeight = 25; reset.FontSize = 11; reset.Padding = new Thickness(6, 2, 6, 2); toolbar.Children.Add(reset);
+            var close = WorkspaceUi.Button("Hide mixer", delegate { ShowMixer(false); }); close.MinHeight = 25; close.FontSize = 11; close.Padding = new Thickness(6, 2, 6, 2); toolbar.Children.Add(close);
+            var channels = new Grid(); channels.ColumnDefinitions.Add(new ColumnDefinition()); channels.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(108) }); SetRow(channels, 1); root.Children.Add(channels);
+            var trackStrips = new StackPanel { Orientation = Orientation.Horizontal };
+            for (int i = 0; i < 16; i++) { mixerStrips[i] = CreateMixerStrip(i); trackStrips.Children.Add(mixerStrips[i].Frame); }
+            mixerTrackScroll = new ScrollViewer { Content = trackStrips, HorizontalScrollBarVisibility = ScrollBarVisibility.Auto, VerticalScrollBarVisibility = ScrollBarVisibility.Disabled };
+            channels.Children.Add(mixerTrackScroll);
+            masterStrip = CreateMixerStrip(-1); SetColumn(masterStrip.Frame, 1); channels.Children.Add(masterStrip.Frame);
+            var note = WorkspaceUi.Text("File peak shows the saved source level. Faders change playback/export; recording gain is set on the input device.", 11);
+            note.Margin = new Thickness(2, 3, 2, 0); SetRow(note, 2); root.Children.Add(note);
+            return root;
+        }
+        private MixerStrip CreateMixerStrip(int index)
+        {
+            bool master = index < 0; var strip = new MixerStrip();
+            var body = new StackPanel();
+            strip.Name = WorkspaceUi.Button(master ? "MASTER" : (index + 1).ToString("00"), delegate { if (!master && !IsBusy) { track = index; UpdateSelectionText(); BuildHeaders(); DrawCanvas(); } });
+            strip.Name.FontSize = 11; strip.Name.FontWeight = FontWeights.SemiBold; strip.Name.MinHeight = 25; strip.Name.Height = 25; strip.Name.Padding = new Thickness(2); strip.Name.Margin = new Thickness(0, 0, 0, 3);
+            strip.NameText = WorkspaceUi.Text(master ? "MASTER" : (index + 1).ToString("00"), 11); strip.NameText.MaxWidth = 80; strip.NameText.TextWrapping = TextWrapping.NoWrap; strip.NameText.TextTrimming = TextTrimming.CharacterEllipsis; strip.Name.Content = strip.NameText;
+            body.Children.Add(strip.Name);
+            strip.Source = WorkspaceUi.Text(master ? "Mix output" : "File peak —", 11); strip.Source.TextWrapping = TextWrapping.NoWrap; strip.Source.TextTrimming = TextTrimming.CharacterEllipsis;
+            strip.Source.Margin = new Thickness(0, 0, 0, 3); body.Children.Add(strip.Source);
+            var level = new Grid { Height = 96 }; level.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(27) }); level.ColumnDefinitions.Add(new ColumnDefinition()); level.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(21) }); body.Children.Add(level);
+            var scale = new Canvas { Height = 96 }; level.Children.Add(scale);
+            foreach (var mark in new[] { new { Text = master ? "+12" : "+24", Top = 0.0 }, new { Text = "0 dB", Top = 96.0 * (master ? 12 : 24) / (master ? 72 : 84) - 6 }, new { Text = "−60", Top = 83.0 } }) {
+                var label = WorkspaceUi.Text(mark.Text, 11); label.FontSize = 9; Canvas.SetTop(label, Math.Max(0, mark.Top)); scale.Children.Add(label);
+            }
+            strip.Gain = new Slider { Minimum = -60, Maximum = master ? 12 : 24, Value = 0, Orientation = Orientation.Vertical, SmallChange = 1, LargeChange = 3, TickFrequency = 1, IsSnapToTickEnabled = false, ToolTip = master ? "Master mix gain: playback and export, before the listening volume" : "Track gain: playback and export; original recording unchanged", Margin = new Thickness(1, 0, 1, 0) };
+            strip.Gain.Height = 96;
+            SetColumn(strip.Gain, 1); level.Children.Add(strip.Gain);
+            strip.Meter = new StereoLevelMeter(); SetColumn(strip.Meter, 2); level.Children.Add(strip.Meter);
+            strip.Gain.ValueChanged += delegate { if (!updatingMixer) SetMixerGain(index, Math.Round(strip.Gain.Value, 1)); };
+            strip.Gain.PreviewMouseLeftButtonUp += delegate { FinishMixerGesture(); }; strip.Gain.LostKeyboardFocus += delegate { FinishMixerGesture(); };
+            strip.GainText = new TextBox { Text = "0.0", FontSize = 11, FontFamily = new FontFamily("Consolas"), HorizontalContentAlignment = HorizontalAlignment.Center, Padding = new Thickness(2), MinHeight = 22, Height = 22, Margin = new Thickness(0, 3, 0, 2), ToolTip = "Gain in dB; enter 0 for unity" }; body.Children.Add(strip.GainText);
+            Action commit = delegate {
+                double value; if (!TempoGrid.TryTempo(strip.GainText.Text, out value) || double.IsNaN(value) || double.IsInfinity(value) || value < -60 || value > (master ? 12 : 24)) {
+                    status("Enter a mixer level between -60 and +" + (master ? 12 : 24) + " dB.");
+                } else SetMixerGain(index, value);
+                strip.GainText.Text = (master ? session.MasterGainDb : session.Tracks[index].GainDb).ToString("0.0", CultureInfo.InvariantCulture); FinishMixerGesture();
+            };
+            strip.GainText.LostKeyboardFocus += delegate { commit(); };
+            strip.GainText.TextChanged += delegate { double value; if (!updatingMixer && strip.GainText.IsKeyboardFocusWithin && TempoGrid.TryTempo(strip.GainText.Text, out value) && !double.IsNaN(value) && !double.IsInfinity(value) && value >= -60 && value <= (master ? 12 : 24)) SetMixerGain(index, value); };
+            strip.GainText.KeyDown += delegate(object sender, KeyEventArgs e) { if (e.Key == Key.Enter) { commit(); e.Handled = true; } };
+            strip.Pan = new Slider { Minimum = -1, Maximum = 1, Value = 0, SmallChange = .05, LargeChange = .2, Height = 19, ToolTip = master ? "The master is stereo" : "Pan / stereo balance. Centre preserves the original channel levels.", IsEnabled = !master, Margin = new Thickness(0, 1, 0, 2) }; body.Children.Add(strip.Pan);
+            strip.Pan.ValueChanged += delegate { if (!master && !updatingMixer) SetMixerPan(index, Math.Round(strip.Pan.Value, 2)); };
+            strip.Pan.PreviewMouseLeftButtonUp += delegate { FinishMixerGesture(); }; strip.Pan.LostKeyboardFocus += delegate { FinishMixerGesture(); };
+            var switches = new StackPanel { Orientation = Orientation.Horizontal, HorizontalAlignment = HorizontalAlignment.Center };
+            strip.Mute = new ToggleButton { Content = master ? "Mute" : "M", MinWidth = master ? 66 : 35, Height = 23, FontSize = 11, Margin = new Thickness(0, 0, 3, 0), ToolTip = master ? "Mute the master mix in playback and export" : "Mute this track" }; switches.Children.Add(strip.Mute);
+            strip.Mute.Click += delegate { if (!updatingMixer) SetMixerMute(index, strip.Mute.IsChecked == true); };
+            strip.Solo = new ToggleButton { Content = "S", Width = 35, Height = 23, FontSize = 11, ToolTip = "Solo this track", Visibility = master ? Visibility.Collapsed : Visibility.Visible }; switches.Children.Add(strip.Solo);
+            strip.Solo.Click += delegate { if (!master && !updatingMixer) SetMixerSolo(index, strip.Solo.IsChecked == true); }; body.Children.Add(switches);
+            strip.Peak = WorkspaceUi.Button("−∞ dBFS", delegate { ClearMixerPeak(strip); }); strip.Peak.FontSize = 10; strip.Peak.FontFamily = new FontFamily("Consolas"); strip.Peak.MinHeight = 22; strip.Peak.Height = 22; strip.Peak.Padding = new Thickness(1); strip.Peak.Margin = new Thickness(0, 2, 0, 0);
+            strip.Peak.ToolTip = "Peak hold in dBFS. Red means a level at or above 0 dBFS; click to clear. Float originals retain their headroom."; body.Children.Add(strip.Peak);
+            strip.Frame = new Border { Child = body, Width = 100, Padding = new Thickness(5), Margin = new Thickness(0, 0, 4, 0), Background = WorkspaceUi.Color(master ? "#E4ECEA" : "#F3F5F5"), BorderBrush = WorkspaceUi.Color("#D6E1DF"), BorderThickness = new Thickness(1), CornerRadius = new CornerRadius(3) };
+            return strip;
+        }
+        private void FinishMixerGesture() { mixerUndoKey = null; }
+        private bool ChangeMixer(Action change, string key, bool coalesce)
+        {
+            if (IsBusy) return false;
+            if (!coalesce || mixerUndoKey != key || DateTime.UtcNow > mixerUndoUntil) { undo.Push(session.Copy()); redo.Clear(); }
+            change(); dirty = true; mixerUndoKey = coalesce ? key : null; mixerUndoUntil = DateTime.UtcNow.AddMilliseconds(500);
+            if (mix != null) mix.UpdateMixer(session);
+            RefreshMixerControls(); RefreshHeaderMixerControls(); RefreshRegionHighlights();
+            undoButton.IsEnabled = true; redoButton.IsEnabled = false; title.Text = session.Name + " *";
+            return true;
+        }
+        private void SetMixerGain(int index, double value)
+        {
+            value = Math.Round(Math.Max(-60, Math.Min(index < 0 ? 12 : 24, value)), 1, MidpointRounding.AwayFromZero);
+            if ((index < 0 ? session.MasterGainDb : session.Tracks[index].GainDb) == value) return;
+            ChangeMixer(delegate { if (index < 0) session.MasterGainDb = value; else session.Tracks[index].GainDb = value; }, "gain:" + index, true);
+        }
+        private void SetMixerPan(int index, double value)
+        {
+            value = Math.Max(-1, Math.Min(1, value)); if (session.Tracks[index].Pan == value) return;
+            ChangeMixer(delegate { session.Tracks[index].Pan = value; }, "pan:" + index, true);
+        }
+        private void SetMixerMute(int index, bool value)
+        { if ((index < 0 ? session.MasterMuted : session.Tracks[index].Mute) != value) ChangeMixer(delegate { if (index < 0) session.MasterMuted = value; else session.Tracks[index].Mute = value; }, "mute:" + index, false); }
+        private void SetMixerSolo(int index, bool value)
+        { if (session.Tracks[index].Solo != value) ChangeMixer(delegate { session.Tracks[index].Solo = value; }, "solo:" + index, false); }
+        private void ResetMixer()
+        {
+            ChangeMixer(delegate { foreach (var state in session.Tracks) { state.GainDb = state.Pan = 0; state.Mute = state.Solo = false; } session.MasterGainDb = 0; session.MasterMuted = false; }, "reset", false);
+            ResetMixerMeters();
+        }
+        private void RefreshHeaderMixerControls()
+        {
+            bool previous = updating; updating = true;
+            try {
+                for (int i = 0; i < 16; i++) {
+                    if (headerMutes[i] == null) continue; var state = session.Tracks[i];
+                    headerMutes[i].IsChecked = state.Mute; headerSolos[i].IsChecked = state.Solo;
+                    var levels = new[] { -60.0, -24, -18, -12, -6, 0, 3, 6, 12, 18, 24, state.GainDb }.Distinct().OrderBy(v => v).ToArray();
+                    string selected = state.GainDb.ToString("0.#", CultureInfo.InvariantCulture) + " dB";
+                    if (!Equals(headerLevels[i].SelectedItem, selected)) { headerLevels[i].ItemsSource = levels.Select(v => v.ToString("0.#", CultureInfo.InvariantCulture) + " dB").ToArray(); headerLevels[i].SelectedItem = selected; }
+                }
+            }
+            finally { updating = previous; }
+        }
+        private void RefreshMixerControls()
+        {
+            if (masterStrip == null || !MixerVisible) return; updatingMixer = true;
+            try {
+                var filePeaks = new double[16]; var hasAudio = new bool[16];
+                foreach (var region in session.Regions) { Clip clip; if (assets.TryGetValue(region.Source, out clip)) { hasAudio[region.Track] = true; filePeaks[region.Track] = Math.Max(filePeaks[region.Track], clip.Peak); } }
+                for (int i = 0; i < 17; i++) {
+                    bool master = i == 16; var strip = master ? masterStrip : mixerStrips[i]; var state = master ? null : session.Tracks[i];
+                    strip.Gain.Value = master ? session.MasterGainDb : state.GainDb;
+                    if (!strip.GainText.IsKeyboardFocusWithin) strip.GainText.Text = strip.Gain.Value.ToString("0.0", CultureInfo.InvariantCulture);
+                    strip.Mute.IsChecked = master ? session.MasterMuted : state.Mute;
+                    if (!master) {
+                        strip.Pan.Value = state.Pan; strip.Solo.IsChecked = state.Solo;
+                        strip.NameText.Text = (i + 1).ToString("00") + (RecordingTrack(i) ? " IN " : " ") + state.Name; strip.Name.ToolTip = "Select track " + (i + 1) + ": " + state.Name;
+                        strip.Source.Text = filePeaks[i] > 0 ? "File " + (20 * Math.Log10(filePeaks[i])).ToString("0.0", CultureInfo.InvariantCulture) + " dBFS" : hasAudio[i] ? "File −∞ dBFS" : "File peak —";
+                        strip.Pan.ToolTip = state.Pan == 0 ? "Pan / balance: centre" : "Pan / balance: " + (state.Pan < 0 ? "L " : "R ") + (Math.Abs(state.Pan) * 100).ToString("0", CultureInfo.InvariantCulture) + "%";
+                        strip.Source.ToolTip = "Maximum peak in the original source file(s), before mixer gain. " + strip.Source.Text;
+                        strip.Frame.BorderBrush = WorkspaceUi.Color(RecordingTrack(i) ? "#B52C36" : i == track ? "#006D68" : "#D6E1DF");
+                    }
+                    strip.Gain.IsEnabled = strip.GainText.IsEnabled = strip.Mute.IsEnabled = !IsBusy;
+                    strip.Pan.IsEnabled = strip.Solo.IsEnabled = !master && !IsBusy;
+                    strip.Name.IsEnabled = master || !IsBusy;
+                }
+                mixerContext.Text = recording ? "Recording inputs" : "Meters"; mixerMeterMode.Visibility = recording ? Visibility.Collapsed : Visibility.Visible;
+                if (MixerVisible && lastMixerSelection != track) { mixerTrackScroll.ScrollToHorizontalOffset(Math.Max(0, track * 104 - 104)); lastMixerSelection = track; }
+            }
+            finally { updatingMixer = false; }
+        }
+        private static void ClearMixerPeak(MixerStrip strip) { strip.Over = false; strip.Hold = 0; strip.HoldUntil = DateTime.MinValue; }
+        private void ResetMixerMeters()
+        {
+            foreach (var strip in mixerStrips) if (strip != null) { ClearMixerPeak(strip); strip.Left = strip.Right = 0; strip.Meter.SetLevels(0, 0); }
+            if (masterStrip != null) { ClearMixerPeak(masterStrip); masterStrip.Left = masterStrip.Right = 0; masterStrip.Meter.SetLevels(0, 0); }
+            if (mix != null) mix.DrainMeters();
+        }
+        private void TickMixerMeters()
+        {
+            if (!MixerVisible || !mixerPane.IsExpanded) return;
+            var levels = mix == null ? new TimelineMeterLevels() : mix.DrainMeters(); bool source = mixerMeterMode.SelectedIndex == 1;
+            for (int i = 0; i < 16; i++) {
+                float left = source ? levels.SourceLeft[i] : levels.OutputLeft[i], right = source ? levels.SourceRight[i] : levels.OutputRight[i];
+                if (recording && DateTime.UtcNow < inputMeterUntil) { left = recordingMixerLeft[i]; right = recordingMixerRight[i]; }
+                UpdateMixerMeter(mixerStrips[i], left, right);
+            }
+            UpdateMixerMeter(masterStrip, levels.MasterLeft, levels.MasterRight);
+        }
+        private static void UpdateMixerMeter(MixerStrip strip, float left, float right)
+        {
+            strip.Left = Math.Max(left, strip.Left * .78f); strip.Right = Math.Max(right, strip.Right * .78f); strip.Meter.SetLevels(strip.Left, strip.Right);
+            float peak = Math.Max(left, right); strip.Over |= peak >= 1;
+            if (strip.Over) strip.Hold = Math.Max(strip.Hold, peak);
+            else if (peak >= strip.Hold || DateTime.UtcNow >= strip.HoldUntil) { strip.Hold = peak; strip.HoldUntil = DateTime.UtcNow.AddSeconds(1.5); }
+            strip.Peak.Content = strip.Hold > .000001 ? (20 * Math.Log10(strip.Hold)).ToString("0.0", CultureInfo.InvariantCulture) + " dBFS" : "−∞ dBFS";
+            strip.Peak.Foreground = WorkspaceUi.Color(strip.Over ? "#B52C36" : "#526771"); strip.Peak.FontWeight = strip.Over ? FontWeights.Bold : FontWeights.Normal;
+        }
+        public void UpdateRecordingInputMeters(float[] inputs)
+        {
+            Array.Clear(recordingMixerPeaks, 0, recordingMixerPeaks.Length);
+            Array.Clear(recordingMixerLeft, 0, recordingMixerLeft.Length); Array.Clear(recordingMixerRight, 0, recordingMixerRight.Length);
+            if (recordingPlan == null) return;
+            int first = recordingPlan.Mode > 0 ? recordingPlan.Mode - 1 : 0;
+            for (int i = 0; i < recordingPlan.InputChannels && first + i < inputs.Length; i++) {
+                int target = recordingPlan.FirstTrack + (recordingPlan.Mode == -1 ? i : 0);
+                recordingMixerPeaks[target] = Math.Max(recordingMixerPeaks[target], inputs[first + i]);
+                if (recordingPlan.Mode == 0) { if (i == 0) recordingMixerLeft[target] = inputs[first + i]; else recordingMixerRight[target] = inputs[first + i]; }
+                else recordingMixerLeft[target] = recordingMixerRight[target] = inputs[first + i];
+            }
+            inputMeterUntil = DateTime.UtcNow.AddMilliseconds(350);
+        }
+        internal DockablePane MixerPaneForTest { get { return mixerPane; } }
+        internal void MixerGainForTest(int index, double value) { FinishMixerGesture(); SetMixerGain(index, value); FinishMixerGesture(); }
+        internal void MixerPanForTest(int index, double value) { FinishMixerGesture(); SetMixerPan(index, value); FinishMixerGesture(); }
+        internal void MixerMuteForTest(int index, bool value) { SetMixerMute(index, value); }
+        internal void MixerSoloForTest(int index, bool value) { SetMixerSolo(index, value); }
+        internal void MixerMeterForTest(TimelineMeterLevels levels) { for (int i = 0; i < 16; i++) UpdateMixerMeter(mixerStrips[i], levels.OutputLeft[i], levels.OutputRight[i]); UpdateMixerMeter(masterStrip, levels.MasterLeft, levels.MasterRight); }
+        internal string MixerSourceForTest(int index) { return mixerStrips[index].Source.Text; }
+        internal string MixerPeakForTest(int index) { return (index < 0 ? masterStrip : mixerStrips[index]).Peak.Content.ToString(); }
+        internal float RecordingMixerPeakForTest(int index) { return recordingMixerPeaks[index]; }
+        internal float RecordingMixerLeftForTest(int index) { return recordingMixerLeft[index]; }
+        internal float RecordingMixerRightForTest(int index) { return recordingMixerRight[index]; }
+        internal Slider MixerFaderForTest(int index) { return (index < 0 ? masterStrip : mixerStrips[index]).Gain; }
+        internal ScrollViewer MixerScrollForTest { get { return mixerTrackScroll; } }
+        internal bool MasterControlsVisibleForTest { get { return masterStrip.Peak.TransformToAncestor(this).Transform(new Point(0, masterStrip.Peak.ActualHeight)).Y <= ActualHeight; } }
+        internal void ResetMixerForTest() { ResetMixer(); }
+    }
+}

package/source/EditorMixerTests.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+using System.Xml;
+
+namespace DrumBuddy
+{
+    public static class EditorMixerTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string message) { if (!value) throw new Exception(message); log.Add("PASS  " + message); }
+        private static bool Near(float actual, double expected) { return Math.Abs(actual - expected) < .00001; }
+        private static Clip Source(string root, string name, float left, float right, bool stereo)
+        {
+            string file = Path.Combine(root, name + ".wav"); int channels = stereo ? 2 : 1; var samples = new float[Audio.Rate * 8 * channels];
+            for (int f = 0; f < Audio.Rate * 8; f++) { samples[f * channels] = left; if (stereo) samples[f * channels + 1] = right; }
+            using (var writer = new FloatWaveWriter(file, channels, Audio.Rate)) writer.Write(samples, samples.Length, 1);
+            return Audio.Load(file, Path.Combine(root, "cache"), CancellationToken.None, null);
+        }
+        private static EditorSession State(params Clip[] clips)
+        {
+            var state = new EditorSession();
+            for (int i = 0; i < clips.Length; i++) { state.Tracks[i].Name = Path.GetFileNameWithoutExtension(clips[i].Name); state.Regions.Add(new TimelineRegion { Source = clips[i].Source, Name = state.Tracks[i].Name, Track = i, Length = Audio.Rate * 8L }); }
+            return state;
+        }
+        private static void RunUi(Func<Task> action)
+        {
+            var previous = SynchronizationContext.Current; var dispatcher = Dispatcher.CurrentDispatcher;
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(dispatcher));
+            try { var task = action(); var frame = new DispatcherFrame(); task.ContinueWith(delegate { dispatcher.BeginInvoke((Action)delegate { frame.Continue = false; }); }); if (!task.IsCompleted) Dispatcher.PushFrame(frame); task.GetAwaiter().GetResult(); }
+            finally { SynchronizationContext.SetSynchronizationContext(previous); }
+        }
+        private static void Picture(FrameworkElement view, string path, int width, int height)
+        {
+            view.Measure(new Size(width, height)); view.Arrange(new Rect(0, 0, width, height)); view.UpdateLayout();
+            var bitmap = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32); bitmap.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bitmap)); using (var file = File.Create(path)) encoder.Save(file);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "FluxMixer_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var old = InterfacePreferences.Current; string oldOutput = AudioOutputs.PreferredKey;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); ThemePalette.Apply(true); AudioOutputs.PreferredKey = "default";
+                var quiet = Source(root, "Quiet kick", .01f, .01f, false); var strong = Source(root, "Snare", .2f, .2f, false); var stereo = Source(root, "Stereo overhead", .25f, -.125f, true);
+                var decoded = new Dictionary<string, Clip> { { quiet.Source, quiet }, { strong.Source, strong }, { stereo.Source, stereo } };
+                byte[] original = File.ReadAllBytes(quiet.Source); var state = State(quiet, strong);
+                using (var mix = new TimelineMix(state, decoded)) {
+                    var samples = new float[128]; mix.Read(samples, 0, samples.Length); var meters = mix.DrainMeters();
+                    Check(samples.All(v => Near(v, .21)), "Keep unity track/master gain and centred pan identical to the existing mix");
+                    Check(Near(meters.SourceLeft[0], .01) && Near(meters.OutputLeft[0], .01) && Near(meters.MasterLeft, .21), "Measure actual pre-fader, post-fader and stereo master levels");
+                    var empty = mix.DrainMeters(); Check(empty.SourceLeft.All(v => v == 0) && empty.MasterLeft == 0 && mix.Peak > .2, "Drain UI meter peaks without resetting the export protection peak");
+                    long before = mix.Position; state.Tracks[0].GainDb = 6; state.Tracks[0].Pan = -1; state.Tracks[1].Mute = true; state.MasterGainDb = 3; mix.UpdateMixer(state);
+                    Check(mix.Position == before, "Apply live mixer controls without seeking or reopening source audio");
+                    mix.Read(samples, 0, samples.Length); meters = mix.DrainMeters();
+                    Check(Near(samples[0], .01 * Math.Pow(10, 9 / 20.0)) && samples.Where((v, i) => i % 2 == 1).All(v => v == 0), "Apply live gain, hard-left pan, track mute and master gain on the next audio block");
+                    Check(Near(meters.SourceLeft[1], .2) && meters.OutputLeft[1] == 0, "Keep pre-fader source metering available on a muted track");
+                    state.MasterMuted = true; mix.UpdateMixer(state); mix.Read(samples, 0, samples.Length); meters = mix.DrainMeters();
+                    Check(samples.All(v => v == 0) && meters.MasterLeft == 0 && meters.OutputLeft[0] > 0, "Master mute silences the mix while keeping channel/source diagnostics available");
+                }
+                state = State(quiet, strong); state.Tracks[0].Solo = true;
+                using (var mix = new TimelineMix(state, decoded)) {
+                    var samples = new float[32]; mix.Read(samples, 0, samples.Length); var meters = mix.DrainMeters();
+                    Check(samples.All(v => Near(v, .01)) && Near(meters.SourceLeft[1], .2) && meters.OutputLeft[1] == 0, "Solo isolates the chosen track while source meters still reveal the other signal");
+                }
+                var overlap = State(strong); overlap.Regions.Add(overlap.Regions[0].Copy());
+                using (var mix = new TimelineMix(overlap, decoded)) { mix.Read(new float[32], 0, 32); var meters = mix.DrainMeters(); Check(Near(meters.SourceLeft[0], .4) && Near(meters.OutputLeft[0], .4), "Meter the sum of overlapping clips on a track rather than their individual maximum"); }
+                var panned = State(stereo);
+                using (var mix = new TimelineMix(panned, decoded)) {
+                    var samples = new float[32]; mix.Read(samples, 0, samples.Length);
+                    Check(Near(samples[0], .25) && Near(samples[1], -.125), "Centred stereo balance preserves original left/right channel levels");
+                    panned.Tracks[0].Pan = 1; mix.UpdateMixer(panned); mix.Read(samples, 0, samples.Length);
+                    Check(samples.Where((v, i) => i % 2 == 0).All(v => v == 0) && Near(samples[1], -.125), "Hard-right stereo balance produces an exactly silent left channel");
+                }
+                var boosted = State(quiet); boosted.Tracks[0].GainDb = 24;
+                using (var mix = new TimelineMix(boosted, decoded)) { var samples = new float[8]; mix.Read(samples, 0, samples.Length); Check(Near(samples[0], .01 * Math.Pow(10, 24 / 20.0)), "Boost a quiet recording by up to 24 dB without rewriting its source"); }
+                boosted.MasterGainDb = 6; boosted.Tracks[0].Pan = -.5;
+                var clone = boosted.Copy(); clone.MasterGainDb = -6; clone.Tracks[0].Pan = 1;
+                Check(boosted.MasterGainDb == 6 && boosted.Tracks[0].Pan == -.5, "Keep master/pan settings independent in undo snapshots");
+                string saved = Path.Combine(root, "mixer.dbedit"); boosted.Save(saved); var reopened = EditorSession.Load(saved);
+                Check(reopened.MasterGainDb == 6 && reopened.Tracks[0].GainDb == 24 && reopened.Tracks[0].Pan == -.5, "Save and reopen mixer gain, pan and master settings in a session");
+                var xml = new XmlDocument(); xml.Load(saved); foreach (XmlNode node in xml.SelectNodes("/EditorSession/MasterGainDb|/EditorSession/MasterMuted|/EditorSession/Tracks/EditorTrack/Pan")) node.ParentNode.RemoveChild(node);
+                foreach (XmlNode node in xml.SelectNodes("/EditorSession/Tracks/EditorTrack/GainDb")) node.InnerText = "0";
+                string legacyPath = Path.Combine(root, "legacy.dbedit"); xml.Save(legacyPath); var legacy = EditorSession.Load(legacyPath);
+                Check(legacy.MasterGainDb == 0 && !legacy.MasterMuted && legacy.Tracks.All(t => t.Pan == 0), "Open older sessions with unity master gain and centred pan");
+                var bad = state.Copy(); bad.Tracks[0].Pan = double.NaN; bool rejected = false; try { bad.Validate(); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject non-finite pan positions before rendering or saving");
+                bad = state.Copy(); bad.MasterGainDb = 13; rejected = false; try { bad.Validate(); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject unsupported master gain");
+                var exportState = State(quiet); exportState.Tracks[0].GainDb = 6; exportState.MasterGainDb = 6; exportState.Tracks[0].Pan = -1;
+                string rendered = Path.Combine(root, "mixer-export.wav"); TimelineRender.Export(exportState, decoded, rendered, 32, false, 0, Audio.Rate, CancellationToken.None, null);
+                var renderedClip = Audio.Load(rendered, Path.Combine(root, "export-cache"), CancellationToken.None, null);
+                Check(Math.Abs(renderedClip.Peak - .01 * Math.Pow(10, 12 / 20.0)) < .00001, "Render track and master levels into float mix exports");
+                exportState = State(strong); exportState.Tracks[0].GainDb = 24; exportState.MasterGainDb = 12;
+                rendered = Path.Combine(root, "protected-mixer-export.wav"); TimelineRender.Export(exportState, decoded, rendered, 24, true, 0, Audio.Rate, CancellationToken.None, null);
+                Check(Math.Abs(Audio.Load(rendered, Path.Combine(root, "export-cache"), CancellationToken.None, null).PeakDb + 1) < .02, "Keep PCM clipping protection effective after track and master amplification");
+
+                var main = new MainWindow(Path.Combine(root, "preferences.xml"), true); main.OpenEditorForTest(); var editor = main.RecordingEditorForTest;
+                main.EditorFixtureForTest(State(quiet, strong), decoded); editor.ShowMixer(true);
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-initial-dark.png"), 1280, 800);
+                Check(editor.MixerVisible && main.NativeWindow.FindName("ViewMixer") != null, "Expose the integrated mixer from the editor and View menu");
+                Check(editor.MasterControlsVisibleForTest && editor.MixerScrollForTest.ComputedHorizontalScrollBarVisibility == Visibility.Visible, "Keep the master controls and track-scroll bar visible at the default mixer size");
+                editor.MixerScrollForTest.ScrollToRightEnd(); ((FrameworkElement)main.NativeWindow.Content).UpdateLayout();
+                Check(editor.MixerScrollForTest.HorizontalOffset > 0 && editor.MasterControlsVisibleForTest, "Reach the remaining tracks while keeping the master strip pinned in view");
+                editor.MixerScrollForTest.ScrollToLeftEnd(); ((FrameworkElement)main.NativeWindow.Content).UpdateLayout();
+                Check(editor.MixerSourceForTest(0).Contains("-40.0"), "Display the quiet recording's actual file peak independently of mixer gain");
+                var fader = editor.MixerFaderForTest(0); fader.ApplyTemplate(); var track = (Track)fader.Template.FindName("PART_Track", fader);
+                Check(track.Orientation == Orientation.Vertical && fader.ActualHeight >= 90 && track.ActualHeight >= 85, "Use a real vertical fader with its full travel in the dark theme");
+                double thumbBefore = track.Thumb.TransformToAncestor(fader).Transform(new Point()).Y;
+                fader.Value = 6; fader.Value = 7; main.NativeWindow.Content.AsFramework().UpdateLayout();
+                Check(editor.SessionForTest.Tracks[0].GainDb == 7 && track.Thumb.TransformToAncestor(fader).Transform(new Point()).Y < thumbBefore, "Moving the visible fader upward changes the real track gain");
+                RunUi(() => editor.ExecuteAction("undo")); Check(editor.SessionForTest.Tracks[0].GainDb == 0, "Coalesce one fader gesture into a single undo operation");
+                RunUi(() => editor.ExecuteAction("redo")); Check(editor.SessionForTest.Tracks[0].GainDb == 7, "Redo a mixer change");
+                editor.MixerPanForTest(0, -.5); editor.MixerGainForTest(-1, 3);
+                Check(editor.SessionForTest.Tracks[0].Pan == -.5 && editor.SessionForTest.MasterGainDb == 3, "Wire visible pan and master controls to the session model");
+                editor.ListenVolumeForTest(0); editor.PlayheadForTest(Audio.Rate);
+                RunUi(() => editor.ExecuteAction("play")); long playingAt = editor.PlayheadFrame;
+                editor.MixerGainForTest(0, 12); editor.MixerMuteForTest(1, true); editor.MixerSoloForTest(0, true);
+                RunUi(async delegate { await Task.Delay(150); });
+                Check(editor.PlayingForTest && editor.PlayheadFrame >= playingAt, "Adjust track gain, mute and solo while native playback continues at muted listening volume");
+                Check(!editor.MixerPeakForTest(-1).Contains("∞"), "Keep mix meters active even when the monitor listening slider is zero");
+                editor.Stop(); editor.ResetMixerForTest();
+                var plan = new RecordingPlan(new InputChoice { Name = "Test microphone" }, 2, 24, 48000, 2, 5, 0, new TempoGridOptions());
+                editor.BeginRecordingCountdown(plan); editor.UpdateRecordingInputMeters(new[] { .1f, .2f }); editor.MixerGainForTest(5, 24);
+                Check(editor.RecordingMixerPeakForTest(5) == .2f && editor.RecordingMixerPeakForTest(0) == 0 && editor.SessionForTest.Tracks[5].GainDb == 0, "Route the selected recording input to its registered mixer strip and lock playback-only faders during capture");
+                editor.SetRecordingState(false); plan = new RecordingPlan(new InputChoice { Name = "Stereo microphone" }, 0, 24, 48000, 2, 5, 0, new TempoGridOptions());
+                editor.BeginRecordingCountdown(plan); editor.UpdateRecordingInputMeters(new[] { .1f, .3f });
+                Check(editor.RecordingMixerLeftForTest(5) == .1f && editor.RecordingMixerRightForTest(5) == .3f, "Keep stereo recording input meters separate on a stereo destination track");
+                editor.SetRecordingState(false); editor.ShowRecordingOptions(false);
+                var display = State(quiet, strong); display.Tracks[0].Name = "Quiet kick"; display.Tracks[1].Name = "Snare";
+                for (int i = 2; i < 16; i++) { display.Tracks[i].Name = "Drum input " + (i + 1); display.Regions.Add(new TimelineRegion { Source = i % 2 == 0 ? quiet.Source : strong.Source, Name = display.Tracks[i].Name, Track = i, Length = Audio.Rate * 8L }); }
+                display.Tracks[0].GainDb = 18; display.Tracks[1].GainDb = 6; main.EditorFixtureForTest(display, decoded); editor.ShowMixer(true);
+                using (var mix = new TimelineMix(display, decoded)) { mix.Read(new float[512], 0, 512); editor.MixerMeterForTest(mix.DrainMeters()); }
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-dark.png"), 1280, 800);
+                Check(editor.MixerPeakForTest(-1).Contains("dBFS") && editor.SessionForTest.MasterGainDb == 0, "Display actual stereo master peaks while keeping the separate monitor level out of the saved mix");
+                main.SetThemeForTest(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-light.png"), 1280, 800);
+                main.SetThemeForTest(true); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-compact-dark.png"), 850, 560);
+                editor.MixerPaneForTest.SetExpanded(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-collapsed-dark.png"), 850, 560);
+                Check(!editor.MixerPaneForTest.IsExpanded && editor.TimelineHeightForTest > 180, "Collapse the mixer to restore timeline space on a compact window");
+                editor.ShowMixer(false); main.EditorFixtureForTest(new EditorSession(), new Dictionary<string, Clip>()); main.NativeWindow.Close();
+                Check(original.SequenceEqual(File.ReadAllBytes(quiet.Source)), "Keep the original quiet recording byte-for-byte unchanged through mixing, playback and exports");
+                File.WriteAllLines(Path.Combine(root, "mixer-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "mixer-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = old; AudioOutputs.PreferredKey = oldOutput; ThemePalette.Apply(old.Theme == "Dark"); }
+        }
+        private static FrameworkElement AsFramework(this object value) { return (FrameworkElement)value; }
+    }
+}

package/source/EditorPlaybackTests.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Windows;
+using System.Windows.Input;
 using System.Windows.Threading;
 using NAudio.Wave;
 
@@ -74,6 +75,27 @@ namespace DrumBuddy
                     owner.Content = null; owner.Close();
                     Check(original.SequenceEqual(File.ReadAllBytes(file)), "Preserve the original " + kind + " file through import and playback");
                 }
+                string navigationFile = Path.Combine(root, "bar-navigation.wav");
+                using (var writer = new FloatWaveWriter(navigationFile, 1, Audio.Rate)) writer.Write(new float[Audio.Rate * 12], Audio.Rate * 12, 1);
+                var navigationOwner = new Window(); ThemePalette.Install(navigationOwner);
+                using (var editor = new EditorView(navigationOwner, Path.Combine(root, "navigation-cache"), delegate(string text) { }, delegate { })) {
+                    navigationOwner.Content = editor; editor.ListenVolumeForTest(0);
+                    RunUi(() => editor.AddFiles(new[] { navigationFile })); editor.PlayheadForTest(Audio.Rate * 5L);
+                    RunUi(() => editor.ExecuteAction("play"));
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Left, ModifierKeys.Control)));
+                    Check(editor.PlayingForTest && Math.Abs(editor.PlayheadFrame - Audio.Rate * 4L) < Audio.Rate / 2, "Ctrl+Left seeks to the preceding bar while playback continues");
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Right, ModifierKeys.Control)));
+                    Check(editor.PlayingForTest && Math.Abs(editor.PlayheadFrame - Audio.Rate * 6L) < Audio.Rate / 2, "Ctrl+Right seeks to the following bar while playback continues");
+                    editor.Stop(); editor.PlayheadForTest(Audio.Rate * 5L);
+                    RunUi(() => editor.ExecuteAction("play")); RunUi(() => editor.ExecuteAction("play"));
+                    RunUi(() => editor.ExecuteAction("previousBar"));
+                    Check(!editor.PlayingForTest && editor.PlayheadFrame == Audio.Rate * 4L, "A bar jump from paused playback stays silent at the new position");
+                    RunUi(() => editor.ExecuteAction("play"));
+                    Check(editor.PlayingForTest && Math.Abs(editor.PlayheadFrame - Audio.Rate * 4L) < Audio.Rate / 2, "Resume after a paused bar jump starts at the new bar");
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Enter, ModifierKeys.None)));
+                    Check(!editor.PlayingForTest && editor.PlayheadFrame == 0, "Enter returns to the very beginning with the same transport behavior as Home");
+                }
+                navigationOwner.Content = null; navigationOwner.Close();
                 var picker = new AudioOutputPicker(delegate { }, delegate { });
                 AudioOutputs.PreferredKey = "windows:missing-output-for-test"; picker.RefreshForTest();
                 Check(picker.SelectionForTest == "default" && AudioOutputs.PreferredKey == "default", "Keep the displayed default and actual saved routing selection consistent after a device disappears");