@pro-gram/flux 1.6.0 → 1.6.2

package/NOTICE.txt

@@ -1,4 +1,4 @@
-Flux 1.6.0 - third-party components
+Flux 1.6.1 - third-party components
 
 FFmpeg 9.0.2, release essentials build by Gyan Doshi
 Used as a separate command-line decoding process.

package/README.md

@@ -7,10 +7,21 @@ Flux is a compact Windows audio studio with a 16-track editor/recorder, a Media
 Close the running audio application, then:
 
 ```powershell
-npm.cmd install -g @pro-gram/flux@latest
-flux.cmd
+npm install -g @pro-gram/flux@latest
+flux --setup
+flux
 ```
 
+**If npm skips setup or the Desktop shortcut is missing, run `flux --setup`.** This completes the desktop installation and creates the Flux Desktop and Start menu shortcuts. When npm allows the setup script, these steps happen automatically. An `allowScripts` notice can also appear after a successful installation. The first `flux` launch completes setup if it is needed.
+
+To allow Flux's setup script for one installation:
+
+```powershell
+npm install -g @pro-gram/flux@latest --allow-scripts=@pro-gram/flux
+```
+
+If PowerShell blocks the `npm.ps1` or `flux.ps1` launcher, use `npm.cmd` and `flux.cmd` for the same commands.
+
 Windows 10/11 x64 is supported. macOS is planned. Basic tools work locally without an account.
 
 ### Moving from Drum Buddy / FluxTempo
@@ -51,7 +62,9 @@ The visible **- / + buttons and slider** zoom the timeline from a full-project o
 
 **Ctrl+Plus / Ctrl+Minus** zoom (including Ctrl+= and numeric-keypad keys), **Ctrl+0** fits the project and **Ctrl+Shift+0** fits the selection. These shortcuts are editable in Settings > Keybinds. At close zoom, waveform detail is read from decoded audio in the background, preserving positive/negative peaks and float headroom. The ruler displays fractional seconds when a close-up contains no labeled beat. Zoom changes the view without changing audio, the playhead or undo history.
 
-Record options contains microphone/input channels, sample rate and PCM/float format. Recording saves original takes and inserts them at the starting playhead on the selected track; separate input channels use consecutive tracks. Use hardware direct monitoring. Software overdub latency alignment is not included.
+Record options contains microphone/input channels, sample rate and PCM/float format. **Record** or **R** reserves the selected track (consecutive tracks for separate input files) and shows a one-bar countdown at the project tempo and time signature. The countdown displays the destination tracks and selected input. Press Record again, Stop, or Escape to cancel it before capture starts.
+
+After the final beat, capture starts through the selected input. A red playhead, growing recording highlights and elapsed timer follow the audio actually received. **Stop & save** preserves the original take and inserts it at the registered starting point; the playhead stays at the end of the take. Bar lines display **1, 2, 3**; detailed beat labels remain available when zoomed in. Use hardware direct monitoring. Software overdub latency alignment is not included.
 
 Recording controls, converter output settings and Media Player gain have draggable dividers, Collapse/Show and Side/Bottom positioning.
 

package/bin/flux.js

@@ -10,7 +10,7 @@ const { needsUpdate } = require('../scripts/version.js');
   const arg = process.argv[2];
   if (arg === '--version' || arg === '-v') { console.log(pkg.version); return; }
   if (arg === '--help' || arg === '-h') {
-    console.log('Flux ' + pkg.version + ' for Windows\n\nflux             Open Flux\nflux --setup     Install or repair Flux\nflux --audio-diagnostics  Save an audio device report\nflux --version   Show the npm package version\n\nAudio: H5studio native 32-bit float recording; 16/24-bit PCM recording and export.\nWindows/Realtek/USB microphones use 16-bit PCM input.\nWorkspaces: PCM/float Media Player and 16-track timeline Editor with recording.\nTempo grid: BPM, time signatures, 1/1 to 1/256 subdivisions, triplets and independent grid/edge snapping.\nCtrl+C copies; Backspace deletes selection; Ctrl+V pastes at the playhead.\nDark/light themes, Converter and editable keybind settings.\nUpdate: close Flux, then npm.cmd install -g @pro-gram/flux@latest\nRun flux.cmd afterward to finish setup if npm skipped the install script.'); return;
+    console.log('Flux ' + pkg.version + ' for Windows\n\nflux             Open Flux\nflux --setup     Install or repair Flux\nflux --audio-diagnostics  Save an audio device report\nflux --version   Show the npm package version\n\nAudio: H5studio native 32-bit float recording; 16/24-bit PCM recording and export.\nWindows/Realtek/USB microphones use 16-bit PCM input.\nWorkspaces: PCM/float Media Player and 16-track timeline Editor with recording.\nRecording: one-bar visual count-in, reserved input tracks and a moving recording playhead.\nTempo grid: BPM, time signatures, 1/1 to 1/256 subdivisions, triplets and independent grid/edge snapping.\nCtrl+C copies; Backspace deletes selection; Ctrl+V pastes at the playhead.\nDark/light themes, Converter and editable keybind settings.\nUpdate: close Flux, then npm.cmd install -g @pro-gram/flux@latest\nRun flux.cmd afterward to finish setup if npm skipped the install script.'); return;
   }
   if (process.platform !== 'win32' || process.arch !== 'x64') throw new Error('Flux needs Windows x64.');
   const root = installRoot();

package/dependencies.json

@@ -1,15 +1,15 @@
-{
-  "ffmpeg": {
-    "url": "https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-9.0.2-essentials_build.zip",
-    "file": "ffmpeg-9.0.2.zip",
-    "sha256": "60f467265b1e312373dbcd92200c2618a74850f98d3d078e94296bb3fa2047ba"
-  },
-  "panel": {
-    "url": "https://zoomcorp.com/media/original_images/R16_list_0.png",
-    "file": "r16-panel.png",
-    "sha256": "315a71e8942a445c903b2d1aedb703b64aab30f054e46199a2bac447d3d03cb2",
-    "alternateSha256": "5564fa622f101dc27ea402c399c5b9b1e1e039b8771daf40b185dab9772adf38"
-  },
-  "installerSha256": "0a57d2459fdb2c5c0c2917df12ca907b47c5a966006d2680e9d160d16bdfed9c",
-  "bundledAssets": true
-}
+{
+  "ffmpeg": {
+    "url": "https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-9.0.2-essentials_build.zip",
+    "file": "ffmpeg-9.0.2.zip",
+    "sha256": "60f467265b1e312373dbcd92200c2618a74850f98d3d078e94296bb3fa2047ba"
+  },
+  "panel": {
+    "url": "https://zoomcorp.com/media/original_images/R16_list_0.png",
+    "file": "r16-panel.png",
+    "sha256": "315a71e8942a445c903b2d1aedb703b64aab30f054e46199a2bac447d3d03cb2",
+    "alternateSha256": "5564fa622f101dc27ea402c399c5b9b1e1e039b8771daf40b185dab9772adf38"
+  },
+  "installerSha256": "1d54666d43c987d0200d70634cec75da7e7cc269aaee224603c5cc7139a2cb81",
+  "bundledAssets": true
+}

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "@pro-gram/flux",
-  "version": "1.6.0",
-  "description": "Flux: a 16-track Windows audio studio with native shared playback, float/PCM recording, clip editing tools, tempo grids and bundled audio codecs.",
-  "license": "MIT",
-  "author": "pro-gram",
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "bin": {
-    "flux": "bin/flux.js"
-  },
-  "scripts": {
-    "postinstall": "node scripts/install.js",
-    "test": "node --test test/*.test.js"
-  },
-  "files": [
-    "bin/flux.js",
-    "scripts/",
-    "test/",
-    "payload/DrumBuddy-Setup.exe",
-    "dependencies.json",
-    "source/",
-    "LICENSE",
-    "NOTICE.txt"
-  ],
-  "keywords": [
-    "audio-editor",
-    "media-player",
-    "multitrack",
-    "zoom-h5studio",
-    "32-bit-float",
-    "pcm",
-    "zoom-r16",
-    "drums",
-    "audio",
-    "midi",
-    "wav",
-    "windows",
-    "recording",
-    "fluxtempo",
-    "realtek",
-    "audio-workstation",
-    "flux",
-    "tempo-grid",
-    "beat-grid",
-    "snap-to-grid"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "homepage": "https://fluxtempo.ca"
-}
+{
+  "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.",
+  "license": "MIT",
+  "author": "pro-gram",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "flux": "bin/flux.js"
+  },
+  "scripts": {
+    "postinstall": "echo If npm skips setup, run flux --setup && node scripts/install.js",
+    "test": "node --test test/*.test.js"
+  },
+  "files": [
+    "bin/flux.js",
+    "scripts/",
+    "test/",
+    "payload/DrumBuddy-Setup.exe",
+    "dependencies.json",
+    "source/",
+    "LICENSE",
+    "NOTICE.txt"
+  ],
+  "keywords": [
+    "audio-editor",
+    "media-player",
+    "multitrack",
+    "zoom-h5studio",
+    "32-bit-float",
+    "pcm",
+    "zoom-r16",
+    "drums",
+    "audio",
+    "midi",
+    "wav",
+    "windows",
+    "recording",
+    "fluxtempo",
+    "realtek",
+    "audio-workstation",
+    "flux",
+    "tempo-grid",
+    "beat-grid",
+    "snap-to-grid"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "homepage": "https://fluxtempo.ca"
+}

