Merge branch 'omega-w1-t3-meter-rate' into phase-omega

src/core/instrument/CLAUDE.md

@@ -362,7 +362,7 @@ anything for a trigger shape.
   drag the bank model and the WAV codec in behind it. The shell keeps only the controls the
   parameter set does not carry (key-track, voice count, master gain, preview velocity) and the
   labels for them.
-- `master_meter` — the MASTER column's interior, split from `knob_deck` on the axis `sample_chrome` has to `sample_bands`: that says where the column is, this lays out inside it (22 px numeral gutter · 4 · 36 px bar field) and holds the per-instance UI state the bars draw from. `kMeterColumnW` is the SUM of those three, exported so `deck_groups`' MASTER descriptor reserves exactly what the interior consumes — the column is banked to grow, and a reserve that did not track it would underfill or overrun silently. **Bar count takes a RESOLVED `LaneSplit`, the same value `waveform_view`'s `resolveLaneSplit` answers** — a mono source under stereo mode is dual-mono, and two identical bars would be a lie. Also owns `meterTickNumeralled` (the spec-pinned 0/−12/−24/−36/−48/−60 numeral set, beside the tick step it derives from), `meterNumeralRect` (bottom-clamped, so the floor tick's numeral cannot hang out of the gutter), and `meterSingleLaneState` — the one bar folds both channels PER FIELD, never picking a whole channel by level. Composes `engine/meter_ballistics` per channel and gives the gain-reduction lamp the peak tick's own hold-then-release, without which a catch smaller than 20 dB × the UI period is dark again before it has been drawn twice; the audio thread's clip flag is ORed in because it is the only latch that sees every block. `meterDrawEqual` is what lets the UI tick repaint on change alone.
+- `master_meter` — the MASTER column's interior, split from `knob_deck` on the axis `sample_chrome` has to `sample_bands`: that says where the column is, this lays out inside it (22 px numeral gutter · 4 · 36 px bar field) and holds the per-instance UI state the bars draw from. `kMeterColumnW` is the SUM of those three, exported so `deck_groups`' MASTER descriptor reserves exactly what the interior consumes — the column is banked to grow, and a reserve that did not track it would underfill or overrun silently. **Bar count takes a RESOLVED `LaneSplit`, the same value `waveform_view`'s `resolveLaneSplit` answers** — a mono source under stereo mode is dual-mono, and two identical bars would be a lie. Also owns `meterTickNumeralled` (the spec-pinned 0/−12/−24/−36/−48/−60 numeral set, beside the tick step it derives from), `meterNumeralRect` (bottom-clamped, so the floor tick's numeral cannot hang out of the gutter), and `meterSingleLaneState` — the one bar folds both channels PER FIELD, never picking a whole channel by level. Composes `engine/meter_ballistics` per channel and gives the gain-reduction lamp the peak tick's own hold-then-release, without which a catch smaller than 20 dB × the UI period is dark again before it has been drawn twice; the audio thread's clip flag is ORed in because it is the only latch that sees every block. `meterDrawEqual` is what lets the UI tick repaint on change alone. Also owns the editor's two paint-dispatch predicates, so neither lives as a bare comment in the shell: `meterFastPathEligible` (is a WM_PAINT dirty rect wholly inside the field?) and `meterBarsWithinField` (the self-containment invariant that fast path rests on), both asserted in `test_master_meter.cpp`.
 - `deck_groups` — also home to `deckParamCommit` and `liveCommitFor`, the editor's whole commit-tier routing decision (see "Live parameter delivery" above), and to `OverlayEnv` + `nextOverlaySelection`/`overlayEnvEnabled`/`overlayEnvInert`, the whole overlay-selection state machine (exclusivity, the none resting state, and which selections a disabled or DRAWN group makes inert); WHICH groups the Sample face's deck carries, split from `knob_deck`'s HOW they lay out: the `DeckParam` control-id space (the editor's `ParamControl` is an alias of it), the `DeckGroupId` list, `sampleDeckGroups` in signal-flow order (**pitch → filter → amp**, then velocity/voice/master), and the deck's bipolar-knob law. Reads `PlayMode` for the AMP group's Gate/Trigger face, which is why this and not `knob_deck` is the module that touches the engine's value layer. Also home to `CurveTarget` + `curveTargetFor` — the VELOCITY group's three cells are popup openers, not dials, and that predicate is the ONE place they are named, so paint, hit-test routing and the popup's title all agree. MASTER is reserved for post-voice-mixer concerns, which is why the curves sit in their own group immediately left of VOICE rather than there; it now discharges that reservation as the double-height bus deck — gain, the limiter enable, one reserved slot, the meter column and the GR lamp. FILTER's `Band|Notch` rides its caption slack rather than the knob row: that is the −92 px that makes the SOUND row fit its block, and putting it back breaks the fit. VOICE's `Retrig|Legato` deliberately stays in the knob row — VOICE's caption row is the binding side, so moving it there makes the group 226 rather than 164.
 - `spline_edit` — THE point-editing grammar, and the one place it is written down: left-click grabs a node and adds one in empty space, right-click deletes, control-click toggles hard/smooth. Both spline consumers — the velocity-curve popup and the spline EG overlay — route their mouse-down through `resolveSplineEdit`, so the two cannot drift into two grammars. The endpoint and point-count rules are NOT restated here: `deletePoint` and `addPoint` own them, and the caller applies the resolved action to the curve. Also home to `splineOverlayBox`, the contour's mapping box inside the waveform overlay — the FULL area, no inset, so the drawn contour stays 1:1 with the sample's time axis. Spline points are excluded from `param_taper`'s Shift/Ctrl modifier law like waveform markers are: a point is a normalized position with no displayed unit, and control-click there is already claimed by the hard/smooth toggle above.
 - `curve_popup` — pure curve-popup geometry + dismissal test (FB1): centered sheet over the Sample face — width/height clamps, title row, Close button rect, curve-box rect, outside-sheet dismissal test. Mirror of `overflow_menu`; no LICE or REAPER types.

