Merge pS-fa2-envmodel: fully-editable bounded amp envelope nodes (Gate + Trigger)

src/vst/envelope_edit.cpp

@@ -23,6 +23,16 @@ double secondsPerPixel(const Rect& area, double totalSeconds) {
     return totalSeconds / static_cast<double>(w);
 }
 
+// Seconds per pixel for a GATE time-node drag (FA2): the reciprocal of the overlay's
+// param-domain gatePxPerSecond(area) scale — sample-length-free, matching
+// envelope_overlay::gatePolyline exactly so the dragged handle tracks the cursor 1:1 (each
+// node's x is affine in its own segment duration with slope gatePxPerSecond). Zero when the
+// area is degenerate.
+double gateSecondsPerPixel(const Rect& area) {
+    const double pps = gatePxPerSecond(area);
+    return pps > 0.0 ? 1.0 / pps : 0.0;
+}
+
 // Level (0..1) represented by one vertical pixel. levelToY spans (height-1) rows for [0,1], so one
 // pixel is 1/(height-1). Zero when degenerate. Matches envelope_overlay::levelToY.
 double levelPerPixel(const Rect& area) {
@@ -42,44 +52,81 @@ bool isDraggable(EnvNode n) {
     }
 }
 
+// True when the node belongs to the envelope's active mode. Guards the degenerate cross-mode
+// write: the degenerate baseline polyline carries a ReleaseEnd vertex regardless of mode, so a
+// zero-height Trigger-mode grab of it must not write releaseSeconds (and vice versa for Gate
+// nodes vs Trigger fields). Applied by BOTH the hit-test and the drag resolver so they agree.
+bool nodeInMode(EnvNode n, EnvMode m) {
+    switch (n) {
+        case EnvNode::AttackEnd:
+        case EnvNode::HoldEnd:
+        case EnvNode::DecayEnd:
+        case EnvNode::ReleaseEnd:
+            return m == EnvMode::Gate;
+        case EnvNode::FadeInEnd:
+        case EnvNode::FadeOutStart:
+        case EnvNode::LengthEnd:
+            return m == EnvMode::Trigger;
+        case EnvNode::Origin:
+        case EnvNode::ReleaseStart:
+            return false;  // never draggable in any mode (isDraggable filters these anyway)
+    }
+    return false;
+}
+
 }  // namespace
 
 NodeHit nodeAtPoint(const AmpEnvelope& env, const Rect& area, double totalSeconds, int x, int y) {
     const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, area, totalSeconds);
