No placement leaves a pane shorter than its tag and two rows

Placement could split a pane down to a tag and one row, or give a new one
less. Every placement now checks the pane it made and each pane it shrank
against its tag (wrapped at its width) plus two rows: where they lack the
room, the column's tallest pane is halved instead, and where none can give
it the new pane is refused with "no space for a pane in that column"
(ENOSPC over 9P) and closed at the step's end, once its maker is done with
it. splitBelow and splitParent leave two body rows (a boot layout, split
before any row exists, is as before). Re-recorded by name: lookpanes (panes
one or two rows lower) and splitparent (the 6-row squeeze now refuses);
fs.py closes the scratches and long-named panes it no longer needs, since
its 24-row session filled.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

1 files changed, 54 insertions, 9 deletions

diff --git a/src/layout.zig b/src/layout.zig
index b9b24e79..4c974fb7 100644
--- a/src/layout.zig
+++ b/src/layout.zig
@@ -408,6 +408,46 @@ pub fn acmePlace(p: *Pardes, c: usize, origin: ?usize, id: usize) void {
     splitAt(p, c, id, y);
 }
 
+/// The body rows a placement leaves every pane it makes or shrinks, under
+/// its tag (acme's minht keeps one).
+pub const min_body_rows = 2;
+
+fn minRows(p: *Pardes, id: usize) u16 {
+    return p.wantedTagRows(id) + min_body_rows;
+}
+
+/// After placing `id`: whether it, and every pane of its column that the
+/// placement shrank, still has its tag and `min_body_rows` (from `before`,
+/// the rects as they were). A pane alone in its column always has room: the
+/// window can be no taller.
+pub fn placedRoomy(p: *Pardes, id: usize, before: *const [MAX_PANES]Rect) bool {
+    compute(p);
+    const f = findPane(p, id) orelse return true;
+    if (p.col_n[f.col] == 1) return true;
+    for (p.col_panes[f.col][0..p.col_n[f.col]]) |k| {
+        const pane = p.panes[k] orelse continue;
+        if (pane.collapsed) continue;
+        if (k != id and p.rects[k].h >= before[k].h) continue;
+        if (p.rects[k].h < minRows(p, k)) return false;
+    }
+    return true;
+}
+
+/// Places `id` in column `c` by halving its tallest unfolded pane, when
+/// that leaves both their rows; false, and `id` in no column, when not.
+pub fn splitTallest(p: *Pardes, c: usize, id: usize) bool {
+    compute(p);
+    var tall: ?usize = null;
+    for (p.col_panes[c][0..p.col_n[c]]) |k| {
+        if (k == id or p.panes[k].?.collapsed) continue;
+        if (tall == null or p.rects[k].h > p.rects[tall.?].h) tall = k;
+    }
+    const v = tall orelse return false;
+    if (p.rects[v].h < minRows(p, v) + minRows(p, id)) return false;
+    splitAt(p, c, id, p.rects[v].y + p.rects[v].h / 2);
+    return true;
+}
+
 /// acme's coladd at row `y` (cols.c:66-126): the new pane goes under the
 /// pane that `y` falls in, which keeps its rows above `y`.
 fn splitAt(p: *Pardes, c: usize, id: usize, y: u16) void {
@@ -419,9 +459,9 @@ fn splitAt(p: *Pardes, c: usize, id: usize, y: u16) void {
     snapColWeights(p, c);
     insert(p, c, k + 1, id);
     const pane = p.panes[id].?;
-    // Each keeps a tag and a body row, as acme's minht does.
-    const lo = r.y +| BOX_H + 1;
-    const hi = (r.y + r.h) -| (BOX_H + 1);
+    // Each keeps a tag and min_body_rows, where acme's minht keeps one.
+    const lo = r.y +| minRows(p, v);
+    const hi = (r.y + r.h) -| minRows(p, id);
     const row = splitRowForExtent(r.y, r.h, if (lo <= hi) std.math.clamp(y, lo, hi) else r.y + r.h / 2) orelse {
         pane.vweight = BOX_H + 1;
         return;
@@ -550,7 +590,7 @@ pub fn absorbVWeight(p: *Pardes, id: usize, to: ?usize) ?usize {
 }
 
 pub fn splitParent(p: *Pardes, want: usize) usize {
-    const need = 2 * BOX_H + 3;
+    const need = 2 * (BOX_H + min_body_rows);
     if (p.rects[want].h >= need) return want;
     if (findPane(p, want)) |f| for (0..p.col_n[f.col]) |k| {
         if (p.rects[p.col_panes[f.col][k]].h >= need) return p.col_panes[f.col][k];
@@ -567,23 +607,28 @@ pub fn splitParent(p: *Pardes, want: usize) usize {
 pub fn splitBelow(p: *Pardes, src_id: usize, nw: *Pane) void {
     const src = p.panes[src_id] orelse return;
     const src_h = p.rects[src_id].h;
-    const body: u16 = if (src_h > BOX_H) src_h - BOX_H else 1;
+    // Its tag may wrap to more than one row: the rows under it are its body.
+    const tag_h = @max(BOX_H, src.tag_rows);
+    const body: u16 = if (src_h > tag_h) src_h - tag_h else 1;
     const cur: u16 = if (!src.isTerminal()) body / 2 else panes.Terminal.gridCursor(src).y + 1;
     // cap keep so a content-full source still leaves the new pane a tag +
     // a few body rows (an Alt-n from a full shell was born 0 rows tall)
-    const keep = std.math.clamp(cur, 1, @max(1, body -| (BOX_H + 3)));
+    // ...and the source min_body_rows of its own (exec.placeNew), when it
+    // has them: a boot layout splits before any row is laid out.
+    const least = @min(min_body_rows, body);
+    const keep = std.math.clamp(cur, least, @max(least, body -| (BOX_H + 3)));
     if (findPane(p, src_id)) |f| for (0..p.col_n[f.col]) |k| {
         const pid = p.col_panes[f.col][k];
         if (p.panes[pid]) |pp| if (pp != nw and !pp.collapsed) {
             pp.vweight = @floatFromInt(@max(1, p.rects[pid].h));
         };
     };
-    if (!src.collapsed) src.vweight = @floatFromInt(BOX_H + keep);
-    nw.vweight = @floatFromInt(@max(1, src_h -| (BOX_H + keep)));
+    if (!src.collapsed) src.vweight = @floatFromInt(tag_h + keep);
+    nw.vweight = @floatFromInt(@max(1, src_h -| (tag_h + keep)));
     if (nw.file) |f| if (!panes.Output.fileTraits(f.output).doc) {
         // trimmed: every row ends in a newline, and the empty line after
         // the last one is not a result
-        const want: f32 = @floatFromInt(BOX_H + panes.File.lineCount(std.mem.trimEnd(u8, f.content, "\n")));
+        const want: f32 = @floatFromInt(BOX_H + @max(min_body_rows, panes.File.lineCount(std.mem.trimEnd(u8, f.content, "\n"))));
         if (want < nw.vweight) {
             src.vweight += nw.vweight - want;
             nw.vweight = want;