@pro-gram/flux 1.5.0 → 1.6.0

package/source/Build Instructions.txt

@@ -13,9 +13,13 @@ Dependencies are pinned to reviewed SHA-256 hashes. The FFmpeg release URL is ve
 Verification:
   DrumBuddy.exe --self-test "C:\path\to\new-audio-test-folder"
   DrumBuddy.exe --grid-self-test "C:\path\to\new-grid-test-folder"
+  DrumBuddy.exe --zoom-self-test "C:\path\to\new-zoom-test-folder"
+  DrumBuddy.exe --selection-self-test "C:\path\to\new-selection-test-folder"
+  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 --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"
   DrumBuddy.exe --conversion-self-test "C:\path\to\new-conversion-test-folder"
   DrumBuddy.exe --audio-diagnostics "C:\path\to\Audio-Diagnostics.txt"
@@ -30,9 +34,11 @@ The workspace suite covers the 16-track editor, range/playhead gestures,
 endpoint resampling/channel adaptation, PCM/float imports and exports,
 and offscreen player/editor renders. The output suite opens the actual
 default Windows endpoint and plays only silence; it never changes volume.
-Windows speakers/headphones use shared WASAPI with the exact endpoint format,
-with an endpoint-matched 16-bit PCM compatibility fallback. The output suite
-checks both paths and queries microphone formats without opening capture.
+Windows speakers/headphones use the native shared WASAPI renderer with the
+exact endpoint format. No WinMM output fallback or compatibility devices are
+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 interface suite checks keybind capture, saved/unsaved settings, theme
 switching, integrated recording insertion and dark/light/compact layouts.

package/source/Build.ps1

@@ -30,14 +30,15 @@ $panelSource = Join-Path $PSScriptRoot 'r16-panel.png'
 if (!(Test-Path -LiteralPath $panelSource)) { $panelSource = Join-Path $Dependencies 'r16-panel.png' }
 Copy-Item -LiteralPath $panelSource -Destination $package -Force
 }
-Copy-Item -LiteralPath (Join-Path $PSScriptRoot 'logo.png') -Destination $package -Force
+Copy-Item -LiteralPath (Join-Path $PSScriptRoot 'Flux-Logo.png') -Destination $package -Force
 Copy-Item -LiteralPath (Join-Path $PSScriptRoot 'Flux-Mark.svg') -Destination $package -Force
-foreach ($file in @('Quick Start.txt','LICENSE.txt','Third Party Notices.txt')) { Copy-Item -LiteralPath (Join-Path $PSScriptRoot $file) -Destination $package -Force }
+foreach ($file in @('Quick Start.txt','LICENSE.txt','Third Party Notices.txt','Audio Decoders.txt')) { Copy-Item -LiteralPath (Join-Path $PSScriptRoot $file) -Destination $package -Force }
 if (Test-Path -LiteralPath (Join-Path $Dependencies 'NAudio-license.txt')) { Copy-Item -LiteralPath (Join-Path $Dependencies 'NAudio-license.txt') -Destination (Join-Path $package 'licenses\NAudio-MIT.txt') -Force }
 
-# Convert the original logo into the native Windows ICO container, preserving alpha.
+# Use the current Flux mark for every executable/shortcut icon. The drummer
+# artwork is retained separately in source/brand-archive.
 Add-Type -AssemblyName System.Drawing
