@pro-gram/flux 0.0.0-stage → 1.6.0

package/source/Fetch-Dependencies.ps1

@@ -0,0 +1,15 @@
+param([string]$Dependencies = (Join-Path $PSScriptRoot '..\deps'))
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+$Dependencies = [IO.Path]::GetFullPath($Dependencies)
+$downloads = Join-Path $Dependencies 'downloads'
+New-Item -ItemType Directory -Force -Path $Dependencies,$downloads | Out-Null
+$locked = Get-Content -LiteralPath (Join-Path $PSScriptRoot 'dependency-lock.json') -Raw | ConvertFrom-Json
+foreach ($item in $locked) {
+    $download = Join-Path $downloads $item.File
+    if (!(Test-Path -LiteralPath $download)) { Invoke-WebRequest -Uri $item.Url -OutFile $download }
+    if ((Get-FileHash -LiteralPath $download -Algorithm SHA256).Hash -ne $item.Sha256) { throw ('Dependency hash mismatch: ' + $item.File + '. The upstream file may have changed. Obtain the pinned version rather than disabling this check.') }
+    if ($item.ExtractTo) { Expand-Archive -LiteralPath $download -DestinationPath (Join-Path $Dependencies $item.ExtractTo) -Force }
+    else { Copy-Item -LiteralPath $download -Destination (Join-Path $Dependencies $item.File) -Force }
+}
+Write-Output ('Dependencies ready in ' + $Dependencies)

package/source/FloatRecording.cs

@@ -0,0 +1,99 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace DrumBuddy
+{
+    public interface IRecordingWriter : IDisposable
+    {
+        void Write(float[] samples, int count, double gain);
+    }
+
+    // A recording layout is based on the channels actually exposed by the ASIO driver.
+    public sealed class CaptureLayout
+    {
+        public int FirstInput, Channels;
+        public bool Separate;
+        public static bool IsH5studio(string driver)
+        { return driver != null && driver.Replace(" ", "").IndexOf("H5studio", StringComparison.OrdinalIgnoreCase) >= 0; }
+        public static CaptureLayout Create(int available, int mode)
+        {
+            if (available < 1) throw new IOException("The selected ASIO device has no recording inputs.");
+            var layout = new CaptureLayout { Separate = mode == -1, FirstInput = mode > 0 ? mode - 1 : 0 };
+            layout.Channels = layout.Separate ? Math.Min(8, available) : mode == 0 ? 2 : 1;
+            if (mode < -1 || layout.FirstInput < 0 || layout.FirstInput + layout.Channels > available || layout.FirstInput + layout.Channels > 8)
+                throw new IOException("This device does not have those inputs. Refresh the device and choose an available input.");
+            return layout;
+        }
+    }
+
+    // IEEE float WAV: fmt (tag 3), fact (frame count), then interleaved float data.
+    // Values above +1 or below -1 are kept exactly; only a later PCM export limits peaks.
+    public sealed class FloatWaveWriter : IRecordingWriter
+    {
+        public const long MaxData = 0xFFFFFF00L;
+        private readonly FileStream stream;
+        private readonly BinaryWriter writer;
+        private readonly int channels, rate;
+        private byte[] bytes = new byte[0];
+        private float[] scaled = new float[0];
+        private long dataSize;
+        private bool disposed;
+
+        public FloatWaveWriter(string path, int channels, int rate)
+        {
+            if (channels < 1 || channels > 8 || (rate != 44100 && rate != 48000 && rate != 96000))
+                throw new ArgumentException("Unsupported float WAV format.");
+            this.channels = channels; this.rate = rate;
+            stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.Read, 65536);
+            writer = new BinaryWriter(stream);
+            writer.Write(Encoding.ASCII.GetBytes("RIFF")); writer.Write((uint)50);
+            writer.Write(Encoding.ASCII.GetBytes("WAVEfmt ")); writer.Write(18);
+            writer.Write((ushort)3); writer.Write((ushort)channels); writer.Write(rate);
+            writer.Write(rate * channels * 4); writer.Write((ushort)(channels * 4)); writer.Write((ushort)32); writer.Write((ushort)0);
+            writer.Write(Encoding.ASCII.GetBytes("fact")); writer.Write(4); writer.Write((uint)0);
+            writer.Write(Encoding.ASCII.GetBytes("data")); writer.Write((uint)0);
+            stream.Flush();
+        }
+
+        public void Write(float[] samples, int count, double gain)
+        {
+            if (disposed) throw new ObjectDisposedException("FloatWaveWriter");
+            if (samples == null || count < 0 || count > samples.Length || count % channels != 0)
+                throw new ArgumentException("Incomplete audio frame.");
+            long size = (long)count * 4;
+            if (dataSize + size > MaxData)
+                throw new IOException("This WAV take has reached its 4 GB limit. Stop and start a new take. The audio already saved is kept.");
+            if (double.IsNaN(gain) || double.IsInfinity(gain)) throw new ArgumentException("Invalid audio gain.");
+            for (int i = 0; i < count; i++)
+                if (float.IsNaN(samples[i]) || float.IsInfinity(samples[i]) || Math.Abs((double)samples[i] * gain) > float.MaxValue)
+                    throw new IOException("The driver sent an invalid audio sample. The audio already saved is kept.");
+            int byteCount = checked(count * 4);
+            if (bytes.Length < byteCount) bytes = new byte[byteCount];
+            if (gain == 1) Buffer.BlockCopy(samples, 0, bytes, 0, byteCount);
+            else {
+                if (scaled.Length < count) scaled = new float[count];
+                for (int i = 0; i < count; i++) scaled[i] = (float)(samples[i] * gain);
+                Buffer.BlockCopy(scaled, 0, bytes, 0, byteCount);
+            }
+            long before = dataSize;
+            stream.Write(bytes, 0, byteCount); dataSize += byteCount;
+            if (dataSize / (rate * channels * 4) != before / (rate * channels * 4)) UpdateHeader();
+        }
+
+        private void UpdateHeader()
+        {
+            long position = stream.Position;
+            stream.Position = 4; writer.Write((uint)(50 + dataSize));
+            stream.Position = 46; writer.Write((uint)(dataSize / (channels * 4)));
+            stream.Position = 54; writer.Write((uint)dataSize);
+            stream.Position = position; stream.Flush();
+        }
+
+        public void Dispose()
+        {
+            if (disposed) return; disposed = true;
+            try { UpdateHeader(); } finally { writer.Dispose(); }
+        }
+    }
+}

