//! Display list + paint context — Phase 3 of the core rebuild (single paint path).
 //!
 //! Today the toolkit paints through **three** uncoordinated routes — the app's top-level
 //! `view*` methods, each container's recursive `all_quads`/`all_rounded_quads` (with clipping
 //! hand-copied into every container), and the immediate-mode `render_widget`/`SectionContext`.
 //! Nothing arbitrates z-order (hence the `overlay_quads` escape hatch) and every clip is CPU
 //! rect-intersection math duplicated per container (there is no GPU scissor).
 //!
 //! This module is the foundation for collapsing those into **one** ordered pass: a paint walk
 //! emits primitives into a single [`DisplayList`] through a [`PaintCtx`] that carries a **clip
 //! stack** (each pushed clip is intersected with the current one, so a primitive records the exact
 //! scissor rect it should be drawn under) and a **translate stack** (local coordinates compose to
 //! absolute — the seam Phase 4 animation slides/scales through). The backend then tessellates the
 //! one ordered list, using the recorded clip as a GPU `set_scissor_rect`.
 //!
 //! This first cut is pure data + bookkeeping, fully unit-tested without a GPU. Wiring the widget
 //! tree's paint into it, and routing the backend through the result, are the runtime-gated
 //! follow-ups.
 
 use crate::scene::layout::Rect;
 use crate::scene::material::{Finish, Material, PlateRole};
 
 /// End-cap style for a [`Prim::Vector`], mirroring the toolkit's line caps.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Cap {
     Flat,
     Round,
     Arrow,
 }
 
 /// A single paint primitive in logical pixels (absolute coordinates once emitted). These mirror
 /// the toolkit's existing tessellators so a `DisplayList` maps directly onto them at draw time.
 /// Per-corner radii `(top_left, top_right, bottom_right, bottom_left)`, matching the toolkit's
 /// `CornerRadii` order.
 pub type Radii = (f32, f32, f32, f32);
 
 /// RFC Phase 7b: the ONE description of a lit base surface — a window's root
 /// plate or a nested pane plate — distinguished only by ROLE data, never by
 /// type. A window root is a plate whose four corners are all window corners;
 /// detaching a pane into its own window is a role flip, nothing more.
 ///
 /// The material's tint always carries POSITIVE alpha; the frost encoding is
 /// applied by [`Self::fill`] per the role (see the Phase 7b blur-regime note
 /// in `docs/rfc-core-rebuild.md`): a root plate stays positive-alpha (the
 /// COMPOSITOR frosts behind the window), a nested plate whose material is
 /// [`Frost::Frosted`] encodes the in-app frost pass's negative-alpha sentinel.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PlateSpec {
     pub rect: Rect,
     /// What the plate is made of: tint, frost and finish
     /// (`docs/rfc-material.md`). `Material::root()` / `Material::pane()` are
     /// the rung defaults; `Material::opaque(c)` an app's own colour.
     pub material: Material,
     /// Which corners lie ON the window silhouette (TL, TR, BR, BL).
     pub window_corners: (bool, bool, bool, bool),
     /// Transition-band width of the rolled perimeter. Negative = the fill-less
     /// roll-overlay sentinel (see [`PaintCtx::plate`]).
     pub depth: f32,
 }
 
 impl PlateSpec {
     /// THE standard root plate of a `width` x `height` window — the base
     /// surface every cce app stands its panes and controls on: the whole
     /// window, the root rung's material ([`Material::root`], which is the
     /// DE's `style.surface.plate.root.color` at its configured opacity
     /// unless a `material=` is bound), all four corners on the silhouette,
     /// and the perimeter rolled over [`crate::layout::bevel_width`].
     ///
     /// This is the spec every app used to hand-copy as an eight-line block
     /// (page-low colour, opacity override, four window corners, the DE roll)
     /// — the copies are gone, and a window whose base is anything else is
     /// off the standard on purpose, which its code should say. Emit it with
     /// [`PaintCtx::root_plate`]; deviate with [`Self::with_material`] /
     /// [`Self::with_depth`] (cce-system-interface's own tint, an overlay's
     /// shallower roll).
     pub fn window(width: f32, height: f32) -> Self {
         Self::root_at(Rect { x: 0.0, y: 0.0, width, height })
     }
 
     /// [`Self::window`] for a root plate that is not the whole surface — a
     /// layer-shell overlay drawing the window silhouette itself inside a
     /// larger transparent surface (cce-cloud). Same material, corners and
     /// roll; `rect` is where the "window" is.
     pub fn root_at(rect: Rect) -> Self {
         Self {
             rect,
             material: Material::root(),
             window_corners: (true, true, true, true),
             depth: crate::layout::bevel_width(),
         }
     }
 
     /// This plate made of `material` instead of its rung's default.
     pub fn with_material(mut self, material: Material) -> Self {
         self.material = material;
         self
     }
 
     /// This plate with a `depth` roll instead of the DE's `bevel_width`.
     pub fn with_depth(mut self, depth: f32) -> Self {
         self.depth = depth;
         self
     }
 
     /// All four corners on the silhouette: this plate IS the window's base
     /// surface.
     pub fn is_root(&self) -> bool {
         let (tl, tr, br, bl) = self.window_corners;
         tl && tr && br && bl
     }
 
     /// Which of `rect`'s corners lie on a `win_w` x `win_h` window's
     /// silhouette (edge tolerance 1.5px) — the designer's `pane_plate_radii`
     /// derivation, toolkit-side.
     pub fn window_corner_flags(rect: Rect, win_w: f32, win_h: f32) -> (bool, bool, bool, bool) {
         let e = 1.5;
         let left = rect.x <= e;
         let top = rect.y <= e;
         let right = rect.x + rect.width >= win_w - e;
         let bottom = rect.y + rect.height >= win_h - e;
         (top && left, top && right, bottom && right, bottom && left)
     }
 
     /// Per-corner radii for `flags`: a window corner wears the SHARED
     /// silhouette curve (`window_corner_radius * corner_span_factor` — the
     /// compositor clips the window and the desktop grid draws its cells from
     /// the same value, so window-corner arcs must follow it, never a per-app
     /// plate override); an interior corner wears the nominal
     /// `plate_corner_radius`.
     pub fn radii_for(flags: (bool, bool, bool, bool)) -> Radii {
         let nominal = crate::layout::plate_corner_radius();
         let window_r = crate::layout::window_silhouette_radius();
         let (tl, tr, br, bl) = flags;
         let pick = |on: bool| if on { window_r } else { nominal };
         (pick(tl), pick(tr), pick(br), pick(bl))
     }
 
     /// [`Self::radii_for`] over this spec's flags.
     pub fn radii(&self) -> Radii {
         Self::radii_for(self.window_corners)
     }
 
     /// This plate detached into its own window (RFC Phase 7c): every corner
     /// becomes a window corner, and with the role the radii snap to the
     /// silhouette curve and [`Self::fill`] flips frost regimes (the
     /// compositor's blur-behind takes over from the in-app sentinel). The
     /// reverse — reattaching — is the host assigning its computed
     /// `window_corner_flags` back.
     pub fn detached(mut self) -> Self {
         self.window_corners = (true, true, true, true);
         self
     }
 
     /// The frost regime this plate is under: [`PlateRole::Root`] when it IS
     /// the window's base surface, [`PlateRole::Nested`] otherwise.
     pub fn role(&self) -> PlateRole {
         if self.is_root() { PlateRole::Root } else { PlateRole::Nested }
     }
 
     /// The fill with the role-correct frost encoding: root → alpha forced
     /// non-negative (the compositor's frost, not ours), nested + frosted →
     /// the in-app frost pass's negative-alpha sentinel. The rule itself is
     /// [`Material::fill_tint`], the one place a negative alpha is written.
     pub fn fill(&self) -> [f32; 4] {
         self.material.fill(self.role())
     }
 }
 
 /// The **relief primitives** are the members of this enum that describe a lit
 /// surface rather than a flat fill: [`Prim::Bevel`], [`Prim::Plate`],
 /// [`Prim::Recess`], [`Prim::Boss`], [`Prim::Ridge`], [`Prim::ConcaveFillet`],
 /// [`Prim::Groove`], [`Prim::Lattice`], [`Prim::CarveUnion`] and [`Prim::Sphere`]. They share one lighting model — the
 /// DE's light vector, roll width and profile, per-pixel through shader2d's
 /// SDF branch (see `crate::layout::bevel_shader`) — and split in two:
 ///
 /// - **plates** carry their own fill: `Bevel`, `Plate`. Shader mode 1.
 /// - **carves** emit shading ONLY, no fill, over whatever is already painted
 ///   beneath: `Recess`, `Boss`, `Ridge`, `ConcaveFillet`, `Groove`, `Lattice`,
 ///   `CarveUnion`. Modes 2-4, 6-8, 13 and 14. (`Sphere`, mode 5, is neither —
 ///   a lit ball under the same model.)
 ///
 /// That split is load-bearing for flat-path hosts, which need one list for the
 /// faces and another for the edges drawn over them (cce-files' `rects` vs
 /// `reliefs`).
 ///
 /// How a control plate sits on the surface beneath it — see "Plates, wells
 /// and seams" in `CLAUDE.md`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PlateStance {
     /// Floats above the surface: a [`Prim::Bevel`] when it has a face of its
     /// own, an edges-only [`Prim::Boss`] carved inside its footprint when the
     /// face is transparent (the surface below shows through as the face).
     Raised,
     /// Level with the surface inside a groove ring: a [`Prim::Trough`] carved
     /// inside its footprint, with the face as a flat fill when it has one
     /// ([`PaintCtx::inset_plate`]).
     Flush,
     /// No relief at all — the face alone, filling the footprint as a flat
     /// rounded rect. This is the PANE rung's material brought down to the
     /// control rung, and it exists because the other two stances cannot give
     /// a control two things a pane has:
     ///
     /// - **Its silhouette IS its rect.** `Raised` and `Flush` both carve
     ///   inside the footprint, so their visible edge sits half the carve depth
     ///   in and a control laid out on the same numbers as a pane does not line
     ///   up with it. Nothing is inset here, so it does.
     /// - **It can be frosted.** The blur-behind sentinel (a negative alpha)
     ///   only reaches quads, and the relief stances lay their face through
     ///   `Border`/`Trough` strokes. This one fills with a quad, so a control
     ///   can be made of the same frosted material as the pane behind it.
     ///
     /// The cost is that a flat fill carries ONE radius, not four: the
     /// per-corner silhouette a nested relief control computes (Dropdown's
     /// concentric corner adjustment) has no equivalent here, and `radii.0` is
     /// used for all four corners. A focus `tint` is drawn as a ring, since
     /// there is no rim to light.
     Flat,
 }
 
 /// How far past a [`Prim::Field`]'s end its run's end is put to say the run
 /// REACHES that end and there is no well on that side: far enough that the
 /// blend across the seam and the seam's own wall land nowhere near the
 /// field. An encoding of the prim's; a [`Field`] says it by its form.
 pub const FIELD_RUN_ONLY: f32 = 1.0e4;
 
 /// How near a run's end may come to the field's end and still be taken as
 /// reaching it — the shader's own tolerance (half a pixel, `MODE_FIELD`).
 const FIELD_REACH: f32 = 0.5;
 
 /// A FIELD: a well cut into a plate with a flush plate, the RUN, standing
 /// in it, one outline round both. One object in every form a control takes
 /// — they differ only in where the run is:
 ///
 /// | form | constructor | run | well |
 /// | --- | --- | --- | --- |
 /// | text box | [`Field::well`] | none | the whole field |
 /// | flush control plate (dropdown, button, …) | [`Field::run`] | the whole field | none |
 /// | text row with its picker, spinbox | [`Field::ending_in_run`] | the right end | left of it |
 /// | toggle | [`Field::sliding_run`] | part of the field, anywhere | either side of it |
 ///
 /// Painted by [`PaintCtx::field`], as a [`Prim::Field`] — except a field
 /// with no run, which is a [`Prim::Recess`]: that is what a plain well has
 /// always been, and a recess groups into the plate under it where a field
 /// prim never does. The rect is the field's OUTLINE (the carve's boundary;
 /// a widget takes it through [`crate::layout::carve_inside`] from its
 /// footprint), and `depth` the wall width.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Field {
     pub rect: Rect,
     pub radii: Radii,
     pub depth: f32,
     /// The run's span in x, clamped to the outline; `None` for a well.
     run: Option<(f32, f32)>,
     /// Lights the rim — the focus and hover treatment.
     pub tint: Option<[f32; 3]>,
 }
 
 impl Field {
     /// All well, no run: a text box.
     pub fn well(rect: Rect, radii: Radii, depth: f32) -> Self {
         Field { rect, radii, depth, run: None, tint: None }
     }
 
     /// All run, no well: the edge of a flush control plate — a dropdown
     /// trigger, a button ([`PaintCtx::inset_plate`]).
     pub fn run(rect: Rect, radii: Radii, depth: f32) -> Self {
         Self::spanning(rect, radii, depth, rect.x, rect.x + rect.width)
     }
 
     /// A well ending in a run from `split` to the field's right end: a text
     /// row with its completion picker, a spinbox with its -/+ run.
     pub fn ending_in_run(rect: Rect, radii: Radii, depth: f32, split: f32) -> Self {
         Self::spanning(rect, radii, depth, split, rect.x + rect.width)
     }
 
     /// A run `width` wide, at `t` of its travel along the field: 0 is the
     /// left end, 1 the right, a well either side between — a toggle, whose
     /// run glides from off to on.
     pub fn sliding_run(rect: Rect, radii: Radii, depth: f32, width: f32, t: f32) -> Self {
         let width = width.clamp(0.0, rect.width);
         let x = rect.x + t.clamp(0.0, 1.0) * (rect.width - width);
         Self::spanning(rect, radii, depth, x, x + width)
     }
 
     /// A run from `a` to `b`, anywhere in the field — the general form the
     /// others are; clamped to the outline.
     pub fn spanning(rect: Rect, radii: Radii, depth: f32, a: f32, b: f32) -> Self {
         let (l, r) = (rect.x, rect.x + rect.width);
         let a = a.clamp(l, r);
         let b = b.clamp(a, r);
         Field { rect, radii, depth, run: Some((a, b)), tint: None }
     }
 
     /// The rim lit in `tint` (focus, hover), or not.
     pub fn with_tint(mut self, tint: Option<[f32; 3]>) -> Self {
         self.tint = tint;
         self
     }
 
     /// Where the run is, `(left, right)` within the outline; `None` for a
     /// field that is all well.
     pub fn run_span(&self) -> Option<(f32, f32)> {
         self.run
     }
 
     /// Whether any of the field is well — false for a field that is all run.
     pub fn has_well(&self) -> bool {
         match self.run {
             None => true,
             Some((a, b)) => a > self.rect.x + FIELD_REACH || b < self.rect.x + self.rect.width - FIELD_REACH,
         }
     }
 
     /// The run as [`Prim::Field`] encodes it, `(split, end)`: an end that
     /// reaches the field's is put [`FIELD_RUN_ONLY`] past it.
     fn prim_span(&self) -> Option<(f32, f32)> {
         let (a, b) = self.run?;
         let (l, r) = (self.rect.x, self.rect.x + self.rect.width);
         let split = if a <= l + FIELD_REACH { l - FIELD_RUN_ONLY } else { a };
         let end = if b >= r - FIELD_REACH { r + FIELD_RUN_ONLY } else { b };
         Some((split, end))
     }
 }
 
 /// A control plate: the thing you press, at the control rung of the plate
 /// ladder. One description for every control face — Button, Dropdown,
 /// FontSelector, Breadcrumb, a ButtonStrip's selected plateau — so their
 /// carve-inside, radius, depth and transparent-face rules cannot drift.
 /// Painted by [`PaintCtx::control_plate`]. The root and pane rungs of the
 /// ladder are [`PlateSpec`]; this is the same idea one rung down.
 ///
 /// `rect` is the plate's footprint, the OUTER edge of its silhouette; the
 /// carve is taken inside it ([`crate::layout::carve_inside`]), so the gap
 /// beside the plate is the gap. `radii` is the silhouette, per corner (a
 /// Dropdown nested concentrically in a frame corner adjusts each). `face`
 /// is the plate's own material; `None` means the surface below IS the face
 /// (edges only), and a frosted material is a real face — the frost carried
 /// where the stance can (`Flat`; see [`PlateStance`]). `depth` is the
 /// relief's wall width — [`ControlPlate::control`] takes the DE relief width
 /// capped at a fifth of the height.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ControlPlate {
     pub rect: Rect,
     pub radii: Radii,
     pub stance: PlateStance,
     pub face: Option<Material>,
     pub depth: f32,
     /// The rim's light and shadow tinted this colour: the keyboard-focus
     /// ring, drawn on the plate's own relief rather than as extra geometry.
     /// `None` untinted.
     pub tint: Option<[f32; 3]>,
 }
 
 impl ControlPlate {
     /// A control plate at `rect` with a uniform corner `radius`: depth from
     /// the DE relief width, capped at a fifth of the plate's height.
     pub fn control(rect: Rect, radius: f32, stance: PlateStance, face: Option<Material>) -> Self {
         let depth = crate::layout::bevel_width().min(rect.height * 0.2);
         Self { rect, radii: (radius, radius, radius, radius), stance, face, depth, tint: None }
     }
 
 
     /// Light the rim — the focus ring on the plate's silhouette. Pass the
     /// highlight colour while the control holds keyboard focus, `None` otherwise.
     pub fn with_tint(mut self, tint: Option<[f32; 3]>) -> Self {
         self.tint = tint;
         self
     }
 
     /// The DE's focus-ring colour for a plate rim: the highlight accent, the
     /// same the wells light their rims with while editing.
     pub fn focus_tint() -> [f32; 3] {
         let c = crate::color::highlight_primary_color();
         [c[0], c[1], c[2]]
     }
 
     /// Per-corner silhouette (a concentric corner-frame adjustment).
     pub fn with_radii(mut self, radii: Radii) -> Self {
         self.radii = radii;
         self
     }
 
     /// An explicit wall width — a plate that shares its depth with the well
     /// it stands in, or one capped by its short side rather than its height.
     pub fn with_depth(mut self, depth: f32) -> Self {
         self.depth = depth;
         self
     }
 
     /// The face a stance draws: `Some` only for a material with a visible
     /// tint — a transparent one is the surface below showing through, the
     /// same as `None`.
     pub fn faced(&self) -> Option<&Material> {
         self.face.as_ref().filter(|m| m.tint[3] > 0.001)
     }
 
     /// The face as the encoded fill the flat-path bridges consume
     /// (`Button::inset_face`, cce-system-interface's `ControlCarve`):
     /// transparent for no face, else the material's nested fill.
     pub fn face_fill(&self) -> [f32; 4] {
         self.face.map_or([0.0; 4], |m| m.fill(PlateRole::Nested))
     }
 }
 
 // Call the family **relief primitives** — see `Prim`. (This note sat above `DropletSpec`,
 // which moved to `cce_core::droplet`.)
 // Call the family **relief primitives**, not "bevel primitives": `Bevel` is one
 // specific member — a filled rounded rect plus a lit roll on its lip — and a
 // groove, a fillet or a sphere is not a bevel in any sense. "Relief" is also
 // what the rest of the stack already says: `layout::control_relief` gates the
 // whole family, and the config node is `relief`. The name **bevel** is reserved
 // for two things: the `Bevel` prim, and the shared *edge treatment* every
 // relief primitive is shaded with (`bevel_width`, `bevel_depth`,
 // `bevel_shader`, `bevel_profile` — the lit roll, not the shape).
 pub use cce_core::droplet::DropletSpec;
 
 /// What a droplet's material is shaded with — an extension, since [`DropletSpec`] lives in
 /// `cce_core`, which knows no [`Finish`]. `use cce_ui::scene::paint::DropletFinish;` at a
 /// call site that writes `spec.finish()`.
 pub trait DropletFinish {
     /// The drop's finish: its own gleam, shine and rim in the specular,
     /// shininess and curvature slots of a [`Finish`] (a drop is wetter than
     /// the DE's plates), the shading strength the DE's. The material a
     /// droplet is emitted with carries this — `Material::from_fill(c)
     /// .with_finish(spec.finish())` — and the tessellator reads it from
     /// there like any plate's, instead of packing the slots by hand.
     fn finish(&self) -> Finish;
 }
 
 impl DropletFinish for DropletSpec {
     fn finish(&self) -> Finish {
         Finish { spec: self.gleam, shininess: self.shine, curvature: self.rim, ..Finish::from_style() }
     }
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Prim {
     Quad { rect: Rect, color: [f32; 4] },
     RoundedRect { rect: Rect, radius: f32, corners: (bool, bool, bool, bool), color: [f32; 4] },
     /// A rounded fill plus a solid border stroke — a widget's own "plate"
     /// (`append_widget_plate`'s non-bevel branch).
     Border { rect: Rect, radii: Radii, fill: [f32; 4], border: [f32; 4], thickness: f32 },
     /// A beveled plate: a rounded fill at full size plus a light/shadow overlay lip
     /// (`append_widget_plate`'s bevel branch). `tint` colours the
     /// roll's light and shadow — neutral white normally; a host sets it to a
     /// highlight color to mark the plate (the focused-pane treatment) without a
     /// separate border ring: the light goes to the tint, the shadow to a dark
     /// tint, so the relief still reads. Shader-plates path only; the legacy
     /// banded tessellation ignores it.
     Bevel { rect: Rect, radii: Radii, material: Material, depth: f32, tint: [f32; 3] },
     /// A [`Prim::Bevel`] turned inside out: the plate's face is everything in
     /// `rect` OUTSIDE `hole`, and its rolled edge runs round the hole's
     /// outline, falling INTO the hole. So a corner of the hole is an inside
     /// corner of the plate — a cove, rounded at the hole's radius in the DE's
     /// corner family — which a box can only round convex. A band of a
     /// window's edge with an opening above it (the designer's playbar shelf):
     /// its top edge and both coves are ONE outline, one profile evaluation,
     /// with no join to stack two shadings at. `rect` bounds the face (its
     /// own edges are not rolled — lay them past the window or under
     /// something), and it is a carve host like a Bevel: carves inside `rect`
     /// group into it. Shader-plates path; the legacy path fills `rect`.
     Frame { rect: Rect, hole: Rect, hole_radii: Radii, material: Material, depth: f32 },
     /// A recess carved into whatever is already painted underneath — the inverse of
     /// `Bevel`. Emits ONLY the shaded edges, never a fill, so the surface below shows
     /// through the middle: a relief cut into the root plate rather than a plate laid on
     /// top of it. The light vector is negated relative to `Bevel`, so the edges facing
     /// `light_source_position` fall into shadow and the far edges catch the light —
     /// which is what reads as "lower" instead of "raised".
     ///
     /// The shading is a translucent light/shadow overlay, so the carve needs no knowledge
     /// of what it carves: fills, gradients, and translucency below all show through
     /// modulated rather than repainted.
     /// `edges` is (top, right, bottom, left): which walls of the carve actually exist.
     /// A region flush with the plate's own edge is a step, not a trough — see
     /// `push_bevel_edge_vertices_banded`.
     /// `tint` colours the wall's light and shadow — the same focused-pane
     /// treatment as [`Prim::Bevel`]'s tint, for carved wells instead of raised
     /// plates. A tinted
     /// recess never groups into a host plate's CSG features (a feature carries no
     /// color), so it always renders as the free-carve overlay. Shader-plates path
     /// only; the legacy banded tessellation ignores it.
     Recess { rect: Rect, radii: Radii, depth: f32, edges: (bool, bool, bool, bool), tint: Option<[f32; 3]> },
     /// The inverse of [`Prim::Recess`]: a plateau RAISED out of the surface below.
     /// Like `Recess` it emits only the shaded edges, never a fill — the face is the
     /// untouched surface underneath — so a region outlined by raised rolled bumps
     /// keeps the root plate's own color and translucency. Same wall semantics as
     /// `Recess` (`edges` = top/right/bottom/left); the lighting is the raised sign,
     /// so the edges facing `light_source_position` catch the light. `tint` colors
     /// the lit rim like [`Prim::Recess`]'s — the focused-pane treatment for a
     /// rim-only pane (a fill-less surface can't carry [`Prim::Bevel`]'s tint).
     /// Like a tinted recess it never groups into a host plate's CSG features.
     Boss { rect: Rect, radii: Radii, depth: f32, edges: (bool, bool, bool, bool), tint: Option<[f32; 3]> },
     /// A raised RIM riding the rect's boundary: a bump profile straddling the
     /// outline (span ±depth/2), rising from the surrounding surface to a crest on
     /// the boundary and falling back to the same level inside — an elevated border
     /// around a channel, both faces at the underlying surface's own level. One
     /// primitive, ONE lighting evaluation per pixel: building the same shape from
     /// a Boss plus an inset Recess stacks two shading passes (double specular /
     /// shoulder terms at the crest) and reads far hotter than a plate edge.
     Ridge { rect: Rect, radii: Radii, depth: f32, edges: (bool, bool, bool, bool) },
     /// The sunken twin of [`Prim::Ridge`]: a VALLEY riding the rect's boundary —
     /// a bump profile straddling the outline (span ±depth/2), falling from the
     /// surrounding surface to a trough on the boundary and rising back to the
     /// same level inside, so both faces sit at the underlying surface's own
     /// level. This is the seam a flush inset control leaves ([`PaintCtx::inset_plate`]).
     ///
     /// Same reason to exist as `Ridge`, measured: building this from a `Recess`
     /// on an outset rect plus a `Boss` on the rect (what `inset_plate` used to
     /// emit) stacks two independent shading passes. At depth 4.8 that read as a
     /// band 15px wide instead of 8 with THREE lobes — bright, dark, brighter —
     /// because the recess ring's own lit rim lands ~depth outside the control
     /// instead of merging into one wall, and the highlight peaked 22% hotter
     /// than a single evaluation of the same depth. It looked like two concentric
     /// rings, which is what it was.
     ///
     /// `edges` and the host-box fade behave exactly as [`Prim::Recess`]'s.
     /// SDF path only; the legacy banded tessellation approximates it with the
     /// old two-step stack (like `Ridge`, which approximates itself there).
     ///
     /// `tint` lights the rim like [`Prim::Recess`]'s — the focus treatment of a
     /// flush control plate (`PaintCtx::control_plate`).
     Trough { rect: Rect, radii: Radii, depth: f32, edges: (bool, bool, bool, bool), tint: Option<[f32; 3]> },
     /// A sunken well holding a FLUSH run: one field, one outer contour.
     /// Between `split` and `end` (xs in the same space as `rect`) the
     /// interior is back at the surface's level, as a flush control plate's
     /// face, inside a valley on the outline; on either side of that it is a
     /// [`Prim::Recess`] — the interior one step down. A run that reaches an
     /// end of the field (`split` left of it, or `end` right of it — by
     /// [`FIELD_RUN_ONLY`]) has no well on that side. The forms in use: a
     /// parameter pane's text row with its completion picker and a spinbox's
     /// value with its -/+ run (the run at the right end), a flush control
     /// plate (all run), a toggle (a run half the field wide, at the left end
     /// off and the right end on, gliding between).
     ///
     /// Why one prim and not the two it replaces, side by side: each of those
     /// shades its OWN box, so at the seam the outline breaks — each box
     /// turns its own square corner there, and the strong line of the edge
     /// jumps from the recess's outer rim to the trough's inner lip. Here the
     /// outline is evaluated once (the whole field, its own radii), its wall
     /// blends from the step to the valley across a wall's width about the
     /// seam — the two agree on the outer half, falling from the surface to
     /// half the step, and part on the inner half — and the seam is the
     /// well's floor rising to the run's face: a step wall along `split`,
     /// fading to nothing where it meets the outer wall, the one place the
     /// two sides stand at the same height.
     ///
     /// SDF path only; the legacy banded tessellation and flat hosts draw the
     /// two-box form it replaced. `tint` lights it like a recess's.
     Field { rect: Rect, radii: Radii, depth: f32, split: f32, end: f32, tint: Option<[f32; 3]> },
     /// The window's glass slab: a rounded fill plus a rolled, lit edge around its whole
     /// perimeter, drawn at full size. Distinct from `Bevel`, which insets its fill by
     /// `depth` — a plate must fill the window exactly, or the compositor's rounded window
     /// corners would show a gap. `depth` is the width of the roll-off in px, not a color
     /// offset (the shading amplitude is the DE-wide `bevel_depth`).
     ///
     /// `shape` overrides the DE-wide corner exponent (`layout::corner_shape`)
     /// for this one plate — `Some(2.0)` is circular arcs, so a plate whose
     /// radii reach its half-extent is a true circle regardless of the
     /// squircle the rest of the DE wears. `None` follows the DE.
     Plate { rect: Rect, radii: Radii, material: Material, depth: f32, shape: Option<f32> },
     Arc { cx: f32, cy: f32, radius: f32, thickness: f32, start: f32, end: f32, color: [f32; 4] },
     /// A ring band with radial color interpolation — inner rim → crest
     /// (centerline) → outer rim — for rounded rim bevels (the Ramp's key
     /// rings). `radius` is the stroke's outer edge, like `Arc`.
     ArcShaded { cx: f32, cy: f32, radius: f32, thickness: f32, start: f32, end: f32, inner: [f32; 4], crest: [f32; 4], outer: [f32; 4] },
     Vector { x1: f32, y1: f32, x2: f32, y2: f32, thickness: f32, color: [f32; 4], cap: Cap },
     Circle { cx: f32, cy: f32, radius: f32, color: [f32; 4] },
     /// A feathered aura around (and over) a rounded rect: the interior fills
     /// at the color's full alpha, and outside the boundary the alpha falls
     /// off smoothly to zero across `reach` px. Tessellated as concentric
     /// per-vertex-alpha rings the GPU interpolates, so the gradient is
     /// per-pixel smooth — no stacked-layer banding. Highlights and soft
     /// focus auras (the designer's drop-target glow) are the intended use;
     /// no relief shading, no light involvement.
     Glow { rect: Rect, radius: f32, reach: f32, color: [f32; 4] },
     /// A `Circle` lit as a ball: the disc is shaded per pixel as a hemisphere
     /// under the DE's plate light (same ambient/diffuse/specular model), so it
     /// reads as a sphere sitting on the surface — the slider thumb's look. The
     /// color is the sphere's face color exactly at the lit center, like a
     /// plate's face keeps the app's color. Falls back to a flat circle on the
     /// legacy (`bevel_shader 0`) path.
     Sphere { cx: f32, cy: f32, radius: f32, material: Material },
     /// A hanging water droplet clinging to the TOP edge of `rect`, lit per pixel
     /// by shader mode 10: the silhouette is a smooth union of a film "sheet"
     /// attached to the top edge (square top corners — the attach line) and a
     /// belly capsule resting on the rect's bottom, blended metaball-style so a
     /// waist forms where the sides pull up. Shaded as a glass dome under the
     /// DE's plate light — same ambient/diffuse and decoupled specular as the
     /// plates, plus a fresnel rim crest and a thin-edge clarity falloff (tint
     /// opacity drops toward the silhouette, so the frosted backdrop shows
     /// through clearer at the rim, which is what reads as water rather than
     /// plastic). Shape knobs in [`DropletSpec`]. On the legacy (`bevel_shader
     /// 0`) path it degrades to the flat hanging capsule — square top, round
     /// bottom — rather than vanishing.
     Droplet { rect: Rect, material: Material, spec: DropletSpec },
     /// The same silhouette as [`Prim::Droplet`] under the same [`DropletSpec`],
     /// filled FLAT and feathered inward: opaque through the interior, fading
     /// to nothing over `feather` px as it approaches the drop's edge. A
     /// vignette shaped exactly like the drop, for grounding text drawn on top
     /// of one — not a second lit body, so it carries no dome, rim, gleam or
     /// contact shadow.
     ///
     /// It shares the droplet's shader path rather than approximating the
     /// outline with a rounded rect, so the two can never disagree about where
     /// the drop's edge is. On the legacy (`bevel_shader 0`) path it degrades
     /// to the same flat rounded-rect outline `Prim::Droplet` falls back to.
     DropletScrim { rect: Rect, material: Material, spec: DropletSpec, feather: f32 },
     /// A concave inside-corner fillet for composed carves: a quarter-arc wall
     /// whose centre `(cx, cy)` sits out in the corner's pocket, shaded with the
     /// same step profile as a `Recess`/`Boss` wall (`raised` flips the sign).
     /// `start` is the wedge's start angle (quarter span, hard-cut at the
     /// tangent lines — the neighboring straight walls continue the profile
     /// exactly there). Box radii can only round convex corners; this is the
     /// missing concave piece. SDF path only (no legacy fallback).
     ConcaveFillet { cx: f32, cy: f32, radius: f32, depth: f32, start: f32, raised: bool },
     /// An engraved line: a groove of half-width `width / 2` running along the
     /// segment `a`–`b`, cut into whatever is painted beneath. Like [`Prim::Recess`]
     /// it emits only shading, never a fill — but its shape is a SLAB (a band about
     /// an arbitrary line) rather than a box, which is what lets it run at an angle.
     /// A box SDF can only carve axis-aligned walls; this is the diagonal case.
     ///
     /// Both walls come from ONE profile evaluation on `|distance to the line|`, so
     /// the groove carries a single specular/shoulder term — the same reason
     /// [`Prim::Ridge`] exists instead of stacking a boss on a recess.
     /// `width` 0 makes the two walls meet in a V.
     ///
     /// `depth` is the transition width in px (the wall's run), matching
     /// [`Prim::Recess`]. `host` is the surface the groove is engraved into: the
     /// shading fades out across that box's perimeter roll, so a seam cut across a
     /// plate dies into the plate's own rolled edge instead of ending on a hard line.
     /// SDF path only — the legacy banded tessellation draws nothing (like `Ridge`).
     ///
     /// `strength` scales the groove's shading, specular and AO — 1.0 is the
     /// DE's finish, 0.0 no groove at all — which is how a carve with no colour
     /// of its own fades ([`Prim::faded`]).
     Groove { a: (f32, f32), b: (f32, f32), width: f32, depth: f32, host: Rect, strength: f32 },
     /// A periodic field of identical rounded-box wells — every cell of a grid
     /// carved into whatever is painted beneath, as ONE surface. The wells
     /// repeat every `period` (x, y) with one cell centred at `origin`, each
     /// `cell` (w, h) big with `radius` corners; the wall runs from the cell
     /// edge OUTWARD over `depth` px (floor at the edge, plateau one run out),
     /// so a rail between two cells carries one wall from each side and the
     /// rail face is whatever the runs leave. Shading lands only inside `rect`.
     /// The wall's outer edge is MITRED, not offset: it is the cell grown by
     /// the run at the same `radius`, so a crossing keeps the cell's corner
     /// rounding instead of sweeping at `radius + depth`, and the four walls
     /// meet on the diagonals.
     ///
     /// This exists because a lattice drawn as one [`Prim::Recess`] per cell is
     /// N independent overlays: where four rounded rings meet at a crossing
     /// their shadings stack in colour space and read as overlapping effects,
     /// not a junction. Here the pixel is folded into the period and the
     /// distance is to the NEAREST cell — the union of every well — evaluated
     /// once, so the rail centre lines and the diagonals at each crossing are
     /// true mitres, and the cost is one draw regardless of how many cells the
     /// surface holds (a free carve per cell also runs into the per-frame
     /// feature budget long before a zoomed-out grid does). SDF path only.
     Lattice { rect: Rect, period: (f32, f32), origin: (f32, f32), cell: (f32, f32), radius: f32, depth: f32 },
     /// `color`, flat, everywhere inside `rect` that is OUTSIDE a periodic
     /// field of rounded cells — the same field [`Prim::Lattice`] carves
     /// (`period`, one cell centred at `origin`, each `cell` big with `radius`
     /// corners), painted as grout rather than shaded. One draw for the whole
     /// grid, with the cells' superellipse corners exact: what a graph's grid
     /// lines are when the cells are the surface beneath showing through.
     /// SDF path only — the legacy banded tessellation draws nothing.
     Grout { rect: Rect, period: (f32, f32), origin: (f32, f32), cell: (f32, f32), radius: f32, color: [f32; 4] },
     /// A flat fill of a MATERIAL: `rect` at `radii`, no roll, no rim — the
     /// material's tint, frosted at the material's own recipe when it is
     /// frosted. What a frosted `RoundedRect` promotes to, except that the
     /// recipe is the material's rather than the DE default's, so a fill can
     /// compress harder (or softer) than the pane it sits on. Opens no carve
     /// host: carves emitted after it overlay it, as they overlay any flat
     /// geometry. An opaque material draws as a plain rounded fill.
     Fill { rect: Rect, radii: Radii, material: Material },
     /// Several rounded boxes carved (`raised` false) or raised (`raised`
     /// true) as ONE shape: the union of the boxes is the well, and its wall
     /// follows the union's outline — straddling it by ±`depth`/2 like every
     /// carve boundary — through a single profile evaluation per pixel. An L,
     /// a T, a plus, a slot with a round end: any outline boxes can compose.
     ///
     /// The alternative, one [`Prim::Recess`] per box, is N overlays that
     /// each shade their own full outline: where two boxes overlap, each
     /// draws a wall straight through the other's interior, and where their
     /// walls cross the shadings stack in colour space — the junction reads
     /// as two effects laid over each other, not one shape. Here the pixel's
     /// distance is to the NEAREST box (the union SDF), so a box's wall
     /// vanishes wherever it runs inside another, and an inside corner is a
     /// sharp mitre (round it with [`Prim::ConcaveFillet`] if it must be
     /// concave-rounded — the union has no radius there by construction).
     /// Outer corners are mitred like [`Prim::Lattice`]'s: the wall band runs
     /// between each box shrunk and grown by half the run at the box's own
     /// radius, so a corner keeps its radius instead of sweeping wider.
     ///
     /// The boxes ride the frame's plate-feature buffer (the same slots CSG
     /// carves use, 64 per frame), so a union costs one draw plus one slot
     /// per box. When the budget cannot hold all of a union's boxes the
     /// tessellator keeps as many as fit — a degraded shape rather than none —
     /// and says so under `CCE_PLATE_DEBUG`. SDF path only.
     CarveUnion { boxes: Vec<(Rect, Radii)>, depth: f32, raised: bool },
     /// Text in sRGB u8 (the `TextLabel` convention). `font` is a font string for
     /// `get_text_buffer` (family, or "family:size"); `bounds` is a logical `[l, t, r, b]` clip
     /// for the glyph pass (Phase 6: the backend renders these through the glyph pass when the app
     /// opts in via `Application::display_list_text`; the paint walk's clip additionally
     /// applies through the item's `clip`). `attrs` carries the optional shaping attributes
     /// beyond family+size (the font picker's italic/weight preview variants). `layout`, when
     /// `Some`, requests box layout — word-wrap at a width and horizontal/vertical alignment
     /// within a box (the placed-text-box case, e.g. cce-layout-interface's canvas elements);
     /// `None` is the ordinary single-run label. `alpha` fades the glyphs (1.0 = opaque) —
     /// the color stays sRGB u8, so translucent text doesn't need a color-type change.
     Text { text: String, x: f32, y: f32, font_size: f32, color: [u8; 3], alpha: f32, font: Option<String>, bounds: Option<[f32; 4]>, attrs: TextAttrs, layout: Option<TextLayout> },
     /// A user image (id from `cce_ui::vk::upload_rgba`) drawn as a quad, in
     /// display-list order like any other primitive. The paint walk's clip
     /// applies through the item's `clip` as usual.
     Image { image: u32, rect: Rect, alpha: f32 },
 }
 
 impl Prim {
     /// This prim at `alpha` of its strength (0..1): a colour's alpha scaled,
     /// a text's or an image's alpha, a groove's shading. What a host fading a
     /// part of its drawing out or in replays it through (the context menu's
     /// page turn). The relief prims with no colour or strength of their own —
     /// the walls, plates and materials — come back as they are: they are
     /// drawn whole or not at all.
     pub fn faded(self, alpha: f32) -> Prim {
         let a = alpha.clamp(0.0, 1.0);
         let f = |c: [f32; 4]| [c[0], c[1], c[2], c[3] * a];
         match self {
             Prim::Quad { rect, color } => Prim::Quad { rect, color: f(color) },
             Prim::RoundedRect { rect, radius, corners, color } => Prim::RoundedRect { rect, radius, corners, color: f(color) },
             Prim::Border { rect, radii, fill, border, thickness } => Prim::Border { rect, radii, fill: f(fill), border: f(border), thickness },
             Prim::Arc { cx, cy, radius, thickness, start, end, color } => Prim::Arc { cx, cy, radius, thickness, start, end, color: f(color) },
             Prim::ArcShaded { cx, cy, radius, thickness, start, end, inner, crest, outer } => {
                 Prim::ArcShaded { cx, cy, radius, thickness, start, end, inner: f(inner), crest: f(crest), outer: f(outer) }
             }
             Prim::Vector { x1, y1, x2, y2, thickness, color, cap } => Prim::Vector { x1, y1, x2, y2, thickness, color: f(color), cap },
             Prim::Circle { cx, cy, radius, color } => Prim::Circle { cx, cy, radius, color: f(color) },
             Prim::Glow { rect, radius, reach, color } => Prim::Glow { rect, radius, reach, color: f(color) },
             Prim::Grout { rect, period, origin, cell, radius, color } => Prim::Grout { rect, period, origin, cell, radius, color: f(color) },
             Prim::Groove { a: p, b, width, depth, host, strength } => Prim::Groove { a: p, b, width, depth, host, strength: strength * a },
             Prim::Text { text, x, y, font_size, color, alpha, font, bounds, attrs, layout } => {
                 Prim::Text { text, x, y, font_size, color, alpha: alpha * a, font, bounds, attrs, layout }
             }
             Prim::Image { image, rect, alpha } => Prim::Image { image, rect, alpha: alpha * a },
             other => other,
         }
     }
 }
 
 /// Horizontal alignment of laid-out (boxed) text — the toolkit-plain mirror of
 /// `cosmic_text::Align`, mapped at shape time.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub enum AlignH {
     #[default]
     Left,
     Center,
     Right,
 }
 
 /// Vertical alignment of laid-out text within its box.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub enum AlignV {
     #[default]
     Top,
     Middle,
     Bottom,
 }
 
 /// Box layout for a [`Prim::Text`]: word-wrap width (`Some` ⇒ multiline wrap; `None` ⇒ single
 /// run) and horizontal/vertical alignment within a box of `box_height`. All lengths are logical.
 /// The backend shapes it with `get_text_buffer_laid_out`, cached under the box as well as the
 /// text, and applies the vertical offset from the shaped height.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct TextLayout {
     pub wrap_width: Option<f32>,
     pub box_height: f32,
     pub align_h: AlignH,
     pub align_v: AlignV,
 }
 
 /// Optional shaping attributes for a [`Prim::Text`] — the subset a widget can request beyond
 /// family + size. `weight` is the OpenType weight (400 regular, 700 bold); `None` leaves the
 /// family default. `stretch` is the OpenType width class (`usWidthClass`, 1 ultra-condensed
 /// … 5 normal … 9 ultra-expanded); `None` is normal width — what picks a family's Narrow or
 /// Condensed cut over its normal-width sibling at the same weight. Kept toolkit-plain (no
 /// cosmic-text types) like the rest of the scene layer; the backend maps them onto
 /// `cosmic_text::Style`/`Weight`/`Stretch` at shape time.
 ///
 /// Build one with `..Default::default()` after the fields you set, so a field added here
 /// does not break every literal in the sibling crates.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub struct TextAttrs {
     pub italic: bool,
     pub weight: Option<u16>,
     pub stretch: Option<u16>,
 }
 
 /// A primitive plus the scissor rect it must be clipped to (`None` = unclipped), an
 /// optional circular clip `[cx, cy, r]` in logical pixels (`None` = unclipped) — the
 /// per-vertex circle clip the tessellators already support, for round panes (the designer's
 /// circular network pane) — and an optional rounded-rect clip `[cx, cy, bx, by, r]`
 /// (center, SDF half-extents = half-size minus radius, corner radius; logical px) so a
 /// plate's children cut off at its rounded corners. The clips compose: the scissor is GPU
 /// state, the circle rides the vertices, the rounded rect is per-draw-batch state.
 #[derive(Clone, Debug, PartialEq)]
 pub struct PaintItem {
     pub prim: Prim,
     pub clip: Option<Rect>,
     pub clip_circle: Option<[f32; 3]>,
     pub clip_rrect: Option<[f32; 5]>,
 }
 
 /// An ordered list of clipped primitives — the single source of truth for a frame's geometry.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct DisplayList {
     pub items: Vec<PaintItem>,
 }
 
 impl DisplayList {
     pub fn new() -> Self {
         DisplayList { items: Vec::new() }
     }
     pub fn len(&self) -> usize {
         self.items.len()
     }
     pub fn is_empty(&self) -> bool {
         self.items.is_empty()
     }
 }
 
 /// Intersection of two rects, clamped so width/height never go negative (an empty clip is a
 /// zero-size rect — nothing draws under it).
 fn intersect(a: Rect, b: Rect) -> Rect {
     let x0 = a.x.max(b.x);
     let y0 = a.y.max(b.y);
     let x1 = (a.x + a.width).min(b.x + b.width);
     let y1 = (a.y + a.height).min(b.y + b.height);
     Rect { x: x0, y: y0, width: (x1 - x0).max(0.0), height: (y1 - y0).max(0.0) }
 }
 
 /// Accumulates a [`DisplayList`] while a paint walk pushes/pops clips and translations.
 ///
 /// Coordinates passed to the emit methods (and to [`push_clip`](PaintCtx::push_clip)) are in the
 /// **current** local space; the active translation is applied so everything recorded is absolute.
 pub struct PaintCtx {
     list: DisplayList,
     /// Each entry is the effective (already-intersected, absolute) clip at that depth.
     clip_stack: Vec<Rect>,
     /// Active circular clips; primitives record the innermost (`last`). Circles don't
     /// intersect analytically like rects, so nesting keeps the innermost only.
     clip_circle_stack: Vec<[f32; 3]>,
     /// Active rounded-rect clips `[cx, cy, bx, by, r]`; innermost wins, like circles.
     clip_rrect_stack: Vec<[f32; 5]>,
     /// Saved offsets for nesting; `offset` is the current cumulative translation.
     offset_stack: Vec<(f32, f32)>,
     offset: (f32, f32),
 }
 
 impl Default for PaintCtx {
     fn default() -> Self {
         Self::new()
     }
 }
 
 impl PaintCtx {
     pub fn new() -> Self {
         PaintCtx {
             list: DisplayList::new(),
             clip_stack: Vec::new(),
             clip_circle_stack: Vec::new(),
             clip_rrect_stack: Vec::new(),
             offset_stack: Vec::new(),
             offset: (0.0, 0.0),
         }
     }
 
     /// The scissor rect primitives are currently recorded under.
     pub fn current_clip(&self) -> Option<Rect> {
         self.clip_stack.last().copied()
     }
 
     /// Push a clip (in current local space); it is translated to absolute and intersected with the
     /// enclosing clip. Pair with [`pop_clip`](PaintCtx::pop_clip), or prefer [`clip`](PaintCtx::clip).
     pub fn push_clip(&mut self, rect: Rect) {
         let r = self.apply_offset(rect);
         let effective = match self.clip_stack.last() {
             Some(cur) => intersect(*cur, r),
             None => r,
         };
         self.clip_stack.push(effective);
     }
 
     pub fn pop_clip(&mut self) {
         self.clip_stack.pop();
     }
 
     /// Run `f` with `rect` pushed as a clip, popping it afterward.
     pub fn clip<R>(&mut self, rect: Rect, f: impl FnOnce(&mut Self) -> R) -> R {
         self.push_clip(rect);
         let out = f(self);
         self.pop_clip();
         out
     }
 
     /// Push a circular clip `[cx, cy, r]` (current local space, translated to absolute).
     /// Primitives emitted while it is active record it and tessellate with the per-vertex
     /// circle clip. Pair with [`pop_clip_circle`](PaintCtx::pop_clip_circle), or prefer
     /// [`clip_circle`](PaintCtx::clip_circle).
     pub fn push_clip_circle(&mut self, c: [f32; 3]) {
         self.clip_circle_stack.push([c[0] + self.offset.0, c[1] + self.offset.1, c[2]]);
     }
 
     pub fn pop_clip_circle(&mut self) {
         self.clip_circle_stack.pop();
     }
 
     /// Run `f` with `[cx, cy, r]` pushed as a circular clip, popping it afterward.
     pub fn clip_circle<R>(&mut self, c: [f32; 3], f: impl FnOnce(&mut Self) -> R) -> R {
         self.push_clip_circle(c);
         let out = f(self);
         self.pop_clip_circle();
         out
     }
 
     /// Push a rounded-rect clip: `rect` (current local space) with corner radius `radius`,
     /// so children of a rounded plate cut off at its corners. Pushes the rect as a scissor
     /// too — the scissor handles the straight edges (and keeps batching), the SDF trims the
     /// corners. A radius of zero degenerates to the plain rect clip. Pair with
     /// [`pop_clip_rounded`](PaintCtx::pop_clip_rounded), or prefer
     /// [`clip_rounded`](PaintCtx::clip_rounded).
     pub fn push_clip_rounded(&mut self, rect: Rect, radius: f32) {
         self.push_clip(rect);
         let r = radius.max(0.0);
         if r > 0.0 {
             let abs = self.apply_offset(rect);
             self.clip_rrect_stack.push([
                 abs.x + abs.width / 2.0,
                 abs.y + abs.height / 2.0,
                 (abs.width / 2.0 - r).max(0.0),
                 (abs.height / 2.0 - r).max(0.0),
                 r,
             ]);
         } else {
             // Keep push/pop balanced regardless of radius.
             self.clip_rrect_stack.push([0.0; 5]);
         }
     }
 
     pub fn pop_clip_rounded(&mut self) {
         self.clip_rrect_stack.pop();
         self.pop_clip();
     }
 
     /// Run `f` with `rect` (radius `radius`) pushed as a rounded clip, popping it afterward.
     pub fn clip_rounded<R>(&mut self, rect: Rect, radius: f32, f: impl FnOnce(&mut Self) -> R) -> R {
         self.push_clip_rounded(rect, radius);
         let out = f(self);
         self.pop_clip_rounded();
         out
     }
 
     /// Run `f` with an additional translation applied to all emitted coordinates.
     /// Imperative translate pair for spans too large to wrap in
     /// [`translate`](Self::translate)'s closure (an app bracketing its whole
     /// frame in the overflow-margin shift). Must balance before `finish`.
     pub fn push_translate(&mut self, dx: f32, dy: f32) {
         self.offset_stack.push(self.offset);
         self.offset.0 += dx;
         self.offset.1 += dy;
     }
 
     /// See [`push_translate`](Self::push_translate).
     pub fn pop_translate(&mut self) {
         self.offset = self.offset_stack.pop().expect("translate stack underflow");
     }
 
     pub fn translate<R>(&mut self, dx: f32, dy: f32, f: impl FnOnce(&mut Self) -> R) -> R {
         self.offset_stack.push(self.offset);
         self.offset = (self.offset.0 + dx, self.offset.1 + dy);
         let out = f(self);
         self.offset = self.offset_stack.pop().expect("translate stack underflow");
         out
     }
 
     /// The translation applied to what is emitted now: a widget's own rect
     /// plus this is where it lands in the window.
     pub fn offset(&self) -> (f32, f32) {
         self.offset
     }
 
     fn apply_offset(&self, r: Rect) -> Rect {
         Rect { x: r.x + self.offset.0, y: r.y + self.offset.1, width: r.width, height: r.height }
     }
 
     fn push(&mut self, prim: Prim) {
         let clip = self.current_clip();
         let clip_circle = self.clip_circle_stack.last().copied();
         // r == 0 entries are balance placeholders (a zero-radius rounded clip is just its
         // scissor rect) — record no rounded clip so batches keep merging.
         let clip_rrect = self.clip_rrect_stack.last().copied().filter(|c| c[4] > 0.0);
         self.list.items.push(PaintItem { prim, clip, clip_circle, clip_rrect });
     }
 
     /// Append items another context painted — a nested paint walk spliced into this list,
     /// as a host does that keeps a walk's text for a pass of its own. Each item keeps its own
     /// clips and is clipped by this context's current scissor too; its own circular or
     /// rounded clip wins over the current one (the innermost, as when pushing). Items are
     /// absolute already, so this context's offset does not apply.
     pub fn append_items(&mut self, items: impl IntoIterator<Item = PaintItem>) {
         let cur = self.current_clip();
         let cur_circle = self.clip_circle_stack.last().copied();
         let cur_rrect = self.clip_rrect_stack.last().copied().filter(|c| c[4] > 0.0);
         for mut item in items {
             item.clip = match (cur, item.clip) {
                 (Some(a), Some(b)) => Some(intersect(a, b)),
                 (a, b) => a.or(b),
             };
             item.clip_circle = item.clip_circle.or(cur_circle);
             item.clip_rrect = item.clip_rrect.or(cur_rrect);
             self.list.items.push(item);
         }
     }
 
     pub fn quad(&mut self, rect: Rect, color: [f32; 4]) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Quad { rect, color });
     }
 
     /// A user image (id from `cce_ui::vk::upload_rgba`) drawn at `rect`.
     pub fn image(&mut self, image: u32, rect: Rect, alpha: f32) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Image { image, rect, alpha });
     }
 
     /// A bundled cce-icons glyph (`cce-icons/svg/<name>.svg`) drawn at
     /// `rect`, tinted `color` — given as a text colour is, raw sRGB, so a
     /// glyph and the label beside it match — with the colour's alpha as the
     /// image's. Rasterized at twice the rect's longer side so it stays crisp
     /// on a 2x output, and cached (see [`crate::upload_icon_tinted`]).
     /// `false`, and nothing drawn, when the glyph is missing.
     ///
     /// The ONE way the toolkit draws a symbol: a chevron, a mark, a + or a
     /// − is this, never a character in whatever face the font falls back to.
     /// A `weather-*` glyph carries its own colours; draw it with
     /// [`icon_untinted`](Self::icon_untinted).
     pub fn icon(&mut self, name: &str, rect: Rect, color: [f32; 4]) -> bool {
         let px = (rect.width.max(rect.height) * 2.0).ceil().max(1.0) as u32;
         match crate::upload_icon_tinted(name, px, crate::icon_tint(color)) {
             Some((id, _, _)) => {
                 self.image(id, rect, color[3]);
                 true
             }
             None => false,
         }
     }
 
     /// [`icon`](Self::icon) for a glyph that carries its own colours (the
     /// `weather-*` family): drawn as it is, at `alpha`.
     pub fn icon_untinted(&mut self, name: &str, rect: Rect, alpha: f32) -> bool {
         let px = (rect.width.max(rect.height) * 2.0).ceil().max(1.0) as u32;
         match crate::upload_icon(name, px) {
             Some((id, _, _)) => {
                 self.image(id, rect, alpha);
                 true
             }
             None => false,
         }
     }
 
     pub fn rounded_rect(&mut self, rect: Rect, radius: f32, corners: (bool, bool, bool, bool), color: [f32; 4]) {
         let rect = self.apply_offset(rect);
         self.push(Prim::RoundedRect { rect, radius, corners, color });
     }
 
     /// Feathered aura over a rounded rect (see [`Prim::Glow`]): interior at
     /// the color's alpha, smooth per-pixel falloff to zero across `reach` px
     /// outside the boundary.
     pub fn glow(&mut self, rect: Rect, radius: f32, reach: f32, color: [f32; 4]) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Glow { rect, radius, reach, color });
     }
 
     pub fn vector(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, thickness: f32, color: [f32; 4], cap: Cap) {
         let (ox, oy) = self.offset;
         self.push(Prim::Vector { x1: x1 + ox, y1: y1 + oy, x2: x2 + ox, y2: y2 + oy, thickness, color, cap });
     }
 
     pub fn circle(&mut self, cx: f32, cy: f32, radius: f32, color: [f32; 4]) {
         let (ox, oy) = self.offset;
         self.push(Prim::Circle { cx: cx + ox, cy: cy + oy, radius, color });
     }
 
     /// A sphere-lit circle — see `Prim::Sphere`.
     pub fn sphere(&mut self, cx: f32, cy: f32, radius: f32, material: &Material) {
         let (ox, oy) = self.offset;
         self.push(Prim::Sphere { cx: cx + ox, cy: cy + oy, radius, material: *material });
     }
 
     /// A hanging water droplet clinging to `rect`'s top edge — see
     /// [`Prim::Droplet`] and [`DropletSpec`].
     /// See [`Prim::DropletScrim`]. `feather` is how far in from the drop's
     /// edge the fill reaches full opacity, in logical px.
     pub fn droplet_scrim(&mut self, rect: Rect, material: &Material, spec: DropletSpec, feather: f32) {
         let rect = self.apply_offset(rect);
         self.push(Prim::DropletScrim { rect, material: *material, spec, feather });
     }
 
     /// The drop's finish is the material's (see [`DropletSpec::finish`]).
     pub fn droplet(&mut self, rect: Rect, material: &Material, spec: DropletSpec) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Droplet { rect, material: *material, spec });
     }
 
     /// A concave inside-corner fillet — see `Prim::ConcaveFillet`. `start` is
     /// the quarter wedge's start angle; the arc's centre sits in the corner's
     /// pocket and the wall descends (or rises, `raised`) away from it.
     pub fn concave_fillet(&mut self, cx: f32, cy: f32, radius: f32, depth: f32, start: f32, raised: bool) {
         let (ox, oy) = self.offset;
         self.push(Prim::ConcaveFillet { cx: cx + ox, cy: cy + oy, radius, depth, start, raised });
     }
 
     /// Re-emit an already-built [`Prim`] through this context, so it re-records the
     /// current clip and translate state. This is the **single** place that has to
     /// learn a new `Prim` variant: a nested paint walk builds a scratch list and
     /// replays it into the real one, and that forwarding match used to exist
     /// verbatim in two crates ([`crate::widget::model`] and cce-cloud's
     /// `json_layout`) — adding `Prim::Groove` compiled against one and broke the
     /// other, caught only by a full workspace build.
     ///
     /// [`Prim::Text`] is NOT emitted: it is returned untouched, because the two
     /// callers disagree about it (a subtree painter authors its own text and wants
     /// it forwarded; everyone else drops it in favour of the widget's own label
     /// bridge). Every other variant is emitted and `None` comes back.
     #[must_use = "a returned Text prim was not emitted — drop or forward it explicitly"]
     pub fn replay(&mut self, prim: Prim) -> Option<Prim> {
         match prim {
             Prim::Text { .. } => return Some(prim),
             Prim::Quad { rect, color } => self.quad(rect, color),
             Prim::RoundedRect { rect, radius, corners, color } => {
                 self.rounded_rect(rect, radius, corners, color)
             }
             Prim::Border { rect, radii, fill, border, thickness } => {
                 self.border(rect, radii, fill, border, thickness)
             }
             Prim::Bevel { rect, radii, material, depth, tint } => {
                 self.bevel_tinted(rect, radii, &material, depth, tint)
             }
             Prim::Frame { rect, hole, hole_radii, material, depth } => {
                 self.frame(rect, hole, hole_radii, &material, depth)
             }
             Prim::Recess { rect, radii, depth, edges, tint } => match tint {
                 Some(t) => self.recess_tinted(rect, radii, depth, t),
                 None => self.recess_edges(rect, radii, depth, edges),
             },
             Prim::Boss { rect, radii, depth, edges, tint } => match tint {
                 Some(t) => self.boss_edges_tinted(rect, radii, depth, edges, t),
                 None => self.boss_edges(rect, radii, depth, edges),
             },
             Prim::Ridge { rect, radii, depth, edges } => self.ridge_edges(rect, radii, depth, edges),
             Prim::Trough { rect, radii, depth, edges, tint } => match tint {
                 Some(t) => self.trough_tinted(rect, radii, depth, t),
                 None => self.trough_edges(rect, radii, depth, edges),
             },
             Prim::Field { rect, radii, depth, split, end, tint } => {
                 self.field(&Field::spanning(rect, radii, depth, split, end).with_tint(tint))
             }
             Prim::Plate { rect, radii, material, depth, shape } => {
                 self.plate_shaped(rect, radii, &material, depth, shape)
             }
             Prim::Arc { cx, cy, radius, thickness, start, end, color } => {
                 self.arc(cx, cy, radius, thickness, start, end, color)
             }
             Prim::ArcShaded { cx, cy, radius, thickness, start, end, inner, crest, outer } => {
                 self.arc_shaded(cx, cy, radius, thickness, start, end, inner, crest, outer)
             }
             Prim::Vector { x1, y1, x2, y2, thickness, color, cap } => {
                 self.vector(x1, y1, x2, y2, thickness, color, cap)
             }
             Prim::Circle { cx, cy, radius, color } => self.circle(cx, cy, radius, color),
             Prim::Sphere { cx, cy, radius, material } => self.sphere(cx, cy, radius, &material),
             Prim::Glow { rect, radius, reach, color } => self.glow(rect, radius, reach, color),
             Prim::Droplet { rect, material, spec } => self.droplet(rect, &material, spec),
             Prim::DropletScrim { rect, material, spec, feather } => {
                 self.droplet_scrim(rect, &material, spec, feather)
             }
             Prim::ConcaveFillet { cx, cy, radius, depth, start, raised } => {
                 self.concave_fillet(cx, cy, radius, depth, start, raised)
             }
             Prim::Groove { a, b, width, depth, host, strength } => self.groove_strength(a, b, width, depth, host, strength),
             Prim::Lattice { rect, period, origin, cell, radius, depth } => {
                 self.lattice(rect, period, origin, cell, radius, depth)
             }
             Prim::Grout { rect, period, origin, cell, radius, color } => {
                 self.grout(rect, period, origin, cell, radius, color)
             }
             Prim::Fill { rect, radii, material } => self.fill_material(rect, radii, &material),
             Prim::CarveUnion { boxes, depth, raised } => self.carve_union(boxes, depth, raised),
             Prim::Image { image, rect, alpha } => self.image(image, rect, alpha),
         }
         None
     }
 
     /// An engraved line from `a` to `b` cut into `host` — see [`Prim::Groove`].
     pub fn groove(&mut self, a: (f32, f32), b: (f32, f32), width: f32, depth: f32, host: Rect) {
         self.groove_strength(a, b, width, depth, host, 1.0);
     }
 
     /// [`Self::groove`] at a fraction of its strength — see [`Prim::Groove`].
     pub fn groove_strength(&mut self, a: (f32, f32), b: (f32, f32), width: f32, depth: f32, host: Rect, strength: f32) {
         let (ox, oy) = self.offset;
         let host = self.apply_offset(host);
         self.push(Prim::Groove {
             a: (a.0 + ox, a.1 + oy),
             b: (b.0 + ox, b.1 + oy),
             width,
             depth,
             host,
             strength,
         });
     }
 
     /// A periodic field of rounded wells carved as one surface — see
     /// [`Prim::Lattice`]. `origin` is any one cell's centre; `rect` bounds the
     /// shading. All logical px, like every other carve.
     pub fn lattice(
         &mut self,
         rect: Rect,
         period: (f32, f32),
         origin: (f32, f32),
         cell: (f32, f32),
         radius: f32,
         depth: f32,
     ) {
         let (ox, oy) = self.offset;
         let rect = self.apply_offset(rect);
         self.push(Prim::Lattice { rect, period, origin: (origin.0 + ox, origin.1 + oy), cell, radius, depth });
     }
 
     /// A flat fill of `material` — see [`Prim::Fill`].
     pub fn fill_material(&mut self, rect: Rect, radii: Radii, material: &Material) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Fill { rect, radii, material: *material });
     }
 
     /// Grout between a periodic field of rounded cells — see [`Prim::Grout`].
     /// `origin` is any one cell's centre; `rect` bounds the paint.
     pub fn grout(&mut self, rect: Rect, period: (f32, f32), origin: (f32, f32), cell: (f32, f32), radius: f32, color: [f32; 4]) {
         let (ox, oy) = self.offset;
         let rect = self.apply_offset(rect);
         self.push(Prim::Grout { rect, period, origin: (origin.0 + ox, origin.1 + oy), cell, radius, color });
     }
 
     /// Carve (or raise, with `raised`) the union of `boxes` as one shape with
     /// one wall — see [`Prim::CarveUnion`]. `depth` is the wall's run in px,
     /// as for [`PaintCtx::recess`].
     pub fn carve_union(&mut self, boxes: Vec<(Rect, Radii)>, depth: f32, raised: bool) {
         let boxes: Vec<(Rect, Radii)> = boxes.into_iter().map(|(r, radii)| (self.apply_offset(r), radii)).collect();
         if boxes.is_empty() {
             return;
         }
         self.push(Prim::CarveUnion { boxes, depth, raised });
     }
 
     pub fn border(&mut self, rect: Rect, radii: Radii, fill: [f32; 4], border: [f32; 4], thickness: f32) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Border { rect, radii, fill, border, thickness });
     }
 
     pub fn bevel(&mut self, rect: Rect, radii: Radii, material: &Material, depth: f32) {
         self.bevel_tinted(rect, radii, material, depth, [1.0, 1.0, 1.0]);
     }
 
     /// A plate whose face is `rect` outside `hole` — see [`Prim::Frame`].
     pub fn frame(&mut self, rect: Rect, hole: Rect, hole_radii: Radii, material: &Material, depth: f32) {
         let rect = self.apply_offset(rect);
         let hole = self.apply_offset(hole);
         self.push(Prim::Frame { rect, hole, hole_radii, material: *material, depth });
     }
 
     /// `bevel` with a specular tint — see `Prim::Bevel::tint`.
     pub fn bevel_tinted(&mut self, rect: Rect, radii: Radii, material: &Material, depth: f32, tint: [f32; 3]) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Bevel { rect, radii, material: *material, depth, tint });
     }
 
     /// Carve a recess into the already-painted surface below. Unlike `bevel`, this fills
     /// nothing — the shading is an overlay, so it composes over whatever was painted.
     pub fn recess(&mut self, rect: Rect, radii: Radii, depth: f32) {
         self.recess_edges(rect, radii, depth, (true, true, true, true));
     }
 
     /// [`PaintCtx::recess`] with the lit rim tinted — see `Prim::Recess::tint`
     /// (the focused-well treatment).
     pub fn recess_tinted(&mut self, rect: Rect, radii: Radii, depth: f32, tint: [f32; 3]) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Recess { rect, radii, depth, edges: (true, true, true, true), tint: Some(tint) });
     }
 
     /// Raise a plateau out of the already-painted surface below — the inverse of
     /// [`PaintCtx::recess`]. Only the edges are shaded; the face stays the surface
     /// beneath, so the raised region inherits the root plate's color. `depth` is the
     /// roll width in px (pass [`crate::layout::bevel_width`] unless the widget
     /// needs a tighter lip).
     pub fn boss(&mut self, rect: Rect, radii: Radii, depth: f32) {
         self.boss_edges(rect, radii, depth, (true, true, true, true));
     }
 
     /// [`PaintCtx::boss`] with only some of the walls — see `Prim::Boss`.
     pub fn boss_edges(
         &mut self,
         rect: Rect,
         radii: Radii,
         depth: f32,
         edges: (bool, bool, bool, bool),
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Boss { rect, radii, depth, edges, tint: None });
     }
 
     /// [`PaintCtx::boss_edges`] with a specular tint on the lit rim — see
     /// `Prim::Boss::tint`.
     pub fn boss_edges_tinted(
         &mut self,
         rect: Rect,
         radii: Radii,
         depth: f32,
         edges: (bool, bool, bool, bool),
         tint: [f32; 3],
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Boss { rect, radii, depth, edges, tint: Some(tint) });
     }
 
     /// Paint a control plate — see [`ControlPlate`]. The ONE place a control face's
     /// relief is composed: raised with a face is a `bevel` on the footprint;
     /// raised without one carves inside and raises a `boss`; flush carves
     /// inside and lays an `inset_plate` (trough plus face).
     pub fn control_plate(&mut self, plate: &ControlPlate) {
         match plate.stance {
             PlateStance::Raised => {
                 if let Some(face) = plate.faced() {
                     match plate.tint {
                         Some(t) => self.bevel_tinted(plate.rect, plate.radii, face, plate.depth, t),
                         None => self.bevel(plate.rect, plate.radii, face, plate.depth),
                     }
                 } else {
                     let (plateau, radii) = crate::layout::carve_inside(plate.rect, plate.radii, plate.depth);
                     match plate.tint {
                         Some(t) => self.boss_edges_tinted(plateau, radii, plate.depth, (true, true, true, true), t),
                         None => self.boss(plateau, radii, plate.depth),
                     }
                 }
             }
             PlateStance::Flush => {
                 let (trough, radii) = crate::layout::carve_inside(plate.rect, plate.radii, plate.depth);
                 match plate.tint {
                     Some(t) => self.inset_plate_tinted(trough, radii, plate.faced(), plate.depth, t),
                     None => self.inset_plate(trough, radii, plate.faced(), plate.depth),
                 }
             }
             PlateStance::Flat => {
                 if let Some(face) = plate.faced() {
                     // A QUAD deliberately, not the `Border` the relief stances
                     // fill through: carrying the blur-behind sentinel is half
                     // the point of this stance, and only quads reach it.
                     self.rounded_rect(
                         plate.rect,
                         plate.radii.0,
                         (true, true, true, true),
                         face.fill(PlateRole::Nested),
                     );
                 }
                 if let Some(t) = plate.tint {
                     // No relief, so no rim to light: the focus ring is drawn as
                     // one, over the face and keeping the per-corner silhouette.
                     self.border(plate.rect, plate.radii, [0.0; 4], [t[0], t[1], t[2], 1.0], 1.0);
                 }
             }
         }
     }
 
     /// A section's well — the settings app's union carve, the ONE shape a
     /// section or a [`crate::widget::Group`] is cut into the plate with: the
     /// `body` carved as a recess with `radii` (TL, TR, BR, BL), and when there
     /// is a title `tab` (flush on the body's top edge, at its left), the tab
     /// carved WITH it as one shape — the tab bottom-open, one piece owning the
     /// body's whole right run so its corners are real turns, a left piece
     /// carrying the left wall, the pieces extending past their interior seam by
     /// `depth` so the walls crossfade there instead of notching — and the
     /// throat's inside corner rounded by a concave fillet.
     pub fn section_well(&mut self, body: Rect, tab: Option<Rect>, radii: Radii, depth: f32) {
         let (cx, cy, cw, ch) = (body.x, body.y, body.width, body.height);
         let (tl, tr, br, bl) = radii;
         let Some(t) = tab else {
             self.recess_edges(body, radii, depth, (true, true, true, true));
             return;
         };
         let (tx, ty, tw, th) = (t.x, t.y, t.width, t.height);
         let rt = tl.max(tr).min(th * 0.45);
         let throat_r = tx + tw;
         // The designer's SECTION_FILLET_R.
         let rho = 10.0f32;
         let body_lr = |x_run: f32, pc: &mut Self| {
             pc.recess_edges(
                 Rect { x: x_run, y: cy, width: cx + cw - x_run, height: ch },
                 (0.0, tr, br, 0.0),
                 depth,
                 (true, true, true, false),
             );
             pc.recess_edges(
                 Rect { x: cx, y: cy, width: x_run + depth - cx, height: ch },
                 (0.0, 0.0, 0.0, bl),
                 depth,
                 (false, false, true, true),
             );
         };
         if cx + cw > throat_r + 2.0 * rho {
             // Filleted throat: the tab's right wall ends at the fillet's vertical
             // tangent, a left-only bridge carries the left wall across the span.
             self.recess_edges(
                 Rect { x: tx, y: ty, width: tw, height: (cy - rho) - ty + depth },
                 (rt, rt, 0.0, 0.0),
                 depth,
                 (true, true, false, true),
             );
             self.recess_edges(
                 Rect { x: tx, y: cy - rho, width: tw, height: rho + depth },
                 (0.0, 0.0, 0.0, 0.0),
                 depth,
                 (false, false, false, true),
             );
             body_lr(throat_r + rho - depth, self);
             self.concave_fillet(throat_r + rho, cy - rho, rho, depth, std::f32::consts::FRAC_PI_2, false);
         } else if cx + cw > throat_r + 0.5 {
             // Too narrow for the fillet: the plain square throat.
             self.recess_edges(
                 Rect { x: tx, y: ty, width: tw, height: (cy - ty) + depth },
                 (rt, rt, 0.0, 0.0),
                 depth,
                 (true, true, false, true),
             );
             body_lr(throat_r - depth, self);
         } else {
             // The tab spans the body: no top wall at all.
             self.recess_edges(
                 Rect { x: tx, y: ty, width: tw, height: (cy - ty) + depth },
                 (rt, rt, 0.0, 0.0),
                 depth,
                 (true, true, false, true),
             );
             self.recess_edges(
                 Rect { x: cx, y: cy, width: cw, height: ch },
                 (0.0, 0.0, br, bl),
                 depth,
                 (false, true, true, true),
             );
         }
     }
 
     /// A flush inset control: `rect`'s plate sits SUNKEN into the surface with
     /// its face level with it — a valley seam runs the boundary, the surface
     /// falling into it on the way out and the control's own face rising back
     /// out of it inside. The face never leaves the surface plane; the seam is
     /// the only thing saying it is a separate part. `depth` is the full width
     /// of that valley, which straddles the boundary by ±depth/2.
     ///
     /// One [`Prim::Trough`] — ONE lighting evaluation. This used to emit a
     /// `Recess` on a rect outset by depth/2 plus a `Boss` on the rect, whose
     /// walls overlapped over half their width and shaded twice; see
     /// `Prim::Trough` for what that measured as. Do not re-expand this into its
     /// parts.
     ///
     /// An opaque `color` fills the face; transparent leaves the surface below
     /// showing through as the face.
     pub fn inset_plate(&mut self, rect: Rect, radii: Radii, face: Option<&Material>, depth: f32) {
         // A transparent material is no face either — only a visible tint
         // fills; a frosted one fills with the sentinel.
         if let Some(face) = face.filter(|m| m.tint[3] > 0.001) {
             // Flat fill only — the relief is the trough's, so the face must not
             // carry a lip of its own (that lip WAS the second wall).
             //
             // Deliberately a zero-stroke `Border` and NOT `rounded_rect`: this
             // fill used to be a `Bevel`, and the legacy reverse bridges
             // (`all_rounded_quads` and friends in `widget/model.rs`) extract
             // `Prim::RoundedRect` but neither `Bevel` nor `Border`. Emitting a
             // RoundedRect here would newly leak every raised control's face into
             // those getters — a change to the legacy surface that has nothing to
             // do with the relief. Border also keeps all four radii, which
             // `Prim::RoundedRect`'s single radius cannot.
             self.border(rect, radii, face.fill(PlateRole::Nested), [0.0; 4], 0.0);
         }
         // The edge is a field's RUN (a field with no well, its seam put
         // [`FIELD_RUN_ONLY`] px to the left): the outer half a well's own
         // fall, the inner half that fall mirrored back up to the face — so
         // every flush control has the edge of the run at the end of a text
         // row's field, and the well beside it. Until 2026-10-02 this was a
         // [`Prim::Trough`], whose outer half is a compressed copy of a step;
         // the dropdown, button, breadcrumb, font selector and menubar
         // triggers had been switched to the run's edge one by one the day
         // before, and the apps' own flush plates (the calendar's, cce-cloud's,
         // cce-files', the system interface's) kept the trough until here.
         self.field(&Field::run(rect, radii, depth));
     }
 
     /// [`inset_plate`](Self::inset_plate) with the rim lit — the focused flush
     /// control plate's ring (`ControlPlate::with_tint`); the face fill as
     /// there, the trough tinted.
     pub fn inset_plate_tinted(&mut self, rect: Rect, radii: Radii, face: Option<&Material>, depth: f32, tint: [f32; 3]) {
         if let Some(face) = face.filter(|m| m.tint[3] > 0.001) {
             self.border(rect, radii, face.fill(PlateRole::Nested), [0.0; 4], 0.0);
         }
         self.field(&Field::run(rect, radii, depth).with_tint(Some(tint)));
     }
 
     /// A canvas well's floor — the opening you look into or draw in (a
     /// Trackpad, a Slider2D pad, a bevel or ramp preview) — cut into `host`,
     /// the material of the plate it sits on (`Material::pane()` for a pane).
     /// `lifted` is a clickable canvas's hover cue: the floor rises toward
     /// the plate.
     ///
     /// An opaque host's floor is that plate darkened, drawn as the darkening
     /// itself ([`crate::colors::WELL_FLOOR`] over whatever the plate resolved
     /// to — exact at any plate alpha, and what every floor drew before
     /// materials). A FROSTED host's floor is deeper glass
     /// ([`Material::floor`]: the host's material with the tint darkened,
     /// frost and finish carried), so a well in glass blurs and compresses
     /// what is under it again instead of being the one opaque patch in a
     /// frosted pane (RFC material § 11 (3)).
     pub fn well_floor(&mut self, rect: Rect, radius: f32, host: &Material, lifted: bool) {
         let fill = if host.frost.is_frosted() {
             host.floor(lifted).fill(PlateRole::Nested)
         } else if lifted {
             crate::colors::WELL_FLOOR_LIFTED
         } else {
             crate::colors::WELL_FLOOR
         };
         self.rounded_rect(rect, radius, (true, true, true, true), fill);
     }
 
     /// A canvas well's rim, drawn AFTER the content so the wall's shading falls
     /// over whatever runs to the edge. Under `relief` it is the recess carved
     /// inside `rect` ([`crate::layout::carve_inside`], the wall the DE width
     /// capped at a fifth of the height — every well's rule); flat, the
     /// hairline frame every well shares ([`crate::colors::well_frame_color`]).
     pub fn well_rim(&mut self, rect: Rect, radius: f32, relief: bool) {
         let radii = (radius, radius, radius, radius);
         if relief {
             let depth = crate::layout::bevel_width().min(rect.height * 0.2);
             let (well, radii) = crate::layout::carve_inside(rect, radii, depth);
             self.recess(well, radii, depth);
         } else {
             self.border(rect, radii, [0.0; 4], crate::colors::well_frame_color(false, false), 1.0);
         }
     }
 
     /// [`well_floor`](Self::well_floor) then [`well_rim`](Self::well_rim) in
     /// one call — a canvas whose content is drawn over the rim (a Trackpad's
     /// fingers). Content that should slide under the wall draws between the two.
     pub fn canvas_well(&mut self, rect: Rect, radius: f32, host: &Material, relief: bool, lifted: bool) {
         self.well_floor(rect, radius, host, lifted);
         self.well_rim(rect, radius, relief);
     }
 
     /// Emit one [`crate::layout::ReliefCarve`]. The shared application point:
     /// a widget's `paint` carves through here, and a flat host re-emits the
     /// carves it collected through here too, so the two can only ever draw the
     /// same prim.
     ///
     /// A tinted recess takes `recess_tinted`, which lights the whole rim — it
     /// is the focus treatment, and every tinted carve the toolkit emits is a
     /// full ring. A partial ring falls back to the untinted walls rather than
     /// silently tinting walls the caller suppressed.
     pub fn carve(&mut self, c: &crate::layout::ReliefCarve) {
         let rect = Rect { x: c.x, y: c.y, width: c.w, height: c.h };
         match c.kind {
             crate::layout::CarveKind::Boss { tint: Some(t) } if c.edges == (true, true, true, true) => {
                 self.boss_edges_tinted(rect, c.radii, c.depth, c.edges, t)
             }
             crate::layout::CarveKind::Boss { .. } => self.boss_edges(rect, c.radii, c.depth, c.edges),
             crate::layout::CarveKind::Recess { tint: Some(t) }
                 if c.edges == (true, true, true, true) =>
             {
                 self.recess_tinted(rect, c.radii, c.depth, t)
             }
             crate::layout::CarveKind::Recess { .. } => {
                 self.recess_edges(rect, c.radii, c.depth, c.edges)
             }
             crate::layout::CarveKind::Trough => self.trough_edges(rect, c.radii, c.depth, c.edges),
         }
     }
 
     /// Sink a valley along `rect`'s boundary — see [`Prim::Trough`]. `depth` is
     /// the full width of the seam (it straddles the outline by ±depth/2).
     pub fn trough(&mut self, rect: Rect, radii: Radii, depth: f32) {
         self.trough_edges(rect, radii, depth, (true, true, true, true));
     }
 
     /// [`PaintCtx::trough`] with only some of the walls — see [`Prim::Trough`].
     pub fn trough_edges(
         &mut self,
         rect: Rect,
         radii: Radii,
         depth: f32,
         edges: (bool, bool, bool, bool),
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Trough { rect, radii, depth, edges, tint: None });
     }
 
     /// [`PaintCtx::trough`] with the rim lit — see `Prim::Trough::tint` (the
     /// focused flush control plate).
     pub fn trough_tinted(&mut self, rect: Rect, radii: Radii, depth: f32, tint: [f32; 3]) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Trough { rect, radii, depth, edges: (true, true, true, true), tint: Some(tint) });
     }
 
     /// [`PaintCtx::trough_edges`] with a specular tint on the lit rim — see
     /// `Prim::Trough::tint`.
     pub fn trough_edges_tinted(
         &mut self,
         rect: Rect,
         radii: Radii,
         depth: f32,
         edges: (bool, bool, bool, bool),
         tint: [f32; 3],
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Trough { rect, radii, depth, edges, tint: Some(tint) });
     }
 
     /// Paint a [`Field`] — see it for the forms. One with a run is a
     /// [`Prim::Field`]; one that is all well a [`Prim::Recess`], which groups
     /// into the plate under it.
     pub fn field(&mut self, field: &Field) {
         let Field { rect, radii, depth, tint, .. } = *field;
         match field.prim_span() {
             None => match tint {
                 Some(t) => self.recess_tinted(rect, radii, depth, t),
                 None => self.recess(rect, radii, depth),
             },
             Some((split, end)) => {
                 let (split, end) = (split + self.offset.0, end + self.offset.0);
                 let rect = self.apply_offset(rect);
                 self.push(Prim::Field { rect, radii, depth, split, end, tint });
             }
         }
     }
 
     /// Raise a rim along `rect`'s boundary — see `Prim::Ridge`. `depth` is the
     /// full width of the bump (it straddles the outline by ±depth/2).
     pub fn ridge(&mut self, rect: Rect, radii: Radii, depth: f32) {
         self.ridge_edges(rect, radii, depth, (true, true, true, true));
     }
 
     /// [`PaintCtx::ridge`] with only some of the walls — see `Prim::Ridge`.
     pub fn ridge_edges(
         &mut self,
         rect: Rect,
         radii: Radii,
         depth: f32,
         edges: (bool, bool, bool, bool),
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Ridge { rect, radii, depth, edges });
     }
 
     /// [`PaintCtx::recess`] with only some of the walls — see `Prim::Recess`.
     pub fn recess_edges(
         &mut self, rect: Rect, radii: Radii, depth: f32,
         edges: (bool, bool, bool, bool),
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Recess { rect, radii, depth, edges, tint: None });
     }
 
     /// [`PaintCtx::recess_edges`] with a specular tint on the lit rim — see
     /// `Prim::Recess::tint`. A tinted carve never groups into its host plate
     /// (the tint could only land on the whole plate's specular), so it
     /// shades through the overlay path with its own lit rim.
     pub fn recess_edges_tinted(
         &mut self, rect: Rect, radii: Radii, depth: f32,
         edges: (bool, bool, bool, bool),
         tint: [f32; 3],
     ) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Recess { rect, radii, depth, edges, tint: Some(tint) });
     }
 
     /// The window's glass slab: rounded fill at full size plus a rolled, lit perimeter.
     /// `depth` is the roll-off width in px — pass [`crate::layout::bevel_width`] unless the
     /// window wants a shallower edge than the DE default.
     ///
     /// A NEGATIVE `depth` is the fill-less sentinel: no fill is drawn, and the
     /// rolled perimeter (width `-depth`) renders as an overlay — translucent
     /// white screen / black multiply — over whatever is beneath, for a root
     /// plate whose face is not a fill (the designer's full-bleed 3D canvas).
     /// `material` is ignored; the roll profile, crest and specular are exactly the
     /// positive-depth plate's.
     pub fn plate(&mut self, rect: Rect, radii: Radii, material: &Material, depth: f32) {
         self.plate_shaped(rect, radii, material, depth, None);
     }
 
     /// [`plate`](Self::plate) with an explicit corner exponent — see
     /// [`Prim::Plate`]'s `shape`. `Some(2.0)` on a plate whose radii are its
     /// half-extent draws a circle; `None` is exactly `plate`.
     pub fn plate_shaped(&mut self, rect: Rect, radii: Radii, material: &Material, depth: f32, shape: Option<f32>) {
         let rect = self.apply_offset(rect);
         self.push(Prim::Plate { rect, radii, material: *material, depth, shape });
     }
 
     /// Emit the plate a [`PlateSpec`] describes: role-resolved per-corner
     /// radii and role-encoded frost (RFC Phase 7b).
     ///
     /// The spec's radii are FINAL on-screen values (a window corner already
     /// wears the full silhouette span), but `Prim::Plate` speaks the older
     /// convention — NOMINAL radii, span applied downstream by
     /// `plate_push_raised(scale_corners = true)`, which the unmigrated
     /// hand-rolled plates (cce-cloud, the test-interface gallery shim) still
     /// rely on. So divide the span back out here and let the push multiply
     /// reconstruct the spec's exact values.
     ///
     /// Feeding the final radii straight through double-spanned every window
     /// corner (12 → ~100 logical at corner_shape 4.5): the plate arc pulled
     /// away from the compositor's clip, the black window background showed
     /// through as a corner crescent, and the corners stopped matching the
     /// desktop grid — the original 7b-2 report of this looking like "the arc
     /// correction" was the regression itself.
     pub fn plate_spec(&mut self, spec: &PlateSpec) {
         let f = crate::layout::corner_span_factor();
         let (tl, tr, br, bl) = spec.radii();
         self.plate(spec.rect, (tl / f, tr / f, br / f, bl / f), &spec.material.for_role(spec.role()), spec.depth);
     }
 
     /// The standard root plate of a `width` x `height` window —
     /// [`PlateSpec::window`] emitted. The first prim of a standard cce app's
     /// frame: everything else is laid on this surface (pane plates atop it,
     /// bands and wells carved into it), starting
     /// [`crate::layout::root_plate_inset`] in from each window edge.
     pub fn root_plate(&mut self, width: f32, height: f32) {
         self.plate_spec(&PlateSpec::window(width, height));
     }
 
     pub fn arc(&mut self, cx: f32, cy: f32, radius: f32, thickness: f32, start: f32, end: f32, color: [f32; 4]) {
         let (ox, oy) = self.offset;
         self.push(Prim::Arc { cx: cx + ox, cy: cy + oy, radius, thickness, start, end, color });
     }
 
     /// A radially-shaded ring band — see [`Prim::ArcShaded`].
     #[allow(clippy::too_many_arguments)]
     pub fn arc_shaded(
         &mut self,
         cx: f32,
         cy: f32,
         radius: f32,
         thickness: f32,
         start: f32,
         end: f32,
         inner: [f32; 4],
         crest: [f32; 4],
         outer: [f32; 4],
     ) {
         let (ox, oy) = self.offset;
         self.push(Prim::ArcShaded {
             cx: cx + ox,
             cy: cy + oy,
             radius,
             thickness,
             start,
             end,
             inner,
             crest,
             outer,
         });
     }
 
     pub fn text(&mut self, text: impl Into<String>, x: f32, y: f32, font_size: f32, color: [u8; 3]) {
         self.text_with(text, x, y, font_size, color, None, None);
     }
 
     /// Text with a per-label font and clip rect (`[l, t, r, b]`, local space) — what the
     /// legacy `text_labels_with_font_and_bounds` tuples carry, expressible in the display
     /// list since Phase 6.
     pub fn text_with(
         &mut self,
         text: impl Into<String>,
         x: f32,
         y: f32,
         font_size: f32,
         color: [u8; 3],
         font: Option<String>,
         bounds: Option<[f32; 4]>,
     ) {
         self.text_attrs(text, x, y, font_size, color, font, bounds, TextAttrs::default());
     }
 
     /// [`text_with`](PaintCtx::text_with) plus shaping attributes (italic / weight) — what the
     /// font picker's style-variant previews need beyond family + size.
     #[allow(clippy::too_many_arguments)]
     pub fn text_attrs(
         &mut self,
         text: impl Into<String>,
         x: f32,
         y: f32,
         font_size: f32,
         color: [u8; 3],
         font: Option<String>,
         bounds: Option<[f32; 4]>,
         attrs: TextAttrs,
     ) {
         let (ox, oy) = self.offset;
         let bounds = bounds.map(|[l, t, r, b]| [l + ox, t + oy, r + ox, b + oy]);
         self.push(Prim::Text { text: text.into(), x: x + ox, y: y + oy, font_size, color, alpha: 1.0, font, bounds, attrs, layout: None });
     }
 
     /// [`text_with`](PaintCtx::text_with) plus a glyph alpha (1.0 = opaque) — translucent
     /// labels (a pane fading out) without changing the sRGB u8 color convention.
     #[allow(clippy::too_many_arguments)]
     pub fn text_faded(
         &mut self,
         text: impl Into<String>,
         x: f32,
         y: f32,
         font_size: f32,
         color: [u8; 3],
         alpha: f32,
         font: Option<String>,
         bounds: Option<[f32; 4]>,
     ) {
         let (ox, oy) = self.offset;
         let bounds = bounds.map(|[l, t, r, b]| [l + ox, t + oy, r + ox, b + oy]);
         self.push(Prim::Text {
             text: text.into(),
             x: x + ox,
             y: y + oy,
             font_size,
             color,
             alpha,
             font,
             bounds,
             attrs: TextAttrs::default(),
             layout: None,
         });
     }
 
     /// Boxed text: word-wrap + horizontal/vertical alignment within a box (a placed text box).
     /// Unlike [`text_with`](PaintCtx::text_with), the backend shapes this with the box layout
     /// applied (cached per box). `x, y` are the box's top-left; the backend applies the vertical offset.
     #[allow(clippy::too_many_arguments)]
     pub fn text_boxed(
         &mut self,
         text: impl Into<String>,
         x: f32,
         y: f32,
         font_size: f32,
         color: [u8; 3],
         font: Option<String>,
         bounds: Option<[f32; 4]>,
         attrs: TextAttrs,
         layout: TextLayout,
     ) {
         let (ox, oy) = self.offset;
         let bounds = bounds.map(|[l, t, r, b]| [l + ox, t + oy, r + ox, b + oy]);
         self.push(Prim::Text {
             text: text.into(),
             x: x + ox,
             y: y + oy,
             font_size,
             color,
             alpha: 1.0,
             font,
             bounds,
             attrs,
             layout: Some(layout),
         });
     }
 
     /// Consume the context and return the accumulated display list.
     pub fn finish(self) -> DisplayList {
         debug_assert!(self.clip_stack.is_empty(), "unbalanced push_clip/pop_clip");
         debug_assert!(self.offset_stack.is_empty(), "unbalanced translate");
         self.list
     }
 }
 
 /// `PaintCtx` as a popover render target: display-list hosts pass their frame
 /// ctx straight into `render_popover`, so popovers draw REAL prims — relief
 /// plates, rounded rects, bounded text — instead of the flattened
 /// `PopoverCollector` view (which stays for legacy tuple hosts).
 impl crate::layout::RenderTarget for PaintCtx {
     fn icon(&mut self, name: &str, rect: Rect, color: [f32; 4]) {
         PaintCtx::icon(self, name, rect, color);
     }
     fn line(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, thickness: f32, color: [f32; 4], cap: Cap) {
         PaintCtx::vector(self, x1, y1, x2, y2, thickness, color, cap);
     }
     fn arc(&mut self, cx: f32, cy: f32, radius: f32, thickness: f32, start: f32, end: f32, color: [f32; 4]) {
         PaintCtx::arc(self, cx, cy, radius, thickness, start, end, color);
     }
     fn circle(&mut self, cx: f32, cy: f32, radius: f32, color: [f32; 4]) {
         PaintCtx::circle(self, cx, cy, radius, color);
     }
 
     fn rect(&mut self, color: [f32; 4], x: f32, y: f32, w: f32, h: f32) {
         self.quad(Rect { x, y, width: w, height: h }, color);
     }
     fn rect_with_radius(&mut self, color: [f32; 4], x: f32, y: f32, w: f32, h: f32, radius: f32) {
         self.rounded_rect(Rect { x, y, width: w, height: h }, radius, (true, true, true, true), color);
     }
     fn rect_with_radius_corners(&mut self, color: [f32; 4], x: f32, y: f32, w: f32, h: f32, radius: f32, corners: (bool, bool, bool, bool)) {
         self.rounded_rect(Rect { x, y, width: w, height: h }, radius, corners, color);
     }
     fn text(&mut self, content: &str, x: f32, y: f32, size: f32, color: [f32; 4]) {
         let c = [
             (color[0] * 255.0).clamp(0.0, 255.0) as u8,
             (color[1] * 255.0).clamp(0.0, 255.0) as u8,
             (color[2] * 255.0).clamp(0.0, 255.0) as u8,
         ];
         PaintCtx::text(self, content, x, y, size, c);
     }
     fn text_with_font(&mut self, content: &str, x: f32, y: f32, size: f32, color: [f32; 4], font: &str) {
         crate::layout::RenderTarget::text_with_font_and_bounds(self, content, x, y, size, color, font, None);
     }
     fn text_with_bounds(&mut self, content: &str, x: f32, y: f32, size: f32, color: [f32; 4], bounds: Option<[f32; 4]>) {
         let c = [
             (color[0] * 255.0).clamp(0.0, 255.0) as u8,
             (color[1] * 255.0).clamp(0.0, 255.0) as u8,
             (color[2] * 255.0).clamp(0.0, 255.0) as u8,
         ];
         self.text_with(content, x, y, size, c, None, bounds);
     }
     fn text_with_font_and_bounds(&mut self, content: &str, x: f32, y: f32, size: f32, color: [f32; 4], font: &str, bounds: Option<[f32; 4]>) {
         let c = [
             (color[0] * 255.0).clamp(0.0, 255.0) as u8,
             (color[1] * 255.0).clamp(0.0, 255.0) as u8,
             (color[2] * 255.0).clamp(0.0, 255.0) as u8,
         ];
         self.text_with(content, x, y, size, c, Some(font.to_string()), bounds);
     }
     fn push_clip_rect(&mut self, x: f32, y: f32, w: f32, h: f32) {
         self.push_clip(Rect { x, y, width: w, height: h });
     }
     fn pop_clip_rect(&mut self) {
         self.pop_clip();
     }
     fn inset_plate(&mut self, color: [f32; 4], x: f32, y: f32, w: f32, h: f32, radius: f32, depth: f32) {
         PaintCtx::inset_plate(self, Rect { x, y, width: w, height: h }, (radius, radius, radius, radius), Material::face(color).as_ref(), depth);
     }
     fn inset_plate_tinted(&mut self, color: [f32; 4], x: f32, y: f32, w: f32, h: f32, radius: f32, depth: f32, tint: [f32; 3]) {
         PaintCtx::inset_plate_tinted(self, Rect { x, y, width: w, height: h }, (radius, radius, radius, radius), Material::face(color).as_ref(), depth, tint);
     }
     fn relief_carve(&mut self, carve: &crate::layout::ReliefCarve) {
         PaintCtx::carve(self, carve);
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     /// A nested paint spliced in keeps its own clips under the host's: the scissors
     /// intersect, and the nested item's rounded clip wins over the host's.
     #[test]
     fn appended_items_keep_their_clips_under_the_hosts() {
         let r = |x: f32, y: f32, w: f32, h: f32| Rect { x, y, width: w, height: h };
         let mut nested = PaintCtx::new();
         nested.quad(r(0.0, 0.0, 5.0, 5.0), [1.0; 4]);
         nested.clip_rounded(r(10.0, 10.0, 40.0, 40.0), 6.0, |pc| pc.quad(r(12.0, 12.0, 5.0, 5.0), [1.0; 4]));
         let mut host = PaintCtx::new();
         host.clip(r(0.0, 0.0, 30.0, 30.0), |pc| pc.append_items(nested.finish().items));
         let items = host.finish().items;
         assert_eq!(items.len(), 2);
         assert_eq!(items[0].clip, Some(r(0.0, 0.0, 30.0, 30.0)), "an unclipped item takes the host's clip");
         assert_eq!(items[1].clip, Some(r(10.0, 10.0, 20.0, 20.0)), "the two scissors intersect");
         assert!(items[1].clip_rrect.is_some_and(|c| c[4] == 6.0), "its rounded clip survives");
     }
 
     /// The one flush control plate draws a face and a field that is all
     /// run — the edge every flush control wears — and no trough.
     #[test]
     fn an_inset_plate_is_a_field_that_is_all_run() {
         let rect = Rect { x: 10.0, y: 20.0, width: 120.0, height: 24.0 };
         let face = Material::face([0.2, 0.2, 0.25, 1.0]);
         for tint in [None, Some([1.0, 0.5, 0.0])] {
             let mut pc = PaintCtx::new();
             match tint {
                 Some(t) => pc.inset_plate_tinted(rect, (4.0, 4.0, 4.0, 4.0), face.as_ref(), 4.0, t),
                 None => pc.inset_plate(rect, (4.0, 4.0, 4.0, 4.0), face.as_ref(), 4.0),
             }
             let prims: Vec<Prim> = pc.finish().items.into_iter().map(|i| i.prim).collect();
             assert!(!prims.iter().any(|p| matches!(p, Prim::Trough { .. })), "{prims:?}");
             assert!(prims.iter().any(|p| matches!(p, Prim::Border { .. })), "the face");
             assert!(
                 prims.iter().any(|p| matches!(p, Prim::Field { rect: r, split, tint: t, .. } if *r == rect && *split <= rect.x - 100.0 && *t == tint)),
                 "{prims:?}"
             );
         }
     }
     use crate::scene::material::Frost;
 
     /// RFC Phase 7b: PlateSpec role mechanics — flag derivation from window
     /// geometry, silhouette-vs-nominal radii selection, and the role-encoded
     /// frost (root positive-alpha, nested negative-alpha sentinel).
     #[test]
     fn plate_spec_roles() {
         // Flags: a full-window rect is root; an inset pane has none; a pane
         // flush to the window's right edge owns the two right corners.
         let root_flags = PlateSpec::window_corner_flags(
             Rect { x: 0.0, y: 0.0, width: 800.0, height: 600.0 }, 800.0, 600.0);
         assert_eq!(root_flags, (true, true, true, true));
         let inset = PlateSpec::window_corner_flags(
             Rect { x: 20.0, y: 20.0, width: 100.0, height: 100.0 }, 800.0, 600.0);
         assert_eq!(inset, (false, false, false, false));
         let right_pane = PlateSpec::window_corner_flags(
             Rect { x: 500.0, y: 0.0, width: 300.0, height: 600.0 }, 800.0, 600.0);
         assert_eq!(right_pane, (false, true, true, false));
 
         // Radii: flagged corners wear the shared silhouette curve, interior
         // ones the nominal plate radius (compared against the same getters,
         // so the assertion holds for any configured values).
         let window_r =
             crate::layout::window_corner_radius() * crate::layout::corner_span_factor();
         let nominal = crate::layout::plate_corner_radius();
         let r = PlateSpec::radii_for((false, true, true, false));
         assert_eq!(r, (nominal, window_r, window_r, nominal));
 
         // Frost encoding by role.
         let frosted = Frost::Frosted { compression: 0.0, refraction: 0.0, radius: Frost::DEFAULT_RADIUS };
         let mut spec = PlateSpec {
             rect: Rect { x: 0.0, y: 0.0, width: 10.0, height: 10.0 },
             material: Material::opaque([0.1, 0.2, 0.3, 0.8]).with_frost(frosted),
             window_corners: (true, true, true, true),
             depth: 3.0,
         };
         assert!(spec.is_root());
         assert_eq!(spec.role(), PlateRole::Root);
         assert!(spec.fill()[3] > 0.0, "root frost is the compositor's; alpha stays positive");
         spec.window_corners = (false, true, true, false);
         assert!(!spec.is_root());
         assert_eq!(spec.role(), PlateRole::Nested);
         assert!(spec.fill()[3] < 0.0, "nested frost = negative-alpha sentinel");
         spec.material.frost = Frost::Unfrosted;
         assert_eq!(spec.fill()[3], 0.8, "no frost, no encoding");
 
         // The detach role flip (RFC 7c): a frosted nested pane becomes a
         // root — silhouette corners, and the frost regime flips from the
         // in-app sentinel to the compositor's (alpha back to positive).
         spec.material.frost = frosted;
         assert!(spec.fill()[3] < 0.0);
         let det = spec.detached();
         assert!(det.is_root());
         assert!(det.fill()[3] > 0.0, "root frost is the compositor's again");
         let wr = crate::layout::window_silhouette_radius();
         assert_eq!(det.radii(), (wr, wr, wr, wr));
     }
 
     fn r(x: f32, y: f32, w: f32, h: f32) -> Rect {
         Rect { x, y, width: w, height: h }
     }
 
     /// The emission round-trip: `plate_spec` pre-divides by the span factor so
     /// `plate_push_raised(scale_corners = true)` lands each corner at exactly
     /// the spec's final radius. Guards the double-span regression (7b-2), and
     /// holds for any configured corner_shape because both sides use the same
     /// factor.
     #[test]
     fn plate_spec_emission_round_trips_the_span() {
         let spec = PlateSpec {
             rect: r(0.0, 0.0, 400.0, 300.0),
             material: Material::opaque([0.1, 0.2, 0.3, 0.8]),
             window_corners: (true, true, false, false),
             depth: 4.0,
         };
         let mut pc = PaintCtx::new();
         pc.plate_spec(&spec);
         let f = crate::layout::corner_span_factor();
         let emitted = pc
             .finish()
             .items
             .iter()
             .find_map(|it| match &it.prim {
                 Prim::Plate { radii, .. } => Some(*radii),
                 _ => None,
             })
             .expect("plate_spec emits a Prim::Plate");
         let want = spec.radii();
         let got = (emitted.0 * f, emitted.1 * f, emitted.2 * f, emitted.3 * f);
         for (g, w) in [(got.0, want.0), (got.1, want.1), (got.2, want.2), (got.3, want.3)] {
             assert!((g - w).abs() < 1e-3, "span round-trip drifted: {g} vs {w}");
         }
     }
 
     #[test]
     fn emits_in_order_unclipped() {
         let mut ctx = PaintCtx::new();
         ctx.quad(r(0.0, 0.0, 10.0, 10.0), [1.0, 0.0, 0.0, 1.0]);
         ctx.quad(r(5.0, 5.0, 10.0, 10.0), [0.0, 1.0, 0.0, 1.0]);
         let list = ctx.finish();
         assert_eq!(list.len(), 2);
         assert_eq!(list.items[0].clip, None);
         assert!(matches!(list.items[0].prim, Prim::Quad { color, .. } if color[0] == 1.0));
         assert!(matches!(list.items[1].prim, Prim::Quad { color, .. } if color[1] == 1.0));
     }
 
     #[test]
     fn clip_is_recorded_and_popped() {
         let mut ctx = PaintCtx::new();
         ctx.clip(r(0.0, 0.0, 50.0, 50.0), |ctx| {
             ctx.quad(r(10.0, 10.0, 5.0, 5.0), [0.0; 4]);
         });
         ctx.quad(r(60.0, 60.0, 5.0, 5.0), [0.0; 4]); // outside any clip now
         let list = ctx.finish();
         assert_eq!(list.items[0].clip, Some(r(0.0, 0.0, 50.0, 50.0)));
         assert_eq!(list.items[1].clip, None, "clip popped after the closure");
     }
 
     #[test]
     fn nested_clips_intersect() {
         let mut ctx = PaintCtx::new();
         ctx.clip(r(0.0, 0.0, 100.0, 100.0), |ctx| {
             ctx.clip(r(50.0, 50.0, 100.0, 100.0), |ctx| {
                 ctx.quad(r(0.0, 0.0, 1.0, 1.0), [0.0; 4]);
             });
         });
         // Intersection of (0,0,100,100) and (50,50,100,100) = (50,50,50,50).
         assert_eq!(ctx.finish().items[0].clip, Some(r(50.0, 50.0, 50.0, 50.0)));
     }
 
     #[test]
     fn non_overlapping_clips_produce_empty_scissor() {
         let mut ctx = PaintCtx::new();
         ctx.clip(r(0.0, 0.0, 10.0, 10.0), |ctx| {
             ctx.clip(r(100.0, 100.0, 10.0, 10.0), |ctx| {
                 ctx.quad(r(0.0, 0.0, 1.0, 1.0), [0.0; 4]);
             });
         });
         let clip = ctx.finish().items[0].clip.unwrap();
         assert_eq!((clip.width, clip.height), (0.0, 0.0), "empty intersection");
     }
 
     #[test]
     fn translate_applies_to_coordinates_and_restores() {
         let mut ctx = PaintCtx::new();
         ctx.translate(100.0, 200.0, |ctx| {
             ctx.quad(r(0.0, 0.0, 5.0, 5.0), [0.0; 4]);
         });
         ctx.quad(r(0.0, 0.0, 5.0, 5.0), [0.0; 4]); // back at origin
         let list = ctx.finish();
         assert!(matches!(list.items[0].prim, Prim::Quad { rect, .. } if rect.x == 100.0 && rect.y == 200.0));
         assert!(matches!(list.items[1].prim, Prim::Quad { rect, .. } if rect.x == 0.0 && rect.y == 0.0));
     }
 
     #[test]
     fn nested_translate_is_cumulative() {
         let mut ctx = PaintCtx::new();
         ctx.translate(10.0, 10.0, |ctx| {
             ctx.translate(5.0, 5.0, |ctx| {
                 ctx.circle(0.0, 0.0, 3.0, [0.0; 4]);
             });
         });
         assert!(matches!(ctx.finish().items[0].prim, Prim::Circle { cx, cy, .. } if cx == 15.0 && cy == 15.0));
     }
 
     #[test]
     fn clip_pushed_under_translation_is_absolute() {
         let mut ctx = PaintCtx::new();
         ctx.translate(20.0, 20.0, |ctx| {
             ctx.clip(r(0.0, 0.0, 30.0, 30.0), |ctx| {
                 ctx.quad(r(0.0, 0.0, 5.0, 5.0), [0.0; 4]);
             });
         });
         let item = &ctx.finish().items[0];
         // Clip translated to absolute (20,20,30,30); prim likewise at (20,20).
         assert_eq!(item.clip, Some(r(20.0, 20.0, 30.0, 30.0)));
         assert!(matches!(item.prim, Prim::Quad { rect, .. } if rect.x == 20.0 && rect.y == 20.0));
     }
 
     #[test]
     fn all_primitive_kinds_emit() {
         let mut ctx = PaintCtx::new();
         ctx.quad(r(0.0, 0.0, 1.0, 1.0), [0.0; 4]);
         ctx.rounded_rect(r(0.0, 0.0, 1.0, 1.0), 2.0, (true, false, true, false), [0.0; 4]);
         ctx.border(r(0.0, 0.0, 10.0, 10.0), (2.0, 2.0, 2.0, 2.0), [0.1; 4], [0.9; 4], 1.5);
         ctx.bevel(r(0.0, 0.0, 10.0, 10.0), (2.0, 2.0, 2.0, 2.0), &Material::opaque([0.3; 4]), 2.0);
         ctx.arc(5.0, 5.0, 4.0, 1.0, 0.0, std::f32::consts::PI, [0.0; 4]);
         ctx.vector(0.0, 0.0, 10.0, 0.0, 1.0, [0.0; 4], Cap::Arrow);
         ctx.circle(5.0, 5.0, 3.0, [0.0; 4]);
         ctx.text("hi", 1.0, 2.0, 12.0, [255, 255, 255]);
         assert_eq!(ctx.finish().len(), 8);
     }
 
     #[test]
     fn border_and_bevel_are_offset() {
         let mut ctx = PaintCtx::new();
         ctx.translate(10.0, 20.0, |ctx| {
             ctx.border(r(0.0, 0.0, 5.0, 5.0), (1.0, 1.0, 1.0, 1.0), [0.0; 4], [1.0; 4], 1.0);
             ctx.bevel(r(0.0, 0.0, 5.0, 5.0), (1.0, 1.0, 1.0, 1.0), &Material::opaque([0.0; 4]), 1.0);
         });
         let list = ctx.finish();
         assert!(matches!(list.items[0].prim, Prim::Border { rect, .. } if rect.x == 10.0 && rect.y == 20.0));
         assert!(matches!(list.items[1].prim, Prim::Bevel { rect, .. } if rect.x == 10.0 && rect.y == 20.0));
     }
     #[test]
     fn text_with_translates_position_and_bounds() {
         let mut ctx = PaintCtx::new();
         ctx.translate(10.0, 20.0, |ctx| {
             ctx.text_with("hi", 1.0, 2.0, 12.0, [1, 2, 3], Some("Mono".into()), Some([0.0, 0.0, 50.0, 30.0]));
             ctx.text("plain", 3.0, 4.0, 10.0, [9, 9, 9]);
         });
         let list = ctx.finish();
         match &list.items[0].prim {
             Prim::Text { x, y, font, bounds, .. } => {
                 assert_eq!((*x, *y), (11.0, 22.0), "position translated");
                 assert_eq!(font.as_deref(), Some("Mono"));
                 assert_eq!(*bounds, Some([10.0, 20.0, 60.0, 50.0]), "bounds translated");
             }
             other => panic!("expected Text, got {other:?}"),
         }
         match &list.items[1].prim {
             Prim::Text { font, bounds, .. } => {
                 assert_eq!(*font, None, "plain text carries no font");
                 assert_eq!(*bounds, None);
             }
             other => panic!("expected Text, got {other:?}"),
         }
     }
 
 }