-$image = [Drawing.Image]::FromFile((Join-Path $PSScriptRoot 'logo.png'))
+$image = [Drawing.Image]::FromFile((Join-Path $PSScriptRoot 'Flux-Logo.png'))
 $sizes = @(16,24,32,48,64,128,256)
 $iconImages = @()
 foreach ($size in $sizes) {
@@ -45,10 +46,12 @@ foreach ($size in $sizes) {
     $graphics = [Drawing.Graphics]::FromImage($bitmap)
     $graphics.Clear([Drawing.Color]::Transparent)
     $graphics.InterpolationMode = [Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
-    $scale = [Math]::Min($size / $image.Width,$size / $image.Height)
-    $w = [int]($image.Width * $scale)
-    $h = [int]($image.Height * $scale)
-    $graphics.DrawImage($image,[int](($size-$w)/2),[int](($size-$h)/2),$w,$h)
+    $markBounds = New-Object Drawing.Rectangle(100,280,1050,800)
+    $scale = [Math]::Min($size / $markBounds.Width,$size / $markBounds.Height)
+    $w = [int]($markBounds.Width * $scale)
+    $h = [int]($markBounds.Height * $scale)
+    $destinationBounds = New-Object Drawing.Rectangle([int](($size-$w)/2),[int](($size-$h)/2),$w,$h)
+    $graphics.DrawImage($image,$destinationBounds,$markBounds,[Drawing.GraphicsUnit]::Pixel)
     $memory = New-Object IO.MemoryStream
     $bitmap.Save($memory,[Drawing.Imaging.ImageFormat]::Png)
     $iconImages += ,$memory.ToArray()
@@ -90,8 +93,17 @@ $appArgs = $common + $refs + @(('/out:' + (Join-Path $package 'DrumBuddy.exe')),
 $appArgs += '/resource:' + (Join-Path $PSScriptRoot 'ShellStyles.xaml') + ',ShellStyles.xaml'
 $appArgs += '/resource:' + (Join-Path $PSScriptRoot 'Flux-Mark.svg') + ',Flux-Mark.svg'
 $appArgs += Join-Path $PSScriptRoot 'BrandArtwork.cs'
+$appArgs += @('TimelineZoom.cs','WaveformDetail.cs','ZoomTests.cs') | ForEach-Object { Join-Path $PSScriptRoot $_ }
+$appArgs += @('WindowsAudioPlayer.cs','AudioEndpointWatcher.cs') | ForEach-Object { Join-Path $PSScriptRoot $_ }
+$appArgs += Join-Path $PSScriptRoot 'EditorPlaybackTests.cs'
+$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'
 & $compiler @appArgs
 if ($LASTEXITCODE -ne 0) { throw 'App compilation failed.' }
+$iconVersion = [Reflection.AssemblyName]::GetAssemblyName((Join-Path $package 'DrumBuddy.exe')).Version.ToString(3)
+Copy-Item -LiteralPath $iconPath -Destination (Join-Path $package ('Flux-' + $iconVersion + '.ico')) -Force
 @'
 <?xml version="1.0" encoding="utf-8"?>
 <configuration><startup useLegacyV2RuntimeActivationPolicy="true"><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/></startup><runtime><AppContextSwitchOverrides value="Switch.System.Windows.DoNotScaleForDpiChanges=false"/></runtime></configuration>
@@ -114,7 +126,7 @@ $manifestPath = Join-Path $BuildFolder 'payload.sha256'
 $setupRefs = $refs | Where-Object { $_ -notmatch 'NAudio|Microsoft.Win32.Registry|System.Security' }
 $setupRefs += '/reference:' + (Join-Path $framework 'System.IO.Compression.dll')
 $setupRefs += '/reference:' + (Join-Path $framework 'System.IO.Compression.FileSystem.dll')
-$setupArgs = $common + $setupRefs + @(('/out:' + (Join-Path $BuildFolder 'DrumBuddy-Setup.exe')),('/resource:' + $payload + ',payload.zip'),('/resource:' + $manifestPath + ',payload.sha256'),('/resource:' + (Join-Path $PSScriptRoot 'Setup.xaml') + ',Setup.xaml'),('/resource:' + (Join-Path $PSScriptRoot 'logo.png') + ',logo.png'),(Join-Path $PSScriptRoot 'Setup.cs'),(Join-Path $PSScriptRoot 'DriverSetup.cs'),(Join-Path $PSScriptRoot 'AssetBootstrap.cs'))
+$setupArgs = $common + $setupRefs + @(('/out:' + (Join-Path $BuildFolder 'DrumBuddy-Setup.exe')),('/resource:' + $payload + ',payload.zip'),('/resource:' + $manifestPath + ',payload.sha256'),('/resource:' + (Join-Path $PSScriptRoot 'Setup.xaml') + ',Setup.xaml'),('/resource:' + (Join-Path $PSScriptRoot 'Flux-Logo.png') + ',Flux-Logo.png'),(Join-Path $PSScriptRoot 'Setup.cs'),(Join-Path $PSScriptRoot 'DriverSetup.cs'),(Join-Path $PSScriptRoot 'AssetBootstrap.cs'))
 $setupArgs += '/resource:' + (Join-Path $PSScriptRoot 'Flux-Mark.svg') + ',Flux-Mark.svg'
 $setupArgs += Join-Path $PSScriptRoot 'BrandArtwork.cs'
 & $compiler @setupArgs

package/source/EditorCompactLayout.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace DrumBuddy
+{
+    public sealed partial class EditorView
+    {
+        private void ArrangeCompactChrome(Panel top, Panel editing, Panel range, Panel viewControls, Panel zoomTools, Panel bottom, Panel transport, Panel exports)
+        {
+            top.Children.Remove(title); top.Children.Remove(cancel); top.Visibility = Visibility.Collapsed;
+            title.FontSize = 14; title.MaxWidth = 180; title.TextWrapping = TextWrapping.NoWrap; title.TextTrimming = TextTrimming.CharacterEllipsis; title.Margin = new Thickness(0, 0, 12, 4);
+            editing.Children.Insert(0, title); editing.Children.Insert(1, cancel);
+            editing.Children.Remove(separate); separate.Content = "Separate import tracks"; range.Children.Add(separate);
+            compactOptionsButton.Content = "Export settings"; scope.Width = 132;
+            foreach (var control in editing.Children.OfType<Control>()) { control.FontSize = 12; control.MinHeight = 26; control.Padding = new Thickness(6, 2, 6, 2); control.Margin = new Thickness(0, 0, 4, 4); }
+            viewControls.Children.Remove(zoomTools); viewControls.Children.Remove(selectionText); viewControls.Visibility = Visibility.Collapsed;
+            zoomTools.Margin = new Thickness(10, 0, 0, 0); gridControls.Children.Add(zoomTools);
+            foreach (var control in gridControls.Children.OfType<Control>()) { control.FontSize = 12; control.MinHeight = 26; }
+            tempoBox.Width = 50; gridDivision.Width = 72; rulerMode.Width = 104;
+            foreach (var button in gridControls.Children.OfType<Button>()) { button.Content = "Grid…"; button.MinHeight = 26; button.Padding = new Thickness(6, 2, 6, 2); }
+            foreach (var button in zoomTools.Children.OfType<Button>()) { button.MinHeight = 24; button.Padding = new Thickness(4, 1, 4, 1); button.Margin = new Thickness(0, 0, 4, 4); }
+            fitSelection.Content = "Sel"; zoomSpan.Width = 62;
+            bottom.Margin = new Thickness(0, 5, 0, 0);
+            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 "; }
+            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); }
+            exportFormat.Width = 150;
+        }
+    }
+}

package/source/EditorPlaybackTests.cs

@@ -0,0 +1,87 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Threading;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    public static class EditorPlaybackTests
+    {
+        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 Pump(Func<bool> ready, int milliseconds)
+        {
+            var frame = new DispatcherFrame(); var watch = Stopwatch.StartNew();
+            var timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(10) };
+            timer.Tick += delegate { if (ready() || watch.ElapsedMilliseconds > milliseconds) { timer.Stop(); frame.Continue = false; } };
+            timer.Start(); Dispatcher.PushFrame(frame);
+        }
+        private static void RunUi(Func<Task> action)
+        {
+            var previous = SynchronizationContext.Current;
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
+            try { var task = action(); Pump(() => task.IsCompleted, 20000); if (!task.IsCompleted) throw new TimeoutException("Editor action did not finish."); task.GetAwaiter().GetResult(); }
+            finally { SynchronizationContext.SetSynchronizationContext(previous); }
+        }
+        private sealed class Silence : ISampleProvider
+        {
+            private int remaining = Audio.Rate;
+            public WaveFormat WaveFormat { get { return WaveFormat.CreateIeeeFloatWaveFormat(Audio.Rate, 1); } }
+            public int Read(float[] data, int offset, int count) { int read = Math.Min(count, remaining); Array.Clear(data, offset, read); remaining -= read; return read; }
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args[0]); Directory.CreateDirectory(root); log.Clear();
+            var previous = InterfacePreferences.Current; string oldKey = AudioOutputs.PreferredKey, oldLog = AudioOutputs.TestErrorLog;
+            AudioOutputs.TestErrorLog = Path.Combine(root, "playback-errors.txt");
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); AudioOutputs.PreferredKey = "default";
+                using (var done = new ManualResetEvent(false)) using (var player = new WindowsAudioPlayer(new Silence(), null, false, 80)) {
+                    Exception stopped = null; player.PlaybackStopped += delegate(object sender, StoppedEventArgs e) { stopped = e.Exception; done.Set(); };
+                    player.Play(); Thread.Sleep(80); player.Pause(); Thread.Sleep(70); long a = player.GetPosition(); Thread.Sleep(70); long b = player.GetPosition();
+                    Check(player.PlaybackState == PlaybackState.Paused && a > 0 && a == b, "Pause a native polling stream without advancing its audible position");
+                    player.Play(); Check(done.WaitOne(5000) && stopped == null && player.Counter.Frames > Audio.Rate / 2, "Resume and drain the native shared polling stream");
+                }
+                foreach (string kind in new[] { "float-mono-44100", "float-stereo-48000", "float-eight-channel-96000", "pcm16", "pcm24" }) {
+                    bool pcm = kind.StartsWith("pcm"); int channels = kind.Contains("eight") ? 8 : kind.Contains("stereo") || kind == "pcm24" ? 2 : 1;
+                    int rate = kind.Contains("96000") ? 96000 : kind.Contains("48000") ? 48000 : Audio.Rate;
+                    string file = Path.Combine(root, kind + ".wav"); var samples = new float[rate / 5 * channels];
+                    for (int i = 0; i < samples.Length; i++) samples[i] = (float)((pcm ? .6 : 1.5) * Math.Sin(i / channels * .08));
+                    if (pcm) { using (var writer = new PcmWriter(file, kind == "pcm16" ? 16 : 24, channels)) writer.Write(samples, samples.Length, 1); }
+                    else { using (var writer = new FloatWaveWriter(file, channels, rate)) writer.Write(samples, samples.Length, 1); }
+                    if (channels == 8) {
+                        string extensible = Path.Combine(root, "float-extensible.wav");
+                        Audio.Run("-hide_banner -v error -nostdin -i " + Audio.Q(file) + " -c:a pcm_f32le " + Audio.Q(extensible), CancellationToken.None, null, true); file = extensible;
+                        using (var wave = new WaveFileReader(file)) Check(wave.WaveFormat.Encoding == WaveFormatEncoding.Extensible, "Exercise a real multichannel WAVEFORMATEXTENSIBLE float file");
+                    }
+                    byte[] original = File.ReadAllBytes(file); var messages = new List<string>(); var owner = new Window(); ThemePalette.Install(owner);
+                    using (var editor = new EditorView(owner, Path.Combine(root, "cache-" + kind), text => messages.Add(text), delegate { })) {
+                        owner.Content = editor; editor.ListenVolumeForTest(0);
+                        RunUi(() => editor.AddFiles(new[] { file }));
+                        Check(editor.SessionForTest.Regions.Count == 1 && editor.SessionForTest.End > 0, "Import " + kind + " into the actual editor");
+                        long end = editor.SessionForTest.End;
+                        RunUi(() => editor.ExecuteAction("play"));
+                        Pump(() => editor.PlayheadFrame == end || messages.Any(t => t.StartsWith("Could not play") || t.StartsWith("Editor playback stopped")), 5000);
+                        Check(editor.PlayheadFrame == end && !messages.Any(t => t.StartsWith("Could not play") || t.StartsWith("Editor playback stopped")), "Play and finish imported " + kind + " through the actual editor transport at muted listening volume");
+                    }
+                    owner.Content = null; owner.Close();
+                    Check(original.SequenceEqual(File.ReadAllBytes(file)), "Preserve the original " + kind + " file through import and playback");
+                }
+                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");
+                log.Add("Local Windows output used Cirrus Logic. Muted listening preserves system volume. Affected Realtek-device acceptance remains required.");
+                File.WriteAllLines(Path.Combine(root, "editor-playback-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "editor-playback-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = previous; AudioOutputs.PreferredKey = oldKey; AudioOutputs.TestErrorLog = oldLog; }
+        }
+    }
+}

