@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/WorkspaceTests.cs

@@ -0,0 +1,198 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+namespace DrumBuddy
+{
+    public static class WorkspaceTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool ok, string message) { if (!ok) throw new Exception(message); log.Add("PASS  " + message); }
+        private static Clip Source(string root, string name, float[] values, int channels)
+        {
+            string path = Path.Combine(root, name + ".wav");
+            using (var writer = new FloatWaveWriter(path, channels, Audio.Rate)) writer.Write(values, values.Length, 1);
+            return Audio.Load(path, Path.Combine(root, "cache"), CancellationToken.None, null);
+        }
+        private static float[] Render(EditorSession session, IDictionary<string, Clip> decoded)
+        {
+            using (var mix = new TimelineMix(session, decoded)) {
+                var result = new List<float>(); var block = new float[126]; int read;
+                while ((read = mix.Read(block, 0, block.Length)) > 0) result.AddRange(block.Take(read));
+                return result.ToArray();
+            }
+        }
+        private static void Picture(FrameworkElement view, string path, int width, int height)
+        {
+            view.Measure(new Size(width, height)); view.Arrange(new Rect(0, 0, width, height)); view.UpdateLayout();
+            var image = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
+            var background = new DrawingVisual(); using (var drawing = background.RenderOpen()) drawing.DrawRectangle(WorkspaceUi.Color("#F3F5F5"), null, new Rect(0, 0, width, height));
+            image.Render(background); image.Render(view);
+            var png = new PngBitmapEncoder(); png.Frames.Add(BitmapFrame.Create(image)); using (var file = File.Create(path)) png.Save(file);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "DrumBuddyWorkspace_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear();
+            try {
+                PlaybackTests.Offline(Check);
+                var preference = new Preferences { AudioOutputKey = "compat:default", AudioInputKey = "input:microphone" };
+                var serializer = new System.Xml.Serialization.XmlSerializer(typeof(Preferences));
+                using (var xml = new StringWriter()) {
+                    serializer.Serialize(xml, preference);
+                    using (var read = new StringReader(xml.ToString())) {
+                        var reopenedPreference = (Preferences)serializer.Deserialize(read);
+                        Check(reopenedPreference.AudioInputKey == preference.AudioInputKey && reopenedPreference.AudioOutputKey == preference.AudioOutputKey,
+                            "Save and reload both microphone and compatibility-output selections");
+                    }
+                }
+                var pickerA = new AudioOutputPicker(delegate { }, delegate(string text) { }); var pickerB = new AudioOutputPicker(delegate { }, delegate(string text) { });
+                string previousOutput = AudioOutputs.PreferredKey;
+                pickerA.RaiseEvent(new RoutedEventArgs(FrameworkElement.LoadedEvent)); pickerB.RaiseEvent(new RoutedEventArgs(FrameworkElement.LoadedEvent));
+                try {
+                    AudioOutputs.PreferredKey = "compat:default";
+                    Check(pickerA.Selected != null && pickerB.Selected != null && pickerA.Selected.Key == "compat:default" && pickerB.Selected.Key == "compat:default",
+                        "Synchronize loaded playback selectors when the shared output changes");
+                }
+                finally { AudioOutputs.PreferredKey = previousOutput; pickerA.RaiseEvent(new RoutedEventArgs(FrameworkElement.UnloadedEvent)); pickerB.RaiseEvent(new RoutedEventArgs(FrameworkElement.UnloadedEvent)); }
+                float[] precise = Enumerable.Range(0, 500).Select(i => (float)(i + 1) / 100).ToArray();
+                Clip ramp = Source(root, "Precise float source", precise, 1);
+                byte[] original = File.ReadAllBytes(ramp.Source);
+                var decoded = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase) { { ramp.Source, ramp } };
+                var session = new EditorSession();
+                session.Regions.Add(new TimelineRegion { Source = ramp.Source, Name = "Ramp", Track = 0, Start = 100, SourceStart = 20, Length = 100 });
+                var baseline = Render(session, decoded);
+                Check(baseline.Length == 400 && baseline.Take(200).All(v => v == 0), "Render silence before a region and stop exactly at the timeline end");
+                Check(Math.Abs(baseline[200] - precise[20]) < .000001 && baseline[200] == baseline[201] && Math.Abs(baseline[398] - precise[119]) < .000001,
+                    "Use exact source-frame offsets and duplicate mono correctly into stereo");
+                var sixteen = new EditorSession();
+                for (int i = 0; i < 16; i++) sixteen.Regions.Add(new TimelineRegion { Source = ramp.Source, Name = "Input " + (i + 1), Track = i, Start = 0, SourceStart = 0, Length = 1 });
+                Check(Math.Abs(Render(sixteen, decoded)[0] - precise[0] * 16) < .000001, "Mix audio from all 16 editor tracks simultaneously");
+                Clip stereo = Source(root, "Stereo separation", Enumerable.Range(0, 512).Select(i => i % 2 == 0 ? .5f : -.25f).ToArray(), 2);
+                var stereoState = new EditorSession(); stereoState.Regions.Add(new TimelineRegion { Source = stereo.Source, Name = "Stereo", Track = 0, Start = 0, SourceStart = 10, Length = 100 });
+                var stereoAudio = Render(stereoState, new Dictionary<string, Clip> { { stereo.Source, stereo } });
+                Check(stereoAudio.Where((v, i) => i % 2 == 0).All(v => v == .5f) && stereoAudio.Where((v, i) => i % 2 == 1).All(v => v == -.25f), "Preserve stereo channel separation when trimming and mixing");
+                using (var mix = new TimelineMix(session, decoded)) {
+                    mix.Seek(150); var block = new float[4]; mix.Read(block, 0, 4);
+                    Check(Math.Abs(block[0] - precise[70]) < .000001 && mix.Position == 152, "Seek into a region without losing source position");
+                }
+                var split = session.Copy(); TimelineEdits.Split(split, 0, false, 150);
+                Check(split.Regions.Count == 2 && split.Regions[1].Start == 150 && split.Regions[1].SourceStart == 70 && Render(split, decoded).SequenceEqual(baseline),
+                    "Split audio without changing any rendered sample or timing");
+                var cut = session.Copy(); TimelineEdits.Delete(cut, 0, false, 130, 170); var cutAudio = Render(cut, decoded);
+                Check(cut.Regions.Count == 2 && cut.Regions[0].Length == 30 && cut.Regions[1].Start == 170 && cut.Regions[1].SourceStart == 90,
+                    "Cut the middle of a clip into correctly trimmed left and right regions");
+                Check(cutAudio.Skip(260).Take(80).All(v => v == 0) && cutAudio.Take(260).SequenceEqual(baseline.Take(260)) && cutAudio.Skip(340).SequenceEqual(baseline.Skip(340)),
+                    "Leave the cut gap while preserving all unselected samples and alignment");
+                var copied = TimelineEdits.Copy(session, 0, false, 120, 180); var pasted = session.Copy();
+                TimelineEdits.Paste(pasted, copied, 15, 300); var lastTrack = pasted.Regions.Last();
+                Check(lastTrack.Track == 15 && lastTrack.Start == 300 && lastTrack.SourceStart == 40 && lastTrack.Length == 60,
+                    "Copy a partial section and paste it into track 16 at the playhead");
+                Check(Math.Abs(Render(pasted, decoded)[600] - precise[40]) < .000001, "Render pasted audio from the copied source range");
+                var group = session.Copy(); group.Regions.Add(new TimelineRegion { Source = ramp.Source, Name = "Other", Track = 15, Start = 140, SourceStart = 5, Length = 30 });
+                var groupCopy = TimelineEdits.Copy(group, 0, true, 120, 180); TimelineEdits.Paste(group, groupCopy, 7, 500);
+                Check(group.Regions.Any(r => r.Track == 0 && r.Start == 500) && group.Regions.Any(r => r.Track == 15 && r.Start == 520),
+                    "Copy all-track selections with original track numbers and relative timing");
+                var selectedOnly = group.Copy(); TimelineEdits.Delete(selectedOnly, 0, false, 0, 1000);
+                Check(selectedOnly.Regions.All(r => r.Track == 15), "Limit selected-track cuts to that track");
+                var invalid = session.Copy(); invalid.Regions[0].Track = 16; bool blocked = false;
+                try { invalid.Validate(); } catch (IOException) { blocked = true; }
+                Check(blocked, "Reject a track beyond the 16-track editor limit");
+                string saved = Path.Combine(root, "Practice.dbedit"); group.Save(saved); var reopened = EditorSession.Load(saved);
+                Check(reopened.Tracks.Length == 16 && Render(reopened, decoded).SequenceEqual(Render(group, decoded)), "Save and reopen editor sessions without changing edited audio");
+                var clone = group.Copy(); clone.Regions[0].Length = 1; clone.Tracks[0].GainDb = -12;
+                Check(group.Regions[0].Length != 1 && group.Tracks[0].GainDb == 0, "Keep undo snapshots independent of later region and track edits");
+                bool protectedSource = false; try { group.Save(ramp.Source); } catch (IOException) { protectedSource = true; }
+                Check(protectedSource && original.SequenceEqual(File.ReadAllBytes(ramp.Source)), "Refuse to save a session over original audio");
+
+                Clip left = Source(root, "Kick", Enumerable.Repeat(.6f, Audio.Rate).ToArray(), 1);
+                Clip right = Source(root, "Snare", Enumerable.Repeat(.7f, Audio.Rate).ToArray(), 1);
+                var mixedAssets = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase) { { left.Source, left }, { right.Source, right } };
+                var mixState = new EditorSession { Name = "Practice mix" };
+                mixState.Regions.Add(new TimelineRegion { Source = left.Source, Name = "Kick", Track = 0, Start = 0, Length = Audio.Rate });
+                mixState.Regions.Add(new TimelineRegion { Source = right.Source, Name = "Snare", Track = 1, Start = 0, Length = Audio.Rate });
+                Check(Render(mixState, mixedAssets).All(v => Math.Abs(v - 1.3f) < .00001), "Mix simultaneous tracks in float without clipping over-0-dBFS samples");
+                using (var mix = new TimelineMix(mixState, mixedAssets)) {
+                    var listening = AudioOutputs.Adapt(mix, 48000, 2); var samples = new float[400]; int count = listening.Read(samples, 0, samples.Length);
+                    Check(listening.WaveFormat.SampleRate == 48000 && count == 400 && samples.All(v => Math.Abs(v) <= 1),
+                        "Adapt the float editor mix to the endpoint rate and bound its listening samples");
+                }
+                var solo = mixState.Copy(); solo.Tracks[1].Solo = true;
+                Check(Render(solo, mixedAssets).All(v => Math.Abs(v - .7f) < .00001), "Solo isolates the chosen editor track");
+                solo.Tracks[1].Mute = true; Check(Render(solo, mixedAssets).All(v => v == 0), "Mute silences a soloed track without leaking other tracks");
+                var level = mixState.Copy(); level.Tracks[0].GainDb = -6; level.Tracks[1].Mute = true;
+                Check(Math.Abs(Render(level, mixedAssets)[0] - .6 * Math.Pow(10, -.3)) < .00001, "Apply track level changes in the timeline mix");
+                foreach (int bits in new[] { 16, 24, 32 }) {
+                    string path = Path.Combine(root, "editor-mix-" + bits + ".wav");
+                    TimelineRender.Export(mixState, mixedAssets, path, bits, true, 0, 0, CancellationToken.None, null);
+                    Clip exported = Audio.Load(path, Path.Combine(root, "cache"), CancellationToken.None, null);
+                    using (var reader = new WaveFileReader(path)) Check(reader.WaveFormat.BitsPerSample == bits && reader.WaveFormat.SampleRate == Audio.Rate && reader.Length == Audio.Rate * 2 * bits / 8,
+                        "Export exact-duration " + bits + "-bit stereo WAV from the multitrack editor");
+                    Check(bits == 32 ? exported.Peak > 1.29 : Math.Abs(exported.PeakDb + 1) < .02,
+                        bits == 32 ? "Preserve float mix headroom" : "Scale the full PCM mix to prevent clipping");
+                }
+                string selectedMix = Path.Combine(root, "selected-mix.wav");
+                TimelineRender.Export(mixState, mixedAssets, selectedMix, 32, false, Audio.Rate / 4, Audio.Rate / 2, CancellationToken.None, null);
+                using (var reader = new WaveFileReader(selectedMix)) Check(reader.Length == Audio.Rate / 4 * 8, "Export only the selected timeline range");
+                var cancelled = new CancellationTokenSource(); cancelled.Cancel(); string cancelledPath = Path.Combine(root, "cancelled.wav"); bool wasCancelled = false;
+                try { TimelineRender.Export(mixState, mixedAssets, cancelledPath, 32, false, 0, 0, cancelled.Token, null); } catch (OperationCanceledException) { wasCancelled = true; }
+                Check(wasCancelled && !File.Exists(cancelledPath) && !Directory.GetFiles(root, "*.partial").Any(), "Cancel rendering without leaving incomplete exports");
+                Check(original.SequenceEqual(File.ReadAllBytes(ramp.Source)), "Keep original source bytes unchanged through all timeline edits");
+
+                foreach (string codec in new[] { "pcm_s16le", "pcm_s24le", "pcm_s32le", "pcm_f32le", "pcm_f64le" }) {
+                    string file = Path.Combine(root, "player-" + codec + ".wav");
+                    Audio.Run("-hide_banner -v error -nostdin -y -i " + Audio.Q(left.Source) + " -ar 48000 -c:a " + codec + " " + Audio.Q(file), CancellationToken.None, null, true);
+                    var clip = Audio.Load(file, Path.Combine(root, "cache"), CancellationToken.None, null);
+                    Check(clip.Ready && Math.Abs(clip.Duration - 1) < .001 && clip.Peak > .59 && clip.SourceFormat.Contains("48000 Hz"),
+                        "Decode " + codec + " at 48 kHz for the Media Player and display source format");
+                }
+                string aiff = Path.Combine(root, "player-pcm-big-endian.aiff");
+                Audio.Run("-hide_banner -v error -nostdin -y -i " + Audio.Q(left.Source) + " -c:a pcm_s24be " + Audio.Q(aiff), CancellationToken.None, null, true);
+                Check(Audio.Load(aiff, Path.Combine(root, "cache"), CancellationToken.None, null).Ready, "Decode big-endian PCM AIFF without Windows Media Player codecs");
+
+                Window owner;
+                using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Main.xaml")) owner = (Window)XamlReader.Load(stream);
+                ThemePalette.Install(owner);
+                Check(owner.FindName("AudioDevicesButton") != null, "Expose Audio devices in the main header on every workspace");
+                Picture((FrameworkElement)owner.Content, Path.Combine(root, "main-header-preview.png"), 1050, 850);
+                using (var devices = new AudioDevicesView(AudioInputs.Choices().FirstOrDefault(), delegate(InputChoice choice) { }, delegate { }, false)) {
+                    owner.Content = devices; Picture(devices, Path.Combine(root, "audio-devices-preview.png"), 760, 640);
+                    Check(devices.ActualWidth == 712 && devices.DesiredSize.Height <= 640, "Render output selector, speaker test, microphone selector and diagnostics together");
+                }
+                using (var view = new EditorView(owner, Path.Combine(root, "editor-cache"), delegate(string message) { }, delegate { })) {
+                    owner.Content = view; view.SetForTest(mixState, mixedAssets);
+                    Check(view.CheckUndoRedoForTest(), "Exercise the editor's actual cut, undo and redo handlers");
+                    float[] pulse = new float[Audio.Rate * 8];
+                    for (int i = 0; i < pulse.Length; i++) pulse[i] = (float)(.7 * Math.Exp(-(i % (Audio.Rate / 2)) / 3000.0) * Math.Sin(i * .06));
+                    var beat = Source(root, "Generated drum reference", pulse, 1);
+                    var previewAssets = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase) { { beat.Source, beat } };
+                    var previewState = new EditorSession { Name = "Practice · generated test audio" };
+                    string[] names = { "Kick", "Snare", "Hi-hat", "Tom 1", "Tom 2", "Floor tom", "Overhead L", "Overhead R", "Room L", "Room R", "Percussion", "Bass guide", "Guitar guide", "Keys guide", "Click", "Reference" };
+                    for (int i = 0; i < 16; i++) { previewState.Tracks[i].Name = names[i]; previewState.Regions.Add(new TimelineRegion { Source = beat.Source, Name = names[i], Track = i, Start = (i % 3) * Audio.Rate / 2, SourceStart = i % 2 * Audio.Rate, Length = (6 - i % 3) * Audio.Rate }); }
+                    view.SetForTest(previewState, previewAssets); view.ShowSelectionForTest(Audio.Rate, 4L * Audio.Rate); Picture(view, Path.Combine(root, "editor-preview.png"), 1280, 760);
+                    Picture(view, Path.Combine(root, "editor-small-preview.png"), 800, 560);
+                    Check(view.ActualWidth == 800 && view.ActualHeight == 560, "Lay out editor controls and scrolling timeline at small window size");
+                }
+                using (var view = new MediaPlayerView(owner, Path.Combine(root, "player-cache"), delegate(string message) { }, delegate { })) {
+                    owner.Content = view; view.SetForTest(left); Picture(view, Path.Combine(root, "player-preview.png"), 1100, 760);
+                    Picture(view, Path.Combine(root, "player-small-preview.png"), 800, 560);
+                    Check(view.ActualWidth == 800, "Render the Media Player waveform, playlist, transport and seek controls");
+                }
+                owner.Content = null;
+                log.Add("Rendered views use generated samples. Realtek playback on the affected PC and physical Windows/H5studio capture need a connected-device acceptance test.");
+                File.WriteAllLines(Path.Combine(root, "workspace-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "workspace-test-results.txt"), log, Encoding.UTF8); return 1; }
+        }
+    }
+}

