//! Narrow-trait `ParametersBg` (Phase 5s) — the designer's parameter panel: a scrollable column
 //! of param rows (sliders, spinboxes, dropdowns, text boxes, toggles, colors, float3s,
 //! buttons, section borders, and an inline emacs-flavored code editor), each row's widget owned
 //! by value in parallel `Vec<Option<..>>` fields (most already `Adapted<W>` from earlier
 //! phases), plus a raw-pointer `children` container list. The designer stores it as
 //! `Box<dyn WidgetHost>` and drives it through direct `dyn WidgetHost` calls; `window_runner`'s
 //! `get_child_widget_for_quad` downcasts to the concrete type through `as_any` (which the
 //! adapter forwards to the inner widget) and reads the pub sub-widget fields — both keep
 //! working unchanged.
 //!
 //! The model caches its laid-out rect via [`Layout::rect_assigned`] (all row geometry derives
 //! from it — the TextBox pattern). The panel's own background is drawn by the host from
 //! [`Paint::color`]/[`Paint::corner_style`], NOT emitted here, and its text rides the
 //! per-label view ([`Paint::serves_legacy_labels`] — each label clips to the viewport but
 //! the code editor's clip to the code box, in monospace, which the one-font one-bounds prim
 //! bridge can't express).
 //!
 //! The code row is an editor, not a text box (2026-09-24): a line-number gutter, shift+arrow /
 //! shift+click selection with ctrl+c / ctrl+x / ctrl+v through the toolkit clipboard, tab and
 //! shift+tab indenting by four, Enter carrying the line's indentation (a level deeper after an
 //! opening bracket), ctrl+z / ctrl+shift+z on a `History` of editor snapshots that lives as long
 //! as the editor does, and the emacs chords it always had. Edits go to the BUFFER and reach the
 //! row's VALUE on ctrl+enter, Escape, or leaving the row — never per keystroke, because a host
 //! that evaluates a script on every value change would fail it on every half-typed line. The
 //! border says which state the row is in (amber pending, blue applied, grey at rest), and
 //! [`ParametersBg::set_code_error_line`] lets the host flag the line its last evaluation
 //! failed on.
 //!
 //! Flagged approximation: the legacy scrollbar-press called `self.focus()` (base flag only —
 //! nothing reads it: the highlight keys on the ctx focus slot, and the designer tracks its
 //! focused pane by index); the `on_event` arm drops it.
 
 use crate::colors;
 use crate::scene::layout::Rect;
 use crate::scene::paint::PaintCtx;
 use crate::widget::display::{Float3, TextLabel};
 use crate::scene::paint::Field;
 use crate::widget::input::{Button, ColorSelector, Dropdown, Ramp, Slider, Spinbox, TextBox, Toggle};
 use crate::widget::{Adapted, WidgetHost, ElementState, Event, EventCtx, Input, Key, Layout, MouseButton,
     MouseScrollDelta, NamedKey, Paint, ParamController, TextEditorState, UiContext, WidgetHostExt};
 
 /// A text row, in either variant: plain (`"text"`), or with a completion
 /// picker (`"textpick:a,b,c"` — the Houdini-style attribute/group chooser: a
 /// TextBox plus a slim menu-button Dropdown at its right edge whose pick
 /// fills the box; the host supplies the candidates in the type string).
 fn is_text_row(t: &str) -> bool {
     t == "text" || t.starts_with("textpick")
 }
 
 /// Width of a textpick row's picker button: the right end of the field,
 /// a flush control plate reaching the field's outer edge as a dropdown
 /// trigger's does, the text box's well ending at the seam beside it.
 const PICK_W: f32 = crate::widget::input::dropdown::ARROW_SLOT;
 
 pub struct ParametersBg {
     /// A row VALUE changed inside `tick` (a picker stream folded into its
     /// row) — for the host's sync, which must not run on every tick that
     /// merely animated (a scroll glide reports change every frame; syncing
     /// the whole parameter list on each was the choppy params scroll,
     /// 2026-09-20). Drained by [`Self::take_tick_value_change`].
     tick_value_changed: bool,
     /// The view every trackball in the pane is seen from
     /// ([`Self::set_trackball_view`]); kept here so rows built later start
     /// from it.
     trackball_view: [[f32; 3]; 3],
     /// The configured preference (`layout::param_labels_inline`, the
     /// `param_label_layout` style key), re-read at every rebuild.
     inline_pref: bool,
     /// The label layout the rows are laid out under NOW: inline, the pane
     /// draws each label in a column beside an unlabelled control; stacked,
     /// the control carries its own label above itself. The preference,
     /// unless the pane is too narrow for a column: [`Self::decide_inline`]
     /// re-decides on every rect assignment and [`Self::relabel_rows`]
     /// moves the labels when it flips, so geometry and widgets agree.
     inline_labels: bool,
     rect: Rect,
     display_params: Vec<(String, String, String)>,
     dragging_param: Option<usize>,
     pub focused_param: Option<usize>,
     pub code_editor: Option<TextEditorState>,
     /// The code editor's undo history: one entry per edit, typing runs
     /// coalesced by group. Lives exactly as long as the editor does.
     code_history: crate::history::History<TextEditorState>,
     /// A line (0-based) the host has flagged as the site of an error in the
     /// code row's value — a script that failed to parse. Drawn as a band
     /// under that line while the value it was reported for still stands.
     code_error_line: Option<usize>,
     mouse_pos: Option<(f32, f32)>,
     /// The parameter row under the pointer: its LABEL lifts
     /// (`own_text_labels`) and its own carves light (`paint_ui`, the tint
     /// channel) — the pane's ONE hover rule, over every control kind. The controls keep their own hovers (a spinbox's +/- buttons, a
     /// slider's band), but under the DE relief style most of them draw none
     /// at all — the spinbox's row border, the well frames and the dropdown
     /// border are flat-style chrome the relief branches never paint — so
     /// which rows answered the pointer depended on the control and the
     /// style (2026-09-28: a slider lit, the spinbox beside it did not). Set
     /// with the controls' hover in `hover_controls`, so a scroll moves it
     /// too.
     ///
     /// A label, deliberately, and not a wash over the row. A row wash was
     /// tried the same day and failed twice, both times through the relief:
     /// painted before the wells it closed the pane plate's carve-grouping
     /// window and every well in the pane flipped to the overlay shading on
     /// any hover; painted after them, its 5% white composited in LINEAR
     /// light, which lifts a well's dark shade line from 18 to ~67 while
     /// the pane face moves 46 to 76 — the hovered well's outline paled and
     /// read as the well lighting up. Text stands clear of the relief, and
     /// the tinted carve is the relief's own way of lighting ONE rim.
     hover_row: Option<usize>,
     pub sliders: Vec<Option<Adapted<Slider>>>,
     pub float3s: Vec<Option<Adapted<Float3>>>,
     pub spinboxes: Vec<Option<Adapted<Spinbox>>>,
     pub buttons: Vec<Option<Adapted<Button>>>,
     pub choices: Vec<Option<Adapted<Dropdown>>>,
     pub texts: Vec<Option<Adapted<TextBox>>>,
     pub toggles: Vec<Option<Adapted<Toggle>>>,
     pub colors: Vec<Option<crate::widget::Adapted<ColorSelector>>>,
     /// Ramp-curve rows (`"ramp"` type; value = the ramp spec string). Painted
     /// scene-path through [`ParametersBg::paint_scene_rows`] — the legacy flat
     /// views can't carry the curve/key geometry.
     pub ramps: Vec<Option<Adapted<Ramp>>>,
     /// Titles of the sections the user has collapsed by clicking their header. Keyed by
     /// title so it outlives the row rebuild `set_display_params` runs on every node change.
     collapsed: std::collections::HashSet<String>,
     visible: bool,
     pub scroll_y: f32,
     pub content_h: f32,
     scrollbar_dragging: bool,
     drag_offset_y: f32,
     /// The raise/sink hysteresis (wheel/drag raises, hover sustains, the hold decays in
     /// `tick`) — the shared [`crate::widget::ScrollbarActivity`], which was extracted FROM
     /// this widget so every app's plate-straddling scrollbar behaves the same way.
     activity: crate::widget::ScrollbarActivity,
     /// Smooth-scroll driver behind `scroll_y` (see `ScrollRegion::motion`).
     scroll_motion: crate::widget::ScrollMotion,
     /// One code-editor column's shaped advance (monospace @12, the family/size
     /// the code rows draw in), recorded by [`Paint::prepare_text`]. The caret
     /// and click→column math read it; the hardcoded 7.2 px/col they used
     /// before drifted off the glyphs. 0.0 until the first shape.
     code_char_advance: f32,
 }
 
 /// The channel: the ONLY gap a control keeps from whatever its edge meets — the
 /// neighboring control, or its section's wall. Controls pack edge-to-edge; the
 /// reliefs on either side (control bevel, section wall) shade the channel into a
 /// narrow 3D groove.
 const CHANNEL: f32 = 3.0;
 
 /// The section carve's wall width: the DE relief scaled by the section depth
 /// multiplier (`style.container.section.depth`), capped against the row height
 /// (safety) and the control channel — the channel cap scales WITH the
 /// multiplier, so deepening sections is an explicit choice to let the roll
 /// cross the groove.
 fn section_carve_depth(h: f32) -> f32 {
     let sd = crate::layout::section_depth().max(0.0);
     (crate::layout::bevel_width() * sd).min(h * 0.2).min(CHANNEL * sd)
 }
 /// Vertical pitch between consecutive rows. Wider than the horizontal
 /// channel on purpose: each label+control pair gets its own breathing room,
 /// so rows read as separate entries rather than one packed stack. Was 8
 /// until 2026-09-06; a control's flush seam and the next row's label sat
 /// close enough to read as one block, so the pitch is now near two channels
 /// past the label's own line height.
 const ROW_GAP: f32 = 14.0;
 /// How far a section's title box overhangs its header row upward, and the box's height.
 const TITLE_BOX_INSET: f32 = 2.0;
 const TITLE_BOX_H: f32 = 28.0;
 /// How far a section's content box overhangs the first and last row it wraps —
 /// one channel, so the rows abut the section's top/bottom walls too.
 const CONTENT_BOX_PAD: f32 = CHANNEL;
 /// The section outline's color, stroke width, and its corner radii: convex (outer) corners, and the
 /// concave (inner) corners where the neck joins the title and content boxes.
 const SECTION_BORDER_COLOR: [f32; 4] = [0.18, 0.18, 0.27, 1.0];
 const SECTION_BORDER_T: f32 = 1.0;
 const SECTION_R: f32 = 13.0;
 /// The throat — the concave fillet where the tab's right side turns onto the content
 /// body's top edge (the tab sits flush on the body; there is no connector neck).
 const SECTION_THROAT_R: f32 = 5.0;
 /// The relief carve's concave inside-corner radius at the tab throat
 /// (`section_fillets`) — sized against SECTION_R so inside and outside
 /// corners read as one family.
 const SECTION_FILLET_R: f32 = 10.0;
 /// Narrowest a title box may be: both its corners plus the throat fillet. Titles run
 /// wider than this in practice; it only keeps the throat clear of the corners.
 const SECTION_TITLE_MIN_W: f32 = 2.0 * SECTION_R + SECTION_THROAT_R;
 
 /// The gap between one section's bottom box edge and the next section's title box —
 /// deliberately much wider than the channel the rows pack on, so sections read as
 /// separate blocks. Laid out from the previous block's *drawn* bottom edge (rather
 /// than the uniform row pitch, which the two boxes' overhangs eat into unequally) so the
 /// gap is exact.
 const SECTION_GAP: f32 = 16.0;
 
 /// Horizontal inset of a section's boxes (title tab and content body) from the pane
 /// plate's sides — deliberately the wider of the two horizontal gaps, so sections
 /// float clearly inside the plate.
 const SECTION_MARGIN: f32 = 16.0;
 /// Horizontal gap between a control row and its parent section's side walls —
 /// one channel; controls abut the section's edge.
 const CONTROL_INSET: f32 = CHANNEL;
 /// A row's inset from the plate: the section margin plus the controls' inset within
 /// the section, so bare rows above the first section align with wrapped ones.
 const ROW_X_INSET: f32 = SECTION_MARGIN + CONTROL_INSET;
 
 impl ParametersBg {
     /// The code box's line pitch, its text inset below the box top, and the
     /// gutter that carries line numbers: four columns of digits and a gap.
     const CODE_LINE_H: f32 = 16.0;
     const CODE_TOP: f32 = 22.0;
     const CODE_BOX_TOP: f32 = 18.0;
     const CODE_GUTTER_COLS: f32 = 4.0;
     const CODE_INDENT: &'static str = "    ";
 
     /// Where a code row's text starts: past the gutter.
     fn code_text_x(&self, r: (f32, f32, f32, f32)) -> f32 {
         r.0 + 12.0 + (Self::CODE_GUTTER_COLS + 1.0) * self.code_col_w()
     }
 
     /// Flag a line of the code row as an error site, or clear it. The host
     /// calls this when the value it evaluated failed with a line number —
     /// it is the one piece of feedback a script editor cannot do without.
     pub fn set_code_error_line(&mut self, line: Option<usize>) {
         self.code_error_line = line;
     }
 
     /// Whether a code row is being edited right now.
     pub fn code_editing(&self) -> bool {
         self.focused_param.is_some() && self.code_editor.is_some()
     }
 
     /// The row open for typing, if any: a code row, or a hosted text box,
     /// spinbox, slider readout, colour or vector field that is editing. (A
     /// choice row holds `focused_param` while its list is open; that is not
     /// typing.)
     fn typing_row(&self) -> Option<usize> {
         let i = self.focused_param?;
         if self.code_editor.is_some() {
             return Some(i);
         }
         fn at<T>(v: &[Option<T>], i: usize) -> Option<&T> {
             v.get(i).and_then(Option::as_ref)
         }
         let typing = at(&self.texts, i).is_some_and(|t| t.editing)
             || at(&self.spinboxes, i).is_some_and(|t| t.editing)
             || at(&self.sliders, i).is_some_and(|t| t.editing)
             || at(&self.colors, i).is_some_and(|t| t.editing)
             || at(&self.float3s, i).is_some_and(|t| t.editing_idx().is_some());
         typing.then_some(i)
     }
 
     /// Say a field is open for typing (`crate::text_input`): at its row, or
     /// the pane when the row is not laid out. The hosted fields are drawn
     /// from this pane's aggregates, never through their own paint, so their
     /// own claims never run — the pane makes it for them.
     fn claim_typing(&self, ctx: &PaintCtx) {
         if let Some(i) = self.typing_row() {
             let (x, y, w, h) = self
                 .get_param_rects()
                 .get(i)
                 .copied()
                 .filter(|r| r.3 > 0.0)
                 .unwrap_or((self.rect.x, self.rect.y, self.rect.width, self.rect.height));
             let (ox, oy) = ctx.offset();
             crate::text_input::claim(x + ox, y + oy, w, h);
         }
     }
 
     /// The clipboard, selection and history actions over the code editor:
     /// what the runner's undo / redo chords and the context menu's rows
     /// reach through [`Input::context_action`], and what the editor's own
     /// chords call. Returns whether the editor was open to act on.
     pub fn code_action(&mut self, action: crate::widget::ContextAction) -> bool {
         match self.code_editor.as_mut() {
             Some(editor) => {
                 apply_code_action(editor, &mut self.code_history, action);
                 true
             }
             None => false,
         }
     }
 
     /// Whether the focused code row holds edits not yet applied to its value.
     pub fn code_is_dirty(&self) -> bool {
         match (self.focused_param, &self.code_editor) {
             (Some(i), Some(editor)) => self.display_params.get(i).is_some_and(|p| p.1 != editor.buffer),
             _ => false,
         }
     }
 
     /// One code column's width — the shaped advance when recorded, else the
     /// legacy 7.2 estimate (only before the first `prepare_text`).
     fn code_col_w(&self) -> f32 {
         if self.code_char_advance > 0.0 {
             self.code_char_advance
         } else {
             7.2
         }
     }
 
     pub fn new() -> Adapted<ParametersBg> {
         Adapted::new(ParametersBg {
             trackball_view: crate::widget::display::float3::IDENTITY_VIEW,
             inline_pref: crate::layout::param_labels_inline(),
             inline_labels: crate::layout::param_labels_inline(),
             rect: Rect { x: 0.0, y: 0.0, width: 0.0, height: 0.0 },
             display_params: Vec::new(),
             dragging_param: None,
             focused_param: None,
             code_editor: None,
             code_history: crate::history::History::with_limit(200),
             code_error_line: None,
             mouse_pos: None,
             hover_row: None,
             sliders: Vec::new(),
             float3s: Vec::new(),
             spinboxes: Vec::new(),
             buttons: Vec::new(),
             choices: Vec::new(),
             texts: Vec::new(),
             toggles: Vec::new(),
             colors: Vec::new(),
             ramps: Vec::new(),
             collapsed: std::collections::HashSet::new(),
             visible: true,
             scroll_y: 0.0,
             content_h: 0.0,
             code_char_advance: 0.0,
             scrollbar_dragging: false,
             drag_offset_y: 0.0,
             activity: crate::widget::ScrollbarActivity::new(),
             scroll_motion: crate::widget::ScrollMotion::new(),
             tick_value_changed: false,
         })
     }
 
     /// Row `i`'s laid-out height, ignoring collapse (the row-type table).
     /// The shortest TRACK an inline row may leave its slider. Below it the
     /// pane stacks every label above its control instead. Measured on the
     /// track — what the slider is, to the eye and the hand — not on the
     /// control's rect, which also holds the readout and its gap (and a
     /// float3's axis column): until 2026-09-28 the rect was what was
     /// measured, so a slider's track shrank to 52 px, and a float3's to
     /// 36, before the labels moved. A control with no track (spinbox, text
     /// box, dropdown, colour) is measured whole.
     pub const MIN_INLINE_TRACK_W: f32 = 120.0;
 
     /// See every trackball in the pane from a host's camera
     /// (`Float3::set_view`): the view's right, up and toward-the-viewer
     /// axes, in the vectors' space. Returns whether anything changed, so a
     /// host knows to draw again. Kept for the rows built after it.
     pub fn set_trackball_view(&mut self, view: [[f32; 3]; 3]) -> bool {
         let mut probe = Float3::new();
         if !probe.set_view(view) {
             return false;
         }
         let view = probe.view();
         let moved = (0..3).any(|i| (0..3).any(|k| (view[i][k] - self.trackball_view[i][k]).abs() > 1e-5));
         if moved {
             self.trackball_view = view;
             for f in self.float3s.iter_mut().flatten() {
                 f.set_view(view);
             }
         }
         moved
     }
 
     /// Whether a float3 row's type asks for the trackball: a fourth segment,
     /// `float3:lo:hi:trackball`.
     fn has_trackball(t: &str) -> bool {
         t.starts_with("float3:") && t.split(':').nth(3) == Some("trackball")
     }
 
     /// What a row of type `t` spends of its control rect on everything but
     /// its track: a slider's readout and gap, plus a float3's axis column.
     /// Zero for the controls that have no track.
     fn control_chrome(t: &str) -> f32 {
         if t.starts_with("slider") {
             crate::widget::input::slider::Slider::readout_chrome()
         } else if is_vec_row(t) {
             let ball = if Self::has_trackball(t) { Float3::trackball_chrome() } else { 0.0 };
             ball + crate::widget::display::float3::AXIS_W + crate::widget::input::slider::Slider::readout_chrome()
         } else {
             0.0
         }
     }
 
     /// Whether a row of type `t` takes the inline layout at all. Only the
     /// rows whose control would otherwise carry a label strip: toggles and
     /// buttons ARE their label, a ramp keeps its label band, sections and
     /// code rows have layouts of their own.
     fn inline_kind(t: &str) -> bool {
         t.starts_with("slider")
             || is_vec_row(t)
             || t.starts_with("spinbox")
             || t.starts_with("choice")
             || is_text_row(t)
             || t.starts_with("color")
             || t == "rgb"
             || t == "rgba"
     }
 
     /// Whether row `i` is laid out with its label beside the control.
     fn inline_row(&self, i: usize) -> bool {
         self.inline_labels && Self::inline_kind(&self.display_params[i].2)
     }
 
     /// The layout the rows allow: the preference, unless a label column
     /// would leave any visible row's track shorter than
     /// [`Self::MIN_INLINE_TRACK_W`], in which case the labels stack. One
     /// decision for the pane — a mix of inline and stacked rows reads as
     /// ragged — taken by its SHORTEST track, so a pane of spinboxes keeps
     /// its column at a width where a pane with a float3 has let it go. An
     /// unlaid pane (no rect yet) follows the preference; the first rect
     /// assignment decides.
     fn decide_inline(&self) -> bool {
         if !self.inline_pref {
             return false;
         }
         if self.rect.width <= 0.0 {
             return true;
         }
         let row_w = (self.rect.width - 2.0 * ROW_X_INSET).max(0.0);
         let control_w = row_w - self.label_col_w_if(true);
         let hidden = self.hidden_rows();
         self.display_params
             .iter()
             .enumerate()
             .filter(|(i, p)| !hidden[*i] && Self::inline_kind(&p.2))
             .all(|(_, p)| control_w - Self::control_chrome(&p.2) >= Self::MIN_INLINE_TRACK_W)
     }
 
     /// Re-decide the layout for the current rect and, when it flips, move
     /// every label between the column and the controls. The widgets were
     /// built with or without a label, and the two layouts have different
     /// row heights, so a flip is a relabel and a re-layout, not a flag.
     fn apply_label_layout(&mut self) {
         let want = self.decide_inline();
         if want != self.inline_labels {
             self.inline_labels = want;
             self.relabel_rows();
         }
     }
 
     /// Put each inline-kind row's label where the current layout wants it:
     /// on the control when stacked, off it (the pane draws the column) when
     /// inline. Toggles, buttons and ramps carry their label either way.
     fn relabel_rows(&mut self) {
         let inline = self.inline_labels;
         for i in 0..self.display_params.len() {
             let (name, ty) = (self.display_params[i].0.clone(), self.display_params[i].2.clone());
             if !Self::inline_kind(&ty) {
                 continue;
             }
             macro_rules! relabel {
                 ($w:expr) => {
                     if let Some(w) = $w {
                         if inline { w.clear_label() } else { w.set_label(&name) }
                     }
                 };
             }
             relabel!(&mut self.sliders[i]);
             relabel!(&mut self.float3s[i]);
             relabel!(&mut self.spinboxes[i]);
             relabel!(&mut self.texts[i]);
             relabel!(&mut self.colors[i]);
             // Only a choice row's dropdown carries the row label; a text
             // row's completion picker is a button inside the box.
             if ty.starts_with("choice:") {
                 relabel!(&mut self.choices[i]);
             }
         }
     }
 
     /// The label strip an inline row no longer spends: the control was
     /// built unlabelled, so the row loses exactly the strip's height.
     fn inline_strip(&self, i: usize) -> f32 {
         if self.inline_row(i) { crate::layout::control_label_strip() } else { 0.0 }
     }
 
     /// Gap between the label column and the control.
     const LABEL_GAP: f32 = 16.0;
 
     /// The inline label's font: the pane's own labels draw in the control
     /// label font (`Paint::widget_font`), so the column is measured in it —
     /// family AND size — or the widest label runs into its control.
     fn inline_label_font() -> (String, f32) {
         crate::layout::control_label_font_parsed()
     }
 
     /// Width of the label column under the inline layout: the widest visible
     /// inline label plus the gap, clamped to a floor (so a pane of one-word
     /// labels still reads as a column) and to under half the row (so a long
     /// label truncates rather than squeezing the control out). Zero when
     /// nothing is inline.
     fn label_col_w(&self) -> f32 {
         self.label_col_w_if(self.inline_labels)
     }
 
     /// [`Self::label_col_w`] under a given layout — what the column WOULD
     /// take, which is what [`Self::decide_inline`] asks before committing.
     fn label_col_w_if(&self, inline: bool) -> f32 {
         if !inline {
             return 0.0;
         }
         let (family, size) = Self::inline_label_font();
         let hidden = self.hidden_rows();
         let widest = self
             .display_params
             .iter()
             .enumerate()
             .filter(|(i, p)| !hidden[*i] && Self::inline_kind(&p.2))
             .map(|(_, p)| crate::widget::display::measure_text_width(&p.0, &family, size))
             .fold(0.0f32, f32::max);
         if widest <= 0.0 {
             return 0.0;
         }
         let row_w = (self.rect.width - 2.0 * ROW_X_INSET).max(0.0);
         (widest + Self::LABEL_GAP).clamp(72.0f32.min(row_w * 0.45), row_w * 0.45)
     }
 
     /// Row `i`'s CONTROL rect: the row rect less the label column when the
     /// row is inline, the row rect itself otherwise.
     fn control_rect(&self, r: (f32, f32, f32, f32), i: usize, lw: f32) -> (f32, f32, f32, f32) {
         if self.inline_row(i) { (r.0 + lw, r.1, (r.2 - lw).max(0.0), r.3) } else { r }
     }
 
     fn row_height(&self, i: usize) -> f32 {
         let p = &self.display_params[i];
         if p.2 == "code" {
             let val_text = if self.focused_param == Some(i) {
                 if let Some(ref editor) = self.code_editor {
                     &editor.buffer
                 } else {
                     &p.1
                 }
             } else {
                 &p.1
             };
             let line_count = val_text.split('\n').count();
             let content_h = Self::CODE_TOP + (line_count as f32 * Self::CODE_LINE_H) + 12.0;
             content_h.max(200.0)
         } else if p.2 == "section" {
             24.0
         } else if p.2 == SEPARATOR {
             // A rule, its own pixel: the row gaps either side are the air.
             1.0
         } else if p.2 == "ramp" {
             // Label band + the ramp's graph and control strip. The control
             // strip and label band are fixed, so this whole increase grows the
             // curve plot (Ramp::graph_h = height − strip).
             260.0
         } else if is_vec_row(&p.2) {
             Float3::preferred_height_for(!self.inline_row(i), vec_row_n(&p.2))
         } else if p.2.starts_with("slider") {
             (38.0 - self.inline_strip(i)).max(22.0)
         } else if is_text_row(&p.2) || p.2.starts_with("spinbox") || p.2.starts_with("choice") {
             (42.0 - self.inline_strip(i)).max(24.0)
         } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
             (40.0 - self.inline_strip(i)).max(24.0)
         } else if p.2 == "button" || p.2 == "toggle" || p.2 == "checkbox" {
             24.0
         } else {
             20.0
         }
     }
 
     /// Per-row "sits inside a collapsed section" flags: a section owns every row between its
     /// header and the next header. Headers themselves are never hidden — they stay clickable
     /// so a collapsed section can be reopened. Rows before the first header belong to no
     /// section and are always shown.
     fn hidden_rows(&self) -> Vec<bool> {
         let mut out = Vec::with_capacity(self.display_params.len());
         let mut hiding = false;
         for p in &self.display_params {
             if p.2 == "section" {
                 hiding = self.collapsed.contains(&p.0);
                 out.push(false);
             } else {
                 out.push(hiding);
             }
         }
         out
     }
 
     /// Whether the section titled `title` is collapsed.
     pub fn section_collapsed(&self, title: &str) -> bool {
         self.collapsed.contains(title)
     }
 
     /// Collapse/expand the section titled `title`, re-laying the rows. Keyed by title, not
     /// row index, so the state survives the `set_display_params` rebuilds a host runs
     /// whenever the inspected node changes.
     pub fn set_section_collapsed(&mut self, title: &str, collapsed: bool) {
         let changed = if collapsed {
             self.collapsed.insert(title.to_string())
         } else {
             self.collapsed.remove(title)
         };
         if changed {
             self.refresh_scroll_metrics();
         }
     }
 
     /// The box drawn around a section header's title — and, since the title is the collapse
     /// affordance, that box is also the header's click target.
     fn section_title_box(&self, hdr: usize, r_hdr: (f32, f32, f32, f32)) -> (f32, f32, f32, f32) {
         // The label sits 8px in from the box's left edge; matching that 8px on the right
         // (box width = text + 16) centers the text in the box. Measure the run in the
         // label's real family AND size — parsed, not the raw "Family NN" spec string, which
         // resvg can't resolve (it would fall back to a narrow font and undersize the box).
         let full_w = self.rect.width - 2.0 * SECTION_MARGIN;
         let (label_family, label_size) = crate::layout::control_label_font_parsed();
         let text_w =
             crate::widget::display::measure_text_width(&self.display_params[hdr].0, &label_family, label_size);
         let title_w = (text_w + 16.0).max(SECTION_TITLE_MIN_W).min(full_w);
         // The tab sits FLUSH on the content body: its bottom edge is the body's top
         // edge, in every style (the relief carve always drew it there; the outline now
         // fuses to it too). Collapsed, the box stays where the expanded tab sits (one
         // title-box height above where the body's top edge would be), so collapsing
         // doesn't jump the tab — and the click-toggle hit zone follows the ink. An
         // expanded-but-empty section keeps the legacy header-row placement.
         let y = if self.collapsed.contains(&self.display_params[hdr].0) {
             r_hdr.1 + r_hdr.3 + ROW_GAP - CONTENT_BOX_PAD - TITLE_BOX_H
         } else {
             match self.first_visible_row_top(hdr) {
                 Some(control_top) => control_top - CONTENT_BOX_PAD - TITLE_BOX_H,
                 None => r_hdr.1 - TITLE_BOX_INSET,
             }
         };
         (self.rect.x + SECTION_MARGIN, y, title_w, TITLE_BOX_H)
     }
 
     /// The top edge of the first visible row under header `hdr` — the row the section's
     /// content box (and so its tab) hangs from. `None` for an empty section (a header
     /// with no rows of its own before the next header).
     fn first_visible_row_top(&self, hdr: usize) -> Option<f32> {
         let hidden = self.hidden_rows();
         let rects = self.get_param_rects();
         self.display_params
             .iter()
             .enumerate()
             .skip(hdr + 1)
             .take_while(|(_, q)| q.2 != "section")
             .find(|(j, _)| !hidden[*j])
             .map(|(j, _)| rects[j].1)
     }
 
     /// Each section as `(header index, its content-row range)` — the rows between a header
     /// and the next one, `None` for a header with nothing under it.
     fn sections(&self) -> Vec<(usize, Option<(usize, usize)>)> {
         let mut out: Vec<(usize, Option<(usize, usize)>)> = Vec::new();
         for (i, p) in self.display_params.iter().enumerate() {
             if p.2 == "section" {
                 out.push((i, None));
             } else if let Some((_, content)) = out.last_mut() {
                 match content {
                     Some((_, end)) => *end = i,
                     None => *content = Some((i, i)),
                 }
             }
         }
         out
     }
 
     /// Each section's boxes: the title box, plus the box wrapping its rows (`None` when the
     /// section is collapsed or has no rows). The shared source for the outline's straight
     /// runs and its corner fillets, so the two halves can't disagree.
     /// The row floors (`layout::param_compression`): the pane material
     /// frosted at the configured compression, filled under every visible
     /// parameter row (headers excepted) before anything else in the pane
     /// paints, at the control corner radius — each parameter on its own
     /// tablet, the way the designer's node bodies get their own compression.
     /// Nothing when the key is unset. Relief only: the flat style has no
     /// floor language.
     fn paint_row_floors(&self, ctx: &mut PaintCtx) {
         let Some(k) = crate::layout::param_compression() else { return };
         if !crate::layout::control_relief() {
             return;
         }
         let mut mat = crate::scene::Material::pane();
         if let crate::scene::Frost::Frosted { compression, .. } = &mut mat.frost {
             *compression = k;
         }
         let r = crate::layout::control_corner_radius();
         let hidden = self.hidden_rows();
         for (i, (x, y, w, h)) in self.get_param_rects().into_iter().enumerate() {
             if hidden[i] || h <= 0.0 || self.display_params[i].2 == "section" || self.display_params[i].2 == SEPARATOR {
                 continue;
             }
             ctx.fill_material(Rect { x, y, width: w, height: h }, (r, r, r, r), &mat);
         }
     }
 
     fn section_boxes(&self) -> Vec<((f32, f32, f32, f32), Option<(f32, f32, f32, f32)>)> {
         let rects = self.get_param_rects();
         let full_w = self.rect.width - 2.0 * SECTION_MARGIN;
         let mut out = Vec::new();
         for (hdr, content) in self.sections() {
             if hdr >= rects.len() {
                 continue;
             }
             let title = self.section_title_box(hdr, rects[hdr]);
             let content_box = if self.collapsed.contains(&self.display_params[hdr].0) {
                 None
             } else {
                 content.and_then(|(start, end)| {
                     if start <= end && start < rects.len() && end < rects.len() {
                         let by = rects[start].1 - CONTENT_BOX_PAD;
                         let bh = (rects[end].1 + rects[end].3 + CONTENT_BOX_PAD) - by;
                         Some((title.0, by, full_w, bh))
                     } else {
                         None
                     }
                 })
             };
             out.push((title, content_box));
         }
         out
     }
 
     /// One section's outline: a SINGLE continuous border shaped like a folder tab — around
     /// the title box, whose bottom edge is open onto the content body it sits flush on
     /// (its right side turning onto the body's top edge through the concave throat fillet,
     /// its left side running straight down into the body's left edge) — as
     /// `(straight runs, corner fillets)`.
     ///
     /// Runs are `(x, y, w, h)`; fillets are `(cx, cy, radius, start, end)` for an arc stroked
     /// `SECTION_BORDER_T` inward of `radius` (the renderer's convention). Convex corners take
     /// the stroke inside the box, so their radius is the outer one; the concave throat corner
     /// has its centre out in the empty pocket, so its carries the `+ T` that puts the
     /// ink on the far side. Every run stops a radius short of its corner, and each fillet
     /// picks it up there — the path closes.
     fn section_outline(
         &self,
         title: (f32, f32, f32, f32),
         content: Option<(f32, f32, f32, f32)>,
     ) -> (Vec<(f32, f32, f32, f32)>, Vec<(f32, f32, f32, f32, f32)>) {
         use std::f32::consts::{PI, TAU};
         const Q: f32 = std::f32::consts::FRAC_PI_2;
         let (t, r) = (SECTION_BORDER_T, SECTION_R);
         let mut quads: Vec<(f32, f32, f32, f32)> = Vec::new();
         let mut arcs: Vec<(f32, f32, f32, f32, f32)> = Vec::new();
         fn hrun(out: &mut Vec<(f32, f32, f32, f32)>, x0: f32, x1: f32, y: f32) {
             if x1 - x0 > 0.01 {
                 out.push((x0, y, x1 - x0, SECTION_BORDER_T));
             }
         }
         fn vrun(out: &mut Vec<(f32, f32, f32, f32)>, y0: f32, y1: f32, x: f32) {
             if y1 - y0 > 0.01 {
                 out.push((x, y0, SECTION_BORDER_T, y1 - y0));
             }
         }
 
         let (tx, ty, tw, th) = title;
         let ty_b = ty + th; // the title box's bottom edge
         arcs.push((tx + r, ty + r, r, PI, PI + Q)); // title top-left
         arcs.push((tx + tw - r, ty + r, r, PI + Q, TAU)); // title top-right
         hrun(&mut quads, tx + r, tx + tw - r, ty); // title top
 
         let Some((cx, cy_t, cw, ch)) = content else {
             // Collapsed or empty: the title box IS the section, so it closes on itself.
             arcs.push((tx + tw - r, ty_b - r, r, 0.0, Q)); // title bottom-right
             arcs.push((tx + r, ty_b - r, r, Q, PI)); // title bottom-left
             vrun(&mut quads, ty + r, ty_b - r, tx + tw - t); // title right
             vrun(&mut quads, ty + r, ty_b - r, tx); // title left
             hrun(&mut quads, tx + r, tx + tw - r, ty_b - t); // title bottom
             return (quads, arcs);
         };
 
         // The tab sits flush on the body (`ty_b == cy_t` — `section_title_box` places it
         // there): its bottom edge is open. The throat fillet shrinks if the tab runs
         // close to the body's right corner.
         let f = SECTION_THROAT_R.min((cx + cw - r - (tx + tw)).max(0.0));
         vrun(&mut quads, ty + r, cy_t - f, tx + tw - t); // tab right side, down to the throat
         arcs.push((tx + tw + f, cy_t - f, f + t, Q, PI)); // throat: tab side -> body top
         hrun(&mut quads, tx + tw + f, cx + cw - r, cy_t); // body top, right of the tab
 
         arcs.push((cx + cw - r, cy_t + r, r, PI + Q, TAU)); // body top-right
         arcs.push((cx + cw - r, cy_t + ch - r, r, 0.0, Q)); // body bottom-right
         arcs.push((cx + r, cy_t + ch - r, r, Q, PI)); // body bottom-left
         vrun(&mut quads, cy_t + r, cy_t + ch - r, cx + cw - t); // body right
         hrun(&mut quads, cx + r, cx + cw - r, cy_t + ch - t); // body bottom
         vrun(&mut quads, ty + r, cy_t + ch - r, tx); // tab + body left, one straight run
 
         (quads, arcs)
     }
 
     /// The section outlines' corner fillets, as the renderer's arc tuples
     /// `(cx, cy, radius, thickness, start, end, color)`.
     ///
     /// A concrete accessor rather than prims out of [`Paint::paint`] on purpose: the host
     /// draws this panel through the legacy plain-quad hatch, and `append_widget_plate` serves
     /// a widget's arcs UNCLIPPED — these have to land inside the pane's scroll viewport, so
     /// the host draws them itself under its own clip (the straight runs ride `plain_quads`,
     /// which clips them there by hand).
     pub fn arcs(&self) -> Vec<(f32, f32, f32, f32, f32, f32, [f32; 4])> {
         if !self.visible || crate::layout::control_relief() {
             return Vec::new();
         }
         let color = SECTION_BORDER_COLOR;
         let mut out = Vec::new();
         for (title, content) in self.section_boxes() {
             let (_, arcs) = self.section_outline(title, content);
             out.extend(
                 arcs.into_iter()
                     .map(|(cx, cy, r, a0, a1)| (cx, cy, r, SECTION_BORDER_T, a0, a1, color)),
             );
         }
         out
     }
 
     /// Where the rows start, in absolute y — the origin `get_param_rects` lays out from.
     fn rows_origin(&self) -> f32 {
         self.rect.y - self.scroll_y
     }
 
     /// The scrollable height of the row column. Derived from [`Self::get_param_rects`] rather
     /// than re-walking the advance rules, so the two can't drift apart.
     pub fn get_total_content_height(&self) -> f32 {
         let hidden = self.hidden_rows();
         let rects = self.get_param_rects();
         let bottom = rects
             .iter()
             .enumerate()
             .filter(|(i, _)| !hidden[*i])
             .map(|(_, r)| r.1 + r.3)
             .fold(f32::NEG_INFINITY, f32::max);
         if bottom == f32::NEG_INFINITY {
             return 30.0 + 10.0; // no rows: the top offset plus the bottom padding
         }
         (bottom - self.rows_origin()) + ROW_GAP + 10.0
     }
 
     /// One rect per row, in index order — collapsed rows get a zero-height rect at the
     /// current cursor (and consume no vertical space), so every index-parallel consumer
     /// keeps working while the row draws and hit-tests as nothing.
     ///
     /// Rows advance on a uniform [`ROW_GAP`] pitch, except a section header, which is placed
     /// [`SECTION_GAP`] below the previous section's drawn bottom edge — see [`SECTION_GAP`].
     pub fn get_param_rects(&self) -> Vec<(f32, f32, f32, f32)> {
         let hidden = self.hidden_rows();
         let mut rects = Vec::new();
         let mut cur_y = self.rows_origin() + 30.0;
         // Bottom edge of the last row as DRAWN: a row inside a section is wrapped by the
         // content box, which overhangs it; a header with no visible rows under it (empty or
         // collapsed) ends at its own title box. `None` until the first section starts —
         // rows above it are bare, with no box to measure against.
         let mut prev_bottom: Option<f32> = None;
         for i in 0..self.display_params.len() {
             if hidden[i] {
                 rects.push((self.rect.x + ROW_X_INSET, cur_y, self.rect.width - 2.0 * ROW_X_INSET, 0.0));
                 continue;
             }
             let is_header = self.display_params[i].2 == "section";
             if is_header {
                 if let Some(bottom) = prev_bottom {
                     cur_y = bottom + SECTION_GAP + TITLE_BOX_INSET;
                 }
             }
             let h = self.row_height(i);
             rects.push((self.rect.x + ROW_X_INSET, cur_y, self.rect.width - 2.0 * ROW_X_INSET, h));
             prev_bottom = Some(if is_header {
                 cur_y - TITLE_BOX_INSET + TITLE_BOX_H
             } else if prev_bottom.is_some() {
                 cur_y + h + CONTENT_BOX_PAD
             } else {
                 cur_y + h
             });
             cur_y += h + ROW_GAP;
         }
         rects
     }
 
     /// The pane's scrollbar width — the DE `scrollbar_width` widened: the bar
     /// rides over the section carves and reads too slim at the stock width.
     fn scrollbar_w(&self) -> f32 {
         crate::layout::scrollbar_width() * 1.6
     }
 
     /// The scrollbar's left x: the bar rides the pane's CENTRE line, as
     /// every sink-behind bar in the DE does (cce-mail's list and body, the
     /// designer's dialog list) — over the rows, reserving no lane, in front
     /// only while raised. It sat a sixth of the width in from the right
     /// edge before 2026-09-21, which beside a centred bar read as off.
     fn scrollbar_x(&self) -> f32 {
         self.rect.x + (self.rect.width - self.scrollbar_w()) * 0.5
     }
 
     pub fn hit_test_scrollbar(&self, px: f32, py: f32) -> bool {
         if self.content_h <= self.rect.height {
             return false;
         }
         let sb_w = self.scrollbar_w();
         let sb_x = self.scrollbar_x();
         let sb_track_h = self.rect.height - 8.0;
         let sb_track_y = self.rect.y + 4.0;
 
         px >= sb_x - 4.0 && px <= sb_x + sb_w + 4.0
             && py >= sb_track_y && py <= sb_track_y + sb_track_h
     }
 
     /// Whether the pane holds enough content to need a scrollbar at all.
     pub fn scrollbar_visible(&self) -> bool {
         self.content_h > self.rect.height
     }
 
     /// Whether the scrollbar is currently raised in front of the pane plate (the latched
     /// state). While this is false the bar sits behind the plate and is non-interactive.
     pub fn scrollbar_active(&self) -> bool {
         self.activity.raised()
     }
 
     /// How far the bar's FORE copy has faded in, 0..=1: the host draws the
     /// idle copy before the plate every frame and the fore copy after the
     /// rows at this alpha, so the raise and the sink are a fade, not a flip.
     pub fn scrollbar_fade(&self) -> f32 {
         self.activity.fade()
     }
 
     /// Re-latch the shared hysteresis with this pane's inputs, returning whether it changed.
     fn recompute_scrollbar_raised(&mut self) -> bool {
         let visible = self.scrollbar_visible();
         self.activity.recompute(visible, self.scrollbar_dragging)
     }
 
     /// The scrollbar's track + thumb quads (empty when no scrollbar is needed). The host draws
     /// these either behind or in front of the pane plate per [`Self::scrollbar_active`]; they
     /// are deliberately kept out of [`Self::plain_quads`] so the host controls their depth.
     pub fn scrollbar_quads(&self) -> Vec<(f32, f32, f32, f32, [f32; 4])> {
         if !self.scrollbar_visible() {
             return Vec::new();
         }
         let sb_w = self.scrollbar_w();
         let sb_x = self.scrollbar_x();
         let sb_track_h = self.rect.height - 8.0;
         let sb_track_y = self.rect.y + 4.0;
 
         let visible_ratio = self.rect.height / self.content_h;
         let thumb_h = if sb_track_h <= 20.0 {
             sb_track_h
         } else {
             (sb_track_h * visible_ratio).clamp(20.0, sb_track_h)
         };
         let max_scroll = self.content_h - self.rect.height;
         let scroll_ratio = if max_scroll > 0.0 { self.scroll_y / max_scroll } else { 0.0 };
         let thumb_y = sb_track_y + scroll_ratio * (sb_track_h - thumb_h);
 
         vec![
             (sb_x, sb_track_y, sb_w, sb_track_h, crate::color::scrollbar_track_color()),
             (sb_x, thumb_y, sb_w, thumb_h, crate::color::scrollbar_thumb_color()),
         ]
     }
 
     /// Hand a pointer position to every hosted control, so each re-reads
     /// its own hover (and a ramp row its key drag). Called for every pointer
     /// move, and again from the last known position (`mouse_pos`) whenever a
     /// SCROLL moves the rows under a still pointer — the wheel arm and the
     /// tick's coast — because a control's hover is recomputed only when it
     /// is told where the pointer is, and until 2026-09-28 nothing told it on
     /// a scroll: a control that scrolled under the pointer stayed dark and
     /// one that scrolled away stayed lit until the next motion. Sliders are
     /// in the roster since the same day, having had no hover before.
     fn hover_controls(&mut self, px: f32, py: f32, ui: &mut UiContext) -> bool {
         let mut changed = false;
         for s in self.sliders.iter_mut().flatten() {
             if s.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for sb in self.spinboxes.iter_mut().flatten() {
             if sb.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for f in self.float3s.iter_mut().flatten() {
             if f.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for b in self.buttons.iter_mut().flatten() {
             if b.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for d in self.choices.iter_mut().flatten() {
             if d.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for tb in self.texts.iter_mut().flatten() {
             if tb.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for cb in self.toggles.iter_mut().flatten() {
             if cb.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         for c in self.colors.iter_mut().flatten() {
             if c.on_cursor_moved(px, py, ui) {
                 changed = true;
             }
         }
         // Ramp rows: a move can drag a key — re-serialize the curve
         // into the row value so hosts polling `node_params` see it.
         for i in 0..self.ramps.len() {
             if let Some(rp) = &mut self.ramps[i] {
                 if rp.on_cursor_moved(px, py, ui) {
                     self.display_params[i].1 = rp.inner().spec_string();
                     changed = true;
                 }
             }
         }
         let row = self.hoverable_row_at(px, py);
         if row != self.hover_row {
             self.hover_row = row;
             changed = true;
         }
         changed
     }
 
     /// The parameter row under `(px, py)`: a visible, non-header row whose
     /// rect holds the point, and only while the point is inside the pane's
     /// own viewport (a row scrolled out of it is not under anything).
     fn hoverable_row_at(&self, px: f32, py: f32) -> Option<usize> {
         if !self.visible
             || px < self.rect.x
             || px > self.rect.x + self.rect.width
             || py < self.rect.y
             || py > self.rect.y + self.rect.height
         {
             return None;
         }
         let hidden = self.hidden_rows();
         self.get_param_rects().into_iter().enumerate().find_map(|(i, (x, y, w, h))| {
             let hoverable = !hidden[i] && h > 0.0 && self.display_params[i].2 != "section" && self.display_params[i].2 != SEPARATOR;
             (hoverable && px >= x && px <= x + w && py >= y && py <= y + h).then_some(i)
         })
     }
 
     /// The rows moved under a still pointer: re-hover from where it was.
     fn rehover_after_scroll(&mut self, ui: &mut UiContext) -> bool {
         match self.mouse_pos {
             Some((px, py)) => self.hover_controls(px, py, ui),
             None => false,
         }
     }
 
     /// The pane's own row label, and the same label under the pointer: the
     /// dialog's row and selected-row label colours, so a hovered parameter
     /// reads as the dialog's hovered command does.
     const LABEL: [u8; 3] = [0xaa, 0xaa, 0xbb];
     const LABEL_HOVER: [u8; 3] = [0xf4, 0xf4, 0xfa];
     /// The hovered row's carve tint: the lifted label's own colour, so the
     /// lit rim and the label read as one cue. Through the tint channel the
     /// shader composites the rim's light in this colour at its focus gain
     /// and the shadow in a quarter of it — the carve lights, it is not
     /// washed over (a wash over a carve pales its dark shade line in linear
     /// blending; see `hover_row`).
     const HOVER_TINT: [f32; 3] = [0xf4 as f32 / 255.0, 0xf4 as f32 / 255.0, 0xfa as f32 / 255.0];
 
     fn update_slider_rects(&mut self) {
         // Inline rows hand their control the row less the label column; the
         // row rects themselves (`get_param_rects`) stay the full row, which is
         // what the floors, the section boxes and hit routing measure against.
         let lw = self.label_col_w();
         let rects: Vec<(f32, f32, f32, f32)> = self
             .get_param_rects()
             .into_iter()
             .enumerate()
             .map(|(i, r)| self.control_rect(r, i, lw))
             .collect();
         let inline: Vec<bool> = (0..self.display_params.len()).map(|i| self.inline_row(i)).collect();
         for (i, s_opt) in self.sliders.iter_mut().enumerate() {
             if let Some(s) = s_opt {
                 let r = rects[i];
                 s.set_rect(r.0, r.1, r.2, r.3);
             }
         }
         for (i, f_opt) in self.float3s.iter_mut().enumerate() {
             if let Some(f) = f_opt {
                 let r = rects[i];
                 f.set_rect(r.0, r.1, r.2, r.3);
             }
         }
         for (i, sb_opt) in self.spinboxes.iter_mut().enumerate() {
             if let Some(sb) = sb_opt {
                 let r = rects[i];
                 sb.set_rect(r.0, r.1, r.2, r.3);
             }
         }
         for (i, b_opt) in self.buttons.iter_mut().enumerate() {
             if let Some(b) = b_opt {
                 let r = rects[i];
                 b.set_rect(r.0, r.1, r.2, r.3);
             }
         }
         for (i, d_opt) in self.choices.iter_mut().enumerate() {
             if let Some(d) = d_opt {
                 let r = rects[i];
                 if self.display_params[i].2.starts_with("textpick") {
                     // The picker is the field's RIGHT END: a flush control
                     // plate over the whole band below the detached label,
                     // out to the field's outer edge on the top, right and
                     // bottom as a dropdown trigger's plate is, square where
                     // it meets the text box (whose well stops at the seam —
                     // `TextBox::joined_right`) and the box's radius on the
                     // outside, so the two read as one field. Until
                     // 2026-10-01 it was a button nested INSIDE the box's
                     // well, its face stopping at the base of the well's
                     // wall, so it never reached the edge a dropdown's does.
                     let label_top = if inline[i] { 0.0 } else { crate::layout::control_label_strip() };
                     let band_h = r.3 - label_top;
                     let rr = crate::layout::textbox_corner_radius();
                     // The picker is a trigger's arrow slot: PICK_W and a
                     // wall, the wall being the lip its face rises out of at
                     // the seam. Its arrow in its middle is then where every
                     // other trigger's arrow is, in its slot.
                     let pick_w = crate::widget::input::dropdown::arrow_slot(band_h);
                     d.set_rect(r.0 + r.2 - pick_w, r.1 + label_top, pick_w, band_h);
                     d.inner_mut().set_radii(Some((0.0, rr, rr, 0.0)));
                     d.inner_mut().center_arrow = true;
                     // The menu hangs off the WHOLE field, not the button
                     // sliver: anchor the popover to the box's well band.
                     d.popover_anchor = Some(Rect {
                         x: r.0,
                         y: r.1 + label_top,
                         width: r.2,
                         height: r.3 - label_top,
                     });
                 } else {
                     d.set_rect(r.0, r.1, r.2, r.3);
                 }
             }
         }
         for (i, tb_opt) in self.texts.iter_mut().enumerate() {
             if let Some(tb) = tb_opt {
                 let r = rects[i];
                 // A textpick row's box ends where its picker begins.
                 let joined = self.display_params[i].2.starts_with("textpick") && self.choices[i].is_some();
                 tb.inner_mut().joined_right = joined;
                 tb.set_rect(r.0, r.1, r.2, r.3);
                 if joined {
                     // The box ends where the picker begins, at the seam.
                     let depth = crate::layout::bevel_width().min((r.3 - tb.label_strip()) * 0.2);
                     tb.set_rect(r.0, r.1, (r.2 - PICK_W - depth).max(0.0), r.3);
                 }
             }
         }
         for (i, cb_opt) in self.toggles.iter_mut().enumerate() {
             if let Some(cb) = cb_opt {
                 let r = rects[i];
                 cb.set_rect(r.0, r.1, r.2, r.3);
             }
         }
         for (i, c_opt) in self.colors.iter_mut().enumerate() {
             if let Some(c) = c_opt {
                 let r = rects[i];
                 c.set_rect(r.0, r.1, r.2, r.3);
             }
         }
         for (i, rp_opt) in self.ramps.iter_mut().enumerate() {
             if let Some(rp) = rp_opt {
                 let r = rects[i];
                 // Below the 18px label band own_text_labels draws (the ramp
                 // carries no label of its own).
                 rp.set_rect(r.0, r.1 + 18.0, r.2, r.3 - 18.0);
             }
         }
     }
 
     /// The legacy `set_rect`/`set_display_params` tail: recompute the content height, clamp the
     /// scroll into it, re-lay the rows.
     fn refresh_scroll_metrics(&mut self) {
         // The label layout (inline column or stacked) is decided first, by
         // the tracks the rows would get: every geometry below depends on
         // it. Here rather than on rect assignment alone, because a section
         // collapsing or opening changes which rows are visible, and so
         // which is the shortest track and how wide the column is.
         self.apply_label_layout();
         self.content_h = self.get_total_content_height();
         let max_scroll = (self.content_h - self.rect.height).max(0.0);
         self.scroll_y = self.scroll_y.clamp(0.0, max_scroll);
         self.update_slider_rects();
     }
 
     fn own_text_labels(&self) -> Vec<TextLabel> {
         let rects = self.get_param_rects();
         let hidden = self.hidden_rows();
         let mut labels = Vec::new();
         let lw = self.label_col_w();
         let (family, size) = Self::inline_label_font();
         for (i, (name, value, ptype)) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             let r = rects[i];
             if self.inline_row(i) {
                 // The pane's own label, in the column beside an unlabelled
                 // control: vertically centred on the row, tail-truncated to
                 // the column — by the measure the column is sized with, so
                 // a label it was sized to hold is never cut (it was cut to
                 // as many chars as the column holds M's).
                 labels.push(TextLabel {
                     text: fit_tail(name, lw - Self::LABEL_GAP, &family, size),
                     x: r.0,
                     y: r.1 + (r.3 - size) * 0.5,
                     font_size: size,
                     color: if self.hover_row == Some(i) { Self::LABEL_HOVER } else { Self::LABEL },
                 });
             }
             if ptype.starts_with("slider") {
                 if let Some(s) = &self.sliders[i] {
                     labels.extend(s.own_text_labels());
                 }
             } else if is_vec_row(ptype) {
                 if let Some(f) = &self.float3s[i] {
                     labels.extend(f.own_text_labels());
                 }
             } else if ptype == "section" {
                 // Centered within the tab itself — `section_title_box` is the one
                 // source for where the tab sits (flush on the body; collapsed and
                 // empty sections carry their own placements there).
                 let font_size = 13.0;
                 let (bx, by, _, _) = self.section_title_box(i, r);
                 labels.push(TextLabel {
                     text: name.clone(),
                     // 8px in from the title box's left edge — the inset
                     // `section_title_box`'s width math centers against.
                     x: bx + 8.0,
                     y: by + (TITLE_BOX_H - font_size) / 2.0,
                     font_size,
                     color: [0xee, 0xee, 0xf0],
                 });
             } else if ptype == "code" {
                 labels.push(TextLabel {
                     text: format!("{}:", name),
                     x: self.rect.x + 12.0,
                     y: r.1,
                     font_size: 12.0,
                     color: [0xaa, 0xaa, 0xbb],
                 });
                 let val_text = if self.focused_param == Some(i) {
                     if let Some(ref editor) = self.code_editor {
                         editor.buffer.clone()
                     } else {
                         value.clone()
                     }
                 } else {
                     value.clone()
                 };
                 // One label PER LINE, at the same pitch the cursor math uses
                 // (`plain_quads`' cursor_y) — a single multi-line label would depend on
                 // the consumer's buffer line-height matching that pitch, and never
                 // exactly did. A line number sits in the gutter before each.
                 let text_x = self.code_text_x(r);
                 for (line_i, line) in val_text.split('\n').enumerate() {
                     let y = r.1 + Self::CODE_TOP + line_i as f32 * Self::CODE_LINE_H;
                     let number = format!("{:>3}", line_i + 1);
                     labels.push(TextLabel {
                         text: number,
                         x: r.0 + 12.0,
                         y,
                         font_size: 12.0,
                         color: if self.code_error_line == Some(line_i) { [0xff, 0x80, 0x70] } else { [0x66, 0x66, 0x78] },
                     });
                     if line.is_empty() {
                         continue;
                     }
                     labels.push(TextLabel {
                         text: line.to_string(),
                         x: text_x,
                         y,
                         font_size: 12.0,
                         color: [0xee, 0xee, 0xf0],
                     });
                 }
                 if self.focused_param == Some(i) && self.code_is_dirty() {
                     labels.push(TextLabel {
                         text: "ctrl+enter applies".to_string(),
                         x: r.0 + r.2 - 12.0 - 18.0 * self.code_col_w(),
                         y: r.1 + r.3 - 15.0,
                         font_size: 12.0,
                         color: [0xd8, 0xa0, 0x50],
                     });
                 }
             } else if ptype.starts_with("spinbox") {
                 if let Some(sb) = &self.spinboxes[i] {
                     labels.extend(sb.own_text_labels());
                 }
             } else if is_text_row(ptype) {
                 if let Some(tb) = &self.texts[i] {
                     labels.extend(tb.own_text_labels());
                 }
                 if let Some(d) = &self.choices[i] {
                     labels.extend(d.own_text_labels());
                 }
             } else if ptype.starts_with("choice") {
                 if let Some(d) = &self.choices[i] {
                     labels.extend(d.own_text_labels());
                 }
             } else if ptype == "button" {
                 if let Some(b) = &self.buttons[i] {
                     labels.extend(b.own_text_labels());
                 }
             } else if ptype == "toggle" || ptype == "checkbox" {
                 if let Some(cb) = &self.toggles[i] {
                     labels.extend(cb.own_text_labels());
                 }
             } else if ptype.starts_with("color") || ptype == "rgb" || ptype == "rgba" {
                 if let Some(c) = &self.colors[i] {
                     labels.extend(c.own_text_labels());
                 }
             } else if ptype == SEPARATOR {
                 // A rule says nothing.
             } else if ptype == "ramp" {
                 // The name label only — the ramp's own control labels ride its
                 // scene-path paint (paint_scene_rows).
                 labels.push(TextLabel {
                     text: name.clone(),
                     x: r.0,
                     y: r.1,
                     font_size: 12.0,
                     color: [0xaa, 0xaa, 0xbb],
                 });
             } else {
                 labels.push(TextLabel {
                     text: format!("{}: {}", name, value),
                     x: self.rect.x + ROW_X_INSET,
                     y: r.1,
                     font_size: 12.0,
                     color: [0xaa, 0xaa, 0xbb],
                 });
             }
         }
         labels
     }
 
     /// The hosted controls' GLYPHS — a dropdown's or a picker's arrow, a
     /// spinbox's −/+ — as `(image, rect, alpha)`, row by row as
     /// [`own_text_labels`](Self::own_text_labels) collects their text. The
     /// pane paints its controls' chrome itself and never runs their
     /// `Paint::paint` into the frame, so a symbol a control draws reaches
     /// the pane only through here. Ramps are not asked: they paint whole
     /// through `paint_scene_rows`.
     fn child_glyphs(&self) -> Vec<(u32, Rect, f32)> {
         let hidden = self.hidden_rows();
         let mut glyphs = Vec::new();
         for (i, (_, _, ptype)) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             if ptype.starts_with("slider") {
                 if let Some(s) = &self.sliders[i] {
                     glyphs.extend(s.own_glyphs());
                 }
             } else if is_vec_row(ptype) {
                 if let Some(f) = &self.float3s[i] {
                     glyphs.extend(f.own_glyphs());
                 }
             } else if ptype.starts_with("spinbox") {
                 if let Some(sb) = &self.spinboxes[i] {
                     glyphs.extend(sb.own_glyphs());
                 }
             } else if is_text_row(ptype) {
                 if let Some(tb) = &self.texts[i] {
                     glyphs.extend(tb.own_glyphs());
                 }
                 if let Some(d) = &self.choices[i] {
                     glyphs.extend(d.own_glyphs());
                 }
             } else if ptype.starts_with("choice") {
                 if let Some(d) = &self.choices[i] {
                     glyphs.extend(d.own_glyphs());
                 }
             } else if ptype == "button" {
                 if let Some(b) = &self.buttons[i] {
                     glyphs.extend(b.own_glyphs());
                 }
             } else if ptype == "toggle" || ptype == "checkbox" {
                 if let Some(cb) = &self.toggles[i] {
                     glyphs.extend(cb.own_glyphs());
                 }
             } else if ptype.starts_with("color") || ptype == "rgb" || ptype == "rgba" {
                 if let Some(c) = &self.colors[i] {
                     glyphs.extend(c.own_glyphs());
                 }
             }
         }
         glyphs
     }
 
     /// Paint [`child_glyphs`](Self::child_glyphs), over the chrome.
     fn paint_child_glyphs(&self, ctx: &mut PaintCtx) {
         for (image, rect, alpha) in self.child_glyphs() {
             ctx.image(image, rect, alpha);
         }
     }
 
     /// The dropdown rows' popover, if one is open — the widget's OWN popover surface
     /// ([`Paint::popover`]); the raw `children`'s popovers are the adapter's recursion.
     /// The ramp rows' field dropdowns count too.
     fn choices_popover_rect(&self) -> Option<(f32, f32, f32, f32)> {
         for d in self.choices.iter().flatten() {
             if let Some(r) = d.popover_rect() {
                 return Some(r);
             }
         }
         for rp in self.ramps.iter().flatten() {
             let ramp = rp.inner();
             if let Some(r) = ramp
                 .preset_dropdown
                 .popover_rect()
                 .or_else(|| ramp.line_type_dropdown.popover_rect())
             {
                 return Some(r);
             }
         }
         None
     }
 
     /// The full legacy popover reach (choices, then children) — hit-testing extends to it.
     fn own_popover_rect(&self) -> Option<(f32, f32, f32, f32)> {
         if let Some(r) = self.choices_popover_rect() {
             return Some(r);
         }
         None
     }
 
     /// The state half of the legacy `unfocus`: commit the focused row's in-flight value back
     /// into `display_params`, drop the code editor, and unfocus the raw children.
     fn commit_and_unfocus(&mut self) {
         if let Some(idx) = self.focused_param {
             if idx < self.display_params.len() {
                 let p = &mut self.display_params[idx];
                 if p.2.starts_with("spinbox") {
                     if let Some(sb) = &mut self.spinboxes[idx] {
                         sb.unfocus();
                         p.1 = sb.value.to_string();
                     }
                 } else if p.2.starts_with("slider") {
                     if let Some(s) = &mut self.sliders[idx] {
                         s.unfocus();
                         let new_val = s.get_scaled_value();
                         p.1 = format!("{:.*}", slider_decimals(&p.2), new_val);
                     }
                 } else if is_vec_row(&p.2) {
                     if let Some(f) = &mut self.float3s[idx] {
                         f.unfocus();
                         p.1 = f.value_string();
                     }
                 } else if is_text_row(&p.2) {
                     if let Some(tb) = &mut self.texts[idx] {
                         tb.unfocus();
                         p.1 = tb.text.clone();
                     }
                     if let Some(d) = &mut self.choices[idx] {
                         d.unfocus();
                     }
                 } else if p.2.starts_with("choice") {
                     if let Some(d) = &mut self.choices[idx] {
                         d.unfocus();
                         if let Some(val) = d.get_value_string() {
                             p.1 = val;
                         }
                     }
                 } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
                     if let Some(c) = &mut self.colors[idx] {
                         c.unfocus();
                         if let Some(val) = c.get_value_string() {
                             p.1 = val;
                         }
                     }
                 } else if p.2 == "code" {
                     if let Some(ref editor) = self.code_editor {
                         p.1 = editor.buffer.clone();
                     }
                     self.code_editor = None;
                     self.code_history.clear();
                 }
             }
         }
         self.focused_param = None;
     }
 
     /// The pane's plain quads: section border boxes, every row's chrome (slider/spinbox
     /// backgrounds read via `rect()`+`color()`, the code editor's box/border/cursor), the
     /// controls' own plain quads, all clipped to the viewport — plus the unclipped scrollbar.
     fn plain_quads(&self) -> Vec<(f32, f32, f32, f32, [f32; 4])> {
         if !self.visible {
             return Vec::new();
         }
         let mut quads = Vec::new();
         let rects = self.get_param_rects();
         let view_min = self.rect.y + 4.0;
         let view_max = self.rect.y + self.rect.height - 4.0;
 
         let clip_quad = |q: (f32, f32, f32, f32, [f32; 4])| -> Option<(f32, f32, f32, f32, [f32; 4])> {
             let (qx, qy, qw, qh, qc) = q;
             let y1 = qy.max(view_min);
             let y2 = (qy + qh).min(view_max);
             if y1 < y2 {
                 Some((qx, y1, qw, y2 - y1, qc))
             } else {
                 None
             }
         };
 
         let mut param_quads = Vec::new();
 
         // Each section is drawn as ONE continuous outline — around the title, down the
         // neck, around the content rows — whose straight runs are these quads; its corner
         // fillets ride `arcs()`, which the host draws under the same clip. Under
         // `control_relief` the outline is replaced by the inset carves served
         // through `reliefs` (title tab + content body recessed).
         if !crate::layout::control_relief() {
             for (title, content) in self.section_boxes() {
                 let (runs, _) = self.section_outline(title, content);
                 param_quads.extend(runs.into_iter().map(|(x, y, w, h)| (x, y, w, h, SECTION_BORDER_COLOR)));
             }
         }
 
         let hidden = self.hidden_rows();
         for (i, p) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             let r = rects[i];
             if p.2.starts_with("slider") {
                 if let Some(s) = &self.sliders[i] {
                     let (sx, sy, sw, sh) = s.rect();
                     param_quads.push((sx, sy, sw, sh, s.color()));
                     param_quads.extend(crate::widget::shown_quads(s));
                 }
             } else if p.2 == "section" {
                 // Section header line is handled by the border box top border now
             } else if p.2 == SEPARATOR {
                 // A hairline across the row, inset from the pane's edges.
                 let c = crate::colors::active_theme().surface_border;
                 param_quads.push((r.0 + 6.0, r.1, (r.2 - 12.0).max(0.0), 1.0, [c[0], c[1], c[2], c[3] * 0.8]));
             } else if is_vec_row(&p.2) {
                 if let Some(f) = &self.float3s[i] {
                     param_quads.extend(crate::widget::shown_quads(f));
                 }
             } else if p.2 == "code" {
                 let (bx, by, bw, bh) = (r.0, r.1 + Self::CODE_BOX_TOP, r.2, r.3 - Self::CODE_BOX_TOP);
                 param_quads.push((bx, by, bw, bh, [0.08, 0.08, 0.10, 1.0]));
                 let focused = self.focused_param == Some(i);
                 // Amber while edits are pending, blue while focused and
                 // applied, grey at rest: the border says whether what the
                 // node runs is what the box shows.
                 let border_color = if focused && self.code_is_dirty() {
                     [0.85, 0.60, 0.25, 1.0]
                 } else if focused {
                     [0.25, 0.45, 0.85, 1.0]
                 } else {
                     [0.20, 0.20, 0.25, 1.0]
                 };
                 let text_x = self.code_text_x(r);
                 let col_w = self.code_col_w();
                 let line_y = |l: usize| by + (Self::CODE_TOP - Self::CODE_BOX_TOP) + l as f32 * Self::CODE_LINE_H;
                 // The gutter's edge.
                 param_quads.push((text_x - col_w * 0.5, by + 1.0, 1.0, bh - 2.0, [0.16, 0.16, 0.20, 1.0]));
                 // The error band, under the flagged line.
                 if let Some(err_line) = self.code_error_line {
                     let y = line_y(err_line);
                     if y >= by && y + Self::CODE_LINE_H <= by + bh {
                         param_quads.push((bx + 1.0, y, bw - 2.0, Self::CODE_LINE_H, [0.45, 0.12, 0.10, 1.0]));
                     }
                 }
                 if focused {
                     if let Some(ref editor) = self.code_editor {
                         // Selection: one band per line it covers.
                         if let Some((start, end)) = editor.selected_range() {
                             let (sl, sc) = get_cursor_line_col(&editor.buffer, start);
                             let (el, ec) = get_cursor_line_col(&editor.buffer, end);
                             let line_len = |l: usize| editor.buffer.split('\n').nth(l).map_or(0, |s| s.chars().count());
                             for l in sl..=el {
                                 let c0 = if l == sl { sc } else { 0 };
                                 let c1 = if l == el { ec } else { line_len(l) + 1 };
                                 let y = line_y(l);
                                 if y >= by && y + Self::CODE_LINE_H <= by + bh && c1 > c0 {
                                     param_quads.push((
                                         text_x + c0 as f32 * col_w,
                                         y,
                                         (c1 - c0) as f32 * col_w,
                                         Self::CODE_LINE_H,
                                         [0.22, 0.32, 0.55, 1.0],
                                     ));
                                 }
                             }
                         }
                         let (cursor_l, cursor_c) = get_cursor_line_col(&editor.buffer, editor.cursor_idx);
                         let cursor_x = text_x + (cursor_c as f32 * col_w);
                         let cursor_y = line_y(cursor_l) + (Self::CODE_LINE_H - 13.0) / 2.0;
                         if cursor_y >= by && cursor_y + 13.0 <= by + bh {
                             param_quads.push((cursor_x, cursor_y, 1.5, 13.0, [0.80, 0.80, 0.85, 1.0]));
                         }
                     }
                 }
                 param_quads.push((bx, by, bw, 1.0, border_color));
                 param_quads.push((bx, by + bh - 1.0, bw, 1.0, border_color));
                 param_quads.push((bx, by, 1.0, bh, border_color));
                 param_quads.push((bx + bw - 1.0, by, 1.0, bh, border_color));
             } else if is_text_row(&p.2) {
                 if let Some(tb) = &self.texts[i] {
                     param_quads.extend(crate::widget::shown_quads(tb));
                 }
                 if let Some(d) = &self.choices[i] {
                     param_quads.extend(crate::widget::shown_quads(d));
                 }
             } else if p.2.starts_with("choice") {
                 if let Some(d) = &self.choices[i] {
                     param_quads.extend(crate::widget::shown_quads(d));
                 }
             } else if p.2 == "button" {
                 if let Some(b) = &self.buttons[i] {
                     param_quads.extend(crate::widget::shown_quads(b));
                 }
             } else if p.2.starts_with("spinbox") {
                 if let Some(sb) = &self.spinboxes[i] {
                     { let (bx, by, bw, bh) = sb.rect(); param_quads.push((bx, by, bw, bh, sb.color())); }
                     param_quads.extend(crate::widget::shown_quads(sb));
                 }
             } else if p.2 == "toggle" || p.2 == "checkbox" {
                 if let Some(cb) = &self.toggles[i] {
                     param_quads.extend(crate::widget::shown_quads(cb));
                 }
             } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
                 if let Some(c) = &self.colors[i] {
                     param_quads.extend(crate::widget::shown_quads(c));
                 }
             }
         }
 
         // Clip all parameter quads vertically
         for q in param_quads {
             if let Some(clipped) = clip_quad(q) {
                 quads.push(clipped);
             }
         }
 
         // The scrollbar is NOT emitted here: the host draws it via `scrollbar_quads`, above
         // or below the pane plate depending on `scrollbar_active`.
 
         quads
     }
 
     /// The rounded companion to [`Self::plain_quads`]: the row controls whose boxes are
     /// `Prim::RoundedRect` (textbox, dropdown, button, toggle, color selector), which the
     /// plain list does not carry. Returned unclipped; the pane's paint clips them to its
     /// scroll viewport. (x, y, w, h, radius, color, (tl, tr, br, bl)).
     pub fn rounded_quads(
         &self,
     ) -> Vec<(f32, f32, f32, f32, f32, [f32; 4], (bool, bool, bool, bool))> {
         if !self.visible {
             return Vec::new();
         }
         let mut out = Vec::new();
         let hidden = self.hidden_rows();
         for (i, p) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             if is_text_row(&p.2) {
                 if let Some(tb) = &self.texts[i] {
                     out.extend(crate::widget::shown_rounded_quads(tb));
                 }
                 if let Some(d) = &self.choices[i] {
                     out.extend(crate::widget::shown_rounded_quads(d));
                 }
             } else if p.2.starts_with("slider") {
                 // Track (square style only — the recessed style has no track
                 // background), value fill, and readout box; the thumb knob is a
                 // `Prim::Sphere` and rides `spheres()` instead.
                 if let Some(s) = &self.sliders[i] {
                     out.extend(crate::widget::shown_rounded_quads(s));
                 }
             } else if is_vec_row(&p.2) {
                 // Three slider rows: the same set per row (readout boxes,
                 // square-style tracks and fills), through the group's own paint.
                 if let Some(f) = &self.float3s[i] {
                     out.extend(crate::widget::shown_rounded_quads(f));
                 }
             } else if p.2.starts_with("choice") {
                 if let Some(d) = &self.choices[i] {
                     out.extend(crate::widget::shown_rounded_quads(d));
                 }
             } else if p.2.starts_with("spinbox") {
                 // The spinbox's whole chrome (frame, display well, +/- button
                 // wells) is modern rounded-rect paint — its legacy color() is
                 // transparent and it has no extra_quads, so skipping it here
                 // renders the row as bare text.
                 if let Some(sb) = &self.spinboxes[i] {
                     out.extend(crate::widget::shown_rounded_quads(sb));
                 }
             } else if p.2 == "button" {
                 if let Some(b) = &self.buttons[i] {
                     out.extend(crate::widget::shown_rounded_quads(b));
                 }
             } else if p.2 == "toggle" || p.2 == "checkbox" {
                 if let Some(cb) = &self.toggles[i] {
                     out.extend(crate::widget::shown_rounded_quads(cb));
                 }
             } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
                 if let Some(c) = &self.colors[i] {
                     out.extend(crate::widget::shown_rounded_quads(c));
                 }
             }
         }
         out
     }
 
     /// The relief companion to [`Self::rounded_quads`]: the row controls'
     /// raised/recessed step prims (boss rims, recess wells), which the flat
     /// views cannot carry — a host rendering this panel through the legacy
     /// views must read this getter too or the `control_relief` styling is lost
     /// entirely (with the DE's transparent control backgrounds the controls all
     /// but vanish). Edges-only variants throughout: the flat views own the
     /// faces, exactly the widgets' own transparent-fill bevel→boss degradation.
     /// Returned unclipped; the host clips to the pane's scroll viewport and
     /// draws these AFTER the flat quads, so the walls' shading modulates the
     /// fills they cross (the order the widgets' own paints use). Tuple:
     /// (x, y, w, h, per-corner radii, depth, raised, walls) — raised maps to
     /// `PaintCtx::boss_edges`, flat to `recess_edges`; a toggle's well and
     /// the plate standing in it are why radii/walls are per-entry.
     #[allow(clippy::type_complexity)]
     pub fn reliefs(
         &self,
     ) -> Vec<(f32, f32, f32, f32, (f32, f32, f32, f32), f32, bool, (bool, bool, bool, bool))> {
         if !self.visible || !crate::layout::control_relief() {
             return Vec::new();
         }
         let mut out = Vec::new();
 
         // Sections as inset panels (the flat outline+fillet path is the
         // non-relief style): ONE union-shaped recess per section — a
         // title-text-width tab strip flush with the body's left edge, opening
         // into the full-width body below. Composed from three edge-suppressed
         // pieces (the tab with its bottom open, the body with its top open,
         // and the top-wall run right of the tab's throat) so no wall crosses
         // the union's interior and the whole section reads as a single well.
         // Collapsed sections keep the title-box carve.
         let all = (true, true, true, true);
         let r4 = |r: f32| (r, r, r, r);
         let r = SECTION_R;
         for (title, content) in self.section_boxes() {
             let (tx, ty, tw, th) = title;
             if let Some((cx, cy, cw, ch)) = content {
                 // Capped at the channel: the well's wall must roll off inside the
                 // groove between it and the controls packed one CHANNEL inside,
                 // not shade across their faces. `section_depth` scales wall and
                 // channel cap together — past 1.0 the roll crosses the groove
                 // by choice.
                 let depth = section_carve_depth(ch);
                 // Tab strip: the title box itself, sitting flush on the body's top
                 // edge (the header row above it stays plain plate), bottom open.
                 // A wall FADES OUT over the carve width approaching a suppressed
                 // edge (the tessellator's host fade — meant for carves flush with
                 // a real plate edge), so every piece extends past its interior
                 // seam by `depth`: its fade-out then crossfades with the
                 // neighbor's fade-in instead of both dying AT the seam (which
                 // notched the walls there; found the hard way).
                 let throat_r = tx + tw;
                 let rho = SECTION_FILLET_R;
                 // Right of the throat, ONE piece owns the whole right run —
                 // top wall, top-right arc, right wall, bottom-right arc — so
                 // both right corners are real turns. (The old top-run +
                 // full-body split put the top wall and the right wall in
                 // different pieces; each faded out at the seam and the
                 // top-right corner rendered square.) A left piece carries the
                 // left wall and the bottom-left arc; the two bottom runs
                 // crossfade under the seam at the right piece's left edge.
                 let body_lr = |x_run: f32, out: &mut Vec<_>| {
                     out.push((x_run, cy, cx + cw - x_run, ch, (0.0, r, r, 0.0), depth, false, (true, true, true, false)));
                     out.push((cx, cy, x_run + depth - cx, ch, (0.0, 0.0, 0.0, r), depth, false, (false, false, true, true)));
                 };
                 if cx + cw > throat_r + 2.0 * rho {
                     // Filleted throat ([`Self::section_fillets`]): the tab's
                     // right wall must END at the fillet's vertical tangent
                     // (crossfading out under the arc) or its straight run
                     // ghosts through the curve — so the tab piece stops there,
                     // and a left-only bridge carries the left wall across the
                     // fillet span down to the body's own fade-in.
                     out.push((tx, ty, tw, (cy - rho) - ty + depth, (r, r, 0.0, 0.0), depth, false, (true, true, false, true)));
                     out.push((tx, cy - rho, tw, rho + depth, (0.0, 0.0, 0.0, 0.0), depth, false, (false, false, false, true)));
                     body_lr(throat_r + rho - depth, &mut out);
                 } else {
                     // Too narrow for the fillet: the plain square throat.
                     out.push((tx, ty, tw, th + depth, (r, r, 0.0, 0.0), depth, false, (true, true, false, true)));
                     if cx + cw > throat_r + 0.5 {
                         body_lr(throat_r - depth, &mut out);
                     } else {
                         // The tab spans the body: no top wall at all.
                         out.push((cx, cy, cw, ch, (0.0, 0.0, r, r), depth, false, (false, true, true, true)));
                     }
                 }
             } else {
                 let depth = section_carve_depth(th);
                 out.push((tx, ty, tw, th, r4(SECTION_R), depth, false, all));
             }
         }
 
         let hidden = self.hidden_rows();
         for (i, p) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             // (control, its configured corner radius, raised vs recessed)
             let ctl: Option<(&dyn WidgetHost, f32, bool)> = if is_text_row(&p.2) {
                 // The textpick picker is NOT in this list: with it the row is
                 // a field ([`Self::fields`]) — a well ending in a flush run.
                 self.texts[i].as_ref().map(|w| (w as &dyn WidgetHost, crate::layout::textbox_corner_radius(), false))
             } else if p.2.starts_with("choice") {
                 // The dropdown trigger is a FLUSH control, a field that is all
                 // run ([`Self::fields`]). A boss here read as a raised island
                 // the widget itself never draws.
                 None
             } else if p.2 == "button" {
                 // A flush control with a field run's edge, as its own paint
                 // draws it ([`Self::fields`]) — it was a boss here, a raised
                 // island the button itself never drew.
                 None
             } else if p.2 == "toggle" || p.2 == "checkbox" {
                 // A toggle is a field ([`Self::fields`]): its well and the
                 // flush run gliding in it, one outline round both.
                 None
             } else if p.2.starts_with("spinbox") {
                 // A plain well only when there is no -/+ run; with one the
                 // control is a field ([`Self::fields`]) and its -/+ seam a
                 // groove ([`Self::grooves`]). Same side-label inset, same
                 // content band, same depth cap as its paint.
                 if let Some(sb) = &self.spinboxes[i] {
                     let (x, y, w, h) = sb.rect();
                     let ty = sb.label_strip();
                     let band = Rect { x, y: y + ty, width: w, height: h - ty };
                     if w > 0.0 && h > 0.0 {
                         let r = crate::layout::spinbox_corner_radius();
                         let depth = crate::layout::bevel_width().min((h - ty) * 0.2);
                         // With its -/+ run the control is a field
                         // ([`Self::fields`]); without, a plain well.
                         if let Some(rel) = sb.inner().relief_parts(band) {
                             if rel.run.is_none() {
                                 out.push((x, y + ty, w, h - ty, r4(r), depth, false, all));
                             }
                         }
                     }
                 }
                 None
             } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
                 // The control's one well (`ColorSelector::field_relief`, the
                 // same geometry its paint carves); the swatch is a fill on its
                 // floor and the seam a groove, both on the widget's paint.
                 if let Some(c) = &self.colors[i] {
                     let (x, y, w, h) = c.rect();
                     let ty = c.label_strip();
                     if let Some((rx, ry, rw, rh, rr, rd)) =
                         c.inner().field_relief(Rect { x, y: y + ty, width: w, height: h - ty })
                     {
                         out.push((rx, ry, rw, rh, r4(rr), rd, false, all));
                     }
                 }
                 None
             } else {
                 // Sliders (and Float3's three rows) are bands: their well is
                 // hand-shaded quads that follow the band's contour, which reach
                 // a flat host through the plain-quad view — no rect carve.
                 None
             };
             if let Some((w, radius, raised)) = ctl {
                 let (x, y, ww, h) = w.rect();
                 if ww <= 0.0 || h <= 0.0 {
                     continue;
                 }
                 // The top-label band stays outside the relief like every other host.
                 let ty = w.label_strip();
                 let depth = crate::layout::bevel_width().min((h - ty) * 0.2);
                 // A text box joined to its picker is half of a field
                 // ([`Self::fields`]), drawn there.
                 if is_text_row(&p.2) && self.texts[i].as_ref().is_some_and(|t| t.inner().joined_right) {
                     continue;
                 }
                 out.push((x, y + ty, ww, h - ty, r4(radius), depth, raised, all));
             }
         }
         out
     }
 
     /// The rows that are ONE field with a run ([`Field`]: a sunken well
     /// holding a flush run, one outline round both), drawn AFTER
     /// [`Self::reliefs`]. A textpick row is its text box's well ending in its
     /// picker, a spinbox its value's well ending in its -/+ run
     /// ([`Field::ending_in_run`]); a dropdown or button row, a field that is
     /// all run ([`Field::run`]); a toggle, its own sliding field
     /// (`Toggle::field`). So every flush control in the pane has the same
     /// edge. The plain wells are not here — they are [`Self::reliefs`], which
     /// group into the pane's plate. They replaced
     /// `troughs()` on 2026-10-01. On the pane's own rule for wells and
     /// troughs: the content band as the outline, the wall straddling it.
     #[allow(clippy::type_complexity)]
     pub fn fields(&self) -> Vec<Field> {
         if !self.visible || !crate::layout::control_relief() {
             return Vec::new();
         }
         let mut out = Vec::new();
         let hidden = self.hidden_rows();
         for (i, p) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             if p.2.starts_with("textpick") {
                 if let (Some(tb), Some(d)) = (&self.texts[i], &self.choices[i]) {
                     if !tb.inner().joined_right {
                         continue;
                     }
                     let (x, y, w, h) = tb.rect();
                     let (dx, _, dw, _) = d.rect();
                     let ty = tb.label_strip();
                     if w > 0.0 && h - ty > 0.0 && dw > 0.0 {
                         let depth = crate::layout::bevel_width().min((h - ty) * 0.2);
                         let r = crate::layout::textbox_corner_radius();
                         let outline = Rect { x, y: y + ty, width: dx + dw - x, height: h - ty };
                         out.push(Field::ending_in_run(outline, (r, r, r, r), depth, dx));
                     }
                 }
             } else if p.2 == "button" {
                 // A button: a field that is all run, as its own flush plate
                 // (`Button::plate`, `PaintCtx::inset_plate`) on its
                 // band, at the button radius.
                 if let Some(b) = &self.buttons[i] {
                     let (x, y, w, h) = b.rect();
                     let ty = b.label_strip();
                     if w > 0.0 && h - ty > 0.0 {
                         let depth = crate::layout::bevel_width().min((h - ty) * 0.2);
                         let r = crate::layout::button_corner_radius();
                         out.push(Field::run(Rect { x, y: y + ty, width: w, height: h - ty }, (r, r, r, r), depth));
                     }
                 }
             } else if p.2.starts_with("choice") {
                 // The dropdown trigger: a field that is all run — the
                 // widget's own raised paint (`PaintCtx::inset_plate`)
                 // on the same band, radius and depth cap. Until 2026-10-01
                 // a trough, whose edge differed from the run's at the end of
                 // a text row's field.
                 if let Some(d) = &self.choices[i] {
                     let (x, y, w, h) = d.rect();
                     let ty = d.label_strip();
                     if w > 0.0 && h - ty > 0.0 {
                         let depth = crate::layout::bevel_width().min((h - ty) * 0.2);
                         let r = crate::layout::dropdown_corner_radius();
                         out.push(Field::run(Rect { x, y: y + ty, width: w, height: h - ty }, (r, r, r, r), depth));
                     }
                 }
             } else if p.2.starts_with("spinbox") {
                 if let Some(sb) = &self.spinboxes[i] {
                     let (x, y, w, h) = sb.rect();
                     let ty = sb.label_strip();
                     let band = Rect { x, y: y + ty, width: w, height: h - ty };
                     if let Some(rel) = sb.inner().relief_parts(band) {
                         if let Some((split, _)) = rel.run {
                             let r = rel.radius;
                             out.push(Field::ending_in_run(band, (r, r, r, r), rel.depth, split));
                         }
                     }
                 }
             } else if p.2 == "toggle" || p.2 == "checkbox" {
                 // The toggle's own field (`Toggle::field`) —
                 // exactly what its paint draws, on its band. It paints no
                 // fill, so this IS the control.
                 if let Some(t) = &self.toggles[i] {
                     let (x, y, w, h) = t.rect();
                     let ty = t.label_strip();
                     if w > 0.0 && h - ty > 0.0 {
                         // The pane's hover is the tint here, as on every field.
                         let band = Rect { x, y: y + ty, width: w, height: h - ty };
                         out.push(t.inner().field(band).with_tint(None));
                     }
                 }
             }
         }
         out
     }
 
     /// The engraved seams companion — `(a, b, width, depth, host)` for
     /// [`crate::scene::paint::PaintCtx::groove`], drawn AFTER [`Self::fields`]
     /// (a groove engraves the surface the trough's control face provides).
     /// Today: the seam dividing a spinbox's -/+ run into its two buttons —
     /// the breadcrumb's segment-seam language at miniature scale.
     #[allow(clippy::type_complexity)]
     pub fn grooves(&self) -> Vec<((f32, f32), (f32, f32), f32, f32, Rect)> {
         if !self.visible || !crate::layout::control_relief() {
             return Vec::new();
         }
         let mut out = Vec::new();
         let hidden = self.hidden_rows();
         for (i, p) in self.display_params.iter().enumerate() {
             if hidden[i] || !p.2.starts_with("spinbox") {
                 continue;
             }
             if let Some(sb) = &self.spinboxes[i] {
                 let (x, y, w, h) = sb.rect();
                 let ty = sb.label_strip();
                 let band = Rect { x, y: y + ty, width: w, height: h - ty };
                 if let Some(rel) = sb.inner().relief_parts(band) {
                     if let Some((_, (sa, sb2, sw, host))) = rel.run {
                         out.push((sa, sb2, sw, rel.depth, host));
                     }
                 }
             }
         }
         out
     }
 
     /// The knobs a flat host draws after [`Self::reliefs`] — none: the sliders
     /// are bands (their swell is part of the band's own quads), so this is kept
     /// only for the hosts that still call it.
     pub fn spheres(&self) -> Vec<(f32, f32, f32, [f32; 4])> {
         Vec::new()
     }
 
     /// The section carves' concave inside-corner fillets — `(cx, cy, radius,
     /// depth, start angle)` for [`crate::scene::paint::PaintCtx::concave_fillet`]
     /// (recessed), drawn by the host AFTER [`Self::reliefs`]. The box reliefs
     /// can only round convex corners; this rounds the throat where a tab's
     /// right wall turns onto its body's top edge.
     pub fn section_fillets(&self) -> Vec<(f32, f32, f32, f32, f32)> {
         if !self.visible || !crate::layout::control_relief() {
             return Vec::new();
         }
         let mut out = Vec::new();
         for (title, content) in self.section_boxes() {
             let (tx, _ty, tw, _th) = title;
             if let Some((cx, cy, cw, ch)) = content {
                 let depth = section_carve_depth(ch);
                 let throat_r = tx + tw;
                 if cx + cw > throat_r + 2.0 * SECTION_FILLET_R {
                     out.push((
                         throat_r + SECTION_FILLET_R,
                         cy - SECTION_FILLET_R,
                         SECTION_FILLET_R,
                         depth,
                         std::f32::consts::FRAC_PI_2,
                     ));
                 }
             }
         }
         out
     }
 
     /// The scene-path companion to the legacy views: rows whose widgets paint
     /// prims NO flat tuple view can carry (the ramp rows' curve fill, key
     /// circles, and field controls). A host rendering this panel through the
     /// legacy hatches calls this with its own `PaintCtx` inside the pane's
     /// scroll clip, after the flat chrome — or the rows draw as bare labels.
     /// Whether a row value changed inside `tick` since the last call
     /// (see `tick_value_changed`); clears the flag.
     pub fn take_tick_value_change(&mut self) -> bool {
         std::mem::take(&mut self.tick_value_changed)
     }
 
     pub fn paint_scene_rows(&self, pc: &mut PaintCtx) {
         if !self.visible {
             return;
         }
         let hidden = self.hidden_rows();
         let dummy = UiContext::new();
         for (i, p) in self.display_params.iter().enumerate() {
             if hidden[i] {
                 continue;
             }
             if p.2 == "ramp" {
                 if let Some(rp) = &self.ramps[i] {
                     rp.paint_self(&dummy, pc);
                 }
             } else if let Some(f) = self.float3s[i].as_ref().filter(|f| f.has_trackball()) {
                 // A float3's trackball: a sphere is not a prim the flat
                 // views carry, so it rides the scene path like the ramp.
                 f.paint_ball(pc);
             }
         }
     }
 
 }
 
 impl Layout for ParametersBg {
     /// Ungated rect landing (the legacy `set_rect` head, before its visibility gate): cache the
     /// rect all row geometry derives from, then re-derive content height/scroll/row rects.
     fn rect_assigned(&mut self, rect: Rect) {
         self.rect = rect;
         self.refresh_scroll_metrics();
     }
 
 }
 
 impl Paint for ParametersBg {
     /// Shape the hosted controls (their carets read per-glyph advances nothing
     /// else records for children of a container) and one code column's advance
     /// from the same monospace@12 path the code rows draw through.
     fn prepare_text(&mut self, fs: &mut cosmic_text::FontSystem, _rect: Rect) {
         for tb in self.texts.iter_mut().flatten() {
             tb.prepare_text(fs);
         }
         for sb in self.spinboxes.iter_mut().flatten() {
             sb.prepare_text(fs);
         }
         for c in self.colors.iter_mut().flatten() {
             c.prepare_text(fs);
         }
         let clusters = crate::backend::text::shaped_cluster_offsets(
             fs,
             "MMMMMMMM",
             12.0,
             Some("monospace"),
         );
         if let Some(&(_, total)) = clusters.last() {
             if total > 0.0 {
                 self.code_char_advance = total / 8.0;
             }
         }
     }
 
     /// The panel IS its own background plate (the host draws it from `color()` + the corner
     /// style via `append_widget_plate`) — there is no separate plate widget behind it, so
     /// this carries the full plate treatment: `PARAM_BG` scaled by the global plate opacity,
     /// with the alpha negated as the scenefx blur marker when plate blur is on. Transparent
     /// while hidden. It must not ALSO be emitted as a quad anywhere or it would double-blend.
     fn color(&self) -> [f32; 4] {
         if !self.visible {
             return [0.0, 0.0, 0.0, 0.0];
         }
         colors::param_plate_fill()
     }
 
     /// The shared plate corner radius (rounded on all four corners when non-zero).
     fn corner_style(&self, _rect: Rect) -> Option<(f32, (bool, bool, bool, bool))> {
         let r = crate::layout::plate_corner_radius();
         let on = r > 0.0;
         Some((r, (on, on, on, on)))
     }
 
     /// The shared plate border (folded in from the retired backing plate widget).
     fn solid_border(&self) -> Option<([f32; 4], f32)> {
         colors::plate_border_color().map(|bc| (bc, colors::plate_border_thickness()))
     }
 
     fn widget_font(&self) -> Option<String> {
         Some(crate::layout::control_label_font())
     }
 
     /// The COMPLETE row chrome — everything the legacy hatches carry, in the hosts' canonical
     /// draw order: the controls' rounded wells, the flat-style section outline fillets, the
     /// relief steps (after the fills so the walls shade what they cross), the section carves'
     /// concave throat fillets, the slider-thumb spheres, the scene-path rows, the flat
     /// plain-quad chrome, then the hosted controls' glyphs (arrows, −/+) over it. What stays OUT, deliberately: the background plate (see
     /// [`color`](Paint::color)), the scrollbar (hosts place its depth — the designer straddles
     /// it around the pane plate), and text (`paint_self`'s own-labels bridge carries the
     /// per-row fonts and code-box bounds). Hosts clip this to their pane viewport — a rect
     /// clip pushed here would not survive `paint_self`'s replay.
     fn paint_ui(&self, _ui: &UiContext, _rect: Rect, ctx: &mut PaintCtx) {
         if !self.visible {
             return;
         }
         self.claim_typing(ctx);
         self.paint_row_floors(ctx);
         for (qx, qy, qw, qh, qr, qc, corners) in self.rounded_quads() {
             ctx.rounded_rect(Rect { x: qx, y: qy, width: qw, height: qh }, qr, corners, qc);
         }
         for (acx, acy, ar, at, a0, a1, ac) in self.arcs() {
             ctx.arc(acx, acy, ar, at, a0, a1, ac);
         }
         // The hovered row's carves are TINTED — the focus treatment's channel
         // with a neutral light instead of the accent: the rim's own light and
         // shadow, recoloured and gained, so the control under the pointer
         // reads lit while every other carve keeps the plate's grouped shading.
         // A tinted carve shades through the overlay path by design, and a
         // section's well spans many rows, so it never qualifies.
         let hover_rect = self.hover_row.and_then(|i| self.get_param_rects().get(i).copied()).filter(|r| r.3 > 0.0);
         let hovered = |x: f32, y: f32, w: f32, h: f32| {
             hover_rect.is_some_and(|(rx, ry, rw, rh)| {
                 x >= rx - 0.5 && y >= ry - 0.5 && x + w <= rx + rw + 0.5 && y + h <= ry + rh + 0.5
             })
         };
         for (rx, ry, rw, rh, radii, rd, raised, edges) in self.reliefs() {
             let rect = Rect { x: rx, y: ry, width: rw, height: rh };
             match (raised, hovered(rx, ry, rw, rh)) {
                 (true, true) => ctx.boss_edges_tinted(rect, radii, rd, edges, Self::HOVER_TINT),
                 (true, false) => ctx.boss_edges(rect, radii, rd, edges),
                 (false, true) => ctx.recess_edges_tinted(rect, radii, rd, edges, Self::HOVER_TINT),
                 (false, false) => ctx.recess_edges(rect, radii, rd, edges),
             }
         }
         for field in self.fields() {
             let r = field.rect;
             let tint = hovered(r.x, r.y, r.width, r.height).then_some(Self::HOVER_TINT);
             ctx.field(&field.with_tint(tint));
         }
         for (ga, gb, gw, gd, ghost) in self.grooves() {
             ctx.groove(ga, gb, gw, gd, ghost);
         }
         for (fcx, fcy, fr, fd, fs) in self.section_fillets() {
             ctx.concave_fillet(fcx, fcy, fr, fd, fs, false);
         }
         for (scx, scy, sr, sc) in self.spheres() {
             ctx.sphere(scx, scy, sr, &crate::scene::material::Material::from_fill(sc));
         }
         self.paint_scene_rows(ctx);
         for (qx, qy, qw, qh, qc) in self.plain_quads() {
             ctx.quad(Rect { x: qx, y: qy, width: qw, height: qh }, qc);
         }
         self.paint_child_glyphs(ctx);
     }
 
     /// Ui-less emission (the [`paint_ui`](Paint::paint_ui) override above is what `paint_self`
     /// runs): the flat subset plus the scrollbar, kept for direct callers only. The background
     /// plate stays out — see [`color`](Paint::color).
     fn paint(&self, _rect: Rect, ctx: &mut PaintCtx) {
         self.claim_typing(ctx);
         for (qx, qy, qw, qh, qc) in self.plain_quads() {
             ctx.quad(Rect { x: qx, y: qy, width: qw, height: qh }, qc);
         }
         self.paint_scene_rows(ctx);
         self.paint_child_glyphs(ctx);
         // Scene-path hosts get the scrollbar on top (the designer instead straddles it around
         // the pane plate through `scrollbar_quads`).
         for (qx, qy, qw, qh, qc) in self.scrollbar_quads() {
             ctx.quad(Rect { x: qx, y: qy, width: qw, height: qh }, qc);
         }
         let view_min = self.rect.y + 4.0;
         let view_max = self.rect.y + self.rect.height - 4.0;
         // The y test above culls the scrolled-away rows; it is the pane's
         // WIDTH that nothing enforced, so a long parameter name ran out of the
         // pane sideways.
         let pane = Some([
             self.rect.x,
             self.rect.y,
             self.rect.x + self.rect.width,
             self.rect.y + self.rect.height,
         ]);
         for l in self.own_text_labels() {
             if l.y >= view_min - 20.0 && l.y <= view_max + 20.0 {
                 ctx.text_with(l.text, l.x, l.y, l.font_size, l.color, None, pane);
             }
         }
     }
 
     fn serves_legacy_labels(&self) -> bool {
         true
     }
 
     /// The legacy `text_labels_with_font_and_bounds` body: every label clipped to the panel
     /// viewport in the control-label font, except labels inside a code row — those clip to the
     /// code box (or hide when it's scrolled out) and render monospace.
     fn legacy_labels_with_font_and_bounds(&self, _rect: Rect, _ctx: &UiContext) -> Vec<(TextLabel, Option<String>, Option<[f32; 4]>)> {
         let view_min = self.rect.y + 4.0;
         let view_max = self.rect.y + self.rect.height - 4.0;
         let mut result = Vec::new();
         let font = Paint::widget_font(self);
         let rects = self.get_param_rects();
         for l in self.own_text_labels() {
             if l.y < view_min - 20.0 || l.y > view_max + 20.0 {
                 continue;
             }
             let mut bounds = Some([self.rect.x + 4.0, view_min, self.rect.x + self.rect.width - 4.0, view_max]);
             let mut label_font = font.clone();
             for (i, p) in self.display_params.iter().enumerate() {
                 if p.2 == "code" {
                     let r = rects[i];
                     if l.y >= r.1 + 18.0 && l.y <= r.1 + r.3 {
                         let code_min = (r.1 + 19.0).max(view_min);
                         let code_max = (r.1 + r.3 - 1.0).min(view_max);
                         if code_min < code_max {
                             bounds = Some([r.0 + 1.0, code_min, r.0 + r.2 - 1.0, code_max]);
                         } else {
                             bounds = Some([0.0, 0.0, 0.0, 0.0]); // hidden
                         }
                         label_font = Some("monospace".to_string());
                         break;
                     }
                 }
             }
             result.push((l, label_font, bounds));
         }
         result
     }
 
     fn popover(&self, _rect: Rect) -> Option<(f32, f32, f32, f32)> {
         self.choices_popover_rect()
     }
 
     /// The dropdown rows' popovers; the raw children's are the adapter's recursion.
     fn draw_popover(&self, _rect: Rect, pc: &mut dyn crate::layout::RenderTarget) {
         for d in self.choices.iter().flatten() {
             d.render_popover(pc);
         }
         for rp in self.ramps.iter().flatten() {
             rp.inner().preset_dropdown.render_popover(pc);
             rp.inner().line_type_dropdown.render_popover(pc);
         }
     }
 }
 
 impl Input for ParametersBg {
     /// While a code row is being edited, the clipboard, selection and
     /// history actions are the editor's — the runner routes the undo / redo
     /// chords here before the app's own history gets them.
     fn context_action(&mut self, action: crate::widget::ContextAction) -> bool {
         if self.code_editing() {
             return self.code_action(action);
         }
         false
     }
 
     fn scrollable(&self) -> bool {
         true
     }
 
     /// Legacy `mouse_input` saw every press (and consumes every left press — the designer
     /// relies on the panel swallowing clicks anywhere while it's the dispatch target).
     fn gates_presses(&self) -> bool {
         false
     }
 
     /// Legacy hit reach: the panel rect, or an open popover (a dropdown row's list extends
     /// below the panel).
     fn hit(&self, rect: Rect, px: f32, py: f32) -> bool {
         if px >= rect.x && px <= rect.x + rect.width && py >= rect.y && py <= rect.y + rect.height {
             return true;
         }
         if let Some((pop_x, pop_y, pop_w, pop_h)) = self.own_popover_rect() {
             if px >= pop_x && px <= pop_x + pop_w && py >= pop_y && py <= pop_y + pop_h {
                 return true;
             }
         }
         false
     }
 
 
     // --- The host-driven drag surface (the designer routes pointer drags here directly). ---
 
     fn draggable(&self, _rect: Rect) -> bool {
         self.scrollbar_dragging
             || self.dragging_param.is_some()
             || self.display_params.iter().any(|p| p.2.starts_with("slider") || is_vec_row(&p.2))
     }
 
     fn is_dragging(&self) -> bool {
         self.scrollbar_dragging || self.dragging_param.is_some()
     }
 
     fn drag_begin(&mut self, px: f32, py: f32, _rect: Rect) {
         if self.scrollbar_dragging {
             return;
         }
         let rects = self.get_param_rects();
         for (i, p) in self.display_params.iter().enumerate() {
             if p.2.starts_with("slider") {
                 let r = rects[i];
                 if let Some(s) = &mut self.sliders[i] {
                     let top = s.label_strip();
                     if py >= r.1 + top && py <= r.1 + r.3 {
                         s.drag_begin(px, py);
                         self.dragging_param = Some(i);
                         break;
                     }
                 }
             } else if is_vec_row(&p.2) {
                 let r = rects[i];
                 if py >= r.1 && py <= r.1 + r.3 {
                     if let Some(f) = &mut self.float3s[i] {
                         let mut dummy = crate::context::UiContext::new();
                         if f.mouse_input(MouseButton::Left, ElementState::Pressed, px, py, &mut dummy) {
                             self.dragging_param = Some(i);
                             break;
                         }
                     }
                 }
             }
         }
     }
 
     fn drag_update(&mut self, px: f32, py: f32, _rect: Rect) -> bool {
         if self.scrollbar_dragging {
             let sb_track_h = self.rect.height - 8.0;
             let sb_track_y = self.rect.y + 4.0;
             let visible_ratio = self.rect.height / self.content_h;
             let thumb_h = if sb_track_h <= 20.0 {
                 sb_track_h
             } else {
                 (sb_track_h * visible_ratio).clamp(20.0, sb_track_h)
             };
             let max_scroll = (self.content_h - self.rect.height).max(0.0);
 
             let target_thumb_y = py - self.drag_offset_y;
             let new_scroll_ratio = if sb_track_h - thumb_h > 0.0 {
                 ((target_thumb_y - sb_track_y) / (sb_track_h - thumb_h)).clamp(0.0, 1.0)
             } else {
                 0.0
             };
 
             let old_scroll = self.scroll_y;
             self.scroll_y = new_scroll_ratio * max_scroll;
             if (self.scroll_y - old_scroll).abs() > 0.01 {
                 self.update_slider_rects();
                 return true;
             }
             return false;
         }
 
         if let Some(i) = self.dragging_param {
             if let Some(s) = &mut self.sliders[i] {
                 if s.drag_update(px, py) {
                     let new_val = s.get_scaled_value();
                     let old_val = &self.display_params[i].1;
                     let new_val_str = format!("{:.*}", slider_decimals(&self.display_params[i].2), new_val);
                     if *old_val != new_val_str {
                         self.display_params[i].1 = new_val_str;
                         return true;
                     }
                 }
             } else if let Some(f) = &mut self.float3s[i] {
                 if f.drag_update(px, py) {
                     let new_val_str = f.value_string();
                     if self.display_params[i].1 != new_val_str {
                         self.display_params[i].1 = new_val_str;
                         return true;
                     }
                 }
             }
         }
         false
     }
 
     fn drag_end(&mut self) {
         if self.scrollbar_dragging {
             self.scrollbar_dragging = false;
             self.activity.bump();
             return;
         }
         if let Some(i) = self.dragging_param.take() {
             if let Some(s) = &mut self.sliders[i] {
                 s.drag_end();
             } else if let Some(f) = &mut self.float3s[i] {
                 f.drag_end();
             }
         }
     }
 
     /// Legacy `tick` forwarded to the raw children (the adapter's recursion now) and the
     /// checkbox rows. The checkbox tick never touches the ctx (a leaf `Adapted` tick is
     /// ctx-free), so the in-file dummy-ctx convention (`drag_begin`, `collect_child_quads`)
     /// applies.
     fn tick(&mut self, dt: f32, _rect: Rect) -> bool {
         if !self.visible {
             return false;
         }
         let mut changed = false;
         let mut dummy = crate::context::UiContext::new();
         // Choice rows tick their Dropdowns' open/close animation. This was the
         // ONLY path that can advance a pane dropdown's anim_snap (the widget's
         // tick-receiver registration points at an id pane internals never put
         // in the host tree), and without it every params-pane dropdown opened
         // at zero drawn extent: logically open, invisible, reporting a sliver
         // popover rect — and the next click toggled it closed again.
         for d in self.choices.iter_mut().flatten() {
             if d.tick(dt, &mut dummy) {
                 changed = true;
             }
         }
         for cb in self.toggles.iter_mut().flatten() {
             if cb.tick(dt, &mut dummy) {
                 changed = true;
             }
         }
         // Slider rows tick their wheel-glide inertia — fold a coasting value
         // back into the row string so hosts syncing off display_params apply
         // it, exactly like a live wheel event would.
         for i in 0..self.sliders.len() {
             if let Some(s) = &mut self.sliders[i] {
                 if s.tick(dt, &mut dummy) {
                     let new_val = s.get_scaled_value();
                     let new_val_str = format!("{:.*}", slider_decimals(&self.display_params[i].2), new_val);
                     if self.display_params[i].1 != new_val_str {
                         self.display_params[i].1 = new_val_str;
                     }
                     changed = true;
                 }
             }
         }
         // Float3 rows are three slider rows: same glide, same fold-back.
         for i in 0..self.float3s.len() {
             if let Some(f) = &mut self.float3s[i] {
                 if f.tick(dt, &mut dummy) {
                     let new_val_str = f.value_string();
                     if self.display_params[i].1 != new_val_str {
                         self.display_params[i].1 = new_val_str;
                     }
                     changed = true;
                 }
             }
         }
         // Ramp rows tick their field widgets (preset application, slider→key
         // sync) and drain their change flag — fold the curve back into the row
         // value when it moved.
         for i in 0..self.ramps.len() {
             if let Some(rp) = &mut self.ramps[i] {
                 if rp.tick(dt, &mut dummy) {
                     self.display_params[i].1 = rp.inner().spec_string();
                     changed = true;
                 }
             }
         }
         // Color rows tick their picker-stream poll (`cce-color-editor --stream`
         // lines applying live) — fold a changed value back into the row so
         // hosts syncing off display_params see it while the picker is open.
         for i in 0..self.colors.len() {
             if let Some(c) = &mut self.colors[i] {
                 if c.tick(dt, &mut dummy) {
                     if let Some(val) = c.get_value_string() {
                         if self.display_params[i].1 != val {
                             self.display_params[i].1 = val;
                             self.tick_value_changed = true;
                         }
                     }
                     changed = true;
                 }
             }
         }
         // The pane's own wheel glide / trackpad coast: adopt any host write to
         // `scroll_y`, advance, and re-seat the rows when the offset moved.
         self.scroll_motion.reconcile(0.0, self.scroll_y);
         let pane_max = (self.content_h - self.rect.height).max(0.0);
         if self.scroll_motion.tick(dt, crate::widget::Bounds::max(0.0), crate::widget::Bounds::max(pane_max)) {
             self.scroll_y = self.scroll_motion.y.pos();
             self.update_slider_rects();
             self.rehover_after_scroll(&mut dummy);
             changed = true;
         }
         if self.scroll_motion.is_animating() {
             changed = true;
         }
         // Decay the "recently scrolled" window; keep frames coming until it expires so the
         // scrollbar's sink behind the plate actually renders.
         if self.activity.holding() {
             changed = true;
         }
         // Re-latch the raised state (e.g. sink once the scroll window lapses).
         let visible = self.scrollbar_visible();
         if self.activity.tick(dt, visible, self.scrollbar_dragging) {
             changed = true;
         }
         changed
     }
 
     fn visibility_changed(&mut self, visible: bool) {
         self.visible = visible;
     }
 
     fn on_event(&mut self, event: &Event, ectx: &mut EventCtx) -> bool {
         // Copied before `ectx.ui` is borrowed: the wheel arm's occlusion check keys on the
         // adapter's address (the pointer hosts register/popover-track).
         let self_id = ectx.id;
         match event {
             // Hosts call `unfocus()` directly (the designer's pane switches): commit the
             // focused row and unfocus the children. Needs no ctx, so the direct path's
             // ui-less synthesis works too.
             Event::FocusOut => {
                 self.commit_and_unfocus();
                 true
             }
             Event::PointerMove { x: px, y: py, .. } => {
                 let (px, py) = (*px, *py);
                 self.mouse_pos = Some((px, py));
                 // Track scrollbar hover, then re-latch: hover only sustains an already-raised
                 // bar (a sunk one is behind the plate, so the pointer never reaches it), so
                 // the only visible change here is the raised state — redraw on that transition.
                 let hover = self.hit_test_scrollbar(px, py);
                 self.activity.set_hover(hover);
                 let raised_changed = self.recompute_scrollbar_raised();
                 let Some(ui) = ectx.ui.as_deref_mut() else {
                     return raised_changed;
                 };
                 let mut changed = raised_changed;
 
                 if self.scrollbar_dragging {
                     let sb_track_h = self.rect.height - 8.0;
                     let sb_track_y = self.rect.y + 4.0;
                     let visible_ratio = self.rect.height / self.content_h;
                     let thumb_h = if sb_track_h <= 20.0 {
                         sb_track_h
                     } else {
                         (sb_track_h * visible_ratio).clamp(20.0, sb_track_h)
                     };
                     let max_scroll = (self.content_h - self.rect.height).max(0.0);
 
                     let target_thumb_y = py - self.drag_offset_y;
                     let new_scroll_ratio = if sb_track_h - thumb_h > 0.0 {
                         ((target_thumb_y - sb_track_y) / (sb_track_h - thumb_h)).clamp(0.0, 1.0)
                     } else {
                         0.0
                     };
 
                     let old_scroll = self.scroll_y;
                     self.scroll_y = new_scroll_ratio * max_scroll;
                     if (self.scroll_y - old_scroll).abs() > 0.01 {
                         self.update_slider_rects();
                         changed = true;
                     }
                 }
 
                 if self.hover_controls(px, py, ui) {
                     changed = true;
                 }
 
                 changed
             }
             Event::MouseButton { button, state, x: px, y: py, .. } => {
                 if !self.visible {
                     return false;
                 }
                 let (button, state, px, py) = (*button, *state, *px, *py);
                 let Some(ui) = ectx.ui.as_deref_mut() else {
                     return false;
                 };
 
                 if button == MouseButton::Left {
                     if state == ElementState::Pressed {
                         // Only a raised bar can be grabbed — a sunk one is behind the plate,
                         // so the press falls through to the pane content underneath it.
                         if self.activity.raised() && self.hit_test_scrollbar(px, py) {
                             // Legacy called `self.focus()` here — base flag only, which
                             // nothing reads (see module docs).
                             self.scrollbar_dragging = true;
 
                             let sb_track_h = self.rect.height - 8.0;
                             let sb_track_y = self.rect.y + 4.0;
                             let visible_ratio = self.rect.height / self.content_h;
                             let thumb_h = if sb_track_h <= 20.0 {
                                 sb_track_h
                             } else {
                                 (sb_track_h * visible_ratio).clamp(20.0, sb_track_h)
                             };
                             let max_scroll = (self.content_h - self.rect.height).max(0.0);
                             let scroll_ratio = if max_scroll > 0.0 { self.scroll_y / max_scroll } else { 0.0 };
                             let thumb_y = sb_track_y + scroll_ratio * (sb_track_h - thumb_h);
 
                             let click_offset = py - thumb_y;
                             if click_offset >= 0.0 && click_offset <= thumb_h {
                                 self.drag_offset_y = click_offset;
                             } else {
                                 // Clicked outside the thumb: jump thumb center to py
                                 self.drag_offset_y = thumb_h / 2.0;
                                 let target_thumb_y = py - self.drag_offset_y;
                                 let new_scroll_ratio = if sb_track_h - thumb_h > 0.0 {
                                     ((target_thumb_y - sb_track_y) / (sb_track_h - thumb_h)).clamp(0.0, 1.0)
                                 } else {
                                     0.0
                                 };
                                 self.scroll_y = new_scroll_ratio * max_scroll;
                                 self.update_slider_rects();
                             }
                             return true;
                         }
                     } else if state == ElementState::Released
                         && self.scrollbar_dragging {
                             self.scrollbar_dragging = false;
                             self.activity.bump();
                             return true;
                         }
                 }
 
                 // A press on a section's title box collapses/expands it. Checked before the
                 // rows so a header can never be shadowed by a control under it, and only on
                 // the press — the matching release lands on whatever the relayout moved
                 // under the pointer, which must not toggle it straight back.
                 if button == MouseButton::Left && state == ElementState::Pressed {
                     let rects = self.get_param_rects();
                     let hit = self.display_params.iter().enumerate().position(|(i, p)| {
                         if p.2 != "section" {
                             return false;
                         }
                         let (bx, by, bw, bh) = self.section_title_box(i, rects[i]);
                         px >= bx && px <= bx + bw && py >= by && py <= by + bh
                     });
                     if let Some(i) = hit {
                         let title = self.display_params[i].0.clone();
                         let collapsed = self.collapsed.contains(&title);
                         // Collapsing out from under a focused row would strand the editor.
                         self.commit_and_unfocus();
                         self.set_section_collapsed(&title, !collapsed);
                         return true;
                     }
                 }
 
                 let hidden = self.hidden_rows();
 
                 // 1. Check open dropdown popovers first (since they are drawn on top)
                 for (i, d_opt) in self.choices.iter_mut().enumerate() {
                     if hidden[i] {
                         continue;
                     }
                     if let Some(d) = d_opt {
                         if std::env::var("CCE_PARAM_DEBUG").is_ok() {
                             eprintln!("[pdbg] press ({px:.0},{py:.0}) choice[{i}] open-priority: popover_rect={:?}", d.popover_rect());
                         }
                         if let Some((ox, oy, ow, oh)) = d.popover_rect() {
                             // Textpick pickers are press-driven end to end
                             // (selection fires on the option PRESS): a release
                             // over the open surface is swallowed, never
                             // dispatched — mid-animation it can read as an
                             // outside press and close the menu it just opened.
                             if state != ElementState::Pressed
                                 && self.display_params[i].2.starts_with("textpick")
                             {
                                 if px >= ox && px <= ox + ow && py >= oy && py <= oy + oh {
                                     return true;
                                 }
                                 continue;
                             }
                             let consumed = d.mouse_input(button, state, px, py, ui);
                             if std::env::var("CCE_PARAM_DEBUG").is_ok() {
                                 eprintln!("[pdbg]   -> open dropdown consumed={consumed}");
                             }
                             if consumed {
                                 if d.take_change() {
                                     if let Some(val) = d.get_value_string() {
                                         // A textpick row's pick fills its
                                         // TextBox — the box IS the value.
                                         if self.display_params[i].2.starts_with("textpick") {
                                             if let Some(tb) = &mut self.texts[i] {
                                                 tb.text = val.clone();
                                                 tb.edit_buffer = val.clone();
                                             }
                                         }
                                         self.display_params[i].1 = val;
                                     }
                                 }
                                 return true;
                             }
                         }
                     }
                 }
                 // The ramp rows' field dropdowns can pop over neighboring rows too.
                 for (i, rp_opt) in self.ramps.iter_mut().enumerate() {
                     if hidden[i] {
                         continue;
                     }
                     if let Some(rp) = rp_opt {
                         let ramp = rp.inner();
                         if (ramp.preset_dropdown.popover_rect().is_some()
                             || ramp.line_type_dropdown.popover_rect().is_some())
                             && rp.mouse_input(button, state, px, py, ui) {
                                 self.display_params[i].1 = rp.inner().spec_string();
                                 return true;
                             }
                     }
                 }
 
                 // 2. Propagate to our widgets
                 for (i, p) in self.display_params.iter_mut().enumerate() {
                     if hidden[i] {
                         continue;
                     }
                     if p.2.starts_with("choice") {
                         if let Some(d) = &mut self.choices[i] {
                             if d.mouse_input(button, state, px, py, ui) {
                                 // Claim the param focus while the dropdown is
                                 // open — the KeyInput arm above is gated on
                                 // `focused_param`, and without this the choice
                                 // row was the ONE row type that never set it,
                                 // so Escape/arrows/Enter could not reach an
                                 // open params dropdown (found via cce-designer).
                                 if d.open {
                                     self.focused_param = Some(i);
                                 } else if self.focused_param == Some(i) {
                                     self.focused_param = None;
                                 }
                                 if d.take_change() {
                                     if let Some(val) = d.get_value_string() {
                                         p.1 = val;
                                     }
                                 }
                                 return true;
                             }
                         }
                     } else if p.2 == "button" {
                         if let Some(b) = &mut self.buttons[i] {
                             if b.mouse_input(button, state, px, py, ui) {
                                 if std::env::var("CCE_PARAM_DEBUG").is_ok() {
                                     eprintln!("[pdbg] press ({px:.0},{py:.0}) BUTTON[{i}] '{}' consumed", p.0);
                                 }
                                 if b.take_click() {
                                     p.1 = "clicked".to_string();
                                 }
                                 return true;
                             }
                         }
                     } else if is_text_row(&p.2) {
                         if let Some(d) = &mut self.choices[i] {
                             // The picker acts on PRESSES only; the release
                             // over the button is swallowed. Releases used to
                             // reach the dropdown, and one arriving before the
                             // open animation's first frame (a fast or
                             // injected click) read as an outside press and
                             // closed the menu it had just opened.
                             let (bx, by, bw, bh) = d.rect();
                             let on_button =
                                 px >= bx && px <= bx + bw && py >= by && py <= by + bh;
                             if state == ElementState::Pressed {
                                 if d.mouse_input(button, state, px, py, ui) {
                                     if d.take_change() {
                                         if let Some(val) = d.get_value_string() {
                                             if let Some(tb) = &mut self.texts[i] {
                                                 tb.text = val.clone();
                                                 tb.edit_buffer = val.clone();
                                             }
                                             p.1 = val;
                                         }
                                     }
                                     return true;
                                 }
                             } else if on_button {
                                 return true;
                             }
                         }
                         if let Some(tb) = &mut self.texts[i] {
                             if tb.mouse_input(button, state, px, py, ui) {
                                 if tb.editing {
                                     self.focused_param = Some(i);
                                 } else {
                                     if self.focused_param == Some(i) {
                                         self.focused_param = None;
                                     }
                                 }
                                 if tb.take_change() {
                                     if let Some(val) = tb.get_value_string() {
                                         p.1 = val;
                                     }
                                 }
                                 return true;
                             }
                         }
                     } else if p.2.starts_with("spinbox") {
                         if let Some(sb) = &mut self.spinboxes[i] {
                             if sb.mouse_input(button, state, px, py, ui) {
                                 p.1 = sb.value.to_string();
                                 if sb.editing {
                                     self.focused_param = Some(i);
                                 } else {
                                     if self.focused_param == Some(i) {
                                         self.focused_param = None;
                                     }
                                 }
                                 return true;
                             }
                         }
                     } else if p.2 == "toggle" || p.2 == "checkbox" {
                         if let Some(cb) = &mut self.toggles[i] {
                             if cb.mouse_input(button, state, px, py, ui) {
                                 if cb.take_change() {
                                     if let Some(val) = cb.get_value_string() {
                                         p.1 = val;
                                     }
                                 }
                                 return true;
                             }
                         }
                     } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
                         if let Some(c) = &mut self.colors[i] {
                             if c.mouse_input(button, state, px, py, ui) {
                                 if let Some(val) = c.get_value_string() {
                                     p.1 = val;
                                 }
                                 if c.editing {
                                     self.focused_param = Some(i);
                                 } else {
                                     if self.focused_param == Some(i) {
                                         self.focused_param = None;
                                     }
                                 }
                                 return true;
                             }
                         }
                     } else if p.2 == "ramp" {
                         if let Some(rp) = &mut self.ramps[i] {
                             if rp.mouse_input(button, state, px, py, ui) {
                                 p.1 = rp.inner().spec_string();
                                 return true;
                             }
                         }
                     }
                 }
 
                 if button == MouseButton::Left && state == ElementState::Pressed {
                     let rects = self.get_param_rects();
                     let mut clicked_any_focusable = false;
                     for (i, p) in self.display_params.iter_mut().enumerate() {
                         if hidden[i] {
                             continue;
                         }
                         if p.2 == "code" {
                             let r = rects[i];
                             if px >= r.0 && px <= r.0 + r.2 && py >= r.1 + Self::CODE_BOX_TOP && py <= r.1 + r.3 {
                                 // Clicking inside the box already being edited moves the
                                 // caret and keeps the buffer (and its history); a click
                                 // into a different row's box starts a fresh editor.
                                 let mut editor = match (self.focused_param == Some(i), self.code_editor.take()) {
                                     (true, Some(e)) => e,
                                     (_, other) => {
                                         drop(other);
                                         self.code_history.clear();
                                         TextEditorState::new(p.1.clone())
                                     }
                                 };
                                 self.focused_param = Some(i);
                                 let click_x = px - self.code_text_x(r);
                                 let click_y = py - (r.1 + Self::CODE_TOP);
                                 let line = (click_y / Self::CODE_LINE_H).floor().max(0.0) as usize;
                                 let col = (click_x / self.code_col_w() + 0.5).floor().max(0.0) as usize;
                                 let at = map_2d_to_1d(&editor.buffer, line, col);
                                 if ui.shift_pressed {
                                     if editor.select_anchor.is_none() {
                                         editor.select_anchor = Some(editor.cursor_idx);
                                     }
                                 } else {
                                     editor.clear_selection();
                                 }
                                 editor.cursor_idx = at;
                                 self.code_editor = Some(editor);
                                 clicked_any_focusable = true;
                                 break;
                             }
                         } else if p.2.starts_with("slider") {
                             let r = rects[i];
                             if py >= r.1 && py <= r.1 + r.3 {
                                 if let Some(s) = &mut self.sliders[i] {
                                     if s.mouse_input(button, state, px, py, ui) {
                                         if s.editing {
                                             self.focused_param = Some(i);
                                             clicked_any_focusable = true;
                                         }
                                         break;
                                     }
                                 }
                             }
                         } else if is_vec_row(&p.2) {
                             let r = rects[i];
                             if py >= r.1 && py <= r.1 + r.3 {
                                 if let Some(f) = &mut self.float3s[i] {
                                     if f.mouse_input(button, state, px, py, ui) {
                                         if f.editing_idx().is_some() {
                                             self.focused_param = Some(i);
                                             clicked_any_focusable = true;
                                         }
                                         break;
                                     }
                                 }
                             }
                         }
                     }
                     if !clicked_any_focusable {
                         self.commit_and_unfocus();
                     }
                     return true;
                 }
                 false
             }
             Event::KeyInput(event) => {
                 if !self.visible {
                     return false;
                 }
                 let Some(ui) = ectx.ui.as_deref_mut() else {
                     return false;
                 };
                 if let Some(idx) = self.focused_param {
                     if event.state == ElementState::Pressed {
                         let p = &mut self.display_params[idx];
                         if p.2 == "code" {
                             if let Some(mut editor) = self.code_editor.take() {
                                 // Edits go to the BUFFER, not the value: a script
                                 // re-evaluates the node on every value change, and
                                 // a half-typed line would fail on every keystroke.
                                 // ctrl+enter applies, and so does leaving the row
                                 // (Escape, a click elsewhere, `unfocus`).
                                 let before = editor.clone();
                                 let mut handled = true;
                                 let mut edited = false;
                                 let mut apply = false;
                                 let mut should_unfocus = false;
                                 let shift = event.shift;
                                 let move_vertical = |editor: &mut TextEditorState, delta: i32| {
                                     if shift && editor.select_anchor.is_none() {
                                         editor.select_anchor = Some(editor.cursor_idx);
                                     } else if !shift {
                                         editor.clear_selection();
                                     }
                                     let (line, col) = get_cursor_line_col(&editor.buffer, editor.cursor_idx);
                                     let total = editor.buffer.split('\n').count() as i32;
                                     let target = (line as i32 + delta).clamp(0, total - 1) as usize;
                                     editor.cursor_idx = map_2d_to_1d(&editor.buffer, target, col);
                                 };
                                 match &event.logical_key {
                                     Key::Named(NamedKey::Backspace) => {
                                         edited = editor.delete_backwards();
                                     }
                                     Key::Named(NamedKey::Delete) => {
                                         edited = editor.delete_forwards();
                                     }
                                     Key::Named(NamedKey::Enter) if event.ctrl => {
                                         apply = true;
                                     }
                                     Key::Named(NamedKey::Enter) => {
                                         // Auto-indent: the line's own leading whitespace,
                                         // one level deeper after an opening brace.
                                         let line_start = get_line_start(&editor.buffer, editor.cursor_idx);
                                         let line: String = editor.buffer.chars().skip(line_start).take(editor.cursor_idx - line_start).collect();
                                         let mut indent: String = line.chars().take_while(|c| *c == ' ' || *c == '\t').collect();
                                         if line.trim_end().ends_with('{') || line.trim_end().ends_with('(') || line.trim_end().ends_with('[') {
                                             indent.push_str(Self::CODE_INDENT);
                                         }
                                         editor.insert_text(&format!("\n{indent}"));
                                         edited = true;
                                     }
                                     Key::Named(NamedKey::Tab) if event.shift => {
                                         // Dedent the current line by one level, or what it has.
                                         let line_start = get_line_start(&editor.buffer, editor.cursor_idx);
                                         let leading = editor.buffer.chars().skip(line_start).take_while(|c| *c == ' ').count().min(Self::CODE_INDENT.len());
                                         if leading > 0 {
                                             let chars: Vec<char> = editor.buffer.chars().collect();
                                             editor.buffer = chars[..line_start].iter().chain(&chars[line_start + leading..]).collect();
                                             editor.cursor_idx = editor.cursor_idx.saturating_sub(leading).max(line_start);
                                             editor.clear_selection();
                                             edited = true;
                                         }
                                     }
                                     Key::Named(NamedKey::Tab) => {
                                         editor.insert_text(Self::CODE_INDENT);
                                         edited = true;
                                     }
                                     Key::Named(NamedKey::Escape) => {
                                         apply = true;
                                         should_unfocus = true;
                                     }
                                     Key::Named(NamedKey::ArrowLeft) => {
                                         editor.move_cursor_left(shift);
                                     }
                                     Key::Named(NamedKey::ArrowRight) => {
                                         editor.move_cursor_right(shift);
                                     }
                                     Key::Named(NamedKey::ArrowUp) => move_vertical(&mut editor, -1),
                                     Key::Named(NamedKey::ArrowDown) => move_vertical(&mut editor, 1),
                                     Key::Named(NamedKey::Home) => {
                                         if shift && editor.select_anchor.is_none() {
                                             editor.select_anchor = Some(editor.cursor_idx);
                                         } else if !shift {
                                             editor.clear_selection();
                                         }
                                         editor.cursor_idx = get_line_start(&editor.buffer, editor.cursor_idx);
                                     }
                                     Key::Named(NamedKey::End) => {
                                         if shift && editor.select_anchor.is_none() {
                                             editor.select_anchor = Some(editor.cursor_idx);
                                         } else if !shift {
                                             editor.clear_selection();
                                         }
                                         editor.cursor_idx = get_line_end(&editor.buffer, editor.cursor_idx);
                                     }
                                     Key::Character(s) => {
                                         if event.ctrl {
                                             match s.to_lowercase().as_str() {
                                                 "f" => {
                                                     editor.move_cursor_right(false);
                                                 }
                                                 "b" => {
                                                     editor.move_cursor_left(false);
                                                 }
                                                 "p" => move_vertical(&mut editor, -1),
                                                 "n" => move_vertical(&mut editor, 1),
                                                 "a" if event.shift => {
                                                     editor.select_all();
                                                 }
                                                 "a" => {
                                                     editor.clear_selection();
                                                     editor.cursor_idx = get_line_start(&editor.buffer, editor.cursor_idx);
                                                 }
                                                 "e" => {
                                                     editor.clear_selection();
                                                     editor.cursor_idx = get_line_end(&editor.buffer, editor.cursor_idx);
                                                 }
                                                 "d" => {
                                                     edited = editor.delete_forwards();
                                                 }
                                                 "h" => {
                                                     edited = editor.delete_backwards();
                                                 }
                                                 "k" => {
                                                     let current_idx = editor.cursor_idx;
                                                     let end_idx = get_line_end(&editor.buffer, current_idx);
                                                     let chars: Vec<char> = editor.buffer.chars().collect();
                                                     if current_idx < chars.len() {
                                                         let delete_end = if chars[current_idx] == '\n' { current_idx + 1 } else { end_idx };
                                                         editor.buffer = chars[..current_idx].iter().chain(&chars[delete_end..]).collect();
                                                         editor.clear_selection();
                                                         edited = true;
                                                     }
                                                 }
                                                 // The clipboard and history chords are the
                                                 // context actions, so the chord, the runner's
                                                 // routing and the menu row do one thing.
                                                 "c" | "x" | "v" | "z" => {
                                                     let action = match (s.to_lowercase().as_str(), event.shift) {
                                                         ("c", _) => crate::widget::ContextAction::Copy,
                                                         ("x", _) => crate::widget::ContextAction::Cut,
                                                         ("v", _) => crate::widget::ContextAction::Paste,
                                                         ("z", true) => crate::widget::ContextAction::Redo,
                                                         _ => crate::widget::ContextAction::Undo,
                                                     };
                                                     apply_code_action(&mut editor, &mut self.code_history, action);
                                                 }
                                                 _ => {
                                                     handled = false;
                                                 }
                                             }
                                         } else {
                                             editor.insert_text(s);
                                             edited = true;
                                         }
                                     }
                                     _ => {
                                         handled = false;
                                     }
                                 }
                                 if edited {
                                     // Typing runs coalesce into one undo step; anything
                                     // structural (a newline, a paste, a deletion of a
                                     // selection) starts a new one.
                                     let plain_char = matches!(&event.logical_key, Key::Character(c) if !event.ctrl && c.chars().count() == 1);
                                     if plain_char {
                                         self.code_history.record_grouped(before, 1);
                                     } else {
                                         self.code_history.record(before);
                                     }
                                 }
                                 if apply {
                                     p.1 = editor.buffer.clone();
                                 }
                                 if should_unfocus {
                                     self.focused_param = None;
                                     self.code_editor = None;
                                     self.code_history.clear();
                                 } else {
                                     self.code_editor = Some(editor);
                                 }
                                 if handled {
                                     return true;
                                 }
                             }
                         } else if is_text_row(&p.2) {
                             if let Some(d) = &mut self.choices[idx] {
                                 if d.open && d.keyboard_input(event, ui) {
                                     if d.take_change() {
                                         if let Some(val) = d.get_value_string() {
                                             if let Some(tb) = &mut self.texts[idx] {
                                                 tb.text = val.clone();
                                                 tb.edit_buffer = val.clone();
                                             }
                                             p.1 = val;
                                         }
                                     }
                                     return true;
                                 }
                             }
                             if let Some(tb) = &mut self.texts[idx] {
                                 if tb.keyboard_input(event, ui) {
                                     if !tb.editing {
                                         p.1 = tb.text.clone();
                                         self.focused_param = None;
                                     } else {
                                         p.1 = tb.edit_buffer.clone();
                                     }
                                     return true;
                                 }
                             }
                         } else if p.2.starts_with("choice") {
                             if let Some(d) = &mut self.choices[idx] {
                                 if d.keyboard_input(event, ui) {
                                     if !d.open {
                                         if let Some(val) = d.get_value_string() {
                                             p.1 = val;
                                         }
                                         self.focused_param = None;
                                     }
                                     return true;
                                 }
                             }
                         } else if p.2.starts_with("spinbox") {
                             if let Some(sb) = &mut self.spinboxes[idx] {
                                 if sb.keyboard_input(event, ui) {
                                     if !sb.editing {
                                         p.1 = sb.value.to_string();
                                         self.focused_param = None;
                                     } else {
                                         p.1 = sb.edit_buffer.clone();
                                     }
                                     return true;
                                 }
                             }
                         } else if p.2.starts_with("slider") {
                             if let Some(s) = &mut self.sliders[idx] {
                                 if s.keyboard_input(event, ui) {
                                     let new_val = s.get_scaled_value();
                                     p.1 = format!("{:.*}", slider_decimals(&p.2), new_val);
                                     if !s.editing {
                                         self.focused_param = None;
                                     }
                                     return true;
                                 }
                             }
                         } else if p.2.starts_with("color") || p.2 == "rgb" || p.2 == "rgba" {
                             if let Some(c) = &mut self.colors[idx] {
                                 if c.keyboard_input(event, ui) {
                                     if let Some(val) = c.get_value_string() {
                                         p.1 = val;
                                     }
                                     if !c.editing {
                                         self.focused_param = None;
                                     }
                                     return true;
                                 }
                             }
                         } else if is_vec_row(&p.2) {
                             if let Some(f) = &mut self.float3s[idx] {
                                 if f.keyboard_input(event, ui) {
                                     p.1 = f.value_string();
                                     if f.editing_idx().is_none() {
                                         self.focused_param = None;
                                     }
                                     return true;
                                 }
                             }
                         }
                     }
                 }
                 false
             }
             Event::MouseWheel { delta, x: px, y: py, .. } => {
                 if !self.visible {
                     return false;
                 }
                 let (px, py) = (*px, *py);
                 let Some(ui) = ectx.ui.as_deref_mut() else {
                     return false;
                 };
                 let mut changed = false;
                 // A value row that took the wheel (slider/float3/spinbox),
                 // whether or not its 2-decimal string ticked over. Gating the
                 // pane's viewport-scroll fallback on the STRING (`changed`)
                 // let every sub-tick trackpad event scroll the pane instead —
                 // a slider-vs-pane tug-of-war that shifted the rows under the
                 // pointer mid-adjust.
                 let mut wheel_taken = false;
                 // Gesture ownership. A gesture the PANE acquired — its first
                 // event fell on no control and scrolled the rows — stays the
                 // pane's until the gesture ends (`scroll_gesture_new`), however
                 // the rows travel under the pointer meanwhile. Without this a
                 // list scroll ran until a slider's halo or a spinbox row slid
                 // under the pointer, which then took every remaining event of
                 // the same gesture and adjusted a value the user never aimed
                 // at (the Alt+D settings tab, 2026-09-20). A gesture that
                 // began ON a control is that control's, as before, and one
                 // nobody claimed (dead space, a control at its limit) is still
                 // open to spatial acquisition — the band slider's feel.
                 let pane_owns = !ui.scroll_gesture_new && ui.scroll_initiate_widget_id == Some(self_id);
                 // A trackpad gesture is the PANE's, from anywhere — a
                 // two-finger swipe is a scroll everywhere on the desktop, and
                 // a pane that is mostly controls (the Alt+D Settings list)
                 // was otherwise scrollable only from a label. A wheel notch
                 // still adjusts the control under the pointer. Unconditional
                 // since 2026-09-21: the first cut kept hover-adjust for finger
                 // gestures in a pane whose content fits, which made the main
                 // params pane feel different from the Settings list depending
                 // on how many parameters the node had. Finger-end frames (no
                 // delta) take the same path so the pane's coast starts.
                 let finger = matches!(delta, MouseScrollDelta::PixelDelta(_))
                     && matches!(
                         crate::widget::scroll_motion::current_scroll_phase(),
                         crate::widget::ScrollPhase::Finger | crate::widget::ScrollPhase::FingerEnd
                     );
                 let rects = self.get_param_rects();
                 // The exception to the finger rule: a VALUE control takes the
                 // gesture that BEGINS on it, trackpad included, and keeps it
                 // until the gesture ends — a spinbox by its row, a slider
                 // and each row of a float3 by the band's own halo
                 // (`Slider::scroll_hit`), the same zones a wheel notch
                 // acquires by. A two-finger scroll is aimed like a wheel:
                 // over a band it is the value being turned, anywhere else
                 // (the label column, the gaps, a toggle, a section header)
                 // the pane being scrolled. Spinboxes first (2026-09-28,
                 // earlier the same day), sliders and float3 rows after: the
                 // slider's wheel arm was written for trackpad streams all
                 // along, and the pane's rule kept every one of them from
                 // reaching it. A gesture the pane or another control
                 // acquired never lands on a control sliding under the
                 // pointer — that is the leak the latch exists to stop — so
                 // the LATCHED control is asked first, and only a gesture
                 // nobody owns is open to the control under the pointer.
                 let owner = {
                     let latched_to = |id| !ui.scroll_gesture_new && ui.scroll_initiate_widget_id == Some(id);
                     let in_row = |r: (f32, f32, f32, f32)| {
                         py >= r.1 && py <= r.1 + r.3 && px >= self.rect.x && px <= self.rect.x + self.rect.width
                     };
                     let n = self.display_params.len();
                     let latched = (0..n).find(|&i| {
                         self.spinboxes[i].as_ref().is_some_and(|sb| latched_to(sb.base().id()))
                             || self.sliders[i].as_ref().is_some_and(|sl| latched_to(sl.base().id()))
                             || self.float3s[i].as_ref().is_some_and(|f| f.wheel_latched(ui))
                     });
                     // Under the pointer: the NEAREST control whose zone
                     // holds it, by the distance to the band's (or the
                     // spinbox row's) centre line. A band's halo reaches
                     // past the band by more than the gap between rows, so
                     // two neighbours' zones hold any point between them,
                     // and the first in row order is the wrong answer for
                     // the lower half of that gap.
                     latched.or_else(|| {
                         if pane_owns {
                             return None;
                         }
                         (0..n)
                             .filter_map(|i| {
                                 if rects[i].3 <= 0.0 {
                                     return None;
                                 }
                                 if self.spinboxes[i].is_some() {
                                     let r = rects[i];
                                     return in_row(r).then(|| (i, (py - (r.1 + r.3 * 0.5)).abs()));
                                 }
                                 if let Some(sl) = self.sliders[i].as_ref() {
                                     let (sx, sy, sw, sh) = sl.rect();
                                     let ty = sl.label_strip();
                                     let band = Rect { x: sx, y: sy + ty, width: sw, height: sh - ty };
                                     return sl
                                         .inner()
                                         .scroll_hit(band, px, py)
                                         .then(|| (i, (py - (band.y + band.height * 0.5)).abs()));
                                 }
                                 // A float3's bands, and its trackball when it has one.
                                 self.float3s[i].as_ref().and_then(|f| f.wheel_zone(px, py)).map(|d| (i, d))
                             })
                             .min_by(|a, b| a.1.total_cmp(&b.1))
                             .map(|(i, _)| i)
                     })
                 };
                 let pane_takes = pane_owns || (finger && owner.is_none());
                 for (i, p) in self.display_params.iter_mut().enumerate() {
                     if pane_takes {
                         break;
                     }
                     // A gesture a control owns is nobody else's: the pointer
                     // may have drifted onto another band's halo since it began.
                     if owner.is_some() && owner != Some(i) {
                         continue;
                     }
                     if p.2.starts_with("slider") {
                         // The capture zone is the slider's own shape halo
                         // (`Slider::scroll_hit` — the band plus the traveling
                         // swell, inset), so scrolls off the shape fall through
                         // to the pane's viewport scroll below.
                         // `owner` made the zone test: this slider is latched
                         // (mid-gesture the slider that acquired the scroll
                         // keeps it — its halo travels away from the pointer
                         // as the value moves), or its band is the nearest
                         // whose halo holds the pointer.
                         let in_zone = owner == Some(i);
                         if in_zone {
                             if let Some(s) = &mut self.sliders[i] {
                                 let was_scroll = s.scroll_enabled;
                                 s.set_scroll(true);
                                 // Ungated: the in_zone halo above already gated
                                 // spatially, and the adapter's rect gate would
                                 // clip the halo's fringe outside the row rect.
                                 if s.mouse_wheel_ungated(delta, px, py, ui) {
                                     wheel_taken = true;
                                     let new_val = s.get_scaled_value();
                                     let old_val = &p.1;
                                     let new_val_str = format!("{:.*}", slider_decimals(&p.2), new_val);
                                     if *old_val != new_val_str {
                                         p.1 = new_val_str;
                                         changed = true;
                                     }
                                 }
                                 s.set_scroll(was_scroll);
                             }
                         }
                     } else if is_vec_row(&p.2) {
                         if owner == Some(i) {
                             // The group's rows apply the slider-row contract
                             // themselves (band halo / gesture latch, else the
                             // row strip; ungated forward).
                             if let Some(f) = &mut self.float3s[i] {
                                 if f.wheel(delta, px, py, ui) {
                                     wheel_taken = true;
                                     let new_val_str = f.value_string();
                                     if p.1 != new_val_str {
                                         p.1 = new_val_str;
                                         changed = true;
                                     }
                                 }
                             }
                         }
                     } else if p.2.starts_with("spinbox")
                         && owner == Some(i) {
                             if let Some(sb) = &mut self.spinboxes[i] {
                                 // The widget's own wheel arm: one step per
                                 // notch, fractions carried between events.
                                 // Ungated — `owner` already tested the
                                 // row, and a latched gesture may have
                                 // drifted off it.
                                 wheel_taken = true;
                                 ui.scroll_initiate_widget_id = Some(sb.base().id());
                                 sb.mouse_wheel_ungated(delta, px, py, ui);
                                 let new_val_str = sb.value.to_string();
                                 if p.1 != new_val_str {
                                     p.1 = new_val_str;
                                     changed = true;
                                 }
                             }
                         }
                 }
 
                 // The legacy tail's `self.hit_test(px, py, ctx)`: occlusion via the adapter's
                 // address, then rect-or-popover containment.
                 let mut swallowed = changed || wheel_taken;
                 if !ui.is_coordinate_covered(self_id, px, py) {
                     let in_rect = px >= self.rect.x
                         && px <= self.rect.x + self.rect.width
                         && py >= self.rect.y
                         && py <= self.rect.y + self.rect.height;
                     let in_popover = self.own_popover_rect().is_some_and(|(rx, ry, rw, rh)| {
                         px >= rx && px <= rx + rw && py >= ry && py <= ry + rh
                     });
                     if in_rect || in_popover {
                         if !changed && !wheel_taken {
                             if crate::scroll_debug() {
                                 eprintln!("[scroll] params: PANE-SCROLL fallback at ({px:.0},{py:.0})");
                             }
                             // The pane takes the gesture (see `pane_owns`).
                             ui.scroll_initiate_widget_id = Some(self_id);
                             let max_scroll = (self.content_h - self.rect.height).max(0.0);
                             self.scroll_motion.reconcile(0.0, self.scroll_y);
                             let moved = self.scroll_motion.apply(
                                 delta,
                                 (crate::widget::LINE_PX, crate::widget::LINE_PX),
                                 crate::widget::Bounds::max(0.0),
                                 crate::widget::Bounds::max(max_scroll),
                             );
                             self.scroll_y = self.scroll_motion.y.pos();
                             if moved {
                                 self.update_slider_rects();
                                 self.activity.bump();
                                 self.recompute_scrollbar_raised();
                                 self.rehover_after_scroll(ui);
                             }
                         }
                         // An opaque pane swallows EVERY wheel over it, whether
                         // anything moved or not: returning false would hand the
                         // event to whatever lies BEHIND the plate — the designer
                         // routes unhandled wheels to the 3D viewport, whose rect
                         // is the whole window in the floating layout, so a
                         // near-miss on a slider would orbit the camera through
                         // the pane.
                         swallowed = true;
                     }
                 }
 
                 swallowed
             }
             _ => false,
         }
     }
 }
 
 /// Display precision for a slider row from the type string's optional 4th
 /// segment (`slider:min:max:decimals`); 2 when absent — the pane-wide
 /// historical default.
 fn slider_decimals(ptype: &str) -> usize {
     ptype.split(':').nth(3).and_then(|s| s.parse().ok()).unwrap_or(2)
 }
 
 /// Whether a row of type `t` is a vector of sliders: `float2`, `float3` or
 /// `float4`, each `floatN:lo:hi` — the one [`Float3`] group with that many
 /// rows ([`Float3::set_components`]).
 fn is_vec_row(t: &str) -> bool {
     t.starts_with("float2") || t.starts_with("float3") || t.starts_with("float4")
 }
 
 /// A SEPARATOR row: a hairline between two runs of rows, a pixel tall with
 /// the row gap either side, that nothing focuses, hovers or edits — what a
 /// host puts between groups of parameters that are about different things.
 /// Its key and value mean nothing; a host writing rows back skips it.
 pub const SEPARATOR: &str = "separator";
 
 /// Whether a slider or vector row's range is SOFT: a `soft` segment
 /// anywhere after the range (`slider:lo:hi:dec:soft`,
 /// `float3:lo:hi:trackball:soft`). A value typed past an end widens the
 /// row's range rather than being clamped to it (`Slider::set_soft`); the
 /// host is expected to choose the range around the value.
 fn is_soft_row(t: &str) -> bool {
     t.split(':').skip(3).any(|s| s == "soft")
 }
 
 /// How many rows a vector row has: the digit after `float`.
 fn vec_row_n(t: &str) -> usize {
     t.get(5..6).and_then(|d| d.parse().ok()).unwrap_or(3)
 }
 
 fn parse_slider_range(ptype: &str) -> (f32, f32) {
     if ptype.starts_with("slider:") || (is_vec_row(ptype) && ptype.contains(':')) {
         let parts: Vec<&str> = ptype.split(':').collect();
         if parts.len() >= 3 {
             if let (Ok(min), Ok(max)) = (parts[1].parse::<f32>(), parts[2].parse::<f32>()) {
                 return (min, max);
             }
         }
     }
     (0.0, 2.0)
 }
 
 /// `text` whole if it measures within `avail` px, else its longest head
 /// with "..." that does.
 fn fit_tail(text: &str, avail: f32, family: &str, size: f32) -> String {
     use crate::widget::display::{measure_text_width, truncate_tail};
     let fits = |t: &str| measure_text_width(t, family, size) <= avail;
     if fits(text) {
         return text.to_string();
     }
     (0..text.chars().count())
         .rev()
         .map(|n| truncate_tail(text, n))
         .find(|t| fits(t))
         .unwrap_or_default()
 }
 
 fn parse_hex_to_rgb(s: &str) -> Option<[u8; 3]> {
     crate::color::parse_hex_bytes(s).map(|[r, g, b, _]| [r, g, b])
 }
 
 fn parse_hex_to_rgba(s: &str) -> Option<[u8; 4]> {
     crate::color::parse_hex_bytes(s)
 }
 
 fn parse_spinbox_range(ptype: &str) -> (i32, i32, i32) {
     if ptype.starts_with("spinbox:") {
         let parts: Vec<&str> = ptype.split(':').collect();
         if parts.len() >= 4 {
             if let (Ok(min), Ok(max), Ok(step)) = (parts[1].parse::<i32>(), parts[2].parse::<i32>(), parts[3].parse::<i32>()) {
                 return (min, max, step);
             }
         } else if parts.len() == 3 {
             if let (Ok(min), Ok(max)) = (parts[1].parse::<i32>(), parts[2].parse::<i32>()) {
                 return (min, max, 1);
             }
         }
     }
     (0, 10000, 1)
 }
 
 /// A vector row's text as `n` normalized values: each component over the
 /// row's range, mid-range where the text has none.
 fn parse_vec_value(val_str: &str, min: f32, max: f32, n: usize) -> Vec<f32> {
     let mut out = vec![0.5; n];
     let parts: Vec<&str> = val_str
         .split([':', ',', ' '])
         .filter(|s| !s.is_empty())
         .collect();
     for i in 0..n {
         if i < parts.len() {
             if let Ok(v) = parts[i].parse::<f32>() {
                 let range = max - min;
                 if range != 0.0 {
                     out[i] = ((v - min) / range).clamp(0.0, 1.0);
                 } else {
                     out[i] = 0.0;
                 }
             }
         }
     }
     out
 }
 
 impl ParamController for ParametersBg {
     fn node_params(&self) -> Vec<(String, String, String)> {
         self.display_params.clone()
     }
 
     fn set_display_params(&mut self, params: &[(String, String, String)]) {
         let mut layout_changed = self.display_params.len() != params.len();
         if !layout_changed {
             for (p_old, p_new) in self.display_params.iter().zip(params.iter()) {
                 if p_old.0 != p_new.0 || p_old.2 != p_new.2 {
                     layout_changed = true;
                     break;
                 }
             }
         }
 
         if layout_changed {
             self.scroll_y = 0.0;
             self.display_params = params.to_vec();
             self.focused_param = None;
             // Re-read at every rebuild, so a reloaded style takes effect the
             // next time the rows are built, and geometry and widgets agree;
             // then decided against the cached rect's width, as a resize
             // decides it (`apply_label_layout`).
             self.inline_pref = crate::layout::param_labels_inline();
             self.inline_labels = self.decide_inline();
             let inline = self.inline_labels;
             self.sliders = self.display_params.iter().map(|p| {
                 if p.2.starts_with("slider") {
                     let val = p.1.parse::<f32>().unwrap_or(0.0);
                     let (min, max) = parse_slider_range(&p.2);
                     let t = if max - min != 0.0 {
                         ((val - min) / (max - min)).clamp(0.0, 1.0)
                     } else {
                         0.0
                     };
                     let s = Slider::new().with_value(t).with_range(min, max).with_readout(true).with_decimals(slider_decimals(&p.2)).with_soft(is_soft_row(&p.2));
                     Some(if inline { s } else { s.with_label(&p.0) })
                 } else {
                     None
                 }
             }).collect();
             self.float3s = self.display_params.iter().map(|p| {
                 if is_vec_row(&p.2) {
                     let (min, max) = parse_slider_range(&p.2);
                     let n = vec_row_n(&p.2);
                     let mut f = Float3::new().with_components(n).with_range(min, max).with_trackball(Self::has_trackball(&p.2));
                     f.set_soft(is_soft_row(&p.2));
                     f.set_values_n(&parse_vec_value(&p.1, min, max, n));
                     f.set_view(self.trackball_view);
                     Some(if inline { f } else { f.with_label(&p.0) })
                 } else {
                     None
                 }
             }).collect();
             self.spinboxes = self.display_params.iter().map(|p| {
                 if p.2.starts_with("spinbox") {
                     let (min, max, step) = parse_spinbox_range(&p.2);
                     let val = p.1.parse::<i32>().unwrap_or(min);
                     let sb = Spinbox::new(val, min, max, step);
                     Some(if inline { sb } else { sb.with_label(&p.0) })
                 } else {
                     None
                 }
             }).collect();
             self.buttons = self.display_params.iter().map(|p| {
                 if p.2 == "button" {
                     // Left-aligned, like the toggles below: the rows form one column, and
                     // centered labels made each row's text start at a different x.
                     Some(Button::new(0.0, 0.0, 0.0, 0.0).with_label(&p.0).with_left_align(true))
                 } else {
                     None
                 }
             }).collect();
             self.choices = self.display_params.iter().map(|p| {
                 if p.2.starts_with("choice:") {
                     let options_str = p.2.strip_prefix("choice:").unwrap_or("");
                     let options: Vec<String> = options_str.split(',').map(|s| s.to_string()).collect();
                     let selected = options.iter().position(|o| o == &p.1).unwrap_or(0);
                     let d = Dropdown::new(options, selected);
                     Some(if inline { d } else { d.with_label(&p.0) })
                 } else if p.2.starts_with("textpick:") {
                     // The text row's completion picker: a menu-button Dropdown
                     // (fixed glyph, re-fires on repeat picks) beside the box.
                     let options: Vec<String> = p.2.strip_prefix("textpick:").unwrap_or("")
                         .split(',')
                         .filter(|s| !s.is_empty())
                         .map(|s| s.to_string())
                         .collect();
                     if options.is_empty() {
                         None
                     } else {
                         // A raised face: the picker reads as a BUTTON sitting
                         // in the box's recess, not a bare glyph beside it.
                         Some(
                             Dropdown::new(options, 0)
                                 .with_custom_display_text("")
                                 .with_raised(true),
                         )
                     }
                 } else {
                     None
                 }
             }).collect();
             self.texts = self.display_params.iter().map(|p| {
                 if is_text_row(&p.2) {
                     let tb = TextBox::new(p.1.clone());
                     Some(if inline { tb } else { tb.with_label(&p.0) })
                 } else {
                     None
                 }
             }).collect();
             self.toggles = self.display_params.iter().map(|p| {
                 if p.2 == "toggle" || p.2 == "checkbox" {
                     let on = p.1.trim().to_lowercase() == "true";
                     let mut t = Toggle::new().with_label(&p.0).with_left_align(true);
                     t.set_toggled(on);
                     Some(t)
                 } else {
                     None
                 }
             }).collect();
             self.colors = self.display_params.iter().map(|p| {
                 if p.2 == "rgba" {
                     // Alpha-carrying param: the full picker, 8-digit hex.
                     let col = parse_hex_to_rgba(&p.1).unwrap_or([255, 255, 255, 255]);
                     let c = ColorSelector::new_rgba(col);
                     Some(if inline { c } else { c.with_label(&p.0) })
                 } else if p.2.starts_with("color") || p.2 == "rgb" {
                     let col = parse_hex_to_rgb(&p.1).unwrap_or([255, 255, 255]);
                     let c = ColorSelector::new(col);
                     Some(if inline { c } else { c.with_label(&p.0) })
                 } else {
                     None
                 }
             }).collect();
             self.ramps = self.display_params.iter().map(|p| {
                 if p.2 == "ramp" {
                     let mut rp = Ramp::new();
                     rp.inner_mut().set_spec(&p.1);
                     Some(rp)
                 } else {
                     None
                 }
             }).collect();
         } else {
             for (i, p_new) in params.iter().enumerate() {
                 if Some(i) != self.focused_param && Some(i) != self.dragging_param {
                     self.display_params[i].1 = p_new.1.clone();
                     if let Some(ref mut s) = self.sliders[i] {
                         let (min, max) = parse_slider_range(&p_new.2);
                         // Idempotence guard: hosts push params straight back
                         // after every sync, and re-seeding from the 2-decimal
                         // string quantizes away the slider's sub-tick state —
                         // mid-scroll that snaps the value BACKWARD between
                         // wheel events/glide ticks (visible as jitter). Only
                         // re-seed when the incoming string says something the
                         // current value doesn't (a genuinely external change).
                         let cur_str = format!("{:.*}", slider_decimals(&p_new.2), min + s.value * (max - min));
                         if cur_str != p_new.1 {
                             let val = p_new.1.parse::<f32>().unwrap_or(0.0);
                             let t = if max - min != 0.0 {
                                 ((val - min) / (max - min)).clamp(0.0, 1.0)
                             } else {
                                 0.0
                             };
                             s.set_value(t);
                         }
                     } else if let Some(ref mut f) = self.float3s[i] {
                         let (min, max) = parse_slider_range(&p_new.2);
                         // Same round-trip guard as the slider row.
                         let cur_str = f.value_string();
                         if cur_str != p_new.1 {
                             let n = vec_row_n(&p_new.2);
                             if f.components() != n {
                                 f.set_components(n);
                             }
                             f.set_values_n(&parse_vec_value(&p_new.1, min, max, n));
                         }
                     } else if let Some(ref mut sb) = self.spinboxes[i] {
                         if !sb.editing {
                             let (min, _max, _step) = parse_spinbox_range(&p_new.2);
                             let val = p_new.1.parse::<i32>().unwrap_or(min);
                             sb.value = val;
                         }
                     } else if let Some(ref mut d) = self.choices[i] {
                         if !d.open {
                             if let Some(options_str) = p_new.2.strip_prefix("choice:") {
                                 let options: Vec<String> = options_str.split(',').map(|s| s.to_string()).collect();
                                 if d.options != options {
                                     d.options = options.clone();
                                 }
                                 if let Some(idx) = options.iter().position(|o| o == &p_new.1) {
                                     d.selected = idx;
                                 }
                             }
                         }
                     } else if let Some(ref mut tb) = self.texts[i] {
                         if !tb.editing {
                             tb.set_value_string(&p_new.1);
                         }
                     } else if let Some(ref mut t) = self.toggles[i] {
                         let on = p_new.1.trim().to_lowercase() == "true";
                         t.set_toggled(on);
                     } else if let Some(ref mut c) = self.colors[i] {
                         if !c.editing {
                             c.set_value_string(&p_new.1);
                         }
                     } else if let Some(ref mut rp) = self.ramps[i] {
                         if !rp.inner().is_dragging_key {
                             rp.set_value_string(&p_new.1);
                         }
                     }
                 }
             }
         }
         self.refresh_scroll_metrics();
     }
 }
 
 /// One clipboard, selection or history action over a code editor and its
 /// history — the body [`ParametersBg::code_action`] and the editor's own
 /// chords share, free of `self` so a caller holding a row borrow can use it.
 fn apply_code_action(
     editor: &mut TextEditorState,
     history: &mut crate::history::History<TextEditorState>,
     action: crate::widget::ContextAction,
 ) {
     use crate::widget::ContextAction;
     let before = editor.clone();
     let mut edited = false;
     match action {
         ContextAction::Undo => {
             if let Some(prev) = history.undo(editor.clone()) {
                 *editor = prev;
             }
         }
         ContextAction::Redo => {
             if let Some(next) = history.redo(editor.clone()) {
                 *editor = next;
             }
         }
         ContextAction::SelectAll => editor.select_all(),
         ContextAction::Copy => {
             if let Some(text) = editor.selected_text() {
                 crate::widget::clipboard::copy_to_clipboard(&text);
             }
         }
         ContextAction::Cut => {
             if let Some(text) = editor.selected_text() {
                 crate::widget::clipboard::copy_to_clipboard(&text);
                 edited = editor.delete_backwards();
             }
         }
         ContextAction::Paste => {
             if let Some(text) = crate::widget::clipboard::read_from_clipboard() {
                 editor.insert_text(&text);
                 edited = true;
             }
         }
         _ => {}
     }
     if edited {
         history.record(before);
     }
 }
 
 fn get_cursor_line_col(buffer: &str, cursor_idx: usize) -> (usize, usize) {
     let mut cur_line = 0;
     let mut cur_col = 0;
     for (count, c) in buffer.chars().enumerate() {
         if count == cursor_idx {
             return (cur_line, cur_col);
         }
         if c == '\n' {
             cur_line += 1;
             cur_col = 0;
         } else {
             cur_col += 1;
         }
     }
     (cur_line, cur_col)
 }
 
 fn map_2d_to_1d(buffer: &str, line: usize, col: usize) -> usize {
     let mut target_line = line;
     let lines: Vec<Vec<char>> = buffer.split('\n').map(|l| l.chars().collect()).collect();
     if lines.is_empty() {
         return 0;
     }
     if target_line >= lines.len() {
         target_line = lines.len() - 1;
     }
     let mut target_col = col;
     if target_col > lines[target_line].len() {
         target_col = lines[target_line].len();
     }
     let mut index = 0;
     for i in 0..target_line {
         index += lines[i].len() + 1; // +1 for the '\n'
     }
     index += target_col;
     index
 }
 
 fn get_line_start(buffer: &str, cursor_idx: usize) -> usize {
     let (line, _) = get_cursor_line_col(buffer, cursor_idx);
     map_2d_to_1d(buffer, line, 0)
 }
 
 fn get_line_end(buffer: &str, cursor_idx: usize) -> usize {
     let (line, _) = get_cursor_line_col(buffer, cursor_idx);
     let lines: Vec<Vec<char>> = buffer.split('\n').map(|l| l.chars().collect()).collect();
     if lines.is_empty() {
         return 0;
     }
     let line_len = if line < lines.len() {
         lines[line].len()
     } else {
         lines[lines.len() - 1].len()
     };
     map_2d_to_1d(buffer, line, line_len)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::context::UiContext;
 
     fn panel_with(params: &[(&str, &str, &str)]) -> Adapted<ParametersBg> {
         let mut p = ParametersBg::new();
         let params: Vec<(String, String, String)> = params
             .iter()
             .map(|(a, b, c)| (a.to_string(), b.to_string(), c.to_string()))
             .collect();
         ParamController::set_display_params(&mut *p, &params);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 400.0);
         p
     }
 
     /// The textpick text-row variant: a TextBox AND a menu-button Dropdown
     /// share the row — the picker takes a right-edge sliver, its options come
     /// from the type string, and a plain text row builds no picker.
     /// A textpick row's picker centres its arrow, and every other dropdown
     /// row's arrow stands in the same column: the picker is a trigger's
     /// arrow slot (`dropdown::arrow_slot`).
     #[test]
     fn a_pickers_arrow_lines_up_with_a_dropdowns() {
         let p = panel_with(&[
             ("Name", "mass", "textpick:Norm,UV,Pos,Col"),
             ("Type", "Float", "choice:Float,Float3,Int"),
         ]);
         let arrow = |i: usize| {
             let d = p.choices[i].as_ref().unwrap();
             let (x, y, w, h) = d.rect();
             d.inner().arrow_rect(crate::scene::layout::Rect { x, y, width: w, height: h }).x
         };
         assert!((arrow(0) - arrow(1)).abs() < 1e-3, "picker {} vs dropdown {}", arrow(0), arrow(1));
     }
 
     /// The pane draws its controls' glyphs: a dropdown's and a picker's
     /// arrow, a spinbox's minus and plus. The pane paints its rows' chrome
     /// itself and took only their TEXT, so when the symbols became glyphs
     /// (2026-10-05) every control in the pane lost them. Skipped where the
     /// icon set is not checked out (no glyph uploads, nothing to name).
     #[test]
     fn the_pane_draws_its_controls_glyphs() {
         if !std::path::Path::new(&crate::icons_dir()).join("chevron-down.svg").is_file() {
             eprintln!("skipped: no icon set");
             return;
         }
         let p = panel_with(&[
             ("Name", "mass", "textpick:Norm,UV,Pos,Col"),
             ("Type", "Float", "choice:Float,Float3,Int"),
             ("Count", "3", "spinbox:0:10:1"),
         ]);
         let ui = UiContext::new();
         let mut pc = PaintCtx::new();
         let r = Rect { x: 0.0, y: 0.0, width: 300.0, height: 400.0 };
         Paint::paint_ui(&*p, &ui, r, &mut pc);
         let names: Vec<String> = pc
             .finish()
             .items
             .into_iter()
             .filter_map(|item| match item.prim {
                 crate::scene::paint::Prim::Image { image, .. } => crate::icon_source(image).map(|(n, _, _)| n),
                 _ => None,
             })
             .collect();
         let count = |n: &str| names.iter().filter(|m| *m == n).count();
         assert_eq!(count("chevron-down"), 2, "the picker's and the dropdown's arrows: {names:?}");
         assert_eq!(count("minus"), 1, "the spinbox's minus: {names:?}");
         assert_eq!(count("plus"), 1, "the spinbox's plus: {names:?}");
     }
 
     #[test]
     fn textpick_rows_carry_a_picker() {
         let p = panel_with(&[
             ("Attribute Name", "mass", "textpick:Norm,UV,Pos,Col"),
             ("Plain", "x", "text"),
             ("Empty", "y", "textpick:"),
         ]);
         assert!(p.texts[0].is_some(), "textpick keeps its TextBox");
         let d = p.choices[0].as_ref().expect("textpick builds the picker");
         assert_eq!(d.options, ["Norm", "UV", "Pos", "Col"]);
         assert!(d.custom_display_text.is_some(), "menu-button mode");
         assert!(p.choices[1].is_none(), "plain text has no picker");
         assert!(p.texts[2].is_some() && p.choices[2].is_none(), "no options, no picker");
 
         // Layout: the picker is the field's right end — the box stops at
         // the seam, square there, and the picker reaches the field's outer
         // edge on the right, top and bottom, as a dropdown trigger does.
         let (tx, ty, tw, th) = p.texts[0].as_ref().unwrap().rect();
         let (dx, dy, dw, dh) = p.choices[0].as_ref().unwrap().rect();
         // The box ends where the picker begins, at the seam; the picker
         // is a wall wider than PICK_W, the wall being the lip its face
         // rises out of at the seam, so the face is PICK_W wide.
         let label = p.texts[0].as_ref().unwrap().label_strip();
         let depth = crate::layout::bevel_width().min((th - label) * 0.2);
         assert!((dw - (PICK_W + depth)).abs() < 1e-3, "the picker is PICK_W and a wall: {dw}");
         assert!((dx - (tx + tw)).abs() < 1e-3, "the picker begins where the box ends: {dx} vs {}", tx + tw);
         assert!(d.center_arrow, "the picker's arrow stands in its middle, its padding even");
         assert_eq!((dy, dy + dh), (ty + label, ty + th), "the picker spans the field's band, edge to edge");
         assert!(p.texts[0].as_ref().unwrap().inner().joined_right, "the box is square at the seam");
         assert!(!p.texts[1].as_ref().unwrap().inner().joined_right, "a plain text row is not");
         // ONE field: one outline round the box and the picker, its seam at
         // the picker — not a well and a trough each turning its own corner
         // there.
         let rr = crate::layout::textbox_corner_radius();
         let fields = p.inner().fields();
         assert_eq!(fields.len(), 1, "{fields:?}");
         let f = fields[0].rect;
         assert_eq!((f.x, f.y, f.x + f.width, f.y + f.height), (tx, dy, dx + dw, dy + dh), "the field spans box and picker");
         assert_eq!(fields[0].radii, (rr, rr, rr, rr), "its own radius at all four corners");
         assert_eq!(fields[0].run_span(), Some((dx, dx + dw)), "the run is the picker, to the field's end");
         assert!(p.inner().reliefs().iter().all(|r| !(r.0 == tx && r.2 == tw)), "nor the box a well of its own");
 
         // Both text variants lay out at the same row height.
         assert_eq!(p.inner().row_height(0), p.inner().row_height(1));
 
         // The menu anchors off the WHOLE field: the popover spans at least
         // the box width and hangs below it, not off the button sliver.
         let anchor = p.choices[0].as_ref().unwrap().popover_anchor.expect("anchor set");
         assert_eq!(anchor.x, tx);
         assert!((anchor.width - (dx + dw - tx)).abs() < 1e-3, "the whole field");
         let d = p.choices[0].as_ref().unwrap();
         let (px_, py_, pw, _ph) = d.popover_geom(crate::scene::layout::Rect {
             x: dx, y: dy, width: dw, height: dh,
         });
         assert_eq!(px_, tx, "menu left-aligns with the box");
         assert!(pw >= tw, "menu at least as wide as the box");
         assert!(py_ >= ty + th - 1.0, "menu hangs below the box");
     }
 
     /// A dropdown trigger's edge is a field's run: its own paint and the
     /// pane's re-emission both draw a field that is all run, so its edge
     /// matches the picker at the end of a text row and the -/+ run of a
     /// spinbox. Never a trough, whose outer half differed.
     #[test]
     fn a_dropdown_trigger_wears_the_runs_edge() {
         use crate::scene::paint::{PaintCtx, Prim};
         if !crate::layout::control_relief() {
             return;
         }
         let p = panel_with(&[("Mode", "b", "choice:a,b,c")]);
         let d = p.choices[0].as_ref().expect("a dropdown");
         let (x, y, w, h) = d.rect();
         let ty = d.label_strip();
         let fields = p.inner().fields();
         assert_eq!(fields.len(), 1, "{fields:?}");
         assert_eq!(fields[0].rect, Rect { x, y: y + ty, width: w, height: h - ty }, "on the trigger's band");
         assert!(!fields[0].has_well(), "all run, no well");
         let mut pc = PaintCtx::new();
         Paint::paint(d.inner(), Rect { x, y: y + ty, width: w, height: h - ty }, &mut pc);
         let prims: Vec<Prim> = pc.finish().items.into_iter().map(|i| i.prim).collect();
         assert!(prims.iter().any(|p| matches!(p, Prim::Field { rect, split, .. } if *split < rect.x - 100.0)), "{prims:?}");
         assert!(!prims.iter().any(|p| matches!(p, Prim::Trough { .. })), "no trough");
     }
 
     #[test]
     fn param_controller_roundtrip_and_row_widgets() {
         let p = panel_with(&[
             ("Size", "1.00", "slider:0:2"),
             ("Mode", "b", "choice:a,b,c"),
             ("On", "true", "checkbox"),
         ]);
         assert_eq!(ParamController::node_params(&*p).len(), 3);
         assert!(p.sliders[0].is_some() && p.choices[1].is_some() && p.toggles[2].is_some());
         // Rows were laid out from the cached rect: the slider's control rect
         // is the row less the label column when the labels are inline (the
         // default), the whole row when they are stacked.
         let lw = p.inner().label_col_w();
         if p.inner().inline_labels {
             assert!(lw > 0.0, "inline labels reserve a column");
             let labels = p.inner().own_text_labels();
             let size = labels.iter().find(|l| l.text == "Size").expect("the pane draws the inline label");
             assert_eq!(size.x, ROW_X_INSET, "the label sits at the row's left edge");
         } else {
             assert_eq!(lw, 0.0);
         }
         let (sx, _, sw, _) = p.sliders[0].as_ref().unwrap().rect();
         assert_eq!(
             (sx, sw),
             (ROW_X_INSET + lw, 300.0 - 2.0 * ROW_X_INSET - lw),
             "control rect derives from the assigned rect and the label column"
         );
     }
 
     /// A pane too narrow for a label column stacks its labels above the
     /// controls, and takes them back into the column when it widens: the
     /// controls are relabelled, the column goes, the rows grow by the label
     /// strip. The threshold is the control's width, not the pane's.
     #[test]
     fn a_narrow_pane_stacks_its_labels_and_a_wide_one_puts_them_back() {
         let mut p = panel_with(&[("Size", "1.00", "slider:0:2"), ("Mode", "b", "choice:a,b,c"), ("On", "true", "checkbox")]);
         if !p.inner().inline_pref {
             return; // a stacked preference has nothing to re-flow
         }
         let strip = crate::layout::control_label_strip();
         // The COLUMN label sits exactly at the row's left edge; a control's
         // own detached label is inset from the control's edge, so the two
         // are told apart by x.
         let labels_in_column = |p: &Adapted<ParametersBg>| {
             p.inner().own_text_labels().iter().any(|l| l.text == "Size" && l.x == ROW_X_INSET)
         };
 
         // 300 wide: inline. The slider carries no label; the pane draws it.
         assert!(p.inner().inline_labels);
         let col = p.inner().label_col_w();
         assert!(col > 0.0);
         assert!(labels_in_column(&p));
         assert!(p.sliders[0].as_ref().unwrap().base().label.is_none());
         let (_, _, sw_inline, _) = p.sliders[0].as_ref().unwrap().rect();
         let h_inline = p.get_param_rects()[0].3;
         // The threshold is the slider's TRACK: its rect less the readout.
         let chrome = crate::widget::input::slider::Slider::readout_chrome();
         assert!(sw_inline - chrome >= ParametersBg::MIN_INLINE_TRACK_W, "the fixture starts with room: {sw_inline}");
 
         // Narrow it until the TRACK would fall under the minimum: stacked,
         // though the control's rect is still well over it.
         let narrow = 2.0 * ROW_X_INSET + col + chrome + ParametersBg::MIN_INLINE_TRACK_W - 1.0;
         WidgetHost::set_rect(&mut p, 0.0, 0.0, narrow, 400.0);
         assert!(!p.inner().inline_labels, "under the minimum the labels stack");
         assert_eq!(p.inner().label_col_w(), 0.0, "no column");
         assert!(!labels_in_column(&p), "the pane draws no column label");
         assert_eq!(p.sliders[0].as_ref().unwrap().base().label.as_deref(), Some("Size"), "the slider carries its label");
         assert_eq!(p.choices[1].as_ref().unwrap().base().label.as_deref(), Some("Mode"));
         let (sx, _, sw, _) = p.sliders[0].as_ref().unwrap().rect();
         assert_eq!((sx, sw), (ROW_X_INSET, narrow - 2.0 * ROW_X_INSET), "the control spans the row");
         // The row grows for the label band — by the strip, less the floor
         // the inline row's height table clamps at.
         let h_stacked = p.get_param_rects()[0].3;
         assert!(h_stacked > h_inline && h_stacked <= h_inline + strip, "inline {h_inline}, stacked {h_stacked}, strip {strip}");
         // The toggle carried its label all along.
         assert_eq!(p.toggles[2].as_ref().unwrap().base().label.as_deref(), Some("On"));
 
         // One pixel wider than the minimum: inline again, labels off the controls.
         WidgetHost::set_rect(&mut p, 0.0, 0.0, narrow + 1.0, 400.0);
         assert!(p.inner().inline_labels, "at the minimum the column comes back");
         assert!(labels_in_column(&p));
         assert!(p.sliders[0].as_ref().unwrap().base().label.is_none(), "the label left the slider");
         assert!(p.choices[1].as_ref().unwrap().base().label.is_none());
         assert_eq!(p.get_param_rects()[0].3, h_inline);
         let (sx, _, sw, _) = p.sliders[0].as_ref().unwrap().rect();
         assert_eq!((sx, sw), (ROW_X_INSET + col, narrow + 1.0 - 2.0 * ROW_X_INSET - col));
 
         // A rebuild under a narrow rect builds stacked from the start.
         let rows: Vec<(String, String, String)> = vec![("Size".into(), "1.00".into(), "slider:0:2".into()), ("Width".into(), "2.00".into(), "slider:0:2".into())];
         WidgetHost::set_rect(&mut p, 0.0, 0.0, narrow, 400.0);
         ParamController::set_display_params(&mut *p, &rows);
         assert!(!p.inner().inline_labels);
         assert_eq!(p.sliders[1].as_ref().unwrap().base().label.as_deref(), Some("Width"));
 
         // The shortest track decides. At one width: a pane of controls with
         // no track keeps its column, a slider's readout costs it the
         // column, and a float3's axis letters cost it sooner still.
         let at = |rows: &[(&str, &str, &str)], width: f32| {
             let mut p = panel_with(rows);
             WidgetHost::set_rect(&mut p, 0.0, 0.0, width, 400.0);
             p.inner().inline_labels
         };
         let spin = [("Size", "3", "spinbox:0:10")];
         let slider = [("Size", "1.00", "slider:0:2")];
         let float3 = [("Size", "0:0:0", "float3:-1:1")];
         let base = 2.0 * ROW_X_INSET + col + ParametersBg::MIN_INLINE_TRACK_W;
         assert!(at(&spin, base), "a spinbox is measured whole");
         assert!(!at(&slider, base), "a slider at that width has a track {chrome} short");
         assert!(at(&slider, base + chrome));
         assert!(!at(&float3, base + chrome), "a float3 spends an axis column too");
         assert!(at(&float3, base + chrome + crate::widget::display::float3::AXIS_W));
 
         // Collapsing the section that holds the only slider re-decides: the
         // rows left visible have no track, and the column comes back.
         let mut p = panel_with(&[("Count", "3", "spinbox:0:10"), ("Shape", "", "section"), ("Size", "1.00", "slider:0:2")]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, base, 400.0);
         assert!(!p.inner().inline_labels, "the slider's track is the shortest");
         p.inner_mut().set_section_collapsed("Shape", true);
         assert!(p.inner().inline_labels, "with the slider hidden the spinbox decides");
     }
 
     /// A `separator` row is a hairline a pixel tall between its neighbours,
     /// the row gap either side, drawn as a rule and never hovered.
     #[test]
     fn a_separator_row_is_a_rule_between_rows() {
         let p = panel_with(&[("Input", "a", "text"), ("", "", SEPARATOR), ("Size", "1.00", "slider:0:2")]);
         let mut p = p;
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 400.0, 400.0);
         let rects = p.get_param_rects();
         assert_eq!(rects[1].3, 1.0, "a pixel tall");
         assert!((rects[1].1 - (rects[0].1 + rects[0].3 + ROW_GAP)).abs() < 1e-3, "the row gap above");
         assert!((rects[2].1 - (rects[1].1 + 1.0 + ROW_GAP)).abs() < 1e-3, "and below");
         let rule = p.plain_quads().into_iter().find(|q| q.3 == 1.0 && (q.1 - rects[1].1).abs() < 1e-3);
         assert!(rule.is_some_and(|q| q.2 > 300.0), "a rule across the row");
         assert_eq!(p.hoverable_row_at(rects[1].0 + 50.0, rects[1].1 + 0.5), None, "nothing to hover");
         let near = |l: &TextLabel| (l.y - rects[1].1).abs() < 6.0;
         assert!(!p.own_text_labels().iter().any(near), "and no label: a fallback `name: value` once drew ':'");
     }
 
     /// A `soft` slider or float row builds its sliders with a soft range,
     /// and the pane writes back the value the slider holds — past the
     /// row's declared range once a typed value has widened it — rather
     /// than re-reading the slider's fraction over the declared range.
     #[test]
     fn a_soft_row_writes_back_what_its_slider_holds() {
         let mut p = panel_with(&[("V", "1.00", "slider:-10:10:2:soft"), ("W", "1:2", "float2:-10:10:soft"), ("H", "1.00", "slider:-10:10")]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 500.0, 400.0);
         assert!(is_soft_row("slider:-10:10:2:soft") && is_soft_row("float3:-1:1:trackball:soft"));
         assert!(!is_soft_row("slider:-10:10") && !is_soft_row("float3:-1:1:trackball"));
         assert_eq!(slider_decimals("slider:-10:10:2:soft"), 2);
         {
             let s = p.sliders[0].as_mut().unwrap();
             s.set_range(-10.0, 500.0);
             s.set_scaled_value(500.0);
         }
         p.inner_mut().focused_param = Some(0);
         p.inner_mut().commit_and_unfocus();
         assert_eq!(p.display_params[0].1, "500.00");
         assert_eq!(p.display_params[2].1, "1.00", "the hard row is untouched");
     }
 
     /// `float2` and `float4` rows are the float3 group with two or four
     /// rows (X Y, X Y Z W): that many sliders over the row's range, laid out
     /// and sized for that many, read from and written back as that many
     /// components — and no trackball, which a direction of three numbers
     /// is the only thing to have.
     #[test]
     fn float2_and_float4_rows_are_the_group_with_two_or_four_sliders() {
         let mut p = panel_with(&[
             ("Two", "1.00:-2.00", "float2:-10:10"),
             ("Four", "1:2:3:4", "float4:-10:10:trackball"),
             ("Three", "0:0:0", "float3:-10:10"),
         ]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 500.0, 600.0);
         let two = p.float3s[0].as_ref().expect("a float2 row is a group");
         let four = p.float3s[1].as_ref().expect("a float4 row is a group");
         assert_eq!((two.components(), four.components()), (2, 4));
         assert_eq!(two.get_row_rects().len(), 2);
         assert_eq!(four.get_row_rects().len(), 4);
         assert!(!four.has_trackball(), "four numbers have no ball");
         assert_eq!(two.value_string(), "1.00:-2.00");
         assert_eq!(four.value_string(), "1.00:2.00:3.00:4.00");
         assert!(
             Float3::preferred_height_for(false, 4) > Float3::preferred_height_for(false, 3)
                 && Float3::preferred_height_for(false, 3) > Float3::preferred_height_for(false, 2)
         );
         assert_eq!(Float3::preferred_height_for(false, 3), Float3::preferred_height(false));
 
         // A new value for the row reaches the group, and a group whose
         // row changed width takes the new width.
         let rows: Vec<(String, String, String)> = vec![
             ("Two".into(), "3:4".into(), "float2:-10:10".into()),
             ("Four".into(), "5:6:7".into(), "float3:-10:10".into()),
             ("Three".into(), "0:0:0".into(), "float3:-10:10".into()),
         ];
         ParamController::set_display_params(&mut *p, &rows);
         assert_eq!(p.float3s[0].as_ref().unwrap().value_string(), "3.00:4.00");
         let f = p.float3s[1].as_ref().unwrap();
         assert_eq!((f.components(), f.value_string()), (3, "5.00:6.00:7.00".to_string()));
     }
 
     /// A `float3:lo:hi:trackball` row builds its group with the ball, counts
     /// the ball as chrome when the label layout is decided, paints it
     /// through the scene path, and a press-and-drag on it through the
     /// pane's own drag protocol turns the row's value.
     #[test]
     fn a_trackball_row_turns_its_value_through_the_pane() {
         use crate::scene::paint::Prim;
         let mut p = panel_with(&[("Name", "x", "text"), ("Pull", "0.000:0.000:2.000", "float3:-10:10:trackball"), ("Plain", "0:0:0", "float3:-10:10")]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 500.0, 400.0);
         assert!(p.float3s[1].as_ref().unwrap().has_trackball());
         assert!(!p.float3s[2].as_ref().unwrap().has_trackball());
         assert_eq!(
             ParametersBg::control_chrome("float3:-10:10:trackball") - ParametersBg::control_chrome("float3:-10:10"),
             Float3::trackball_chrome(),
             "the ball is chrome: the tracks are what is left of it"
         );
 
         let mut pc = crate::scene::paint::PaintCtx::new();
         p.inner().paint_scene_rows(&mut pc);
         let spheres = pc.finish().items.into_iter().filter(|i| matches!(i.prim, Prim::Sphere { .. })).count();
         assert_eq!(spheres, 1, "one ball, for the one row that asks");
 
         let (cx, cy, r) = p.float3s[1].as_ref().unwrap().ball_circle().unwrap();
         let rect = Rect { x: 0.0, y: 0.0, width: 500.0, height: 400.0 };
         Input::drag_begin(p.inner_mut(), cx, cy, rect);
         assert!(Input::is_dragging(p.inner()), "the pane is dragging the row");
         assert!(Input::drag_update(p.inner_mut(), cx + r * std::f32::consts::FRAC_PI_2, cy, rect));
         Input::drag_end(p.inner_mut());
         let v: Vec<f32> = p.display_params[1].1.split(':').map(|c| c.parse().unwrap()).collect();
         assert!((v[0] - 2.0).abs() < 2e-3 && v[1].abs() < 2e-3 && v[2].abs() < 2e-3, "a quarter turn right: {v:?}");
         assert_eq!(p.display_params[2].1, "0:0:0", "the plain row is untouched");
 
         // The pane's camera reaches every ball it has, and the ones built
         // after it; the same view again changes nothing.
         let camera = [[0.0, 0.0, -1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0]];
         assert!(p.inner_mut().set_trackball_view(camera));
         assert_eq!(p.float3s[1].as_ref().unwrap().view(), camera);
         assert!(!p.inner_mut().set_trackball_view(camera), "unchanged");
         let rebuilt: Vec<(String, String, String)> = vec![("Other".into(), "0.000:0.000:1.000".into(), "float3:-10:10:trackball".into())];
         ParamController::set_display_params(&mut *p, &rebuilt);
         assert_eq!(p.float3s[0].as_ref().unwrap().view(), camera, "a rebuilt row starts from the pane's view");
 
         // A trackpad gesture beginning on the ball rolls it — the pane does
         // not scroll — and one beginning on the label column is the pane's.
         use crate::widget::{scroll_motion::set_scroll_phase, Position, ScrollPhase};
         let rows: Vec<(String, String, String)> = (0..12)
             .map(|i| (format!("P{i}"), "0.000:0.000:2.000".to_string(), "float3:-10:10:trackball".to_string()))
             .collect();
         let mut p = ParametersBg::new();
         ParamController::set_display_params(&mut *p, &rows);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 500.0, 300.0);
         assert!(p.content_h > 300.0, "the pane overflows, so it has somewhere to scroll");
         let (cx, cy, _) = p.float3s[1].as_ref().unwrap().ball_circle().unwrap();
         let mut ctx = UiContext::new();
         ctx.scroll_gesture_new = true;
         set_scroll_phase(ScrollPhase::Finger);
         assert!(p.mouse_wheel(&MouseScrollDelta::PixelDelta(Position { x: 60.0, y: 0.0 }), cx, cy, &mut ctx));
         let v: Vec<f32> = p.display_params[1].1.split(':').map(|c| c.parse().unwrap()).collect();
         assert!(v[0] > 0.4 && v[1].abs() < 2e-3, "rolled right by a notch: {v:?}");
         assert_eq!(ctx.scroll_initiate_widget_id, Some(p.float3s[1].as_ref().unwrap().ball_id()));
         assert_eq!(p.scroll_y, 0.0, "the pane did not scroll");
         assert_eq!(p.display_params[0].1, "0.000:0.000:2.000", "the row above is untouched");
         set_scroll_phase(ScrollPhase::Wheel);
     }
 
     #[test]
     fn ramp_row_builds_from_spec_and_edits_serialize_back() {
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[("Bevel Profile", "smooth;0.000:0.000,1.000:1.000", "ramp")]);
         let rp = p.ramps[0].as_ref().expect("ramp row builds a Ramp");
         assert_eq!(rp.inner().keys.len(), 2);
         assert!(rp.inner().smooth());
 
         // A press inside the curve area adds a key, and the row value carries
         // the re-serialized spec (what hosts poll and persist).
         let (rx, ry, rw, _) = rp.rect();
         p.mouse_input(MouseButton::Left, ElementState::Pressed, rx + rw * 0.5, ry + 40.0, &mut ctx);
         assert_eq!(p.ramps[0].as_ref().unwrap().inner().keys.len(), 3);
         let val = &ParamController::node_params(&*p)[0].1;
         assert_eq!(val.split(',').count(), 3, "spec re-serialized: {val}");
         assert!(val.starts_with("smooth;"));
     }
 
     #[test]
     fn toggle_click_commits_value_and_unfocus_commits_editor() {
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[("On", "false", "checkbox")]);
         let (cx, cy, _, ch) = p.toggles[0].as_ref().unwrap().rect();
         // Click the toggle row (presses are ungated for this widget; the panel consumes
         // every left press, so the return is true either way — assert the value flip).
         p.mouse_input(MouseButton::Left, ElementState::Pressed, cx + 6.0, cy + ch / 2.0, &mut ctx);
         p.mouse_input(MouseButton::Left, ElementState::Released, cx + 6.0, cy + ch / 2.0, &mut ctx);
         assert_eq!(ParamController::node_params(&*p)[0].1, "true");
 
         // Code editor: focus it via a click, type, then unfocus commits the buffer.
         let mut p = panel_with(&[("Src", "let x = 1;", "code")]);
         let rects = p.get_param_rects();
         let r = rects[0];
         p.mouse_input(MouseButton::Left, ElementState::Pressed, r.0 + 20.0, r.1 + 30.0, &mut ctx);
         assert_eq!(p.focused_param, Some(0), "code row focused");
         assert!(p.code_editor.is_some());
         p.code_editor.as_mut().unwrap().insert_text("y");
         WidgetHost::unfocus(&mut p);
         assert_eq!(p.focused_param, None);
         assert!(p.code_editor.is_none());
         assert!(ParamController::node_params(&*p)[0].1.contains('y'), "editor buffer committed on unfocus");
     }
 
     fn key(k: Key, ctrl: bool, shift: bool) -> Event {
         Event::KeyInput(crate::widget::KeyEvent { state: ElementState::Pressed, logical_key: k, text: None, repeat: false, ctrl, shift, alt: false })
     }
 
     fn chr(c: &str) -> Event {
         key(Key::Character(c.into()), false, false)
     }
 
     fn ctrl(c: &str) -> Event {
         key(Key::Character(c.into()), true, false)
     }
 
     fn named(k: NamedKey) -> Event {
         key(Key::Named(k), false, false)
     }
 
     fn shift_named(k: NamedKey) -> Event {
         key(Key::Named(k), false, true)
     }
 
     /// A code row focused by a click at its first character.
     fn code_panel(src: &str) -> (Adapted<ParametersBg>, UiContext) {
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[("Src", src, "code")]);
         let r = p.get_param_rects()[0];
         let x = p.code_text_x(r);
         p.mouse_input(MouseButton::Left, ElementState::Pressed, x, r.1 + ParametersBg::CODE_TOP + 2.0, &mut ctx);
         assert_eq!(p.focused_param, Some(0));
         (p, ctx)
     }
 
     fn send(p: &mut Adapted<ParametersBg>, ctx: &mut UiContext, ev: Event) -> bool {
         WidgetHost::handle_event(p, &ev, ctx)
     }
 
     /// Typing edits the buffer and leaves the VALUE alone until ctrl+enter
     /// applies it — a script would otherwise re-run on every keystroke — and
     /// the row says so: dirty while they differ, clean once applied.
     #[test]
     fn code_edits_apply_on_ctrl_enter_not_per_keystroke() {
         let (mut p, mut ctx) = code_panel("let x = 1;");
         assert!(!p.code_is_dirty());
         send(&mut p, &mut ctx, chr("/"));
         send(&mut p, &mut ctx, chr("/"));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "//let x = 1;");
         assert_eq!(ParamController::node_params(&*p)[0].1, "let x = 1;", "the value waits");
         assert!(p.code_is_dirty());
         send(&mut p, &mut ctx, key(Key::Named(NamedKey::Enter), true, false));
         assert_eq!(ParamController::node_params(&*p)[0].1, "//let x = 1;", "ctrl+enter applies");
         assert!(!p.code_is_dirty());
         assert_eq!(p.focused_param, Some(0), "and keeps editing");
         // Escape applies too, and leaves the row.
         send(&mut p, &mut ctx, chr("!"));
         send(&mut p, &mut ctx, named(NamedKey::Escape));
         assert_eq!(ParamController::node_params(&*p)[0].1, "//!let x = 1;");
         assert_eq!(p.focused_param, None);
     }
 
     /// Tab indents, shift+tab dedents, and Enter carries the indentation —
     /// one level deeper after an opening brace.
     #[test]
     fn code_editor_indents_like_an_editor() {
         let (mut p, mut ctx) = code_panel("");
         send(&mut p, &mut ctx, chr("i"));
         send(&mut p, &mut ctx, chr("f"));
         send(&mut p, &mut ctx, chr(" "));
         send(&mut p, &mut ctx, chr("{"));
         send(&mut p, &mut ctx, named(NamedKey::Enter));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "if {\n    ", "a brace opens a level");
         send(&mut p, &mut ctx, chr("x"));
         send(&mut p, &mut ctx, named(NamedKey::Enter));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "if {\n    x\n    ", "the level carries");
         send(&mut p, &mut ctx, shift_named(NamedKey::Tab));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "if {\n    x\n", "shift+tab dedents the line");
         send(&mut p, &mut ctx, chr("}"));
         send(&mut p, &mut ctx, named(NamedKey::Tab));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "if {\n    x\n}    ", "tab inserts a level");
         assert!(send(&mut p, &mut ctx, named(NamedKey::Tab)), "tab is the editor's: it does not fall through to the host");
     }
 
     /// shift+arrows select, typing replaces the selection, ctrl+z undoes a
     /// typing run as one step and ctrl+shift+z redoes it.
     #[test]
     fn code_editor_selects_and_undoes() {
         let (mut p, mut ctx) = code_panel("abc\ndef");
         send(&mut p, &mut ctx, named(NamedKey::End));
         send(&mut p, &mut ctx, shift_named(NamedKey::ArrowDown));
         let e = p.code_editor.as_ref().unwrap();
         assert_eq!(e.selected_text().as_deref(), Some("\ndef"), "shift+down from the end of line 1 selects to the same column of line 2");
         send(&mut p, &mut ctx, chr("Z"));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "abcZ", "typing replaces the selection");
         send(&mut p, &mut ctx, chr("Y"));
         send(&mut p, &mut ctx, chr("X"));
         send(&mut p, &mut ctx, ctrl("z"));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "abc\ndef", "one typing run, one undo");
         send(&mut p, &mut ctx, key(Key::Character("z".into()), true, true));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "abcZYX", "and one redo");
         send(&mut p, &mut ctx, key(Key::Character("a".into()), true, true));
         assert_eq!(p.code_editor.as_ref().unwrap().selected_text().as_deref(), Some("abcZYX"), "ctrl+shift+a selects all");
         assert_eq!(ParamController::node_params(&*p)[0].1, "abc\ndef", "none of it applied yet");
     }
 
     /// The host flags an error line and the gutter number turns red for it;
     /// a click lands the caret past the gutter, on the column it named.
     #[test]
     fn code_row_flags_an_error_line_and_clicks_land_past_the_gutter() {
         let (mut p, mut ctx) = code_panel("one\ntwo\nthree");
         p.set_code_error_line(Some(1));
         let labels = p.own_text_labels();
         let two = labels.iter().find(|l| l.text == "  2").expect("a gutter number for line 2");
         assert_eq!(two.color, [0xff, 0x80, 0x70]);
         let one = labels.iter().find(|l| l.text == "  1").unwrap();
         assert_eq!(one.color, [0x66, 0x66, 0x78]);
         let r = p.get_param_rects()[0];
         let x = p.code_text_x(r) + 2.0 * p.code_col_w();
         p.mouse_input(MouseButton::Left, ElementState::Pressed, x, r.1 + ParametersBg::CODE_TOP + 2.0 * ParametersBg::CODE_LINE_H + 2.0, &mut ctx);
         let e = p.code_editor.as_ref().unwrap();
         assert_eq!(get_cursor_line_col(&e.buffer, e.cursor_idx), (2, 2), "line 3, column 2");
         p.set_code_error_line(None);
         assert!(p.own_text_labels().iter().all(|l| l.color != [0xff, 0x80, 0x70]));
     }
 
     /// The context actions reach the editor: undo through the runner's
     /// routing is the editor's own history, and select-all selects the
     /// buffer. Outside an edit the pane declines them.
     #[test]
     fn code_editor_answers_context_actions_while_editing() {
         use crate::widget::ContextAction;
         let (mut p, mut ctx) = code_panel("abc");
         send(&mut p, &mut ctx, named(NamedKey::End));
         send(&mut p, &mut ctx, chr("d"));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "abcd");
         assert!(Input::context_action(&mut *p, ContextAction::Undo));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "abc", "undo through the context action");
         assert!(Input::context_action(&mut *p, ContextAction::Redo));
         assert_eq!(p.code_editor.as_ref().unwrap().buffer, "abcd");
         assert!(Input::context_action(&mut *p, ContextAction::SelectAll));
         assert_eq!(p.code_editor.as_ref().unwrap().selected_text().as_deref(), Some("abcd"));
         WidgetHost::unfocus(&mut p);
         assert!(!Input::context_action(&mut *p, ContextAction::Undo), "nothing to act on once the editor is closed");
     }
 
     #[test]
     fn clicking_a_section_title_collapses_its_rows() {
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[
             ("Transform", "", "section"),
             ("Size", "1.00", "slider:0:2"),
             ("Shading", "", "section"),
             ("On", "true", "checkbox"),
         ]);
         let expanded_h = p.get_total_content_height();
         let below_before = p.get_param_rects()[2].1;
 
         // Press the first section's title box.
         let r_hdr = p.get_param_rects()[0];
         let (bx, by, _, bh) = p.section_title_box(0, r_hdr);
         p.mouse_input(MouseButton::Left, ElementState::Pressed, bx + 4.0, by + bh / 2.0, &mut ctx);
 
         assert!(p.section_collapsed("Transform"));
         assert_eq!(p.get_param_rects()[1].3, 0.0, "the collapsed section's row has no height");
         assert!(p.get_param_rects()[2].1 < below_before, "the next section moves up");
         assert!(p.get_total_content_height() < expanded_h);
         // The row's chrome and label are gone; the header's stay.
         assert!(!p.own_text_labels().iter().any(|l| l.text.contains("Size")));
         assert!(p.own_text_labels().iter().any(|l| l.text.contains("Transform")));
 
         // Clicking it again restores the section.
         let r_hdr = p.get_param_rects()[0];
         let (bx, by, _, bh) = p.section_title_box(0, r_hdr);
         p.mouse_input(MouseButton::Left, ElementState::Pressed, bx + 4.0, by + bh / 2.0, &mut ctx);
         assert!(!p.section_collapsed("Transform"));
         assert_eq!(p.get_total_content_height(), expanded_h);
     }
 
     /// Both ends of a straight run, and of an arc, as points on the path.
     fn run_ends(r: &(f32, f32, f32, f32)) -> [(f32, f32); 2] {
         let (x, y, w, h) = *r;
         if w > h {
             [(x, y), (x + w, y)]
         } else {
             [(x, y), (x, y + h)]
         }
     }
     fn arc_ends(a: &(f32, f32, f32, f32, f32)) -> [(f32, f32); 2] {
         let (cx, cy, r, a0, a1) = *a;
         [
             (cx + r * a0.cos(), cy + r * a0.sin()),
             (cx + r * a1.cos(), cy + r * a1.sin()),
         ]
     }
 
     #[test]
     fn section_outline_is_one_continuous_path() {
         let p = panel_with(&[("Transform", "", "section"), ("Size", "1.00", "slider:0:2")]);
         let (title, content) = p.section_boxes().into_iter().next().expect("one section");
         let content = content.expect("the section has a content box");
         let (runs, arcs) = p.section_outline(title, content.into());
 
         // The tab sits flush on the body — its bottom edge is the body's top edge.
         assert_eq!(title.1 + title.3, content.1, "the tab fuses to the body");
         // Folder-tab shape: the tab's two top corners, the concave throat where its right
         // side turns onto the body's top edge, and the body's three remaining corners
         // (its top-LEFT is the tab's left side running straight through).
         assert_eq!(arcs.len(), 6);
         let (tab_right, body_top) = (title.0 + title.2, content.1);
         let throats = arcs
             .iter()
             .filter(|(cx, cy, ..)| *cx > tab_right - 0.01 && *cy < body_top)
             .count();
         assert_eq!(throats, 1, "the throat — centred out in the pocket right of the tab");
 
         // Every corner hands off to a straight run — no arc dangles. (Within a stroke width:
         // runs and arcs are anchored on opposite ink sides at the concave corner.)
         let ends: Vec<(f32, f32)> = runs.iter().flat_map(run_ends).collect();
         for arc in &arcs {
             for (ax, ay) in arc_ends(arc) {
                 let nearest = ends
                     .iter()
                     .map(|(x, y)| ((x - ax).powi(2) + (y - ay).powi(2)).sqrt())
                     .fold(f32::INFINITY, f32::min);
                 assert!(nearest <= SECTION_BORDER_T + 0.01, "corner at ({ax}, {ay}) dangles: {nearest}");
             }
         }
 
         // The tab's bottom edge is open (no run along it), and the body's top edge runs
         // only right of the throat.
         let tab_bottom = title.1 + title.3 - SECTION_BORDER_T;
         let bottom_runs = runs
             .iter()
             .filter(|(_, y, w, _)| (*y - tab_bottom).abs() < 0.01 && *w > SECTION_BORDER_T)
             .count();
         assert_eq!(bottom_runs, 0, "the tab opens onto the body");
         let top_runs: Vec<&(f32, f32, f32, f32)> = runs
             .iter()
             .filter(|(_, y, w, _)| (*y - body_top).abs() < 0.01 && *w > SECTION_BORDER_T)
             .collect();
         assert_eq!(top_runs.len(), 1, "the body's top edge starts past the tab");
         assert!(top_runs[0].0 >= tab_right, "…right of the throat");
 
         // The left edge is ONE straight run from the tab's top corner to the body's
         // bottom corner.
         let left_runs: Vec<&(f32, f32, f32, f32)> = runs
             .iter()
             .filter(|(x, _, _, h)| (*x - title.0).abs() < 0.01 && *h > 0.0)
             .collect();
         assert_eq!(left_runs.len(), 1, "tab + body share one left side");
         assert!((left_runs[0].1 - (title.1 + SECTION_R)).abs() < 0.01);
         assert!((left_runs[0].1 + left_runs[0].3 - (content.1 + content.3 - SECTION_R)).abs() < 0.01);
     }
 
     #[test]
     fn a_collapsed_section_outline_closes_on_itself() {
         let mut p = panel_with(&[("Transform", "", "section"), ("Size", "1.00", "slider:0:2")]);
         p.set_section_collapsed("Transform", true);
         let (title, content) = p.section_boxes().into_iter().next().expect("one section");
         assert!(content.is_none(), "nothing to wrap below a collapsed header");
         let (runs, arcs) = p.section_outline(title, None);
         assert_eq!(arcs.len(), 4, "a plain rounded rect");
         assert_eq!(runs.len(), 4);
     }
 
     #[test]
     fn rows_pack_on_the_channel_and_sections_separate_wider() {
         let p = panel_with(&[
             ("Transform", "", "section"),
             ("Size", "1.00", "slider:0:2"),
             ("Shading", "", "section"),
             ("On", "true", "checkbox"),
         ]);
         let rects = p.get_param_rects();
         let content_bottom = |i: usize| rects[i].1 + rects[i].3 + CONTENT_BOX_PAD;
         let title_top = |i: usize| rects[i].1 - TITLE_BOX_INSET;
 
         // Inside a section everything packs on the channel: each tab sits flush on its
         // content box, and the rows keep one channel from the box's walls.
         for (title, content) in p.section_boxes() {
             let content = content.expect("both sections have content");
             assert_eq!(title.1 + title.3, content.1, "tab flush on its body");
         }
         let (_, content0) = p.section_boxes()[0];
         let content0 = content0.unwrap();
         assert_eq!(rects[1].1 - content0.1, CHANNEL, "row -> its box's top wall");
         assert_eq!(rects[1].0 - content0.0, CHANNEL, "row -> its box's side wall");
 
         // Section to section stays far wider, so the blocks still read apart.
         assert_eq!(title_top(2) - content_bottom(1), SECTION_GAP, "section -> next section");
         const { assert!(SECTION_GAP > 2.0 * CHANNEL, "sections separate wider than any channel") };
     }
 
     #[test]
     fn a_collapsed_section_keeps_the_same_gap_to_the_next_one() {
         // With no content box under it, the collapsed section's bottom edge is its own title
         // box — a fixed row-pitch bump would leave a double gap here.
         let mut p = panel_with(&[
             ("Transform", "", "section"),
             ("Size", "1.00", "slider:0:2"),
             ("Shading", "", "section"),
             ("On", "true", "checkbox"),
         ]);
         p.set_section_collapsed("Transform", true);
         let rects = p.get_param_rects();
         let collapsed_bottom = rects[0].1 - TITLE_BOX_INSET + TITLE_BOX_H;
         let next_title_top = rects[2].1 - TITLE_BOX_INSET;
         assert_eq!(next_title_top - collapsed_bottom, SECTION_GAP);
     }
 
     #[test]
     fn collapse_survives_a_param_rebuild_and_swallows_row_clicks() {
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[("Shading", "", "section"), ("On", "false", "checkbox")]);
         p.set_section_collapsed("Shading", true);
 
         // A click where the toggle used to sit must not reach it.
         let (cx, cy, _, ch) = p.toggles[1].as_ref().unwrap().rect();
         p.mouse_input(MouseButton::Left, ElementState::Pressed, cx + 6.0, cy + ch / 2.0, &mut ctx);
         p.mouse_input(MouseButton::Left, ElementState::Released, cx + 6.0, cy + ch / 2.0, &mut ctx);
         assert_eq!(ParamController::node_params(&*p)[1].1, "false", "hidden row ignores clicks");
 
         // The host re-syncs the panel (node change): collapse is keyed by title, so it holds.
         let params: Vec<(String, String, String)> = [("Shading", "", "section"), ("On", "false", "checkbox"), ("Extra", "1", "int")]
             .iter()
             .map(|(a, b, c)| (a.to_string(), b.to_string(), c.to_string()))
             .collect();
         ParamController::set_display_params(&mut *p, &params);
         assert!(p.section_collapsed("Shading"));
         assert_eq!(p.get_param_rects()[1].3, 0.0);
     }
 
     #[test]
     fn the_row_chrome_is_the_panes_and_the_plate_the_hosts() {
         let ctx = UiContext::new();
         let p = panel_with(&[("Size", "1.00", "slider:0:2")]);
         // The pane's plain quads carry the row chrome (clipped), including the slider
         // background it reads via rect()+color()...
         let plain = p.plain_quads();
         assert!(!plain.is_empty(), "row chrome in the pane's plain quads");
         // ...but NOT the panel's own PARAM_BG plate (the host draws that from color()).
         let (x, y, w, h) = WidgetHost::rect(&p);
         assert!(
             !plain.iter().any(|q| (q.0, q.1, q.2, q.3) == (x, y, w, h)),
             "panel bg plate is the host's, not the pane's"
         );
         // Per-label hatch: the walk's text prims carry the widget font and viewport bounds.
         let mut scratch = crate::scene::paint::PaintCtx::new();
         crate::scene::painter::append_widget_text(&ctx, &p, &mut scratch);
         let labels: Vec<_> = scratch
             .finish()
             .items
             .into_iter()
             .filter_map(|item| match item.prim {
                 crate::scene::paint::Prim::Text { font, bounds, .. } => Some((font, bounds)),
                 _ => None,
             })
             .collect();
         assert!(!labels.is_empty());
         assert!(labels.iter().all(|(font, bounds)| font.is_some() && bounds.is_some()));
     }
 
     #[test]
     fn scroll_wheel_scrolls_when_content_overflows() {
         let mut ctx = UiContext::new();
         let rows: Vec<(String, String, String)> = (0..30)
             .map(|i| (format!("P{i}"), "1.00".to_string(), "slider:0:2".to_string()))
             .collect();
         let mut p = ParametersBg::new();
         ParamController::set_display_params(&mut *p, &rows);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 200.0);
         assert!(p.content_h > 200.0);
         assert!(crate::widget::WidgetHostExt::is_scrollable(&p));
         // Wheel over the panel body but off every slider row's x-span is impossible (rows are
         // full-width), so scroll via the region below the last visible row: use a y between
         // rows (the 2px slack above a row) — simplest is the bottom padding strip.
         let before = p.scroll_y;
         p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, -3.0), 150.0, 199.0, &mut ctx);
         // Either a slider consumed it (value change) or the panel scrolled; both mark change.
         // The panel-scroll path must work when no slider is under the pointer:
         p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, -3.0), 2.0, 2.0, &mut ctx);
         assert!(p.scroll_y >= before, "scroll never decreases on a downward wheel");
     }
 
     /// A scroll moves the rows under a still pointer, and the hover follows
     /// the rows: the control that was under the pointer goes dark and the one
     /// now there lights, without a pointer motion. The pointer's last
     /// position is what the pane re-hovers from, so the wheel's own position
     /// (over the label column, where the pane takes it) need not be it.
     #[test]
     fn a_scroll_re_hovers_the_control_under_a_still_pointer() {
         let mut ctx = UiContext::new();
         let rows: Vec<(String, String, String)> = (0..30)
             .map(|i| (format!("P{i}"), "1.00".to_string(), "slider:0:2".to_string()))
             .collect();
         let mut p = ParametersBg::new();
         ParamController::set_display_params(&mut *p, &rows);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 200.0);
         let hovered = |p: &Adapted<ParametersBg>| -> Vec<usize> {
             p.sliders.iter().enumerate().filter(|(_, s)| s.as_ref().is_some_and(|s| s.inner().hovered())).map(|(i, _)| i).collect()
         };
         assert!(hovered(&p).is_empty());
 
         // Over the first row's control.
         let r0 = p.get_param_rects()[0];
         let (px, py) = (250.0, r0.1 + r0.3 * 0.5);
         p.on_cursor_moved(px, py, &mut ctx);
         assert_eq!(hovered(&p), vec![0], "the slider under the pointer hovers");
         assert_eq!(p.hover_row, Some(0), "and the pane lifts its label");
 
         // A wheel over the label column scrolls the pane: a notch moves the
         // TARGET and the rows glide there over the following ticks, so the
         // re-hover that matters is the tick's. The pointer's stored position
         // has not moved, but the rows under it have.
         ctx.scroll_gesture_new = true;
         let before = p.scroll_y;
         p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, -3.0), 2.0, py, &mut ctx);
         for _ in 0..120 {
             WidgetHost::tick(&mut p, 1.0 / 60.0, &mut ctx);
         }
         assert!(p.scroll_y > before, "the pane scrolled: {} -> {}", before, p.scroll_y);
         let now = p
             .get_param_rects()
             .iter()
             .position(|r| py >= r.1 && py <= r.1 + r.3)
             .expect("a row under the pointer after the scroll");
         assert_ne!(now, 0, "a different row is under the pointer");
         assert_eq!(hovered(&p), vec![now], "the hover followed the rows, without a motion");
         assert_eq!(p.hover_row, Some(now), "the label lift followed too");
 
         // Off the pane, nothing is hovered.
         p.on_cursor_moved(-9999.0, -9999.0, &mut ctx);
         assert!(hovered(&p).is_empty());
         assert_eq!(p.hover_row, None);
     }
 
     /// An inline label is cut only when it does not fit its column, by the
     /// measure the column is sized with. It used to be cut to as many
     /// characters as the column holds M's: in a proportional face a label
     /// of narrow letters is far narrower than that many M's, so a label the
     /// column was sized to hold lost its tail. On a runner whose fallback
     /// face drew "M" a pixel wider, "Count" became "C..." in a column with
     /// 30 px to spare.
     #[test]
     fn an_inline_label_is_cut_only_when_it_does_not_fit() {
         use crate::widget::display::measure_text_width;
         let narrow = "iiiiiiiiiiii";
         let long = "A parameter name far too long for any label column of this pane";
         let mut p = panel_with(&[(narrow, "x", "text"), ("Count", "3", "spinbox:0:10"), (long, "y", "text")]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 400.0);
         let (family, size) = ParametersBg::inline_label_font();
         let avail = p.label_col_w() - ParametersBg::LABEL_GAP;
         assert!(avail > 0.0, "the pane lays its labels out inline");
         let texts: Vec<String> = p.own_text_labels().into_iter().map(|l| l.text).collect();
         for name in [narrow, "Count"] {
             if measure_text_width(name, &family, size) <= avail {
                 assert!(texts.iter().any(|t| t == name), "{name:?} fits its {avail} px column and is drawn whole: {texts:?}");
             }
         }
         assert!(measure_text_width(long, &family, size) > avail, "the long label cannot fit");
         let cut = texts.iter().find(|t| t.starts_with("A p") && t.ends_with("...")).expect("the long label is cut");
         assert!(measure_text_width(cut, &family, size) <= avail, "and what is left fits: {cut:?}");
     }
 
     /// The hover cue is the row's LABEL and the row's OWN carves lit through
     /// the tint channel — and nothing else in the pane's paint changes with
     /// it. A hover adds no geometry: it can neither close the pane plate's
     /// carve-grouping window (a wash before the wells did, and every well
     /// flipped shading on any hover) nor composite over a well's shade lines
     /// (a wash after them did, and the hovered well's outline paled). Both
     /// shipped for part of 2026-09-28. The other rows' carves keep their
     /// untinted, grouped shading.
     #[test]
     fn a_hover_lifts_the_label_and_lights_only_its_own_carves() {
         use crate::scene::paint::Prim;
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[("Name", "x", "text"), ("Count", "3", "spinbox:0:10"), ("Size", "0.5", "slider:0:1")]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 400.0);
         let rect = Rect { x: 0.0, y: 0.0, width: 300.0, height: 400.0 };
         let prims = |p: &Adapted<ParametersBg>, ctx: &UiContext| {
             let mut pc = crate::scene::paint::PaintCtx::new();
             Paint::paint_ui(&**p, ctx, rect, &mut pc);
             pc.finish().items.into_iter().map(|i| i.prim).collect::<Vec<_>>()
         };
         let label_of = |p: &Adapted<ParametersBg>, name: &str| {
             p.own_text_labels().into_iter().find(|l| l.text == name).map(|l| l.color).expect("a row label")
         };
         // A carve's rect and tint, whatever its kind.
         let carve = |prim: &Prim| match prim {
             Prim::Recess { rect, tint, .. }
             | Prim::Boss { rect, tint, .. }
             | Prim::Trough { rect, tint, .. }
             | Prim::Field { rect, tint, .. } => Some((*rect, *tint)),
             _ => None,
         };
         let at_rest = prims(&p, &ctx);
         assert!(at_rest.iter().all(|pr| carve(pr).is_none_or(|(_, t)| t.is_none())), "nothing is tinted at rest");
         assert_eq!(label_of(&p, "Count"), ParametersBg::LABEL);
 
         let (x, y, w, h) = p.get_param_rects()[1];
         p.on_cursor_moved(x + w * 0.5, y + h * 0.5, &mut ctx);
         assert_eq!(p.hover_row, Some(1));
         assert_eq!(label_of(&p, "Count"), ParametersBg::LABEL_HOVER, "the hovered row's label lifts");
         assert_eq!(label_of(&p, "Name"), ParametersBg::LABEL, "and only that row's");
 
         let hovered = prims(&p, &ctx);
         assert_eq!(hovered.len(), at_rest.len(), "a hover adds no geometry");
         let mut lit = 0;
         for (a, b) in at_rest.iter().zip(&hovered) {
             if a == b {
                 continue;
             }
             let ((ra, ta), (rb, tb)) = (carve(a).expect("only carves change"), carve(b).expect("only carves change"));
             assert_eq!(ra, rb, "a carve keeps its place");
             assert_eq!((ta, tb), (None, Some(ParametersBg::HOVER_TINT)), "the change is the hover tint");
             assert!(rb.y >= y - 0.5 && rb.y + rb.height <= y + h + 0.5, "and only inside the hovered row: {rb:?}");
             lit += 1;
         }
         assert!(lit > 0, "the hovered row's carves light");
     }
 
     /// The label lift is the pane's rule, not the control's: a spinbox row,
     /// which draws no hover of its own under the relief style, lifts exactly
     /// as a slider row does, and a section header never does.
     #[test]
     fn every_control_kind_hovers_by_its_row() {
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[
             ("Shape", "", "section"),
             ("Count", "3", "spinbox:0:10"),
             ("Mode", "A", "choice:A,B"),
             ("Size", "0.5", "slider:0:1"),
         ]);
         WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 400.0);
         let rects = p.get_param_rects();
         for i in 1..4 {
             let (x, y, w, h) = rects[i];
             p.on_cursor_moved(x + w * 0.5, y + h * 0.5, &mut ctx);
             assert_eq!(p.hover_row, Some(i), "row {i} under the pointer");
         }
         let (x, y, w, h) = rects[0];
         p.on_cursor_moved(x + w * 0.5, y + h * 0.5, &mut ctx);
         assert_eq!(p.hover_row, None, "a header is not a hoverable row");
     }
 
     /// A gesture the pane acquired stays the pane's: rows travelling under
     /// the pointer mid-gesture must not hand the wheel to the slider that
     /// arrives there (the Alt+D settings-tab leak, 2026-09-20). A NEW gesture
     /// over the same slider still adjusts it.
     #[test]
     fn pane_owned_scroll_gesture_is_not_captured_by_a_slider_sliding_under_the_pointer() {
         let rows: Vec<(String, String, String)> = (0..30)
             .map(|i| (format!("P{i}"), "1.00".to_string(), "slider:0:2".to_string()))
             .collect();
         let fresh = || {
             let mut p = ParametersBg::new();
             ParamController::set_display_params(&mut *p, &rows);
             WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, 200.0);
             p
         };
         // A point on a slider's band: row 1's rect, below the label strip.
         let band_point = |p: &Adapted<ParametersBg>| {
             let r = p.get_param_rects()[1];
             (r.0 + r.2 * 0.5, r.1 + r.3 * 0.7)
         };
         let values = |p: &Adapted<ParametersBg>| -> Vec<String> { p.display_params.iter().map(|d| d.1.clone()).collect() };
 
         // Control: a new gesture ON the band adjusts the slider (the point is a real hit).
         let mut ctx = UiContext::new();
         let mut p = fresh();
         let (bx, by) = band_point(&p);
         ctx.scroll_gesture_new = true;
         ctx.scroll_initiate_widget_id = None;
         p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, -3.0), bx, by, &mut ctx);
         assert_ne!(values(&p)[1], "1.00", "a new gesture on the band adjusts the slider");
 
         // The case: the gesture starts on the pane (dead space), the pane owns it...
         let mut ctx = UiContext::new();
         let mut p = fresh();
         ctx.scroll_gesture_new = true;
         ctx.scroll_initiate_widget_id = None;
         p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, -3.0), 2.0, 2.0, &mut ctx);
         // (The scroll itself is animated by scroll_motion over later ticks, so
         // ownership — set only on the pane-scroll path — is the witness.)
         assert_eq!(ctx.scroll_initiate_widget_id, Some(p.base().id()), "the pane owns the gesture");
         // ...and the same gesture continuing over a band adjusts nothing.
         let (bx, by) = band_point(&p);
         ctx.scroll_gesture_new = false;
         p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, -3.0), bx, by, &mut ctx);
         assert!(values(&p).iter().all(|v| v == "1.00"), "no slider took the pane's gesture: {:?}", values(&p));
         assert_eq!(ctx.scroll_initiate_widget_id, Some(p.base().id()), "the pane still owns it");
     }
 
     /// A trackpad gesture belongs to what it BEGINS on: over a slider's band
     /// it turns the slider — in a pane that overflows and in one that fits
     /// alike — and keeps turning it as the pointer drifts; beginning on the
     /// label column it scrolls the pane, and stays the pane's as bands pass
     /// under the pointer. A float3's rows are three such bands. (Until
     /// 2026-09-28 every finger gesture was the pane's, from anywhere, and a
     /// slider could be turned by a wheel notch but not by a trackpad.)
     #[test]
     fn a_finger_gesture_belongs_to_the_control_it_begins_on() {
         use crate::widget::{scroll_motion::set_scroll_phase, Position, ScrollPhase};
         let rows = |n: usize| -> Vec<(String, String, String)> {
             (0..n).map(|i| (format!("P{i}"), "1.00".to_string(), "slider:0:2".to_string())).collect()
         };
         let panel = |n: usize, h: f32| {
             let mut p = ParametersBg::new();
             ParamController::set_display_params(&mut *p, &rows(n));
             WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, h);
             p
         };
         // A point on row 1's band: the slider's own rect, below its label strip.
         let band_point = |p: &Adapted<ParametersBg>| {
             let s = p.sliders[1].as_ref().unwrap();
             let (sx, sy, sw, sh) = s.rect();
             let ty = s.label_strip();
             (sx + sw * 0.3, sy + ty + (sh - ty) * 0.5)
         };
         let values = |p: &Adapted<ParametersBg>| -> Vec<String> { p.display_params.iter().map(|d| d.1.clone()).collect() };
         let finger = |dy: f64| MouseScrollDelta::PixelDelta(Position { x: 0.0, y: dy });
 
         for (n, h) in [(30, 200.0), (3, 600.0)] {
             // Beginning ON the band: the slider turns, and owns the gesture.
             let mut ctx = UiContext::new();
             let mut p = panel(n, h);
             let (bx, by) = band_point(&p);
             ctx.scroll_gesture_new = true;
             set_scroll_phase(ScrollPhase::Finger);
             assert!(p.mouse_wheel(&finger(-60.0), bx, by, &mut ctx));
             let slider_id = p.sliders[1].as_ref().unwrap().base().id();
             assert_ne!(values(&p)[1], "1.00", "a finger gesture on the band turns the slider ({n} rows)");
             assert_eq!(ctx.scroll_initiate_widget_id, Some(slider_id), "the slider owns the gesture");
             assert_eq!(p.scroll_y, 0.0, "the pane did not scroll");
             // Still its gesture with the pointer drifted onto the next band.
             let turned = values(&p)[1].clone();
             let (_, sy2, _, sh2) = p.sliders[2].as_ref().unwrap().rect();
             ctx.scroll_gesture_new = false;
             assert!(p.mouse_wheel(&finger(-60.0), bx, sy2 + sh2 * 0.7, &mut ctx));
             assert_ne!(values(&p)[1], turned, "latched: the first slider keeps turning");
             assert_eq!(values(&p)[2], "1.00", "the band under the drifted pointer holds");
         }
 
         // Beginning on the label column: the pane scrolls and owns the
         // gesture, and a band passing under the pointer adjusts nothing.
         let mut ctx = UiContext::new();
         let mut p = panel(30, 200.0);
         let (_, by) = band_point(&p);
         ctx.scroll_gesture_new = true;
         set_scroll_phase(ScrollPhase::Finger);
         p.mouse_wheel(&finger(-30.0), ROW_X_INSET + 2.0, by, &mut ctx);
         assert_eq!(ctx.scroll_initiate_widget_id, Some(p.base().id()), "the pane took the gesture");
         assert!(p.scroll_y > 0.0, "the pane scrolled (finger tracks 1:1): {}", p.scroll_y);
         let (bx, by) = band_point(&p);
         ctx.scroll_gesture_new = false;
         p.mouse_wheel(&finger(-60.0), bx, by, &mut ctx);
         assert!(values(&p).iter().all(|v| v == "1.00"), "a pane-owned gesture turns nothing: {:?}", values(&p));
 
         // A float3's rows are three bands: a finger gesture on the Y row
         // turns Y alone.
         let mut ctx = UiContext::new();
         let mut p = panel_with(&[("Name", "x", "text"), ("Offset", "0.00:0.00:0.00", "float3:-1:1")]);
         let f = p.float3s[1].as_ref().unwrap();
         let (rx, ry, rw, rh) = f.get_row_rects()[1];
         let chrome = crate::widget::input::slider::Slider::readout_chrome();
         let (bx, by) = (rx + (rw - chrome) * 0.5, ry + rh * 0.5);
         ctx.scroll_gesture_new = true;
         set_scroll_phase(ScrollPhase::Finger);
         assert!(p.mouse_wheel(&finger(-120.0), bx, by, &mut ctx));
         let parts: Vec<f32> = p.display_params[1].1.split(':').map(|v| v.parse().unwrap()).collect();
         assert_eq!((parts[0], parts[2]), (0.0, 0.0), "X and Z hold: {parts:?}");
         assert_ne!(parts[1], 0.0, "Y turned: {parts:?}");
         assert_eq!(p.scroll_y, 0.0);
         set_scroll_phase(ScrollPhase::Wheel);
     }
 
     /// The same rule on a spinbox, whose zone is its row: a gesture that
     /// begins on a spinbox row steps the spinbox — a finger's fractional notches accumulating
     /// into whole steps — and stays the spinbox's, while a gesture the pane
     /// acquired still scrolls past it. A wheel notch on the row steps it too,
     /// however the scroll factor scales the notch.
     #[test]
     fn a_gesture_beginning_on_a_spinbox_row_steps_it_trackpad_included() {
         use crate::widget::{scroll_motion::set_scroll_phase, Position, ScrollPhase};
         let rows = |n: usize| -> Vec<(String, String, String)> {
             (0..n)
                 .map(|i| if i == 1 { ("Count".to_string(), "10".to_string(), "spinbox:0:100:1".to_string()) } else { (format!("P{i}"), "1.00".to_string(), "slider:0:2".to_string()) })
                 .collect()
         };
         let panel = |n: usize, h: f32| {
             let mut p = ParametersBg::new();
             ParamController::set_display_params(&mut *p, &rows(n));
             WidgetHost::set_rect(&mut p, 0.0, 0.0, 300.0, h);
             p
         };
         let row_point = |p: &Adapted<ParametersBg>| {
             let r = p.get_param_rects()[1];
             (r.0 + r.2 * 0.3, r.1 + r.3 * 0.5)
         };
         let count = |p: &Adapted<ParametersBg>| p.display_params[1].1.clone();
 
         // A finger gesture beginning on the row: 60 px of travel is one step,
         // the spinbox owns the gesture, and the pane does not scroll.
         let mut ctx = UiContext::new();
         let mut p = panel(30, 200.0);
         let (x, y) = row_point(&p);
         ctx.scroll_gesture_new = true;
         set_scroll_phase(ScrollPhase::Finger);
         assert!(p.mouse_wheel(&MouseScrollDelta::PixelDelta(Position { x: 0.0, y: 30.0 }), x, y, &mut ctx));
         assert_eq!(count(&p), "10", "half a notch: no step yet");
         let sb_id = p.spinboxes[1].as_ref().unwrap().base().id();
         assert_eq!(ctx.scroll_initiate_widget_id, Some(sb_id), "the spinbox owns the gesture");
         ctx.scroll_gesture_new = false;
         assert!(p.mouse_wheel(&MouseScrollDelta::PixelDelta(Position { x: 0.0, y: 30.0 }), x, y, &mut ctx));
         assert_eq!(count(&p), "11", "the second half completes the notch");
         assert_eq!(p.scroll_y, 0.0, "the pane did not scroll");
         // Still its gesture when the pointer drifts onto the row below.
         let below = p.get_param_rects()[2];
         assert!(p.mouse_wheel(&MouseScrollDelta::PixelDelta(Position { x: 0.0, y: -120.0 }), x, below.1 + below.3 * 0.5, &mut ctx));
         assert_eq!(count(&p), "9", "two notches down, latched");
         assert_eq!(p.display_params[2].1, "1.00", "the slider under the drifted pointer holds");
 
         // A gesture the pane acquired scrolls past the row without stepping it.
         let mut ctx = UiContext::new();
         let mut p = panel(30, 200.0);
         ctx.scroll_gesture_new = true;
         set_scroll_phase(ScrollPhase::Finger);
         p.mouse_wheel(&MouseScrollDelta::PixelDelta(Position { x: 0.0, y: -30.0 }), 2.0, 2.0, &mut ctx);
         assert_eq!(ctx.scroll_initiate_widget_id, Some(p.base().id()), "the pane took the gesture");
         let (x, y) = row_point(&p);
         ctx.scroll_gesture_new = false;
         p.mouse_wheel(&MouseScrollDelta::PixelDelta(Position { x: 0.0, y: -120.0 }), x, y, &mut ctx);
         assert_eq!(count(&p), "10", "a pane-owned gesture never steps a spinbox");
         assert_eq!(ctx.scroll_initiate_widget_id, Some(p.base().id()));
 
         // A scaled wheel notch (scroll_factor 0.5) still steps, over two notches.
         let mut ctx = UiContext::new();
         let mut p = panel(30, 200.0);
         let (x, y) = row_point(&p);
         ctx.scroll_gesture_new = true;
         set_scroll_phase(ScrollPhase::Wheel);
         assert!(p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, 0.5), x, y, &mut ctx));
         assert_eq!(count(&p), "10");
         ctx.scroll_gesture_new = false;
         assert!(p.mouse_wheel(&MouseScrollDelta::LineDelta(0.0, 0.5), x, y, &mut ctx));
         assert_eq!(count(&p), "11", "a half-notch factor is not truncated to nothing");
     }
 }