package/payload/DrumBuddy-Setup.exe

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

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.0";client.DownloadFile(url,temporary); }
+                using(var client=new WebClient()) { client.Headers[HttpRequestHeader.UserAgent]="DrumBuddy/1.6.2";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.0 bundled FFmpeg audio decoders
+Flux 1.6.2 bundled FFmpeg audio decoders
 These decode imported files without Windows Media Player codecs.
 
  A..... = Audio

package/source/Audio.cs

@@ -282,6 +282,7 @@ namespace DrumBuddy
         private Task writing;
         private readonly object gate = new object();
         private bool accepting;
+        private Action beginCapture;
         private int captureChannels, selectedInput, savedChannels;
         private bool separate, requireFloatInput;
         private readonly List<IRecordingWriter> writers = new List<IRecordingWriter>();
@@ -300,18 +301,27 @@ namespace DrumBuddy
 
         public void Start(InputChoice input, int mode, int bits, string folder, int rate)
         {
-            if (input.Driver != null) { Start(input.Driver, mode, bits, folder, rate); return; }
+            Prepare(input, mode, bits, folder, rate); BeginCapture();
+        }
+
+        // Prepare drivers on the UI thread before the count-in, without capturing audio
+        // or creating a take. ASIO COM objects must stay on this thread.
+        public void Prepare(InputChoice input, int mode, int bits, string folder, int rate)
+        {
+            if (input == null) throw new ArgumentNullException("input");
+            if (device != null || windowsInput != null || queue != null || beginCapture != null) throw new InvalidOperationException("This recorder is already prepared.");
+            if (input.Driver != null) { PrepareAsio(input.Driver, mode, bits, folder, rate); return; }
             try {
                 windowsChannels = AudioInputs.Channels(input);
                 var layout = CaptureLayout.Create(windowsChannels, mode);
+                captureChannels = layout.Channels;
                 windowsInput = new WaveInEvent { DeviceNumber = AudioInputs.Device(input), WaveFormat = new WaveFormat(rate, 16, windowsChannels), BufferMilliseconds = 50, NumberOfBuffers = 3 };
-                StartBuffered(layout, bits, folder, rate, false);
                 SourceFormat = "Windows 16-bit PCM"; SourceIsFloat = false;
                 windowsInput.DataAvailable += delegate(object sender, WaveInEventArgs e) { ProcessWindowsPcm(e.Buffer, e.BytesRecorded, windowsChannels); };
                 windowsInput.RecordingStopped += delegate(object sender, StoppedEventArgs e) {
                     lock (gate) { if (accepting && Error == null) Error = e.Exception ?? new IOException("The microphone stopped. Check its connection and Windows microphone permissions."); }
                 };
-                windowsInput.StartRecording();
+                beginCapture = delegate { StartBuffered(layout, bits, folder, rate, false); windowsInput.StartRecording(); };
             }
             catch { Stop(); throw; }
         }
@@ -341,19 +351,30 @@ namespace DrumBuddy
         }
 
         public void Start(string driver, int mode, int bits, string folder, int rate)
+        { Start(new InputChoice { Driver = driver, Name = driver }, mode, bits, folder, rate); }
+
+        public void BeginCapture()
+        {
+            var start = beginCapture;
+            if (start == null) throw new InvalidOperationException("Prepare a recording input before starting capture.");
+            beginCapture = null;
+            try { start(); } catch { Stop(); throw; }
+        }
+
+        private void PrepareAsio(string driver, int mode, int bits, string folder, int rate)
         {
             try {
                 device = new AsioOut(driver);
                 var layout = CaptureLayout.Create(device.DriverInputChannelCount, mode);
+                captureChannels = layout.Channels;
                 if (!device.IsSampleRateSupported(rate)) throw new IOException("This device does not support " + rate + " Hz in its current mode. Choose a supported rate, or set the recorder to Audio I/F Only.");
                 device.InputChannelOffset = layout.FirstInput;
                 device.InitRecordAndPlayback(null, layout.Channels, rate);
-                StartBuffered(layout, bits, folder, rate, bits == 32 && CaptureLayout.IsH5studio(driver));
                 device.AudioAvailable += Captured;
                 device.PlaybackStopped += delegate(object sender, StoppedEventArgs e) {
                     lock (gate) { if (accepting && Error == null) Error = e.Exception ?? new IOException("The recording device stopped sending audio. Check its USB connection."); }
                 };
-                device.Play();
+                beginCapture = delegate { StartBuffered(layout, bits, folder, rate, bits == 32 && CaptureLayout.IsH5studio(driver)); device.Play(); };
             }
             catch { Stop(); throw; }
         }
