S12: editor scale + S15/S16 control surfaces

Pure browser_scroll/note_entry/param_slider modules (+ CTest) for scroll,
type-to-filter search, numeric note entry, and the AHDSR/Trigger/pitch-engine/
pitch-env control panel. Editor shell draws + routes through them; params edit
the selected zone's ZonePlayParams via commitAndReload.

src/vst/note_entry.cpp

@@ -0,0 +1,113 @@
+// note_entry.cpp — see note_entry.h. PURE text->MIDI-note parse for the S12 numeric entry.
+
+#include "note_entry.h"
+
+#include <algorithm>
+#include <cctype>
+
+namespace reasampler::vst {
+
+namespace {
+char asciiUpper(char c) {
+    return static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
+}
+
+std::string trim(const std::string& s) {
+    std::size_t a = 0;
+    std::size_t b = s.size();
+    while (a < b && std::isspace(static_cast<unsigned char>(s[a]))) ++a;
+    while (b > a && std::isspace(static_cast<unsigned char>(s[b - 1]))) --b;
+    return s.substr(a, b - a);
+}
+
+int clampNote(long long n) {
+    if (n < 0) return 0;
+    if (n > 127) return 127;
+    return static_cast<int>(n);
+}
+
+// Semitone offset within an octave for a note letter (C..B), or -1 for a non-letter.
+int letterSemitone(char up) {
+    switch (up) {
+        case 'C': return 0;
+        case 'D': return 2;
+        case 'E': return 4;
+        case 'F': return 5;
+        case 'G': return 7;
+        case 'A': return 9;
+        case 'B': return 11;
+        default: return -1;
+    }
+}
+
+// Parse a note name like "C4", "F#3", "Bb-1" (case-insensitive). MIDI 0 == C-1, 60 == C4
+// (the DAW convention the editor's noteLabel uses). Returns nullopt if it is not a note name.
+std::optional<int> parseNoteName(const std::string& s) {
+    if (s.empty()) return std::nullopt;
+    std::size_t i = 0;
+    const int base = letterSemitone(asciiUpper(s[i]));
+    if (base < 0) return std::nullopt;  // not a letter -> not a note name
+    ++i;
+    int semitone = base;
+    // Optional accidental(s): # / b (or 's'/'f' are NOT accepted — keep it to the two glyphs).
+    while (i < s.size() && (s[i] == '#' || s[i] == 'b' || s[i] == 'B')) {
+        // A trailing 'b'/'B' could be a flat OR the start of nothing; here after a letter it is
+        // an accidental. '#' raises, 'b'/'B' lowers.
+        if (s[i] == '#') ++semitone;
+        else --semitone;
+        ++i;
+    }
+    // The octave: an optional sign then digits, running to the end.
+    if (i >= s.size()) return std::nullopt;  // a bare "C" has no octave -> reject (ambiguous)
+    bool neg = false;
+    if (s[i] == '+' || s[i] == '-') {
+        neg = (s[i] == '-');
+        ++i;
+    }
+    if (i >= s.size()) return std::nullopt;
+    int octave = 0;
+    bool anyDigit = false;
+    for (; i < s.size(); ++i) {
+        if (!std::isdigit(static_cast<unsigned char>(s[i]))) return std::nullopt;
+        octave = octave * 10 + (s[i] - '0');
+        anyDigit = true;
+    }
+    if (!anyDigit) return std::nullopt;
+    if (neg) octave = -octave;
+    // MIDI note = (octave + 1) * 12 + semitone  (C-1 == 0, C4 == 60).
+    const long long note = static_cast<long long>(octave + 1) * 12 + semitone;
+    return clampNote(note);
+}
+
+std::optional<int> parseInteger(const std::string& s) {
+    if (s.empty()) return std::nullopt;
+    std::size_t i = 0;
+    bool neg = false;
+    if (s[i] == '+' || s[i] == '-') {
+        neg = (s[i] == '-');
+        ++i;
+    }
+    if (i >= s.size()) return std::nullopt;
+    long long v = 0;
+    for (; i < s.size(); ++i) {
+        if (!std::isdigit(static_cast<unsigned char>(s[i]))) return std::nullopt;
+        v = v * 10 + (s[i] - '0');
+        if (v > 1000000) v = 1000000;  // saturate; clampNote takes it to 127 anyway
+    }
+    if (neg) v = -v;
+    return clampNote(v);
+}
+}  // namespace
+
+std::optional<int> parseNoteEntry(const std::string& text) {
+    const std::string s = trim(text);
+    if (s.empty()) return std::nullopt;
+    // Try a plain integer first (the common MIDI-number case); fall back to a note name.
+    if (std::isdigit(static_cast<unsigned char>(s[0])) || s[0] == '+' ||
+        (s[0] == '-' && s.size() > 1 && std::isdigit(static_cast<unsigned char>(s[1])))) {
+        if (auto n = parseInteger(s)) return n;
+    }
+    return parseNoteName(s);
+}
+
+}  // namespace reasampler::vst