The GUI draws in tiers from the regions; pane chrome moves with its pane

Stage 8 of docs/render-pipeline.md. The frame is drawn in groups: tier 0,
one per track in paint order (tiers 2 and 3), tier 4 (notices, then guides
and the debug box), tier 5 (bar cursors), each cells, images, decor. Decor
(rules, rails, thumbs, grip marks, spines, the workspace and column rules,
the bottom band, notice rules, bar cursors) is whole-pixel rects through
the new decor.frag over ui.vert, so it carries its track's transition and
clip. A closing pane's chrome comes from Surface.previous_regions.

Deleted: taglineBaseRgb, topbarPaneBorderHeight, bottomTaglinePresent,
frameChromeBg, cellBackgroundIs and the rail inference, paneGripCell's
scan, transient_on, PaintPlan. One cover map (coverFrame) is marked from
the layers and regions once a frame. New regions column, guide and debug;
Surface.chrome is the palette, carried in wire v8 (not shipped yet), so an
attached GUI draws the same chrome (test). A per-instance clip replaces the
vertical transition's scissor.

Goldens: 01-12 byte-identical. 13-17 differ only past the grid: the image
pass left its scissor at the grid's size, cutting rule ends, rail feet and
the bottom band in the leftover pixels whenever a picture was on screen.
16-debug now shows the debug box, which a context-row layer had hidden.
18-mid-transition is new: virtual clock (PARDES_TEST_CLOCK in the GUI),
PanelSlide Newcol with the picture, frame 6 of 12.

Also: the GUI sleeps when idle instead of polling every 16 ms, and a
minimized or occluded window sleeps through animation. Tracy 'gui frame
build' at 200x60: 992/1015 us median before, 989/987 us after.

Shared files touched: pardes.zig (one export), detached/client.zig,
detached/server.zig, detached/wire.zig (all additive), gui.zig. Not touched:
Messages.zig, mouse.zig, tagline.zig, colors.zig, tty.zig, host_io.zig,
dump.zig, exec.zig, panes.zig.

1 files changed, 39 insertions, 1 deletions

diff --git a/src/surface.zig b/src/surface.zig
index db7dd468..07b593b1 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -344,6 +344,13 @@ pub const Region = struct {
         column_grip,
         column_tag,
         workspace_tag,
+        /// A column below the workspace tag, its bar and panes: its left
+        /// edge is the spine a pixel shell rules down it.
+        column,
+        /// A drag's guide or a seam's hover hint, drawn over the panes.
+        guide,
+        /// The debug stats box, drawn over the panes.
+        debug,
     };
     pub const none = std.math.maxInt(u8);
 
@@ -368,7 +375,30 @@ pub const Region = struct {
     clip: u16 = 0,
 };
 
-pub const MAX_REGIONS = 1 + MAX_PANES * (4 + panes.Pane.Notices.max) + pardes.MAX_COLS * 2 + 1;
+/// Guides a frame can draw: a run of a column-move rail per pane it skips
+/// the tags of, and a handful of border and hover dashes.
+pub const MAX_GUIDES = MAX_PANES + 4;
+pub const MAX_REGIONS = 1 + MAX_PANES * (4 + panes.Pane.Notices.max) + pardes.MAX_COLS * 3 + 1 + MAX_GUIDES + 1;
+
+/// The colours a pixel shell draws its chrome in (rules, rails, grips, the
+/// tag underlay), resolved by the core each frame, so a frontend attached
+/// to a detached session draws them from the frame alone.
+pub const Chrome = struct {
+    /// The theme's ground and ink; null where it leaves them to the shell.
+    page: ?[3]u8 = null,
+    fg: ?[3]u8 = null,
+    /// Rules and column spines.
+    border: [3]u8 = .{ 0, 0, 0 },
+    /// The rule under the workspace tag.
+    topbar_rule: [3]u8 = .{ 0, 0, 0 },
+    tag_bg: [3]u8 = .{ 0, 0, 0 },
+    /// The focused pane's and column's tag underlay: `tag_bg` unless
+    /// FocusTint is on.
+    tag_focus_bg: [3]u8 = .{ 0, 0, 0 },
+    tag_fg: [3]u8 = .{ 0, 0, 0 },
+    scroll_track: [3]u8 = .{ 0, 0, 0 },
+    scroll_thumb: [3]u8 = .{ 0, 0, 0 },
+};
 
 /// The canonical interface: what a frame of pardes IS. The tty shell writes
 /// these cells to vaxis one-to-one; the SDL shells rasterize them.
@@ -385,6 +415,7 @@ pub const Surface = struct {
     rows: u16 = 0,
     regions: [MAX_REGIONS]Region = undefined,
     nregions: u16 = 0,
+    chrome: Chrome = .{},
     cells: []Cell = &.{},
     /// bar: draw an insert-style thin cursor instead of the block
     cursor: ?struct { x: u16, y: u16, bar: bool = false } = null,
@@ -395,6 +426,7 @@ pub const Surface = struct {
     previous_cells: []const Cell = &.{},
     previous_body_layers: []const Layer = &.{},
     previous_tag_layers: []const Layer = &.{},
+    previous_regions: []const Region = &.{},
     cell_diffs: []const PanelCellDiff = &.{},
 
     pub fn tagLayers(s: *const Surface) []const Layer {
@@ -409,6 +441,12 @@ pub const Surface = struct {
         return s.regions[0..s.nregions];
     }
 
+    pub fn addRegion(s: *Surface, r: Region) void {
+        std.debug.assert(s.nregions < s.regions.len);
+        s.regions[s.nregions] = r;
+        s.nregions += 1;
+    }
+
     /// The first part of `kind` that `owner` has: its tag, its rail.
     pub fn region(s: *Surface, kind: Region.Kind, owner: usize) ?*Region {
         for (s.regions[0..s.nregions]) |*r| if (r.kind == kind and r.owner == owner) return r;