@@ -427,6 +448,7 @@ namespace DrumBuddy
         // Call on the UI thread: ASIO COM objects have thread affinity.
         public void Stop()
         {
+            beginCapture = null;
             lock (gate) accepting = false;
             if (windowsInput != null) {
                 try { windowsInput.StopRecording(); } catch (Exception ex) { if (Error == null) Error = ex; }

package/source/Build Instructions.txt

@@ -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 --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"
   DrumBuddy.exe --interface-self-test "C:\path\to\new-interface-test-folder"
@@ -40,6 +41,9 @@ exposed. The output suite queries microphone formats without opening capture.
 The editor-playback suite imports float/PCM files and exercises the actual
 editor transport with muted listening, plus native pause/resume/drain checks.
 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 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

@@ -100,6 +100,7 @@ $appArgs += Join-Path $PSScriptRoot 'EditorSelectionTests.cs'
 $appArgs += @('EditorTools.cs','EditorToolInteractions.cs') | ForEach-Object { Join-Path $PSScriptRoot $_ }
 $appArgs += Join-Path $PSScriptRoot 'EditorToolsTests.cs'
 $appArgs += Join-Path $PSScriptRoot 'EditorCompactLayout.cs'
+$appArgs += @('RecordingSession.cs','EditorRecording.cs','RecordingTests.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)
@@ -119,7 +120,11 @@ if (Test-Path -LiteralPath $payload) { Remove-Item -LiteralPath $payload }
 [IO.Compression.ZipFile]::CreateFromDirectory($package,$payload,[IO.Compression.CompressionLevel]::Optimal,$false)
 $manifest = Get-ChildItem -LiteralPath $package -Recurse -File | ForEach-Object {
     $relative = $_.FullName.Substring($package.Length + 1).Replace('\','/')
-    (Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256).Hash + '  ' + $relative
+    $payloadStream = [IO.File]::OpenRead($_.FullName)
+    $payloadHasher = [Security.Cryptography.SHA256]::Create()
+    try { $payloadHash = [BitConverter]::ToString($payloadHasher.ComputeHash($payloadStream)).Replace('-','') }
+    finally { $payloadStream.Dispose(); $payloadHasher.Dispose() }
+    $payloadHash + '  ' + $relative
 }
 $manifestPath = Join-Path $BuildFolder 'payload.sha256'
 [IO.File]::WriteAllLines($manifestPath,[string[]]$manifest,(New-Object Text.UTF8Encoding($false)))

package/source/EditorRecording.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Shapes;
+
+namespace DrumBuddy
+{
+    public sealed partial class EditorView
+    {
+        private Border recordingBanner;
+        private TextBlock countdownText, recordingHeadline, recordingRouting;
+        private RecordingPlan recordingPlan;
+        private bool captureRunning;
+        private readonly List<Rectangle> recordingOverlays = new List<Rectangle>();
+
+        private void InitializeRecordingFeedback(Panel tools)
+        {
+            var body = new DockPanel();
+            countdownText = WorkspaceUi.Text("", 30); countdownText.FontWeight = FontWeights.Bold;
+            countdownText.Foreground = WorkspaceUi.Color("#B52C36"); countdownText.MinWidth = 72;
+            countdownText.Margin = new Thickness(0, 0, 12, 0); countdownText.VerticalAlignment = VerticalAlignment.Center;
+            DockPanel.SetDock(countdownText, Dock.Left); body.Children.Add(countdownText);
+            var details = new StackPanel { VerticalAlignment = VerticalAlignment.Center }; body.Children.Add(details);
+            recordingHeadline = WorkspaceUi.Text("", 15); recordingHeadline.FontWeight = FontWeights.SemiBold; details.Children.Add(recordingHeadline);
+            recordingRouting = WorkspaceUi.Text("", 12); recordingRouting.Margin = new Thickness(0, 3, 0, 0); details.Children.Add(recordingRouting);
+            recordingBanner = new Border { Child = body, BorderBrush = WorkspaceUi.Color("#B52C36"), BorderThickness = new Thickness(2),
+                Background = WorkspaceUi.Color("#F3F5F5"), Padding = new Thickness(10, 6, 10, 6), Margin = new Thickness(0, 0, 0, 6), Visibility = Visibility.Collapsed };
+            tools.Children.Add(recordingBanner);
+        }
+        public RecordingPlan PlanRecording(InputChoice input, int mode, int bits, int rate, int availableInputs)
+        {
+            if (!CommitTempo()) throw new System.IO.IOException("Enter a valid project tempo before recording.");
+            return new RecordingPlan(input, mode, bits, rate, availableInputs, track, playhead, session.Grid);
+        }
+        public void BeginRecordingCountdown(RecordingPlan plan)
+        {
+            recordingPlan = plan; captureRunning = false; playhead = plan.AnchorFrame;
+            SetRecordingState(true); recordButton.Content = "Cancel count-in";
+            recordingBanner.Visibility = Visibility.Visible; countdownText.Text = "...";
+            recordingHeadline.Text = "Preparing recording input"; recordingRouting.Text = plan.Routing;
+            BuildHeaders(); DrawCanvas(); EnsurePlayheadVisible();
+            double top = RulerHeight + plan.FirstTrack * RowHeight, bottom = top + plan.TrackCount * RowHeight;
+            if (scroll.ViewportHeight > 0) {
+                if (top < scroll.VerticalOffset) scroll.ScrollToVerticalOffset(Math.Max(0, top - RowHeight));
+                else if (bottom > scroll.VerticalOffset + scroll.ViewportHeight) scroll.ScrollToVerticalOffset(Math.Max(0, bottom - scroll.ViewportHeight));
+            }
+        }
+        public void ShowCountdownBeat(int remaining)
+        {
+            countdownText.Text = remaining.ToString();
+            recordingHeadline.Text = "Recording in " + remaining + (remaining == 1 ? " beat" : " beats");
+        }
+        public void BeginRecordingCapture()
+        {
+            captureRunning = true; recordButton.Content = "Stop recording"; countdownText.Text = "REC";
+            recordingHeadline.Text = "Recording | 00:00.00"; BuildHeaders(); DrawCanvas();
+        }
+        public void UpdateRecordingProgress(long capturedFrames, int sampleRate)
+        {
+            if (!recording || recordingPlan == null) return;
+            playhead = recordingPlan.TimelineFrame(capturedFrames, sampleRate);
+            timeline.Width = Math.Max(timeline.Width, X(Math.Min(EditorSession.MaxFrame, playhead + Audio.Rate * 15L)));
+            recordingHeadline.Text = "Recording | " + WorkspaceUi.Clock(capturedFrames / (double)sampleRate);
+            UpdateRecordingOverlays(); UpdatePlayLine(); UpdateTransport();
+            if (DateTime.UtcNow >= manualViewUntil) EnsurePlayheadVisible();
+        }
+        public void ShowRecordingSaving()
+        { recordButton.Content = "Saving..."; recordButton.IsEnabled = false; countdownText.Text = "..."; recordingHeadline.Text = "Saving recording"; }
+        public void ShowRecordingError(string message)
+        {
+            recordingBanner.Visibility = Visibility.Visible; countdownText.Text = "!";
+            recordingHeadline.Text = "Could not record"; recordingRouting.Text = message;
+        }
+        private bool RecordingTrack(int index)
+        { return recording && recordingPlan != null && index >= recordingPlan.FirstTrack && index < recordingPlan.FirstTrack + recordingPlan.TrackCount; }
+        private void DrawRecordingOverlays()
+        {
+            recordingOverlays.Clear(); if (recordingPlan == null || !recording) return;
+            for (int i = 0; i < recordingPlan.TrackCount; i++) {
+                var rectangle = new Rectangle { Fill = WorkspaceUi.Color("#B52C36"), Opacity = .24, Stroke = WorkspaceUi.Color("#B52C36"),
+                    StrokeThickness = 2, Height = RowHeight - 6, IsHitTestVisible = false, Tag = "RecordingPreview" };
+                Canvas.SetTop(rectangle, RulerHeight + (recordingPlan.FirstTrack + i) * RowHeight + 3);
+                timeline.Children.Add(rectangle); recordingOverlays.Add(rectangle);
+            }
+            UpdateRecordingOverlays();
+        }
+        private void UpdateRecordingOverlays()
+        {
+            if (recordingPlan == null) return;
+            double left = Math.Max(scroll.HorizontalOffset, X(recordingPlan.AnchorFrame));
+            double right = Math.Min(scroll.HorizontalOffset + Math.Max(900, scroll.ViewportWidth), X(playhead));
+            foreach (var rectangle in recordingOverlays) {
+                Canvas.SetLeft(rectangle, left); rectangle.Width = Math.Max(2, right - left);
+                rectangle.Visibility = right >= left ? Visibility.Visible : Visibility.Collapsed;
+            }
+        }
+        internal string CountdownForTest { get { return countdownText.Text; } }
+        internal string RecordingHeadlineForTest { get { return recordingHeadline.Text; } }
+        internal string RoutingForTest { get { return recordingRouting.Text; } }
+        internal int[] ArmedTracksForTest { get { return Enumerable.Range(0, 16).Where(RecordingTrack).ToArray(); } }
+        internal int RecordingOverlaysForTest { get { return recordingOverlays.Count; } }
+    }
+}

package/source/EditorView.cs

@@ -119,6 +119,7 @@ namespace DrumBuddy
             separate = new CheckBox { Content = "Import files on separate tracks", IsChecked = true, FontSize = 14, Margin = new Thickness(4, 0, 0, 8), VerticalAlignment = VerticalAlignment.Center }; editing.Children.Add(separate);
             compactOptionsButton = WorkspaceUi.Button("Audio / export options", delegate { compactOptions = !compactOptions; UpdateCompactLayout(); }); editing.Children.Add(compactOptionsButton);
 
+            InitializeRecordingFeedback(tools);
             gridControls = new WrapPanel { Margin = new Thickness(0, 0, 0, 3) }; tools.Children.Add(gridControls);
             gridControls.Children.Add(WorkspaceUi.Text("BPM  ", 12));
             tempoBox = new TextBox { Width = 60, MinHeight = 28, Padding = new Thickness(5, 3, 5, 3), Margin = new Thickness(0, 0, 9, 5) }; gridControls.Children.Add(tempoBox);
@@ -202,7 +203,7 @@ namespace DrumBuddy
             var transport = new WrapPanel(); bottom.Children.Add(transport);
             play = WorkspaceUi.Button("Play", delegate { PlayPause(); }); play.MinWidth = 90; transport.Children.Add(play);
             transport.Children.Add(WorkspaceUi.Button("Stop", delegate { if (recording && StopRequested != null) StopRequested(); else { Stop(); UpdateTransport(); } }));
-            transport.Children.Add(WorkspaceUi.Button("To start", delegate { Stop(); playhead = 0; DrawCanvas(); EnsurePlayheadVisible(); }));
+            transport.Children.Add(WorkspaceUi.Button("To start", delegate { if (IsBusy) return; Stop(); playhead = 0; DrawCanvas(); EnsurePlayheadVisible(); }));
             positionText = WorkspaceUi.Text("00:00.00 / 00:00.00", 16); positionText.FontFamily = new FontFamily("Consolas"); positionText.Margin = new Thickness(0, 0, 14, 8); transport.Children.Add(positionText);
             transport.Children.Add(WorkspaceUi.Text("Listen volume  ", 14));
             volume = new Slider { Minimum = 0, Maximum = 100, Value = 75, Width = 120, Margin = new Thickness(0, 0, 16, 8), VerticalAlignment = VerticalAlignment.Center };
@@ -413,7 +414,8 @@ namespace DrumBuddy
             for (int i = 0; i < 16; i++) {
                 int index = i; var state = session.Tracks[i];
                 var panel = new StackPanel { Margin = new Thickness(7, 3, 7, 3) };
-                var name = WorkspaceUi.Text((i + 1).ToString("00") + "  " + state.Name, 14); name.TextWrapping = TextWrapping.NoWrap; name.TextTrimming = TextTrimming.CharacterEllipsis; name.FontWeight = FontWeights.SemiBold; panel.Children.Add(name);
+                var name = WorkspaceUi.Text((i + 1).ToString("00") + (RecordingTrack(i) ? (captureRunning ? " REC  " : " ARM  ") : "  ") + state.Name, 14); name.TextWrapping = TextWrapping.NoWrap; name.TextTrimming = TextTrimming.CharacterEllipsis; name.FontWeight = FontWeights.SemiBold; panel.Children.Add(name);
+                if (RecordingTrack(i)) name.Foreground = WorkspaceUi.Color("#B52C36");
                 var strip = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 3, 0, 0) }; panel.Children.Add(strip);
                 var mute = new ToggleButton { Content = "M", IsChecked = state.Mute, Width = 28, Height = 26, FontSize = 12, Margin = new Thickness(0, 0, 4, 0), ToolTip = "Mute track " + (i + 1) };
                 mute.Click += delegate { if (!updating) Change(delegate { session.Tracks[index].Mute = mute.IsChecked == true; return true; }, "Track mute changed."); }; strip.Children.Add(mute);
@@ -422,7 +424,7 @@ namespace DrumBuddy
                 var levels = new[] { -60.0, -24, -18, -12, -6, 0, 3, 6, 12, state.GainDb }.Distinct().OrderBy(v => v).ToArray();
                 var level = new ComboBox { ItemsSource = levels.Select(v => v.ToString("0.#", CultureInfo.InvariantCulture) + " dB").ToArray(), SelectedIndex = Array.IndexOf(levels, state.GainDb), Width = 102, MinHeight = 26, Height = 26, FontSize = 12, Padding = new Thickness(3, 0, 3, 0), ToolTip = "Track playback / export level" };
                 level.SelectionChanged += delegate { if (!updating && level.SelectedIndex >= 0) { double value = levels[level.SelectedIndex]; Change(delegate { session.Tracks[index].GainDb = value; return true; }, "Track level changed."); } }; strip.Children.Add(level);
-                var border = new Border { Height = RowHeight, BorderThickness = new Thickness(0, 0, 1, 1), BorderBrush = WorkspaceUi.Color("#D6E1DF"), Background = WorkspaceUi.Color(i == track ? "#DCEFEB" : "#EDF3F1"), Child = panel };
+                var border = new Border { Height = RowHeight, BorderThickness = new Thickness(RecordingTrack(i) ? 3 : 0, 0, 1, 1), BorderBrush = WorkspaceUi.Color(RecordingTrack(i) ? "#B52C36" : "#D6E1DF"), Background = WorkspaceUi.Color(i == track ? "#DCEFEB" : "#EDF3F1"), Child = panel };
                 border.PreviewMouseLeftButtonDown += delegate { if (!IsBusy && track != index) { track = index; UpdateSelectionText(); } };
                 border.MouseLeftButtonUp += delegate { BuildHeaders(); DrawCanvas(); };
                 headers.Children.Add(border);
@@ -451,6 +453,7 @@ namespace DrumBuddy
                 if (tick.Label != null) { if (x >= left && x < left + ViewportWidth) visibleLabel = true; var label = WorkspaceUi.Text(tick.Label, 11); label.IsHitTestVisible = false; Canvas.SetLeft(label, x + 4); Canvas.SetTop(label, 3); timeline.Children.Add(label); }
             }
             if (!session.Grid.MusicalRuler || !visibleLabel) DrawTimeRuler(left, right);
+            DrawRecordingOverlays();
             timeline.Children.Add(selectionOverlay); timeline.Children.Add(selectionStartLine); timeline.Children.Add(selectionEndLine); timeline.Children.Add(selectionStartHandle); timeline.Children.Add(selectionEndHandle); UpdateSelectionOverlay();
             playLine.Y1 = 0; playLine.Y2 = timeline.Height; timeline.Children.Add(playLine); UpdatePlayLine(); UpdateTransport();
             undoButton.IsEnabled = !IsBusy && undo.Count > 0; redoButton.IsEnabled = !IsBusy && redo.Count > 0;
@@ -517,7 +520,7 @@ namespace DrumBuddy
         }
         private void UpdatePlayLine() { playLine.X1 = playLine.X2 = X(playhead); }
         private void UpdateTransport()
-        { positionText.Text = WorkspaceUi.Clock(playhead / (double)Audio.Rate) + " / " + WorkspaceUi.Clock(session.End / (double)Audio.Rate); }
+        { positionText.Text = WorkspaceUi.Clock(playhead / (double)Audio.Rate) + " / " + WorkspaceUi.Clock(Math.Max(session.End, recording ? playhead : 0) / (double)Audio.Rate); }
         private void EnsurePlayheadVisible()
         { double x = X(playhead); if (x < scroll.HorizontalOffset || x > scroll.HorizontalOffset + scroll.ViewportWidth - 15) scroll.ScrollToHorizontalOffset(Math.Max(0, x - 30)); }
 
@@ -685,12 +688,14 @@ namespace DrumBuddy
         internal DockablePane RecordingPaneForTest { get { return recordingPane; } }
         public void SetRecordingState(bool active)
         {
-            recording = active; recordButton.Content = active ? "Stop recording" : "Record";
+            recording = active; recordButton.Content = active ? "Stop recording" : "Record"; recordButton.IsEnabled = true; play.IsEnabled = !active;
+            playLine.Stroke = WorkspaceUi.Color(active ? "#B52C36" : "#D0772C");
             RefreshGridToolbar();
             foreach (var button in fileButtons) button.IsEnabled = !active && operation == null;
             if (active) { Stop(); ShowRecordingOptions(true); }
+            else { recordingPlan = null; captureRunning = false; recordingBanner.Visibility = Visibility.Collapsed; BuildHeaders(); DrawCanvas(); }
         }
-        public async Task AddRecordedFiles(IEnumerable<string> paths, long at, int firstTrack)
+        public async Task AddRecordedFiles(IEnumerable<string> paths, long at, int firstTrack, bool keepPlayhead = false)
         {
             if (IsBusy) throw new IOException("Finish the editor operation before adding the take.");
             var files = paths.Where(File.Exists).ToArray();
@@ -706,7 +711,8 @@ namespace DrumBuddy
                     if (session.Tracks[index].Name == "Track " + (index + 1)) session.Tracks[index].Name = Path.GetFileNameWithoutExtension(clip.Name);
                 }
                 try { session.Validate(); } catch { session = before; throw; }
-                undo.Push(before); redo.Clear(); dirty = true; track = firstTrack; playhead = at;
+                undo.Push(before); redo.Clear(); dirty = true; track = firstTrack;
+                playhead = keepPlayhead ? Math.Min(EditorSession.MaxFrame, at + decoded.Max(c => (long)Math.Round(c.Duration * Audio.Rate))) : at;
             }
             finally { EndWork(); BuildHeaders(); DrawCanvas(); }
         }