-    // First-match in draw order (deterministic tie-break), skipping non-draggable anchors.
+    // NEAREST draggable, mode-matching node within the pick radius wins (Chebyshev distance —
+    // the square grab box); ties break to the earlier draw-order node (FA2). Gate nodes never
+    // coincide (the forward map enforces kGateNodeSepPx separation), so the tie-break only
+    // matters for Trigger's zero-fade-out coincidence: FadeOutStart overlays LengthEnd, WINS the
+    // tie, and can be dragged inward from the right edge. The mode filter keeps the degenerate
+    // baseline's ReleaseEnd vertex from registering as a grabbable node in Trigger mode.
+    NodeHit best;
+    int bestDist = kNodeGrabRadius + 1;
     for (const EnvVertex& v : poly) {
-        if (!isDraggable(v.node)) continue;
-        if (std::abs(x - v.x) <= kNodeGrabRadius && std::abs(y - v.y) <= kNodeGrabRadius) {
-            return NodeHit{true, v.node};
+        if (!isDraggable(v.node) || !nodeInMode(v.node, env.mode)) continue;
+        const int dist = std::max(std::abs(x - v.x), std::abs(y - v.y));
+        if (dist < bestDist) {  // strictly closer only: earlier draw order keeps ties
+            bestDist = dist;
+            best = NodeHit{true, v.node};
         }
     }
-    return NodeHit{false, EnvNode::Origin};
+    return best;
 }
 
 AmpEnvelope resolveNodeDrag(const AmpEnvelope& grabEnv, EnvNode node, const Rect& area,
                             double totalSeconds, const EnvClampBounds& bounds,
                             int dxPixels, int dyPixels) {
     AmpEnvelope out = grabEnv;
-    if (!isDraggable(node)) return out;
+    if (!isDraggable(node) || !nodeInMode(node, grabEnv.mode)) return out;
 
     const double secPerPx = secondsPerPixel(area, totalSeconds);
     if (secPerPx <= 0.0) return out;  // degenerate area / duration — no motion
     const double dSec = static_cast<double>(dxPixels) * secPerPx;
+    // Gate time nodes use the schematic's PARAM-DOMAIN px->seconds scale (FA2) — the reciprocal
+    // of the overlay's gatePxPerSecond, sample-length-free — so the dragged handle tracks the
+    // cursor 1:1. gateTimedWidth >= 1 whenever the area is non-empty, so gateDSec is
+    // well-defined past the degenerate guard above.
+    const double gateDSec = static_cast<double>(dxPixels) * gateSecondsPerPixel(area);
 
     switch (node) {
         // --- Gate: each cumulative-time node edits its OWN segment duration. Non-negative
         //     durations ARE the monotonic-in-time guarantee (a node can never cross a neighbour
         //     because every segment stays >= 0), so the [0, max] clamp is the whole constraint.
         case EnvNode::AttackEnd:
-            out.attackSeconds = clamp(grabEnv.attackSeconds + dSec, 0.0, bounds.maxAttackSeconds);
+            out.attackSeconds =
+                clamp(grabEnv.attackSeconds + gateDSec, 0.0, bounds.maxAttackSeconds);
             break;
         case EnvNode::HoldEnd:
-            out.holdSeconds = clamp(grabEnv.holdSeconds + dSec, 0.0, bounds.maxHoldSeconds);
+            out.holdSeconds = clamp(grabEnv.holdSeconds + gateDSec, 0.0, bounds.maxHoldSeconds);
             break;
         case EnvNode::DecayEnd: {
             // Sustain node: X sets decay time, Y sets sustain level (drag DOWN = higher y = lower
             // level, so subtract the level delta).
-            out.decaySeconds = clamp(grabEnv.decaySeconds + dSec, 0.0, bounds.maxDecaySeconds);
+            out.decaySeconds = clamp(grabEnv.decaySeconds + gateDSec, 0.0, bounds.maxDecaySeconds);
             const double lvlPerPx = levelPerPixel(area);
             const double dLevel = -static_cast<double>(dyPixels) * lvlPerPx;
             out.sustainLevel = clamp(grabEnv.sustainLevel + dLevel, 0.0, 1.0);
@@ -87,7 +134,7 @@ AmpEnvelope resolveNodeDrag(const AmpEnvelope& grabEnv, EnvNode node, const Rect
         }
         case EnvNode::ReleaseEnd:
             out.releaseSeconds =
-                clamp(grabEnv.releaseSeconds + dSec, 0.0, bounds.maxReleaseSeconds);
+                clamp(grabEnv.releaseSeconds + gateDSec, 0.0, bounds.maxReleaseSeconds);
             break;
 
         // --- Trigger: fades + length are FRACTIONS. X pixels convert to a fraction of the PLAYED

src/vst/envelope_edit.h

@@ -20,11 +20,19 @@
 //     CALLER-SUPPLIED here (EnvClampBounds): the shell passes the same maxima it feeds the slider,
 //     so the two surfaces share one clamp by construction.
 //
-// WHICH AXES. Time-only nodes (attack-end, hold-end, release-end; fade-in-end, length-end,
-// fade-out-end) drag on X only. The sustain node (DecayEnd) drags on BOTH axes — its X sets the
+// WHICH AXES. Time-only nodes (AttackEnd, HoldEnd, ReleaseEnd; FadeInEnd, FadeOutStart,
+// LengthEnd) drag on X only. The sustain node (DecayEnd) drags on BOTH axes — its X sets the
 // decay time, its Y sets the sustain level (the standard ADSR-editor grammar). Origin and the
 // drawing-only ReleaseStart vertex are NOT draggable.
 //
+// GATE DRAG SCALE (FA2). Gate time nodes convert px->seconds via the reciprocal of the
+// schematic's PARAM-DOMAIN scale (envelope_overlay's gatePxPerSecond — sample-length-free), so
+// a dragged handle tracks the cursor exactly 1:1 for stages within the schematic domain (each
+// node's x is affine in its own segment duration). Trigger nodes keep the full-canvas
+// PCM-aligned scale. Both match the forward map in envelope_overlay. A node is only editable in
+// its OWN mode: Gate nodes ignore drags while the envelope is in Trigger mode and vice versa
+// (guards the degenerate baseline's cross-mode ReleaseEnd vertex from writing releaseSeconds).
+//
 // Reuses editor_geometry's Rect + the EnvNode / AmpEnvelope / EnvMode types from
 // envelope_overlay (one shared node vocabulary across draw + edit), and the shared timeToX /
 // levelToY maps so the handle the overlay drew and the grab region here agree pixel-for-pixel.
@@ -64,9 +72,14 @@ struct EnvClampBounds {
 // Which node a grab at (x, y) lands on, given the CURRENT envelope + overlay rect + sample
 // duration (the same inputs buildEnvelopePolyline drew from, so the grab tests the drawn handles).
 // Returns EnvNode::Origin's NON-membership as a miss via the bool return: `hit` is false for a
-// point off every DRAGGABLE node. Origin and ReleaseStart are never returned (not draggable). On a
-// tie (two handles within the radius) the earlier draw-order node wins (deterministic, mirroring
-// waveform_view::markerAtPoint's first-match). Pure.
+// point off every DRAGGABLE node. Origin and ReleaseStart are never returned (not draggable),
+// and a node from the OTHER mode is never returned (the degenerate baseline's ReleaseEnd vertex
+// is not grabbable in Trigger mode). The NEAREST node within the radius wins (Chebyshev
+// distance); an exact tie goes to the earlier draw-order node (FA2 — deterministic). Gate nodes
+// never coincide (the forward map enforces kGateNodeSepPx separation, so every Gate handle is
+// individually grabbable in every state); the tie-break matters only for Trigger's zero-fade-out
+// coincidence, where FadeOutStart overlays LengthEnd, wins the tie, and can be dragged inward
+// from the right edge. Pure.
 struct NodeHit {
     bool    hit  = false;
     EnvNode node = EnvNode::Origin;  // meaningful only when hit == true
@@ -83,7 +96,8 @@ NodeHit nodeAtPoint(const AmpEnvelope& env, const Rect& area, double totalSecond
 //     duration (e.g. dragging HoldEnd changes holdSeconds, not attack).
 //   * Y delta -> the LEVEL param, but ONLY for the sustain node (DecayEnd); clamped to [0,1].
 //     dyPixels is IGNORED for every time-only node.
-//   * Non-draggable node (Origin / ReleaseStart) or a zero-width/zero-height area or
+//   * Non-draggable node (Origin / ReleaseStart), a node from the OTHER mode (a Gate node while
+//     grabEnv.mode is Trigger, or vice versa), a zero-width/zero-height area, or
 //     totalSeconds <= 0 -> `grabEnv` returned unchanged (no motion).
 // Only the dragged node's param(s) change; every other field carries through from `grabEnv`. Pure
 // — rounding is to the param's continuous value (no snapping, matching the sliders' resolution).

src/vst/envelope_overlay.cpp

@@ -10,11 +10,31 @@ int timeToX(const Rect& area, double totalSeconds, double t) {
     const int w = std::max(0, area.width());
     if (w <= 0 || totalSeconds <= 0.0) return area.left;
     if (t < 0.0) t = 0.0;
-    // Linear map, NOT clamped on the high side: t past totalSeconds maps past area.right (the Gate
-    // release tail, drawn after the sample end by design). Round to the nearest pixel.
-    const double frac = t / totalSeconds;
-    const long xi = static_cast<long>(frac * static_cast<double>(w) + 0.5);
-    return area.left + static_cast<int>(xi);
+    // Linear map, clamped on BOTH sides (FA2 bounds invariant): t past totalSeconds pins to the
+    // last in-bounds column area.right-1. Clamp in DOUBLE space BEFORE the integer cast — a huge
+    // t would overflow a 32-bit long (Windows) and wrap to the WRONG edge — then round.
+    double px = (t / totalSeconds) * static_cast<double>(w);
+    if (px > static_cast<double>(w - 1)) px = static_cast<double>(w - 1);
+    return area.left + static_cast<int>(px + 0.5);
+}
+
+int gateTimedWidth(const Rect& area) {
+    const int w = std::max(0, area.width());
+    if (w <= 0) return 0;
+    const int sustainPx =
+        static_cast<int>(kGateSustainDisplayFraction * static_cast<double>(w) + 0.5);
+    return std::max(1, w - sustainPx);
+}
+
+double gatePxPerSecond(const Rect& area) {
+    const int timedW = gateTimedWidth(area);
+    if (timedW <= 0) return 0.0;
+    // Usable width = timed region minus the four per-segment separation bases and the last
+    // in-bounds column, floored at 1 px so the scale never degenerates; the domain is the four
+    // stages end-to-end at their schematic maxima (param-domain scale — sample-length-free).
+    const double usable =
+        std::max(1.0, static_cast<double>(timedW - 1 - 4 * kGateNodeSepPx));
+    return usable / (4.0 * kGateStageMaxSeconds);
 }
 
 int levelToY(const Rect& area, double level) {
@@ -46,7 +66,23 @@ EnvVertex vtx(EnvNode node, const Rect& area, double totalSeconds, double t, dou
     return v;
 }
 
-std::vector<EnvVertex> gatePolyline(const AmpEnvelope& env, const Rect& area, double totalSeconds) {
+// One Gate vertex from a pixel offset inside the area (the Gate schematic works in px space —
+// timed px + the fixed sustain-plateau reserve — not through the plain timeToX map). Clamps x in
+// DOUBLE space to the last in-bounds column BEFORE the integer cast (FA2 bounds invariant; a
+// huge px would overflow a 32-bit long on Windows and wrap to the WRONG edge).
+EnvVertex gateVtx(EnvNode node, const Rect& area, double px, double level) {
+    const int w = std::max(1, area.width());
+    if (px < 0.0) px = 0.0;
+    if (px > static_cast<double>(w - 1)) px = static_cast<double>(w - 1);
+    EnvVertex v;
+    v.node = node;
+    v.x = area.left + static_cast<int>(px + 0.5);
+    v.y = levelToY(area, level);
+    v.level = level;
+    return v;
+}
+
+std::vector<EnvVertex> gatePolyline(const AmpEnvelope& env, const Rect& area) {
     // Non-negative segment durations (a stored negative would be an upstream bug; clamp defensively).
     const double a = std::max(0.0, env.attackSeconds);
     const double h = std::max(0.0, env.holdSeconds);
@@ -54,23 +90,48 @@ std::vector<EnvVertex> gatePolyline(const AmpEnvelope& env, const Rect& area, do
     const double r = std::max(0.0, env.releaseSeconds);
     const double sus = clamp01(env.sustainLevel);
 
-    // Cumulative wall-clock times of each breakpoint from t=0.
-    const double tAttack = a;
-    const double tHold   = tAttack + h;
-    const double tDecay  = tHold + d;
-    // The sustain plateau runs to the sample end; if the pre-sustain stages already overrun the
-    // sample, the plateau collapses to zero width (its end clamps up to tDecay).
-    const double tSustainEnd = std::max(tDecay, totalSeconds);
-    const double tRelease    = tSustainEnd + r;  // release trails PAST the sample end, by design
+    // BOUNDED SCHEMATIC (FA2): A/H/D and R map onto the TIMED region (canvas minus the reserved
+    // sustain-plateau width) at the PARAM-DOMAIN scale — sample-length-free — and every segment
+    // gets a kGateNodeSepPx base so consecutive nodes never coincide (every node individually
+    // grabbable at any params, incl. the tier-0 zero-hold/zero-decay defaults). The sustain
+    // plateau is the fixed reserve between DecayEnd and ReleaseStart.
+    const int W = std::max(1, area.width());
+    const double sustainPx = static_cast<double>(W - gateTimedWidth(area));
+    const double sep = static_cast<double>(kGateNodeSepPx);
+    const double pps = gatePxPerSecond(area);
+
+    double xAttack  = sep + a * pps;              // AttackEnd
+    double xHold    = xAttack + sep + h * pps;    // HoldEnd
+    double xDecay   = xHold + sep + d * pps;      // DecayEnd (sustain node)
+    double xPlateau = xDecay + sustainPx;         // ReleaseStart (schematic note-off)
+    double xRelease = xPlateau + sep + r * pps;   // ReleaseEnd
+
+    // Right-edge overrun (a stored stage beyond the schematic domain): compress from the RIGHT
+    // preserving the minimum gaps, so trailing nodes stay individually separated instead of
+    // piling on the last column. The re-floor pass only bites when the canvas is too narrow to
+    // hold the minimum gaps at all — then gateVtx's [0, W-1] clamp wins (in-bounds > separation).
+    const double xMax = static_cast<double>(W - 1);
+    if (xRelease > xMax) {
+        xRelease = xMax;
+        xPlateau = std::min(xPlateau, xRelease - sep);
+        xDecay   = std::min(xDecay, xPlateau - sustainPx);
+        xHold    = std::min(xHold, xDecay - sep);
+        xAttack  = std::min(xAttack, xHold - sep);
+        xAttack  = std::max(xAttack, sep);
+        xHold    = std::max(xHold, xAttack + sep);
+        xDecay   = std::max(xDecay, xHold + sep);
+        xPlateau = std::max(xPlateau, xDecay + sustainPx);
+        xRelease = std::max(xRelease, xPlateau + sep);
+    }
 
     std::vector<EnvVertex> pts;
     pts.reserve(6);
-    pts.push_back(vtx(EnvNode::Origin,       area, totalSeconds, 0.0,         0.0));
-    pts.push_back(vtx(EnvNode::AttackEnd,    area, totalSeconds, tAttack,     1.0));
-    pts.push_back(vtx(EnvNode::HoldEnd,      area, totalSeconds, tHold,       1.0));
-    pts.push_back(vtx(EnvNode::DecayEnd,     area, totalSeconds, tDecay,      sus));  // sustain node
-    pts.push_back(vtx(EnvNode::ReleaseStart, area, totalSeconds, tSustainEnd, sus));  // plateau end
-    pts.push_back(vtx(EnvNode::ReleaseEnd,   area, totalSeconds, tRelease,    0.0));
+    pts.push_back(gateVtx(EnvNode::Origin,       area, 0.0,      0.0));
+    pts.push_back(gateVtx(EnvNode::AttackEnd,    area, xAttack,  1.0));
+    pts.push_back(gateVtx(EnvNode::HoldEnd,      area, xHold,    1.0));
+    pts.push_back(gateVtx(EnvNode::DecayEnd,     area, xDecay,   sus));  // sustain node
+    pts.push_back(gateVtx(EnvNode::ReleaseStart, area, xPlateau, sus));  // plateau end
+    pts.push_back(gateVtx(EnvNode::ReleaseEnd,   area, xRelease, 0.0));
     return pts;
 }
 
@@ -106,7 +167,9 @@ std::vector<EnvVertex> buildEnvelopePolyline(const AmpEnvelope& env, const Rect&
         return {vtx(EnvNode::Origin, area, 1.0, 0.0, 0.0),
                 vtx(EnvNode::ReleaseEnd, area, 1.0, 1.0, 0.0)};
     }
-    return env.mode == EnvMode::Gate ? gatePolyline(env, area, totalSeconds)
+    // Gate is a param-domain schematic — totalSeconds only gates the degenerate branch above
+    // (no loaded duration -> baseline); Trigger is PCM-aligned and consumes it.
+    return env.mode == EnvMode::Gate ? gatePolyline(env, area)
                                      : triggerPolyline(env, area, totalSeconds);
 }
 

src/vst/envelope_overlay.h

@@ -4,16 +4,46 @@
 // the DAW, while the editor shell (reasampler_editor.cpp) traces the polyline in an accent hue
 // and draws the node handles (via envelope_edit's hit-test).
 //
-// WHAT IT DRAWS. The amp envelope over the Sample view's hero waveform at accurate wall-clock
-// time (Simpler / Phase-Plant grammar):
+// WHAT IT DRAWS. The amp envelope over the Sample view's hero waveform (Simpler / Phase-Plant
+// grammar):
 //   * Gate    -> the AHDSR shape: attack ramp 0->1, hold plateau at 1, decay 1->sustain,
-//                sustain plateau, release sustain->0.
+//                sustain plateau, release sustain->0. Since there is no held note-off to draw
+//                against, Gate is a BOUNDED SCHEMATIC (FA2): a fixed fraction of the canvas
+//                width (kGateSustainDisplayFraction) is RESERVED for the sustain plateau, and
+//                the remaining "timed" width carries A/H/D AND the release at the PARAM-DOMAIN
+//                scale — the timed width represents 4 x kGateStageMaxSeconds (the four stage
+//                sliders end-to-end at their maxima), NOT the sample's duration, so the layout
+//                is identical for a 0.3s and a 10s capture. Each segment additionally gets a
+//                kGateNodeSepPx pixel base, so consecutive nodes NEVER coincide: every Gate
+//                node is individually grabbable at ANY param values, including the tier-0
+//                defaults (hold 0 / decay 0). A -> (H) -> D -> S-plateau -> R all render INSIDE
+//                the canvas and the release is a visible, draggable segment.
 //   * Trigger -> the fade/%-length shape: fade-in 0->1, unity plateau, fade-out 1->0 anchored
-//                to playEnd (= lengthFraction of the post-start span).
-// The horizontal axis is wall-clock TIME across the waveform rect; the vertical axis is LEVEL
-// (0 at rect bottom, 1 at rect top). The overlay shares the waveform's time base so the drawn
-// shape lines up with the PCM under it: the same [0, frameCount] span waveform_view maps, so the
-// envelope's own duration is placed at the SAME frames the voice plays it over.
+//                to playEnd (= lengthFraction of the post-start span). Trigger keeps the
+//                waveform's exact time base so the shape lines up with the PCM under it.
+// The horizontal axis is TIME (Gate: schematic, see above; Trigger: wall-clock across the rect);
+// the vertical axis is LEVEL (0 at rect bottom, 1 at rect top).
+//
+// BOUNDS INVARIANT (FA2). EVERY vertex of EVERY polyline is clamped inside the canvas:
+// x in [area.left, area.right-1], y in [area.top, area.bottom-1] (half-open rect convention).
+// No node and no drawn segment ever exceeds the canvas — paint-time clipping of handles is no
+// longer needed (and never fires) in the shell.
+//
+// FA2 CONTRACT CHANGE — WAVE B SHELL AUTHOR, READ THIS:
+//   * The EnvNode enum is UNCHANGED (same node set, same draggable set — Origin + ReleaseStart
+//     remain the only non-draggable anchors).
+//   * ALL vertices are now in-bounds (see above). The shell's previous "skip handle when
+//     v.x >= waveArea.right" clip is dead code: ReleaseEnd (Gate) and FadeOutStart/LengthEnd
+//     (Trigger, at full length / zero fade-out) now land at area.right-1 and MUST get handles.
+//   * Gate's x-axis is SCHEMATIC, not PCM-aligned: the timed region is scaled to the param
+//     domain (4 x kGateStageMaxSeconds), the sustain reserve is a fixed width, and every
+//     segment carries a kGateNodeSepPx pixel base. The Gate curve does NOT line up with the
+//     waveform under it — do not label it as if it did. Trigger's x-axis IS still PCM-aligned.
+//   * Gate nodes never coincide (min-separation, above), so every Gate handle is individually
+//     grabbable in every state. nodeAtPoint (envelope_edit) resolves to the NEAREST node within
+//     the grab radius with a draw-order tie-break; the tie-break only matters for the one
+//     remaining coincidence, Trigger's zero-fade-out (FadeOutStart overlays LengthEnd at the
+//     right edge and wins the tie, so the fade can be dragged open from zero).
 //
 // DELIBERATELY ENGINE-FREE (house pattern — param_slider does the same). It does NOT depend on
 // sample_map / sampler_core (which would drag bank_book / wav_trim in). The shell reads the
@@ -44,7 +74,8 @@ enum class EnvMode { Gate, Trigger };
 //
 // Gate nodes:    Origin -> AttackEnd -> HoldEnd -> DecayEnd(=sustain corner) -> ReleaseStart
 //                -> ReleaseEnd. The sustain node is DecayEnd (its Y is the sustain level);
-//                ReleaseStart is a drawing-only plateau-end vertex.
+//                ReleaseStart is a drawing-only plateau-end vertex (the schematic note-off);
+//                release is edited by dragging ReleaseEnd.
 // Trigger nodes: Origin -> FadeInEnd -> FadeOutStart -> LengthEnd(playEnd, level 0). The fade-out
 //                ramp is the FadeOutStart->LengthEnd segment; LengthEnd is the playEnd terminal.
 enum class EnvNode {
@@ -55,7 +86,8 @@ enum class EnvNode {
                    //       Y sets sustainLevel)
     ReleaseStart,  // Gate: end of the sustain plateau / start of the release (sustain level) —
                    //       a DRAWING vertex only, not a draggable handle (release is edited at
-                   //       ReleaseEnd; this vertex tracks its X = sample end, Y = sustain level)
+                   //       ReleaseEnd; this vertex sits a fixed sustain-plateau width right of
+                   //       DecayEnd — the schematic note-off — Y = sustain level)
     ReleaseEnd,    // Gate: end of the release tail (level 0) — X sets releaseSeconds
     FadeInEnd,     // Trigger: top of the fade-in (level 1) — X sets fadeInFraction
     FadeOutStart,  // Trigger: end of the unity plateau / start of the fade-out (level 1) —
@@ -121,36 +153,71 @@ struct EnvVertex {
     }
 };
 
+// The fraction of the canvas width RESERVED for the Gate sustain-plateau display (FA2). The
+// plateau is a fixed-width schematic region between DecayEnd and ReleaseStart; the remaining
+// width is the "timed" region A/H/D/R map onto at the schematic param-domain scale. One
+// constant shared by the forward map (here) and the inverse map (envelope_edit).
+inline constexpr double kGateSustainDisplayFraction = 0.15;
+
+// The minimum pixel separation between consecutive Gate polyline nodes: every Gate segment gets
+// this many px as a base, PLUS its time-proportional extent, so zero-duration stages (tier-0
+// defaults: hold 0, decay 0) still render as distinct, individually grabbable handles. Chosen
+// larger than envelope_edit's kNodeGrabRadius (6) so a click dead-on a node can never tie with
+// its neighbour. Shared by the forward map and the drag inverse.
+inline constexpr int kGateNodeSepPx = 8;
+
+// The Gate schematic's per-stage time domain (seconds): the timed region represents the four
+// stages end-to-end at this maximum each (4 x this total). MIRRORS the shell's stage-slider
+// ceiling (kEnvTimeMaxSeconds in reasampler_editor.cpp) — keep the two equal so a stage at its
+// slider max lands exactly at the canvas edge. Drag safety does NOT depend on this constant
+// (param clamps are caller-supplied in envelope_edit); only layout does.
+inline constexpr double kGateStageMaxSeconds = 2.0;
+
+// The pixel width of the Gate timed region: area.width() minus the sustain-plateau reserve,
+// floored at 1 px so the px<->seconds scale never degenerates for a non-empty area. Returns 0
+// for a zero/negative-width area. Shared by gatePolyline and envelope_edit's gate drag scale.
+int gateTimedWidth(const Rect& area);
+
+// Pixels per second of the Gate timed region under the PARAM-DOMAIN scale: the timed width,
+// minus the four per-segment kGateNodeSepPx bases and the last in-bounds column, spread over
+// 4 x kGateStageMaxSeconds. Independent of the sample's duration. Returns 0 for a
+// zero/negative-width area; otherwise > 0 (the usable width floors at 1 px). The ONE px<->sec
+// scale shared by the forward map (gatePolyline) and the drag inverse (envelope_edit), so a
+// dragged handle tracks the cursor 1:1.
+double gatePxPerSecond(const Rect& area);
+
 // Map an amp envelope to its polyline vertices inside `area`, over a sample of `totalSeconds`
 // wall-clock duration. `area` is the waveform rect (left/top inclusive, right/bottom exclusive);
-// x maps time 0..totalSeconds across [area.left, area.right], y maps level 0..1 across
-// [area.bottom-1 .. area.top] (level 1 at the TOP). The polyline reads left-to-right in draw
-// order, Origin first.
+// y maps level 0..1 across [area.bottom-1 .. area.top] (level 1 at the TOP). The polyline reads
+// left-to-right in draw order, Origin first.
 //
-// TIME BASE. The envelope's own segment durations are placed on the SAME time axis the waveform
-// occupies, so the curve lines up with the PCM:
-//   * Gate: attack/hold/decay run from t=0; the sustain plateau runs to the note-off. Since the
-//     overlay has no held note-off to draw against, the sustain plateau is drawn to the END of
-//     the sample (totalSeconds) and the release tail is drawn AFTER that boundary — i.e. the
-//     release is appended past the sample end (the standard "release after key-up at end of
-//     view" convention). When attack+hold+decay already exceed totalSeconds the plateau collapses
-//     to zero width (nodes clamp to the sample end) and release still trails past it.
-//   * Trigger: the played span is lengthFraction * totalSeconds; fade-in/out are fractions OF
-//     that played span. Nodes past the played span never appear (LengthEnd/FadeOutEnd sit at the
-//     played span's right edge).
+// TIME BASE (FA2).
+//   * Gate: a bounded schematic, INDEPENDENT of totalSeconds. The canvas splits into a TIMED
+//     region of gateTimedWidth(area) px — where attack/hold/decay run from t=0 and the release
+//     ramp runs after the plateau, at the gatePxPerSecond(area) PARAM-DOMAIN scale, each segment
+//     carrying a kGateNodeSepPx base so consecutive nodes never coincide — plus a FIXED sustain
+//     plateau of (width - timedWidth) px between DecayEnd and ReleaseStart (the schematic
+//     note-off). Stages beyond the schematic domain (a stored stage > kGateStageMaxSeconds)
+//     compress from the RIGHT preserving the minimum gaps, so trailing nodes stay individually
+//     separated instead of piling on the last column; only a canvas too narrow to hold the
+//     minimum gaps at all sacrifices separation (in-bounds wins).
+//   * Trigger: the waveform's exact time base (PCM-aligned). The played span is
+//     lengthFraction * totalSeconds; fade-in/out are fractions OF that played span. Nodes past
+//     the played span never appear (FadeOutStart/LengthEnd sit at the played span's right edge).
 //
-// A time beyond totalSeconds (the Gate release tail) maps past area.right — the shell clips at
-// paint time (the same way waveform_view lets a frame past the count pin the marker). A degenerate
-// area (zero width/height) or totalSeconds <= 0 yields the two-point flat baseline [Origin, end at
-// level 0] so the shell always has a drawable line. Pure — same inputs, same polyline.
+// BOUNDS: every vertex is inside the canvas — x in [area.left, area.right-1], y in
+// [area.top, area.bottom-1]. Nothing maps past area.right (the pre-FA2 release tail is gone). A
+// degenerate area (zero width/height) or totalSeconds <= 0 yields the two-point flat baseline
+// [Origin, end at level 0] so the shell always has a drawable line. Pure — same inputs, same
+// polyline.
 std::vector<EnvVertex> buildEnvelopePolyline(const AmpEnvelope& env, const Rect& area,
                                              double totalSeconds);
 
-// Map a time (seconds) to a pixel x inside `area`: t=0 -> area.left, t=totalSeconds -> area.right,
-// linear. t is NOT clamped on the high side (a Gate release past the sample end maps past
-// area.right, by design — see buildEnvelopePolyline); t < 0 pins to area.left. A zero-width area
-// or totalSeconds <= 0 yields area.left. Pure — the shared time->x map both the polyline and the
-// node hit-test (envelope_edit) use, so the drawn handle and its grab region agree.
+// Map a time (seconds) to a pixel x inside `area`: t=0 -> area.left, t=totalSeconds ->
+// area.right-1, linear, CLAMPED on both sides (t < 0 pins to area.left; t past totalSeconds pins
+// to area.right-1 — the in-bounds invariant, FA2). A zero-width area or totalSeconds <= 0 yields
+// area.left. Pure — the shared time->x map the Trigger polyline and the node hit-test
+// (envelope_edit) use, so the drawn handle and its grab region agree.
 int timeToX(const Rect& area, double totalSeconds, double t);
 
 // Map a level (0..1) to a pixel y inside `area`: level 1 -> area.top, level 0 -> area.bottom-1