package/source/FloatRecordingTests.cs

@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using NAudio.Wave;
+using NAudio.Wave.Asio;
+
+namespace DrumBuddy
+{
+    public static class FloatRecordingTests
+    {
+        private static readonly List<string> results = new List<string>();
+        private static void Check(bool ok, string description)
+        { if (!ok) throw new Exception(description); results.Add("PASS  " + description); }
+
+        private static void Feed(Recorder recorder, float[][] channels)
+        {
+            var pointers = new IntPtr[channels.Length];
+            try {
+                for (int c = 0; c < channels.Length; c++) {
+                    pointers[c] = Marshal.AllocHGlobal(channels[c].Length * 4);
+                    Marshal.Copy(channels[c], 0, pointers[c], channels[c].Length);
+                }
+                recorder.ProcessCapture(new AsioAudioAvailableEventArgs(pointers, new IntPtr[0], channels[0].Length, AsioSampleType.Float32LSB));
+            }
+            finally { foreach (var pointer in pointers) if (pointer != IntPtr.Zero) Marshal.FreeHGlobal(pointer); }
+        }
+
+        private static float[] ReadFloat(string path, int rate, int channels)
+        {
+            using (var reader = new WaveFileReader(path)) {
+                Check(reader.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat && reader.WaveFormat.BitsPerSample == 32,
+                    "Independent WAV reader identifies IEEE float, rather than integer PCM");
+                Check(reader.WaveFormat.SampleRate == rate && reader.WaveFormat.Channels == channels,
+                    "WAV retains " + rate + " Hz and " + channels + " channel(s)");
+                var bytes = new byte[checked((int)reader.Length)];
+                int read = 0, next;
+                while ((next = reader.Read(bytes, read, bytes.Length - read)) > 0) read += next;
+                var samples = new float[read / 4]; Buffer.BlockCopy(bytes, 0, samples, 0, read); return samples;
+            }
+        }
+
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "DrumBuddyFloat_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); results.Clear();
+            try {
+                Check(CaptureLayout.IsH5studio("ZOOM H5studio ASIO Driver") && CaptureLayout.IsH5studio("ZOOM H5 Studio") && !CaptureLayout.IsH5studio("ZOOM H5 ASIO Driver"),
+                    "Apply native float defaults to H5studio without confusing it with the older H5");
+                var pcmInput = new short[] { short.MinValue, 16384, -16384, short.MaxValue, 0, -8192, 8192, 0 };
+                var pcmBytes = new byte[pcmInput.Length * 2]; Buffer.BlockCopy(pcmInput, 0, pcmBytes, 0, pcmBytes.Length);
+                foreach (int mode in new[] { -1, 0, 2 }) {
+                    var recorder = new Recorder(); var layout = CaptureLayout.Create(2, mode);
+                    recorder.StartBuffered(layout, 32, Path.Combine(root, "windows-microphone-" + mode), 48000, false);
+                    recorder.ProcessWindowsPcm(pcmBytes, pcmBytes.Length, 2); recorder.ProcessWindowsPcm(pcmBytes, pcmBytes.Length, 2); recorder.Stop();
+                    recorder.ProcessWindowsPcm(pcmBytes, pcmBytes.Length, 2); recorder.Finish().GetAwaiter().GetResult();
+                    Check(recorder.Error == null && recorder.Frames == 8 && !recorder.SourceIsFloat && recorder.SourceFormat == "Windows 16-bit PCM",
+                        "Drain Windows PCM microphone buffers on Stop without claiming native float capture (mode " + mode + ")");
+                    for (int file = 0; file < recorder.Paths.Count; file++) {
+                        int savedChannels = layout.Separate ? 1 : layout.Channels;
+                        var actual = ReadFloat(recorder.Paths[file], 48000, savedChannels); bool exact = actual.Length == 8 * savedChannels;
+                        for (int f = 0; f < 8 && exact; f++) for (int c = 0; c < savedChannels; c++) {
+                            int sourceChannel = layout.Separate ? file : layout.FirstInput + c;
+                            exact &= actual[f * savedChannels + c] == pcmInput[(f % 4) * 2 + sourceChannel] / 32768f;
+                        }
+                        Check(exact, "Save exact Windows microphone samples with correct selected/separate channel routing (mode " + mode + ", file " + file + ")");
+                    }
+                }
+                var malformed = new Recorder(); malformed.StartBuffered(CaptureLayout.Create(1, 1), 16, Path.Combine(root, "windows-incomplete"), 44100, false);
+                malformed.ProcessWindowsPcm(new byte[3], 3, 1); malformed.Stop(); malformed.Finish().GetAwaiter().GetResult();
+                Check(malformed.Error is IOException && malformed.Frames == 0, "Reject incomplete Windows microphone frames without writing corrupt samples");
+                foreach (int channels in new[] { 2, 4 }) {
+                    int rate = channels == 2 ? 48000 : 96000;
+                    string folder = Path.Combine(root, channels + "-input-float");
+                    var input = new float[channels][];
+                    for (int c = 0; c < channels; c++) {
+                        input[c] = new float[1024];
+                        for (int i = 0; i < input[c].Length; i++) input[c][i] = (float)((c + 2.5) * Math.Sin(i * .071 + c * .3));
+                        input[c][0] = c % 2 == 0 ? 4.25f + c : -3.5f - c;
+                    }
+                    var recorder = new Recorder();
+                    recorder.StartBuffered(CaptureLayout.Create(channels, channels == 2 ? 0 : -1), 32, folder, rate, true);
+                    Feed(recorder, input); Feed(recorder, input); recorder.Stop();
+                    Feed(recorder, input); // A final driver callback after Stop must not append another block.
+                    recorder.Finish().GetAwaiter().GetResult();
+                    Check(recorder.Error == null && recorder.Frames == 2048 && recorder.SourceIsFloat,
+                        "Drain queued ASIO float buffers on Stop and ignore late callbacks (" + channels + " inputs)");
+                    Check(recorder.Paths.Count == (channels == 2 ? 1 : 4),
+                        "Use the device's actual channel count for stereo / separate multitrack capture");
+                    for (int file = 0; file < recorder.Paths.Count; file++) {
+                        int fileChannels = channels == 2 ? 2 : 1;
+                        var actual = ReadFloat(recorder.Paths[file], rate, fileChannels);
+                        bool exact = actual.Length == 2048 * fileChannels;
+                        for (int f = 0; f < 2048 && exact; f++)
+                            for (int c = 0; c < fileChannels; c++)
+                                exact &= actual[f * fileChannels + c] == input[fileChannels == 2 ? c : file][f % 1024];
+                        Check(exact && actual.Any(value => Math.Abs(value) > 1),
+                            "Preserve every float sample and headroom above 0 dBFS in " + Path.GetFileName(recorder.Paths[file]));
+                        byte[] bytes = File.ReadAllBytes(recorder.Paths[file]);
+                        Check(BitConverter.ToUInt32(bytes, 4) == bytes.Length - 8 && BitConverter.ToUInt16(bytes, 20) == 3 &&
+                            Encoding.ASCII.GetString(bytes, 38, 4) == "fact" && BitConverter.ToUInt32(bytes, 46) == 2048 &&
+                            BitConverter.ToUInt32(bytes, 54) == bytes.Length - 58,
+                            "Finalize RIFF, IEEE float, fact-frame and data sizes correctly");
+                        Audio.Run("-hide_banner -v error -nostdin -i " + Audio.Q(recorder.Paths[file]) + " -f null -", CancellationToken.None, null, true);
+                    }
+                }
+
+                var integerInput = new Recorder();
+                integerInput.StartBuffered(CaptureLayout.Create(2, 0), 32, Path.Combine(root, "integer-driver-rejected"), 48000, true);
+                IntPtr data = Marshal.AllocHGlobal(16);
+                try {
+                    Marshal.Copy(new int[] { 0, int.MaxValue, int.MinValue, 0 }, 0, data, 4);
+                    integerInput.ProcessCapture(new AsioAudioAvailableEventArgs(new[] { data, data }, new IntPtr[0], 4, AsioSampleType.Int32LSB));
+                }
+                finally { Marshal.FreeHGlobal(data); }
+                integerInput.Stop(); integerInput.Finish().GetAwaiter().GetResult();
+                Check(integerInput.Error != null && integerInput.Frames == 0 && integerInput.Error.Message.Contains("native 32-bit float"),
+                    "Reject integer ASIO input when native H5studio float is required");
+
+                var invalid = new Recorder();
+                invalid.StartBuffered(CaptureLayout.Create(1, 1), 32, Path.Combine(root, "invalid-after-good"), 44100, true);
+                Feed(invalid, new[] { new[] { 2.5f, -2.25f, .125f } });
+                Feed(invalid, new[] { new[] { float.NaN } });
+                invalid.Stop(); invalid.Finish().GetAwaiter().GetResult();
+                Check(invalid.Error != null && ReadFloat(invalid.Paths[0], 44100, 1).SequenceEqual(new[] { 2.5f, -2.25f, .125f }),
+                    "Keep valid captured audio when a later driver buffer contains NaN");
+                bool rejected = false;
+                try { CaptureLayout.Create(4, 5); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject nonexistent input 5 on a four-input H5studio");
+
+                foreach (int bits in new[] { 16, 24 }) {
+                    var legacy = new Recorder();
+                    legacy.StartBuffered(CaptureLayout.Create(8, -1), bits, Path.Combine(root, "r16-" + bits), 44100, false);
+                    Feed(legacy, Enumerable.Range(0, 8).Select(c => new[] { c / 16.0f, -.25f }).ToArray());
+                    legacy.Stop(); legacy.Finish().GetAwaiter().GetResult();
+                    Check(legacy.Error == null && legacy.Paths.Count == 8, "Keep R16 eight-input " + bits + "-bit recording");
+                    using (var wav = new WaveFileReader(legacy.Paths[7]))
+                        Check(wav.WaveFormat.Encoding == WaveFormatEncoding.Pcm && wav.WaveFormat.BitsPerSample == bits && wav.WaveFormat.SampleRate == 44100 && wav.Length == 2 * bits / 8,
+                            "Keep R16 classic PCM format and frame count");
+                }
+
+                string master = Path.Combine(root, "2-input-float", "STEREO.WAV");
+                byte[] original = File.ReadAllBytes(master);
+                Clip clip = Audio.Load(master, Path.Combine(root, "decoded"), CancellationToken.None, null);
+                Check(clip.Ready && clip.Peak > 1, "Import a 48 kHz float WAV without discarding its over-0-dBFS samples");
+                clip.Gain = -1 - clip.PeakDb;
+                foreach (int bits in new[] { 16, 24 }) {
+                    string path = Audio.Export(clip, Path.Combine(root, "compatible-" + bits), bits, true, CancellationToken.None, null);
+                    var pcm = Audio.Load(path, Path.Combine(root, "decoded"), CancellationToken.None, null);
+                    using (var wav = new WaveFileReader(path))
+                        Check(wav.WaveFormat.Encoding == WaveFormatEncoding.Pcm && wav.WaveFormat.SampleRate == 44100 && wav.WaveFormat.BitsPerSample == bits,
+                            "Make a standard " + bits + "-bit PCM playback copy from the float master");
+                    Check(Math.Abs(pcm.PeakDb + 1) < .02, "Recover float peaks by reducing gain before PCM export");
+                }
+                Check(original.SequenceEqual(File.ReadAllBytes(master)), "Keep the original 32-bit float master byte-for-byte unchanged during conversion");
+                bool overwriteRejected = false;
+                try { using (var writer = new FloatWaveWriter(master, 2, 48000)) { } } catch (IOException) { overwriteRejected = true; }
+                Check(overwriteRejected && original.SequenceEqual(File.ReadAllBytes(master)), "Refuse to overwrite an existing master recording");
+                results.Add("Hardware acceptance pending: connect a physical H5studio with Zoom's Windows ASIO driver and test both Stereo mix and Multi Track.");
+                File.WriteAllLines(Path.Combine(root, "float-test-results.txt"), results, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) {
+                results.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "float-test-results.txt"), results, Encoding.UTF8); return 1;
+            }
+        }
+    }
+}