package/source/Main.cs

@@ -20,7 +20,7 @@ using NAudio.Wave.SampleProviders;
 
 [assembly: AssemblyTitle("Flux")]
 [assembly: AssemblyDescription("PCM/float media player, 16-track audio editor, H5studio recording and R16 control")]
-[assembly: AssemblyVersion("1.6.0.0")]
+[assembly: AssemblyVersion("1.6.2.0")]
 
 namespace DrumBuddy
 {
@@ -79,6 +79,9 @@ namespace DrumBuddy
         private CancellationTokenSource cancel;
         private bool busy, closeWhenIdle, stopping;
         private Recorder recorder;
+        private CancellationTokenSource countIn;
+        private Task recordingStartup;
+        private bool captureActive;
         private readonly ProgressBar[] meters = new ProgressBar[8];
         private readonly TextBlock[] meterLabels = new TextBlock[8];
         private readonly DispatcherTimer timer;
@@ -161,7 +164,7 @@ namespace DrumBuddy
             C<RadioButton>("RecordFloat").Checked += delegate { ShowRecordingFormat(); };
             C<RadioButton>("Record16").Checked += delegate { ShowRecordingFormat(); };
             C<RadioButton>("Record24").Checked += delegate { ShowRecordingFormat(); };
-            C<Button>("StartRecordButton").Click += delegate { StartRecording(); };
+            C<Button>("StartRecordButton").Click += async delegate { await StartRecording(); };
             C<Button>("StopRecordButton").Click += async delegate { await StopRecording(true); };
             C<Button>("HelpButton").Click += delegate { ShowHelp(); };
             C<Button>("InstallDriversButton").Click += delegate { DriverSetup.ShowGuide(window); };
@@ -184,6 +187,7 @@ namespace DrumBuddy
                 e.Handled = true;
             };
             window.Closing += async delegate(object sender, System.ComponentModel.CancelEventArgs e) {
+                if (countIn != null) { e.Cancel = true; await StopRecording(false); window.Close(); return; }
                 if (recorder != null) {
                     e.Cancel = true;
                     if (stopping) return;
@@ -244,6 +248,11 @@ namespace DrumBuddy
         public void Show() { window.Show(); }
         public Window NativeWindow { get { return window; } }
         internal void OpenEditorForTest() { OpenWorkspace(true); }
+        internal Task StartRecordingForTest() { return StartRecording(); }
+        internal Task StopRecordingForTest() { return StopRecording(true); }
+        internal Task RecordingTickForTest() { return Tick(); }
+        internal bool RecordingBusyForTest { get { return recorder != null || countIn != null; } }
+        internal EditorView RecordingEditorForTest { get { return editorView; } }
         internal void OpenHomeForTest() { OpenHome(); }
         internal void EditorFixtureForTest(EditorSession session, IDictionary<string, Clip> clips) { editorView.SetForTest(session, clips); editorView.ShowSelectionForTest(Audio.Rate, Audio.Rate * 4L); }
         internal void RecordingPanelForTest()
@@ -291,7 +300,7 @@ namespace DrumBuddy
                 editorView = new EditorView(window, System.IO.Path.Combine(cache, "editor"), Status, delegate { if (mediaPlayerView != null) mediaPlayerView.Stop(); });
                 C<Grid>("EditorHost").Children.Add(editorView);
                 var panel = C<StackPanel>("RecordPage"); var parent = panel.Parent as Panel; if (parent != null) parent.Children.Remove(panel);
-                panel.Visibility = Visibility.Visible; editorView.AttachRecordingPanel(panel); editorView.RecordRequested = async delegate { if (recorder == null) StartRecording(); else await StopRecording(true); };
+                panel.Visibility = Visibility.Visible; editorView.AttachRecordingPanel(panel); editorView.RecordRequested = async delegate { if (recorder == null) await StartRecording(); else await StopRecording(true); };
                 editorView.StopRequested = async delegate { if (recorder != null) await StopRecording(true); };
                 editorView.RecordingOptionsRequested = delegate { var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice; if (input != null && configuredDriver != input.Key && recorder == null) ConfigureRecordingDevice(); };
                 editorView.GridSettingsRequested = delegate { OpenSettings("timeline"); };
@@ -450,6 +459,7 @@ namespace DrumBuddy
         private async void HandleInterfaceKey(object sender, System.Windows.Input.KeyEventArgs e)
         {
             var key = e.Key == System.Windows.Input.Key.System ? e.SystemKey : e.Key;
+            if (key == System.Windows.Input.Key.Escape && countIn != null) { e.Handled = true; await StopRecording(true); return; }
             if (key == System.Windows.Input.Key.Escape && workspace == 3 && editorView != null && editorView.HandleKey(e)) { e.Handled = true; return; }
             string action = InterfacePreferences.Resolve(key, System.Windows.Input.Keyboard.Modifiers);
             if (action == null) return;
@@ -472,7 +482,7 @@ namespace DrumBuddy
                 case "keybinds": OpenSettings("keybinds"); return;
                 case "control": C<Button>("ControlTab").RaiseEvent(new RoutedEventArgs(Button.ClickEvent)); return;
                 case "recordOptions": if (workspace != 3) OpenWorkspace(true); if (editorView != null) editorView.ShowRecordingOptions(true); return;
-                case "record": if (recorder != null) await StopRecording(true); else StartRecording(); return;
+                case "record": if (recorder != null) await StopRecording(true); else await StartRecording(); return;
                 case "play": if (recorder != null) { await StopRecording(true); return; } break;
                 case "stop": if (recorder != null) { await StopRecording(true); return; } break;
             }
@@ -610,70 +620,112 @@ namespace DrumBuddy
             }
             finally { configuringCapture = false; }
         }
