A Newcol refused because the panes' tags would not fit logs its err alone and spends no column serial

Newcol tries its column before keeping it: the new column is inserted,
the panes' rows are shared out again, and where a pane would be left
under its tag and two rows the column is taken back. The trial showed.
insertColumn logged `newcol N` and the take-back `delcol N`, so a
follower saw a column come and go around the err. Laying the column out
also gave it a serial, so the next column made skipped one. The trial is
now unannounced, since insert and drop have unlogged forms. A refusal puts
the serial counter back where it was, after first giving every existing
column its serial so the trial's is the only one spent. Only a column
that stays is logged, and it gets the next serial.

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

1 files changed, 42 insertions, 0 deletions

diff --git a/src/ninep/cols.zig b/src/ninep/cols.zig
index 454cce4a..f07c7f39 100644
--- a/src/ninep/cols.zig
+++ b/src/ninep/cols.zig
@@ -228,6 +228,48 @@ test "New written to a column's exec makes its scratch in the session's director
     try testing.expectEqualStrings("/project/src/+New", p.panes[p.active].?.file.?.path);
 }
 
+test "a Newcol refused because the tags would not fit logs its err alone and spends no column serial" {
+    const p = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 14 });
+    defer p.deinit();
+    while (p.nextEffect()) |_| {}
+    // Long tags wrap onto more rows as their column narrows: the boot's
+    // two panes share one, and each keeps its tag and two rows.
+    const made = try th.newPane(p);
+    const pane = p.panes[p.paneBySerial(made).?].?;
+    const col = layout.findPane(p, p.paneBySerial(made).?).?.col;
+    for (p.col_panes[col][0..p.col_n[col]]) |k| {
+        const each = p.panes[k].?;
+        if (each.tag.own) |old| p.gpa.free(old);
+        each.tag.own = try p.gpa.dupe(u8, "word " ** 60);
+    }
+    try testing.expect(p.col_n[col] >= 2);
+    p.sync();
+    const ctl = @intFromEnum(tree.TopFile.ctl);
+    const focus = @intFromEnum(tree.TopFile.focus);
+    var digits: [16]u8 = undefined;
+    const own = try std.fmt.bufPrint(&digits, "{d}\n", .{pane.serial});
+    var refused = false;
+    for (0..pardes.MAX_COLS) |_| {
+        // From the long tag's column, so it is the one split narrower.
+        _ = th.wr(p, focus, own);
+        const serial_before = p.next_column_serial;
+        const log_before = try pardes.ctlfs.events.freezeLog(p);
+        defer p.gpa.free(log_before.bytes);
+        const r = th.wr(p, ctl, "Newcol\n");
+        if (r.reply.status == .ok) continue;
+        if (std.mem.indexOf(u8, r.reply.ename, "tags would not fit") == null) continue;
+        refused = true;
+        try testing.expectEqual(serial_before, p.next_column_serial);
+        const log_after = try pardes.ctlfs.events.freezeLog(p);
+        defer p.gpa.free(log_after.bytes);
+        const added = log_after.bytes[log_before.bytes.len..];
+        try testing.expect(std.mem.startsWith(u8, added, "err "));
+        try testing.expectEqual(@as(usize, 1), std.mem.count(u8, added, "\n"));
+        break;
+    }
+    try testing.expect(refused);
+}
+
 test "a tagexec word that makes, acts on and focuses no pane reads back nothing" {
     const p = try th.withFile(testing.allocator, "x\n");
     defer p.deinit();