package/source/Flux-Mark.svg

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="100 280 1050 800" role="img" aria-labelledby="title desc">
+  <title id="title">Flux mark</title>
+  <desc id="desc">A cyan-to-violet F with a continuous audio waveform, a bright icy-cyan crest and three tempo bars. Vector paths only.</desc>
+  <defs>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="body" gradientUnits="userSpaceOnUse" x1="310" y1="1020" x2="780" y2="485">
+      <stop offset="0" stop-color="#00D7DD" />
+      <stop offset="0.36" stop-color="#047FBF" />
+      <stop offset="0.72" stop-color="#064397" />
+      <stop offset="1" stop-color="#022966" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="top" gradientUnits="userSpaceOnUse" x1="420" y1="360" x2="1130" y2="420">
+      <stop offset="0" stop-color="#00FFE0" />
+      <stop offset="0.48" stop-color="#009BFF" />
+      <stop offset="1" stop-color="#9426FF" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="lower" gradientUnits="userSpaceOnUse" x1="290" y1="1030" x2="830" y2="750">
+      <stop offset="0" stop-color="#00F2DC" />
+      <stop offset="0.35" stop-color="#00C8F2" />
+      <stop offset="0.64" stop-color="#146CFF" />
+      <stop offset="1" stop-color="#9527FF" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="wave" gradientUnits="userSpaceOnUse" x1="310" y1="650" x2="1000" y2="535">
+      <stop offset="0" stop-color="#00FFE1" />
+      <stop offset="0.3" stop-color="#40F9FF" />
+      <stop offset="0.36" stop-color="#ACFFFF" />
+      <stop offset="0.52" stop-color="#27DBFF" />
+      <stop offset="0.78" stop-color="#628EFF" />
+      <stop offset="1" stop-color="#BE31FF" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="tempo" gradientUnits="userSpaceOnUse" x1="770" y1="650" x2="990" y2="510">
+      <stop offset="0" stop-color="#28C8FF" />
+      <stop offset="0.5" stop-color="#8E8AFF" />
+      <stop offset="1" stop-color="#BF27FF" />
+    </linearGradient>
+  </defs>
+  <path fill="url(#body)" d="M260 1058 L446 545 C455 517 470 493 489 480 L466 459 L495 371 C514 319 552 294 608 294 H1118 C1139 294 1137 306 1123 330 L1097 374 C1079 407 1051 421 1012 421 H711 C676 421 661 432 649 465 L624 532 H903 C924 532 936 519 949 517 L983 516 C998 516 1002 525 994 540 L962 605 C947 637 922 652 885 655 L604 689 C576 695 556 711 540 738 H829 C847 738 850 744 841 760 L811 812 C798 835 776 844 745 844 H519 C489 844 475 861 462 890 L430 970 C408 1020 348 1052 260 1058 Z" />
+  <path fill="url(#top)" d="M371 579 L446 379 C466 326 514 294 575 294 H1123 C1144 294 1136 310 1123 330 L1097 374 C1079 407 1051 421 1012 421 H701 C639 421 602 421 557 444 C474 484 423 543 371 579 Z" />
+  <path fill="url(#lower)" d="M260 1058 C294 980 342 849 398 778 C437 725 481 693 532 692 C557 695 574 711 588 738 H829 C847 738 850 744 841 760 L811 812 C798 835 776 844 745 844 H519 C489 844 475 861 462 890 L430 970 C408 1020 348 1052 260 1058 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#wave)" d="M118 651 L318 642 C331 641 342 644 352 649 L352 659 C338 664 330 666 316 665 L118 660 C110 660 108 655 118 651 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="url(#wave)" stroke-width="66" stroke-linecap="round" stroke-linejoin="round" opacity="0.06" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="url(#wave)" stroke-width="48" stroke-linecap="round" stroke-linejoin="round" opacity="0.14" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="#052C69" stroke-width="36" stroke-linecap="round" stroke-linejoin="round" opacity="0.92" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="url(#wave)" stroke-width="23" stroke-linecap="round" stroke-linejoin="round" opacity="1" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="#D5FFFF" stroke-width="4.5" stroke-linecap="round" stroke-linejoin="round" opacity="0.66" d="M509 603 L534 514 C541 492 550 490 558 508 C567 532 571 579 575 605" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#tempo)" d="M777 639 C770 639 768 634 771 627 L805 549 C808 542 812 540 820 540 H839 C847 540 850 546 847 553 L815 631 C812 638 808 641 801 641 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#tempo)" d="M840 639 C833 639 831 634 834 627 L875 531 C878 524 883 522 891 522 H916 C924 522 926 528 923 535 L882 631 C879 638 875 641 867 641 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#tempo)" d="M904 639 C897 639 895 634 898 627 L941 526 C944 519 950 516 958 516 H984 C993 516 996 523 992 531 L952 624 C947 635 938 641 927 641 Z" />
+</svg>

package/source/FluxTempo Logo Prompt.txt

@@ -0,0 +1,3 @@
+Tool: built-in image_gen, logo-brand generation with transparent background.
+Prompt: Create a polished standalone app emblem for FluxTempo, a sound production and multitrack recording/editor application. Short, clean, modern and energetic identity with a subtle sleek starship-instrument feel. A distinctive bold abstract F made from a flowing audio waveform and precisely spaced tempo-like strokes, forming one coherent simple symbol. Crisp smooth edges, electric cyan/teal to cool violet accents, strong small-icon silhouette, centered square composition, generous transparent padding. No text, wordmark, mascot, fantasy ornamentation, mockup or outer glow. Readable on charcoal and light surfaces.
+The original black-haired Drum Buddy mascot is archived separately and preserved.

package/source/FluxTempo-Mark.svg

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="100 280 1050 800" role="img" aria-labelledby="title desc">
+  <title id="title">FluxTempo mark</title>
+  <desc id="desc">A cyan-to-violet F with a continuous audio waveform, a bright icy-cyan crest and three tempo bars. Vector paths only.</desc>
+  <defs>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="body" gradientUnits="userSpaceOnUse" x1="310" y1="1020" x2="780" y2="485">
+      <stop offset="0" stop-color="#00D7DD" />
+      <stop offset="0.36" stop-color="#047FBF" />
+      <stop offset="0.72" stop-color="#064397" />
+      <stop offset="1" stop-color="#022966" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="top" gradientUnits="userSpaceOnUse" x1="420" y1="360" x2="1130" y2="420">
+      <stop offset="0" stop-color="#00FFE0" />
+      <stop offset="0.48" stop-color="#009BFF" />
+      <stop offset="1" stop-color="#9426FF" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="lower" gradientUnits="userSpaceOnUse" x1="290" y1="1030" x2="830" y2="750">
+      <stop offset="0" stop-color="#00F2DC" />
+      <stop offset="0.35" stop-color="#00C8F2" />
+      <stop offset="0.64" stop-color="#146CFF" />
+      <stop offset="1" stop-color="#9527FF" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="wave" gradientUnits="userSpaceOnUse" x1="310" y1="650" x2="1000" y2="535">
+      <stop offset="0" stop-color="#00FFE1" />
+      <stop offset="0.3" stop-color="#40F9FF" />
+      <stop offset="0.36" stop-color="#ACFFFF" />
+      <stop offset="0.52" stop-color="#27DBFF" />
+      <stop offset="0.78" stop-color="#628EFF" />
+      <stop offset="1" stop-color="#BE31FF" />
+    </linearGradient>
+    <linearGradient xmlns="http://www.w3.org/2000/svg" id="tempo" gradientUnits="userSpaceOnUse" x1="770" y1="650" x2="990" y2="510">
+      <stop offset="0" stop-color="#28C8FF" />
+      <stop offset="0.5" stop-color="#8E8AFF" />
+      <stop offset="1" stop-color="#BF27FF" />
+    </linearGradient>
+  </defs>
+  <path fill="url(#body)" d="M260 1058 L446 545 C455 517 470 493 489 480 L466 459 L495 371 C514 319 552 294 608 294 H1118 C1139 294 1137 306 1123 330 L1097 374 C1079 407 1051 421 1012 421 H711 C676 421 661 432 649 465 L624 532 H903 C924 532 936 519 949 517 L983 516 C998 516 1002 525 994 540 L962 605 C947 637 922 652 885 655 L604 689 C576 695 556 711 540 738 H829 C847 738 850 744 841 760 L811 812 C798 835 776 844 745 844 H519 C489 844 475 861 462 890 L430 970 C408 1020 348 1052 260 1058 Z" />
+  <path fill="url(#top)" d="M371 579 L446 379 C466 326 514 294 575 294 H1123 C1144 294 1136 310 1123 330 L1097 374 C1079 407 1051 421 1012 421 H701 C639 421 602 421 557 444 C474 484 423 543 371 579 Z" />
+  <path fill="url(#lower)" d="M260 1058 C294 980 342 849 398 778 C437 725 481 693 532 692 C557 695 574 711 588 738 H829 C847 738 850 744 841 760 L811 812 C798 835 776 844 745 844 H519 C489 844 475 861 462 890 L430 970 C408 1020 348 1052 260 1058 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#wave)" d="M118 651 L318 642 C331 641 342 644 352 649 L352 659 C338 664 330 666 316 665 L118 660 C110 660 108 655 118 651 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="url(#wave)" stroke-width="66" stroke-linecap="round" stroke-linejoin="round" opacity="0.06" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="url(#wave)" stroke-width="48" stroke-linecap="round" stroke-linejoin="round" opacity="0.14" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="#052C69" stroke-width="36" stroke-linecap="round" stroke-linejoin="round" opacity="0.92" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="url(#wave)" stroke-width="23" stroke-linecap="round" stroke-linejoin="round" opacity="1" d="M319 654 C351 654 363 628 385 599 C397 583 405 577 413 583 C427 596 440 641 456 669 C466 688 481 688 490 665 L533 514 C540 491 550 487 558 505 C571 535 573 604 584 635 C589 651 600 656 612 643 L646 610 C655 601 664 605 674 617 C689 635 708 644 725 637 C735 633 742 620 746 606 L760 568" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="none" stroke="#D5FFFF" stroke-width="4.5" stroke-linecap="round" stroke-linejoin="round" opacity="0.66" d="M509 603 L534 514 C541 492 550 490 558 508 C567 532 571 579 575 605" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#tempo)" d="M777 639 C770 639 768 634 771 627 L805 549 C808 542 812 540 820 540 H839 C847 540 850 546 847 553 L815 631 C812 638 808 641 801 641 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#tempo)" d="M840 639 C833 639 831 634 834 627 L875 531 C878 524 883 522 891 522 H916 C924 522 926 528 923 535 L882 631 C879 638 875 641 867 641 Z" />
+  <path xmlns="http://www.w3.org/2000/svg" fill="url(#tempo)" d="M904 639 C897 639 895 634 898 627 L941 526 C944 519 950 516 958 516 H984 C993 516 996 523 992 531 L952 624 C947 635 938 641 927 641 Z" />
+</svg>

package/source/HomeView.cs

@@ -0,0 +1,32 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media.Imaging;
+
+namespace DrumBuddy
+{
+    public sealed class HomeView : ScrollViewer
+    {
+        private readonly List<Button> tiles = new List<Button>();
+        public HomeView(Action<string> open)
+        {
+            VerticalScrollBarVisibility = ScrollBarVisibility.Auto; HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
+            var page = new StackPanel { Margin = new Thickness(12, 14, 12, 16) }; Content = page;
+            var hero = new DockPanel { Margin = new Thickness(0, 0, 0, 28) };
+            var mark = new Image { Width = 88, Height = 88, Margin = new Thickness(0, 0, 20, 0), Source = BrandArtwork.Raster() }; DockPanel.SetDock(mark, Dock.Left); hero.Children.Add(mark);
+            var heading = new StackPanel { VerticalAlignment = VerticalAlignment.Center }; heading.Children.Add(WorkspaceUi.Text("Your workspace", 30)); heading.Children.Add(WorkspaceUi.Text("Choose a tool, or return to your timeline.", 15)); hero.Children.Add(heading); page.Children.Add(hero);
+            var apps = new WrapPanel(); page.Children.Add(apps);
+            string[,] entries = { { "editor", "Editor + Record", "Record, arrange and edit audio across 16 tracks." }, { "converter", "Converter", "Change audio format and sample rate for other devices." }, { "player", "Media Player", "Listen to PCM, float WAV and other audio formats." }, { "control", "R16 Control", "Open the hardware panel, mixer and MIDI controls." }, { "audio", "Audio devices", "Choose speakers, headphones and recording inputs." }, { "keybinds", "Keybinds", "Make the keyboard shortcuts work your way." } };
+            for (int i = 0; i < entries.GetLength(0); i++) {
+                string action = entries[i, 0]; var body = new StackPanel { Margin = new Thickness(18, 16, 18, 16) };
+                var name = WorkspaceUi.Text(entries[i, 1], 20); name.FontWeight = FontWeights.SemiBold; name.Margin = new Thickness(0, 0, 0, 12); body.Children.Add(name);
+                var detail = WorkspaceUi.Text(entries[i, 2], 14); detail.Foreground = WorkspaceUi.Color("#526771"); body.Children.Add(detail);
+                var button = new Button { Content = body, Height = 134, Margin = new Thickness(0, 0, 12, 12), Background = WorkspaceUi.Color("#FFFFFF"), Foreground = WorkspaceUi.Color("#182C37"), BorderBrush = WorkspaceUi.Color("#C3CED0"), HorizontalContentAlignment = HorizontalAlignment.Stretch, Padding = new Thickness(0) };
+                button.Click += delegate { open(action); }; tiles.Add(button); apps.Children.Add(button);
+            }
+            SizeChanged += delegate { double available = Math.Max(280, ActualWidth - 40); int columns = available >= 1000 ? 3 : available >= 620 ? 2 : 1; foreach (var tile in tiles) tile.Width = Math.Max(240, available / columns - 12); };
+        }
+    }
+}