-        private async void StartRecording()
+        private Task StartRecording()
         {
-            if (busy || recorder != null) return;
+            if (busy || recorder != null || stopping) return Task.FromResult(0);
+            recordingStartup = StartRecordingCore(); return recordingStartup;
+        }
+        private void LockRecordingControls(bool locked)
+        {
+            foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = !locked;
+            if (!locked) C<Button>("StartRecordButton").IsEnabled = C<ComboBox>("InputDevice").SelectedItem != null;
+            C<Button>("StopRecordButton").IsEnabled = locked;
+        }
+        private async Task StartRecordingCore()
+        {
+            if (workspace != 3 || editorView == null) OpenWorkspace(true);
+            if (editorView == null || editorView.IsBusy) { Status("Finish the editor task before recording."); return; }
             var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
-            if (input == null) { Status("Choose a recording input under Audio devices or Record drums, then click Refresh."); return; }
+            if (input == null) { editorView.ShowRecordingOptions(true); editorView.ShowRecordingError("Choose a recording input under Audio devices or Record options, then click Refresh."); return; }
             if (configuredDriver != input.Key) ConfigureRecordingDevice();
-            if (!C<Button>("StartRecordButton").IsEnabled) { Status("Choose a ready recording input in Record options."); return; }
-            string driver = input.Name;
-            
-            int mode = ((ModeChoice)C<ComboBox>("InputMode").SelectedItem).Mode;
+            if (!C<Button>("StartRecordButton").IsEnabled) { editorView.ShowRecordingOptions(true); editorView.ShowRecordingError(C<TextBlock>("CaptureFormatText").Text); return; }
+            var mode = C<ComboBox>("InputMode").SelectedItem as ModeChoice;
+            var rate = C<ComboBox>("RecordRate").SelectedItem as RateChoice;
+            if (mode == null || rate == null) { editorView.ShowRecordingError("Choose input channels and a sample rate in Record options."); return; }
             int bits = C<RadioButton>("RecordFloat").IsChecked == true ? 32 : C<RadioButton>("Record16").IsChecked == true ? 16 : 24;
-            var rateChoice = C<ComboBox>("RecordRate").SelectedItem as RateChoice;
-            if (rateChoice == null) { Status("Choose a sample rate before recording."); return; }
-            if (editorView == null) OpenWorkspace(true);
-            if (editorView == null || editorView.IsBusy) { Status("Finish the editor task before recording."); return; }
-            int files = mode == -1 ? configuredInputChannels : 1;
-            StopWorkspaces();
-            recordingTrack = editorView.SelectedTrack; recordingAnchor = editorView.PlayheadFrame;
-            if (recordingTrack + files > 16) { Status("Select an earlier track so all recording channels fit within the 16-track timeline."); return; }
-            string folder = System.IO.Path.Combine(prefs.RecordFolder,"Take_" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff",CultureInfo.InvariantCulture));
-            recorder = new Recorder();
-            Exception startError = null;
+            StopWorkspaces(); RecordingPlan plan;
+            try { plan = editorView.PlanRecording(input, mode.Mode, bits, rate.Rate, configuredInputChannels); }
+            catch (Exception ex) { editorView.ShowRecordingError(ex.Message); return; }
+            recordingTrack = plan.FirstTrack; recordingAnchor = plan.AnchorFrame;
+            string folder = System.IO.Path.Combine(prefs.RecordFolder, "Take_" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff", CultureInfo.InvariantCulture) + "_" + Guid.NewGuid().ToString("N").Substring(0, 6));
+            var capture = new Recorder(); recorder = capture; captureActive = false;
+            var countdown = new CancellationTokenSource(); countIn = countdown;
+            LockRecordingControls(true); C<Button>("StopRecordButton").Content = "Cancel count-in";
+            C<TextBlock>("RecordTime").Text = "00:00.00";
+            foreach (var meter in meters) meter.Value = 0;
+            C<TextBlock>("RecordingState").Text = "Preparing input"; C<TextBlock>("RecordingState").Foreground = Brush("#B52C36");
+            editorView.BeginRecordingCountdown(plan);
+            Status("Preparing " + plan.Routing);
+            Exception startError = null; bool cancelled = false;
             try {
-                Status("Connecting to " + driver + "…");
-                recorder.Start(input,mode,bits,folder,rateChoice.Rate); captureStarted = DateTime.UtcNow;
-                editorView.SetRecordingState(true);
-                foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = false;
-                C<Button>("StopRecordButton").IsEnabled = true;
-                C<TextBlock>("RecordingState").Text = "● Recording"; C<TextBlock>("RecordingState").Foreground = Brush("#B52C36");
-                Status("Recording. Click Stop & save when you finish.");
+                // Let the armed tracks and connecting feedback render before a driver call.
+                await window.Dispatcher.InvokeAsync((Action)delegate { }, DispatcherPriority.Background);
+                countdown.Token.ThrowIfCancellationRequested();
+                capture.Prepare(plan.Input, plan.Mode, plan.Bits, folder, plan.SampleRate);
+                if (capture.ChannelCount != plan.InputChannels) throw new IOException("The device's input layout changed. Refresh Record options, check the destination tracks, and try again.");
+                await RecordingCountdown.Run(plan.Beats, plan.BeatSeconds, delegate(int remaining) {
+                    editorView.ShowCountdownBeat(remaining);
+                    C<TextBlock>("RecordingState").Text = "Recording in " + remaining;
+                    C<TextBlock>("RecordTime").Text = remaining.ToString(CultureInfo.InvariantCulture);
+                    Status("Count-in: " + remaining + " | " + plan.Routing + " | Stop or Escape cancels.");
+                }, countdown.Token);
+                countdown.Token.ThrowIfCancellationRequested();
+                capture.BeginCapture(); captureStarted = DateTime.UtcNow; captureActive = true;
+                editorView.BeginRecordingCapture();
+                C<Button>("StopRecordButton").Content = "Stop & save";
+                C<TextBlock>("RecordingState").Text = "Recording"; C<TextBlock>("RecordTime").Text = "00:00.00";
+                Status("Recording | " + plan.Routing + " | Click Stop & save when you finish.");
             }
+            catch (OperationCanceledException) { cancelled = true; }
             catch (Exception ex) { startError = ex; }
-            if (startError != null) {
-                if (editorView != null) editorView.SetRecordingState(false);
-                Recorder failed = recorder; recorder = null; failed.Stop(); await failed.Finish();
-                // Keep any partial audio from a failed start; never delete a take.
-                Status("Could not start recording: " + startError.Message + " Check Audio Interface mode and close other audio apps.");
-                RefreshDevices();
+            finally { if (ReferenceEquals(countIn, countdown)) countIn = null; countdown.Dispose(); }
+            if (startError == null && !cancelled) return;
+            captureActive = false; capture.Stop(); await capture.Finish();
+            recorder = null; editorView.SetRecordingState(false); LockRecordingControls(false);
+            C<Button>("StopRecordButton").Content = "Stop & save";
+            C<TextBlock>("RecordTime").Text = "00:00.00";
+            C<TextBlock>("RecordingState").Text = cancelled ? "Count-in cancelled" : "Could not start recording";
+            if (cancelled) Status("Count-in cancelled. No recording was started.");
+            else {
+                editorView.ShowRecordingError(startError.Message);
+                Status("Could not start recording: " + startError.Message + " Check the selected input and close other audio apps.");
             }
         }
         private async Task StopRecording(bool addFiles)
         {
+            if (countIn != null) {
+                var startup = recordingStartup; countIn.Cancel(); if (startup != null) await startup; return;
+            }
             if (recorder == null || stopping) return;
-            stopping = true; C<Button>("StopRecordButton").IsEnabled = false;
+            stopping = true; captureActive = false; C<Button>("StopRecordButton").IsEnabled = false;
             Recorder finished = recorder;
-            Status("Saving your recording…");
-            finished.Stop(); await finished.Finish(); recorder = null;
+            Status("Saving your recording...");
+            finished.Stop();
+            long frames = Interlocked.Read(ref finished.Frames);
+            if (editorView != null) { editorView.UpdateRecordingProgress(frames, finished.SampleRate); editorView.ShowRecordingSaving(); }
+            await finished.Finish(); recorder = null;
             if (editorView != null) editorView.SetRecordingState(false);
-            foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = true;
-            C<TextBlock>("RecordingState").Text = finished.Error == null ? "Take saved" : "Recording stopped - check status";
+            LockRecordingControls(false); C<Button>("StopRecordButton").Content = "Stop & save";
+            C<TextBlock>("RecordingState").Text = finished.Error != null ? "Recording stopped - check status" : frames > 0 ? "Take saved" : "No audio captured";
             C<TextBlock>("RecordingState").Foreground = Brush(finished.Error == null ? "#006D68" : "#B52C36");
             stopping = false;
-            if (Interlocked.Read(ref finished.Frames) > 0 && finished.Paths.Count > 0 && editorView != null) {
-                try { await editorView.AddRecordedFiles(finished.Paths, recordingAnchor, recordingTrack); }
-                catch (Exception ex) { Status("Take saved to its folder, but could not be added to the timeline: " + ex.Message); return; }
+            if (addFiles && frames > 0 && finished.Paths.Count > 0 && editorView != null) {
+                try { await editorView.AddRecordedFiles(finished.Paths, recordingAnchor, recordingTrack, true); }
+                catch (Exception ex) { editorView.ShowRecordingError("Take saved to its folder, but could not be added to the timeline: " + ex.Message); return; }
             }
-            Status(finished.Error == null ? "Take saved and added to the timeline. Original recording files are preserved." : "Recording stopped: " + finished.Error.Message + " Captured audio was kept.");
+            if (finished.Error != null) {
+                editorView.ShowRecordingError(finished.Error.Message);
+                Status("Recording stopped: " + finished.Error.Message + " Captured audio was kept.");
+            }
+            else Status(frames == 0 ? "No audio was captured. Check the selected input device and microphone permissions." : addFiles ? "Take saved and added to the timeline. Original recording files are preserved." : "Take saved. Original recording files are preserved.");
         }
         private async Task Tick()
         {
             if (closeWhenIdle && !busy && !WorkspacesBusy && recorder == null) { closeWhenIdle = false; window.Close(); return; }
-            if (recorder == null || stopping) return;
+            if (recorder == null || stopping || !captureActive) return;
             long frames = Interlocked.Read(ref recorder.Frames);
             C<TextBlock>("RecordTime").Text = WorkspaceUi.Clock(frames / (double)recorder.SampleRate);
+            if (editorView != null) editorView.UpdateRecordingProgress(frames, recorder.SampleRate);
             if (frames == 0 && (DateTime.UtcNow - captureStarted).TotalSeconds > 8 && recorder.Error == null)
                 recorder.Error = new IOException("No audio arrived from the selected input. Check its connection, microphone permissions and selected channels.");
             if (recorder.SourceFormat != null)
@@ -711,7 +763,7 @@ namespace DrumBuddy
                 "HOME AND CONVERTER\nOpen Converter from View or Home. Drop audio or video, choose an output type and click Convert files. WAV PCM, WAV float, AIFF, FLAC, MP3 and AAC copies are supported. Output settings can be resized, collapsed, or displayed on the side or bottom. The source is preserved.\n\n" +
                 "Set safe level brings the loudest peak to −1 dBFS. Prevent clipping caps excessive gain evenly; it preserves the dynamics of your drums.\n\n" +
                 "ZOOM R16\nExports are 44.1 kHz PCM WAV, mono or stereo, with names up to 8 uppercase characters. Use the bit depth of your R16 project. Copy WAVs to that project's AUDIO folder, then assign them to tracks on the R16.\n\n" +
-                "EDITOR + RECORD\nThe Editor opens by default. Record options contains input, channels, WAV format and sample rate. Record or R starts a take at the playhead on the selected track. Stop & save preserves the take and adds it to the timeline. All inputs uses consecutive tracks. Use hardware direct monitoring while recording; software overdub synchronisation is not provided.\n\n" +
+                "EDITOR + RECORD\nThe Editor opens by default. Record options contains input, channels, WAV format and sample rate. Record or R arms the selected track and shows one bar of countdown at the project tempo. Separate inputs reserve consecutive tracks. Stop, Record again or Escape cancels the countdown. Capture then starts through the selected input; the red playhead and elapsed timer follow captured audio. Stop & save preserves the take and adds it at the original starting point, leaving the playhead at its end. Use hardware direct monitoring while recording; software overdub synchronisation is not provided.\n\n" +
                 "H5STUDIO FLOAT\nOn the recorder choose USB > Audio Interface > Connect. Audio I/F Only supports 44.1, 48 and 96 kHz. Stereo mix exposes a mixed stereo signal; Multi Track exposes separate inputs. Choose 32-bit float to keep the original float samples, including peaks above 0 dBFS. The app checks that the H5studio driver is actually sending float samples.\n\n" +
                 "PLAYBACK COMPATIBILITY\nSome players reject float or multichannel WAV files. Open Converter from View, enable Prevent PCM clipping and choose 16-bit or 24-bit WAV PCM. The original float master remains unchanged.\n\n" +
                 "FULL CONTROL\nAn R16 front-panel view with PC multitrack playback, mixer, EQ, recording and Mackie MIDI control. Open Menu reveals files, track settings, saved effects and devices. Escape returns home.\n\n" +
@@ -721,7 +773,7 @@ namespace DrumBuddy
                 "MEDIA PLAYER\nOpen audio or video to listen. Gain / Save amplifies or reduces playback and saves adjusted WAV copies; Playback volume changes listening level only. Reset, Set safe level and Prevent clipping are available. Choose speakers/headphones under Audio output. Gain / Save can be resized, collapsed, or displayed on the side or bottom.\n\n" +
                 "EDITOR\nA 16-track audio timeline. Drag the upper ruler and release to place the playhead. The left edge snaps to zero; Home/To start goes to zero and End goes to the timeline end. Hold Alt to bypass snapping. Drag across a track to select time; two thinner blue sticks mark the selection start/end. Drag their lower-ruler handles to adjust the boundaries. Cut/copy/paste, split, undo/redo, Space to play/pause and Ctrl+S to save. Cuts leave a gap. Choose Selected track or All 16 tracks for edits. Save .dbedit sessions and export PCM or float WAV mixes. Original source files are preserved.\n\n" +
                 "THEME AND SETTINGS\nUse the top-right switch for dark or light theme. Settings has categories for General, Audio and Keybinds. Click Edit on a keybind and press the new shortcut immediately. Save writes the changes; leaving with pending changes asks whether to save them. S splits at the playhead; V returns to the selection cursor.\n\n" +
-                "Basic tools run locally without an account. This release is for Windows; macOS is planned.\n\nFlux 1.6.0 · FFmpeg + NAudio",
+                "Basic tools run locally without an account. This release is for Windows; macOS is planned.\n\nFlux 1.6.2 · FFmpeg + NAudio",
                 "Flux — quick help",MessageBoxButton.OK,MessageBoxImage.Information);
         }
     }
@@ -735,6 +787,7 @@ namespace DrumBuddy
         {
             if (args.Length > 0 && args[0] == "--self-test") return SelfTest.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--float-self-test") return FloatRecordingTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--recording-self-test") return RecordingTests.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--grid-self-test") return TempoGridTests.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--zoom-self-test") return ZoomTests.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--selection-self-test") return EditorSelectionTests.Run(args.Skip(1).ToArray());

package/source/Main.xaml

@@ -261,7 +261,7 @@
                   <TextBlock x:Name="RecordTime" Grid.Column="1" Text="00:00" FontSize="22" FontFamily="Consolas" />
                 </Grid>
                 <UniformGrid x:Name="MeterPanel" Columns="4" Margin="0,7,0,8" />
-                <TextBlock x:Name="RecordHint" Text="Recordings are added at the timeline playhead on the selected track." FontSize="11" Foreground="{DynamicResource Theme526771}" TextWrapping="Wrap" Margin="0,0,0,10" />
+                <TextBlock x:Name="RecordHint" Text="One bar count-in at the project tempo, then record at the playhead on the selected track. Stop or Escape cancels the count-in." FontSize="11" Foreground="{DynamicResource Theme526771}" TextWrapping="Wrap" Margin="0,0,0,10" />
                 <Grid>
                   <Grid.ColumnDefinitions>
                     <ColumnDefinition />

package/source/Quick Start.txt

@@ -1,7 +1,10 @@
-FLUX 1.6.0
+FLUX 1.6.2
 
 INSTALL / UPDATE
 Close the app. Run npm.cmd install -g @pro-gram/flux@latest
+If npm skips its setup script, run flux --setup to finish the desktop install
+and create the Flux Desktop and Start menu shortcuts. With PowerShell scripts
+disabled, use flux.cmd --setup instead. First launch also completes setup.
 Launch flux.cmd, or the Flux Desktop shortcut.
 Migrating: npm.cmd uninstall -g @pro-gram/drumbuddy before installing Flux.
 Windows 10/11 x64 only in this release.
@@ -29,8 +32,14 @@ Fit shows the full project; Selection fills the view with the selected range.
 Ctrl+= / Ctrl+- zoom; Ctrl+0 fits the project; Ctrl+Shift+0 fits the selection.
 Zoom can reveal individual samples. Close-up waveforms load in the background.
 Record options opens the sidebar. Select input, channels, rate and format.
-The take is saved at the playhead on the selected track; separate inputs use
-consecutive tracks. Stop saves and inserts it. Source files are preserved.
+Record or R arms the selected track (consecutive tracks for separate inputs),
+then shows a one-bar countdown at the project tempo and time signature.
+Record again, Stop, or Escape cancels the countdown without starting capture.
+Capture begins after the last beat using the selected input device.
+The red playhead, growing recording highlights and elapsed timer follow the
+captured audio. Stop saves and inserts the take at its original starting point,
+leaving the playhead at its end. Source files are preserved.
+Bar lines are labeled 1, 2, 3; beat labels remain available when zoomed in.
 Use direct headphone monitoring. Software overdub synchronization is not included.
 
 AUDIO DEVICES

package/source/RecordingSession.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DrumBuddy
+{
+    // Snapshot the routing before the count-in; later selection changes cannot reroute a take.
+    public sealed class RecordingPlan
+    {
+        private readonly string inputName, inputDriver, inputEndpoint;
+        public readonly int Mode, Bits, SampleRate, FirstTrack, TrackCount, InputChannels, Beats;
+        public readonly long AnchorFrame;
+        public readonly double BeatSeconds;
+        public InputChoice Input { get { return new InputChoice { Name = inputName, Driver = inputDriver, EndpointId = inputEndpoint }; } }
+        public string Tracks { get { return TrackCount == 1 ? "Track " + (FirstTrack + 1) : "Tracks " + (FirstTrack + 1) + "-" + (FirstTrack + TrackCount); } }
+        public string Routing { get; private set; }
+
+        public RecordingPlan(InputChoice input, int mode, int bits, int rate, int availableInputs, int firstTrack, long anchor, TempoGridOptions grid)
+        {
+            if (input == null) throw new IOException("Choose a recording input in Record options.");
+            grid.Validate(); var layout = CaptureLayout.Create(availableInputs, mode);
+            if (bits != 16 && bits != 24 && bits != 32) throw new IOException("Choose a WAV recording format.");
+            if (rate <= 0) throw new IOException("Choose a recording sample rate.");
+            int tracks = layout.Separate ? layout.Channels : 1;
+            if (firstTrack < 0 || firstTrack + tracks > 16) throw new IOException("Select an earlier track so all recording channels fit within the 16-track timeline.");
+            if (anchor < 0 || anchor >= EditorSession.MaxFrame) throw new IOException("Move the playhead before the end of the timeline to record.");
+            inputName = input.Name; inputDriver = input.Driver; inputEndpoint = input.EndpointId;
+            Mode = mode; Bits = bits; SampleRate = rate; FirstTrack = firstTrack; TrackCount = tracks; InputChannels = layout.Channels; AnchorFrame = anchor;
+            Beats = grid.BeatsPerBar; BeatSeconds = TempoGrid.BeatSeconds(grid);
+            string channels = layout.Channels == 1 ? "Input " + (layout.FirstInput + 1) : "Inputs " + (layout.FirstInput + 1) + "-" + (layout.FirstInput + layout.Channels);
+            Routing = Tracks + " | " + channels + " | " + inputName + " | " + (rate / 1000.0).ToString("0.#", CultureInfo.InvariantCulture) + " kHz";
+        }
+        public long TimelineFrame(long capturedFrames, int sampleRate)
+        {
+            if (sampleRate <= 0) throw new ArgumentOutOfRangeException("sampleRate");
+            double elapsed = Math.Max(0, capturedFrames) * (double)Audio.Rate / sampleRate;
+            return AnchorFrame + (long)Math.Round(Math.Min(EditorSession.MaxFrame - AnchorFrame, elapsed));
+        }
+    }
+
+    public static class RecordingCountdown
+    {
+        public static async Task Run(int beats, double beatSeconds, Action<int> showBeat, CancellationToken token)
+        {
+            if (beats < 1 || beats > 32 || beatSeconds <= 0 || double.IsNaN(beatSeconds) || double.IsInfinity(beatSeconds))
+                throw new ArgumentOutOfRangeException("beats");
+            var clock = Stopwatch.StartNew();
+            for (int beat = 0; beat < beats; beat++) {
+                token.ThrowIfCancellationRequested(); showBeat(beats - beat);
+                double remaining = (beat + 1) * beatSeconds - clock.Elapsed.TotalSeconds;
+                if (remaining > 0) await Task.Delay(TimeSpan.FromSeconds(remaining), token);
+            }
+            token.ThrowIfCancellationRequested();
+        }
+    }
+}

package/source/RecordingTests.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+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.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+
+namespace DrumBuddy
+{
+    public static class RecordingTests
+    {
+        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 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 file, int width, int height)
+        {
+            view.Measure(new Size(width, height)); view.Arrange(new Rect(0, 0, width, height)); view.UpdateLayout();
+            var image = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32); image.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(image)); using (var stream = File.Create(file)) encoder.Save(stream);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "FluxRecording_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var old = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); ThemePalette.Apply(true);
+                var input = new InputChoice { Name = "Selected USB microphone", EndpointId = "selected-endpoint" };
+                var grid = new TempoGridOptions();
+                var plan = new RecordingPlan(input, -1, 32, 48000, 2, 5, Audio.Rate * 2L, grid);
+                input.EndpointId = "other-endpoint"; grid.Tempo = 200; grid.BeatsPerBar = 3;
+                Check(plan.Input.EndpointId == "selected-endpoint" && plan.FirstTrack == 5 && plan.TrackCount == 2 && plan.InputChannels == 2 && plan.Beats == 4 && plan.BeatSeconds == .5,
+                    "Freeze the selected endpoint, input layout, destination tracks, anchor and project tempo before counting in");
+                var stereo = new RecordingPlan(plan.Input, 0, 24, 96000, 2, 15, 0, grid);
+                Check(stereo.TrackCount == 1 && stereo.Beats == 3 && Math.Abs(stereo.BeatSeconds - .3) < 1e-12,
+                    "Route a stereo file to one track and use one bar of the actual project meter");
+                bool rejected = false;
+                try { new RecordingPlan(plan.Input, -1, 24, 48000, 8, 10, 0, grid); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject an overflowing multitrack take before countdown or capture");
+                Check(plan.TimelineFrame(48000, 96000) == plan.AnchorFrame + Audio.Rate / 2 && plan.TimelineFrame(long.MaxValue, 48000) == EditorSession.MaxFrame,
+                    "Convert captured frames to the editor rate without exceeding the timeline limit");
+                RunUi(async delegate {
+                    var beats = new List<int>(); var watch = Stopwatch.StartNew(); bool began = false;
+                    await RecordingCountdown.Run(4, .04, value => beats.Add(value), CancellationToken.None); began = true;
+                    Check(began && beats.SequenceEqual(new[] { 4, 3, 2, 1 }) && watch.Elapsed.TotalSeconds >= .145,
+                        "Display every count-in beat and wait the full bar before starting capture");
+                    var cancelled = new CancellationTokenSource(); began = false; bool stopped = false;
+                    try { await RecordingCountdown.Run(4, .02, value => { if (value == 1) cancelled.Cancel(); }, cancelled.Token); began = true; }
+                    catch (OperationCanceledException) { stopped = true; }
+                    Check(stopped && !began, "Cancelling on the last countdown beat prevents recording from starting"); cancelled.Dispose();
+                    cancelled = new CancellationTokenSource(); cancelled.Cancel(); beats.Clear();
+                    try { await RecordingCountdown.Run(4, .02, beats.Add, cancelled.Token); } catch (OperationCanceledException) { }
+                    Check(beats.Count == 0, "A cancelled startup cannot display another beat or restart capture"); cancelled.Dispose();
+
+                    // Prepare a real Windows endpoint, but cancel before it is ever opened for capture.
+                    var main = new MainWindow(Path.Combine(root, "shell-preferences.xml"), true);
+                    main.OpenEditorForTest(); main.RecordingPanelForTest();
+                    if (((Button)main.NativeWindow.FindName("StartRecordButton")).IsEnabled) {
+                        var startup = main.StartRecordingForTest();
+                        await main.RecordingTickForTest();
+                        Check(main.RecordingBusyForTest && main.RecordingEditorForTest.IsBusy,
+                            "Lock the actual recording controller and editor before driver preparation or the first countdown beat");
+                        await main.StartRecordingForTest();
+                        await main.NativeWindow.Dispatcher.InvokeAsync((Action)delegate { }, DispatcherPriority.Background);
+                        Check(main.RecordingEditorForTest.CountdownForTest == "4", "The actual Record action displays the first countdown beat");
+                        Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "countdown-shell-dark.png"), 1280, 800);
+                        await main.StopRecordingForTest(); await startup;
+                        Check(!main.RecordingBusyForTest && !main.RecordingEditorForTest.IsBusy && ((TextBlock)main.NativeWindow.FindName("RecordingState")).Text == "Count-in cancelled",
+                            "Stop cancels the actual startup, releases the prepared device and restores the recording controls");
+                    }
+                    else log.Add("SKIP  No ready Windows endpoint for the controller preparation/cancellation check; generated-buffer coverage still runs.");
+                    main.NativeWindow.Close();
+
+                    var owner = new Window(); ThemePalette.Install(owner);
+                    using (var editor = new EditorView(owner, Path.Combine(root, "cache"), delegate(string message) { }, delegate { })) {
+                        owner.Content = editor; editor.BeginRecordingCountdown(plan); editor.ShowCountdownBeat(4);
+                        Check(editor.IsBusy && editor.CountdownForTest == "4" && editor.ArmedTracksForTest.SequenceEqual(new[] { 5, 6 }) && editor.RoutingForTest.Contains("Selected USB microphone"),
+                            "Show the countdown and exact armed tracks with the selected device in the editor");
+                        Picture(editor, Path.Combine(root, "countdown-dark.png"), 1280, 760);
+                        Check(!await editor.ExecuteAction("start") && editor.PlayheadFrame == plan.AnchorFrame,
+                            "Protect the recording anchor from transport edits during count-in");
+                        editor.SetRecordingState(false);
+                        Check(!editor.IsBusy && editor.ArmedTracksForTest.Length == 0 && editor.RecordingOverlaysForTest == 0,
+                            "Release reserved tracks and recording visuals after cancellation");
+                        editor.BeginRecordingCountdown(plan); editor.BeginRecordingCapture();
+                        var capture = new Recorder(); capture.StartBuffered(CaptureLayout.Create(2, -1), 32, Path.Combine(root, "take"), 48000, false);
+                        byte[] pcm = new byte[48000 * 2 * 2];
+                        for (int frame = 0; frame < 48000; frame++) {
+                            Buffer.BlockCopy(BitConverter.GetBytes((short)8192), 0, pcm, frame * 4, 2);
+                            Buffer.BlockCopy(BitConverter.GetBytes((short)-4096), 0, pcm, frame * 4 + 2, 2);
+                        }
+                        editor.UpdateRecordingProgress(0, 48000);
+                        Check(editor.PlayheadFrame == plan.AnchorFrame, "Keep the playhead still until input frames actually arrive");
+                        for (int second = 1; second <= 3; second++) {
+                            capture.ProcessWindowsPcm(pcm, pcm.Length, 2); editor.UpdateRecordingProgress(Interlocked.Read(ref capture.Frames), capture.SampleRate);
+                            Check(editor.PlayheadFrame == plan.AnchorFrame + second * Audio.Rate, "Advance the recording playhead by captured audio at second " + second);
+                        }
+                        Check(editor.RecordingOverlaysForTest == 2 && editor.RecordingHeadlineForTest.Contains("00:03.00"),
+                            "Show a growing recording on both destination tracks and the elapsed take time");
+                        Picture(editor, Path.Combine(root, "recording-dark.png"), 1280, 760);
+                        Picture(editor, Path.Combine(root, "recording-compact-dark.png"), 850, 560);
+                        ThemePalette.Apply(false); Picture(editor, Path.Combine(root, "recording-light.png"), 1280, 760); ThemePalette.Apply(true);
+                        capture.Stop(); await capture.Finish(); editor.ShowRecordingSaving();
+                        var originals = capture.Paths.Select(File.ReadAllBytes).ToArray();
+                        editor.SetRecordingState(false); await editor.AddRecordedFiles(capture.Paths, plan.AnchorFrame, plan.FirstTrack, true);
+                        var session = editor.SessionForTest;
+                        Check(capture.Error == null && session.Regions.Count == 2 && session.Regions.All(r => r.Start == plan.AnchorFrame && r.Length == Audio.Rate * 3L) && session.Regions.Select(r => r.Track).OrderBy(t => t).SequenceEqual(new[] { 5, 6 }),
+                            "Save and insert both recorded inputs at the registered start and tracks");
+                        Check(editor.PlayheadFrame == plan.AnchorFrame + Audio.Rate * 3L && editor.RecordingOverlaysForTest == 0 && !editor.IsBusy,
+                            "Leave the playhead at the end of the saved take and clear live recording state");
+                        Check(capture.Paths.Select((file, index) => File.ReadAllBytes(file).SequenceEqual(originals[index])).All(value => value),
+                            "Preserve original recording files while importing the take");
+                        await editor.ExecuteAction("undo");
+                        Check(editor.SessionForTest.Regions.Count == 0 && capture.Paths.All(File.Exists), "Undo the recording insertion without deleting captured audio");
+                    }
+                    owner.Content = null; owner.Close();
+                });
+                log.Add("Generated audio buffers and offscreen UI. A physical microphone/ASIO device still requires an acceptance recording.");
+                File.WriteAllLines(Path.Combine(root, "recording-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "recording-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = old; ThemePalette.Apply(old.Theme == "Dark"); }
+        }
+    }
+}

