af961c3 fix(panes): address split pane review findings · vev

M internal/usecase/daemon/attention_test.go +27 -29


@@ -15,7 +15,6 @@ import (
15	15		portsmocks "github.com/bnema/vev/internal/ports/mocks"
16	16		"github.com/bnema/vev/internal/usecase/keys"
17	17		"github.com/bnema/vev/pkg/renderer"
18		-	"github.com/bnema/vev/pkg/vt"
19	18		)
20	19
21	20		func TestNoteAttentionFlagsBackgroundTab(t *testing.T) {

@@ -68,7 +67,7 @@ func TestPTYReaderBellMarksBackgroundTab(t *testing.T) {
68	67		sess.active = 0
69	68
70	69		d.sessWg.Add(1)
71		-	go d.ptyReader(sess, sess.tabs[1])
	70	+	go d.ptyReader(sess, sess.tabs[1], sess.tabs[1].focusedPane())
72	71
73	72		require.Eventually(t, func() bool {
74	73		sess.mu.Lock()

@@ -104,7 +103,11 @@ func TestNoteAttentionDoesNotBlockOnWedgedOtherClient(t *testing.T) {
104	103		acW := &attachedClient{tr: trW, rend: renderer.New(renderer.Capabilities{}), size: domain.Size{Cols: 80, Rows: 24}}
105	104		sctxW, cancelW := context.WithCancel(d.serveCtx)
106	105		t.Cleanup(cancelW)
107		-	tabW := &tab{screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctxW, cancel: cancelW}
	106	+	tabW := newTab(newScriptPTY(nil), domain.Size{Cols: 80, Rows: 23})
	107	+	tabW.ctx, tabW.cancel = sctxW, cancelW
	108	+	for _, pane := range tabW.panes {
	109	+	pane.ctx, pane.cancel = sctxW, cancelW
	110	+	}
108	111		sessW := &session{id: "wedged", name: "wedged", ctx: sctxW, cancel: cancelW, tabs: []*tab{tabW}, client: acW}
109	112		acW.setSession(sessW)
110	113		acW.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: acW})

@@ -270,7 +273,7 @@ func TestAnimationRepaintConfinedToBarRows(t *testing.T) {
270	273		defer releases[0]()
271	274		defer releases[1]()
272	275		sess.active = 0
273		-	sess.tabs[0].screen.Write([]byte("MIDSCREENMARKER"))
	276	+	sess.tabs[0].focusedPane().screen.Write([]byte("MIDSCREENMARKER"))
274	277		sess.mu.Lock()
275	278		sess.tabs[1].attention = true
276	279		sess.tabs[1].attentionAt = time.Unix(1, 0)

@@ -315,12 +318,12 @@ func TestComposeClientFrameWithStateAttentionFrameChangeDamagesOnlyBars(t *testi
315	318		bars := d.barStateFor(sess, "")
316	319		_, damage := composeClientFrameWithState(bars, tb, true, &cache)
317	320		require.Equal(t, []renderer.Damage{renderer.FullRedraw()}, damage)
318		-	tb.screen.ClearDamage()
	321	+	tb.focusedPane().screen.ClearDamage()
319	322
320	323		bars.attentionFrame++
321	324		_, damage = composeClientFrameWithState(bars, tb, false, &cache)
322	325		require.NotEmpty(t, damage)
323		-	lastRow := tb.screen.Frame.Height + 1
	326	+	lastRow := tb.focusedPane().screen.Frame.Height + 1
324	327		for _, dmg := range damage {
325	328		require.Contains(t, []int{0, lastRow}, dmg.Y, "expected damage confined to bar rows, got y=%d", dmg.Y)
326	329		}

@@ -351,7 +354,11 @@ func TestCloseRingingTabRefreshesOtherSessionBottomBar(t *testing.T) {
351	354		acB := &attachedClient{tr: trB, rend: renderer.New(renderer.Capabilities{}), size: domain.Size{Cols: 80, Rows: 24}}
352	355		sctxB, cancelB := context.WithCancel(d.serveCtx)
353	356		t.Cleanup(cancelB)
354		-	tbB := &tab{pty: pB, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctxB, cancel: cancelB}
	357	+	tbB := newTab(pB, domain.Size{Cols: 80, Rows: 23})
	358	+	tbB.ctx, tbB.cancel = sctxB, cancelB
	359	+	for _, pane := range tbB.panes {
	360	+	pane.ctx, pane.cancel = sctxB, cancelB
	361	+	}
355	362		sessB := &session{id: "sessB", name: "other", ctx: sctxB, cancel: cancelB, tabs: []*tab{tbB}, client: acB}
356	363		acB.setSession(sessB)
357	364		acB.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: acB})

@@ -397,33 +404,24 @@ func TestJumpAttentionCrossesSessionsWhenNoLocalBells(t *testing.T) {
397	404		d, sess1, ac, sends := newManualSessionWithPTYs(t, p1)
398	405		sctx2, cancel2 := context.WithCancel(d.serveCtx)
399	406		defer cancel2()
	407	+	tab2a := newTab(p2, domain.Size{Cols: 80, Rows: 23})
	408	+	tab2b := newTab(p3, domain.Size{Cols: 80, Rows: 23})
	409	+	for _, tb := range []*tab{tab2a, tab2b} {
	410	+	tb.ctx, tb.cancel = sctx2, cancel2
	411	+	for _, pane := range tb.panes {
	412	+	pane.ctx, pane.cancel = sctx2, cancel2
	413	+	}
	414	+	}
	415	+	tab2a.attention = true
	416	+	tab2a.attentionAt = time.Unix(9, 0)
	417	+	tab2b.attention = true
	418	+	tab2b.attentionAt = time.Unix(5, 0)
400	419		sess2 := &session{
401	420		id: "other",
402	421		name: "other",
403	422		ctx: sctx2,
404	423		cancel: cancel2,
405		-	tabs: []*tab{
406		-	{
407		-	pty: p2,
408		-	screen: vt.NewScreen(80, 23),
409		-	dirty: make(chan struct{}, 1),
410		-	size: domain.Size{Cols: 80, Rows: 23},
411		-	ctx: sctx2,
412		-	cancel: cancel2,
413		-	attention: true,
414		-	attentionAt: time.Unix(9, 0),
415		-	},
416		-	{
417		-	pty: p3,
418		-	screen: vt.NewScreen(80, 23),
419		-	dirty: make(chan struct{}, 1),
420		-	size: domain.Size{Cols: 80, Rows: 23},
421		-	ctx: sctx2,
422		-	cancel: cancel2,
423		-	attention: true,
424		-	attentionAt: time.Unix(5, 0),
425		-	},
426		-	},
	424	+	tabs: []*tab{tab2a, tab2b},
427	425		}
428	426		d.sessions[sess2.id] = sess2
429	427

 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/pkg/renderer"
-	"github.com/bnema/vev/pkg/vt"
 )
 func TestNoteAttentionFlagsBackgroundTab(t *testing.T) {
 	sess.active = 0
 	d.sessWg.Add(1)
-	go d.ptyReader(sess, sess.tabs[1])
+	go d.ptyReader(sess, sess.tabs[1], sess.tabs[1].focusedPane())
 	require.Eventually(t, func() bool {
 		sess.mu.Lock()
 	acW := &attachedClient{tr: trW, rend: renderer.New(renderer.Capabilities{}), size: domain.Size{Cols: 80, Rows: 24}}
 	sctxW, cancelW := context.WithCancel(d.serveCtx)
 	t.Cleanup(cancelW)
-	tabW := &tab{screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctxW, cancel: cancelW}
+	tabW := newTab(newScriptPTY(nil), domain.Size{Cols: 80, Rows: 23})
+	tabW.ctx, tabW.cancel = sctxW, cancelW
+	for _, pane := range tabW.panes {
+		pane.ctx, pane.cancel = sctxW, cancelW
+	}
 	sessW := &session{id: "wedged", name: "wedged", ctx: sctxW, cancel: cancelW, tabs: []*tab{tabW}, client: acW}
 	acW.setSession(sessW)
 	acW.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: acW})
 	defer releases[0]()
 	defer releases[1]()
 	sess.active = 0
-	sess.tabs[0].screen.Write([]byte("MIDSCREENMARKER"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("MIDSCREENMARKER"))
 	sess.mu.Lock()
 	sess.tabs[1].attention = true
 	sess.tabs[1].attentionAt = time.Unix(1, 0)
 	bars := d.barStateFor(sess, "")
 	_, damage := composeClientFrameWithState(bars, tb, true, &cache)
 	require.Equal(t, []renderer.Damage{renderer.FullRedraw()}, damage)
-	tb.screen.ClearDamage()
+	tb.focusedPane().screen.ClearDamage()
 	bars.attentionFrame++
 	_, damage = composeClientFrameWithState(bars, tb, false, &cache)
 	require.NotEmpty(t, damage)
-	lastRow := tb.screen.Frame.Height + 1
+	lastRow := tb.focusedPane().screen.Frame.Height + 1
 	for _, dmg := range damage {
 		require.Contains(t, []int{0, lastRow}, dmg.Y, "expected damage confined to bar rows, got y=%d", dmg.Y)
 	}
 	acB := &attachedClient{tr: trB, rend: renderer.New(renderer.Capabilities{}), size: domain.Size{Cols: 80, Rows: 24}}
 	sctxB, cancelB := context.WithCancel(d.serveCtx)
 	t.Cleanup(cancelB)
-	tbB := &tab{pty: pB, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctxB, cancel: cancelB}
+	tbB := newTab(pB, domain.Size{Cols: 80, Rows: 23})
+	tbB.ctx, tbB.cancel = sctxB, cancelB
+	for _, pane := range tbB.panes {
+		pane.ctx, pane.cancel = sctxB, cancelB
+	}
 	sessB := &session{id: "sessB", name: "other", ctx: sctxB, cancel: cancelB, tabs: []*tab{tbB}, client: acB}
 	acB.setSession(sessB)
 	acB.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: acB})
 	d, sess1, ac, sends := newManualSessionWithPTYs(t, p1)
 	sctx2, cancel2 := context.WithCancel(d.serveCtx)
 	defer cancel2()
+	tab2a := newTab(p2, domain.Size{Cols: 80, Rows: 23})
+	tab2b := newTab(p3, domain.Size{Cols: 80, Rows: 23})
+	for _, tb := range []*tab{tab2a, tab2b} {
+		tb.ctx, tb.cancel = sctx2, cancel2
+		for _, pane := range tb.panes {
+			pane.ctx, pane.cancel = sctx2, cancel2
+		}
+	}
+	tab2a.attention = true
+	tab2a.attentionAt = time.Unix(9, 0)
+	tab2b.attention = true
+	tab2b.attentionAt = time.Unix(5, 0)
 	sess2 := &session{
 		id:     "other",
 		name:   "other",
 		ctx:    sctx2,
 		cancel: cancel2,
-		tabs: []*tab{
+		tabs:   []*tab{tab2a, tab2b},
-			{
-				pty:         p2,
-				screen:      vt.NewScreen(80, 23),
-				dirty:       make(chan struct{}, 1),
-				size:        domain.Size{Cols: 80, Rows: 23},
-				ctx:         sctx2,
-				cancel:      cancel2,
-				attention:   true,
-				attentionAt: time.Unix(9, 0),
-			},
-			{
-				pty:         p3,
-				screen:      vt.NewScreen(80, 23),
-				dirty:       make(chan struct{}, 1),
-				size:        domain.Size{Cols: 80, Rows: 23},
-				ctx:         sctx2,
-				cancel:      cancel2,
-				attention:   true,
-				attentionAt: time.Unix(5, 0),
-			},
-		},
 	}
 	d.sessions[sess2.id] = sess2

M internal/usecase/daemon/client.go +1 -14


@@ -449,20 +449,7 @@ func (d Daemon) resize(sess session, ac *attachedClient, sz domain.Size) {
449	449		for _, tb := range tabs {
450	450		tb.mu.Lock()
451	451		tb.size = tbSize
452		-	if tb.tree == nil {
453		-	p := tb.focusedPane()
454		-	if p != nil {
455		-	if err := p.pty.Resize(tbSize); err != nil {
456		-	d.log.Warn("pty resize failed", "err", err, "session", sess.name)
457		-	}
458		-	p.mu.Lock()
459		-	p.screen.Resize(tbSize.Cols, tbSize.Rows)
460		-	p.rect = domain.Rect{Width: tbSize.Cols, Height: tbSize.Rows}
461		-	p.mu.Unlock()
462		-	}
463		-	} else {
464		-	d.applyLayoutLocked(tb)
465		-	}
	452	+	d.applyLayoutLocked(tb)
466	453		tb.mu.Unlock()
467	454		}
468	455		if ac != nil {


@@ -449,20 +449,7 @@ func (d Daemon) resize(sess session, ac *attachedClient, sz domain.Size) {
449		for _, tb := range tabs {	449		for _, tb := range tabs {
450		tb.mu.Lock()	450		tb.mu.Lock()
451		tb.size = tbSize	451		tb.size = tbSize
452	-	if tb.tree == nil {	452	+	d.applyLayoutLocked(tb)
453	-	p := tb.focusedPane()
454	-	if p != nil {
455	-	if err := p.pty.Resize(tbSize); err != nil {
456	-	d.log.Warn("pty resize failed", "err", err, "session", sess.name)
457	-	}
458	-	p.mu.Lock()
459	-	p.screen.Resize(tbSize.Cols, tbSize.Rows)
460	-	p.rect = domain.Rect{Width: tbSize.Cols, Height: tbSize.Rows}
461	-	p.mu.Unlock()
462	-	}
463	-	} else {
464	-	d.applyLayoutLocked(tb)
465	-	}
466		tb.mu.Unlock()	453		tb.mu.Unlock()
467		}	454		}
468		if ac != nil {	455		if ac != nil {

M internal/usecase/daemon/copymode.go +11 -4


@@ -335,13 +335,20 @@ func isCopyEscapePrefix(data []byte) bool {
335	335		func composeCopyClientFrame(mode scopy.Mode, tb tab, bars barState) (renderer.Frame, []renderer.Damage) {
336	336		styles := newThemeStyles(bars.theme)
337	337		p := tb.focusedPane()
	338	+	if p == nil {
	339	+	return renderer.NewFrame(0, 0), nil
	340	+	}
	341	+	p.mu.Lock()
	342	+	paneFrame := p.screen.Frame
	343	+	paneWidth, paneRows := paneFrame.Width, paneFrame.Height
	344	+	snap := scopy.NewSnapshot(p.scrollback, paneFrame)
	345	+	p.mu.Unlock()
	346	+	copyFrame := mode.Render(snap, styles.copyStatus, styles.selection)
338	347		pl, ok := focusedPlacementLocked(tb)
339	348		if !ok {
340		-	pl = layout.Placement{Content: domain.Rect{Width: p.screen.Frame.Width, Height: p.screen.Frame.Height}}
	349	+	pl = layout.Placement{Content: domain.Rect{Width: paneWidth, Height: paneRows}}
341	350		}
342		-	snap := scopy.NewSnapshot(p.scrollback, p.screen.Frame)
343		-	copyFrame := mode.Render(snap, styles.copyStatus, styles.selection)
344		-	width, screenRows := p.screen.Frame.Width, p.screen.Frame.Height
	351	+	width, screenRows := paneWidth, paneRows
345	352		if len(tb.panes) > 1 && tb.size.Valid() {
346	353		width, screenRows = tb.size.Cols, tb.size.Rows
347	354		}

 func composeCopyClientFrame(mode *scopy.Mode, tb *tab, bars barState) (renderer.Frame, []renderer.Damage) {
 	styles := newThemeStyles(bars.theme)
 	p := tb.focusedPane()
+	if p == nil {
+		return renderer.NewFrame(0, 0), nil
+	}
+	p.mu.Lock()
+	paneFrame := p.screen.Frame
+	paneWidth, paneRows := paneFrame.Width, paneFrame.Height
+	snap := scopy.NewSnapshot(p.scrollback, paneFrame)
+	p.mu.Unlock()
+	copyFrame := mode.Render(snap, styles.copyStatus, styles.selection)
 	pl, ok := focusedPlacementLocked(tb)
 	if !ok {
-		pl = layout.Placement{Content: domain.Rect{Width: p.screen.Frame.Width, Height: p.screen.Frame.Height}}
+		pl = layout.Placement{Content: domain.Rect{Width: paneWidth, Height: paneRows}}
 	}
-	snap := scopy.NewSnapshot(p.scrollback, p.screen.Frame)
+	width, screenRows := paneWidth, paneRows
-	copyFrame := mode.Render(snap, styles.copyStatus, styles.selection)
-	width, screenRows := p.screen.Frame.Width, p.screen.Frame.Height
 	if len(tb.panes) > 1 && tb.size.Valid() {
 		width, screenRows = tb.size.Cols, tb.size.Rows
 	}

M internal/usecase/daemon/copymode_test.go +60 -27


@@ -26,15 +26,48 @@ import (
26	26		// stubClock returns timers whose channel never fires, so a scheduler under it
27	27		// blocks in its debounce loop until the session context is cancelled. Used by
28	28
	29	+	func TestComposeCopyClientFrameConcurrentPaneOutput(t *testing.T) {
	30	+	p, release := newBlockingPTY(t)
	31	+	defer release()
	32	+	_, sess, _, _ := newManualSessionWithPTYs(t, p)
	33	+	tb := sess.activeTab()
	34	+	pane := tb.focusedPane()
	35	+	pane.mu.Lock()
	36	+	snap := scopy.NewSnapshot(pane.scrollback, pane.screen.Frame)
	37	+	pane.mu.Unlock()
	38	+	mode := scopy.NewMode(snap)
	39	+	bars := barState{status: sess.statusSegments()}
	40	+
	41	+	var wg sync.WaitGroup
	42	+	wg.Add(2)
	43	+	go func() {
	44	+	defer wg.Done()
	45	+	for range 200 {
	46	+	pane.mu.Lock()
	47	+	pane.screen.Write([]byte("output\n"))
	48	+	pane.mu.Unlock()
	49	+	}
	50	+	}()
	51	+	go func() {
	52	+	defer wg.Done()
	53	+	for range 200 {
	54	+	tb.mu.Lock()
	55	+	_, _ = composeCopyClientFrame(mode, tb, bars)
	56	+	tb.mu.Unlock()
	57	+	}
	58	+	}()
	59	+	wg.Wait()
	60	+	}
	61	+
29	62		func TestCopyModeFrameIncludesTopAndBottomChrome(t *testing.T) {
30	63		p, release := newBlockingPTY(t)
31	64		_, sess, _, _ := newManualSessionWithPTYs(t, p)
32	65		defer release()
33	66		sess.name = "work"
34	67		tb := sess.activeTab()
35		-	tb.screen = vt.NewScreen(12, 3)
36		-	tb.screen.Write([]byte("live"))
37		-	snap := scopy.NewSnapshot(tb.scrollback, tb.screen.Frame)
	68	+	tb.focusedPane().screen = vt.NewScreen(12, 3)
	69	+	tb.focusedPane().screen.Write([]byte("live"))
	70	+	snap := scopy.NewSnapshot(tb.focusedPane().scrollback, tb.focusedPane().screen.Frame)
38	71		mode := scopy.NewMode(snap)
39	72
40	73		frame, damage := composeCopyClientFrame(mode, tb, barState{status: sess.statusSegments()})

@@ -50,8 +83,8 @@ func TestCopyModePaletteCommandEntersAndDoesNotForward(t *testing.T) {
50	83		writes := make(chan []byte, 1)
51	84		p, _ := newBlockingPTYWithWrites(t, writes)
52	85		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
53		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
54		-	sess.tabs[0].screen.Write([]byte("live"))
	86	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	87	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
55	88
56	89		d.handleInput(sess, ac, []byte("\x1b "))
57	90		awaitFrame(t, sends, ports.MsgOutput)

@@ -85,10 +118,10 @@ func TestCopyModeInputNotForwardedAndOSC52Copy(t *testing.T) {
85	118		writes := make(chan []byte, 1)
86	119		p, _ := newBlockingPTYWithWrites(t, writes)
87	120		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
88		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
89		-	sess.tabs[0].scrollback.Append(testRow("old1 "))
90		-	sess.tabs[0].scrollback.Append(testRow("old2 "))
91		-	sess.tabs[0].screen.Write([]byte("live"))
	121	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	122	+	sess.tabs[0].focusedPane().scrollback.Append(testRow("old1 "))
	123	+	sess.tabs[0].focusedPane().scrollback.Append(testRow("old2 "))
	124	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
92	125
93	126		d.enterCopyMode(sess, ac)
94	127		awaitFrame(t, sends, ports.MsgOutput)

@@ -211,8 +244,8 @@ func TestScrollbackEvictionFeedsCopyModeYank(t *testing.T) {
211	244		func TestCopyModeEscapeRestoresLiveFullRepaint(t *testing.T) {
212	245		p, _ := newBlockingPTY(t)
213	246		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
214		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
215		-	sess.tabs[0].screen.Write([]byte("live"))
	247	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	248	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
216	249
217	250		d.enterCopyMode(sess, ac)
218	251		awaitFrame(t, sends, ports.MsgOutput)

@@ -245,10 +278,10 @@ func TestCopyModeSplitArrowDoesNotExit(t *testing.T) {
245	278		t.Run(tc.name, func(t *testing.T) {
246	279		p, _ := newBlockingPTY(t)
247	280		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
248		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
249		-	sess.tabs[0].scrollback.Append(testRow("old1 "))
250		-	sess.tabs[0].scrollback.Append(testRow("old2 "))
251		-	sess.tabs[0].screen.Write([]byte("live"))
	281	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	282	+	sess.tabs[0].focusedPane().scrollback.Append(testRow("old1 "))
	283	+	sess.tabs[0].focusedPane().scrollback.Append(testRow("old2 "))
	284	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
252	285
253	286		d.enterCopyMode(sess, ac)
254	287		awaitFrame(t, sends, ports.MsgOutput)

@@ -265,10 +298,10 @@ func TestCopyModeSplitArrowDoesNotExit(t *testing.T) {
265	298		func TestCopyModeOversizedYankShowsTooLargeFeedback(t *testing.T) {
266	299		p, _ := newBlockingPTY(t)
267	300		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
268		-	sess.tabs[0].scrollback = scopy.NewScrollback(1)
	301	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(1)
269	302		longLine := strings.Repeat("x", scopy.OSC52MaxPayloadBytes+1)
270		-	sess.tabs[0].screen.Frame = renderer.NewFrame(len(longLine), 1)
271		-	copy(sess.tabs[0].screen.Frame.Row(0), testRow(longLine))
	303	+	sess.tabs[0].focusedPane().screen.Frame = renderer.NewFrame(len(longLine), 1)
	304	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow(longLine))
272	305
273	306		d.enterCopyMode(sess, ac)
274	307		awaitFrame(t, sends, ports.MsgOutput)

@@ -290,8 +323,8 @@ func TestCopyModeLoneEscapeExitsAfterDelay(t *testing.T) {
290	323		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
291	324		clk := &signalClock{timers: make(chan *signalTimer, 1)}
292	325		d.clock = clk
293		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
294		-	sess.tabs[0].screen.Write([]byte("live"))
	326	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	327	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
295	328
296	329		d.enterCopyMode(sess, ac)
297	330		awaitFrame(t, sends, ports.MsgOutput)

@@ -313,8 +346,8 @@ func TestCopyModePendingEscapeDoesNotCloseNewMode(t *testing.T) {
313	346		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
314	347		clk := &signalClock{timers: make(chan *signalTimer, 1)}
315	348		d.clock = clk
316		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
317		-	sess.tabs[0].screen.Write([]byte("live"))
	349	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	350	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
318	351
319	352		d.enterCopyMode(sess, ac)
320	353		awaitFrame(t, sends, ports.MsgOutput)

@@ -348,8 +381,8 @@ func TestCopyModeEmptyYankDoesNotClearClipboard(t *testing.T) {
348	381		t.Run(tc.name, func(t *testing.T) {
349	382		p, _ := newBlockingPTY(t)
350	383		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
351		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
352		-	sess.tabs[0].screen.Write([]byte("live"))
	384	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	385	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
353	386
354	387		d.enterCopyMode(sess, ac)
355	388		awaitFrame(t, sends, ports.MsgOutput)

@@ -374,8 +407,8 @@ func TestCopyModeEmptyYankDoesNotClearClipboard(t *testing.T) {
374	407		func TestCopyModeEnterExitConcurrentWithPaintRace(t *testing.T) {
375	408		p, _ := newBlockingPTY(t)
376	409		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
377		-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
378		-	sess.tabs[0].screen.Write([]byte("live"))
	410	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
	411	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
379	412
380	413		done := make(chan struct{})
381	414		var drain sync.WaitGroup

@@ -407,7 +440,7 @@ func TestCopyModeEnterExitConcurrentWithPaintRace(t *testing.T) {
407	440		func TestCursorTailHidesInCopyMode(t *testing.T) {
408	441		p, _ := newBlockingPTY(t)
409	442		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
410		-	sess.tabs[0].screen.Write([]byte("live"))
	443	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
411	444
412	445		d.enterCopyMode(sess, ac)
413	446		data := mustOutputData(t, sends)

 // stubClock returns timers whose channel never fires, so a scheduler under it
 // blocks in its debounce loop until the session context is cancelled. Used by
+func TestComposeCopyClientFrameConcurrentPaneOutput(t *testing.T) {
+	p, release := newBlockingPTY(t)
+	defer release()
+	_, sess, _, _ := newManualSessionWithPTYs(t, p)
+	tb := sess.activeTab()
+	pane := tb.focusedPane()
+	pane.mu.Lock()
+	snap := scopy.NewSnapshot(pane.scrollback, pane.screen.Frame)
+	pane.mu.Unlock()
+	mode := scopy.NewMode(snap)
+	bars := barState{status: sess.statusSegments()}
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		for range 200 {
+			pane.mu.Lock()
+			pane.screen.Write([]byte("output\n"))
+			pane.mu.Unlock()
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		for range 200 {
+			tb.mu.Lock()
+			_, _ = composeCopyClientFrame(mode, tb, bars)
+			tb.mu.Unlock()
+		}
+	}()
+	wg.Wait()
+}
 func TestCopyModeFrameIncludesTopAndBottomChrome(t *testing.T) {
 	p, release := newBlockingPTY(t)
 	_, sess, _, _ := newManualSessionWithPTYs(t, p)
 	defer release()
 	sess.name = "work"
 	tb := sess.activeTab()
-	tb.screen = vt.NewScreen(12, 3)
+	tb.focusedPane().screen = vt.NewScreen(12, 3)
-	tb.screen.Write([]byte("live"))
+	tb.focusedPane().screen.Write([]byte("live"))
-	snap := scopy.NewSnapshot(tb.scrollback, tb.screen.Frame)
+	snap := scopy.NewSnapshot(tb.focusedPane().scrollback, tb.focusedPane().screen.Frame)
 	mode := scopy.NewMode(snap)
 	frame, damage := composeCopyClientFrame(mode, tb, barState{status: sess.statusSegments()})
 	writes := make(chan []byte, 1)
 	p, _ := newBlockingPTYWithWrites(t, writes)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.handleInput(sess, ac, []byte("\x1b "))
 	awaitFrame(t, sends, ports.MsgOutput)
 	writes := make(chan []byte, 1)
 	p, _ := newBlockingPTYWithWrites(t, writes)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-	sess.tabs[0].scrollback.Append(testRow("old1    "))
+	sess.tabs[0].focusedPane().scrollback.Append(testRow("old1    "))
-	sess.tabs[0].scrollback.Append(testRow("old2    "))
+	sess.tabs[0].focusedPane().scrollback.Append(testRow("old2    "))
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
 	awaitFrame(t, sends, ports.MsgOutput)
 func TestCopyModeEscapeRestoresLiveFullRepaint(t *testing.T) {
 	p, _ := newBlockingPTY(t)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
 	awaitFrame(t, sends, ports.MsgOutput)
 		t.Run(tc.name, func(t *testing.T) {
 			p, _ := newBlockingPTY(t)
 			d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-			sess.tabs[0].scrollback = scopy.NewScrollback(4)
+			sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-			sess.tabs[0].scrollback.Append(testRow("old1    "))
+			sess.tabs[0].focusedPane().scrollback.Append(testRow("old1    "))
-			sess.tabs[0].scrollback.Append(testRow("old2    "))
+			sess.tabs[0].focusedPane().scrollback.Append(testRow("old2    "))
-			sess.tabs[0].screen.Write([]byte("live"))
+			sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 			d.enterCopyMode(sess, ac)
 			awaitFrame(t, sends, ports.MsgOutput)
 func TestCopyModeOversizedYankShowsTooLargeFeedback(t *testing.T) {
 	p, _ := newBlockingPTY(t)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	sess.tabs[0].scrollback = scopy.NewScrollback(1)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(1)
 	longLine := strings.Repeat("x", scopy.OSC52MaxPayloadBytes+1)
-	sess.tabs[0].screen.Frame = renderer.NewFrame(len(longLine), 1)
+	sess.tabs[0].focusedPane().screen.Frame = renderer.NewFrame(len(longLine), 1)
-	copy(sess.tabs[0].screen.Frame.Row(0), testRow(longLine))
+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow(longLine))
 	d.enterCopyMode(sess, ac)
 	awaitFrame(t, sends, ports.MsgOutput)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
 	clk := &signalClock{timers: make(chan *signalTimer, 1)}
 	d.clock = clk
-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
 	awaitFrame(t, sends, ports.MsgOutput)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
 	clk := &signalClock{timers: make(chan *signalTimer, 1)}
 	d.clock = clk
-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
 	awaitFrame(t, sends, ports.MsgOutput)
 		t.Run(tc.name, func(t *testing.T) {
 			p, _ := newBlockingPTY(t)
 			d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-			sess.tabs[0].scrollback = scopy.NewScrollback(4)
+			sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-			sess.tabs[0].screen.Write([]byte("live"))
+			sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 			d.enterCopyMode(sess, ac)
 			awaitFrame(t, sends, ports.MsgOutput)
 func TestCopyModeEnterExitConcurrentWithPaintRace(t *testing.T) {
 	p, _ := newBlockingPTY(t)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	sess.tabs[0].scrollback = scopy.NewScrollback(4)
+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(4)
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	done := make(chan struct{})
 	var drain sync.WaitGroup
 func TestCursorTailHidesInCopyMode(t *testing.T) {
 	p, _ := newBlockingPTY(t)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	sess.tabs[0].screen.Write([]byte("live"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
 	data := mustOutputData(t, sends)

M internal/usecase/daemon/input.go +79 -19


@@ -74,6 +74,7 @@ func (d Daemon) handleMouse(ac attachedClient, ev mouse.Event) {
74	74
75	75		if ac.copyModeActive() {
76	76		if ev.Button == mouse.Left {
	77	+	contentRow := ev.Row - 1
77	78		tb.mu.Lock()
78	79		p := tb.focusedPane()
79	80		var pl layout.Placement

@@ -82,11 +83,26 @@ func (d Daemon) handleMouse(ac attachedClient, ev mouse.Event) {
82	83		if p != nil {
83	84		pl, ok = focusedPlacementLocked(tb)
84	85		}
85		-	tb.mu.Unlock()
86		-	if ok && multi {
87		-	if !pointInRect(ev.Col, ev.Row-1, pl.Content) {
	86	+	if ok && multi && !pointInRect(ev.Col, contentRow, pl.Content) && ev.Type == mouse.Press {
	87	+	if target, hit := hitTestPlacementLocked(tb, ev.Col, contentRow); hit {
	88	+	oldFocus := tb.tree.Focus
	89	+	focusPlacementLocked(tb, target.ID)
	90	+	d.applyLayoutLocked(tb)
	91	+	tb.mu.Unlock()
	92	+	d.exitCopyMode(ac)
	93	+	if target.ID != oldFocus {
	94	+	d.refreshPaneTitleOnFocus(sess, target.ID)
	95	+	}
	96	+	d.paint(sess, ac, true)
88	97		return
89	98		}
	99	+	}
	100	+	tb.mu.Unlock()
	101	+	if ok && multi {
	102	+	clampedCol := clampInt(ev.Col, pl.Content.X, pl.Content.X+pl.Content.Width-1)
	103	+	clampedRow := clampInt(contentRow, pl.Content.Y, pl.Content.Y+pl.Content.Height-1)
	104	+	ev.Col = clampedCol
	105	+	ev.Row = clampedRow
90	106		ev = translateMouseEvent(ev, pl.Content.X, pl.Content.Y)
91	107		}
92	108		}

@@ -104,42 +120,56 @@ func (d Daemon) handleMouse(ac attachedClient, ev mouse.Event) {
104	120		tb.mu.Lock()
105	121		contentRow := ev.Row - 1
106	122		pl, hit := hitTestPlacementLocked(tb, ev.Col, contentRow)
107		-	if hit && pl.Collapsed && pointInRect(ev.Col, contentRow, pl.TitleBar) {
108		-	oldFocus := tb.tree.Focus
	123	+	multi := len(tb.panes) > 1
	124	+	focusedID := layout.PaneID("")
	125	+	if tb.tree != nil {
	126	+	focusedID = tb.tree.Focus
	127	+	}
	128	+	if hit && pointInRect(ev.Col, contentRow, pl.TitleBar) {
	129	+	if !isMouseFocusPress(ev) {
	130	+	tb.mu.Unlock()
	131	+	return
	132	+	}
	133	+	oldFocus := focusedID
109	134		focusPlacementLocked(tb, pl.ID)
110	135		d.applyLayoutLocked(tb)
111	136		tb.mu.Unlock()
112	137		if pl.ID != oldFocus {
113	138		d.exitCopyMode(ac)
114		-	d.refreshPaneTitle(sess, pl.ID)
	139	+	d.refreshPaneTitleOnFocus(sess, pl.ID)
115	140		}
116	141		d.paint(sess, ac, true)
117	142		return
118	143		}
119	144		var p *pane
120	145		translated := false
	146	+	hoveredFocused := true
121	147		if hit && !pl.Collapsed && pointInRect(ev.Col, contentRow, pl.Content) {
122		-	oldFocus := tb.tree.Focus
123		-	focusPlacementLocked(tb, pl.ID)
124		-	d.applyLayoutLocked(tb)
125		-	p = tb.panes[pl.ID]
126		-	if len(tb.panes) == 1 {
127		-	p = tb.focusedPane()
	148	+	oldFocus := focusedID
	149	+	if isMouseFocusPress(ev) {
	150	+	focusPlacementLocked(tb, pl.ID)
	151	+	d.applyLayoutLocked(tb)
128	152		}
	153	+	p = tb.panes[pl.ID]
	154	+	hoveredFocused = pl.ID == oldFocus
129	155		tb.mu.Unlock()
130	156		if p == nil {
131	157		return
132	158		}
133		-	if pl.ID != oldFocus {
	159	+	if isMouseFocusPress(ev) && pl.ID != oldFocus {
134	160		d.exitCopyMode(ac)
135		-	d.refreshPaneTitle(sess, pl.ID)
	161	+	d.refreshPaneTitleOnFocus(sess, pl.ID)
136	162		d.paint(sess, ac, true)
137	163		}
138		-	if len(tb.panes) > 1 {
	164	+	if multi {
139	165		ev = translateMouseEvent(ev, pl.Content.X, pl.Content.Y)
140	166		translated = true
141	167		}
142	168		} else {
	169	+	if multi {
	170	+	tb.mu.Unlock()
	171	+	return
	172	+	}
143	173		p = tb.focusedPane()
144	174		tb.mu.Unlock()
145	175		if p == nil {

@@ -161,9 +191,9 @@ func (d Daemon) handleMouse(ac attachedClient, ev mouse.Event) {
161	191		return
162	192		}
163	193		if translated {
164		-	daemonKeyHandler{d: d, ac: ac}.Forward(ev.Raw)
	194	+	d.writeToPane(sess, p, ev.Raw)
165	195		} else {
166		-	daemonKeyHandler{d: d, ac: ac}.Forward(sgrRowOffset(ev.Raw, -1))
	196	+	d.writeToPane(sess, p, sgrRowOffset(ev.Raw, -1))
167	197		}
168	198		return
169	199		}

@@ -218,15 +248,45 @@ func (d Daemon) handleMouse(ac attachedClient, ev mouse.Event) {
218	248		}
219	249		case mouse.WheelUp:
220	250		if altScreen {
221		-	daemonKeyHandler{d: d, ac: ac}.Forward([]byte("\x1b[A\x1b[A\x1b[A"))
	251	+	d.writeToPane(sess, p, []byte("\x1b[A\x1b[A\x1b[A"))
	252	+	return
	253	+	}
	254	+	if !hoveredFocused {
222	255		return
223	256		}
224	257		d.enterCopyMode(sess, ac)
225	258		d.copyWheel(sess, ac, -3)
226	259		case mouse.WheelDown:
227	260		if altScreen {
228		-	daemonKeyHandler{d: d, ac: ac}.Forward([]byte("\x1b[B\x1b[B\x1b[B"))
	261	+	d.writeToPane(sess, p, []byte("\x1b[B\x1b[B\x1b[B"))
	262	+	}
	263	+	}
	264	+	}
	265	+
	266	+	func isMouseFocusPress(ev mouse.Event) bool {
	267	+	return ev.Type == mouse.Press && (ev.Button == mouse.Left \|\| ev.Button == mouse.Middle \|\| ev.Button == mouse.Right)
	268	+	}
	269	+
	270	+	func clampInt(v, lo, hi int) int {
	271	+	if v < lo {
	272	+	return lo
	273	+	}
	274	+	if v > hi {
	275	+	return hi
	276	+	}
	277	+	return v
	278	+	}
	279	+
	280	+	func (d Daemon) writeToPane(sess session, p *pane, data []byte) {
	281	+	if p == nil {
	282	+	return
	283	+	}
	284	+	if _, err := p.pty.Write(data); err != nil {
	285	+	name := ""
	286	+	if sess != nil {
	287	+	name = sess.name
229	288		}
	289	+	d.log.Error("pty write failed", "err", err, "session", name)
230	290		}
231	291		}
232	292

 	if ac.copyModeActive() {
 		if ev.Button == mouse.Left {
+			contentRow := ev.Row - 1
 			tb.mu.Lock()
 			p := tb.focusedPane()
 			var pl layout.Placement
 			if p != nil {
 				pl, ok = focusedPlacementLocked(tb)
 			}
-			tb.mu.Unlock()
+			if ok && multi && !pointInRect(ev.Col, contentRow, pl.Content) && ev.Type == mouse.Press {
-			if ok && multi {
+				if target, hit := hitTestPlacementLocked(tb, ev.Col, contentRow); hit {
-				if !pointInRect(ev.Col, ev.Row-1, pl.Content) {
+					oldFocus := tb.tree.Focus
+					focusPlacementLocked(tb, target.ID)
+					d.applyLayoutLocked(tb)
+					tb.mu.Unlock()
+					d.exitCopyMode(ac)
+					if target.ID != oldFocus {
+						d.refreshPaneTitleOnFocus(sess, target.ID)
+					}
+					d.paint(sess, ac, true)
 					return
 				}
+			}
+			tb.mu.Unlock()
+			if ok && multi {
+				clampedCol := clampInt(ev.Col, pl.Content.X, pl.Content.X+pl.Content.Width-1)
+				clampedRow := clampInt(contentRow, pl.Content.Y, pl.Content.Y+pl.Content.Height-1)
+				ev.Col = clampedCol
+				ev.Row = clampedRow
 				ev = translateMouseEvent(ev, pl.Content.X, pl.Content.Y)
 			}
 		}
 	tb.mu.Lock()
 	contentRow := ev.Row - 1
 	pl, hit := hitTestPlacementLocked(tb, ev.Col, contentRow)
-	if hit && pl.Collapsed && pointInRect(ev.Col, contentRow, pl.TitleBar) {
+	multi := len(tb.panes) > 1
-		oldFocus := tb.tree.Focus
+	focusedID := layout.PaneID("")
+	if tb.tree != nil {
+		focusedID = tb.tree.Focus
+	}
+	if hit && pointInRect(ev.Col, contentRow, pl.TitleBar) {
+		if !isMouseFocusPress(ev) {
+			tb.mu.Unlock()
+			return
+		}
+		oldFocus := focusedID
 		focusPlacementLocked(tb, pl.ID)
 		d.applyLayoutLocked(tb)
 		tb.mu.Unlock()
 		if pl.ID != oldFocus {
 			d.exitCopyMode(ac)
-			d.refreshPaneTitle(sess, pl.ID)
+			d.refreshPaneTitleOnFocus(sess, pl.ID)
 		}
 		d.paint(sess, ac, true)
 		return
 	}
 	var p *pane
 	translated := false
+	hoveredFocused := true
 	if hit && !pl.Collapsed && pointInRect(ev.Col, contentRow, pl.Content) {
-		oldFocus := tb.tree.Focus
+		oldFocus := focusedID
-		focusPlacementLocked(tb, pl.ID)
+		if isMouseFocusPress(ev) {
-		d.applyLayoutLocked(tb)
+			focusPlacementLocked(tb, pl.ID)
-		p = tb.panes[pl.ID]
+			d.applyLayoutLocked(tb)
-		if len(tb.panes) == 1 {
-			p = tb.focusedPane()
 		}
+		p = tb.panes[pl.ID]
+		hoveredFocused = pl.ID == oldFocus
 		tb.mu.Unlock()
 		if p == nil {
 			return
 		}
-		if pl.ID != oldFocus {
+		if isMouseFocusPress(ev) && pl.ID != oldFocus {
 			d.exitCopyMode(ac)
-			d.refreshPaneTitle(sess, pl.ID)
+			d.refreshPaneTitleOnFocus(sess, pl.ID)
 			d.paint(sess, ac, true)
 		}
-		if len(tb.panes) > 1 {
+		if multi {
 			ev = translateMouseEvent(ev, pl.Content.X, pl.Content.Y)
 			translated = true
 		}
 	} else {
+		if multi {
+			tb.mu.Unlock()
+			return
+		}
 		p = tb.focusedPane()
 		tb.mu.Unlock()
 		if p == nil {
 			return
 		}
 		if translated {
-			daemonKeyHandler{d: d, ac: ac}.Forward(ev.Raw)
+			d.writeToPane(sess, p, ev.Raw)
 		} else {
-			daemonKeyHandler{d: d, ac: ac}.Forward(sgrRowOffset(ev.Raw, -1))
+			d.writeToPane(sess, p, sgrRowOffset(ev.Raw, -1))
 		}
 		return
 	}
 		}
 	case mouse.WheelUp:
 		if altScreen {
-			daemonKeyHandler{d: d, ac: ac}.Forward([]byte("\x1b[A\x1b[A\x1b[A"))
+			d.writeToPane(sess, p, []byte("\x1b[A\x1b[A\x1b[A"))
+			return
+		}
+		if !hoveredFocused {
 			return
 		}
 		d.enterCopyMode(sess, ac)
 		d.copyWheel(sess, ac, -3)
 	case mouse.WheelDown:
 		if altScreen {
-			daemonKeyHandler{d: d, ac: ac}.Forward([]byte("\x1b[B\x1b[B\x1b[B"))
+			d.writeToPane(sess, p, []byte("\x1b[B\x1b[B\x1b[B"))
+		}
+	}
+}
+func isMouseFocusPress(ev mouse.Event) bool {
+	return ev.Type == mouse.Press && (ev.Button == mouse.Left || ev.Button == mouse.Middle || ev.Button == mouse.Right)
+}
+func clampInt(v, lo, hi int) int {
+	if v < lo {
+		return lo
+	}
+	if v > hi {
+		return hi
+	}
+	return v
+}
+func (d *Daemon) writeToPane(sess *session, p *pane, data []byte) {
+	if p == nil {
+		return
+	}
+	if _, err := p.pty.Write(data); err != nil {
+		name := ""
+		if sess != nil {
+			name = sess.name
 		}
+		d.log.Error("pty write failed", "err", err, "session", name)
 	}
 }

M internal/usecase/daemon/input_test.go +114 -17


@@ -7,6 +7,7 @@ import (
7	7		"testing"
8	8		"time"
9	9
	10	+	"github.com/stretchr/testify/mock"
10	11		"github.com/stretchr/testify/require"
11	12
12	13		"github.com/bnema/vev/internal/domain"

@@ -171,7 +172,7 @@ func TestMouseWheelEntersScrollbackModeAndExitsAtBottom(t *testing.T) {
171	172		p, _ := newBlockingPTYWithWrites(t, writes)
172	173		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
173	174		win := sess.tabs[0]
174		-	win.screen.Write([]byte("live"))
	175	+	win.focusedPane().screen.Write([]byte("live"))
175	176
176	177		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))
177	178		data := mustOutputData(t, sends)

@@ -198,7 +199,7 @@ func TestMouseAltScreenWheelMapsToArrows(t *testing.T) {
198	199		writes := make(chan []byte, 2)
199	200		p, _ := newBlockingPTYWithWrites(t, writes)
200	201		d, sess, ac, _ := newManualSessionWithPTYs(t, p)
201		-	sess.tabs[0].screen.Write([]byte("\x1b[?1049h"))
	202	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1049h"))
202	203
203	204		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))
204	205		d.handleInput(sess, ac, []byte("\x1b[<65;1;1M"))

@@ -248,7 +249,7 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
248	249		}
249	250		require.Nil(t, ac.copyMode, "press alone must not enter visual mode")
250	251
251		-	sess.tabs[0].screen.Write([]byte("\x1b[?1000h"))
	252	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1000h"))
252	253		raw := []byte("\x1b[<0;2;3M")
253	254		d.handleInput(sess, ac, raw)
254	255		select {

@@ -257,7 +258,7 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
257	258		default:
258	259		}
259	260
260		-	sess.tabs[0].screen.Write([]byte("\x1b[?1006h"))
	261	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1006h"))
261	262		d.handleInput(sess, ac, raw)
262	263		require.Equal(t, []byte("\x1b[<0;2;2M"), <-writes)
263	264

@@ -276,7 +277,7 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
276	277		default:
277	278		}
278	279
279		-	sess.tabs[0].screen.Write([]byte("\x1b[?1006l\x1b[?1000l"))
	280	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1006l\x1b[?1000l"))
280	281		d.handleInput(sess, ac, []byte("\x1b[<0;1;1M"))
281	282		require.Nil(t, ac.copyMode, "press alone must still not enter visual mode")
282	283		d.handleInput(sess, ac, []byte("\x1b[<32;1;3M"))

@@ -291,9 +292,9 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
291	292		func TestCopyModeMouseDragYanksOSC52AndExits(t *testing.T) {
292	293		p, _ := newBlockingPTY(t)
293	294		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
294		-	copy(sess.tabs[0].screen.Frame.Row(0), testRow("alpha"))
295		-	copy(sess.tabs[0].screen.Frame.Row(1), testRow("bravo"))
296		-	copy(sess.tabs[0].screen.Frame.Row(2), testRow("charlie"))
	295	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow("alpha"))
	296	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(1), testRow("bravo"))
	297	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(2), testRow("charlie"))
297	298
298	299		d.enterCopyMode(sess, ac)
299	300		mustOutputData(t, sends)

@@ -330,7 +331,7 @@ func TestCopyModeMouseDragYanksOSC52AndExits(t *testing.T) {
330	331		func TestMouseNormalScreenStatusRowClearsStalePressState(t *testing.T) {
331	332		p, _ := newBlockingPTY(t)
332	333		d, sess, ac, _ := newManualSessionWithPTYs(t, p)
333		-	require.Equal(t, 23, sess.tabs[0].screen.Frame.Height, "fixture assumption: status row is wire row 24")
	334	+	require.Equal(t, 23, sess.tabs[0].focusedPane().screen.Frame.Height, "fixture assumption: status row is wire row 24")
334	335
335	336		// Press on a content row establishes a (soon to be stale) anchor.
336	337		d.handleInput(sess, ac, []byte("\x1b[<0;1;1M"))

@@ -359,10 +360,10 @@ func TestMouseNormalScreenStatusRowClearsStalePressState(t *testing.T) {
359	360		func TestCopyModeStatusRowPressClearsDragState(t *testing.T) {
360	361		p, _ := newBlockingPTY(t)
361	362		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
362		-	copy(sess.tabs[0].screen.Frame.Row(0), testRow("alpha"))
363		-	copy(sess.tabs[0].screen.Frame.Row(1), testRow("bravo"))
364		-	copy(sess.tabs[0].screen.Frame.Row(2), testRow("charlie"))
365		-	require.Equal(t, 23, sess.tabs[0].screen.Frame.Height, "fixture assumption: status row is wire row 24")
	363	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow("alpha"))
	364	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(1), testRow("bravo"))
	365	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(2), testRow("charlie"))
	366	+	require.Equal(t, 23, sess.tabs[0].focusedPane().screen.Frame.Height, "fixture assumption: status row is wire row 24")
366	367
367	368		d.enterCopyMode(sess, ac)
368	369		mustOutputData(t, sends)

@@ -399,8 +400,8 @@ func TestCopyModeStatusRowPressClearsDragState(t *testing.T) {
399	400		func TestMouseNormalScreenDragExtendsToCurrentScrollbackOffset(t *testing.T) {
400	401		p, _ := newBlockingPTY(t)
401	402		d, sess, ac, _ := newManualSessionWithPTYs(t, p)
402		-	sess.tabs[0].scrollback = scopy.NewScrollback(50)
403		-	require.Equal(t, 23, sess.tabs[0].screen.Frame.Height, "fixture assumption: status row is wire row 24")
	403	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(50)
	404	+	require.Equal(t, 23, sess.tabs[0].focusedPane().screen.Frame.Height, "fixture assumption: status row is wire row 24")
404	405
405	406		// Press on a content row while scrollback is empty: the anchor is
406	407		// content-stable at pressTop(0)+pressRow(0) = row 0.

@@ -409,7 +410,7 @@ func TestMouseNormalScreenDragExtendsToCurrentScrollbackOffset(t *testing.T) {
409	410		// Simulate 5 lines evicted into scrollback between the Press and the
410	411		// first Motion (e.g. the child kept producing output).
411	412		for range 5 {
412		-	sess.tabs[0].scrollback.Append(testRow("evicted"))
	413	+	sess.tabs[0].focusedPane().scrollback.Append(testRow("evicted"))
413	414		}
414	415
415	416		// Motion lands on wire row 3 (0-based row 2 of the current screen).

@@ -429,7 +430,7 @@ func TestMouseSplitReportPreservesOrder(t *testing.T) {
429	430		writes := make(chan []byte, 2)
430	431		p, _ := newBlockingPTYWithWrites(t, writes)
431	432		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
432		-	sess.tabs[0].screen.Write([]byte("live"))
	433	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
433	434
434	435		d.handleInput(sess, ac, []byte("\x1b[<64;"))
435	436		d.handleInput(sess, ac, []byte("1;1Mq"))

@@ -444,6 +445,102 @@ func TestMouseSplitReportPreservesOrder(t *testing.T) {
444	445		}
445	446		}
446	447
	448	+	func TestMouseWheelOverUnfocusedPaneDoesNotFocusAndForwardsChildMouse(t *testing.T) {
	449	+	p1 := portsmocks.NewMockPTY(t)
	450	+	p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()
	451	+	p2 := portsmocks.NewMockPTY(t)
	452	+	p2.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()
	453	+	p2.EXPECT().Write([]byte("\x1b[<64;1;1M")).Return(len("\x1b[<64;1;1M"), nil).Once()
	454	+	d, sess, ac, _ := newManualSessionWithPTYs(t, p1)
	455	+	d.procComm = nil
	456	+	tb := sess.activeTab()
	457	+	p2pane := newPane("pane-2", p2, domain.Size{Cols: 20, Rows: 5})
	458	+	p2pane.screen.Write([]byte("\x1b[?1000h\x1b[?1006h"))
	459	+	tb.mu.Lock()
	460	+	tb.size = domain.Size{Cols: 41, Rows: 5}
	461	+	tb.tree.Root = &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}}
	462	+	tb.tree.Focus = "pane-1"
	463	+	tb.panes["pane-2"] = p2pane
	464	+	tb.mu.Unlock()
	465	+
	466	+	d.handleInput(sess, ac, []byte("\x1b[<64;22;2M"))
	467	+
	468	+	require.Equal(t, layout.PaneID("pane-1"), tb.tree.Focus)
	469	+	}
	470	+
	471	+	func TestMouseDividerAndTitleBarDoNotForwardBogusCoordinates(t *testing.T) {
	472	+	cases := []struct {
	473	+	name string
	474	+	raw []byte
	475	+	root *layout.Node
	476	+	size domain.Size
	477	+	}{
	478	+	{
	479	+	name: "divider",
	480	+	raw: []byte("\x1b[<0;21;2M"),
	481	+	root: &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}},
	482	+	size: domain.Size{Cols: 41, Rows: 5},
	483	+	},
	484	+	{
	485	+	name: "expanded title bar",
	486	+	raw: []byte("\x1b[<0;1;1M"),
	487	+	root: &layout.Node{Kind: layout.Stack, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}, Expanded: "pane-1"},
	488	+	size: domain.Size{Cols: 20, Rows: 5},
	489	+	},
	490	+	}
	491	+	for _, tc := range cases {
	492	+	t.Run(tc.name, func(t *testing.T) {
	493	+	p1 := portsmocks.NewMockPTY(t)
	494	+	p1.EXPECT().Resize(mock.Anything).Return(nil).Maybe()
	495	+	p2 := portsmocks.NewMockPTY(t)
	496	+	p2.EXPECT().Resize(mock.Anything).Return(nil).Maybe()
	497	+	d, sess, ac, _ := newManualSessionWithPTYs(t, p1)
	498	+	d.procComm = nil
	499	+	tb := sess.activeTab()
	500	+	tb.focusedPane().screen.Write([]byte("\x1b[?1000h\x1b[?1006h"))
	501	+	tb.mu.Lock()
	502	+	tb.size = tc.size
	503	+	tb.tree.Root = tc.root
	504	+	tb.tree.Focus = "pane-1"
	505	+	tb.panes["pane-2"] = newPane("pane-2", p2, tc.size)
	506	+	tb.mu.Unlock()
	507	+
	508	+	d.handleInput(sess, ac, tc.raw)
	509	+
	510	+	require.Equal(t, layout.PaneID("pane-1"), tb.tree.Focus)
	511	+	})
	512	+	}
	513	+	}
	514	+
	515	+	func TestCopyModeDragOutsideSplitPaneClampsToPaneContent(t *testing.T) {
	516	+	p1 := portsmocks.NewMockPTY(t)
	517	+	p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 10}).Return(nil).Maybe()
	518	+	p2 := portsmocks.NewMockPTY(t)
	519	+	p2.EXPECT().Resize(domain.Size{Cols: 20, Rows: 10}).Return(nil).Maybe()
	520	+	d, sess, ac, sends := newManualSessionWithPTYs(t, p1)
	521	+	d.procComm = nil
	522	+	tb := sess.activeTab()
	523	+	for i := range 10 {
	524	+	copy(tb.focusedPane().screen.Frame.Row(i), testRow(string(rune('a'+i))))
	525	+	}
	526	+	tb.mu.Lock()
	527	+	tb.size = domain.Size{Cols: 41, Rows: 10}
	528	+	tb.tree.Root = &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}}
	529	+	tb.tree.Focus = "pane-1"
	530	+	tb.panes["pane-2"] = newPane("pane-2", p2, domain.Size{Cols: 20, Rows: 10})
	531	+	tb.mu.Unlock()
	532	+	d.enterCopyMode(sess, ac)
	533	+	mustOutputData(t, sends)
	534	+
	535	+	d.handleInput(sess, ac, []byte("\x1b[<0;1;1M\x1b[<32;1;12M"))
	536	+	mustOutputData(t, sends)
	537	+
	538	+	lo, hi, ok := ac.copyMode.SelectedBounds()
	539	+	require.True(t, ok)
	540	+	require.Equal(t, 0, lo)
	541	+	require.Equal(t, 9, hi)
	542	+	}
	543	+
447	544		func TestMouseHitTestFocusesPaneAndTranslatesSGRColumns(t *testing.T) {
448	545		p1 := portsmocks.NewMockPTY(t)
449	546		p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()


@@ -7,6 +7,7 @@ import (
7		"testing"	7		"testing"
8		"time"	8		"time"
9			9
			10	+	"github.com/stretchr/testify/mock"
10		"github.com/stretchr/testify/require"	11		"github.com/stretchr/testify/require"
11			12
12		"github.com/bnema/vev/internal/domain"	13		"github.com/bnema/vev/internal/domain"

@@ -171,7 +172,7 @@ func TestMouseWheelEntersScrollbackModeAndExitsAtBottom(t *testing.T) {
171		p, _ := newBlockingPTYWithWrites(t, writes)	172		p, _ := newBlockingPTYWithWrites(t, writes)
172		d, sess, ac, sends := newManualSessionWithPTYs(t, p)	173		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
173		win := sess.tabs[0]	174		win := sess.tabs[0]
174	-	win.screen.Write([]byte("live"))	175	+	win.focusedPane().screen.Write([]byte("live"))
175			176
176		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))	177		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))
177		data := mustOutputData(t, sends)	178		data := mustOutputData(t, sends)

@@ -198,7 +199,7 @@ func TestMouseAltScreenWheelMapsToArrows(t *testing.T) {
198		writes := make(chan []byte, 2)	199		writes := make(chan []byte, 2)
199		p, _ := newBlockingPTYWithWrites(t, writes)	200		p, _ := newBlockingPTYWithWrites(t, writes)
200		d, sess, ac, _ := newManualSessionWithPTYs(t, p)	201		d, sess, ac, _ := newManualSessionWithPTYs(t, p)
201	-	sess.tabs[0].screen.Write([]byte("\x1b[?1049h"))	202	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1049h"))
202			203
203		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))	204		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))
204		d.handleInput(sess, ac, []byte("\x1b[<65;1;1M"))	205		d.handleInput(sess, ac, []byte("\x1b[<65;1;1M"))

@@ -248,7 +249,7 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
248		}	249		}
249		require.Nil(t, ac.copyMode, "press alone must not enter visual mode")	250		require.Nil(t, ac.copyMode, "press alone must not enter visual mode")
250			251
251	-	sess.tabs[0].screen.Write([]byte("\x1b[?1000h"))	252	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1000h"))
252		raw := []byte("\x1b[<0;2;3M")	253		raw := []byte("\x1b[<0;2;3M")
253		d.handleInput(sess, ac, raw)	254		d.handleInput(sess, ac, raw)
254		select {	255		select {

@@ -257,7 +258,7 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
257		default:	258		default:
258		}	259		}
259			260
260	-	sess.tabs[0].screen.Write([]byte("\x1b[?1006h"))	261	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1006h"))
261		d.handleInput(sess, ac, raw)	262		d.handleInput(sess, ac, raw)
262		require.Equal(t, []byte("\x1b[<0;2;2M"), <-writes)	263		require.Equal(t, []byte("\x1b[<0;2;2M"), <-writes)
263			264

@@ -276,7 +277,7 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
276		default:	277		default:
277		}	278		}
278			279
279	-	sess.tabs[0].screen.Write([]byte("\x1b[?1006l\x1b[?1000l"))	280	+	sess.tabs[0].focusedPane().screen.Write([]byte("\x1b[?1006l\x1b[?1000l"))
280		d.handleInput(sess, ac, []byte("\x1b[<0;1;1M"))	281		d.handleInput(sess, ac, []byte("\x1b[<0;1;1M"))
281		require.Nil(t, ac.copyMode, "press alone must still not enter visual mode")	282		require.Nil(t, ac.copyMode, "press alone must still not enter visual mode")
282		d.handleInput(sess, ac, []byte("\x1b[<32;1;3M"))	283		d.handleInput(sess, ac, []byte("\x1b[<32;1;3M"))

@@ -291,9 +292,9 @@ func TestMouseChildForwardingStatusDropAndPressDrop(t *testing.T) {
291		func TestCopyModeMouseDragYanksOSC52AndExits(t *testing.T) {	292		func TestCopyModeMouseDragYanksOSC52AndExits(t *testing.T) {
292		p, _ := newBlockingPTY(t)	293		p, _ := newBlockingPTY(t)
293		d, sess, ac, sends := newManualSessionWithPTYs(t, p)	294		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
294	-	copy(sess.tabs[0].screen.Frame.Row(0), testRow("alpha"))	295	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow("alpha"))
295	-	copy(sess.tabs[0].screen.Frame.Row(1), testRow("bravo"))	296	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(1), testRow("bravo"))
296	-	copy(sess.tabs[0].screen.Frame.Row(2), testRow("charlie"))	297	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(2), testRow("charlie"))
297			298
298		d.enterCopyMode(sess, ac)	299		d.enterCopyMode(sess, ac)
299		mustOutputData(t, sends)	300		mustOutputData(t, sends)

@@ -330,7 +331,7 @@ func TestCopyModeMouseDragYanksOSC52AndExits(t *testing.T) {
330		func TestMouseNormalScreenStatusRowClearsStalePressState(t *testing.T) {	331		func TestMouseNormalScreenStatusRowClearsStalePressState(t *testing.T) {
331		p, _ := newBlockingPTY(t)	332		p, _ := newBlockingPTY(t)
332		d, sess, ac, _ := newManualSessionWithPTYs(t, p)	333		d, sess, ac, _ := newManualSessionWithPTYs(t, p)
333	-	require.Equal(t, 23, sess.tabs[0].screen.Frame.Height, "fixture assumption: status row is wire row 24")	334	+	require.Equal(t, 23, sess.tabs[0].focusedPane().screen.Frame.Height, "fixture assumption: status row is wire row 24")
334			335
335		// Press on a content row establishes a (soon to be stale) anchor.	336		// Press on a content row establishes a (soon to be stale) anchor.
336		d.handleInput(sess, ac, []byte("\x1b[<0;1;1M"))	337		d.handleInput(sess, ac, []byte("\x1b[<0;1;1M"))

@@ -359,10 +360,10 @@ func TestMouseNormalScreenStatusRowClearsStalePressState(t *testing.T) {
359		func TestCopyModeStatusRowPressClearsDragState(t *testing.T) {	360		func TestCopyModeStatusRowPressClearsDragState(t *testing.T) {
360		p, _ := newBlockingPTY(t)	361		p, _ := newBlockingPTY(t)
361		d, sess, ac, sends := newManualSessionWithPTYs(t, p)	362		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
362	-	copy(sess.tabs[0].screen.Frame.Row(0), testRow("alpha"))	363	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow("alpha"))
363	-	copy(sess.tabs[0].screen.Frame.Row(1), testRow("bravo"))	364	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(1), testRow("bravo"))
364	-	copy(sess.tabs[0].screen.Frame.Row(2), testRow("charlie"))	365	+	copy(sess.tabs[0].focusedPane().screen.Frame.Row(2), testRow("charlie"))
365	-	require.Equal(t, 23, sess.tabs[0].screen.Frame.Height, "fixture assumption: status row is wire row 24")	366	+	require.Equal(t, 23, sess.tabs[0].focusedPane().screen.Frame.Height, "fixture assumption: status row is wire row 24")
366			367
367		d.enterCopyMode(sess, ac)	368		d.enterCopyMode(sess, ac)
368		mustOutputData(t, sends)	369		mustOutputData(t, sends)

@@ -399,8 +400,8 @@ func TestCopyModeStatusRowPressClearsDragState(t *testing.T) {
399		func TestMouseNormalScreenDragExtendsToCurrentScrollbackOffset(t *testing.T) {	400		func TestMouseNormalScreenDragExtendsToCurrentScrollbackOffset(t *testing.T) {
400		p, _ := newBlockingPTY(t)	401		p, _ := newBlockingPTY(t)
401		d, sess, ac, _ := newManualSessionWithPTYs(t, p)	402		d, sess, ac, _ := newManualSessionWithPTYs(t, p)
402	-	sess.tabs[0].scrollback = scopy.NewScrollback(50)	403	+	sess.tabs[0].focusedPane().scrollback = scopy.NewScrollback(50)
403	-	require.Equal(t, 23, sess.tabs[0].screen.Frame.Height, "fixture assumption: status row is wire row 24")	404	+	require.Equal(t, 23, sess.tabs[0].focusedPane().screen.Frame.Height, "fixture assumption: status row is wire row 24")
404			405
405		// Press on a content row while scrollback is empty: the anchor is	406		// Press on a content row while scrollback is empty: the anchor is
406		// content-stable at pressTop(0)+pressRow(0) = row 0.	407		// content-stable at pressTop(0)+pressRow(0) = row 0.

@@ -409,7 +410,7 @@ func TestMouseNormalScreenDragExtendsToCurrentScrollbackOffset(t *testing.T) {
409		// Simulate 5 lines evicted into scrollback between the Press and the	410		// Simulate 5 lines evicted into scrollback between the Press and the
410		// first Motion (e.g. the child kept producing output).	411		// first Motion (e.g. the child kept producing output).
411		for range 5 {	412		for range 5 {
412	-	sess.tabs[0].scrollback.Append(testRow("evicted"))	413	+	sess.tabs[0].focusedPane().scrollback.Append(testRow("evicted"))
413		}	414		}
414			415
415		// Motion lands on wire row 3 (0-based row 2 of the current screen).	416		// Motion lands on wire row 3 (0-based row 2 of the current screen).

@@ -429,7 +430,7 @@ func TestMouseSplitReportPreservesOrder(t *testing.T) {
429		writes := make(chan []byte, 2)	430		writes := make(chan []byte, 2)
430		p, _ := newBlockingPTYWithWrites(t, writes)	431		p, _ := newBlockingPTYWithWrites(t, writes)
431		d, sess, ac, sends := newManualSessionWithPTYs(t, p)	432		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
432	-	sess.tabs[0].screen.Write([]byte("live"))	433	+	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
433			434
434		d.handleInput(sess, ac, []byte("\x1b[<64;"))	435		d.handleInput(sess, ac, []byte("\x1b[<64;"))
435		d.handleInput(sess, ac, []byte("1;1Mq"))	436		d.handleInput(sess, ac, []byte("1;1Mq"))

@@ -444,6 +445,102 @@ func TestMouseSplitReportPreservesOrder(t *testing.T) {
444		}	445		}
445		}	446		}
446			447
			448	+	func TestMouseWheelOverUnfocusedPaneDoesNotFocusAndForwardsChildMouse(t *testing.T) {
			449	+	p1 := portsmocks.NewMockPTY(t)
			450	+	p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()
			451	+	p2 := portsmocks.NewMockPTY(t)
			452	+	p2.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()
			453	+	p2.EXPECT().Write([]byte("\x1b[<64;1;1M")).Return(len("\x1b[<64;1;1M"), nil).Once()
			454	+	d, sess, ac, _ := newManualSessionWithPTYs(t, p1)
			455	+	d.procComm = nil
			456	+	tb := sess.activeTab()
			457	+	p2pane := newPane("pane-2", p2, domain.Size{Cols: 20, Rows: 5})
			458	+	p2pane.screen.Write([]byte("\x1b[?1000h\x1b[?1006h"))
			459	+	tb.mu.Lock()
			460	+	tb.size = domain.Size{Cols: 41, Rows: 5}
			461	+	tb.tree.Root = &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}}
			462	+	tb.tree.Focus = "pane-1"
			463	+	tb.panes["pane-2"] = p2pane
			464	+	tb.mu.Unlock()
			465	+
			466	+	d.handleInput(sess, ac, []byte("\x1b[<64;22;2M"))
			467	+
			468	+	require.Equal(t, layout.PaneID("pane-1"), tb.tree.Focus)
			469	+	}
			470	+
			471	+	func TestMouseDividerAndTitleBarDoNotForwardBogusCoordinates(t *testing.T) {
			472	+	cases := []struct {
			473	+	name string
			474	+	raw []byte
			475	+	root *layout.Node
			476	+	size domain.Size
			477	+	}{
			478	+	{
			479	+	name: "divider",
			480	+	raw: []byte("\x1b[<0;21;2M"),
			481	+	root: &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}},
			482	+	size: domain.Size{Cols: 41, Rows: 5},
			483	+	},
			484	+	{
			485	+	name: "expanded title bar",
			486	+	raw: []byte("\x1b[<0;1;1M"),
			487	+	root: &layout.Node{Kind: layout.Stack, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}, Expanded: "pane-1"},
			488	+	size: domain.Size{Cols: 20, Rows: 5},
			489	+	},
			490	+	}
			491	+	for _, tc := range cases {
			492	+	t.Run(tc.name, func(t *testing.T) {
			493	+	p1 := portsmocks.NewMockPTY(t)
			494	+	p1.EXPECT().Resize(mock.Anything).Return(nil).Maybe()
			495	+	p2 := portsmocks.NewMockPTY(t)
			496	+	p2.EXPECT().Resize(mock.Anything).Return(nil).Maybe()
			497	+	d, sess, ac, _ := newManualSessionWithPTYs(t, p1)
			498	+	d.procComm = nil
			499	+	tb := sess.activeTab()
			500	+	tb.focusedPane().screen.Write([]byte("\x1b[?1000h\x1b[?1006h"))
			501	+	tb.mu.Lock()
			502	+	tb.size = tc.size
			503	+	tb.tree.Root = tc.root
			504	+	tb.tree.Focus = "pane-1"
			505	+	tb.panes["pane-2"] = newPane("pane-2", p2, tc.size)
			506	+	tb.mu.Unlock()
			507	+
			508	+	d.handleInput(sess, ac, tc.raw)
			509	+
			510	+	require.Equal(t, layout.PaneID("pane-1"), tb.tree.Focus)
			511	+	})
			512	+	}
			513	+	}
			514	+
			515	+	func TestCopyModeDragOutsideSplitPaneClampsToPaneContent(t *testing.T) {
			516	+	p1 := portsmocks.NewMockPTY(t)
			517	+	p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 10}).Return(nil).Maybe()
			518	+	p2 := portsmocks.NewMockPTY(t)
			519	+	p2.EXPECT().Resize(domain.Size{Cols: 20, Rows: 10}).Return(nil).Maybe()
			520	+	d, sess, ac, sends := newManualSessionWithPTYs(t, p1)
			521	+	d.procComm = nil
			522	+	tb := sess.activeTab()
			523	+	for i := range 10 {
			524	+	copy(tb.focusedPane().screen.Frame.Row(i), testRow(string(rune('a'+i))))
			525	+	}
			526	+	tb.mu.Lock()
			527	+	tb.size = domain.Size{Cols: 41, Rows: 10}
			528	+	tb.tree.Root = &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}}
			529	+	tb.tree.Focus = "pane-1"
			530	+	tb.panes["pane-2"] = newPane("pane-2", p2, domain.Size{Cols: 20, Rows: 10})
			531	+	tb.mu.Unlock()
			532	+	d.enterCopyMode(sess, ac)
			533	+	mustOutputData(t, sends)
			534	+
			535	+	d.handleInput(sess, ac, []byte("\x1b[<0;1;1M\x1b[<32;1;12M"))
			536	+	mustOutputData(t, sends)
			537	+
			538	+	lo, hi, ok := ac.copyMode.SelectedBounds()
			539	+	require.True(t, ok)
			540	+	require.Equal(t, 0, lo)
			541	+	require.Equal(t, 9, hi)
			542	+	}
			543	+
447		func TestMouseHitTestFocusesPaneAndTranslatesSGRColumns(t *testing.T) {	544		func TestMouseHitTestFocusesPaneAndTranslatesSGRColumns(t *testing.T) {
448		p1 := portsmocks.NewMockPTY(t)	545		p1 := portsmocks.NewMockPTY(t)
449		p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()	546		p1.EXPECT().Resize(domain.Size{Cols: 20, Rows: 5}).Return(nil).Maybe()

M internal/usecase/daemon/pane.go +3 -0


@@ -3,6 +3,7 @@ package daemon
3	3		import (
4	4		"context"
5	5		"sync"
	6	+	"time"
6	7
7	8		"github.com/bnema/vev/internal/domain"
8	9		"github.com/bnema/vev/internal/ports"

@@ -26,6 +27,8 @@ type pane struct {
26	27		syncGen uint64
27	28		rect domain.Rect
28	29		title string
	30	+	titleAt time.Time
	31	+	titleValid bool
29	32		ctx context.Context
30	33		cancel context.CancelFunc
31	34		}


@@ -3,6 +3,7 @@ package daemon
3	import (	3		import (
4	"context"	4		"context"
5	"sync"	5		"sync"
		6	+	"time"
6		7
7	"github.com/bnema/vev/internal/domain"	8		"github.com/bnema/vev/internal/domain"
8	"github.com/bnema/vev/internal/ports"	9		"github.com/bnema/vev/internal/ports"

@@ -26,6 +27,8 @@ type pane struct {
26	syncGen uint64	27		syncGen uint64
27	rect domain.Rect	28		rect domain.Rect
28	title string	29		title string
		30	+	titleAt time.Time
		31	+	titleValid bool
29	ctx context.Context	32		ctx context.Context
30	cancel context.CancelFunc	33		cancel context.CancelFunc
31	}	34		}

M internal/usecase/daemon/pane_actions.go +5 -24


@@ -42,7 +42,6 @@ func (d Daemon) splitPane(sess session, ac *attachedClient, dir layout.Directi
42	42		if !ok {
43	43		_ = tb.tree.Close(newID)
44	44		tb.tree.Focus = oldFocus
45		-	tb.nextPaneID--
46	45		tb.mu.Unlock()
47	46		return layout.ErrTooSmall
48	47		}

@@ -54,7 +53,6 @@ func (d Daemon) splitPane(sess session, ac *attachedClient, dir layout.Directi
54	53		tb.mu.Lock()
55	54		_ = tb.tree.Close(newID)
56	55		tb.tree.Focus = oldFocus
57		-	tb.nextPaneID--
58	56		tb.mu.Unlock()
59	57		return err
60	58		}

@@ -65,7 +63,7 @@ func (d Daemon) splitPane(sess session, ac *attachedClient, dir layout.Directi
65	63		p.rect = newRect
66	64
67	65		tb.mu.Lock()
68		-	if _, ok := tb.panes[newID]; ok \|\| !layoutContains(tb.tree.Root, newID) {
	66	+	if _, ok := tb.panes[newID]; ok \|\| !layout.ContainsLeaf(tb.tree.Root, newID) {
69	67		tb.mu.Unlock()
70	68		cancel()
71	69		_ = pty.Close()

@@ -135,21 +133,6 @@ func placementContent(placements []layout.Placement, id layout.PaneID) domain.Re
135	133
136	134		func rectSize(r domain.Rect) domain.Size { return domain.Size{Cols: r.Width, Rows: r.Height} }
137	135
138		-	func layoutContains(n *layout.Node, id layout.PaneID) bool {
139		-	if n == nil {
140		-	return false
141		-	}
142		-	if n.Kind == layout.Leaf {
143		-	return n.Leaf == id
144		-	}
145		-	for _, child := range n.Children {
146		-	if layoutContains(child, id) {
147		-	return true
148		-	}
149		-	}
150		-	return false
151		-	}
152		-
153	136		func (d Daemon) stackPane(sess session, ac *attachedClient) error {
154	137		if d.ptys == nil {
155	138		if ac != nil {

@@ -183,7 +166,6 @@ func (d Daemon) stackPane(sess session, ac *attachedClient) error {
183	166		if !ok {
184	167		_ = tb.tree.Close(newID)
185	168		tb.tree.Focus = oldFocus
186		-	tb.nextPaneID--
187	169		tb.mu.Unlock()
188	170		return layout.ErrTooSmall
189	171		}

@@ -195,7 +177,6 @@ func (d Daemon) stackPane(sess session, ac *attachedClient) error {
195	177		tb.mu.Lock()
196	178		_ = tb.tree.Close(newID)
197	179		tb.tree.Focus = oldFocus
198		-	tb.nextPaneID--
199	180		tb.mu.Unlock()
200	181		return err
201	182		}

@@ -206,7 +187,7 @@ func (d Daemon) stackPane(sess session, ac *attachedClient) error {
206	187		p.rect = newRect
207	188
208	189		tb.mu.Lock()
209		-	if _, ok := tb.panes[newID]; ok \|\| !layoutContains(tb.tree.Root, newID) {
	190	+	if _, ok := tb.panes[newID]; ok \|\| !layout.ContainsLeaf(tb.tree.Root, newID) {
210	191		tb.mu.Unlock()
211	192		cancel()
212	193		_ = pty.Close()

@@ -281,11 +262,11 @@ func (d Daemon) closePane(sess session, tb tab, id layout.PaneID, ac attache
281	262		}
282	263		tb.mu.Lock()
283	264		p := tb.panes[id]
284		-	if p == nil \|\| tb.tree == nil \|\| !layoutContains(tb.tree.Root, id) {
	265	+	if p == nil \|\| tb.tree == nil \|\| !layout.ContainsLeaf(tb.tree.Root, id) {
285	266		tb.mu.Unlock()
286	267		return nil
287	268		}
288		-	if len(tb.panes) <= 1 {
	269	+	if len(layout.LeafIDs(tb.tree.Root)) <= 1 {
289	270		tb.mu.Unlock()
290	271		d.closeTab(sess, tb, repaint)
291	272		return nil

@@ -339,7 +320,7 @@ func (d Daemon) focusDir(sess session, ac *attachedClient, dir layout.Directio
339	320		pl, ok := focusedPlacementLocked(tb)
340	321		tb.mu.Unlock()
341	322		if ok && pl.TitleBar.Height > 0 {
342		-	d.refreshPaneTitle(sess, newFocus)
	323	+	d.refreshPaneTitleOnFocus(sess, newFocus)
343	324		}
344	325		}
345	326		d.paint(sess, ac, true)

 	if !ok {
 		_ = tb.tree.Close(newID)
 		tb.tree.Focus = oldFocus
-		tb.nextPaneID--
 		tb.mu.Unlock()
 		return layout.ErrTooSmall
 	}
 		tb.mu.Lock()
 		_ = tb.tree.Close(newID)
 		tb.tree.Focus = oldFocus
-		tb.nextPaneID--
 		tb.mu.Unlock()
 		return err
 	}
 	p.rect = newRect
 	tb.mu.Lock()
-	if _, ok := tb.panes[newID]; ok || !layoutContains(tb.tree.Root, newID) {
+	if _, ok := tb.panes[newID]; ok || !layout.ContainsLeaf(tb.tree.Root, newID) {
 		tb.mu.Unlock()
 		cancel()
 		_ = pty.Close()
 func rectSize(r domain.Rect) domain.Size { return domain.Size{Cols: r.Width, Rows: r.Height} }
-func layoutContains(n *layout.Node, id layout.PaneID) bool {
-	if n == nil {
-		return false
-	}
-	if n.Kind == layout.Leaf {
-		return n.Leaf == id
-	}
-	for _, child := range n.Children {
-		if layoutContains(child, id) {
-			return true
-		}
-	}
-	return false
-}
 func (d *Daemon) stackPane(sess *session, ac *attachedClient) error {
 	if d.ptys == nil {
 		if ac != nil {
 	if !ok {
 		_ = tb.tree.Close(newID)
 		tb.tree.Focus = oldFocus
-		tb.nextPaneID--
 		tb.mu.Unlock()
 		return layout.ErrTooSmall
 	}
 		tb.mu.Lock()
 		_ = tb.tree.Close(newID)
 		tb.tree.Focus = oldFocus
-		tb.nextPaneID--
 		tb.mu.Unlock()
 		return err
 	}
 	p.rect = newRect
 	tb.mu.Lock()
-	if _, ok := tb.panes[newID]; ok || !layoutContains(tb.tree.Root, newID) {
+	if _, ok := tb.panes[newID]; ok || !layout.ContainsLeaf(tb.tree.Root, newID) {
 		tb.mu.Unlock()
 		cancel()
 		_ = pty.Close()
 	}
 	tb.mu.Lock()
 	p := tb.panes[id]
-	if p == nil || tb.tree == nil || !layoutContains(tb.tree.Root, id) {
+	if p == nil || tb.tree == nil || !layout.ContainsLeaf(tb.tree.Root, id) {
 		tb.mu.Unlock()
 		return nil
 	}
-	if len(tb.panes) <= 1 {
+	if len(layout.LeafIDs(tb.tree.Root)) <= 1 {
 		tb.mu.Unlock()
 		d.closeTab(sess, tb, repaint)
 		return nil
 			pl, ok := focusedPlacementLocked(tb)
 			tb.mu.Unlock()
 			if ok && pl.TitleBar.Height > 0 {
-				d.refreshPaneTitle(sess, newFocus)
+				d.refreshPaneTitleOnFocus(sess, newFocus)
 			}
 		}
 		d.paint(sess, ac, true)

M internal/usecase/daemon/pane_actions_test.go +42 -1


@@ -72,7 +72,7 @@ func TestSplitPaneOpenErrorRollsBackTreeAndPaneMap(t *testing.T) {
72	72		defer tb.mu.Unlock()
73	73		require.Equal(t, beforeRoot, tb.tree.Root.Leaf)
74	74		require.Equal(t, beforeFocus, tb.tree.Focus)
75		-	require.Equal(t, beforeNext, tb.nextPaneID)
	75	+	require.Equal(t, beforeNext+1, tb.nextPaneID)
76	76		require.Len(t, tb.panes, beforePaneCount)
77	77		require.Nil(t, tb.panes["pane-2"])
78	78		}

@@ -173,6 +173,19 @@ func TestReapPaneSharesClosePathAndIsIdempotent(t *testing.T) {
173	173		require.NotContains(t, tb.panes, layout.PaneID("pane-2"))
174	174		}
175	175
	176	+	func TestClosePaneKeepsTabOpenWhenPendingSpawnLeafExists(t *testing.T) {
	177	+	d, sess, oldPTY, _ := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})
	178	+	tb := sess.activeTab()
	179	+	tb.tree = &layout.Tree{Root: &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}}, Focus: "pane-2"}
	180	+	oldPTY.EXPECT().Close().Return(nil).Once()
	181	+
	182	+	require.NoError(t, d.closePane(sess, tb, "pane-1", nil, false))
	183	+
	184	+	require.Len(t, sess.tabs, 1)
	185	+	require.Empty(t, tb.panes)
	186	+	require.True(t, layout.ContainsLeaf(tb.tree.Root, "pane-2"))
	187	+	}
	188	+
176	189		func TestCloseFocusedLastPaneDelegatesToCloseTab(t *testing.T) {
177	190		d, sess, oldPTY, _ := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})
178	191		otherPTY := portsmocks.NewMockPTY(t)

@@ -243,6 +256,34 @@ func newSplitTestDaemon(t testing.T, sz domain.Size) (Daemon, session, ports
243	256		return d, sess, oldPTY, factory
244	257		}
245	258
	259	+	func TestCloseOriginalPaneLeavesSurvivorFunctional(t *testing.T) {
	260	+	writes := make(chan []byte, 1)
	261	+	d, sess, oldPTY, factory := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})
	262	+	newPTY, releaseNew := newBlockingPTYWithWrites(t, writes)
	263	+	defer releaseNew()
	264	+	oldPTY.EXPECT().Resize(domain.Size{Cols: 20, Rows: 10}).Return(nil).Once()
	265	+	newPTY.EXPECT().Read(mock.Anything).RunAndReturn(blockingRead(t)).Maybe()
	266	+	factory.EXPECT().Open("/bin/sh", []string(nil), mock.Anything, "/work", domain.Size{Cols: 20, Rows: 10}).Return(newPTY, nil).Once()
	267	+
	268	+	require.NoError(t, d.splitPane(sess, nil, layout.Right))
	269	+	tb := sess.activeTab()
	270	+	tb.mu.Lock()
	271	+	tb.tree.Focus = "pane-1"
	272	+	tb.mu.Unlock()
	273	+	oldPTY.EXPECT().Close().Return(nil).Once()
	274	+
	275	+	require.NoError(t, d.closePane(sess, tb, "pane-1", nil, false))
	276	+	require.Equal(t, layout.PaneID("pane-2"), tb.focusedPane().id)
	277	+
	278	+	ac := &attachedClient{}
	279	+	ac.setSession(sess)
	280	+	daemonKeyHandler{d: d, ac: ac}.Forward([]byte("Z"))
	281	+	require.Equal(t, []byte("Z"), <-writes)
	282	+	tb.focusedPane().screen.Write([]byte("survivor"))
	283	+	frame, _ := composeClientFrame(sess, tb, false, "")
	284	+	require.Contains(t, frameRowString(frame, 1), "survivor")
	285	+	}
	286	+
246	287		func blockingRead(t *testing.T) func([]byte) (int, error) {
247	288		t.Helper()
248	289		ch := make(chan struct{})


@@ -72,7 +72,7 @@ func TestSplitPaneOpenErrorRollsBackTreeAndPaneMap(t *testing.T) {
72		defer tb.mu.Unlock()	72		defer tb.mu.Unlock()
73		require.Equal(t, beforeRoot, tb.tree.Root.Leaf)	73		require.Equal(t, beforeRoot, tb.tree.Root.Leaf)
74		require.Equal(t, beforeFocus, tb.tree.Focus)	74		require.Equal(t, beforeFocus, tb.tree.Focus)
75	-	require.Equal(t, beforeNext, tb.nextPaneID)	75	+	require.Equal(t, beforeNext+1, tb.nextPaneID)
76		require.Len(t, tb.panes, beforePaneCount)	76		require.Len(t, tb.panes, beforePaneCount)
77		require.Nil(t, tb.panes["pane-2"])	77		require.Nil(t, tb.panes["pane-2"])
78		}	78		}

@@ -173,6 +173,19 @@ func TestReapPaneSharesClosePathAndIsIdempotent(t *testing.T) {
173		require.NotContains(t, tb.panes, layout.PaneID("pane-2"))	173		require.NotContains(t, tb.panes, layout.PaneID("pane-2"))
174		}	174		}
175			175
			176	+	func TestClosePaneKeepsTabOpenWhenPendingSpawnLeafExists(t *testing.T) {
			177	+	d, sess, oldPTY, _ := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})
			178	+	tb := sess.activeTab()
			179	+	tb.tree = &layout.Tree{Root: &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf("pane-1"), layout.NewLeaf("pane-2")}}, Focus: "pane-2"}
			180	+	oldPTY.EXPECT().Close().Return(nil).Once()
			181	+
			182	+	require.NoError(t, d.closePane(sess, tb, "pane-1", nil, false))
			183	+
			184	+	require.Len(t, sess.tabs, 1)
			185	+	require.Empty(t, tb.panes)
			186	+	require.True(t, layout.ContainsLeaf(tb.tree.Root, "pane-2"))
			187	+	}
			188	+
176		func TestCloseFocusedLastPaneDelegatesToCloseTab(t *testing.T) {	189		func TestCloseFocusedLastPaneDelegatesToCloseTab(t *testing.T) {
177		d, sess, oldPTY, _ := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})	190		d, sess, oldPTY, _ := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})
178		otherPTY := portsmocks.NewMockPTY(t)	191		otherPTY := portsmocks.NewMockPTY(t)

@@ -243,6 +256,34 @@ func newSplitTestDaemon(t testing.T, sz domain.Size) (Daemon, session, ports
243		return d, sess, oldPTY, factory	256		return d, sess, oldPTY, factory
244		}	257		}
245			258
			259	+	func TestCloseOriginalPaneLeavesSurvivorFunctional(t *testing.T) {
			260	+	writes := make(chan []byte, 1)
			261	+	d, sess, oldPTY, factory := newSplitTestDaemon(t, domain.Size{Cols: 41, Rows: 10})
			262	+	newPTY, releaseNew := newBlockingPTYWithWrites(t, writes)
			263	+	defer releaseNew()
			264	+	oldPTY.EXPECT().Resize(domain.Size{Cols: 20, Rows: 10}).Return(nil).Once()
			265	+	newPTY.EXPECT().Read(mock.Anything).RunAndReturn(blockingRead(t)).Maybe()
			266	+	factory.EXPECT().Open("/bin/sh", []string(nil), mock.Anything, "/work", domain.Size{Cols: 20, Rows: 10}).Return(newPTY, nil).Once()
			267	+
			268	+	require.NoError(t, d.splitPane(sess, nil, layout.Right))
			269	+	tb := sess.activeTab()
			270	+	tb.mu.Lock()
			271	+	tb.tree.Focus = "pane-1"
			272	+	tb.mu.Unlock()
			273	+	oldPTY.EXPECT().Close().Return(nil).Once()
			274	+
			275	+	require.NoError(t, d.closePane(sess, tb, "pane-1", nil, false))
			276	+	require.Equal(t, layout.PaneID("pane-2"), tb.focusedPane().id)
			277	+
			278	+	ac := &attachedClient{}
			279	+	ac.setSession(sess)
			280	+	daemonKeyHandler{d: d, ac: ac}.Forward([]byte("Z"))
			281	+	require.Equal(t, []byte("Z"), <-writes)
			282	+	tb.focusedPane().screen.Write([]byte("survivor"))
			283	+	frame, _ := composeClientFrame(sess, tb, false, "")
			284	+	require.Contains(t, frameRowString(frame, 1), "survivor")
			285	+	}
			286	+
246		func blockingRead(t *testing.T) func([]byte) (int, error) {	287		func blockingRead(t *testing.T) func([]byte) (int, error) {
247		t.Helper()	288		t.Helper()
248		ch := make(chan struct{})	289		ch := make(chan struct{})

M internal/usecase/daemon/pane_titles.go +25 -10


@@ -3,11 +3,22 @@ package daemon
3	3		import (
4	4		"path/filepath"
5	5		"strings"
	6	+	"time"
6	7
7	8		"github.com/bnema/vev/internal/usecase/layout"
8	9		)
9	10
	11	+	const paneTitleCacheTTL = time.Second
	12	+
10	13		func (d Daemon) refreshPaneTitle(sess session, id layout.PaneID) string {
	14	+	return d.refreshPaneTitleCached(sess, id, false)
	15	+	}
	16	+
	17	+	func (d Daemon) refreshPaneTitleOnFocus(sess session, id layout.PaneID) string {
	18	+	return d.refreshPaneTitleCached(sess, id, true)
	19	+	}
	20	+
	21	+	func (d Daemon) refreshPaneTitleCached(sess session, id layout.PaneID, force bool) string {
11	22		fallback := filepath.Base(d.shell)
12	23		if fallback == "." \|\| fallback == string(filepath.Separator) \|\| fallback == "" {
13	24		fallback = d.shell

@@ -25,9 +36,20 @@ func (d Daemon) refreshPaneTitle(sess session, id layout.PaneID) string {
25	36		if p == nil {
26	37		return fallback
27	38		}
	39	+	now := d.clock.Now()
	40	+	p.mu.Lock()
	41	+	if !force && p.titleValid && now.Sub(p.titleAt) < paneTitleCacheTTL {
	42	+	title := p.title
	43	+	p.mu.Unlock()
	44	+	if title == "" {
	45	+	return fallback
	46	+	}
	47	+	return title
	48	+	}
	49	+	p.mu.Unlock()
28	50		title := fallback
29	51		if d.procComm != nil && p.pty != nil {
30		-	if pgid, err := foregroundPgid(p.pty); err == nil && pgid > 0 {
	52	+	if pgid, err := p.pty.ForegroundPgid(); err == nil && pgid > 0 {
31	53		if comm, err := d.procComm(pgid); err == nil && strings.TrimSpace(comm) != "" {
32	54		title = strings.TrimSpace(comm)
33	55		}

@@ -35,15 +57,8 @@ func (d Daemon) refreshPaneTitle(sess session, id layout.PaneID) string {
35	57		}
36	58		p.mu.Lock()
37	59		p.title = title
	60	+	p.titleAt = now
	61	+	p.titleValid = true
38	62		p.mu.Unlock()
39	63		return title
40	64		}
41		-
42		-	func foregroundPgid(pty interface{ ForegroundPgid() (int, error) }) (pgid int, err error) {
43		-	defer func() {
44		-	if recover() != nil {
45		-	pgid = 0
46		-	}
47		-	}()
48		-	return pty.ForegroundPgid()
49		-	}

 import (
 	"path/filepath"
 	"strings"
+	"time"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
+const paneTitleCacheTTL = time.Second
 func (d *Daemon) refreshPaneTitle(sess *session, id layout.PaneID) string {
+	return d.refreshPaneTitleCached(sess, id, false)
+}
+func (d *Daemon) refreshPaneTitleOnFocus(sess *session, id layout.PaneID) string {
+	return d.refreshPaneTitleCached(sess, id, true)
+}
+func (d *Daemon) refreshPaneTitleCached(sess *session, id layout.PaneID, force bool) string {
 	fallback := filepath.Base(d.shell)
 	if fallback == "." || fallback == string(filepath.Separator) || fallback == "" {
 		fallback = d.shell
 	if p == nil {
 		return fallback
 	}
+	now := d.clock.Now()
+	p.mu.Lock()
+	if !force && p.titleValid && now.Sub(p.titleAt) < paneTitleCacheTTL {
+		title := p.title
+		p.mu.Unlock()
+		if title == "" {
+			return fallback
+		}
+		return title
+	}
+	p.mu.Unlock()
 	title := fallback
 	if d.procComm != nil && p.pty != nil {
-		if pgid, err := foregroundPgid(p.pty); err == nil && pgid > 0 {
+		if pgid, err := p.pty.ForegroundPgid(); err == nil && pgid > 0 {
 			if comm, err := d.procComm(pgid); err == nil && strings.TrimSpace(comm) != "" {
 				title = strings.TrimSpace(comm)
 			}
 	}
 	p.mu.Lock()
 	p.title = title
+	p.titleAt = now
+	p.titleValid = true
 	p.mu.Unlock()
 	return title
 }
-func foregroundPgid(pty interface{ ForegroundPgid() (int, error) }) (pgid int, err error) {
-	defer func() {
-		if recover() != nil {
-			pgid = 0
-		}
-	}()
-	return pty.ForegroundPgid()
-}

M internal/usecase/daemon/pane_titles_test.go +25 -0


@@ -2,7 +2,9 @@ package daemon
2	2
3	3		import (
4	4		"errors"
	5	+	"sync/atomic"
5	6		"testing"
	7	+	"time"
6	8
7	9		"github.com/stretchr/testify/require"
8	10

@@ -26,6 +28,29 @@ func TestRefreshPaneTitleUsesForegroundProcessComm(t *testing.T) {
26	28		require.Equal(t, "vim", sess.activeTab().focusedPane().title)
27	29		}
28	30
	31	+	func TestRefreshPaneTitleCachesByTTLAndRefreshesOnFocus(t *testing.T) {
	32	+	pty := portsmocks.NewMockPTY(t)
	33	+	pty.EXPECT().ForegroundPgid().Return(1234, nil).Twice()
	34	+	_, sess, _, _ := newManualSessionWithPTYs(t, pty)
	35	+	clk := portsmocks.NewMockClock(t)
	36	+	now := time.Unix(10, 0)
	37	+	clk.EXPECT().Now().RunAndReturn(func() time.Time { return now }).Maybe()
	38	+	d := newTestDaemon(t, nil, clk)
	39	+	var calls atomic.Int32
	40	+	d.procComm = func(pid int) (string, error) {
	41	+	require.Equal(t, 1234, pid)
	42	+	calls.Add(1)
	43	+	return "vim\n", nil
	44	+	}
	45	+
	46	+	require.Equal(t, "vim", d.refreshPaneTitle(sess, "pane-1"))
	47	+	now = now.Add(paneTitleCacheTTL / 2)
	48	+	require.Equal(t, "vim", d.refreshPaneTitle(sess, "pane-1"))
	49	+	require.Equal(t, int32(1), calls.Load(), "paint refresh inside TTL should use cached title")
	50	+	require.Equal(t, "vim", d.refreshPaneTitleOnFocus(sess, "pane-1"))
	51	+	require.Equal(t, int32(2), calls.Load(), "focus refresh should bypass TTL")
	52	+	}
	53	+
29	54		func TestRefreshPaneTitleFallsBackToShellBase(t *testing.T) {
30	55		pty := portsmocks.NewMockPTY(t)
31	56		pty.EXPECT().ForegroundPgid().Return(0, errors.New("no foreground process")).Once()


@@ -2,7 +2,9 @@ package daemon
2		2
3	import (	3		import (
4	"errors"	4		"errors"
		5	+	"sync/atomic"
5	"testing"	6		"testing"
		7	+	"time"
6		8
7	"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
8		10

@@ -26,6 +28,29 @@ func TestRefreshPaneTitleUsesForegroundProcessComm(t *testing.T) {
26	require.Equal(t, "vim", sess.activeTab().focusedPane().title)	28		require.Equal(t, "vim", sess.activeTab().focusedPane().title)
27	}	29		}
28		30
		31	+	func TestRefreshPaneTitleCachesByTTLAndRefreshesOnFocus(t *testing.T) {
		32	+	pty := portsmocks.NewMockPTY(t)
		33	+	pty.EXPECT().ForegroundPgid().Return(1234, nil).Twice()
		34	+	_, sess, _, _ := newManualSessionWithPTYs(t, pty)
		35	+	clk := portsmocks.NewMockClock(t)
		36	+	now := time.Unix(10, 0)
		37	+	clk.EXPECT().Now().RunAndReturn(func() time.Time { return now }).Maybe()
		38	+	d := newTestDaemon(t, nil, clk)
		39	+	var calls atomic.Int32
		40	+	d.procComm = func(pid int) (string, error) {
		41	+	require.Equal(t, 1234, pid)
		42	+	calls.Add(1)
		43	+	return "vim\n", nil
		44	+	}
		45	+
		46	+	require.Equal(t, "vim", d.refreshPaneTitle(sess, "pane-1"))
		47	+	now = now.Add(paneTitleCacheTTL / 2)
		48	+	require.Equal(t, "vim", d.refreshPaneTitle(sess, "pane-1"))
		49	+	require.Equal(t, int32(1), calls.Load(), "paint refresh inside TTL should use cached title")
		50	+	require.Equal(t, "vim", d.refreshPaneTitleOnFocus(sess, "pane-1"))
		51	+	require.Equal(t, int32(2), calls.Load(), "focus refresh should bypass TTL")
		52	+	}
		53	+
29	func TestRefreshPaneTitleFallsBackToShellBase(t *testing.T) {	54		func TestRefreshPaneTitleFallsBackToShellBase(t *testing.T) {
30	pty := portsmocks.NewMockPTY(t)	55		pty := portsmocks.NewMockPTY(t)
31	pty.EXPECT().ForegroundPgid().Return(0, errors.New("no foreground process")).Once()	56		pty.EXPECT().ForegroundPgid().Return(0, errors.New("no foreground process")).Once()

M internal/usecase/daemon/picker_test.go +18 -10


@@ -12,11 +12,19 @@ import (
12	12		"github.com/bnema/vev/internal/ports"
13	13		"github.com/bnema/vev/internal/usecase/keys"
14	14		"github.com/bnema/vev/pkg/renderer"
15		-	"github.com/bnema/vev/pkg/vt"
16	15		)
17	16
18	17		// --- test doubles -----------------------------------------------------------
19	18
	19	+	func newTestTabWithContext(p ports.PTY, ctx context.Context, cancel context.CancelFunc) *tab {
	20	+	tb := newTab(p, domain.Size{Cols: 80, Rows: 23})
	21	+	tb.ctx, tb.cancel = ctx, cancel
	22	+	for _, pane := range tb.panes {
	23	+	pane.ctx, pane.cancel = ctx, cancel
	24	+	}
	25	+	return tb
	26	+	}
	27	+
20	28		// stubClock returns timers whose channel never fires, so a scheduler under it
21	29		// blocks in its debounce loop until the session context is cancelled. Used by
22	30

@@ -144,8 +152,8 @@ func TestPickerCrossSessionSwitchDetachesExistingClient(t *testing.T) {
144	152		sctx2, cancel2 := context.WithCancel(d.serveCtx)
145	153		defer cancel1()
146	154		defer cancel2()
147		-	sess1 := &session{id: "s1", name: "alpha", ephemeral: true, ctx: sctx1, cancel: cancel1, tabs: []*tab{{pty: p1, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx1, cancel: cancel1}}, client: ac1}
148		-	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{{pty: p2, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx2, cancel: cancel2}}, client: ac2}
	155	+	sess1 := &session{id: "s1", name: "alpha", ephemeral: true, ctx: sctx1, cancel: cancel1, tabs: []*tab{newTestTabWithContext(p1, sctx1, cancel1)}, client: ac1}
	156	+	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{newTestTabWithContext(p2, sctx2, cancel2)}, client: ac2}
149	157		ac1.setSession(sess1)
150	158		ac2.setSession(sess2)
151	159		ac1.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: ac1})

@@ -185,9 +193,9 @@ func TestPickerLivePreviewRepaintsInactiveTab(t *testing.T) {
185	193
186	194		previewTab := sess.tabs[1]
187	195		previewTab.mu.Lock()
188		-	previewTab.screen.Write([]byte("inactive-preview-live"))
	196	+	previewTab.focusedPane().screen.Write([]byte("inactive-preview-live"))
189	197		previewTab.mu.Unlock()
190		-	d.render(sess, previewTab)
	198	+	d.render(sess, previewTab, previewTab.focusedPane())
191	199
192	200		previewOut := awaitFrame(t, sends, ports.MsgOutput)
193	201		previewMsg, err := ports.UnmarshalOutput(previewOut.Payload)

@@ -209,8 +217,8 @@ func TestPickerLivePreviewRepaintsCrossSessionTab(t *testing.T) {
209	217		sctx2, cancel2 := context.WithCancel(d.serveCtx)
210	218		defer cancel1()
211	219		defer cancel2()
212		-	sess1 := &session{id: "s1", name: "alpha", ctx: sctx1, cancel: cancel1, tabs: []*tab{{pty: p1, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx1, cancel: cancel1}}, client: ac1}
213		-	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{{pty: p2, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx2, cancel: cancel2}}, client: ac2}
	220	+	sess1 := &session{id: "s1", name: "alpha", ctx: sctx1, cancel: cancel1, tabs: []*tab{newTestTabWithContext(p1, sctx1, cancel1)}, client: ac1}
	221	+	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{newTestTabWithContext(p2, sctx2, cancel2)}, client: ac2}
214	222		ac1.setSession(sess1)
215	223		ac2.setSession(sess2)
216	224		ac1.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: ac1})

@@ -225,9 +233,9 @@ func TestPickerLivePreviewRepaintsCrossSessionTab(t *testing.T) {
225	233
226	234		previewTab := sess2.tabs[0]
227	235		previewTab.mu.Lock()
228		-	previewTab.screen.Write([]byte("cross-session-preview-live"))
	236	+	previewTab.focusedPane().screen.Write([]byte("cross-session-preview-live"))
229	237		previewTab.mu.Unlock()
230		-	d.render(sess2, previewTab)
	238	+	d.render(sess2, previewTab, previewTab.focusedPane())
231	239
232	240		previewOut := awaitFrame(t, sends1, ports.MsgOutput)
233	241		previewMsg, err := ports.UnmarshalOutput(previewOut.Payload)

@@ -277,7 +285,7 @@ func TestPickerOpenCloseNavigationConcurrentWithRenderRace(t *testing.T) {
277	285		p.screen.Write([]byte("render-race"))
278	286		p.mu.Unlock()
279	287		}
280		-	d.render(sess, tb)
	288	+	d.render(sess, tb, tb.focusedPane())
281	289		})
282	290		}
283	291		wg.Wait()

 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/pkg/renderer"
-	"github.com/bnema/vev/pkg/vt"
 )
 // --- test doubles -----------------------------------------------------------
+func newTestTabWithContext(p ports.PTY, ctx context.Context, cancel context.CancelFunc) *tab {
+	tb := newTab(p, domain.Size{Cols: 80, Rows: 23})
+	tb.ctx, tb.cancel = ctx, cancel
+	for _, pane := range tb.panes {
+		pane.ctx, pane.cancel = ctx, cancel
+	}
+	return tb
+}
 // stubClock returns timers whose channel never fires, so a scheduler under it
 // blocks in its debounce loop until the session context is cancelled. Used by
 	sctx2, cancel2 := context.WithCancel(d.serveCtx)
 	defer cancel1()
 	defer cancel2()
-	sess1 := &session{id: "s1", name: "alpha", ephemeral: true, ctx: sctx1, cancel: cancel1, tabs: []*tab{{pty: p1, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx1, cancel: cancel1}}, client: ac1}
+	sess1 := &session{id: "s1", name: "alpha", ephemeral: true, ctx: sctx1, cancel: cancel1, tabs: []*tab{newTestTabWithContext(p1, sctx1, cancel1)}, client: ac1}
-	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{{pty: p2, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx2, cancel: cancel2}}, client: ac2}
+	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{newTestTabWithContext(p2, sctx2, cancel2)}, client: ac2}
 	ac1.setSession(sess1)
 	ac2.setSession(sess2)
 	ac1.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: ac1})
 	previewTab := sess.tabs[1]
 	previewTab.mu.Lock()
-	previewTab.screen.Write([]byte("inactive-preview-live"))
+	previewTab.focusedPane().screen.Write([]byte("inactive-preview-live"))
 	previewTab.mu.Unlock()
-	d.render(sess, previewTab)
+	d.render(sess, previewTab, previewTab.focusedPane())
 	previewOut := awaitFrame(t, sends, ports.MsgOutput)
 	previewMsg, err := ports.UnmarshalOutput(previewOut.Payload)
 	sctx2, cancel2 := context.WithCancel(d.serveCtx)
 	defer cancel1()
 	defer cancel2()
-	sess1 := &session{id: "s1", name: "alpha", ctx: sctx1, cancel: cancel1, tabs: []*tab{{pty: p1, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx1, cancel: cancel1}}, client: ac1}
+	sess1 := &session{id: "s1", name: "alpha", ctx: sctx1, cancel: cancel1, tabs: []*tab{newTestTabWithContext(p1, sctx1, cancel1)}, client: ac1}
-	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{{pty: p2, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: sctx2, cancel: cancel2}}, client: ac2}
+	sess2 := &session{id: "s2", name: "beta", ctx: sctx2, cancel: cancel2, tabs: []*tab{newTestTabWithContext(p2, sctx2, cancel2)}, client: ac2}
 	ac1.setSession(sess1)
 	ac2.setSession(sess2)
 	ac1.keys = keys.NewRouter(d.clock, daemonKeyHandler{d: d, ac: ac1})
 	previewTab := sess2.tabs[0]
 	previewTab.mu.Lock()
-	previewTab.screen.Write([]byte("cross-session-preview-live"))
+	previewTab.focusedPane().screen.Write([]byte("cross-session-preview-live"))
 	previewTab.mu.Unlock()
-	d.render(sess2, previewTab)
+	d.render(sess2, previewTab, previewTab.focusedPane())
 	previewOut := awaitFrame(t, sends1, ports.MsgOutput)
 	previewMsg, err := ports.UnmarshalOutput(previewOut.Payload)
 				p.screen.Write([]byte("render-race"))
 				p.mu.Unlock()
 			}
-			d.render(sess, tb)
+			d.render(sess, tb, tb.focusedPane())
 		})
 	}
 	wg.Wait()

M internal/usecase/daemon/prompt_test.go +1 -3


@@ -4,9 +4,7 @@ import (
4	4		"context"
5	5		"testing"
6	6
7		-	"github.com/bnema/vev/internal/domain"
8	7		"github.com/bnema/vev/internal/ports"
9		-	"github.com/bnema/vev/pkg/vt"
10	8		"github.com/stretchr/testify/require"
11	9		)
12	10

@@ -53,7 +51,7 @@ func TestPromptSubmitErrorKeepsPromptOpen(t *testing.T) {
53	51		defer release2()
54	52		ctx, cancel := context.WithCancel(context.Background())
55	53		defer cancel()
56		-	d.sessions["other"] = &session{id: "other", name: "taken", ctx: ctx, cancel: cancel, tabs: []*tab{{pty: p2, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: ctx, cancel: cancel}}}
	54	+	d.sessions["other"] = &session{id: "other", name: "taken", ctx: ctx, cancel: cancel, tabs: []*tab{newTestTabWithContext(p2, ctx, cancel)}}
57	55
58	56		d.enterPrompt(sess, ac, " Rename session ", "", func(name string) error { return d.renameSession(sess, name) })
59	57		awaitFrame(t, sends, ports.MsgOutput)

 	"context"
 	"testing"
-	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
-	"github.com/bnema/vev/pkg/vt"
 	"github.com/stretchr/testify/require"
 )
 	defer release2()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	d.sessions["other"] = &session{id: "other", name: "taken", ctx: ctx, cancel: cancel, tabs: []*tab{{pty: p2, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}, ctx: ctx, cancel: cancel}}}
+	d.sessions["other"] = &session{id: "other", name: "taken", ctx: ctx, cancel: cancel, tabs: []*tab{newTestTabWithContext(p2, ctx, cancel)}}
 	d.enterPrompt(sess, ac, " Rename session ", "", func(name string) error { return d.renameSession(sess, name) })
 	awaitFrame(t, sends, ports.MsgOutput)

M internal/usecase/daemon/render.go +32 -28


@@ -45,14 +45,8 @@ func signal(ch chan struct{}) {
45	45		}
46	46		}
47	47
48		-	func (d Daemon) ptyReader(sess session, tb tab, panes ...pane) {
	48	+	func (d Daemon) ptyReader(sess session, tb tab, p pane) {
49	49		defer d.sessWg.Done()
50		-	var p *pane
51		-	if len(panes) > 0 {
52		-	p = panes[0]
53		-	} else {
54		-	p = tb.focusedPane()
55		-	}
56	50		if p == nil {
57	51		return
58	52		}

@@ -112,14 +106,8 @@ func (d Daemon) ptyReader(sess session, tb tab, panes ...pane) {
112	106		// scheduler debounces dirty signals. The first dirty opens a short tab;
113	107		// sustained floods progressively widen that tab, while isolated updates
114	108		// return to the minimum delay for interactive latency.
115		-	func (d Daemon) scheduler(sess session, tb tab, panes ...pane) {
	109	+	func (d Daemon) scheduler(sess session, tb tab, p pane) {
116	110		defer d.sessWg.Done()
117		-	var p *pane
118		-	if len(panes) > 0 {
119		-	p = panes[0]
120		-	} else {
121		-	p = tb.focusedPane()
122		-	}
123	111		if p == nil {
124	112		return
125	113		}

@@ -133,7 +121,7 @@ outer:
133	121		case <-paneDone(p):
134	122		return
135	123		case <-p.flush:
136		-	d.render(sess, tb)
	124	+	d.render(sess, tb, p)
137	125		lastRender = d.clock.Now()
138	126		continue
139	127		case <-p.dirty:

@@ -160,7 +148,7 @@ outer:
160	148		default:
161	149		}
162	150		}
163		-	d.render(sess, tb)
	151	+	d.render(sess, tb, p)
164	152		lastRender = d.clock.Now()
165	153		continue outer
166	154		case <-p.dirty:

@@ -170,7 +158,7 @@ outer:
170	158		}
171	159		}
172	160		delay = nextDebounceDelay(delay, coalesced)
173		-	d.render(sess, tb)
	161	+	d.render(sess, tb, p)
174	162		lastRender = d.clock.Now()
175	163		}
176	164		}

@@ -214,9 +202,8 @@ func syncUpdateEndIn(data []byte) bool {
214	202
215	203		// render paints the current client, or (when detached) just clears accumulated
216	204		// damage so it never grows unbounded while headless.
217		-	func (d Daemon) render(sess session, tb *tab) {
	205	+	func (d Daemon) render(sess session, tb tab, p pane) {
218	206		tb.mu.Lock()
219		-	p := tb.focusedPane()
220	207		previewer := tb.previewClient
221	208		tb.mu.Unlock()
222	209		if p == nil {

@@ -470,7 +457,16 @@ func composeClientFrameWithState(bars barState, tb tab, full bool, caches ...b
470	457		}
471	458		p := tb.focusedPane()
472	459		styles := newThemeStyles(bars.theme)
	460	+	if p == nil {
	461	+	width, screenRows := tb.size.Cols, tb.size.Rows
	462	+	if width <= 0 \|\| screenRows <= 0 {
	463	+	return renderer.NewFrame(0, 0), nil
	464	+	}
	465	+	return renderer.NewFrame(width, screenRows+2), nil
	466	+	}
	467	+	p.mu.Lock()
473	468		width, screenRows := p.screen.Frame.Width, p.screen.Frame.Height
	469	+	p.mu.Unlock()
474	470		if tb.size.Valid() {
475	471		width, screenRows = tb.size.Cols, tb.size.Rows
476	472		}

@@ -504,10 +500,7 @@ func composeClientFrameWithState(bars barState, tb tab, full bool, caches ...b
504	500
505	501		func composeTabFrame(tb *tab, area domain.Rect, theme themeui.Theme) (renderer.Frame, []renderer.Damage) {
506	502		frame := renderer.NewFrame(area.Width, area.Height)
507		-	var root *layout.Node
508		-	if tb.tree != nil {
509		-	root = tb.tree.Root
510		-	}
	503	+	root := tb.tree.Root
511	504		placements, ok := layout.Solve(root, area)
512	505		var fallback *pane
513	506		if !ok {

@@ -521,16 +514,13 @@ func composeTabFrame(tb *tab, area domain.Rect, theme themeui.Theme) (renderer.F
521	514		var damage []renderer.Damage
522	515		for _, pl := range placements {
523	516		p := tb.panes[pl.ID]
524		-	if len(tb.panes) == 1 && tb.tree != nil && tb.tree.Focus == pl.ID {
525		-	p = tb.focusedPane()
526		-	}
527	517		if p == nil && fallback != nil && pl.ID == fallback.id {
528	518		p = fallback
529	519		}
530	520		if p == nil {
531	521		continue
532	522		}
533		-	focused := tb.tree == nil \|\| tb.tree.Focus == pl.ID
	523	+	focused := tb.tree.Focus == pl.ID
534	524		if pl.TitleBar.Height > 0 {
535	525		drawPaneTitleBar(frame, pl, p, focused, theme, "")
536	526		}

@@ -540,7 +530,7 @@ func composeTabFrame(tb *tab, area domain.Rect, theme themeui.Theme) (renderer.F
540	530		p.mu.Lock()
541	531		blitPaneFrame(frame, pl.Content, p.screen.Frame, !focused, theme)
542	532		for _, d := range p.screen.Damage() {
543		-	damage = append(damage, translateDamage([]renderer.Damage{d}, pl.Content.X, pl.Content.Y)...)
	533	+	damage = append(damage, translatePaneDamage(d, pl.Content, area)...)
544	534		}
545	535		p.mu.Unlock()
546	536		}

@@ -572,7 +562,9 @@ func drawPaneTitleBar(frame renderer.Frame, pl layout.Placement, p *pane, focuse
572	562		for x := pl.TitleBar.X; x < pl.TitleBar.X+pl.TitleBar.Width && x < frame.Width; x++ {
573	563		frame.Set(x, pl.TitleBar.Y, renderer.Cell{Rune: ' ', Style: style})
574	564		}
	565	+	p.mu.Lock()
575	566		title := p.title
	567	+	p.mu.Unlock()
576	568		if title == "" {
577	569		title = fallback
578	570		}

@@ -668,3 +660,15 @@ func translateDamage(in []renderer.Damage, dx, dy int) []renderer.Damage {
668	660		}
669	661		return out
670	662		}
	663	+
	664	+	func translatePaneDamage(d renderer.Damage, content domain.Rect, area domain.Rect) []renderer.Damage {
	665	+	if d.Kind == renderer.DamageFullRedraw {
	666	+	return []renderer.Damage{d}
	667	+	}
	668	+	if d.Kind == renderer.DamageScrollUp && (content.X != 0 \|\| content.Width != area.Width) {
	669	+	return []renderer.Damage{{Kind: renderer.DamageText, X: content.X, Y: content.Y, Width: content.Width, Height: content.Height}}
	670	+	}
	671	+	d.X += content.X
	672	+	d.Y += content.Y
	673	+	return []renderer.Damage{d}
	674	+	}

 	}
 }
-func (d *Daemon) ptyReader(sess *session, tb *tab, panes ...*pane) {
+func (d *Daemon) ptyReader(sess *session, tb *tab, p *pane) {
 	defer d.sessWg.Done()
-	var p *pane
-	if len(panes) > 0 {
-		p = panes[0]
-	} else {
-		p = tb.focusedPane()
-	}
 	if p == nil {
 		return
 	}
 // scheduler debounces dirty signals. The first dirty opens a short tab;
 // sustained floods progressively widen that tab, while isolated updates
 // return to the minimum delay for interactive latency.
-func (d *Daemon) scheduler(sess *session, tb *tab, panes ...*pane) {
+func (d *Daemon) scheduler(sess *session, tb *tab, p *pane) {
 	defer d.sessWg.Done()
-	var p *pane
-	if len(panes) > 0 {
-		p = panes[0]
-	} else {
-		p = tb.focusedPane()
-	}
 	if p == nil {
 		return
 	}
 		case <-paneDone(p):
 			return
 		case <-p.flush:
-			d.render(sess, tb)
+			d.render(sess, tb, p)
 			lastRender = d.clock.Now()
 			continue
 		case <-p.dirty:
 					default:
 					}
 				}
-				d.render(sess, tb)
+				d.render(sess, tb, p)
 				lastRender = d.clock.Now()
 				continue outer
 			case <-p.dirty:
 			}
 		}
 		delay = nextDebounceDelay(delay, coalesced)
-		d.render(sess, tb)
+		d.render(sess, tb, p)
 		lastRender = d.clock.Now()
 	}
 }
 // render paints the current client, or (when detached) just clears accumulated
 // damage so it never grows unbounded while headless.
-func (d *Daemon) render(sess *session, tb *tab) {
+func (d *Daemon) render(sess *session, tb *tab, p *pane) {
 	tb.mu.Lock()
-	p := tb.focusedPane()
 	previewer := tb.previewClient
 	tb.mu.Unlock()
 	if p == nil {
 	}
 	p := tb.focusedPane()
 	styles := newThemeStyles(bars.theme)
+	if p == nil {
+		width, screenRows := tb.size.Cols, tb.size.Rows
+		if width <= 0 || screenRows <= 0 {
+			return renderer.NewFrame(0, 0), nil
+		}
+		return renderer.NewFrame(width, screenRows+2), nil
+	}
+	p.mu.Lock()
 	width, screenRows := p.screen.Frame.Width, p.screen.Frame.Height
+	p.mu.Unlock()
 	if tb.size.Valid() {
 		width, screenRows = tb.size.Cols, tb.size.Rows
 	}
 func composeTabFrame(tb *tab, area domain.Rect, theme themeui.Theme) (renderer.Frame, []renderer.Damage) {
 	frame := renderer.NewFrame(area.Width, area.Height)
-	var root *layout.Node
+	root := tb.tree.Root
-	if tb.tree != nil {
-		root = tb.tree.Root
-	}
 	placements, ok := layout.Solve(root, area)
 	var fallback *pane
 	if !ok {
 	var damage []renderer.Damage
 	for _, pl := range placements {
 		p := tb.panes[pl.ID]
-		if len(tb.panes) == 1 && tb.tree != nil && tb.tree.Focus == pl.ID {
-			p = tb.focusedPane()
-		}
 		if p == nil && fallback != nil && pl.ID == fallback.id {
 			p = fallback
 		}
 		if p == nil {
 			continue
 		}
-		focused := tb.tree == nil || tb.tree.Focus == pl.ID
+		focused := tb.tree.Focus == pl.ID
 		if pl.TitleBar.Height > 0 {
 			drawPaneTitleBar(frame, pl, p, focused, theme, "")
 		}
 		p.mu.Lock()
 		blitPaneFrame(frame, pl.Content, p.screen.Frame, !focused, theme)
 		for _, d := range p.screen.Damage() {
-			damage = append(damage, translateDamage([]renderer.Damage{d}, pl.Content.X, pl.Content.Y)...)
+			damage = append(damage, translatePaneDamage(d, pl.Content, area)...)
 		}
 		p.mu.Unlock()
 	}
 	for x := pl.TitleBar.X; x < pl.TitleBar.X+pl.TitleBar.Width && x < frame.Width; x++ {
 		frame.Set(x, pl.TitleBar.Y, renderer.Cell{Rune: ' ', Style: style})
 	}
+	p.mu.Lock()
 	title := p.title
+	p.mu.Unlock()
 	if title == "" {
 		title = fallback
 	}
 	}
 	return out
 }
+func translatePaneDamage(d renderer.Damage, content domain.Rect, area domain.Rect) []renderer.Damage {
+	if d.Kind == renderer.DamageFullRedraw {
+		return []renderer.Damage{d}
+	}
+	if d.Kind == renderer.DamageScrollUp && (content.X != 0 || content.Width != area.Width) {
+		return []renderer.Damage{{Kind: renderer.DamageText, X: content.X, Y: content.Y, Width: content.Width, Height: content.Height}}
+	}
+	d.X += content.X
+	d.Y += content.Y
+	return []renderer.Damage{d}
+}

M internal/usecase/daemon/render_test.go +110 -63


@@ -20,7 +20,6 @@ import (
20	20		"github.com/bnema/vev/internal/usecase/layout"
21	21		themeui "github.com/bnema/vev/internal/usecase/theme"
22	22		"github.com/bnema/vev/pkg/renderer"
23		-	"github.com/bnema/vev/pkg/vt"
24	23		)
25	24
26	25		// --- test doubles -----------------------------------------------------------

@@ -34,7 +33,7 @@ func TestPTYWriteErrorIsLogged(t *testing.T) {
34	33		errBoom := errors.New("boom")
35	34		p := portsmocks.NewMockPTY(t)
36	35		p.EXPECT().Write([]byte("input")).Return(0, errBoom).Once()
37		-	win := &tab{pty: p, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}}
	36	+	win := newTab(p, domain.Size{Cols: 80, Rows: 23})
38	37		sess := &session{id: "manual", name: "work", tabs: []*tab{win}}
39	38		ac := &attachedClient{}
40	39		ac.setSession(sess)

@@ -57,8 +56,8 @@ func TestAltXClosesNonFinalTabScheduler(t *testing.T) {
57	56		defer releasePTY2()
58	57
59	58		d.sessWg.Add(1)
60		-	go d.scheduler(sess, sess.tabs[1])
61		-	sess.tabs[1].dirty <- struct{}{}
	59	+	go d.scheduler(sess, sess.tabs[1], sess.tabs[1].focusedPane())
	60	+	sess.tabs[1].focusedPane().dirty <- struct{}{}
62	61		<-clk.called
63	62
64	63		d.handleInput(sess, ac, []byte("\x1b2"))

@@ -83,9 +82,9 @@ func TestPTYEOFClosesNonFinalTabScheduler(t *testing.T) {
83	82		defer releasePTY2()
84	83
85	84		d.sessWg.Add(2)
86		-	go d.scheduler(sess, sess.tabs[1])
87		-	go d.ptyReader(sess, sess.tabs[1])
88		-	sess.tabs[1].dirty <- struct{}{}
	85	+	go d.scheduler(sess, sess.tabs[1], sess.tabs[1].focusedPane())
	86	+	go d.ptyReader(sess, sess.tabs[1], sess.tabs[1].focusedPane())
	87	+	sess.tabs[1].focusedPane().dirty <- struct{}{}
89	88		<-clk.called
90	89		releasePTY2()
91	90

@@ -117,10 +116,10 @@ func TestPTYEOFClosesActiveNonFinalTabAndRepaintsRemaining(t *testing.T) {
117	116		d, sess, _, sends := newManualSessionWithPTYs(t, p1, p2)
118	117		defer releasePTY2()
119	118		sess.active = 0
120		-	sess.tabs[1].screen.Write([]byte("remaining"))
	119	+	sess.tabs[1].focusedPane().screen.Write([]byte("remaining"))
121	120
122	121		d.sessWg.Add(1)
123		-	go d.ptyReader(sess, sess.tabs[0])
	122	+	go d.ptyReader(sess, sess.tabs[0], sess.tabs[0].focusedPane())
124	123		releasePTY1()
125	124
126	125		require.Eventually(t, func() bool { return tabCount(sess) == 1 }, 2time.Second, 5time.Millisecond)

@@ -143,10 +142,10 @@ func TestPTYEOFClosesInactiveNonFinalTabAndRepaintsStatus(t *testing.T) {
143	142		d, sess, _, sends := newManualSessionWithPTYs(t, p1, p2)
144	143		defer releasePTY1()
145	144		sess.active = 0
146		-	sess.tabs[0].screen.Write([]byte("active"))
	145	+	sess.tabs[0].focusedPane().screen.Write([]byte("active"))
147	146
148	147		d.sessWg.Add(1)
149		-	go d.ptyReader(sess, sess.tabs[1])
	148	+	go d.ptyReader(sess, sess.tabs[1], sess.tabs[1].focusedPane())
150	149		releasePTY2()
151	150
152	151		require.Eventually(t, func() bool { return tabCount(sess) == 1 }, 2time.Second, 5time.Millisecond)

@@ -167,7 +166,7 @@ func TestPTYEOFFinalTabKillsSessionAndDetaches(t *testing.T) {
167	166		d, sess, _, sends, releases := newManualTabSession(t, 1)
168	167
169	168		d.sessWg.Add(1)
170		-	go d.ptyReader(sess, sess.tabs[0])
	169	+	go d.ptyReader(sess, sess.tabs[0], sess.tabs[0].focusedPane())
171	170		releases[0]()
172	171
173	172		require.Eventually(t, func() bool { return sessionCount(d) == 0 }, 2time.Second, 5time.Millisecond)

@@ -213,26 +212,26 @@ func TestSchedulerDebounceCoalesces(t *testing.T) {
213	212
214	213		d := New(nil, mc, slog.New(slog.NewTextHandler(io.Discard, nil)))
215	214		sctx, cancel := context.WithCancel(context.Background())
216		-	win := &tab{screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}}
	215	+	win := newTab(newScriptPTY(nil), domain.Size{Cols: 20, Rows: 5})
217	216		ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
218	217		sess := &session{id: "s", name: "s", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
219	218		ac.setSession(sess)
220	219
221	220		win.mu.Lock()
222		-	win.screen.Write([]byte("hi"))
	221	+	win.focusedPane().screen.Write([]byte("hi"))
223	222		win.mu.Unlock()
224	223
225	224		d.sessWg.Add(1)
226		-	go d.scheduler(sess, win)
	225	+	go d.scheduler(sess, win, win.focusedPane())
227	226
228	227		// First dirty opens the debounce window.
229		-	win.dirty <- struct{}{}
	228	+	win.focusedPane().dirty <- struct{}{}
230	229		<-newTimerCalled
231	230
232	231		// A burst of further dirties inside the window must be absorbed.
233	232		for range 5 {
234	233		select {
235		-	case win.dirty <- struct{}{}:
	234	+	case win.focusedPane().dirty <- struct{}{}:
236	235		default:
237	236		}
238	237		}

@@ -268,9 +267,9 @@ func TestResizePreservesLiveContentAndEvictsScrollback(t *testing.T) {
268	267
269	268		win := newTab(p, domain.Size{Cols: 4, Rows: 4})
270	269		for y, text := range []string{"0000", "1111", "2222", "3333"} {
271		-	copy(win.screen.Frame.Row(y), testRow(text))
	270	+	copy(win.focusedPane().screen.Frame.Row(y), testRow(text))
272	271		}
273		-	win.screen.Row = 3
	272	+	win.focusedPane().screen.Row = 3
274	273
275	274		tr := portsmocks.NewMockTransport(t)
276	275		tr.EXPECT().Close().Return(nil).Maybe()

@@ -285,16 +284,16 @@ func TestResizePreservesLiveContentAndEvictsScrollback(t *testing.T) {
285	284		// layout: tabSize reserves 2 chrome rows (top + bottom bar) here, not 1,
286	285		// so a client height of 4 (not 3) is what yields the same 2-row tab.
287	286		d.resize(sess, ac, domain.Size{Cols: 4, Rows: 4})
288		-	require.Equal(t, "2222", frameRowString(win.screen.Frame, 0))
289		-	require.Equal(t, "3333", frameRowString(win.screen.Frame, 1))
290		-	require.Equal(t, 2, win.scrollback.Len())
291		-	require.Equal(t, "0000", cellsString(win.scrollback.Row(0)))
292		-	require.Equal(t, "1111", cellsString(win.scrollback.Row(1)))
	287	+	require.Equal(t, "2222", frameRowString(win.focusedPane().screen.Frame, 0))
	288	+	require.Equal(t, "3333", frameRowString(win.focusedPane().screen.Frame, 1))
	289	+	require.Equal(t, 2, win.focusedPane().scrollback.Len())
	290	+	require.Equal(t, "0000", cellsString(win.focusedPane().scrollback.Row(0)))
	291	+	require.Equal(t, "1111", cellsString(win.focusedPane().scrollback.Row(1)))
293	292
294	293		d.resize(sess, ac, domain.Size{Cols: 6, Rows: 6})
295		-	require.Equal(t, "2222 ", frameRowString(win.screen.Frame, 0))
296		-	require.Equal(t, "3333 ", frameRowString(win.screen.Frame, 1))
297		-	require.Equal(t, 2, win.scrollback.Len())
	294	+	require.Equal(t, "2222 ", frameRowString(win.focusedPane().screen.Frame, 0))
	295	+	require.Equal(t, "3333 ", frameRowString(win.focusedPane().screen.Frame, 1))
	296	+	require.Equal(t, 2, win.focusedPane().scrollback.Len())
298	297		}
299	298
300	299		func frameRowString(f renderer.Frame, y int) string {

@@ -336,6 +335,54 @@ func TestTranslateDamageShiftsXYAndPreservesFullRedraw(t *testing.T) {
336	335		}, damage)
337	336		}
338	337
	338	+	func TestTranslatePaneDamagePreservesFullWidthScrollFastPathOnly(t *testing.T) {
	339	+	tests := []struct {
	340	+	name string
	341	+	content domain.Rect
	342	+	area domain.Rect
	343	+	in renderer.Damage
	344	+	want []renderer.Damage
	345	+	}{
	346	+	{
	347	+	name: "half width scroll becomes pane text damage",
	348	+	content: domain.Rect{X: 21, Y: 0, Width: 20, Height: 4},
	349	+	area: domain.Rect{Width: 41, Height: 4},
	350	+	in: renderer.Damage{Kind: renderer.DamageScrollUp, X: 0, Y: 0, Width: 20, Height: 4, Count: 1},
	351	+	want: []renderer.Damage{{Kind: renderer.DamageText, X: 21, Y: 0, Width: 20, Height: 4}},
	352	+	},
	353	+	{
	354	+	name: "full width scroll keeps translated scroll damage",
	355	+	content: domain.Rect{X: 0, Y: 5, Width: 80, Height: 10},
	356	+	area: domain.Rect{Width: 80, Height: 24},
	357	+	in: renderer.Damage{Kind: renderer.DamageScrollUp, X: 0, Y: 0, Width: 80, Height: 10, Count: 1},
	358	+	want: []renderer.Damage{{Kind: renderer.DamageScrollUp, X: 0, Y: 5, Width: 80, Height: 10, Count: 1}},
	359	+	},
	360	+	}
	361	+	for _, tt := range tests {
	362	+	t.Run(tt.name, func(t *testing.T) {
	363	+	require.Equal(t, tt.want, translatePaneDamage(tt.in, tt.content, tt.area))
	364	+	})
	365	+	}
	366	+	}
	367	+
	368	+	func TestRenderClearsDamageOnEmittingPaneWhenDetached(t *testing.T) {
	369	+	tb := newTab(nil, domain.Size{Cols: 10, Rows: 3})
	370	+	focused := tb.focusedPane()
	371	+	emitting := newPane("pane-2", nil, domain.Size{Cols: 10, Rows: 3})
	372	+	tb.panes[emitting.id] = emitting
	373	+	tb.tree.Root = &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf(focused.id), layout.NewLeaf(emitting.id)}}
	374	+	tb.tree.Focus = focused.id
	375	+	sess := &session{id: "s", name: "work", tabs: []*tab{tb}, active: 0}
	376	+	d := newTestDaemon(t, nil, stubClock{})
	377	+
	378	+	focused.screen.Write([]byte("a"))
	379	+	emitting.screen.Write([]byte("b"))
	380	+	d.render(sess, tb, emitting)
	381	+
	382	+	require.NotEmpty(t, focused.screen.Damage(), "focused pane damage should be untouched by detached render for another pane")
	383	+	require.Empty(t, emitting.screen.Damage(), "emitting pane damage should be drained")
	384	+	}
	385	+
339	386		func TestComposeTabFrameTwoPaneSplitBlitsDividersDimsAndTranslatesDamage(t *testing.T) {
340	387		win := newTab(nil, domain.Size{Cols: 41, Rows: 4})
341	388		left := win.focusedPane()

@@ -393,15 +440,15 @@ func TestComposeClientFrameBarCacheSkipsUnchangedBars(t *testing.T) {
393	440
394	441		_, damage := composeClientFrame(sess, win, true, "", &cache)
395	442		require.Equal(t, []renderer.Damage{renderer.FullRedraw()}, damage)
396		-	win.screen.ClearDamage()
397		-	win.screen.Write([]byte("x"))
	443	+	win.focusedPane().screen.ClearDamage()
	444	+	win.focusedPane().screen.Write([]byte("x"))
398	445
399	446		_, damage = composeClientFrame(sess, win, false, "", &cache)
400	447
401	448		require.NotEmpty(t, damage)
402	449		for _, d := range damage {
403	450		require.NotEqual(t, 0, d.Y, "unchanged top bar should not be damaged")
404		-	require.NotEqual(t, win.screen.Frame.Height+1, d.Y, "unchanged bottom bar should not be damaged")
	451	+	require.NotEqual(t, win.focusedPane().screen.Frame.Height+1, d.Y, "unchanged bottom bar should not be damaged")
405	452		}
406	453		}
407	454

@@ -409,12 +456,12 @@ func TestComposeClientFrameBarCacheDamagesChangedBottomOnly(t *testing.T) {
409	456		sess, win := newBarCacheTestSession()
410	457		var cache barCache
411	458		composeClientFrame(sess, win, true, "", &cache)
412		-	win.screen.ClearDamage()
	459	+	win.focusedPane().screen.ClearDamage()
413	460
414	461		sess.name = "renamed"
415	462		_, damage := composeClientFrame(sess, win, false, "", &cache)
416	463
417		-	require.Equal(t, []renderer.Damage{{Kind: renderer.DamageText, X: 0, Y: win.screen.Frame.Height + 1, Width: win.screen.Frame.Width, Height: 1}}, damage)
	464	+	require.Equal(t, []renderer.Damage{{Kind: renderer.DamageText, X: 0, Y: win.focusedPane().screen.Frame.Height + 1, Width: win.focusedPane().screen.Frame.Width, Height: 1}}, damage)
418	465		}
419	466
420	467		func TestComposeClientFrameFullRedrawPrimesBarCache(t *testing.T) {

@@ -425,14 +472,14 @@ func TestComposeClientFrameFullRedrawPrimesBarCache(t *testing.T) {
425	472
426	473		_, damage := composeClientFrame(sess, win, true, "", &cache)
427	474		require.Equal(t, []renderer.Damage{renderer.FullRedraw()}, damage)
428		-	win.screen.ClearDamage()
	475	+	win.focusedPane().screen.ClearDamage()
429	476
430	477		_, damage = composeClientFrame(sess, win, false, "", &cache)
431	478		require.Empty(t, damage)
432	479		}
433	480
434	481		func newBarCacheTestSession() (session, tab) {
435		-	win := &tab{screen: vt.NewScreen(20, 3), size: domain.Size{Cols: 20, Rows: 3}}
	482	+	win := newTab(newScriptPTY(nil), domain.Size{Cols: 20, Rows: 3})
436	483		sess := &session{id: "s", name: "work", tabs: []*tab{win}}
437	484		return sess, win
438	485		}

@@ -442,13 +489,13 @@ func TestResizeOrdersPTYBeforeScreen(t *testing.T) {
442	489
443	490		p := portsmocks.NewMockPTY(t)
444	491		var screenWidthAtResize int
445		-	win := &tab{screen: vt.NewScreen(80, 24), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 24}}
	492	+	win := newTab(newScriptPTY(nil), domain.Size{Cols: 80, Rows: 24})
446	493		p.EXPECT().Resize(domain.Size{Cols: 100, Rows: 28}).RunAndReturn(func(sz domain.Size) error {
447	494		// The screen must not yet be resized when the PTY is: proves order.
448		-	screenWidthAtResize = win.screen.Frame.Width
	495	+	screenWidthAtResize = win.focusedPane().screen.Frame.Width
449	496		return nil
450	497		}).Once()
451		-	win.pty = p
	498	+	win.focusedPane().pty = p
452	499
453	500		var gotOutput atomic.Bool
454	501		tr := portsmocks.NewMockTransport(t)

@@ -468,8 +515,8 @@ func TestResizeOrdersPTYBeforeScreen(t *testing.T) {
468	515		d.resize(sess, ac, newSize)
469	516
470	517		require.Equal(t, 80, screenWidthAtResize, "pty.Resize must run before screen.Resize")
471		-	require.Equal(t, 100, win.screen.Frame.Width, "screen resized after pty")
472		-	require.Equal(t, 28, win.screen.Frame.Height, "screen reserves top and bottom chrome rows")
	518	+	require.Equal(t, 100, win.focusedPane().screen.Frame.Width, "screen resized after pty")
	519	+	require.Equal(t, 28, win.focusedPane().screen.Frame.Height, "screen reserves top and bottom chrome rows")
473	520		require.True(t, gotOutput.Load(), "resize forces a full redraw output")
474	521		}
475	522

@@ -484,7 +531,7 @@ func TestSendErrorKillsEphemeral(t *testing.T) {
484	531		tr.EXPECT().Close().Return(nil).Maybe()
485	532
486	533		d := newTestDaemon(t, nil, stubClock{})
487		-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}}
	534	+	win := newTab(p, domain.Size{Cols: 20, Rows: 5})
488	535		sctx, cancel := context.WithCancel(context.Background())
489	536		ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
490	537		sess := &session{id: "e", name: "0", ephemeral: true, tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}

@@ -492,7 +539,7 @@ func TestSendErrorKillsEphemeral(t *testing.T) {
492	539		d.sessions[sess.id] = sess
493	540
494	541		win.mu.Lock()
495		-	win.screen.Write([]byte("x"))
	542	+	win.focusedPane().screen.Write([]byte("x"))
496	543		win.mu.Unlock()
497	544
498	545		d.paint(sess, ac, true) // send fails -> detach -> ephemeral killed

@@ -590,13 +637,13 @@ func TestPTYQueryGetsResponseWrittenBackToPTY(t *testing.T) {
590	637
591	638		tr, sends := newCapturingTransport(t)
592	639		sctx, cancel := context.WithCancel(context.Background())
593		-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
	640	+	win := newTestTabWithContext(p, sctx, cancel)
594	641		ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
595	642		sess := &session{id: "query", name: "query", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
596	643		ac.setSession(sess)
597	644		d.sessions[sess.id] = sess
598	645		d.sessWg.Add(1)
599		-	d.ptyReader(sess, win)
	646	+	d.ptyReader(sess, win, win.focusedPane())
600	647
601	648		select {
602	649		case got := <-writes:

@@ -626,19 +673,19 @@ func TestPTYReaderSameReadSynchronizedUpdateStartEndFlushesImmediately(t *testin
626	673		p.EXPECT().Close().Return(nil).Maybe()
627	674
628	675		sctx, cancel := context.WithCancel(context.Background())
629		-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
	676	+	win := newTestTabWithContext(p, sctx, cancel)
630	677		sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel}
631	678		d.sessions[sess.id] = sess
632	679		d.sessWg.Add(1)
633		-	d.ptyReader(sess, win)
	680	+	d.ptyReader(sess, win, win.focusedPane())
634	681
635	682		select {
636		-	case <-win.dirty:
	683	+	case <-win.focusedPane().dirty:
637	684		t.Fatal("same-read synchronized update end should request flush, not dirty")
638	685		default:
639	686		}
640	687		select {
641		-	case <-win.flush:
	688	+	case <-win.focusedPane().flush:
642	689		case <-time.After(time.Second):
643	690		t.Fatal("same-read synchronized update end did not request immediate flush")
644	691		}

@@ -659,19 +706,19 @@ func TestPTYReaderDefersDirtyDuringSynchronizedUpdateAndFlushesAtEnd(t *testing.
659	706		p.EXPECT().Close().Return(nil).Maybe()
660	707
661	708		sctx, cancel := context.WithCancel(context.Background())
662		-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
	709	+	win := newTestTabWithContext(p, sctx, cancel)
663	710		sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel}
664	711		d.sessions[sess.id] = sess
665	712		d.sessWg.Add(1)
666		-	d.ptyReader(sess, win)
	713	+	d.ptyReader(sess, win, win.focusedPane())
667	714
668	715		select {
669		-	case <-win.dirty:
	716	+	case <-win.focusedPane().dirty:
670	717		t.Fatal("dirty signaled while synchronized update was active")
671	718		default:
672	719		}
673	720		select {
674		-	case <-win.flush:
	721	+	case <-win.focusedPane().flush:
675	722		case <-time.After(time.Second):
676	723		t.Fatal("sync end did not request immediate flush")
677	724		}

@@ -695,22 +742,22 @@ func TestSyncUpdateWatchdogAbandonedSyncRenders(t *testing.T) {
695	742
696	743		tr, sends := newCapturingTransport(t)
697	744		sctx, cancel := context.WithCancel(context.Background())
698		-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
	745	+	win := newTestTabWithContext(p, sctx, cancel)
699	746		ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
700	747		sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
701	748		ac.setSession(sess)
702	749		d.sessions[sess.id] = sess
703	750		d.sessWg.Add(2)
704		-	go d.scheduler(sess, win)
705		-	go d.ptyReader(sess, win)
	751	+	go d.scheduler(sess, win, win.focusedPane())
	752	+	go d.ptyReader(sess, win, win.focusedPane())
706	753
707	754		timer := <-clk.timers
708	755		timer.ch <- time.Now()
709	756		awaitFrame(t, sends, ports.MsgOutput)
710	757
711	758		win.mu.Lock()
712		-	active := win.screen.SyncUpdateActive()
713		-	got := screenLineText(win.screen, 0)
	759	+	active := win.focusedPane().screen.SyncUpdateActive()
	760	+	got := screenLineText(win.focusedPane().screen, 0)
714	761		win.mu.Unlock()
715	762		require.False(t, active)
716	763		require.Contains(t, got, "abandoned")

@@ -739,14 +786,14 @@ func TestSyncUpdateWatchdogStaleGenerationNoopAfterEnd(t *testing.T) {
739	786
740	787		tr, sends := newCapturingTransport(t)
741	788		sctx, cancel := context.WithCancel(context.Background())
742		-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
	789	+	win := newTestTabWithContext(p, sctx, cancel)
743	790		ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
744	791		sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
745	792		ac.setSession(sess)
746	793		d.sessions[sess.id] = sess
747	794		d.sessWg.Add(2)
748		-	go d.scheduler(sess, win)
749		-	go d.ptyReader(sess, win)
	795	+	go d.scheduler(sess, win, win.focusedPane())
	796	+	go d.ptyReader(sess, win, win.focusedPane())
750	797
751	798		timer := <-clk.timers
752	799		awaitFrame(t, sends, ports.MsgOutput)

@@ -760,7 +807,7 @@ func TestSyncUpdateWatchdogStaleGenerationNoopAfterEnd(t *testing.T) {
760	807		case <-time.After(50 * time.Millisecond):
761	808		}
762	809		win.mu.Lock()
763		-	active := win.screen.SyncUpdateActive()
	810	+	active := win.focusedPane().screen.SyncUpdateActive()
764	811		win.mu.Unlock()
765	812		require.False(t, active)
766	813

@@ -773,20 +820,20 @@ func TestCursorTailVisibleHideAndMoveOnly(t *testing.T) {
773	820		p, _ := newBlockingPTY(t)
774	821		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
775	822		win := sess.tabs[0]
776		-	win.screen.Write([]byte("A"))
	823	+	win.focusedPane().screen.Write([]byte("A"))
777	824
778	825		d.paint(sess, ac, true)
779	826		data := mustOutputData(t, sends)
780	827		require.Contains(t, string(data), "\x1b[5 q")
781	828		require.Contains(t, string(data), "\x1b[?25h")
782	829
783		-	win.screen.Write([]byte("\x1b[2;3H"))
	830	+	win.focusedPane().screen.Write([]byte("\x1b[2;3H"))
784	831		d.paint(sess, ac, false)
785	832		data = mustOutputData(t, sends)
786	833		require.Contains(t, string(data), "\x1b[3;3H")
787	834		require.Contains(t, string(data), "\x1b[?25h")
788	835
789		-	win.screen.Write([]byte("\x1b[?25l"))
	836	+	win.focusedPane().screen.Write([]byte("\x1b[?25l"))
790	837		d.paint(sess, ac, false)
791	838		data = mustOutputData(t, sends)
792	839		require.Contains(t, string(data), "\x1b[?25l")

 	"github.com/bnema/vev/internal/usecase/layout"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 	"github.com/bnema/vev/pkg/renderer"
-	"github.com/bnema/vev/pkg/vt"
 )
 // --- test doubles -----------------------------------------------------------
 	errBoom := errors.New("boom")
 	p := portsmocks.NewMockPTY(t)
 	p.EXPECT().Write([]byte("input")).Return(0, errBoom).Once()
-	win := &tab{pty: p, screen: vt.NewScreen(80, 23), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 23}}
+	win := newTab(p, domain.Size{Cols: 80, Rows: 23})
 	sess := &session{id: "manual", name: "work", tabs: []*tab{win}}
 	ac := &attachedClient{}
 	ac.setSession(sess)
 	defer releasePTY2()
 	d.sessWg.Add(1)
-	go d.scheduler(sess, sess.tabs[1])
+	go d.scheduler(sess, sess.tabs[1], sess.tabs[1].focusedPane())
-	sess.tabs[1].dirty <- struct{}{}
+	sess.tabs[1].focusedPane().dirty <- struct{}{}
 	<-clk.called
 	d.handleInput(sess, ac, []byte("\x1b2"))
 	defer releasePTY2()
 	d.sessWg.Add(2)
-	go d.scheduler(sess, sess.tabs[1])
+	go d.scheduler(sess, sess.tabs[1], sess.tabs[1].focusedPane())
-	go d.ptyReader(sess, sess.tabs[1])
+	go d.ptyReader(sess, sess.tabs[1], sess.tabs[1].focusedPane())
-	sess.tabs[1].dirty <- struct{}{}
+	sess.tabs[1].focusedPane().dirty <- struct{}{}
 	<-clk.called
 	releasePTY2()
 	d, sess, _, sends := newManualSessionWithPTYs(t, p1, p2)
 	defer releasePTY2()
 	sess.active = 0
-	sess.tabs[1].screen.Write([]byte("remaining"))
+	sess.tabs[1].focusedPane().screen.Write([]byte("remaining"))
 	d.sessWg.Add(1)
-	go d.ptyReader(sess, sess.tabs[0])
+	go d.ptyReader(sess, sess.tabs[0], sess.tabs[0].focusedPane())
 	releasePTY1()
 	require.Eventually(t, func() bool { return tabCount(sess) == 1 }, 2*time.Second, 5*time.Millisecond)
 	d, sess, _, sends := newManualSessionWithPTYs(t, p1, p2)
 	defer releasePTY1()
 	sess.active = 0
-	sess.tabs[0].screen.Write([]byte("active"))
+	sess.tabs[0].focusedPane().screen.Write([]byte("active"))
 	d.sessWg.Add(1)
-	go d.ptyReader(sess, sess.tabs[1])
+	go d.ptyReader(sess, sess.tabs[1], sess.tabs[1].focusedPane())
 	releasePTY2()
 	require.Eventually(t, func() bool { return tabCount(sess) == 1 }, 2*time.Second, 5*time.Millisecond)
 	d, sess, _, sends, releases := newManualTabSession(t, 1)
 	d.sessWg.Add(1)
-	go d.ptyReader(sess, sess.tabs[0])
+	go d.ptyReader(sess, sess.tabs[0], sess.tabs[0].focusedPane())
 	releases[0]()
 	require.Eventually(t, func() bool { return sessionCount(d) == 0 }, 2*time.Second, 5*time.Millisecond)
 	d := New(nil, mc, slog.New(slog.NewTextHandler(io.Discard, nil)))
 	sctx, cancel := context.WithCancel(context.Background())
-	win := &tab{screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}}
+	win := newTab(newScriptPTY(nil), domain.Size{Cols: 20, Rows: 5})
 	ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
 	sess := &session{id: "s", name: "s", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
 	ac.setSession(sess)
 	win.mu.Lock()
-	win.screen.Write([]byte("hi"))
+	win.focusedPane().screen.Write([]byte("hi"))
 	win.mu.Unlock()
 	d.sessWg.Add(1)
-	go d.scheduler(sess, win)
+	go d.scheduler(sess, win, win.focusedPane())
 	// First dirty opens the debounce window.
-	win.dirty <- struct{}{}
+	win.focusedPane().dirty <- struct{}{}
 	<-newTimerCalled
 	// A burst of further dirties inside the window must be absorbed.
 	for range 5 {
 		select {
-		case win.dirty <- struct{}{}:
+		case win.focusedPane().dirty <- struct{}{}:
 		default:
 		}
 	}
 	win := newTab(p, domain.Size{Cols: 4, Rows: 4})
 	for y, text := range []string{"0000", "1111", "2222", "3333"} {
-		copy(win.screen.Frame.Row(y), testRow(text))
+		copy(win.focusedPane().screen.Frame.Row(y), testRow(text))
 	}
-	win.screen.Row = 3
+	win.focusedPane().screen.Row = 3
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Close().Return(nil).Maybe()
 	// layout: tabSize reserves 2 chrome rows (top + bottom bar) here, not 1,
 	// so a client height of 4 (not 3) is what yields the same 2-row tab.
 	d.resize(sess, ac, domain.Size{Cols: 4, Rows: 4})
-	require.Equal(t, "2222", frameRowString(win.screen.Frame, 0))
+	require.Equal(t, "2222", frameRowString(win.focusedPane().screen.Frame, 0))
-	require.Equal(t, "3333", frameRowString(win.screen.Frame, 1))
+	require.Equal(t, "3333", frameRowString(win.focusedPane().screen.Frame, 1))
-	require.Equal(t, 2, win.scrollback.Len())
+	require.Equal(t, 2, win.focusedPane().scrollback.Len())
-	require.Equal(t, "0000", cellsString(win.scrollback.Row(0)))
+	require.Equal(t, "0000", cellsString(win.focusedPane().scrollback.Row(0)))
-	require.Equal(t, "1111", cellsString(win.scrollback.Row(1)))
+	require.Equal(t, "1111", cellsString(win.focusedPane().scrollback.Row(1)))
 	d.resize(sess, ac, domain.Size{Cols: 6, Rows: 6})
-	require.Equal(t, "2222  ", frameRowString(win.screen.Frame, 0))
+	require.Equal(t, "2222  ", frameRowString(win.focusedPane().screen.Frame, 0))
-	require.Equal(t, "3333  ", frameRowString(win.screen.Frame, 1))
+	require.Equal(t, "3333  ", frameRowString(win.focusedPane().screen.Frame, 1))
-	require.Equal(t, 2, win.scrollback.Len())
+	require.Equal(t, 2, win.focusedPane().scrollback.Len())
 }
 func frameRowString(f renderer.Frame, y int) string {
 	}, damage)
 }
+func TestTranslatePaneDamagePreservesFullWidthScrollFastPathOnly(t *testing.T) {
+	tests := []struct {
+		name    string
+		content domain.Rect
+		area    domain.Rect
+		in      renderer.Damage
+		want    []renderer.Damage
+	}{
+		{
+			name:    "half width scroll becomes pane text damage",
+			content: domain.Rect{X: 21, Y: 0, Width: 20, Height: 4},
+			area:    domain.Rect{Width: 41, Height: 4},
+			in:      renderer.Damage{Kind: renderer.DamageScrollUp, X: 0, Y: 0, Width: 20, Height: 4, Count: 1},
+			want:    []renderer.Damage{{Kind: renderer.DamageText, X: 21, Y: 0, Width: 20, Height: 4}},
+		},
+		{
+			name:    "full width scroll keeps translated scroll damage",
+			content: domain.Rect{X: 0, Y: 5, Width: 80, Height: 10},
+			area:    domain.Rect{Width: 80, Height: 24},
+			in:      renderer.Damage{Kind: renderer.DamageScrollUp, X: 0, Y: 0, Width: 80, Height: 10, Count: 1},
+			want:    []renderer.Damage{{Kind: renderer.DamageScrollUp, X: 0, Y: 5, Width: 80, Height: 10, Count: 1}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, translatePaneDamage(tt.in, tt.content, tt.area))
+		})
+	}
+}
+func TestRenderClearsDamageOnEmittingPaneWhenDetached(t *testing.T) {
+	tb := newTab(nil, domain.Size{Cols: 10, Rows: 3})
+	focused := tb.focusedPane()
+	emitting := newPane("pane-2", nil, domain.Size{Cols: 10, Rows: 3})
+	tb.panes[emitting.id] = emitting
+	tb.tree.Root = &layout.Node{Kind: layout.Split, Dir: layout.Horizontal, Children: []*layout.Node{layout.NewLeaf(focused.id), layout.NewLeaf(emitting.id)}}
+	tb.tree.Focus = focused.id
+	sess := &session{id: "s", name: "work", tabs: []*tab{tb}, active: 0}
+	d := newTestDaemon(t, nil, stubClock{})
+	focused.screen.Write([]byte("a"))
+	emitting.screen.Write([]byte("b"))
+	d.render(sess, tb, emitting)
+	require.NotEmpty(t, focused.screen.Damage(), "focused pane damage should be untouched by detached render for another pane")
+	require.Empty(t, emitting.screen.Damage(), "emitting pane damage should be drained")
+}
 func TestComposeTabFrameTwoPaneSplitBlitsDividersDimsAndTranslatesDamage(t *testing.T) {
 	win := newTab(nil, domain.Size{Cols: 41, Rows: 4})
 	left := win.focusedPane()
 	_, damage := composeClientFrame(sess, win, true, "", &cache)
 	require.Equal(t, []renderer.Damage{renderer.FullRedraw()}, damage)
-	win.screen.ClearDamage()
+	win.focusedPane().screen.ClearDamage()
-	win.screen.Write([]byte("x"))
+	win.focusedPane().screen.Write([]byte("x"))
 	_, damage = composeClientFrame(sess, win, false, "", &cache)
 	require.NotEmpty(t, damage)
 	for _, d := range damage {
 		require.NotEqual(t, 0, d.Y, "unchanged top bar should not be damaged")
-		require.NotEqual(t, win.screen.Frame.Height+1, d.Y, "unchanged bottom bar should not be damaged")
+		require.NotEqual(t, win.focusedPane().screen.Frame.Height+1, d.Y, "unchanged bottom bar should not be damaged")
 	}
 }
 	sess, win := newBarCacheTestSession()
 	var cache barCache
 	composeClientFrame(sess, win, true, "", &cache)
-	win.screen.ClearDamage()
+	win.focusedPane().screen.ClearDamage()
 	sess.name = "renamed"
 	_, damage := composeClientFrame(sess, win, false, "", &cache)
-	require.Equal(t, []renderer.Damage{{Kind: renderer.DamageText, X: 0, Y: win.screen.Frame.Height + 1, Width: win.screen.Frame.Width, Height: 1}}, damage)
+	require.Equal(t, []renderer.Damage{{Kind: renderer.DamageText, X: 0, Y: win.focusedPane().screen.Frame.Height + 1, Width: win.focusedPane().screen.Frame.Width, Height: 1}}, damage)
 }
 func TestComposeClientFrameFullRedrawPrimesBarCache(t *testing.T) {
 	_, damage := composeClientFrame(sess, win, true, "", &cache)
 	require.Equal(t, []renderer.Damage{renderer.FullRedraw()}, damage)
-	win.screen.ClearDamage()
+	win.focusedPane().screen.ClearDamage()
 	_, damage = composeClientFrame(sess, win, false, "", &cache)
 	require.Empty(t, damage)
 }
 func newBarCacheTestSession() (*session, *tab) {
-	win := &tab{screen: vt.NewScreen(20, 3), size: domain.Size{Cols: 20, Rows: 3}}
+	win := newTab(newScriptPTY(nil), domain.Size{Cols: 20, Rows: 3})
 	sess := &session{id: "s", name: "work", tabs: []*tab{win}}
 	return sess, win
 }
 	p := portsmocks.NewMockPTY(t)
 	var screenWidthAtResize int
-	win := &tab{screen: vt.NewScreen(80, 24), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 80, Rows: 24}}
+	win := newTab(newScriptPTY(nil), domain.Size{Cols: 80, Rows: 24})
 	p.EXPECT().Resize(domain.Size{Cols: 100, Rows: 28}).RunAndReturn(func(sz domain.Size) error {
 		// The screen must not yet be resized when the PTY is: proves order.
-		screenWidthAtResize = win.screen.Frame.Width
+		screenWidthAtResize = win.focusedPane().screen.Frame.Width
 		return nil
 	}).Once()
-	win.pty = p
+	win.focusedPane().pty = p
 	var gotOutput atomic.Bool
 	tr := portsmocks.NewMockTransport(t)
 	d.resize(sess, ac, newSize)
 	require.Equal(t, 80, screenWidthAtResize, "pty.Resize must run before screen.Resize")
-	require.Equal(t, 100, win.screen.Frame.Width, "screen resized after pty")
+	require.Equal(t, 100, win.focusedPane().screen.Frame.Width, "screen resized after pty")
-	require.Equal(t, 28, win.screen.Frame.Height, "screen reserves top and bottom chrome rows")
+	require.Equal(t, 28, win.focusedPane().screen.Frame.Height, "screen reserves top and bottom chrome rows")
 	require.True(t, gotOutput.Load(), "resize forces a full redraw output")
 }
 	tr.EXPECT().Close().Return(nil).Maybe()
 	d := newTestDaemon(t, nil, stubClock{})
-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}}
+	win := newTab(p, domain.Size{Cols: 20, Rows: 5})
 	sctx, cancel := context.WithCancel(context.Background())
 	ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
 	sess := &session{id: "e", name: "0", ephemeral: true, tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
 	d.sessions[sess.id] = sess
 	win.mu.Lock()
-	win.screen.Write([]byte("x"))
+	win.focusedPane().screen.Write([]byte("x"))
 	win.mu.Unlock()
 	d.paint(sess, ac, true) // send fails -> detach -> ephemeral killed
 	tr, sends := newCapturingTransport(t)
 	sctx, cancel := context.WithCancel(context.Background())
-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
+	win := newTestTabWithContext(p, sctx, cancel)
 	ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
 	sess := &session{id: "query", name: "query", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
 	ac.setSession(sess)
 	d.sessions[sess.id] = sess
 	d.sessWg.Add(1)
-	d.ptyReader(sess, win)
+	d.ptyReader(sess, win, win.focusedPane())
 	select {
 	case got := <-writes:
 	p.EXPECT().Close().Return(nil).Maybe()
 	sctx, cancel := context.WithCancel(context.Background())
-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
+	win := newTestTabWithContext(p, sctx, cancel)
 	sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel}
 	d.sessions[sess.id] = sess
 	d.sessWg.Add(1)
-	d.ptyReader(sess, win)
+	d.ptyReader(sess, win, win.focusedPane())
 	select {
-	case <-win.dirty:
+	case <-win.focusedPane().dirty:
 		t.Fatal("same-read synchronized update end should request flush, not dirty")
 	default:
 	}
 	select {
-	case <-win.flush:
+	case <-win.focusedPane().flush:
 	case <-time.After(time.Second):
 		t.Fatal("same-read synchronized update end did not request immediate flush")
 	}
 	p.EXPECT().Close().Return(nil).Maybe()
 	sctx, cancel := context.WithCancel(context.Background())
-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
+	win := newTestTabWithContext(p, sctx, cancel)
 	sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel}
 	d.sessions[sess.id] = sess
 	d.sessWg.Add(1)
-	d.ptyReader(sess, win)
+	d.ptyReader(sess, win, win.focusedPane())
 	select {
-	case <-win.dirty:
+	case <-win.focusedPane().dirty:
 		t.Fatal("dirty signaled while synchronized update was active")
 	default:
 	}
 	select {
-	case <-win.flush:
+	case <-win.focusedPane().flush:
 	case <-time.After(time.Second):
 		t.Fatal("sync end did not request immediate flush")
 	}
 	tr, sends := newCapturingTransport(t)
 	sctx, cancel := context.WithCancel(context.Background())
-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
+	win := newTestTabWithContext(p, sctx, cancel)
 	ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
 	sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
 	ac.setSession(sess)
 	d.sessions[sess.id] = sess
 	d.sessWg.Add(2)
-	go d.scheduler(sess, win)
+	go d.scheduler(sess, win, win.focusedPane())
-	go d.ptyReader(sess, win)
+	go d.ptyReader(sess, win, win.focusedPane())
 	timer := <-clk.timers
 	timer.ch <- time.Now()
 	awaitFrame(t, sends, ports.MsgOutput)
 	win.mu.Lock()
-	active := win.screen.SyncUpdateActive()
+	active := win.focusedPane().screen.SyncUpdateActive()
-	got := screenLineText(win.screen, 0)
+	got := screenLineText(win.focusedPane().screen, 0)
 	win.mu.Unlock()
 	require.False(t, active)
 	require.Contains(t, got, "abandoned")
 	tr, sends := newCapturingTransport(t)
 	sctx, cancel := context.WithCancel(context.Background())
-	win := &tab{pty: p, screen: vt.NewScreen(20, 5), dirty: make(chan struct{}, 1), flush: make(chan struct{}, 1), size: domain.Size{Cols: 20, Rows: 5}, ctx: sctx, cancel: cancel}
+	win := newTestTabWithContext(p, sctx, cancel)
 	ac := &attachedClient{tr: tr, rend: renderer.New(renderer.Capabilities{})}
 	sess := &session{id: "sync", name: "sync", tabs: []*tab{win}, ctx: sctx, cancel: cancel, client: ac}
 	ac.setSession(sess)
 	d.sessions[sess.id] = sess
 	d.sessWg.Add(2)
-	go d.scheduler(sess, win)
+	go d.scheduler(sess, win, win.focusedPane())
-	go d.ptyReader(sess, win)
+	go d.ptyReader(sess, win, win.focusedPane())
 	timer := <-clk.timers
 	awaitFrame(t, sends, ports.MsgOutput)
 	case <-time.After(50 * time.Millisecond):
 	}
 	win.mu.Lock()
-	active := win.screen.SyncUpdateActive()
+	active := win.focusedPane().screen.SyncUpdateActive()
 	win.mu.Unlock()
 	require.False(t, active)
 	p, _ := newBlockingPTY(t)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
 	win := sess.tabs[0]
-	win.screen.Write([]byte("A"))
+	win.focusedPane().screen.Write([]byte("A"))
 	d.paint(sess, ac, true)
 	data := mustOutputData(t, sends)
 	require.Contains(t, string(data), "\x1b[5 q")
 	require.Contains(t, string(data), "\x1b[?25h")
-	win.screen.Write([]byte("\x1b[2;3H"))
+	win.focusedPane().screen.Write([]byte("\x1b[2;3H"))
 	d.paint(sess, ac, false)
 	data = mustOutputData(t, sends)
 	require.Contains(t, string(data), "\x1b[3;3H")
 	require.Contains(t, string(data), "\x1b[?25h")
-	win.screen.Write([]byte("\x1b[?25l"))
+	win.focusedPane().screen.Write([]byte("\x1b[?25l"))
 	d.paint(sess, ac, false)
 	data = mustOutputData(t, sends)
 	require.Contains(t, string(data), "\x1b[?25l")

M internal/usecase/daemon/scrollback_test.go +6 -6


@@ -24,19 +24,19 @@ func TestNewTabInitializesScrollback(t *testing.T) {
24	24		for _, tt := range tests {
25	25		t.Run(tt.name, func(t *testing.T) {
26	26		win := newTab(nil, domain.Size{Cols: 4, Rows: 3})
27		-	if win.scrollback == nil {
	27	+	if win.focusedPane().scrollback == nil {
28	28		t.Fatal("scrollback is nil")
29	29		}
30		-	if win.scrollback.Cap() != defaultScrollbackRows {
31		-	t.Fatalf("scrollback cap = %d, want %d", win.scrollback.Cap(), defaultScrollbackRows)
	30	+	if win.focusedPane().scrollback.Cap() != defaultScrollbackRows {
	31	+	t.Fatalf("scrollback cap = %d, want %d", win.focusedPane().scrollback.Cap(), defaultScrollbackRows)
32	32		}
33	33
34		-	win.screen.Write(tt.write)
	34	+	win.focusedPane().screen.Write(tt.write)
35	35
36		-	if got := win.scrollback.Len(); got != tt.wantLen {
	36	+	if got := win.focusedPane().scrollback.Len(); got != tt.wantLen {
37	37		t.Fatalf("scrollback len = %d, want %d", got, tt.wantLen)
38	38		}
39		-	row := win.scrollback.Row(0)
	39	+	row := win.focusedPane().scrollback.Row(0)
40	40		runes := make([]rune, len(row))
41	41		for i, c := range row {
42	42		runes[i] = c.Rune


@@ -24,19 +24,19 @@ func TestNewTabInitializesScrollback(t *testing.T) {
24		for _, tt := range tests {	24		for _, tt := range tests {
25		t.Run(tt.name, func(t *testing.T) {	25		t.Run(tt.name, func(t *testing.T) {
26		win := newTab(nil, domain.Size{Cols: 4, Rows: 3})	26		win := newTab(nil, domain.Size{Cols: 4, Rows: 3})
27	-	if win.scrollback == nil {	27	+	if win.focusedPane().scrollback == nil {
28		t.Fatal("scrollback is nil")	28		t.Fatal("scrollback is nil")
29		}	29		}
30	-	if win.scrollback.Cap() != defaultScrollbackRows {	30	+	if win.focusedPane().scrollback.Cap() != defaultScrollbackRows {
31	-	t.Fatalf("scrollback cap = %d, want %d", win.scrollback.Cap(), defaultScrollbackRows)	31	+	t.Fatalf("scrollback cap = %d, want %d", win.focusedPane().scrollback.Cap(), defaultScrollbackRows)
32		}	32		}
33			33
34	-	win.screen.Write(tt.write)	34	+	win.focusedPane().screen.Write(tt.write)
35			35
36	-	if got := win.scrollback.Len(); got != tt.wantLen {	36	+	if got := win.focusedPane().scrollback.Len(); got != tt.wantLen {
37		t.Fatalf("scrollback len = %d, want %d", got, tt.wantLen)	37		t.Fatalf("scrollback len = %d, want %d", got, tt.wantLen)
38		}	38		}
39	-	row := win.scrollback.Row(0)	39	+	row := win.focusedPane().scrollback.Row(0)
40		runes := make([]rune, len(row))	40		runes := make([]rune, len(row))
41		for i, c := range row {	41		for i, c := range row {
42		runes[i] = c.Rune	42		runes[i] = c.Rune

M internal/usecase/daemon/session.go +3 -37


@@ -36,9 +36,7 @@ import (
36	36		"github.com/bnema/vev/internal/domain"
37	37		"github.com/bnema/vev/internal/persist"
38	38		"github.com/bnema/vev/internal/ports"
39		-	scopy "github.com/bnema/vev/internal/usecase/copy"
40	39		"github.com/bnema/vev/internal/usecase/layout"
41		-	"github.com/bnema/vev/pkg/vt"
42	40		)
43	41
44	42		type session struct {

@@ -57,18 +55,8 @@ type session struct {
57	55		createdAt int64
58	56		}
59	57
60		-	// tab is a pane layout container. In the single-leaf case it preserves the old
61		-	// one-PTY tab behavior; pane owns PTY/screen/scrollback/render scheduling state.
	58	+	// tab is a pane layout container; pane owns PTY/screen/scrollback/render scheduling state.
62	59		type tab struct {
63		-	// Compatibility aliases for the single focused pane. Production call sites use
64		-	// focusedPane/all-pane loops; tests still inspect the single-leaf state directly.
65		-	pty ports.PTY
66		-	screen *vt.Screen
67		-	scrollback *scopy.Scrollback
68		-	dirty chan struct{}
69		-	flush chan struct{}
70		-	syncGen uint64
71		-
72	60		mu sync.Mutex // guards tree, panes, nextPaneID, size, previewClient, and pane map membership
73	61
74	62		tree *layout.Tree

@@ -220,11 +208,6 @@ func newTab(pty ports.PTY, sz domain.Size) *tab {
220	208		id := layout.PaneID("pane-1")
221	209		p := newPane(id, pty, sz)
222	210		return &tab{
223		-	pty: p.pty,
224		-	screen: p.screen,
225		-	scrollback: p.scrollback,
226		-	dirty: p.dirty,
227		-	flush: p.flush,
228	211		tree: layout.NewTree(id),
229	212		panes: map[layout.PaneID]*pane{id: p},
230	213		nextPaneID: 2,

@@ -233,33 +216,16 @@ func newTab(pty ports.PTY, sz domain.Size) *tab {
233	216		}
234	217
235	218		func (tb tab) focusedPane() pane {
236		-	if tb == nil {
	219	+	if tb == nil \|\| tb.tree == nil \|\| tb.panes == nil {
237	220		return nil
238	221		}
239		-	if tb.tree != nil && tb.panes != nil {
240		-	p := tb.panes[tb.tree.Focus]
241		-	if p == nil {
242		-	return nil
243		-	}
244		-	if len(tb.panes) == 1 && ((tb.pty != nil && tb.pty != p.pty) \|\| (tb.screen != nil && tb.screen != p.screen) \|\| (tb.scrollback != nil && tb.scrollback != p.scrollback) \|\| (tb.dirty != nil && tb.dirty != p.dirty) \|\| (tb.flush != nil && tb.flush != p.flush)) {
245		-	return &pane{id: p.id, pty: tb.pty, screen: tb.screen, scrollback: tb.scrollback, dirty: tb.dirty, flush: tb.flush, syncGen: tb.syncGen, rect: p.rect, ctx: tb.ctx, cancel: tb.cancel}
246		-	}
247		-	return p
248		-	}
249		-	if tb.pty != nil \|\| tb.screen != nil \|\| tb.scrollback != nil {
250		-	return &pane{pty: tb.pty, screen: tb.screen, scrollback: tb.scrollback, dirty: tb.dirty, flush: tb.flush, syncGen: tb.syncGen, ctx: tb.ctx, cancel: tb.cancel}
251		-	}
252		-	return nil
	222	+	return tb.panes[tb.tree.Focus]
253	223		}
254	224
255	225		func (tb tab) panesSnapshot() []pane {
256	226		if tb == nil {
257	227		return nil
258	228		}
259		-	p0 := tb.focusedPane()
260		-	if len(tb.panes) == 0 && p0 != nil {
261		-	return []*pane{p0}
262		-	}
263	229		out := make([]*pane, 0, len(tb.panes))
264	230		for _, p := range tb.panes {
265	231		out = append(out, p)

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/persist"
 	"github.com/bnema/vev/internal/ports"
-	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
-	"github.com/bnema/vev/pkg/vt"
 )
 type session struct {
 	createdAt int64
 }
-// tab is a pane layout container. In the single-leaf case it preserves the old
+// tab is a pane layout container; pane owns PTY/screen/scrollback/render scheduling state.
-// one-PTY tab behavior; pane owns PTY/screen/scrollback/render scheduling state.
 type tab struct {
-	// Compatibility aliases for the single focused pane. Production call sites use
-	// focusedPane/all-pane loops; tests still inspect the single-leaf state directly.
-	pty        ports.PTY
-	screen     *vt.Screen
-	scrollback *scopy.Scrollback
-	dirty      chan struct{}
-	flush      chan struct{}
-	syncGen    uint64
 	mu sync.Mutex // guards tree, panes, nextPaneID, size, previewClient, and pane map membership
 	tree       *layout.Tree
 	id := layout.PaneID("pane-1")
 	p := newPane(id, pty, sz)
 	return &tab{
-		pty:        p.pty,
-		screen:     p.screen,
-		scrollback: p.scrollback,
-		dirty:      p.dirty,
-		flush:      p.flush,
 		tree:       layout.NewTree(id),
 		panes:      map[layout.PaneID]*pane{id: p},
 		nextPaneID: 2,
 }
 func (tb *tab) focusedPane() *pane {
-	if tb == nil {
+	if tb == nil || tb.tree == nil || tb.panes == nil {
 		return nil
 	}
-	if tb.tree != nil && tb.panes != nil {
+	return tb.panes[tb.tree.Focus]
-		p := tb.panes[tb.tree.Focus]
-		if p == nil {
-			return nil
-		}
-		if len(tb.panes) == 1 && ((tb.pty != nil && tb.pty != p.pty) || (tb.screen != nil && tb.screen != p.screen) || (tb.scrollback != nil && tb.scrollback != p.scrollback) || (tb.dirty != nil && tb.dirty != p.dirty) || (tb.flush != nil && tb.flush != p.flush)) {
-			return &pane{id: p.id, pty: tb.pty, screen: tb.screen, scrollback: tb.scrollback, dirty: tb.dirty, flush: tb.flush, syncGen: tb.syncGen, rect: p.rect, ctx: tb.ctx, cancel: tb.cancel}
-		}
-		return p
-	}
-	if tb.pty != nil || tb.screen != nil || tb.scrollback != nil {
-		return &pane{pty: tb.pty, screen: tb.screen, scrollback: tb.scrollback, dirty: tb.dirty, flush: tb.flush, syncGen: tb.syncGen, ctx: tb.ctx, cancel: tb.cancel}
-	}
-	return nil
 }
 func (tb *tab) panesSnapshot() []*pane {
 	if tb == nil {
 		return nil
 	}
-	p0 := tb.focusedPane()
-	if len(tb.panes) == 0 && p0 != nil {
-		return []*pane{p0}
-	}
 	out := make([]*pane, 0, len(tb.panes))
 	for _, p := range tb.panes {
 		out = append(out, p)

M internal/usecase/daemon/status_test.go +20 -21


@@ -12,7 +12,6 @@ import (
12	12		"github.com/bnema/vev/internal/ports"
13	13		themeui "github.com/bnema/vev/internal/usecase/theme"
14	14		"github.com/bnema/vev/pkg/renderer"
15		-	"github.com/bnema/vev/pkg/vt"
16	15		)
17	16
18	17		// --- test doubles -----------------------------------------------------------

@@ -30,9 +29,9 @@ func TestStatusCompositionGolden(t *testing.T) {
30	29		sess.name = "work"
31	30
32	31		win := sess.activeTab()
33		-	win.screen = vt.NewScreen(12, 2)
	32	+	win.focusedPane().screen.Resize(12, 2)
34	33		win.size = domain.Size{Cols: 12, Rows: 2}
35		-	win.screen.Write([]byte("hello"))
	34	+	win.focusedPane().screen.Write([]byte("hello"))
36	35
37	36		frame, damage := composeClientFrame(sess, win, true, "")
38	37

@@ -54,7 +53,7 @@ func TestStatusCompositionUsesTruecolorTheme(t *testing.T) {
54	53		_, sess, ac, _ := newManualSessionWithPTYs(t, p)
55	54		defer release()
56	55		win := sess.activeTab()
57		-	win.screen = vt.NewScreen(12, 2)
	56	+	win.focusedPane().screen.Resize(12, 2)
58	57		win.size = domain.Size{Cols: 12, Rows: 2}
59	58		ac.setTheme(themeui.Theme{
60	59		Foreground: renderer.RGB{R: 220, G: 220, B: 220},

@@ -86,8 +85,8 @@ func TestStatusApplyThemeStoresClientAndPropagatesScreens(t *testing.T) {
86	85		require.Equal(t, renderer.RGB{R: 1, G: 2, B: 3}, ac.getTheme().Foreground)
87	86		for _, tb := range sess.tabs {
88	87		var got []byte
89		-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
90		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	88	+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
	89	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
91	90		require.True(t, strings.Contains(string(got), "rgb:0101/0202/0303"), string(got))
92	91		require.True(t, strings.Contains(string(got), "rgb:0404/0505/0606"), string(got))
93	92		}

@@ -107,8 +106,8 @@ func TestAttachClientClearsStaleScreenDefaultColors(t *testing.T) {
107	106
108	107		var got []byte
109	108		tb := sess.activeTab()
110		-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
111		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	109	+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
	110	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
112	111		require.Empty(t, got)
113	112		}
114	113

@@ -124,15 +123,15 @@ func TestClientGoneResetsScreenDefaultColors(t *testing.T) {
124	123		// Sanity: the tab answers OSC 10/11 while ac is attached.
125	124		tb := sess.activeTab()
126	125		var before []byte
127		-	tb.screen.OnResponse = func(b []byte) { before = append(before, b...) }
128		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	126	+	tb.focusedPane().screen.OnResponse = func(b []byte) { before = append(before, b...) }
	127	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
129	128		require.NotEmpty(t, before)
130	129
131	130		d.clientGone(sess, ac, true)
132	131
133	132		var got []byte
134		-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
135		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	133	+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
	134	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
136	135		require.Empty(t, got, "OSC 10/11 queries must be swallowed once the client that reported these colors is gone")
137	136		}
138	137

@@ -164,8 +163,8 @@ func TestClientGoneResetDoesNotClobberNewlyAttachedClient(t *testing.T) {
164	163
165	164		tb := sess.activeTab()
166	165		var got []byte
167		-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
168		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	166	+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
	167	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
169	168		require.NotEmpty(t, got, "a newer client's screen default colors must survive a stale detach's reset")
170	169		}
171	170

@@ -182,8 +181,8 @@ func TestDetachOnSendErrorResetsScreenDefaultColors(t *testing.T) {
182	181
183	182		tb := sess.activeTab()
184	183		var got []byte
185		-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
186		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	184	+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
	185	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
187	186		require.Empty(t, got, "OSC 10/11 queries must be swallowed once the client that reported these colors is gone")
188	187		}
189	188

@@ -201,8 +200,8 @@ func TestApplyThemeIgnoresReplacedClient(t *testing.T) {
201	200
202	201		var got []byte
203	202		tb := sess.activeTab()
204		-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
205		-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
	203	+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
	204	+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
206	205		require.Empty(t, got)
207	206		}
208	207

@@ -213,7 +212,7 @@ func TestStatusMarksEphemeralSession(t *testing.T) {
213	212		sess.name = "0"
214	213		sess.ephemeral = true
215	214		win := sess.activeTab()
216		-	win.screen = vt.NewScreen(12, 2)
	215	+	win.focusedPane().screen.Resize(12, 2)
217	216		win.size = domain.Size{Cols: 12, Rows: 2}
218	217
219	218		frame, _ := composeClientFrame(sess, win, true, "")

@@ -228,7 +227,7 @@ func TestStatusCopyFeedbackRendersOnlyWhenFullyFits(t *testing.T) {
228	227		defer releasePTY()
229	228		sess.name = "work"
230	229		win := sess.activeTab()
231		-	win.screen = vt.NewScreen(30, 2)
	230	+	win.focusedPane().screen.Resize(30, 2)
232	231		win.size = domain.Size{Cols: 30, Rows: 2}
233	232
234	233		frame, _ := composeClientFrame(sess, win, true, "ok")

@@ -265,7 +264,7 @@ func TestTopBarRendersAttentionBell(t *testing.T) {
265	264		defer releasePTY1()
266	265		defer releasePTY2()
267	266		win := sess.activeTab()
268		-	win.screen = vt.NewScreen(18, 2)
	267	+	win.focusedPane().screen.Resize(18, 2)
269	268		win.size = domain.Size{Cols: 18, Rows: 2}
270	269		sess.mu.Lock()
271	270		sess.tabs[1].attention = true

 	"github.com/bnema/vev/internal/ports"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 	"github.com/bnema/vev/pkg/renderer"
-	"github.com/bnema/vev/pkg/vt"
 )
 // --- test doubles -----------------------------------------------------------
 	sess.name = "work"
 	win := sess.activeTab()
-	win.screen = vt.NewScreen(12, 2)
+	win.focusedPane().screen.Resize(12, 2)
 	win.size = domain.Size{Cols: 12, Rows: 2}
-	win.screen.Write([]byte("hello"))
+	win.focusedPane().screen.Write([]byte("hello"))
 	frame, damage := composeClientFrame(sess, win, true, "")
 	_, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer release()
 	win := sess.activeTab()
-	win.screen = vt.NewScreen(12, 2)
+	win.focusedPane().screen.Resize(12, 2)
 	win.size = domain.Size{Cols: 12, Rows: 2}
 	ac.setTheme(themeui.Theme{
 		Foreground: renderer.RGB{R: 220, G: 220, B: 220},
 	require.Equal(t, renderer.RGB{R: 1, G: 2, B: 3}, ac.getTheme().Foreground)
 	for _, tb := range sess.tabs {
 		var got []byte
-		tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
+		tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
-		tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+		tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 		require.True(t, strings.Contains(string(got), "rgb:0101/0202/0303"), string(got))
 		require.True(t, strings.Contains(string(got), "rgb:0404/0505/0606"), string(got))
 	}
 	var got []byte
 	tb := sess.activeTab()
-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 	require.Empty(t, got)
 }
 	// Sanity: the tab answers OSC 10/11 while ac is attached.
 	tb := sess.activeTab()
 	var before []byte
-	tb.screen.OnResponse = func(b []byte) { before = append(before, b...) }
+	tb.focusedPane().screen.OnResponse = func(b []byte) { before = append(before, b...) }
-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 	require.NotEmpty(t, before)
 	d.clientGone(sess, ac, true)
 	var got []byte
-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 	require.Empty(t, got, "OSC 10/11 queries must be swallowed once the client that reported these colors is gone")
 }
 	tb := sess.activeTab()
 	var got []byte
-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 	require.NotEmpty(t, got, "a newer client's screen default colors must survive a stale detach's reset")
 }
 	tb := sess.activeTab()
 	var got []byte
-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 	require.Empty(t, got, "OSC 10/11 queries must be swallowed once the client that reported these colors is gone")
 }
 	var got []byte
 	tb := sess.activeTab()
-	tb.screen.OnResponse = func(b []byte) { got = append(got, b...) }
+	tb.focusedPane().screen.OnResponse = func(b []byte) { got = append(got, b...) }
-	tb.screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
+	tb.focusedPane().screen.Write([]byte("\x1b]10;?\a\x1b]11;?\a"))
 	require.Empty(t, got)
 }
 	sess.name = "0"
 	sess.ephemeral = true
 	win := sess.activeTab()
-	win.screen = vt.NewScreen(12, 2)
+	win.focusedPane().screen.Resize(12, 2)
 	win.size = domain.Size{Cols: 12, Rows: 2}
 	frame, _ := composeClientFrame(sess, win, true, "")
 	defer releasePTY()
 	sess.name = "work"
 	win := sess.activeTab()
-	win.screen = vt.NewScreen(30, 2)
+	win.focusedPane().screen.Resize(30, 2)
 	win.size = domain.Size{Cols: 30, Rows: 2}
 	frame, _ := composeClientFrame(sess, win, true, "ok")
 	defer releasePTY1()
 	defer releasePTY2()
 	win := sess.activeTab()
-	win.screen = vt.NewScreen(18, 2)
+	win.focusedPane().screen.Resize(18, 2)
 	win.size = domain.Size{Cols: 18, Rows: 2}
 	sess.mu.Lock()
 	sess.tabs[1].attention = true

M internal/usecase/keys/router.go +3 -5


@@ -224,16 +224,14 @@ func passThroughPrefix(b byte) bool { return b == '[' \|\| b == 'O' }
224	224
225	225		func altArrowCSI(data []byte) (Action, int, bool, bool) {
226	226		const seqLen = len("[1;3A")
227		-	if len(data) > seqLen {
228		-	return 0, 0, false, false
229		-	}
230	227		if len(data) < seqLen {
231	228		return 0, 0, false, hasAltArrowCSIPrefix(data)
232	229		}
233		-	if data[0] != '[' \|\| data[1] != '1' \|\| data[2] != ';' \|\| (data[3] != '3' && data[3] != '9') {
	230	+	seq := data[:seqLen]
	231	+	if seq[0] != '[' \|\| seq[1] != '1' \|\| seq[2] != ';' \|\| (seq[3] != '3' && seq[3] != '9') {
234	232		return 0, 0, false, false
235	233		}
236		-	switch data[4] {
	234	+	switch seq[4] {
237	235		case 'A':
238	236		return ActionFocusPaneUp, seqLen, true, false
239	237		case 'B':

 func altArrowCSI(data []byte) (Action, int, bool, bool) {
 	const seqLen = len("[1;3A")
-	if len(data) > seqLen {
-		return 0, 0, false, false
-	}
 	if len(data) < seqLen {
 		return 0, 0, false, hasAltArrowCSIPrefix(data)
 	}
-	if data[0] != '[' || data[1] != '1' || data[2] != ';' || (data[3] != '3' && data[3] != '9') {
+	seq := data[:seqLen]
+	if seq[0] != '[' || seq[1] != '1' || seq[2] != ';' || (seq[3] != '3' && seq[3] != '9') {
 		return 0, 0, false, false
 	}
-	switch data[4] {
+	switch seq[4] {
 	case 'A':
 		return ActionFocusPaneUp, seqLen, true, false
 	case 'B':

M internal/usecase/keys/router_test.go +44 -0


@@ -301,6 +301,50 @@ func TestRouterAltArrowCSIPartialsAcrossReads(t *testing.T) {
301	301		}
302	302		}
303	303
	304	+	func TestRouterAltArrowCSIPrefixRouting(t *testing.T) {
	305	+	cases := []struct {
	306	+	name string
	307	+	reads [][]byte
	308	+	wantActions []Action
	309	+	wantForwards [][]byte
	310	+	}{
	311	+	{
	312	+	name: "two alt arrows in one read",
	313	+	reads: [][]byte{{ESC, '[', '1', ';', '3', 'A', ESC, '[', '1', ';', '3', 'A'}},
	314	+	wantActions: []Action{ActionFocusPaneUp, ActionFocusPaneUp},
	315	+	},
	316	+	{
	317	+	name: "alt arrow followed by normal byte",
	318	+	reads: [][]byte{{ESC, '[', '1', ';', '3', 'A', 'x'}},
	319	+	wantActions: []Action{ActionFocusPaneUp},
	320	+	wantForwards: [][]byte{[]byte("x")},
	321	+	},
	322	+	{
	323	+	name: "bare arrow passthrough",
	324	+	reads: [][]byte{{ESC, '[', 'A'}},
	325	+	wantForwards: [][]byte{{ESC, '[', 'A'}},
	326	+	},
	327	+	{
	328	+	name: "retained escape alt arrow across reads",
	329	+	reads: [][]byte{{ESC}, []byte("[1;3A")},
	330	+	wantActions: []Action{ActionFocusPaneUp},
	331	+	},
	332	+	}
	333	+
	334	+	for _, tc := range cases {
	335	+	t.Run(tc.name, func(t *testing.T) {
	336	+	clk := &fakeClock{}
	337	+	h := &captureHandler{}
	338	+	r := NewRouter(clk, h)
	339	+	for _, read := range tc.reads {
	340	+	r.Route(read)
	341	+	}
	342	+	require.Equal(t, tc.wantActions, h.actions)
	343	+	require.Equal(t, tc.wantForwards, h.forwards)
	344	+	})
	345	+	}
	346	+	}
	347	+
304	348		func TestRouterPassesThroughBareArrows(t *testing.T) {
305	349		for _, in := range [][]byte{
306	350		{ESC, '[', 'A'},


@@ -301,6 +301,50 @@ func TestRouterAltArrowCSIPartialsAcrossReads(t *testing.T) {
301	}	301		}
302	}	302		}
303		303
		304	+	func TestRouterAltArrowCSIPrefixRouting(t *testing.T) {
		305	+	cases := []struct {
		306	+	name string
		307	+	reads [][]byte
		308	+	wantActions []Action
		309	+	wantForwards [][]byte
		310	+	}{
		311	+	{
		312	+	name: "two alt arrows in one read",
		313	+	reads: [][]byte{{ESC, '[', '1', ';', '3', 'A', ESC, '[', '1', ';', '3', 'A'}},
		314	+	wantActions: []Action{ActionFocusPaneUp, ActionFocusPaneUp},
		315	+	},
		316	+	{
		317	+	name: "alt arrow followed by normal byte",
		318	+	reads: [][]byte{{ESC, '[', '1', ';', '3', 'A', 'x'}},
		319	+	wantActions: []Action{ActionFocusPaneUp},
		320	+	wantForwards: [][]byte{[]byte("x")},
		321	+	},
		322	+	{
		323	+	name: "bare arrow passthrough",
		324	+	reads: [][]byte{{ESC, '[', 'A'}},
		325	+	wantForwards: [][]byte{{ESC, '[', 'A'}},
		326	+	},
		327	+	{
		328	+	name: "retained escape alt arrow across reads",
		329	+	reads: [][]byte{{ESC}, []byte("[1;3A")},
		330	+	wantActions: []Action{ActionFocusPaneUp},
		331	+	},
		332	+	}
		333	+
		334	+	for _, tc := range cases {
		335	+	t.Run(tc.name, func(t *testing.T) {
		336	+	clk := &fakeClock{}
		337	+	h := &captureHandler{}
		338	+	r := NewRouter(clk, h)
		339	+	for _, read := range tc.reads {
		340	+	r.Route(read)
		341	+	}
		342	+	require.Equal(t, tc.wantActions, h.actions)
		343	+	require.Equal(t, tc.wantForwards, h.forwards)
		344	+	})
		345	+	}
		346	+	}
		347	+
304	func TestRouterPassesThroughBareArrows(t *testing.T) {	348		func TestRouterPassesThroughBareArrows(t *testing.T) {
305	for _, in := range [][]byte{	349		for _, in := range [][]byte{
306	{ESC, '[', 'A'},	350		{ESC, '[', 'A'},

M internal/usecase/layout/geometry.go +1 -1


@@ -93,7 +93,7 @@ func solveStack(n Node, r domain.Rect, out []Placement) bool {
93	93		}
94	94		}
95	95		if idx < 0 {
96		-	idx = 0
	96	+	return false
97	97		}
98	98		contentRows := r.Height - count
99	99		for i, child := range n.Children {


@@ -93,7 +93,7 @@ func solveStack(n Node, r domain.Rect, out []Placement) bool {
93		}	93		}
94		}	94		}
95		if idx < 0 {	95		if idx < 0 {
96	-	idx = 0	96	+	return false
97		}	97		}
98		contentRows := r.Height - count	98		contentRows := r.Height - count
99		for i, child := range n.Children {	99		for i, child := range n.Children {

M internal/usecase/layout/layout_test.go +178 -0


@@ -136,6 +136,102 @@ func TestTreeSurgeryShapes(t *testing.T) {
136	136		})
137	137		}
138	138
	139	+	func TestToggleStackNestedShapes(t *testing.T) {
	140	+	t.Parallel()
	141	+	area := domain.Rect{Width: 62, Height: 5}
	142	+	tests := []struct {
	143	+	name string
	144	+	root *Node
	145	+	target PaneID
	146	+	wantKind Kind
	147	+	wantDir SplitDir
	148	+	wantErr error
	149	+	wantLeaves []PaneID
	150	+	}{
	151	+	{
	152	+	name: "nested stack toggles directly containing stack",
	153	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	154	+	NewLeaf("a"),
	155	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c")}, Expanded: "b"},
	156	+	}},
	157	+	target: "b",
	158	+	wantKind: Split,
	159	+	wantDir: Vertical,
	160	+	wantLeaves: []PaneID{"b", "c"},
	161	+	},
	162	+	{
	163	+	name: "nested split toggles directly containing two-leaf split",
	164	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	165	+	NewLeaf("a"),
	166	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("b"), NewLeaf("c")}},
	167	+	}},
	168	+	target: "b",
	169	+	wantKind: Stack,
	170	+	wantLeaves: []PaneID{"b", "c"},
	171	+	},
	172	+	{
	173	+	name: "nested non toggleable split reports not toggleable",
	174	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	175	+	NewLeaf("a"),
	176	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("b"), NewLeaf("c"), NewLeaf("d")}},
	177	+	}},
	178	+	target: "b",
	179	+	wantErr: ErrNotToggleable,
	180	+	},
	181	+	{
	182	+	name: "three leaf split reports not toggleable not too small",
	183	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	184	+	NewLeaf("a"), NewLeaf("b"), NewLeaf("c"),
	185	+	}},
	186	+	target: "b",
	187	+	wantErr: ErrNotToggleable,
	188	+	},
	189	+	}
	190	+	for _, tt := range tests {
	191	+	t.Run(tt.name, func(t *testing.T) {
	192	+	tr := &Tree{Root: tt.root, Focus: tt.target}
	193	+	err := tr.ToggleStack(tt.target, area)
	194	+	if tt.wantErr != nil {
	195	+	require.ErrorIs(t, err, tt.wantErr)
	196	+	require.NotErrorIs(t, err, ErrTooSmall)
	197	+	return
	198	+	}
	199	+	require.NoError(t, err)
	200	+	container := tr.Root.Children[1]
	201	+	require.Equal(t, tt.wantKind, container.Kind)
	202	+	if tt.wantKind == Split {
	203	+	require.Equal(t, tt.wantDir, container.Dir)
	204	+	}
	205	+	require.Equal(t, tt.wantLeaves, LeafIDs(container))
	206	+	})
	207	+	}
	208	+	}
	209	+
	210	+	func TestCloseRefocusPrefersSibling(t *testing.T) {
	211	+	t.Parallel()
	212	+	tr := &Tree{Focus: "c", Root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	213	+	NewLeaf("a"),
	214	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("b"), NewLeaf("c")}},
	215	+	NewLeaf("d"),
	216	+	}}}
	217	+	require.NoError(t, tr.Close("c"))
	218	+	require.Equal(t, PaneID("b"), tr.Focus)
	219	+	}
	220	+
	221	+	func TestSolveRejectsStackWithMissingExpanded(t *testing.T) {
	222	+	t.Parallel()
	223	+	_, ok := Solve(&Node{Kind: Stack, Children: []*Node{NewLeaf("a"), NewLeaf("b")}, Expanded: "missing"}, domain.Rect{Width: 20, Height: 4})
	224	+	require.False(t, ok)
	225	+	}
	226	+
	227	+	func TestExportedLeafHelpers(t *testing.T) {
	228	+	t.Parallel()
	229	+	root := &Node{Kind: Split, Dir: Horizontal, Children: []*Node{NewLeaf("a"), NewLeaf("b")}}
	230	+	require.True(t, ContainsLeaf(root, "b"))
	231	+	require.False(t, ContainsLeaf(root, "c"))
	232	+	require.Equal(t, []PaneID{"a", "b"}, LeafIDs(root))
	233	+	}
	234	+
139	235		func TestFocusDir(t *testing.T) {
140	236		t.Parallel()
141	237		area := domain.Rect{Width: 62, Height: 5}

@@ -168,6 +264,7 @@ func TestFocusDir(t *testing.T) {
168	264		require.Equal(t, PaneID("c"), tr.Root.Expanded)
169	265		require.NoError(t, tr.FocusDir(Up, domain.Rect{Width: 20, Height: 4}))
170	266		require.Equal(t, PaneID("b"), tr.Focus)
	267	+	require.Equal(t, PaneID("b"), tr.Root.Expanded)
171	268		})
172	269
173	270		t.Run("no pane in direction", func(t *testing.T) {

@@ -177,6 +274,74 @@ func TestFocusDir(t *testing.T) {
177	274		})
178	275		}
179	276
	277	+	func TestFocusDirEnteringStackExpandsMember(t *testing.T) {
	278	+	t.Parallel()
	279	+	tests := []struct {
	280	+	name string
	281	+	root *Node
	282	+	area domain.Rect
	283	+	focus PaneID
	284	+	dir Direction
	285	+	want PaneID
	286	+	}{
	287	+	{
	288	+	name: "from left",
	289	+	area: domain.Rect{Width: 62, Height: 8},
	290	+	focus: "a",
	291	+	dir: Right,
	292	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	293	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("x"), NewLeaf("a")}},
	294	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c"), NewLeaf("d"), NewLeaf("e")}, Expanded: "b"},
	295	+	}},
	296	+	want: "c",
	297	+	},
	298	+	{
	299	+	name: "from right",
	300	+	area: domain.Rect{Width: 62, Height: 8},
	301	+	focus: "a",
	302	+	dir: Left,
	303	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
	304	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c"), NewLeaf("d"), NewLeaf("e")}, Expanded: "b"},
	305	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("x"), NewLeaf("a")}},
	306	+	}},
	307	+	want: "c",
	308	+	},
	309	+	{
	310	+	name: "from above",
	311	+	area: domain.Rect{Width: 41, Height: 7},
	312	+	focus: "a",
	313	+	dir: Down,
	314	+	root: &Node{Kind: Split, Dir: Vertical, Children: []*Node{
	315	+	NewLeaf("a"),
	316	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c")}, Expanded: "c"},
	317	+	}},
	318	+	want: "b",
	319	+	},
	320	+	{
	321	+	name: "from below",
	322	+	area: domain.Rect{Width: 41, Height: 7},
	323	+	focus: "a",
	324	+	dir: Up,
	325	+	root: &Node{Kind: Split, Dir: Vertical, Children: []*Node{
	326	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c")}, Expanded: "b"},
	327	+	NewLeaf("a"),
	328	+	}},
	329	+	want: "c",
	330	+	},
	331	+	}
	332	+	for _, tt := range tests {
	333	+	t.Run(tt.name, func(t *testing.T) {
	334	+	tr := &Tree{Root: tt.root, Focus: tt.focus}
	335	+	var stack *Node
	336	+	findStack(tr.Root, &stack)
	337	+	require.NotEqual(t, tt.want, stack.Expanded)
	338	+	require.NoError(t, tr.FocusDir(tt.dir, tt.area))
	339	+	require.Equal(t, tt.want, tr.Focus)
	340	+	require.Equal(t, tt.want, stack.Expanded)
	341	+	})
	342	+	}
	343	+	}
	344	+
180	345		func contents(ps []Placement) map[PaneID]domain.Rect {
181	346		out := make(map[PaneID]domain.Rect, len(ps))
182	347		for _, p := range ps {

@@ -184,3 +349,16 @@ func contents(ps []Placement) map[PaneID]domain.Rect {
184	349		}
185	350		return out
186	351		}
	352	+
	353	+	func findStack(n Node, out *Node) {
	354	+	if n == nil \|\| *out != nil {
	355	+	return
	356	+	}
	357	+	if n.Kind == Stack {
	358	+	*out = n
	359	+	return
	360	+	}
	361	+	for _, child := range n.Children {
	362	+	findStack(child, out)
	363	+	}
	364	+	}


@@ -136,6 +136,102 @@ func TestTreeSurgeryShapes(t *testing.T) {
136	})	136		})
137	}	137		}
138		138
		139	+	func TestToggleStackNestedShapes(t *testing.T) {
		140	+	t.Parallel()
		141	+	area := domain.Rect{Width: 62, Height: 5}
		142	+	tests := []struct {
		143	+	name string
		144	+	root *Node
		145	+	target PaneID
		146	+	wantKind Kind
		147	+	wantDir SplitDir
		148	+	wantErr error
		149	+	wantLeaves []PaneID
		150	+	}{
		151	+	{
		152	+	name: "nested stack toggles directly containing stack",
		153	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		154	+	NewLeaf("a"),
		155	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c")}, Expanded: "b"},
		156	+	}},
		157	+	target: "b",
		158	+	wantKind: Split,
		159	+	wantDir: Vertical,
		160	+	wantLeaves: []PaneID{"b", "c"},
		161	+	},
		162	+	{
		163	+	name: "nested split toggles directly containing two-leaf split",
		164	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		165	+	NewLeaf("a"),
		166	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("b"), NewLeaf("c")}},
		167	+	}},
		168	+	target: "b",
		169	+	wantKind: Stack,
		170	+	wantLeaves: []PaneID{"b", "c"},
		171	+	},
		172	+	{
		173	+	name: "nested non toggleable split reports not toggleable",
		174	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		175	+	NewLeaf("a"),
		176	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("b"), NewLeaf("c"), NewLeaf("d")}},
		177	+	}},
		178	+	target: "b",
		179	+	wantErr: ErrNotToggleable,
		180	+	},
		181	+	{
		182	+	name: "three leaf split reports not toggleable not too small",
		183	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		184	+	NewLeaf("a"), NewLeaf("b"), NewLeaf("c"),
		185	+	}},
		186	+	target: "b",
		187	+	wantErr: ErrNotToggleable,
		188	+	},
		189	+	}
		190	+	for _, tt := range tests {
		191	+	t.Run(tt.name, func(t *testing.T) {
		192	+	tr := &Tree{Root: tt.root, Focus: tt.target}
		193	+	err := tr.ToggleStack(tt.target, area)
		194	+	if tt.wantErr != nil {
		195	+	require.ErrorIs(t, err, tt.wantErr)
		196	+	require.NotErrorIs(t, err, ErrTooSmall)
		197	+	return
		198	+	}
		199	+	require.NoError(t, err)
		200	+	container := tr.Root.Children[1]
		201	+	require.Equal(t, tt.wantKind, container.Kind)
		202	+	if tt.wantKind == Split {
		203	+	require.Equal(t, tt.wantDir, container.Dir)
		204	+	}
		205	+	require.Equal(t, tt.wantLeaves, LeafIDs(container))
		206	+	})
		207	+	}
		208	+	}
		209	+
		210	+	func TestCloseRefocusPrefersSibling(t *testing.T) {
		211	+	t.Parallel()
		212	+	tr := &Tree{Focus: "c", Root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		213	+	NewLeaf("a"),
		214	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("b"), NewLeaf("c")}},
		215	+	NewLeaf("d"),
		216	+	}}}
		217	+	require.NoError(t, tr.Close("c"))
		218	+	require.Equal(t, PaneID("b"), tr.Focus)
		219	+	}
		220	+
		221	+	func TestSolveRejectsStackWithMissingExpanded(t *testing.T) {
		222	+	t.Parallel()
		223	+	_, ok := Solve(&Node{Kind: Stack, Children: []*Node{NewLeaf("a"), NewLeaf("b")}, Expanded: "missing"}, domain.Rect{Width: 20, Height: 4})
		224	+	require.False(t, ok)
		225	+	}
		226	+
		227	+	func TestExportedLeafHelpers(t *testing.T) {
		228	+	t.Parallel()
		229	+	root := &Node{Kind: Split, Dir: Horizontal, Children: []*Node{NewLeaf("a"), NewLeaf("b")}}
		230	+	require.True(t, ContainsLeaf(root, "b"))
		231	+	require.False(t, ContainsLeaf(root, "c"))
		232	+	require.Equal(t, []PaneID{"a", "b"}, LeafIDs(root))
		233	+	}
		234	+
139	func TestFocusDir(t *testing.T) {	235		func TestFocusDir(t *testing.T) {
140	t.Parallel()	236		t.Parallel()
141	area := domain.Rect{Width: 62, Height: 5}	237		area := domain.Rect{Width: 62, Height: 5}

@@ -168,6 +264,7 @@ func TestFocusDir(t *testing.T) {
168	require.Equal(t, PaneID("c"), tr.Root.Expanded)	264		require.Equal(t, PaneID("c"), tr.Root.Expanded)
169	require.NoError(t, tr.FocusDir(Up, domain.Rect{Width: 20, Height: 4}))	265		require.NoError(t, tr.FocusDir(Up, domain.Rect{Width: 20, Height: 4}))
170	require.Equal(t, PaneID("b"), tr.Focus)	266		require.Equal(t, PaneID("b"), tr.Focus)
		267	+	require.Equal(t, PaneID("b"), tr.Root.Expanded)
171	})	268		})
172		269
173	t.Run("no pane in direction", func(t *testing.T) {	270		t.Run("no pane in direction", func(t *testing.T) {

@@ -177,6 +274,74 @@ func TestFocusDir(t *testing.T) {
177	})	274		})
178	}	275		}
179		276
		277	+	func TestFocusDirEnteringStackExpandsMember(t *testing.T) {
		278	+	t.Parallel()
		279	+	tests := []struct {
		280	+	name string
		281	+	root *Node
		282	+	area domain.Rect
		283	+	focus PaneID
		284	+	dir Direction
		285	+	want PaneID
		286	+	}{
		287	+	{
		288	+	name: "from left",
		289	+	area: domain.Rect{Width: 62, Height: 8},
		290	+	focus: "a",
		291	+	dir: Right,
		292	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		293	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("x"), NewLeaf("a")}},
		294	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c"), NewLeaf("d"), NewLeaf("e")}, Expanded: "b"},
		295	+	}},
		296	+	want: "c",
		297	+	},
		298	+	{
		299	+	name: "from right",
		300	+	area: domain.Rect{Width: 62, Height: 8},
		301	+	focus: "a",
		302	+	dir: Left,
		303	+	root: &Node{Kind: Split, Dir: Horizontal, Children: []*Node{
		304	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c"), NewLeaf("d"), NewLeaf("e")}, Expanded: "b"},
		305	+	{Kind: Split, Dir: Vertical, Children: []*Node{NewLeaf("x"), NewLeaf("a")}},
		306	+	}},
		307	+	want: "c",
		308	+	},
		309	+	{
		310	+	name: "from above",
		311	+	area: domain.Rect{Width: 41, Height: 7},
		312	+	focus: "a",
		313	+	dir: Down,
		314	+	root: &Node{Kind: Split, Dir: Vertical, Children: []*Node{
		315	+	NewLeaf("a"),
		316	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c")}, Expanded: "c"},
		317	+	}},
		318	+	want: "b",
		319	+	},
		320	+	{
		321	+	name: "from below",
		322	+	area: domain.Rect{Width: 41, Height: 7},
		323	+	focus: "a",
		324	+	dir: Up,
		325	+	root: &Node{Kind: Split, Dir: Vertical, Children: []*Node{
		326	+	{Kind: Stack, Children: []*Node{NewLeaf("b"), NewLeaf("c")}, Expanded: "b"},
		327	+	NewLeaf("a"),
		328	+	}},
		329	+	want: "c",
		330	+	},
		331	+	}
		332	+	for _, tt := range tests {
		333	+	t.Run(tt.name, func(t *testing.T) {
		334	+	tr := &Tree{Root: tt.root, Focus: tt.focus}
		335	+	var stack *Node
		336	+	findStack(tr.Root, &stack)
		337	+	require.NotEqual(t, tt.want, stack.Expanded)
		338	+	require.NoError(t, tr.FocusDir(tt.dir, tt.area))
		339	+	require.Equal(t, tt.want, tr.Focus)
		340	+	require.Equal(t, tt.want, stack.Expanded)
		341	+	})
		342	+	}
		343	+	}
		344	+
180	func contents(ps []Placement) map[PaneID]domain.Rect {	345		func contents(ps []Placement) map[PaneID]domain.Rect {
181	out := make(map[PaneID]domain.Rect, len(ps))	346		out := make(map[PaneID]domain.Rect, len(ps))
182	for _, p := range ps {	347		for _, p := range ps {

@@ -184,3 +349,16 @@ func contents(ps []Placement) map[PaneID]domain.Rect {
184	}	349		}
185	return out	350		return out
186	}	351		}
		352	+
		353	+	func findStack(n Node, out *Node) {
		354	+	if n == nil \|\| *out != nil {
		355	+	return
		356	+	}
		357	+	if n.Kind == Stack {
		358	+	*out = n
		359	+	return
		360	+	}
		361	+	for _, child := range n.Children {
		362	+	findStack(child, out)
		363	+	}
		364	+	}

M internal/usecase/layout/ops.go +132 -16


@@ -8,9 +8,10 @@ import (
8	8		)
9	9
10	10		var (
11		-	ErrNotFound = errors.New("pane not found")
12		-	ErrTooSmall = errors.New("layout too small")
13		-	ErrNoPane = errors.New("no pane in direction")
	11	+	ErrNotFound = errors.New("pane not found")
	12	+	ErrTooSmall = errors.New("layout too small")
	13	+	ErrNoPane = errors.New("no pane in direction")
	14	+	ErrNotToggleable = errors.New("layout node is not toggleable")
14	15		)
15	16
16	17		// Split adds newID next to target. The after flag controls whether the new pane

@@ -108,8 +109,12 @@ func stackNew(n *Node, target, newID PaneID) bool {
108	109		// a two-child split, it converts that split to a stack.
109	110		func (t *Tree) ToggleStack(target PaneID, area domain.Rect) error {
110	111		candidate := t.clone()
111		-	if !toggleStack(candidate.Root, target) {
	112	+	result := toggleStack(candidate.Root, target)
	113	+	switch result {
	114	+	case toggleNotFound:
112	115		return ErrNotFound
	116	+	case toggleNotToggleable:
	117	+	return ErrNotToggleable
113	118		}
114	119		if _, ok := Solve(candidate.Root, area); !ok {
115	120		return ErrTooSmall

@@ -118,24 +123,63 @@ func (t *Tree) ToggleStack(target PaneID, area domain.Rect) error {
118	123		return nil
119	124		}
120	125
121		-	func toggleStack(n *Node, target PaneID) bool {
122		-	if n.Kind == Stack && containsLeaf(n, target) {
	126	+	type toggleResult int
	127	+
	128	+	const (
	129	+	toggleNotFound toggleResult = iota
	130	+	toggleToggled
	131	+	toggleNotToggleable
	132	+	)
	133	+
	134	+	func toggleStack(n *Node, target PaneID) toggleResult {
	135	+	if n == nil {
	136	+	return toggleNotFound
	137	+	}
	138	+	for _, child := range n.Children {
	139	+	if child.Kind == Leaf \|\| !containsLeaf(child, target) {
	140	+	continue
	141	+	}
	142	+	result := toggleStack(child, target)
	143	+	if result != toggleNotFound {
	144	+	return result
	145	+	}
	146	+	}
	147	+	if !containsLeaf(n, target) {
	148	+	return toggleNotFound
	149	+	}
	150	+	if n.Kind == Stack {
	151	+	if stackDirectLeafIndex(n, target) < 0 {
	152	+	return toggleNotToggleable
	153	+	}
123	154		n.Kind = Split
124	155		n.Dir = Vertical
125	156		n.Expanded = ""
126		-	return true
	157	+	return toggleToggled
127	158		}
128		-	if n.Kind == Split && len(n.Children) == 2 && containsLeaf(n, target) {
	159	+	if n.Kind == Split && len(n.Children) == 2 && splitDirectLeavesContain(n, target) {
129	160		n.Kind = Stack
130	161		n.Expanded = target
131		-	return true
	162	+	return toggleToggled
132	163		}
	164	+	return toggleNotToggleable
	165	+	}
	166	+
	167	+	func stackDirectLeafIndex(n *Node, target PaneID) int {
	168	+	for i, child := range n.Children {
	169	+	if child.Kind == Leaf && child.Leaf == target {
	170	+	return i
	171	+	}
	172	+	}
	173	+	return -1
	174	+	}
	175	+
	176	+	func splitDirectLeavesContain(n *Node, target PaneID) bool {
133	177		for _, child := range n.Children {
134		-	if toggleStack(child, target) {
135		-	return true
	178	+	if child.Kind != Leaf {
	179	+	return false
136	180		}
137	181		}
138		-	return false
	182	+	return n.Children[0].Leaf == target \|\| n.Children[1].Leaf == target
139	183		}
140	184
141	185		// Close removes target and dissolves single-child containers.

@@ -148,18 +192,24 @@ func (t *Tree) Close(target PaneID) error {
148	192		t.Focus = ""
149	193		return nil
150	194		}
	195	+	refocus := closeRefocusCandidate(t.Root, target)
151	196		root, removed := closeNode(t.Root, target)
152	197		if !removed {
153	198		return ErrNotFound
154	199		}
155	200		t.Root = root
156	201		if t.Focus == target {
157		-	ids := leafIDs(t.Root)
158		-	if len(ids) > 0 {
159		-	t.Focus = ids[0]
	202	+	if refocus != "" && containsLeaf(t.Root, refocus) {
	203	+	t.Focus = refocus
160	204		} else {
161		-	t.Focus = ""
	205	+	ids := leafIDs(t.Root)
	206	+	if len(ids) > 0 {
	207	+	t.Focus = ids[0]
	208	+	} else {
	209	+	t.Focus = ""
	210	+	}
162	211		}
	212	+	setExpanded(t.Root, t.Focus)
163	213		}
164	214		return nil
165	215		}

@@ -198,6 +248,40 @@ func closeNode(n Node, target PaneID) (Node, bool) {
198	248		return n, true
199	249		}
200	250
	251	+	func closeRefocusCandidate(n *Node, target PaneID) PaneID {
	252	+	if n == nil \|\| n.Kind == Leaf {
	253	+	return ""
	254	+	}
	255	+	for i, child := range n.Children {
	256	+	if !containsLeaf(child, target) {
	257	+	continue
	258	+	}
	259	+	if child.Kind == Leaf && child.Leaf == target {
	260	+	if i > 0 {
	261	+	return lastLeaf(n.Children[i-1])
	262	+	}
	263	+	if i+1 < len(n.Children) {
	264	+	return firstLeaf(n.Children[i+1])
	265	+	}
	266	+	return ""
	267	+	}
	268	+	if id := closeRefocusCandidate(child, target); id != "" {
	269	+	return id
	270	+	}
	271	+	if i > 0 {
	272	+	return lastLeaf(n.Children[i-1])
	273	+	}
	274	+	if i+1 < len(n.Children) {
	275	+	return firstLeaf(n.Children[i+1])
	276	+	}
	277	+	return ""
	278	+	}
	279	+	return ""
	280	+	}
	281	+
	282	+	// ContainsLeaf reports whether n contains a leaf with id.
	283	+	func ContainsLeaf(n *Node, id PaneID) bool { return containsLeaf(n, id) }
	284	+
201	285		func containsLeaf(n *Node, id PaneID) bool {
202	286		if n == nil {
203	287		return false

@@ -225,6 +309,37 @@ func firstLeaf(n *Node) PaneID {
225	309		return ""
226	310		}
227	311
	312	+	func lastLeaf(n *Node) PaneID {
	313	+	if n.Kind == Leaf {
	314	+	return n.Leaf
	315	+	}
	316	+	for i := len(n.Children) - 1; i >= 0; i-- {
	317	+	if id := lastLeaf(n.Children[i]); id != "" {
	318	+	return id
	319	+	}
	320	+	}
	321	+	return ""
	322	+	}
	323	+
	324	+	func setExpanded(n *Node, id PaneID) bool {
	325	+	if n == nil {
	326	+	return false
	327	+	}
	328	+	if n.Kind == Stack && stackDirectLeafIndex(n, id) >= 0 {
	329	+	n.Expanded = id
	330	+	return true
	331	+	}
	332	+	for _, child := range n.Children {
	333	+	if setExpanded(child, id) {
	334	+	return true
	335	+	}
	336	+	}
	337	+	return false
	338	+	}
	339	+
	340	+	// LeafIDs returns the leaf ids under n in layout order.
	341	+	func LeafIDs(n *Node) []PaneID { return leafIDs(n) }
	342	+
228	343		func leafIDs(n *Node) []PaneID {
229	344		if n == nil {
230	345		return nil

@@ -291,6 +406,7 @@ func (t *Tree) FocusDir(dir Direction, area domain.Rect) error {
291	406		return candidates[i].id < candidates[j].id
292	407		})
293	408		t.Focus = candidates[0].id
	409	+	setExpanded(t.Root, t.Focus)
294	410		return nil
295	411		}
296	412


@@ -8,9 +8,10 @@ import (
8		)	8		)
9			9
10		var (	10		var (
11	-	ErrNotFound = errors.New("pane not found")	11	+	ErrNotFound = errors.New("pane not found")
12	-	ErrTooSmall = errors.New("layout too small")	12	+	ErrTooSmall = errors.New("layout too small")
13	-	ErrNoPane = errors.New("no pane in direction")	13	+	ErrNoPane = errors.New("no pane in direction")
			14	+	ErrNotToggleable = errors.New("layout node is not toggleable")
14		)	15		)
15			16
16		// Split adds newID next to target. The after flag controls whether the new pane	17		// Split adds newID next to target. The after flag controls whether the new pane

@@ -108,8 +109,12 @@ func stackNew(n *Node, target, newID PaneID) bool {
108		// a two-child split, it converts that split to a stack.	109		// a two-child split, it converts that split to a stack.
109		func (t *Tree) ToggleStack(target PaneID, area domain.Rect) error {	110		func (t *Tree) ToggleStack(target PaneID, area domain.Rect) error {
110		candidate := t.clone()	111		candidate := t.clone()
111	-	if !toggleStack(candidate.Root, target) {	112	+	result := toggleStack(candidate.Root, target)
			113	+	switch result {
			114	+	case toggleNotFound:
112		return ErrNotFound	115		return ErrNotFound
			116	+	case toggleNotToggleable:
			117	+	return ErrNotToggleable
113		}	118		}
114		if _, ok := Solve(candidate.Root, area); !ok {	119		if _, ok := Solve(candidate.Root, area); !ok {
115		return ErrTooSmall	120		return ErrTooSmall

@@ -118,24 +123,63 @@ func (t *Tree) ToggleStack(target PaneID, area domain.Rect) error {
118		return nil	123		return nil
119		}	124		}
120			125
121	-	func toggleStack(n *Node, target PaneID) bool {	126	+	type toggleResult int
122	-	if n.Kind == Stack && containsLeaf(n, target) {	127	+
			128	+	const (
			129	+	toggleNotFound toggleResult = iota
			130	+	toggleToggled
			131	+	toggleNotToggleable
			132	+	)
			133	+
			134	+	func toggleStack(n *Node, target PaneID) toggleResult {
			135	+	if n == nil {
			136	+	return toggleNotFound
			137	+	}
			138	+	for _, child := range n.Children {
			139	+	if child.Kind == Leaf \|\| !containsLeaf(child, target) {
			140	+	continue
			141	+	}
			142	+	result := toggleStack(child, target)
			143	+	if result != toggleNotFound {
			144	+	return result
			145	+	}
			146	+	}
			147	+	if !containsLeaf(n, target) {
			148	+	return toggleNotFound
			149	+	}
			150	+	if n.Kind == Stack {
			151	+	if stackDirectLeafIndex(n, target) < 0 {
			152	+	return toggleNotToggleable
			153	+	}
123		n.Kind = Split	154		n.Kind = Split
124		n.Dir = Vertical	155		n.Dir = Vertical
125		n.Expanded = ""	156		n.Expanded = ""
126	-	return true	157	+	return toggleToggled
127		}	158		}
128	-	if n.Kind == Split && len(n.Children) == 2 && containsLeaf(n, target) {	159	+	if n.Kind == Split && len(n.Children) == 2 && splitDirectLeavesContain(n, target) {
129		n.Kind = Stack	160		n.Kind = Stack
130		n.Expanded = target	161		n.Expanded = target
131	-	return true	162	+	return toggleToggled
132		}	163		}
			164	+	return toggleNotToggleable
			165	+	}
			166	+
			167	+	func stackDirectLeafIndex(n *Node, target PaneID) int {
			168	+	for i, child := range n.Children {
			169	+	if child.Kind == Leaf && child.Leaf == target {
			170	+	return i
			171	+	}
			172	+	}
			173	+	return -1
			174	+	}
			175	+
			176	+	func splitDirectLeavesContain(n *Node, target PaneID) bool {
133		for _, child := range n.Children {	177		for _, child := range n.Children {
134	-	if toggleStack(child, target) {	178	+	if child.Kind != Leaf {
135	-	return true	179	+	return false
136		}	180		}
137		}	181		}
138	-	return false	182	+	return n.Children[0].Leaf == target \|\| n.Children[1].Leaf == target
139		}	183		}
140			184
141		// Close removes target and dissolves single-child containers.	185		// Close removes target and dissolves single-child containers.

@@ -148,18 +192,24 @@ func (t *Tree) Close(target PaneID) error {
148		t.Focus = ""	192		t.Focus = ""
149		return nil	193		return nil
150		}	194		}
			195	+	refocus := closeRefocusCandidate(t.Root, target)
151		root, removed := closeNode(t.Root, target)	196		root, removed := closeNode(t.Root, target)
152		if !removed {	197		if !removed {
153		return ErrNotFound	198		return ErrNotFound
154		}	199		}
155		t.Root = root	200		t.Root = root
156		if t.Focus == target {	201		if t.Focus == target {
157	-	ids := leafIDs(t.Root)	202	+	if refocus != "" && containsLeaf(t.Root, refocus) {
158	-	if len(ids) > 0 {	203	+	t.Focus = refocus
159	-	t.Focus = ids[0]
160		} else {	204		} else {
161	-	t.Focus = ""	205	+	ids := leafIDs(t.Root)
			206	+	if len(ids) > 0 {
			207	+	t.Focus = ids[0]
			208	+	} else {
			209	+	t.Focus = ""
			210	+	}
162		}	211		}
			212	+	setExpanded(t.Root, t.Focus)
163		}	213		}
164		return nil	214		return nil
165		}	215		}

@@ -198,6 +248,40 @@ func closeNode(n Node, target PaneID) (Node, bool) {
198		return n, true	248		return n, true
199		}	249		}
200			250
			251	+	func closeRefocusCandidate(n *Node, target PaneID) PaneID {
			252	+	if n == nil \|\| n.Kind == Leaf {
			253	+	return ""
			254	+	}
			255	+	for i, child := range n.Children {
			256	+	if !containsLeaf(child, target) {
			257	+	continue
			258	+	}
			259	+	if child.Kind == Leaf && child.Leaf == target {
			260	+	if i > 0 {
			261	+	return lastLeaf(n.Children[i-1])
			262	+	}
			263	+	if i+1 < len(n.Children) {
			264	+	return firstLeaf(n.Children[i+1])
			265	+	}
			266	+	return ""
			267	+	}
			268	+	if id := closeRefocusCandidate(child, target); id != "" {
			269	+	return id
			270	+	}
			271	+	if i > 0 {
			272	+	return lastLeaf(n.Children[i-1])
			273	+	}
			274	+	if i+1 < len(n.Children) {
			275	+	return firstLeaf(n.Children[i+1])
			276	+	}
			277	+	return ""
			278	+	}
			279	+	return ""
			280	+	}
			281	+
			282	+	// ContainsLeaf reports whether n contains a leaf with id.
			283	+	func ContainsLeaf(n *Node, id PaneID) bool { return containsLeaf(n, id) }
			284	+
201		func containsLeaf(n *Node, id PaneID) bool {	285		func containsLeaf(n *Node, id PaneID) bool {
202		if n == nil {	286		if n == nil {
203		return false	287		return false

@@ -225,6 +309,37 @@ func firstLeaf(n *Node) PaneID {
225		return ""	309		return ""
226		}	310		}
227			311
			312	+	func lastLeaf(n *Node) PaneID {
			313	+	if n.Kind == Leaf {
			314	+	return n.Leaf
			315	+	}
			316	+	for i := len(n.Children) - 1; i >= 0; i-- {
			317	+	if id := lastLeaf(n.Children[i]); id != "" {
			318	+	return id
			319	+	}
			320	+	}
			321	+	return ""
			322	+	}
			323	+
			324	+	func setExpanded(n *Node, id PaneID) bool {
			325	+	if n == nil {
			326	+	return false
			327	+	}
			328	+	if n.Kind == Stack && stackDirectLeafIndex(n, id) >= 0 {
			329	+	n.Expanded = id
			330	+	return true
			331	+	}
			332	+	for _, child := range n.Children {
			333	+	if setExpanded(child, id) {
			334	+	return true
			335	+	}
			336	+	}
			337	+	return false
			338	+	}
			339	+
			340	+	// LeafIDs returns the leaf ids under n in layout order.
			341	+	func LeafIDs(n *Node) []PaneID { return leafIDs(n) }
			342	+
228		func leafIDs(n *Node) []PaneID {	343		func leafIDs(n *Node) []PaneID {
229		if n == nil {	344		if n == nil {
230		return nil	345		return nil

@@ -291,6 +406,7 @@ func (t *Tree) FocusDir(dir Direction, area domain.Rect) error {
291		return candidates[i].id < candidates[j].id	406		return candidates[i].id < candidates[j].id
292		})	407		})
293		t.Focus = candidates[0].id	408		t.Focus = candidates[0].id
			409	+	setExpanded(t.Root, t.Focus)
294		return nil	410		return nil
295		}	411		}
296			412

M internal/usecase/theme/theme.go +32 -0


@@ -258,15 +258,47 @@ func DimStyle(style renderer.Style, t Theme) renderer.Style {
258	258		out.HasForegroundRGB = true
259	259		if style.HasForegroundRGB {
260	260		out.ForegroundRGB = Blend(style.ForegroundRGB, t.Background, 0.35)
	261	+	} else if style.Foreground >= 0 {
	262	+	out.ForegroundRGB = Blend(xterm256Color(style.Foreground), t.Background, 0.35)
261	263		} else {
262	264		out.ForegroundRGB = Blend(t.Foreground, t.Background, 0.35)
263	265		}
	266	+	out.HasBackgroundRGB = true
264	267		if style.HasBackgroundRGB {
265	268		out.BackgroundRGB = Blend(style.BackgroundRGB, t.Background, 0.35)
	269	+	} else if style.Background >= 0 {
	270	+	out.BackgroundRGB = Blend(xterm256Color(style.Background), t.Background, 0.35)
	271	+	} else {
	272	+	out.BackgroundRGB = Blend(t.Background, t.Background, 0.35)
266	273		}
267	274		return out
268	275		}
269	276
	277	+	func xterm256Color(index int) renderer.RGB {
	278	+	if index < 0 {
	279	+	return renderer.RGB{}
	280	+	}
	281	+	base := [...]renderer.RGB{
	282	+	{R: 0x00, G: 0x00, B: 0x00}, {R: 0x80, G: 0x00, B: 0x00}, {R: 0x00, G: 0x80, B: 0x00}, {R: 0x80, G: 0x80, B: 0x00},
	283	+	{R: 0x00, G: 0x00, B: 0x80}, {R: 0x80, G: 0x00, B: 0x80}, {R: 0x00, G: 0x80, B: 0x80}, {R: 0xc0, G: 0xc0, B: 0xc0},
	284	+	{R: 0x80, G: 0x80, B: 0x80}, {R: 0xff, G: 0x00, B: 0x00}, {R: 0x00, G: 0xff, B: 0x00}, {R: 0xff, G: 0xff, B: 0x00},
	285	+	{R: 0x00, G: 0x00, B: 0xff}, {R: 0xff, G: 0x00, B: 0xff}, {R: 0x00, G: 0xff, B: 0xff}, {R: 0xff, G: 0xff, B: 0xff},
	286	+	}
	287	+	if index < len(base) {
	288	+	return base[index]
	289	+	}
	290	+	if index < 232 {
	291	+	index -= 16
	292	+	levels := [...]uint8{0, 95, 135, 175, 215, 255}
	293	+	return renderer.RGB{R: levels[index/36], G: levels[(index/6)%6], B: levels[index%6]}
	294	+	}
	295	+	if index < 256 {
	296	+	level := uint8(8 + (index-232)*10)
	297	+	return renderer.RGB{R: level, G: level, B: level}
	298	+	}
	299	+	return base[index%len(base)]
	300	+	}
	301	+
270	302		func SelectionStyle(t Theme) renderer.Style {
271	303		if !usable(t) {
272	304		return inverseStyle()


@@ -258,15 +258,47 @@ func DimStyle(style renderer.Style, t Theme) renderer.Style {
258	out.HasForegroundRGB = true	258		out.HasForegroundRGB = true
259	if style.HasForegroundRGB {	259		if style.HasForegroundRGB {
260	out.ForegroundRGB = Blend(style.ForegroundRGB, t.Background, 0.35)	260		out.ForegroundRGB = Blend(style.ForegroundRGB, t.Background, 0.35)
		261	+	} else if style.Foreground >= 0 {
		262	+	out.ForegroundRGB = Blend(xterm256Color(style.Foreground), t.Background, 0.35)
261	} else {	263		} else {
262	out.ForegroundRGB = Blend(t.Foreground, t.Background, 0.35)	264		out.ForegroundRGB = Blend(t.Foreground, t.Background, 0.35)
263	}	265		}
		266	+	out.HasBackgroundRGB = true
264	if style.HasBackgroundRGB {	267		if style.HasBackgroundRGB {
265	out.BackgroundRGB = Blend(style.BackgroundRGB, t.Background, 0.35)	268		out.BackgroundRGB = Blend(style.BackgroundRGB, t.Background, 0.35)
		269	+	} else if style.Background >= 0 {
		270	+	out.BackgroundRGB = Blend(xterm256Color(style.Background), t.Background, 0.35)
		271	+	} else {
		272	+	out.BackgroundRGB = Blend(t.Background, t.Background, 0.35)
266	}	273		}
267	return out	274		return out
268	}	275		}
269		276
		277	+	func xterm256Color(index int) renderer.RGB {
		278	+	if index < 0 {
		279	+	return renderer.RGB{}
		280	+	}
		281	+	base := [...]renderer.RGB{
		282	+	{R: 0x00, G: 0x00, B: 0x00}, {R: 0x80, G: 0x00, B: 0x00}, {R: 0x00, G: 0x80, B: 0x00}, {R: 0x80, G: 0x80, B: 0x00},
		283	+	{R: 0x00, G: 0x00, B: 0x80}, {R: 0x80, G: 0x00, B: 0x80}, {R: 0x00, G: 0x80, B: 0x80}, {R: 0xc0, G: 0xc0, B: 0xc0},
		284	+	{R: 0x80, G: 0x80, B: 0x80}, {R: 0xff, G: 0x00, B: 0x00}, {R: 0x00, G: 0xff, B: 0x00}, {R: 0xff, G: 0xff, B: 0x00},
		285	+	{R: 0x00, G: 0x00, B: 0xff}, {R: 0xff, G: 0x00, B: 0xff}, {R: 0x00, G: 0xff, B: 0xff}, {R: 0xff, G: 0xff, B: 0xff},
		286	+	}
		287	+	if index < len(base) {
		288	+	return base[index]
		289	+	}
		290	+	if index < 232 {
		291	+	index -= 16
		292	+	levels := [...]uint8{0, 95, 135, 175, 215, 255}
		293	+	return renderer.RGB{R: levels[index/36], G: levels[(index/6)%6], B: levels[index%6]}
		294	+	}
		295	+	if index < 256 {
		296	+	level := uint8(8 + (index-232)*10)
		297	+	return renderer.RGB{R: level, G: level, B: level}
		298	+	}
		299	+	return base[index%len(base)]
		300	+	}
		301	+
270	func SelectionStyle(t Theme) renderer.Style {	302		func SelectionStyle(t Theme) renderer.Style {
271	if !usable(t) {	303		if !usable(t) {
272	return inverseStyle()	304		return inverseStyle()

M internal/usecase/theme/theme_test.go +86 -0


@@ -197,6 +197,92 @@ func TestScannerFlushesOverflowingPartialQueue(t *testing.T) {
197	197		}
198	198		}
199	199
	200	+	func TestDimStyle(t *testing.T) {
	201	+	theme := Theme{Foreground: renderer.RGB{R: 200, G: 200, B: 200}, Background: renderer.RGB{R: 10, G: 20, B: 30}, HasFG: true, HasBG: true, Known: true, TrueColor: true}
	202	+	tests := []struct {
	203	+	name string
	204	+	in renderer.Style
	205	+	want renderer.Style
	206	+	}{
	207	+	{
	208	+	name: "default foreground and background dim to theme colors",
	209	+	in: renderer.DefaultStyle(),
	210	+	want: renderer.Style{
	211	+	Foreground: -1,
	212	+	Background: -1,
	213	+	HasForegroundRGB: true,
	214	+	ForegroundRGB: Blend(theme.Foreground, theme.Background, 0.35),
	215	+	HasBackgroundRGB: true,
	216	+	BackgroundRGB: theme.Background,
	217	+	},
	218	+	},
	219	+	{
	220	+	name: "indexed foreground is mapped before dimming",
	221	+	in: renderer.Style{Foreground: 196, Background: -1},
	222	+	want: renderer.Style{
	223	+	Foreground: 196,
	224	+	Background: -1,
	225	+	HasForegroundRGB: true,
	226	+	ForegroundRGB: Blend(renderer.RGB{R: 255, G: 0, B: 0}, theme.Background, 0.35),
	227	+	HasBackgroundRGB: true,
	228	+	BackgroundRGB: theme.Background,
	229	+	},
	230	+	},
	231	+	{
	232	+	name: "indexed foregrounds remain distinct",
	233	+	in: renderer.Style{Foreground: 46, Background: -1},
	234	+	want: renderer.Style{
	235	+	Foreground: 46,
	236	+	Background: -1,
	237	+	HasForegroundRGB: true,
	238	+	ForegroundRGB: Blend(renderer.RGB{R: 0, G: 255, B: 0}, theme.Background, 0.35),
	239	+	HasBackgroundRGB: true,
	240	+	BackgroundRGB: theme.Background,
	241	+	},
	242	+	},
	243	+	{
	244	+	name: "indexed background is mapped before dimming",
	245	+	in: renderer.Style{Foreground: -1, Background: 21},
	246	+	want: renderer.Style{
	247	+	Foreground: -1,
	248	+	Background: 21,
	249	+	HasForegroundRGB: true,
	250	+	ForegroundRGB: Blend(theme.Foreground, theme.Background, 0.35),
	251	+	HasBackgroundRGB: true,
	252	+	BackgroundRGB: Blend(renderer.RGB{R: 0, G: 0, B: 255}, theme.Background, 0.35),
	253	+	},
	254	+	},
	255	+	{
	256	+	name: "rgb foreground and background are dimmed",
	257	+	in: renderer.Style{
	258	+	Foreground: -1,
	259	+	Background: -1,
	260	+	HasForegroundRGB: true,
	261	+	ForegroundRGB: renderer.RGB{R: 100, G: 50, B: 25},
	262	+	HasBackgroundRGB: true,
	263	+	BackgroundRGB: renderer.RGB{R: 20, G: 100, B: 180},
	264	+	},
	265	+	want: renderer.Style{
	266	+	Foreground: -1,
	267	+	Background: -1,
	268	+	HasForegroundRGB: true,
	269	+	ForegroundRGB: Blend(renderer.RGB{R: 100, G: 50, B: 25}, theme.Background, 0.35),
	270	+	HasBackgroundRGB: true,
	271	+	BackgroundRGB: Blend(renderer.RGB{R: 20, G: 100, B: 180}, theme.Background, 0.35),
	272	+	},
	273	+	},
	274	+	}
	275	+
	276	+	for _, tt := range tests {
	277	+	t.Run(tt.name, func(t *testing.T) {
	278	+	got := DimStyle(tt.in, theme)
	279	+	if !got.Equal(tt.want) {
	280	+	t.Fatalf("DimStyle()=%+v want %+v", got, tt.want)
	281	+	}
	282	+	})
	283	+	}
	284	+	}
	285	+
200	286		func TestStyleHelpersFallbackAndThemed(t *testing.T) {
201	287		unknown := Theme{}
202	288		if got := StatusBarStyle(unknown); !got.Equal(renderer.DefaultStyle()) {


@@ -197,6 +197,92 @@ func TestScannerFlushesOverflowingPartialQueue(t *testing.T) {
197	}	197		}
198	}	198		}
199		199
		200	+	func TestDimStyle(t *testing.T) {
		201	+	theme := Theme{Foreground: renderer.RGB{R: 200, G: 200, B: 200}, Background: renderer.RGB{R: 10, G: 20, B: 30}, HasFG: true, HasBG: true, Known: true, TrueColor: true}
		202	+	tests := []struct {
		203	+	name string
		204	+	in renderer.Style
		205	+	want renderer.Style
		206	+	}{
		207	+	{
		208	+	name: "default foreground and background dim to theme colors",
		209	+	in: renderer.DefaultStyle(),
		210	+	want: renderer.Style{
		211	+	Foreground: -1,
		212	+	Background: -1,
		213	+	HasForegroundRGB: true,
		214	+	ForegroundRGB: Blend(theme.Foreground, theme.Background, 0.35),
		215	+	HasBackgroundRGB: true,
		216	+	BackgroundRGB: theme.Background,
		217	+	},
		218	+	},
		219	+	{
		220	+	name: "indexed foreground is mapped before dimming",
		221	+	in: renderer.Style{Foreground: 196, Background: -1},
		222	+	want: renderer.Style{
		223	+	Foreground: 196,
		224	+	Background: -1,
		225	+	HasForegroundRGB: true,
		226	+	ForegroundRGB: Blend(renderer.RGB{R: 255, G: 0, B: 0}, theme.Background, 0.35),
		227	+	HasBackgroundRGB: true,
		228	+	BackgroundRGB: theme.Background,
		229	+	},
		230	+	},
		231	+	{
		232	+	name: "indexed foregrounds remain distinct",
		233	+	in: renderer.Style{Foreground: 46, Background: -1},
		234	+	want: renderer.Style{
		235	+	Foreground: 46,
		236	+	Background: -1,
		237	+	HasForegroundRGB: true,
		238	+	ForegroundRGB: Blend(renderer.RGB{R: 0, G: 255, B: 0}, theme.Background, 0.35),
		239	+	HasBackgroundRGB: true,
		240	+	BackgroundRGB: theme.Background,
		241	+	},
		242	+	},
		243	+	{
		244	+	name: "indexed background is mapped before dimming",
		245	+	in: renderer.Style{Foreground: -1, Background: 21},
		246	+	want: renderer.Style{
		247	+	Foreground: -1,
		248	+	Background: 21,
		249	+	HasForegroundRGB: true,
		250	+	ForegroundRGB: Blend(theme.Foreground, theme.Background, 0.35),
		251	+	HasBackgroundRGB: true,
		252	+	BackgroundRGB: Blend(renderer.RGB{R: 0, G: 0, B: 255}, theme.Background, 0.35),
		253	+	},
		254	+	},
		255	+	{
		256	+	name: "rgb foreground and background are dimmed",
		257	+	in: renderer.Style{
		258	+	Foreground: -1,
		259	+	Background: -1,
		260	+	HasForegroundRGB: true,
		261	+	ForegroundRGB: renderer.RGB{R: 100, G: 50, B: 25},
		262	+	HasBackgroundRGB: true,
		263	+	BackgroundRGB: renderer.RGB{R: 20, G: 100, B: 180},
		264	+	},
		265	+	want: renderer.Style{
		266	+	Foreground: -1,
		267	+	Background: -1,
		268	+	HasForegroundRGB: true,
		269	+	ForegroundRGB: Blend(renderer.RGB{R: 100, G: 50, B: 25}, theme.Background, 0.35),
		270	+	HasBackgroundRGB: true,
		271	+	BackgroundRGB: Blend(renderer.RGB{R: 20, G: 100, B: 180}, theme.Background, 0.35),
		272	+	},
		273	+	},
		274	+	}
		275	+
		276	+	for _, tt := range tests {
		277	+	t.Run(tt.name, func(t *testing.T) {
		278	+	got := DimStyle(tt.in, theme)
		279	+	if !got.Equal(tt.want) {
		280	+	t.Fatalf("DimStyle()=%+v want %+v", got, tt.want)
		281	+	}
		282	+	})
		283	+	}
		284	+	}
		285	+
200	func TestStyleHelpersFallbackAndThemed(t *testing.T) {	286		func TestStyleHelpersFallbackAndThemed(t *testing.T) {
201	unknown := Theme{}	287		unknown := Theme{}
202	if got := StatusBarStyle(unknown); !got.Equal(renderer.DefaultStyle()) {	288		if got := StatusBarStyle(unknown); !got.Equal(renderer.DefaultStyle()) {

M pkg/renderer/renderer.go +19 -3


@@ -36,11 +36,18 @@ func (r *Renderer) Draw(frame Frame, damage []Damage) ([]byte, error) {
36	36		return nil, err
37	37		}
38	38
39		-	// Unchanged frame no-op: same dimensions, shadow populated, no damage, no dirty lines.
40		-	if r.width == frame.Width && r.height == frame.Height && len(r.shadow) == len(frame.Cells) {
	39	+	knownSameDimensions := r.width == frame.Width && r.height == frame.Height && len(r.shadow) == len(frame.Cells)
	40	+
	41	+	// Unchanged frame no-op: same dimensions, shadow populated, and either no
	42	+	// damage or a structural redraw request that can be satisfied from the
	43	+	// known terminal shadow.
	44	+	if knownSameDimensions {
41	45		if len(damage) == 0 && !r.hasDirtyLines(frame) {
42	46		return nil, nil
43	47		}
	48	+	if needsFull(damage) && !r.hasDirtyLines(frame) {
	49	+	return nil, nil
	50	+	}
44	51		}
45	52
46	53		buf := bufferPool.Get().(*bytes.Buffer)

@@ -55,7 +62,7 @@ func (r *Renderer) Draw(frame Frame, damage []Damage) ([]byte, error) {
55	62		// tracking and the SGR pen persist across all rects within one Draw.
56	63		st := newDrawState()
57	64
58		-	if r.width != frame.Width \|\| r.height != frame.Height \|\| len(r.shadow) != len(frame.Cells) \|\| needsFull(damage) {
	65	+	if !knownSameDimensions {
59	66		r.writeFull(buf, frame, &st)
60	67		r.replaceShadow(frame)
61	68		if r.caps.SynchronizedOutput {

@@ -64,6 +71,15 @@ func (r *Renderer) Draw(frame Frame, damage []Damage) ([]byte, error) {
64	71		return copyBytes(buf), nil
65	72		}
66	73
	74	+	if needsFull(damage) {
	75	+	r.writeDamage(buf, frame, nil, nil, &st)
	76	+	r.replaceShadow(frame)
	77	+	if r.caps.SynchronizedOutput {
	78	+	buf.WriteString(SyncEndCSI)
	79	+	}
	80	+	return copyBytes(buf), nil
	81	+	}
	82	+
67	83		if scroll, ok := findSafeScroll(frame, damage); ok && r.canApplyScroll(frame, scroll, damage) {
68	84		emitScrollUp(buf, scroll)
69	85		// emitScrollUp resets the SGR pen to default (matching st's initial


@@ -36,11 +36,18 @@ func (r *Renderer) Draw(frame Frame, damage []Damage) ([]byte, error) {
36		return nil, err	36		return nil, err
37		}	37		}
38			38
39	-	// Unchanged frame no-op: same dimensions, shadow populated, no damage, no dirty lines.	39	+	knownSameDimensions := r.width == frame.Width && r.height == frame.Height && len(r.shadow) == len(frame.Cells)
40	-	if r.width == frame.Width && r.height == frame.Height && len(r.shadow) == len(frame.Cells) {	40	+
			41	+	// Unchanged frame no-op: same dimensions, shadow populated, and either no
			42	+	// damage or a structural redraw request that can be satisfied from the
			43	+	// known terminal shadow.
			44	+	if knownSameDimensions {
41		if len(damage) == 0 && !r.hasDirtyLines(frame) {	45		if len(damage) == 0 && !r.hasDirtyLines(frame) {
42		return nil, nil	46		return nil, nil
43		}	47		}
			48	+	if needsFull(damage) && !r.hasDirtyLines(frame) {
			49	+	return nil, nil
			50	+	}
44		}	51		}
45			52
46		buf := bufferPool.Get().(*bytes.Buffer)	53		buf := bufferPool.Get().(*bytes.Buffer)

@@ -55,7 +62,7 @@ func (r *Renderer) Draw(frame Frame, damage []Damage) ([]byte, error) {
55		// tracking and the SGR pen persist across all rects within one Draw.	62		// tracking and the SGR pen persist across all rects within one Draw.
56		st := newDrawState()	63		st := newDrawState()
57			64
58	-	if r.width != frame.Width \|\| r.height != frame.Height \|\| len(r.shadow) != len(frame.Cells) \|\| needsFull(damage) {	65	+	if !knownSameDimensions {
59		r.writeFull(buf, frame, &st)	66		r.writeFull(buf, frame, &st)
60		r.replaceShadow(frame)	67		r.replaceShadow(frame)
61		if r.caps.SynchronizedOutput {	68		if r.caps.SynchronizedOutput {

@@ -64,6 +71,15 @@ func (r *Renderer) Draw(frame Frame, damage []Damage) ([]byte, error) {
64		return copyBytes(buf), nil	71		return copyBytes(buf), nil
65		}	72		}
66			73
			74	+	if needsFull(damage) {
			75	+	r.writeDamage(buf, frame, nil, nil, &st)
			76	+	r.replaceShadow(frame)
			77	+	if r.caps.SynchronizedOutput {
			78	+	buf.WriteString(SyncEndCSI)
			79	+	}
			80	+	return copyBytes(buf), nil
			81	+	}
			82	+
67		if scroll, ok := findSafeScroll(frame, damage); ok && r.canApplyScroll(frame, scroll, damage) {	83		if scroll, ok := findSafeScroll(frame, damage); ok && r.canApplyScroll(frame, scroll, damage) {
68		emitScrollUp(buf, scroll)	84		emitScrollUp(buf, scroll)
69		// emitScrollUp resets the SGR pen to default (matching st's initial	85		// emitScrollUp resets the SGR pen to default (matching st's initial

M pkg/renderer/renderer_test.go +71 -22


@@ -552,32 +552,81 @@ func TestReset(t *testing.T) {
552	552		func TestFullRedraw(t *testing.T) {
553	553		tests := []struct {
554	554		name string
	555	+	run func(t *testing.T)
555	556		}{
556		-	{name: "forces full output even with an unchanged frame"},
557		-	}
	557	+	{
	558	+	name: "known same-size full redraw diffs against shadow",
	559	+	run: func(t *testing.T) {
	560	+	r := New(Capabilities{})
	561	+	frame := NewFrame(3, 2)
	562	+	markFrame(&frame)
558	563
559		-	for _, tt := range tests {
560		-	t.Run(tt.name, func(t *testing.T) {
561		-	r := New(Capabilities{})
562		-	frame := NewFrame(3, 2)
563		-	markFrame(&frame)
	564	+	if _, err := r.Draw(frame, []Damage{FullRedraw()}); err != nil {
	565	+	t.Fatal(err)
	566	+	}
564	567
565		-	// Populate.
566		-	_, err := r.Draw(frame, []Damage{{Kind: DamageText, X: 0, Y: 0, Width: 3, Height: 2}})
567		-	if err != nil {
568		-	t.Fatal(err)
569		-	}
	568	+	changed := frame
	569	+	changed.Set(0, 1, Cell{Rune: 'Z', Style: DefaultStyle()})
	570	+	out, err := r.Draw(changed, []Damage{FullRedraw()})
	571	+	if err != nil {
	572	+	t.Fatal(err)
	573	+	}
	574	+	got := string(out)
	575	+	if strings.Contains(got, "ABC") {
	576	+	t.Fatalf("unchanged row was re-emitted on dimension-stable FullRedraw: %q", got)
	577	+	}
	578	+	if !strings.Contains(got, "ZEF") {
	579	+	t.Fatalf("changed row was not emitted on dimension-stable FullRedraw: %q", got)
	580	+	}
	581	+	outputEndsWith(t, out, "\x1b[0m")
	582	+	},
	583	+	},
	584	+	{
	585	+	name: "unchanged known same-size full redraw is a no-op",
	586	+	run: func(t *testing.T) {
	587	+	r := New(Capabilities{})
	588	+	frame := NewFrame(3, 2)
	589	+	markFrame(&frame)
570	590
571		-	// FullRedraw forces full output even with same frame.
572		-	out, err := r.Draw(frame, []Damage{FullRedraw()})
573		-	if err != nil {
574		-	t.Fatal(err)
575		-	}
576		-	if len(out) == 0 {
577		-	t.Fatal("expected output for FullRedraw")
578		-	}
579		-	outputEndsWith(t, out, "\x1b[0m")
580		-	})
	591	+	if _, err := r.Draw(frame, []Damage{FullRedraw()}); err != nil {
	592	+	t.Fatal(err)
	593	+	}
	594	+	out, err := r.Draw(frame, []Damage{FullRedraw()})
	595	+	if err != nil {
	596	+	t.Fatal(err)
	597	+	}
	598	+	if len(out) != 0 {
	599	+	t.Fatalf("unchanged dimension-stable FullRedraw emitted output: %q", string(out))
	600	+	}
	601	+	},
	602	+	},
	603	+	{
	604	+	name: "reset full redraw emits complete frame",
	605	+	run: func(t *testing.T) {
	606	+	r := New(Capabilities{})
	607	+	frame := NewFrame(3, 2)
	608	+	markFrame(&frame)
	609	+
	610	+	if _, err := r.Draw(frame, []Damage{FullRedraw()}); err != nil {
	611	+	t.Fatal(err)
	612	+	}
	613	+	r.Reset()
	614	+
	615	+	out, err := r.Draw(frame, []Damage{FullRedraw()})
	616	+	if err != nil {
	617	+	t.Fatal(err)
	618	+	}
	619	+	got := string(out)
	620	+	if !strings.Contains(got, "ABC") \|\| !strings.Contains(got, "DEF") {
	621	+	t.Fatalf("reset FullRedraw did not emit complete frame: %q", got)
	622	+	}
	623	+	outputEndsWith(t, out, "\x1b[0m")
	624	+	},
	625	+	},
	626	+	}
	627	+
	628	+	for _, tt := range tests {
	629	+	t.Run(tt.name, tt.run)
581	630		}
582	631		}
583	632


@@ -552,32 +552,81 @@ func TestReset(t *testing.T) {
552		func TestFullRedraw(t *testing.T) {	552		func TestFullRedraw(t *testing.T) {
553		tests := []struct {	553		tests := []struct {
554		name string	554		name string
			555	+	run func(t *testing.T)
555		}{	556		}{
556	-	{name: "forces full output even with an unchanged frame"},	557	+	{
557	-	}	558	+	name: "known same-size full redraw diffs against shadow",
			559	+	run: func(t *testing.T) {
			560	+	r := New(Capabilities{})
			561	+	frame := NewFrame(3, 2)
			562	+	markFrame(&frame)
558			563
559	-	for _, tt := range tests {	564	+	if _, err := r.Draw(frame, []Damage{FullRedraw()}); err != nil {
560	-	t.Run(tt.name, func(t *testing.T) {	565	+	t.Fatal(err)
561	-	r := New(Capabilities{})	566	+	}
562	-	frame := NewFrame(3, 2)
563	-	markFrame(&frame)
564			567
565	-	// Populate.	568	+	changed := frame
566	-	_, err := r.Draw(frame, []Damage{{Kind: DamageText, X: 0, Y: 0, Width: 3, Height: 2}})	569	+	changed.Set(0, 1, Cell{Rune: 'Z', Style: DefaultStyle()})
567	-	if err != nil {	570	+	out, err := r.Draw(changed, []Damage{FullRedraw()})
568	-	t.Fatal(err)	571	+	if err != nil {
569	-	}	572	+	t.Fatal(err)
			573	+	}
			574	+	got := string(out)
			575	+	if strings.Contains(got, "ABC") {
			576	+	t.Fatalf("unchanged row was re-emitted on dimension-stable FullRedraw: %q", got)
			577	+	}
			578	+	if !strings.Contains(got, "ZEF") {
			579	+	t.Fatalf("changed row was not emitted on dimension-stable FullRedraw: %q", got)
			580	+	}
			581	+	outputEndsWith(t, out, "\x1b[0m")
			582	+	},
			583	+	},
			584	+	{
			585	+	name: "unchanged known same-size full redraw is a no-op",
			586	+	run: func(t *testing.T) {
			587	+	r := New(Capabilities{})
			588	+	frame := NewFrame(3, 2)
			589	+	markFrame(&frame)
570			590
571	-	// FullRedraw forces full output even with same frame.	591	+	if _, err := r.Draw(frame, []Damage{FullRedraw()}); err != nil {
572	-	out, err := r.Draw(frame, []Damage{FullRedraw()})	592	+	t.Fatal(err)
573	-	if err != nil {	593	+	}
574	-	t.Fatal(err)	594	+	out, err := r.Draw(frame, []Damage{FullRedraw()})
575	-	}	595	+	if err != nil {
576	-	if len(out) == 0 {	596	+	t.Fatal(err)
577	-	t.Fatal("expected output for FullRedraw")	597	+	}
578	-	}	598	+	if len(out) != 0 {
579	-	outputEndsWith(t, out, "\x1b[0m")	599	+	t.Fatalf("unchanged dimension-stable FullRedraw emitted output: %q", string(out))
580	-	})	600	+	}
			601	+	},
			602	+	},
			603	+	{
			604	+	name: "reset full redraw emits complete frame",
			605	+	run: func(t *testing.T) {
			606	+	r := New(Capabilities{})
			607	+	frame := NewFrame(3, 2)
			608	+	markFrame(&frame)
			609	+
			610	+	if _, err := r.Draw(frame, []Damage{FullRedraw()}); err != nil {
			611	+	t.Fatal(err)
			612	+	}
			613	+	r.Reset()
			614	+
			615	+	out, err := r.Draw(frame, []Damage{FullRedraw()})
			616	+	if err != nil {
			617	+	t.Fatal(err)
			618	+	}
			619	+	got := string(out)
			620	+	if !strings.Contains(got, "ABC") \|\| !strings.Contains(got, "DEF") {
			621	+	t.Fatalf("reset FullRedraw did not emit complete frame: %q", got)
			622	+	}
			623	+	outputEndsWith(t, out, "\x1b[0m")
			624	+	},
			625	+	},
			626	+	}
			627	+
			628	+	for _, tt := range tests {
			629	+	t.Run(tt.name, tt.run)
581		}	630		}
582		}	631		}
583			632