package/source/EditorSelectionTests.cs

@@ -0,0 +1,73 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace DrumBuddy
+{
+    public static class EditorSelectionTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string text) { if (!value) throw new Exception(text); log.Add("PASS  " + text); }
+        private static long Frame(double seconds) { return (long)Math.Round(seconds * Audio.Rate); }
+        private static void Picture(FrameworkElement view, string file)
+        {
+            view.Measure(new Size(1100, 650)); view.Arrange(new Rect(0, 0, 1100, 650)); view.UpdateLayout();
+            var bitmap = new RenderTargetBitmap(1100, 650, 96, 96, PixelFormats.Pbgra32); bitmap.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bitmap)); using (var output = File.Create(file)) encoder.Save(output);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args[0]); Directory.CreateDirectory(root); log.Clear(); var previous = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); InterfacePreferences.Current.SnapToGrid = InterfacePreferences.Current.SnapToEdges = false;
+                Check(InterfacePreferences.Resolve(Key.V, ModifierKeys.None) == "selectTool" && InterfacePreferences.Resolve(Key.V, ModifierKeys.Control) == "paste" && InterfacePreferences.Resolve(Key.S, ModifierKeys.None) == "split", "Keep V selection, S split and Ctrl+V paste as separate actions");
+                Check(InterfacePreferences.Resolve(Key.OemPlus, ModifierKeys.Control | ModifierKeys.Shift) == "zoomInPlus" && InterfacePreferences.Resolve(Key.Add, ModifierKeys.Control) == "zoomInKeypad" && InterfacePreferences.Resolve(Key.Subtract, ModifierKeys.Control) == "zoomOutKeypad", "Recognize literal Ctrl+plus and numeric-keypad zoom shortcuts");
+                string file = Path.Combine(root, "Original float.wav"); var samples = new float[Audio.Rate * 4]; for (int i = 0; i < samples.Length; i++) samples[i] = (float)(.7 * Math.Sin(i * .03));
+                using (var writer = new FloatWaveWriter(file, 1, Audio.Rate)) writer.Write(samples, samples.Length, 1);
+                byte[] original = File.ReadAllBytes(file);
+                var clip = new Clip { Source = file, Cache = file, Name = "Original float.wav", Channels = 1, Duration = 4, Peak = .7, Waveform = Enumerable.Repeat(.7f, 900).ToArray(), Ready = true };
+                var state = new EditorSession { Name = "Selection tools" };
+                var first = new TimelineRegion { Id = "first", Source = file, Name = "Selected audio", Track = 0, Start = Frame(1), Length = Frame(2) };
+                var overlap = new TimelineRegion { Id = "overlap", Source = file, Name = "Overlapping unselected audio", Track = 0, Start = Frame(1.5), SourceStart = Frame(.5), Length = Frame(1) };
+                var other = new TimelineRegion { Id = "other", Source = file, Name = "Second selected track", Track = 1, Start = Frame(2), Length = Frame(1.5) };
+                state.Regions.AddRange(new[] { first, overlap, other });
+                var assets = new Dictionary<string, Clip> { { file, clip } }; var owner = new Window(); ThemePalette.Apply(true); ThemePalette.Install(owner);
+                using (var editor = new EditorView(owner, Path.Combine(root, "cache"), delegate { }, delegate { })) {
+                    owner.Content = editor; editor.SetForTest(state, assets); Picture(editor, Path.Combine(root, "selection-overview.png")); editor.ZoomForTest(320);
+                    editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25));
+                    Check(editor.SelectedClipsForTest == 1 && editor.HighlightedForTest == 1, "Click one clip and highlight only that clip despite overlapping audio");
+                    editor.ExecuteAction("copy").GetAwaiter().GetResult(); editor.ExecuteAction("delete").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Count == 2 && editor.SessionForTest.Regions.Any(r => r.Id == "overlap"), "Delete the selected clip without deleting overlapping unselected audio");
+                    editor.PlayheadForTest(Frame(5)); editor.ExecuteAction("paste").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Any(r => r.Start == Frame(5) && r.Length == Frame(2) && r.SourceStart == 0) && editor.SelectedClipsForTest == 1, "Paste the copied clip at the playhead and select the new item");
+                    editor.ExecuteAction("undo").GetAwaiter().GetResult(); Check(editor.SessionForTest.Regions.Count == 2, "Undo the selected-clip paste independently");
+                    editor.SetForTest(state, assets); editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25)); editor.PointerDownForTest(Frame(3), 1, true);
+                    Check(editor.SelectedClipsForTest == 2 && editor.HighlightedForTest == 2, "Shift-click selects clips across tracks with distinct purple highlights");
+                    editor.ExecuteAction("zoomSelection").GetAwaiter().GetResult(); Picture(editor, Path.Combine(root, "selected-clips-dark.png")); ThemePalette.Apply(false); Picture(editor, Path.Combine(root, "selected-clips-light.png")); ThemePalette.Apply(true);
+                    editor.ExecuteAction("copy").GetAwaiter().GetResult(); editor.ExecuteAction("delete").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Count == 1 && editor.SessionForTest.Regions[0].Id == "overlap", "Multi-clip deletion preserves unselected regions between selected items");
+                    editor.PlayheadForTest(Frame(5)); editor.ExecuteAction("paste").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Any(r => r.Track == 0 && r.Start == Frame(5)) && editor.SessionForTest.Regions.Any(r => r.Track == 1 && r.Start == Frame(6)) && editor.SessionForTest.Regions.Count == 3, "Copy/paste selected clips preserves their relative timing and track layout");
+                    editor.SetForTest(state, assets); editor.PointerDownForTest(Frame(1.75), 0, false); editor.PointerMoveForTest(Frame(2.25));
+                    Check(editor.SelectedClipsForTest == 0 && editor.HighlightedForTest == 2, "Dragging within audio automatically changes to a precise time range with live highlights");
+                    editor.PointerUpForTest(Frame(2.25)); editor.ExecuteAction("delete").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Where(r => r.Track == 0).All(r => r.End <= Frame(1.75) || r.Start >= Frame(2.25)) && editor.SessionForTest.Regions.Any(r => r.Id == "other"), "Backspace on a dragged range removes that time only from the selected track");
+                    editor.SetForTest(state, assets); editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25)); editor.ExecuteAction("split").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Count == 4 && editor.SessionForTest.Regions.Single(r => r.Id == "overlap").Length == Frame(1), "S splits the selected clip at the playhead without splitting an unselected overlap");
+                    editor.ExecuteAction("scissors").GetAwaiter().GetResult(); editor.ExecuteAction("selectTool").GetAwaiter().GetResult(); Check(editor.SelectCursorForTest, "V immediately restores the normal selection pointer");
+                    double zoom = editor.ZoomPixelsForTest; editor.ExecuteAction("zoomInPlus").GetAwaiter().GetResult(); editor.ExecuteAction("zoomOutKeypad").GetAwaiter().GetResult(); Check(editor.ZoomPixelsForTest == zoom, "Execute plus/minus zoom actions without modifying the audio");
+                }
+                owner.Content = null; owner.Close(); Check(original.SequenceEqual(File.ReadAllBytes(file)), "Preserve the original audio through clip selection, range editing and split operations");
+                File.WriteAllLines(Path.Combine(root, "selection-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "selection-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = previous; ThemePalette.Apply(previous.Theme == "Dark"); }
+        }
+    }
+}