package/source/Setup.cs

@@ -14,7 +14,7 @@ using System.Windows.Markup;
 using Microsoft.Win32;
 
 [assembly: AssemblyTitle("Flux Setup")]
-[assembly: AssemblyVersion("1.6.0.0")]
+[assembly: AssemblyVersion("1.6.2.0")]
 
 namespace DrumBuddySetup
 {
@@ -101,7 +101,7 @@ namespace DrumBuddySetup
                     Directory.CreateDirectory(Path.GetDirectoryName(destination));
                     File.Copy(source,destination,true);
                 }
-                File.WriteAllText(Path.Combine(InstallPath,".drumbuddy-installed"),"Flux 1.6.0\n" + InstallPath,Encoding.UTF8);
+                File.WriteAllText(Path.Combine(InstallPath,".drumbuddy-installed"),"Flux 1.6.2\n" + InstallPath,Encoding.UTF8);
                 string[] files = Directory.GetFiles(stage,"*",SearchOption.AllDirectories).Select(f => f.Substring(stage.Length + 1)).Concat(new[] { ".drumbuddy-installed","installed-files.txt" }).ToArray();
                 File.WriteAllLines(Path.Combine(InstallPath,"installed-files.txt"),files,Encoding.UTF8);
                 string exe = Path.Combine(InstallPath,"DrumBuddy.exe");