src/core/instrument/ui/master_meter.cpp

@@ -26,6 +26,24 @@ MeterRects meterRects(const Rect& column, LaneSplit split) {
     return r;
 }
 
+bool meterFastPathEligible(const MeterRects& m, const Rect& dirty) {
+    return !m.field.empty() && dirty.x >= m.field.x && dirty.y >= m.field.y &&
+           dirty.right() <= m.field.right() && dirty.bottom() <= m.field.bottom();
+}
+
+namespace {
+bool rectWithin(const Rect& outer, const Rect& inner) {
+    return inner.empty() ||
+           (inner.x >= outer.x && inner.right() <= outer.right() && inner.y >= outer.y &&
+            inner.bottom() <= outer.bottom());
+}
+}  // namespace
+
+bool meterBarsWithinField(const MeterRects& m) {
+    if (m.field.empty()) return m.barA.empty() && m.barB.empty();
+    return rectWithin(m.field, m.barA) && rectWithin(m.field, m.barB);
+}
+
 Rect meterNumeralRect(const Rect& labels, int y) {
     if (labels.empty()) return {};
     int top = y - 5;

src/core/instrument/ui/master_meter.h

@@ -42,6 +42,19 @@ struct MeterRects {
 // A column narrower than kMeterColumnW yields nothing rather than an overrunning field.
 MeterRects meterRects(const Rect& column, LaneSplit split);
 
+// Whether `dirty` (a WM_PAINT update rect, already client-clipped) lies wholly inside the bar
+// field — the editor's meter-frame fast-path test. Geometric, not a flag: the caller decides
+// per paint from the rect Windows actually handed it, never from a remembered "was this a
+// meter tick" bit, because Windows unions a meter invalidate with any other pending one into a
+// single rcPaint and a flag would then paint a meter frame over a face that had really changed.
+bool meterFastPathEligible(const MeterRects& m, const Rect& dirty);
+
+// The structural invariant drawMeterField's self-containment rests on: every bar it paints
+// stays inside the field it fills first. The ticks, the held-peak tick and the clip cap are all
+// drawn directly off `field`'s own coordinates and so are bounded by construction; the bars are
+// the one independently-computed rect that isn't.
+bool meterBarsWithinField(const MeterRects& m);
+
 // y of `db` inside the bar field — kMeterTopDb at the top edge, kMeterFloorDb at the bottom,
 // linear in dB between, clamped outside.
 int meterDbToY(const Rect& field, double db);