package/source/EditorToolInteractions.cs

@@ -0,0 +1,227 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+
+namespace DrumBuddy
+{
+    public sealed partial class EditorView
+    {
+        private ClipDrag clipDrag;
+        private EditorSession clipBefore;
+        private Dictionary<string, TimelineRegion> clipOriginal;
+        private string dragId, pointerTool = "select";
+        private Point dragOrigin;
+        private long dragOriginFrame;
+        private int dragOriginTrack;
+        private bool clipChanged, renderPending, changingTool;
+        private ComboBox toolPicker;
+
+        private void InitializeClipTools(Panel toolbar)
+        {
+            toolPicker = new ComboBox { ItemsSource = new[] { "Select (V)", "Slip (Y)", "Fade (F)" }, SelectedIndex = 0, Width = 112, MinHeight = 30, Margin = new Thickness(0, 0, 6, 6) };
+            toolPicker.SelectionChanged += delegate { if (!changingTool) SetPointerTool(toolPicker.SelectedIndex == 1 ? "slip" : toolPicker.SelectedIndex == 2 ? "fade" : "select"); }; toolbar.Children.Add(toolPicker);
+            var menu = new ContextMenu(); timeline.ContextMenu = menu;
+            string[,] commands = {
+                { "Selection cursor", "selectTool" }, { "Slip source contents", "slipTool" }, { "Fade tool", "fadeTool" },
+                { "Split at playhead", "split" }, { "Duplicate", "duplicate" }, { "Repeat…", "repeatClips" },
+                { "Mute / unmute clips", "muteClips" }, { "Crossfade selected clips", "crossfade" }, { "Clear clip fades", "clearFades" },
+                { "Cut", "cut" }, { "Copy", "copy" }, { "Paste", "paste" }, { "Delete", "delete" }
+            };
+            for (int i = 0; i < commands.GetLength(0); i++) {
+                string action = commands[i, 1]; var item = new MenuItem { Header = commands[i, 0], Tag = action };
+                item.Click += async delegate { await ExecuteAction(action); }; menu.Items.Add(item);
+            }
+            timeline.PreviewMouseRightButtonDown += delegate(object sender, MouseButtonEventArgs e) {
+                SelectContextTarget(e.GetPosition(timeline));
+            };
+            timeline.ContextMenuOpening += delegate(object sender, ContextMenuEventArgs e) {
+                if (IsBusy) { e.Handled = true; return; }
+                foreach (MenuItem item in menu.Items) { string key = InterfacePreferences.Gesture((string)item.Tag); item.InputGestureText = key == "Unassigned" ? "" : key; }
+            };
+        }
+        private void SelectContextTarget(Point point)
+        {
+            if (IsBusy) return; var region = RegionAt(point); long frame = FrameAt(point.X);
+            bool inRange = region != null && !clipSelection && to > from && frame >= from && frame < to && (AllTracks || region.Track == track);
+            if (region != null && !inRange && (!clipSelection || !selectedIds.Contains(region.Id))) { track = region.Track; SelectRegion(region, false); BuildHeaders(); DrawCanvas(); }
+            timeline.Focus();
+        }
+        private void SetPointerTool(string tool)
+        {
+            pointerTool = tool; sliceCursor = false;
+            changingTool = true; toolPicker.SelectedIndex = tool == "slip" ? 1 : tool == "fade" ? 2 : 0; changingTool = false;
+            timeline.Cursor = tool == "select" ? Cursors.Arrow : Cursors.SizeWE; timeline.Focus(); UpdateSelectionText();
+        }
+        private TimelineRegion RegionAt(Point point)
+        {
+            if (point.Y < RulerHeight) return null;
+            int row = Math.Max(0, Math.Min(15, (int)((point.Y - RulerHeight) / RowHeight))); long frame = FrameAt(point.X);
+            var hit = session.Regions.LastOrDefault(r => r.Track == row && r.Start <= frame && r.End > frame);
+            if (hit == null || (pointerTool == "select" && clipSelection && point.Y - RulerHeight - row * RowHeight >= 13)) {
+                var edge = session.Regions.Where(r => r.Track == row && (hit == null || selectedIds.Contains(r.Id))).OrderBy(r => Math.Min(Math.Abs(point.X - X(r.Start)), Math.Abs(point.X - X(r.End)))).FirstOrDefault();
+                if (edge != null && Math.Min(Math.Abs(point.X - X(edge.Start)), Math.Abs(point.X - X(edge.End))) <= 6) return edge;
+            }
+            return hit;
+        }
+        private ClipDrag ClipToolAt(TimelineRegion region, Point point)
+        {
+            if (pointerTool == "slip") return ClipDrag.Slip;
+            if (pointerTool == "fade") return point.X < (X(region.Start) + X(region.End)) / 2 ? ClipDrag.FadeIn : ClipDrag.FadeOut;
+            double y = point.Y - RulerHeight - region.Track * RowHeight;
+            if (RegionSelected(region) && y < 13) {
+                if (Math.Abs(point.X - FadeX(region, true)) <= 7) return ClipDrag.FadeIn;
+                if (Math.Abs(point.X - FadeX(region, false)) <= 7) return ClipDrag.FadeOut;
+            }
+            if (y >= 13 && Math.Abs(point.X - X(region.Start)) <= 6) return ClipDrag.TrimLeft;
+            if (y >= 13 && Math.Abs(point.X - X(region.End)) <= 6) return ClipDrag.TrimRight;
+            return y < 19 ? ClipDrag.Move : ClipDrag.None;
+        }
+        private void UpdateClipCursor(Point point)
+        {
+            if (sliceCursor) { timeline.Cursor = Cursors.Cross; return; }
+            var region = RegionAt(point); var tool = region == null ? ClipDrag.None : ClipToolAt(region, point);
+            timeline.Cursor = tool == ClipDrag.Move ? Cursors.SizeAll : tool == ClipDrag.None ? Cursors.Arrow : Cursors.SizeWE;
+        }
+        private void BeginClipDrag(ClipDrag tool, TimelineRegion region, Point point)
+        {
+            if (tool != ClipDrag.Move || !clipSelection || !selectedIds.Contains(region.Id)) SelectRegion(region, false);
+            clipBefore = session.Copy(); clipOriginal = session.Regions.Where(r => selectedIds.Contains(r.Id)).ToDictionary(r => r.Id, r => r.Copy());
+            clipDrag = tool; dragId = region.Id; dragOrigin = point; dragOriginFrame = FrameAt(point.X); dragOriginTrack = region.Track; clipChanged = false;
+            playhead = PointerFrame(point.X); RefreshGridToolbar(); RefreshClipBounds(); BuildHeaders(); DrawCanvas();
+        }
+        private long SourceFrames(TimelineRegion region)
+        {
+            Clip clip; if (!assets.TryGetValue(region.Source, out clip)) throw new System.IO.IOException("The clip's source is missing. Re-import it before editing.");
+            return (long)Math.Round(clip.Duration * Audio.Rate);
+        }
+        private long ToolFrame(double x)
+        { return TimelineGesture.FrameAt(x, pixelsPerSecond, session.Regions.Where(r => !selectedIds.Contains(r.Id)).SelectMany(r => new[] { r.Start, r.End }), (Keyboard.Modifiers & ModifierKeys.Alt) != 0, session.Grid, InterfacePreferences.Current.SnapToGrid, InterfacePreferences.Current.SnapToEdges); }
+        private void PreviewClipDrag(Point point)
+        {
+            if (clipDrag == ClipDrag.None) return;
+            try {
+                foreach (var region in session.Regions) {
+                    TimelineRegion original; if (!clipOriginal.TryGetValue(region.Id, out original)) continue;
+                    region.Start = original.Start; region.Track = original.Track; region.SourceStart = original.SourceStart; region.Length = original.Length;
+                    region.FadeIn = original.FadeIn; region.FadeOut = original.FadeOut; region.FadeInOffset = original.FadeInOffset; region.FadeOutOffset = original.FadeOutOffset;
+                }
+                var target = session.Regions.First(r => r.Id == dragId);
+                if (clipDrag == ClipDrag.Move) {
+                    long first = clipOriginal.Values.Min(r => r.Start);
+                    double anchor = (dragOriginFrame - first) / (double)Audio.Rate * pixelsPerSecond;
+                    long delta = ToolFrame(point.X - anchor) - first; int row = (int)Math.Floor((point.Y - RulerHeight) / RowHeight);
+                    EditorTools.Move(session, selectedIds, delta, row - dragOriginTrack); track = target.Track;
+                }
+                else if (clipDrag == ClipDrag.TrimLeft || clipDrag == ClipDrag.TrimRight) EditorTools.Trim(target, clipDrag == ClipDrag.TrimLeft, ToolFrame(point.X), SourceFrames(target));
+                else if (clipDrag == ClipDrag.Slip) {
+                    long delta = (long)Math.Round((dragOrigin.X - point.X) / pixelsPerSecond * Audio.Rate);
+                    if (InterfacePreferences.Current.SnapToGrid && (Keyboard.Modifiers & ModifierKeys.Alt) == 0) { double step = TempoGrid.StepSeconds(session.Grid) * Audio.Rate; delta = (long)Math.Round(Math.Round(delta / step) * step); }
+                    EditorTools.Slip(target, delta, SourceFrames(target));
+                }
+                else EditorTools.Fade(target, clipDrag == ClipDrag.FadeIn, clipDrag == ClipDrag.FadeIn ? ToolFrame(point.X) - target.Start : target.End - ToolFrame(point.X));
+                clipChanged = session.Regions.Where(r => clipOriginal.ContainsKey(r.Id)).Any(r => {
+                    var old = clipOriginal[r.Id]; return r.Start != old.Start || r.Track != old.Track || r.SourceStart != old.SourceStart || r.Length != old.Length || r.FadeIn != old.FadeIn || r.FadeOut != old.FadeOut || r.FadeInOffset != old.FadeInOffset || r.FadeOutOffset != old.FadeOutOffset;
+                });
+                RefreshClipBounds(); RequestClipRender();
+            }
+            catch (Exception ex) { CancelClipDrag(); status("Could not edit this clip: " + ex.Message); }
+        }
+        private void RequestClipRender()
+        {
+            if (renderPending) return; renderPending = true;
+            Dispatcher.BeginInvoke(DispatcherPriority.Render, (Action)delegate { renderPending = false; if (!disposed) DrawCanvas(); });
+        }
+        private void FinishClipDrag()
+        {
+            if (clipDrag == ClipDrag.None) return; var action = clipDrag;
+            try { session.Validate(); if (clipChanged) { undo.Push(clipBefore); redo.Clear(); dirty = true; } }
+            catch (Exception ex) { session = clipBefore; clipChanged = false; status("Could not finish the clip edit: " + ex.Message); }
+            clipDrag = ClipDrag.None; clipBefore = null; clipOriginal = null; RefreshClipBounds(); RefreshGridToolbar(); BuildHeaders(); DrawCanvas();
+            if (clipChanged) status(action == ClipDrag.Move ? "Clips moved." : action == ClipDrag.Slip ? "Source contents slipped." : action == ClipDrag.TrimLeft || action == ClipDrag.TrimRight ? "Clip trimmed." : "Clip fade updated.");
+        }
+        private void CancelClipDrag()
+        {
+            if (clipDrag == ClipDrag.None) return; session = clipBefore; clipDrag = ClipDrag.None; clipBefore = null; clipOriginal = null;
+            selectedIds.Clear(); if (previousIds != null) foreach (string id in previousIds) selectedIds.Add(id); clipSelection = previousClipSelection; track = previousTrack;
+            from = previousFrom; to = previousTo; playhead = previousPlayhead;
+            RefreshClipBounds(); UpdateSelectionText(); RefreshGridToolbar(); BuildHeaders(); DrawCanvas();
+        }
+        private double FadeX(TimelineRegion region, bool incoming)
+        {
+            long frames = incoming ? Math.Max(0, region.FadeIn - region.FadeInOffset) : Math.Max(0, region.FadeOut - region.FadeOutOffset);
+            return X(incoming ? region.Start + Math.Min(region.Length, frames) : region.End - Math.Min(region.Length, frames));
+        }
+        private void DrawClipFades(TimelineRegion region, double left, double right, bool selected)
+        {
+            double y = RulerHeight + region.Track * RowHeight + 4;
+            if (region.FadeIn > 0 || region.FadeOut > 0) {
+                var line = new Polyline { Stroke = WorkspaceUi.Color("#7359C7"), StrokeThickness = 1.3, IsHitTestVisible = false };
+                var positions = new[] { Math.Max(left, X(region.Start)), Math.Min(right, X(region.End)), FadeX(region, true), FadeX(region, false) }.Where(x => x >= left && x <= right && x >= X(region.Start) && x <= X(region.End)).Distinct().OrderBy(x => x);
+                foreach (double x in positions) line.Points.Add(new Point(x, y + 4 + (1 - EditorTools.Envelope(region, Math.Min(region.Length - 1, Math.Max(0, FrameAt(x) - region.Start)))) * (RowHeight - 14)));
+                timeline.Children.Add(line);
+            }
+            if (selected) foreach (bool incoming in new[] { true, false }) {
+                double x = FadeX(region, incoming); if (x < left || x > right) continue;
+                var handle = new Polygon { Fill = WorkspaceUi.Color("#7359C7"), IsHitTestVisible = false };
+                handle.Points.Add(new Point(x, y)); handle.Points.Add(new Point(x + (incoming ? 7 : -7), y)); handle.Points.Add(new Point(x, y + 8)); timeline.Children.Add(handle);
+            }
+        }
+        private HashSet<string> EditableClipIds()
+        {
+            if (clipSelection) return new HashSet<string>(selectedIds);
+            if (to <= from) return new HashSet<string>();
+            TimelineEdits.Split(session, track, AllTracks, from); TimelineEdits.Split(session, track, AllTracks, to);
+            return new HashSet<string>(session.Regions.Where(r => (AllTracks || r.Track == track) && r.Start >= from && r.End <= to).Select(r => r.Id));
+        }
+        private void SelectAdded(IEnumerable<string> ids)
+        { selectedIds.Clear(); foreach (string id in ids) selectedIds.Add(id); clipSelection = selectedIds.Count > 0; RefreshClipBounds(); }
+        private void RepeatClips(int count)
+        {
+            Change(delegate {
+                if (clipSelection) { SelectAdded(EditorTools.Repeat(session, selectedIds, count)); return true; }
+                if (to <= from) return false; var copied = TimelineEdits.Copy(session, track, AllTracks, from, to); if (copied.Regions.Count == 0) return false;
+                var before = new HashSet<string>(session.Regions.Select(r => r.Id)); long start = from;
+                for (int n = 1; n <= count; n++) TimelineEdits.Paste(session, copied, track, start + copied.Length * n);
+                SelectAdded(session.Regions.Where(r => !before.Contains(r.Id)).Select(r => r.Id).ToArray()); return true;
+            }, count == 1 ? "Selection duplicated." : "Selection repeated.");
+        }
+        private bool ExecuteClipAction(string action)
+        {
+            switch (action) {
+                case "slipTool": SetPointerTool("slip"); return true;
+                case "fadeTool": SetPointerTool("fade"); return true;
+                case "duplicate": RepeatClips(1); return true;
+                case "repeatClips": var count = AskRepeatCount(); if (count.HasValue) RepeatClips(count.Value); return true;
+                case "muteClips": Change(delegate { var ids = EditableClipIds(); bool changed = EditorTools.ToggleMute(session, ids); if (changed) SelectAdded(ids); return changed; }, "Clip mute updated."); return true;
+                case "crossfade": Change(() => EditorTools.Crossfade(session, selectedIds), "Crossfade applied."); return true;
+                case "clearFades": Change(delegate { var ids = EditableClipIds(); bool changed = false; foreach (var region in session.Regions.Where(r => ids.Contains(r.Id))) { changed |= region.FadeIn > 0 || region.FadeOut > 0; region.FadeIn = region.FadeOut = region.FadeInOffset = region.FadeOutOffset = 0; } if (changed) SelectAdded(ids); return changed; }, "Clip fades cleared."); return true;
+                default: return false;
+            }
+        }
+        private int? AskRepeatCount()
+        {
+            var dialog = new Window { Owner = owner, Title = "Repeat selected audio", Width = 330, Height = 180, ResizeMode = ResizeMode.NoResize, WindowStartupLocation = WindowStartupLocation.CenterOwner, ShowInTaskbar = false, Icon = BrandArtwork.Raster() }; ThemePalette.Install(dialog);
+            var body = new StackPanel { Margin = new Thickness(18) }; dialog.Content = body; body.Children.Add(WorkspaceUi.Text("Additional copies (1–64)", 14));
+            var input = new TextBox { Text = "3", Margin = new Thickness(0, 8, 0, 10), Padding = new Thickness(5) }; body.Children.Add(input);
+            var buttons = new StackPanel { Orientation = Orientation.Horizontal }; body.Children.Add(buttons); int result = 0;
+            var apply = WorkspaceUi.Button("Repeat", delegate { int value; if (int.TryParse(input.Text, out value) && value >= 1 && value <= 64) { result = value; dialog.DialogResult = true; } else input.SelectAll(); }); apply.IsDefault = true; buttons.Children.Add(apply);
+            var close = WorkspaceUi.Button("Cancel", delegate { dialog.DialogResult = false; }); close.IsCancel = true; buttons.Children.Add(close); dialog.Loaded += delegate { input.Focus(); input.SelectAll(); };
+            return dialog.ShowDialog() == true ? (int?)result : null;
+        }
+        internal void ToolDownForTest(string id, string tool, long frame)
+        {
+            var region = session.Regions.Single(r => r.Id == id); previousIds = selectedIds.ToArray(); previousClipSelection = clipSelection; previousTrack = track;
+            previousFrom = from; previousTo = to; previousPlayhead = playhead;
+            BeginClipDrag((ClipDrag)Enum.Parse(typeof(ClipDrag), tool), region, new Point(X(frame), RulerHeight + region.Track * RowHeight + 8));
+        }
+        internal void ToolMoveForTest(long frame, int row) { PreviewClipDrag(new Point(X(frame), RulerHeight + row * RowHeight + 8)); }
+        internal void ToolEndForTest(bool cancel) { if (cancel) CancelClipDrag(); else FinishClipDrag(); }
+        internal void ContextForTest(long frame, int row) { SelectContextTarget(new Point(X(frame), RulerHeight + row * RowHeight + 35)); }
+    }
+}