package/source/app.manifest

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="DrumBuddy"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"><security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false"/></requestedPrivileges></security></trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application><supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/></application></compatibility>
+  <application xmlns="urn:schemas-microsoft-com:asm.v3"><windowsSettings><dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware><dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness><longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware></windowsSettings></application>
+</assembly>

package/source/dependency-lock.json

@@ -0,0 +1,62 @@
+[
+  {
+    "File": "naudio.wasapi.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/naudio.wasapi/2.2.1/naudio.wasapi.2.2.1.nupkg",
+    "ExtractTo": "naudio.wasapi",
+    "Sha256": "C8396B8DBAB86A2619EDFD9158BEAF18C21CB86677099B5594950FD8651B9D1A"
+  },
+  {
+    "File": "naudio.core.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/naudio.core/2.2.1/naudio.core.2.2.1.nupkg",
+    "ExtractTo": "naudio.core",
+    "Sha256": "794645DBFD30E4880663D52D9D9224D55C301FA54228FF623C95D572C7887347"
+  },
+  {
+    "File": "naudio.asio.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/naudio.asio/2.2.1/naudio.asio.2.2.1.nupkg",
+    "ExtractTo": "naudio.asio",
+    "Sha256": "AAE0C06C2559FBF56BD4B4F4A5CB9AEEF158E35C7B536699E4E6B8012A683577"
+  },
+  {
+    "File": "naudio.winmm.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/naudio.winmm/2.2.1/naudio.winmm.2.2.1.nupkg",
+    "ExtractTo": "naudio.winmm",
+    "Sha256": "48DA978D715F219489C050EE8C32C64F80FF73718EBA237EBCBC636BA5902BE3"
+  },
+  {
+    "File": "microsoft.win32.registry.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/microsoft.win32.registry/4.7.0/microsoft.win32.registry.4.7.0.nupkg",
+    "ExtractTo": "microsoft.win32.registry",
+    "Sha256": "FA3582C11A94FC9FE32DD40A0C59BDDD67C80EB0CC5CC27DF3851EBDA40CA22F"
+  },
+  {
+    "File": "system.security.accesscontrol.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/system.security.accesscontrol/4.7.0/system.security.accesscontrol.4.7.0.nupkg",
+    "ExtractTo": "system.security.accesscontrol",
+    "Sha256": "FFD6423C81CB761CEAECE5B850AA93B11D0EF778E31DDE81446D524708071358"
+  },
+  {
+    "File": "system.security.principal.windows.zip",
+    "Url": "https://api.nuget.org/v3-flatcontainer/system.security.principal.windows/4.7.0/system.security.principal.windows.4.7.0.nupkg",
+    "ExtractTo": "system.security.principal.windows",
+    "Sha256": "AD604CD94F0AAB7AC475A6B530F65260E3A46ED306816C81F223EBA48AA6A6A8"
+  },
+  {
+    "File": "ffmpeg.zip",
+    "Url": "https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-9.0.2-essentials_build.zip",
+    "ExtractTo": "ffmpeg",
+    "Sha256": "60F467265B1E312373DBCD92200C2618A74850F98D3D078E94296BB3FA2047BA"
+  },
+  {
+    "File": "NAudio-license.txt",
+    "Url": "https://raw.githubusercontent.com/naudio/NAudio/v2.2.1/license.txt",
+    "ExtractTo": null,
+    "Sha256": "303E01786B271EB464B3F43D18A375F2F17D37BC708A37C2FDF45B289FB5BFAA"
+  },
+  {
+    "File": "r16-panel.png",
+    "Url": "https://zoomcorp.com/media/original_images/R16_list_0.png",
+    "ExtractTo": null,
+    "Sha256": "5564FA622F101DC27EA402C399C5B9B1E1E039B8771DAF40B185DAB9772ADF38"
+  }
+]

