struct Color

From hue (turns, 0…1 and wrapping), saturation and lightness.

Here rather than at a call site because the useful thing about HSL is generating a family — a row of tints that vary in hue while holding saturation and lightness fixed, so they read as one set instead of as an argument. Doing that in RGB means picking every member by hand and getting the brightness subtly wrong on the ones near yellow.

lightness is in the same space as r/g/b: authored sRGB, the numbers a colour picker shows.

From hue (turns, 0…1), saturation and value — the square a colour picker draws. Distinct from hue:saturation:lightness:: value is the brightest channel, so the top-right of the square is the pure hue rather than a pastel, which is what the hand expects to land on.

Same authored sRGB as r/g/b. A picker that used linear components here would disagree with the hex it prints.

Reads #rgb, #rrggbb, #rrggbbaa, with or without the hash. Nil if the string is not one of those — including a half-typed field.

Fully transparent — draws nothing at all.

What a conditional background needs for its "neither" case. A row that is highlighted when selected and hovered has to fall back to no fill the rest of the time, and the nearest thing without this is the theme's own background painted over whatever the row actually sits on, which is right until the day something sits behind it.

#rrggbb when opaque, #rrggbbaa otherwise. The bytes a picker and a CSS author share.

Hue / saturation / value of these authored components.

Hue is undefined (and returned as 0) when the colour is grey. A picker that has to keep the strip still while the user drags through white should remember the last non-zero hue itself.

This colour with the sRGB curve removed — components proportional to light rather than to perceived brightness.

Needed wherever colours are multiplied rather than merely carried: a light times a surface, a fade times a fill. Doing that arithmetic on authored components is the classic error — it looks like a dimming that is simply too strong, because halving an encoded value takes far more than half the light out. See docs/colour-and-blending.md.

Not what to hand to the renderer: the wire format is authored sRGB and nothing downstream re-encodes. Convert back with fromLinear first. Alpha is a coverage fraction, not light, and is carried through.

Perceived brightness, 0…1 (Rec. 601 weights). For deciding whether a foreground drawn on this colour should be light or dark.

Packed 0x00RRGGBB, the compositor wallpaper spelling. Alpha is dropped on the way out and assumed opaque on the way in.

Pack as authored sRGB RGBA8 (R in the low byte). Carried through unchanged — do not pre-linearise here, or the colour arrives dark.

The inverse of linear: re-applies the sRGB curve, so the result can be packed and sent like any authored colour. Clamps, because lighting arithmetic overshoots and 8-bit packing has nowhere to put it.

Renderer overlay for a hover fill sitting on surface.

hover is a fill colour. The renderer paints this over the whole node, so alpha is capped: past ~0.40 the letters take the hover's hue and a row of light text on a dark chip turns muddy.

Moves toward white by amount (0…1), keeping alpha.

For deriving a hover or pressed variant from a semantic token, so a control does not have to hard-code a second colour that a theme swap would then fail to update.

Returns a copy with alpha replaced (0…1). Useful for glass tints on top of .blur().

Smallest source-over tint that turns a uniform base into this colour.

What the renderer needs for a hover chip: it paints the tint over the node, glyphs included, so the overlay has to carry as little alpha as will still land on self when composited with base.