cli: the selection is a wash, and it covers the whole block

THE BAR IS GONE. A selected block wore a slim cyan bar in the left margin
AND a background lift; the bar said what the lift already said, in the
column the adornment's snake wants, and it was a second thing to keep
right at every width. The lift is the whole cue now, one step off the
pane for a block in range and one step further for the focused one,
which is what tells a reader where Enter, t and d will land.

AND IT COVERS THE BLOCK, not the half of it that is text. Chrome rows
carrying a block's ref are washed with it, the chrome BETWEEN washed rows
is washed, and the band closes over the rule that fences the box beneath
them: select a question and its heading, its text and the seam under it
lift together, which is what Gluck asked for and what a "selection" ought
to mean. It stops at the first row of a block that is not selected, so
the answer's voice header stays the answer's.

The wash moves into the palette (term.NodeWash) beside the visual
selection's, rather than living as a literal in the pager, and
firstVisible is now one scanner for "the row from its first painted
cell", shared by the gutter junctions and the band's rule test.

WITH COLOUR OFF THERE IS NO CUE. Deliberate: nothing else in the pager is
legible without colour either, and reverse video is a one-line change in
one place if anyone ever needs it.

TESTS. Two traps, both of which made assertions vacuous:

  - term.NodeWash answers "" when colour is off, and a test process is
    not a terminal, so `strings.Contains(row, term.NodeWash(...))` was
    TRUE FOR EVERY ROW. The washes are now read once with colour forced.
  - `tmux capture-pane -e` emits renditions as a RUNNING STATE across the
    whole capture, not per row: two washed rows share one sequence and
    the second, read alone, looks unwashed. That cost half an hour of
    hunting a paint bug that was not there (the emitted frame was
    correct, verified with pipe-pane). Per-row colour claims against a
    capture now go through capturedWashes, which tracks the background in
    force at each row's first cell.

The colour frame goldens were already stale on main (they only rebuild
under FORCE_COLOR); they are regenerated here along with the plain pair.

Author: gluck

internal/cli/adornment_pty_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/jack-work/figaro/api/rpc"
 	ldrender "github.com/jack-work/figaro/internal/livelog/render"
 	"github.com/jack-work/figaro/internal/tape"
+	"github.com/jack-work/figaro/internal/term"
 )
 
 // THE ADORNMENT, IN A REAL TERMINAL.