package/source/references/R16 Format Research.txt

@@ -0,0 +1,16 @@
+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

package/test/package.test.js

@@ -0,0 +1,55 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { execFileSync } = require('node:child_process');
+const { hash, cached, installRoot } = require('../scripts/install');
+const pkg = require('../package.json');
+const dependencies = require('../dependencies.json');
+test('launcher identifies the packaged release and update command', () => {
+  assert.equal(pkg.name, '@pro-gram/flux');
+  assert.equal(pkg.bin.flux, 'bin/flux.js');
+  const launcher = path.resolve(__dirname, '../bin/flux.js');
+  assert.equal(execFileSync(process.execPath, [launcher, '--version'], { encoding: 'utf8' }).trim(), pkg.version);
+  const help = execFileSync(process.execPath, [launcher, '--help'], { encoding: 'utf8' });
+  assert.match(help, /npm\.cmd install -g @pro-gram\/flux@latest/);
+  assert.match(help, /32-bit float/);
+  assert.match(help, /16\/24-bit PCM/);
+  assert.match(help, /16-track timeline Editor/);
+  assert.match(help, /PCM\/float Media Player/);
+  assert.match(help, /--audio-diagnostics/);
+  assert.match(help, /Backspace/);
+  assert.match(help, /1\/256/);
+  assert.doesNotMatch(help, /--allow-scripts/);
+});
+test('an older Flux launcher preserves a newer installed release', () => {
+  const { needsUpdate } = require('../scripts/version');
+  assert.equal(needsUpdate('1.4.1', '1.5.0'), true);
+  assert.equal(needsUpdate('1.5.0\n', '1.5.0'), false);
+  assert.equal(needsUpdate('1.6.0', '1.5.0'), false);
+  assert.equal(needsUpdate(null, '1.5.0'), true);
+  assert.equal(needsUpdate('bad marker', '1.5.0'), true);
+});
+test('public installer matches its package integrity pin', async () => {
+  assert.equal(await hash(path.resolve(__dirname, '../payload/DrumBuddy-Setup.exe')), dependencies.installerSha256);
+});
+test('verified cached data works without a network call', async () => {
+  const folder = await fs.mkdtemp(path.join(os.tmpdir(), 'drumbuddy-cache-check-'));
+  const contents = Buffer.from('Drum Buddy cache test');
+  const file = path.join(folder, 'fixture');
+  await fs.writeFile(file, contents);
+  const asset = { file: 'fixture', url: 'https://invalid.example/', sha256: crypto.createHash('sha256').update(contents).digest('hex') };
+  assert.equal(await cached(asset, folder), file);
+  assert.equal(await hash(file), asset.sha256);
+  assert.equal(await cached({ ...asset, sha256: '0'.repeat(64), alternateSha256: asset.sha256 }, folder), file);
+});
+test('dependencies are pinned to official HTTPS sources and exclude driver downloads', () => {
+  assert.equal(new URL(dependencies.ffmpeg.url).host, 'www.gyan.dev');
+  assert.equal(new URL(dependencies.panel.url).host, 'zoomcorp.com');
+  assert.match(dependencies.ffmpeg.sha256, /^[a-f0-9]{64}$/);
+  assert.equal(dependencies.driver, undefined);
+  assert.equal(installRoot(), path.join(process.env.LOCALAPPDATA, 'Programs', 'DrumBuddy'));
+});