@@ -112,7 +112,7 @@ namespace DrumBuddySetup
                 RemoveLegacyShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),"Programs","Drum Buddy.lnk"),exe);
                 RemoveLegacyShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),"Drum Buddy.lnk"),exe);
                 using (var key = Microsoft.Win32.Registry.CurrentUser.CreateSubKey(RegistryKey)) {
-                    key.SetValue("DisplayName","Flux"); key.SetValue("DisplayVersion","1.6.0"); key.SetValue("Publisher","Flux");
+                    key.SetValue("DisplayName","Flux"); key.SetValue("DisplayVersion","1.6.2"); key.SetValue("Publisher","Flux");
                     key.SetValue("InstallLocation",InstallPath); key.SetValue("DisplayIcon",BrandIcon);
                     key.SetValue("UninstallString","\"" + Path.Combine(InstallPath,"Uninstall.exe") + "\"");
                     key.SetValue("NoModify",1); key.SetValue("NoRepair",1);
@@ -137,17 +137,18 @@ namespace DrumBuddySetup
                 foreach (var entry in zip.Entries) {
                     if (string.IsNullOrEmpty(entry.Name)) continue;
                     string relative = entry.FullName.Replace('/',Path.DirectorySeparatorChar);
+                    string manifestName = entry.FullName.Replace('\\','/');
                     string target = Path.GetFullPath(Path.Combine(root,relative));
                     if (!target.StartsWith(root,StringComparison.OrdinalIgnoreCase) || relative.Contains(":")) throw new IOException("Invalid installer file path.");
                     string expected;
-                    if (!hashes.TryGetValue(entry.FullName,out expected)) throw new IOException("An installer file is not in the integrity manifest.");
+                    if (!hashes.TryGetValue(manifestName,out expected)) throw new IOException("An installer file is not in the integrity manifest.");
                     Directory.CreateDirectory(Path.GetDirectoryName(target));
                     using (var input = entry.Open()) using (var output = new FileStream(target,FileMode.Create,FileAccess.Write)) input.CopyTo(output);
                     using (var sha = SHA256.Create()) using (var file = File.OpenRead(target)) {
                         string actual = BitConverter.ToString(sha.ComputeHash(file)).Replace("-","");
                         if (!string.Equals(actual,expected,StringComparison.OrdinalIgnoreCase)) throw new IOException("An installer file failed its integrity check. Please obtain a fresh copy.");
                     }
-                    hashes.Remove(entry.FullName);
+                    hashes.Remove(manifestName);
                     if (progress != null) progress((double)++count / zip.Entries.Count);
                 }
             }