package/source/EditorTools.cs

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace DrumBuddy
+{
+    internal enum ClipDrag { None, Move, TrimLeft, TrimRight, Slip, FadeIn, FadeOut }
+    public static class EditorTools
+    {
+        public static double Envelope(TimelineRegion region, long offset)
+        {
+            double value = 1;
+            if (region.FadeIn > 0) value = Math.Min(value, Math.Max(0, offset + region.FadeInOffset) / (double)region.FadeIn);
+            if (region.FadeOut > 0) value = Math.Min(value, Math.Max(0, region.Length - 1 - offset + region.FadeOutOffset) / (double)region.FadeOut);
+            return Math.Max(0, Math.Min(1, value));
+        }
+        public static void ClampFades(TimelineRegion region)
+        { region.FadeIn = Math.Max(0, Math.Min(region.Length, region.FadeIn)); region.FadeOut = Math.Max(0, Math.Min(region.Length, region.FadeOut)); region.FadeInOffset = region.FadeOutOffset = 0; }
+        public static bool Move(EditorSession session, ISet<string> ids, long delta, int tracks)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).ToArray(); if (selected.Length == 0) return false;
+            delta = Math.Max(-selected.Min(r => r.Start), Math.Min(EditorSession.MaxFrame - selected.Max(r => r.End), delta));
+            tracks = Math.Max(-selected.Min(r => r.Track), Math.Min(15 - selected.Max(r => r.Track), tracks));
+            if (delta == 0 && tracks == 0) return false;
+            foreach (var region in selected) { region.Start += delta; region.Track += tracks; } return true;
+        }
+        public static bool Trim(TimelineRegion region, bool left, long boundary, long sourceFrames)
+        {
+            if (sourceFrames < region.SourceStart + region.Length) throw new IOException("Re-import the source before extending this clip.");
+            long before = region.Length;
+            if (left) {
+                long start = Math.Max(Math.Max(0, region.Start - region.SourceStart), Math.Min(region.End - 1, boundary));
+                long delta = start - region.Start; region.Start = start; region.SourceStart += delta; region.Length -= delta;
+            }
+            else {
+                long end = Math.Max(region.Start + 1, Math.Min(Math.Min(EditorSession.MaxFrame, region.Start + sourceFrames - region.SourceStart), boundary)); region.Length = end - region.Start;
+            }
+            ClampFades(region); return before != region.Length;
+        }
+        public static bool Slip(TimelineRegion region, long delta, long sourceFrames)
+        {
+            long before = region.SourceStart; region.SourceStart = Math.Max(0, Math.Min(sourceFrames - region.Length, region.SourceStart + delta));
+            return before != region.SourceStart;
+        }
+        public static bool Fade(TimelineRegion region, bool fadeIn, long length)
+        {
+            length = Math.Max(0, Math.Min(region.Length, length)); long before = fadeIn ? region.FadeIn : region.FadeOut;
+            if (fadeIn) { region.FadeIn = length; region.FadeInOffset = 0; } else { region.FadeOut = length; region.FadeOutOffset = 0; } return before != length;
+        }
+        public static List<string> Repeat(EditorSession session, ISet<string> ids, int copies)
+        {
+            var source = session.Regions.Where(r => ids.Contains(r.Id)).ToArray();
+            if (source.Length == 0) throw new IOException("Select clips to duplicate or repeat.");
+            if (copies < 1 || copies > 64 || session.Regions.Count + copies * source.Length > 20000) throw new IOException("Choose 1 to 64 additional copies within the session's region limit.");
+            long length = source.Max(r => r.End) - source.Min(r => r.Start);
+            if (length > (EditorSession.MaxFrame - source.Max(r => r.End)) / copies) throw new IOException("The repeats would exceed the 24-hour timeline.");
+            var added = new List<string>();
+            for (int n = 1; n <= copies; n++) foreach (var item in source) {
+                var copy = item.Copy(); copy.Id = Guid.NewGuid().ToString("N"); copy.Start += length * n; session.Regions.Add(copy); added.Add(copy.Id);
+            }
+            return added;
+        }
+        public static bool ToggleMute(EditorSession session, ISet<string> ids)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).ToArray(); if (selected.Length == 0) return false;
+            bool mute = selected.Any(r => !r.Muted); foreach (var region in selected) region.Muted = mute; return true;
+        }
+        public static bool Crossfade(EditorSession session, ISet<string> ids)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).OrderBy(r => r.Start).ToArray();
+            if (selected.Length != 2 || selected[0].Track != selected[1].Track || selected[0].Start >= selected[1].Start || selected[0].End <= selected[1].Start || selected[0].End > selected[1].End)
+                throw new IOException("Select two overlapping clips on one track, with the second extending beyond the first, to crossfade.");
+            long overlap = selected[0].End - selected[1].Start;
+            selected[0].FadeOut = overlap; selected[0].FadeOutOffset = 0; selected[1].FadeIn = overlap; selected[1].FadeInOffset = 1; return true;
+        }
+    }
+}