@@ -97,9 +98,9 @@ func adornSelectedMarker(t *testing.T, p *adornPane) {
 	// the last block, so prose is one step BACK from it.
 	p.key("Enter") // close what the previous case opened
 	p.key("C-p")
-	rows, styled := p.rows(), p.styled()
+	rows, wash := p.rows(), p.paneWashed()
 	i := p.only(t, rows, adornProseTail)
-	if !washed(styled[i]) {
+	if !wash[i] {
 		t.Fatalf("the prose block is not the selection:\n%s", p.dump())
 	}
 	if w := ldrender.Width(rows[i]); w != p.w || !strings.HasSuffix(rows[i], deltaGlyph) {
@@ -173,17 +174,17 @@ func adornInquiryOpens(t *testing.T, p *adornPane) {
 		t.Errorf("the rule under the list does not close on %q: %q", snakeClose, clean(rows[last+1]))
 	}
 
-	// The wash. The question's own text is selected and washed; the
-	// adornment's chrome row is not, and the head stays visible on it.
-	styled := p.styled()
-	if !washed(styled[p.only(t, styled, adornAsk)]) {
+	// The wash covers the whole selected block, chrome included, and the
+	// parked head stays visible on it.
+	wash := p.paneWashed()
+	if !wash[p.only(t, rows, adornAsk)] {
 		t.Errorf("the selected question is not washed\n%s", p.dump())
 	}
-	if washed(styled[anchor]) {
-		t.Errorf("the selection wash swallowed the adornment's chrome row: %q", clean(styled[anchor]))
+	if !wash[anchor] {
+		t.Errorf("the block's chrome row is not washed with the rest of it\n%s", p.dump())
 	}
-	if !strings.Contains(clean(styled[anchor]), deltaGlyph) {
-		t.Errorf("the parked head is gone from the chrome row: %q", clean(styled[anchor]))
+	if !strings.Contains(rows[anchor], deltaGlyph) {
+		t.Errorf("the parked head is gone from the chrome row: %q", rows[anchor])
 	}
 }
 
@@ -198,8 +199,8 @@ func adornRowsWalk(t *testing.T, p *adornPane) {
 
 	// Out of the list, onto the block below it, then back in from below.
 	p.key("C-n")
-	styled := p.styled()
-	if !washed(styled[p.only(t, styled, adornProseHead)]) {
+	wash := p.paneWashed()
+	if !wash[p.only(t, p.rows(), adornProseHead)] {
 		t.Fatalf("^N past the last row did not select the block below\n%s", p.dump())
 	}
 	p.key("C-p")
@@ -209,13 +210,13 @@ func adornRowsWalk(t *testing.T, p *adornPane) {
 	p.key("C-p")
 	adornFocus(t, p, adornAskKeys[0], "stepping up inside the list")
 	p.key("C-p")
-	styled = p.styled()
-	if !washed(styled[p.only(t, styled, adornAsk)]) {
+	wash, rows := p.paneWashed(), p.rows()
+	if !wash[p.only(t, rows, adornAsk)] {
 		t.Errorf("^P past the first row did not select the parent block\n%s", p.dump())
 	}
 	for _, key := range adornAskKeys {
-		if row := styled[p.only(t, styled, key)]; washed(row) {
-			t.Errorf("the parent's wash reached delta row %q: %q", key, clean(row))
+		if i := p.only(t, rows, key); wash[i] {
+			t.Errorf("the parent's wash reached delta row %q: %q", key, clean(rows[i]))
 		}
 	}
 }
@@ -232,8 +233,7 @@ func adornCloseLands(t *testing.T, p *adornPane) {
 			t.Errorf("Enter left the row for %q on screen\n%s", key, p.dump())
 		}
 	}
-	styled := p.styled()
-	if !washed(styled[p.only(t, styled, adornAsk)]) {
+	if !p.paneWashed()[p.only(t, rows, adornAsk)] {
 		t.Errorf("after closing, the question is not the selection\n%s", p.dump())
 	}
 }
@@ -267,10 +267,10 @@ func adornToolSnake(t *testing.T, p *adornPane) {
 	adornFocus(t, p, adornToolKeys[0], "the tool's first row")
 
 	// The head is drawn INTO the washed row, and the wash does not eat it.
-	styled := p.styled()
-	row := styled[p.only(t, styled, adornToolKeys[0])]
-	if !washed(row) || !strings.Contains(row, deltaGlyph) {
-		t.Errorf("the focused row lost its head or its wash: %q", clean(row))
+	rows = p.rows()
+	i := p.only(t, rows, adornToolKeys[0])
+	if !p.paneWashed()[i] || !strings.Contains(rows[i], deltaGlyph) {
+		t.Errorf("the focused row lost its head or its wash: %q", rows[i])
 	}
 
 	p.key("C-p")   // back to the block
@@ -307,18 +307,18 @@ func adornBodyAndList(t *testing.T, p *adornPane) {
 // the snake's head in its spine column, and alone in both.
 func adornFocus(t *testing.T, p *adornPane, key, what string) {
 	t.Helper()
-	styled, plain := p.styled(), p.rows()
-	i := p.only(t, styled, key)
-	if !washed(styled[i]) {
+	wash, plain := p.paneWashed(), p.rows()
+	i := p.only(t, plain, key)
+	if !wash[i] {
 		t.Errorf("%s: the row for %q is not the focus\n%s", what, key, p.dump())
 		return
 	}
 	if !strings.Contains(plain[i], deltaGlyph) {
 		t.Errorf("%s: the row for %q carries no head: %q", what, key, plain[i])
 	}
-	for j, row := range styled {
-		if j != i && washed(row) && strings.Contains(clean(row), "->") {
-			t.Errorf("%s: row %d is a washed delta row too: %q", what, j, clean(row))
+	for j, row := range plain {
+		if j != i && wash[j] && strings.Contains(row, "->") {
+			t.Errorf("%s: row %d is a washed delta row too: %q", what, j, row)
 		}
 	}
 }
@@ -532,8 +532,83 @@ func countGlyph(rows []string, glyph string) int {
 	return n
 }
 
-// washed reports the selection lift, by the very constant the pager paints.
-func washed(row string) bool { return strings.Contains(row, selBg) }
+// nodeWashes are the two selection washes as the palette spells them, read
+// once with colour forced: a test process is not a terminal, so asking term
+// in the moment would answer "" and match every row ever painted.
+var nodeWashes = func() []string {
+	defer term.SetColorMode(term.ColorAlways)()
+	return []string{term.NodeWash(false), term.NodeWash(true)}
+}()
+
+// washed reports the selection lift on a row the PAINTER produced, which
+// carries its own renditions from column zero.
+func washed(row string) bool {
+	return strings.Contains(row, nodeWashes[0]) || strings.Contains(row, nodeWashes[1])
+}
+
+// A TMUX CAPTURE IS A RUNNING STATE, NOT A ROW AT A TIME RENDERING.
+// `capture-pane -e` emits an escape only where the attributes CHANGE, and it
+// carries them ACROSS line boundaries: two washed rows in a row share one
+// sequence, and the second, read on its own, looks unwashed. That is how a
+// correct frame was read as a bug for half an hour. Every per-row colour claim
+// against a capture goes through paneWashed, which tracks the background in
+// force at each row's first cell from the top of the capture.
+func (p *adornPane) paneWashed() []bool { return capturedWashes(p.last) }
+
+func capturedWashes(capture string) []bool {
+	var out []bool
+	bg := ""
+	for _, line := range splitPane(capture) {
+		at, seen := bg, false
+		for i := 0; i < len(line); {
+			if line[i] != 0x1b {
+				if !seen {
+					at, seen = bg, true
+				}
+				i++
+				continue
+			}
+			j := i + 1
+			for j < len(line) && !(line[j] >= 'A' && line[j] <= 'Z' || line[j] >= 'a' && line[j] <= 'z') {
+				j++
+			}
+			if j < len(line) {
+				j++
+			}
+			bg = applyBackground(bg, line[i:j])
+			i = j
+		}
+		if !seen {
+			at = bg
+		}
+		out = append(out, at == nodeWashes[0] || at == nodeWashes[1])
+	}
+	return out
+}
+
+// applyBackground folds one escape into the background in force, spelling it
+// the way the palette does so the two can be compared.
+func applyBackground(bg, esc string) string {
+	if !strings.HasSuffix(esc, "m") {
+		return bg
+	}
+	params := strings.Split(strings.TrimSuffix(strings.TrimPrefix(esc, "\x1b["), "m"), ";")
+	for i := 0; i < len(params); i++ {
+		switch params[i] {
+		case "", "0", "49":
+			bg = ""
+		case "48":
+			if i+2 < len(params) && params[i+1] == "5" {
+				bg = "\x1b[48;5;" + params[i+2] + "m"
+				i += 2
+			} else if i+4 < len(params) && params[i+1] == "2" {
+				bg = "\x1b[48;2;" + strings.Join(params[i+2:i+5], ";") + "m"
+				i += 4
+			}
+		}
+	}
+	return bg
+}
 
 // clean is a captured row with its renditions dropped.
 func clean(row string) string { return visibleText(row) }

internal/cli/adornment_test.go

@@ -395,11 +395,13 @@ func TestDeltaKeyIsTheHalfPageScroll(t *testing.T) {
 	}
 }
 
-// THE WASH STOPS AT THE ADORNMENT'S CHROME. The blank row between a question
-// and its rows belongs to the block's coordinate (the snake stands in it) but
-// is none of its content, and washing it read as a selection one row taller
-// than it was.
-func TestWashSkipsTheAdornmentChrome(t *testing.T) {
+// THE WASH COVERS THE WHOLE BLOCK, chrome included. The blank row between a
+// question and its delta rows carries the block's coordinate but none of its
+// content; it used to be left unwashed, which cut a hole in the band. Gluck
+// asked for a selection that is defined at every space it covers, so the hole
+// is gone: the cue is one continuous lift, and the snake's head remains the
+// thing that says which row inside it the cursor is on.
+func TestWashCoversTheBlocksChrome(t *testing.T) {
 	defer term.SetColorMode(term.ColorAlways)()
 	tr := adornFixture(t)
 	inq := nodeRef{turn: 1, index: inquiryNode}
@@ -422,17 +424,15 @@ func TestWashSkipsTheAdornmentChrome(t *testing.T) {
 	if text == "" || chrome == "" {
 		t.Fatal("fixture: the question must have a text row and an adornment chrome row")
 	}
-	if !strings.Contains(text, selBg) {
-		t.Fatalf("the question's own row is washed: %q", text)
-	}
-	if strings.Contains(chrome, selBg) {
-		t.Fatalf("the adornment's chrome row must not be washed: %q", chrome)
+	for _, row := range []string{text, chrome} {
+		if !washed(row) {
+			t.Fatalf("every row of the selected block is washed: %q", row)
+		}
 	}
 }
 
 // A DELTA ROW KEEPS ITS SNAKE UNDER THE WASH, and keeps its own colour: the
-// head is how a reader tells which row of a washed list is the focused one,
-// and the bar cannot stand in that column as well.
+// head is how a reader tells which row of a washed list the cursor is on.
 func TestWashedDeltaRowKeepsItsSnake(t *testing.T) {
 	defer term.SetColorMode(term.ColorAlways)()
 	tr := adornFixture(t)
@@ -448,16 +448,13 @@ func TestWashedDeltaRowKeepsItsSnake(t *testing.T) {
 				continue
 			}
 			line := tr.rowLine(r, "", tr.selectionSpan())
-			if !strings.Contains(line, selBg) {
+			if !washed(line) {
 				t.Fatalf("a selected delta row is washed: %q", line)
 			}
 			plain := stripANSI(line)
 			if !strings.Contains(plain, deltaGlyph) {
 				t.Fatalf("the snake's head survives the wash: %q", plain)
 			}
-			if strings.Contains(plain, "▎") {
-				t.Fatalf("the bar must not stand where the snake does: %q", plain)
-			}
 			return
 		}
 	}

internal/cli/command_listen_test.go

@@ -197,7 +197,6 @@ func TestOverlaySpecIsOnePositional(t *testing.T) {
 	}
 }
 
-
 // AND THE BOX'S DOOR IS OPENED. commandFork is driven with one ':' line, and
 // what is asserted is the REQUEST a daemon receives: the trunk, the turn and
 // the dressing the plan carried. Nothing here compares a parser with itself.

internal/cli/escape_selection_test.go

@@ -1,8 +1,9 @@
 package cli
 
 import (
-	"strings"
 	"testing"
+
+	"github.com/jack-work/figaro/internal/term"
 )
 
 // ---------------------------------------------------------------------------
@@ -26,21 +27,22 @@ import (
 // the user complained about (no cue in the painted frame).
 // ---------------------------------------------------------------------------
 
-// cueRows counts painted rows carrying the selection gutter bar. It reads the
-// frame the terminal is actually holding (t.prev), not the model, because the
-// bug was invisible in the model: t.selection was already empty.
+// cueRows counts painted rows carrying the selection wash. It reads the frame
+// the terminal is actually holding (t.prev), not the model, because the bug
+// was invisible in the model: t.selection was already empty.
 func cueRows(rows []string) int {
 	n := 0
 	for _, r := range rows {
-		if strings.Contains(r, "▎") {
+		if washed(r) {
 			n++
 		}
 	}
 	return n
 }
 
 func TestEscapeClearsSelectionCueOnNextFrame(t *testing.T) {
-	p := newInputProbe(t, true) // pager up: mouse reporting on, Esc bound
+	defer term.SetColorMode(term.ColorAlways)() // the cue IS the wash
+	p := newInputProbe(t, true)                 // pager up: mouse reporting on, Esc bound
 
 	// Ctrl-N selects the first node.
 	feed(t, p.in, "\x0e")

internal/cli/testdata/transcript_frames.golden

@@ -35,19 +35,19 @@
 "\x1b[2m────────────────────────────────────────────────\x1b[0m"
 "< figaro"
 ""
-"▎ │ \x1b[38;5;252mweighing the\x1b[m\x1b[38;5;252m options and a second line    \x1b[m"
-""
-"▎ \x1b[38;5;252mThe quick brown fox jumps over the lazy dog,\x1b[m\x1b[38;5;252m  \x1b[m"
-"▎ \x1b[38;5;252mrepeatedly and at length, past the right\x1b[m\x1b[38;5;252m      \x1b[m"
-"▎ \x1b[38;5;252mmargin.\x1b[m\x1b[38;5;252m                                       \x1b[m"
-"▎ \x1b[38;5;252m \x1b[m\x1b[38;5;252m                                             \x1b[m"
-"▎ \x1b[38;5;252m日本語のテキストもここにあります。\x1b[m\x1b[38;5;252m            \x1b[m"
-""
-"▎✓ $ ls -la ⏎"
-"▎ │ alpha"
-"▎ │ beta tabbed"
-"▎ │ gamma 日本語"
-"▎ │ wide wide wide wide wide wide wide wide wid…\x1b[0m"
+"  │ \x1b[38;5;252mweighing the\x1b[m\x1b[38;5;252m options and a second line    \x1b[m"
+""
+"  \x1b[38;5;252mThe quick brown fox jumps over the lazy dog,\x1b[m\x1b[38;5;252m  \x1b[m"
+"  \x1b[38;5;252mrepeatedly and at length, past the right\x1b[m\x1b[38;5;252m      \x1b[m"
+"  \x1b[38;5;252mmargin.\x1b[m\x1b[38;5;252m                                       \x1b[m"
+"  \x1b[38;5;252m \x1b[m\x1b[38;5;252m                                             \x1b[m"
+"  \x1b[38;5;252m日本語のテキストもここにあります。\x1b[m\x1b[38;5;252m            \x1b[m"
+""
+"✓ $ ls -la ⏎"
+"  │ alpha"
+"  │ beta tabbed"
+"  │ gamma 日本語"
+"  │ wide wide wide wide wide wide wide wide wid…\x1b[0m"
 ""
 "  \x1b[38;5;252mdone.\x1b[m\x1b[38;5;252m                                         \x1b[m"
 ## highlighted