package/source/TempoGrid.cs

@@ -86,7 +86,7 @@ namespace DrumBuddy
             int count = 0;
             for (long index = first; index <= last && count++ < 5000; index += stride) {
                 double frame = index * seconds * Audio.Rate; if (frame > EditorSession.MaxFrame) break;
-                string label = kind == 2 && index % labelStride == 0 ? (index + 1).ToString(CultureInfo.InvariantCulture) + ".1" : null;
+                string label = kind == 2 && index % labelStride == 0 ? (index + 1).ToString(CultureInfo.InvariantCulture) : null;
                 if (kind == 1 && spacing >= 58 && index % options.BeatsPerBar != 0) label = (index / options.BeatsPerBar + 1) + "." + (index % options.BeatsPerBar + 1);
                 yield return new TempoGridTick { Frame = FrameAt(frame), Kind = kind, Label = label };
             }

package/source/TempoGridTests.cs

@@ -49,6 +49,8 @@ namespace DrumBuddy
                 long distant = (long)Math.Round(100000 * 240.0 / 123 / 128 * Audio.Rate);
                 Check(Math.Abs(TempoGrid.Snap(distant, grid) - distant) <= 1, "Avoid accumulated frame rounding drift far into a fine grid");
                 grid = new TempoGridOptions { Division = 32 };
+                var bars = TempoGrid.VisibleTicks(grid, 0, 400, 40).Where(t => t.Kind == 2 && t.Label != null).ToArray();
+                Check(bars.Length >= 2 && bars[0].Label == "1" && bars[1].Label == "2", "Show whole bar numbers on the musical ruler");
                 long first = TimelineGesture.FrameAt(2.5, 40, new long[] { 0 }, false, grid, true, true);
                 Check(first == 2756, "Do not swallow the first 1/32 grid line with the start-of-track magnet");
                 Check(TimelineGesture.FrameAt(21.4, 40, new long[0], false, new TempoGridOptions(), true, false) == 22050, "Snap a playhead gesture to the nearest sixteenth-note frame");

package/source/Third Party Notices.txt

@@ -1,4 +1,4 @@
-Flux 1.6.0 - third-party components
+Flux 1.6.2 - third-party components
 
 FFmpeg 9.0.2, release essentials build by Gyan Doshi
 Used as a separate command-line decoding process.

package/source/references/R16 Format Research.txt

@@ -1,16 +0,0 @@
-The independent C# R16 project container reader/writer uses file-format facts
-researched with zoomrlib 1.1.0 by Remy Taymans and Glenn Boysko:
-https://gitlab.com/remytms/zoomrlib
-https://pypi.org/project/zoomrlib/1.1.0/
-
-Its unchanged binary fixture projects were used for round-trip verification.
-The upstream Python implementation is not bundled or linked into Drum Buddy.
-Download the upstream release's tests/data to reproduce the native fixture tests:
-DrumBuddy.exe --control-self-test TEST_OUTPUT PATH_TO_TEST_FIXTURES
-
-Mackie control protocol reference (message assignments only):
-https://github.com/justinfrankel/reaper-sdk/blob/main/reaper-plugins/reaper_csurf/csurf_mcu.cpp
-
-Official R16 manuals:
-https://zoomcorp.com/media/documents/E_R16_.pdf
-https://zoomcorp.com/media/documents/E_R16_AIF_.pdf