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;