356dacb fix(outputs): keyboard screen focus sticks, terminal respawn backoff, stale terminal tokens expire · neferwl

M internal/core/action.go +1 -1


@@ -126,7 +126,7 @@ func (c *Core) applyAction(a Action) Effect {
126	126		if i := c.neighbor(dir); edge && i >= 0 {
127	127		// The last column stays: a workspace on screen is never
128	128		// empty, and moving it would only spawn a new terminal.
129		-	if len(w.Columns) < 2 {
	129	+	if len(w.Columns) < 2 && c.keepsTerminal() {
130	130		return Effect{}
131	131		}
132	132		col, ok := w.takeColumn()


@@ -126,7 +126,7 @@ func (c *Core) applyAction(a Action) Effect {
126		if i := c.neighbor(dir); edge && i >= 0 {	126		if i := c.neighbor(dir); edge && i >= 0 {
127		// The last column stays: a workspace on screen is never	127		// The last column stays: a workspace on screen is never
128		// empty, and moving it would only spawn a new terminal.	128		// empty, and moving it would only spawn a new terminal.
129	-	if len(w.Columns) < 2 {	129	+	if len(w.Columns) < 2 && c.keepsTerminal() {
130		return Effect{}	130		return Effect{}
131		}	131		}
132		col, ok := w.takeColumn()	132		col, ok := w.takeColumn()

M internal/core/core.go +10 -4


@@ -49,6 +49,7 @@ type Core struct {
49	49		grab WindowID
50	50		buttons map[uint32]bool
51	51		cursorX, cursorY float64 // global, logical
	52	+	pointerOutput string // output under the pointer at the last motion
52	53		seq uint64
53	54		// layerChanged is set once layer state arrives from wayland.
54	55		layerChanged bool

@@ -549,10 +550,15 @@ func (c *Core) Run(ctx context.Context) error {
549	550		c.cursorX, c.cursorY = c.layout().Clamp(c.cursorX, c.cursorY, v.X, v.Y)
550	551		// The focused screen follows the pointer, so new windows
551	552		// and launchers open where the user is.
552		-	if o, ok := c.layout().At(c.cursorX, c.cursorY); ok && o.Info.Name != c.cur().name() {
553		-	c.focusScreen = c.screenIndex(o.Info.Name)
554		-	if err := c.publish(ctx); err != nil {
555		-	return nil
	553	+	// Only a pointer entering another output switches: keyboard
	554	+	// moves to another screen stick until then. Not mid-drag.
	555	+	if o, ok := c.layout().At(c.cursorX, c.cursorY); ok && o.Info.Name != c.pointerOutput && c.grab == 0 {
	556	+	c.pointerOutput = o.Info.Name
	557	+	if o.Info.Name != c.cur().name() {
	558	+	c.focusScreen = c.screenIndex(o.Info.Name)
	559	+	if err := c.publish(ctx); err != nil {
	560	+	return nil
	561	+	}
556	562		}
557	563		}
558	564		id, x, y := c.hit(c.cursorX, c.cursorY)

 	grab             WindowID
 	buttons          map[uint32]bool
 	cursorX, cursorY float64 // global, logical
+	pointerOutput    string  // output under the pointer at the last motion
 	seq              uint64
 	// layerChanged is set once layer state arrives from wayland.
 	layerChanged bool
 				c.cursorX, c.cursorY = c.layout().Clamp(c.cursorX, c.cursorY, v.X, v.Y)
 				// The focused screen follows the pointer, so new windows
 				// and launchers open where the user is.
-				if o, ok := c.layout().At(c.cursorX, c.cursorY); ok && o.Info.Name != c.cur().name() {
+				// Only a pointer entering another output switches: keyboard
-					c.focusScreen = c.screenIndex(o.Info.Name)
+				// moves to another screen stick until then. Not mid-drag.
-					if err := c.publish(ctx); err != nil {
+				if o, ok := c.layout().At(c.cursorX, c.cursorY); ok && o.Info.Name != c.pointerOutput && c.grab == 0 {
-						return nil
+					c.pointerOutput = o.Info.Name
+					if o.Info.Name != c.cur().name() {
+						c.focusScreen = c.screenIndex(o.Info.Name)
+						if err := c.publish(ctx); err != nil {
+							return nil
+						}
 					}
 				}
 				id, x, y := c.hit(c.cursorX, c.cursorY)

M internal/core/layout.go +3 -0


@@ -7,6 +7,7 @@ import (
7	7		"slices"
8	8		"strconv"
9	9		"strings"
	10	+	"time"
10	11		)
11	12
12	13		type WindowID = ports.WindowID

@@ -125,6 +126,8 @@ type Workspace struct {
125	126		// its position there, where it returns.
126	127		home string
127	128		homePos int
	129	+	// termAt is when core last spawned a terminal for this workspace.
	130	+	termAt time.Time
128	131		}
129	132
130	133		func (w *Workspace) empty() bool { return len(w.Columns) == 0 }


@@ -7,6 +7,7 @@ import (
7	"slices"	7		"slices"
8	"strconv"	8		"strconv"
9	"strings"	9		"strings"
		10	+	"time"
10	)	11		)
11		12
12	type WindowID = ports.WindowID	13		type WindowID = ports.WindowID

@@ -125,6 +126,8 @@ type Workspace struct {
125	// its position there, where it returns.	126		// its position there, where it returns.
126	home string	127		home string
127	homePos int	128		homePos int
		129	+	// termAt is when core last spawned a terminal for this workspace.
		130	+	termAt time.Time
128	}	131		}
129		132
130	func (w *Workspace) empty() bool { return len(w.Columns) == 0 }	133		func (w *Workspace) empty() bool { return len(w.Columns) == 0 }

M internal/core/screens.go +2 -1


@@ -99,7 +99,7 @@ func (c Core) byName(name string) (screen, *Workspace) {
99	99		return nil, nil
100	100		}
101	101
102		-	// configScale is output.<name>.scale, else 1.
	102	+	// isPrimary reports output.<name>.primary.
103	103		func (c *Core) isPrimary(name string) bool {
104	104		for _, o := range c.cfg.Outputs {
105	105		if o.Name == name && o.Primary {

@@ -121,6 +121,7 @@ func (c *Core) anyWindow() bool {
121	121		return false
122	122		}
123	123
	124	+	// configScale is output.<name>.scale, else 1.
124	125		func (c *Core) configScale(name string) float64 {
125	126		v := 1.0
126	127		for _, o := range c.cfg.Outputs {

 	return nil, nil
 }
-// configScale is output.<name>.scale, else 1.
+// isPrimary reports output.<name>.primary.
 func (c *Core) isPrimary(name string) bool {
 	for _, o := range c.cfg.Outputs {
 		if o.Name == name && o.Primary {
 	return false
 }
+// configScale is output.<name>.scale, else 1.
 func (c *Core) configScale(name string) float64 {
 	v := 1.0
 	for _, o := range c.cfg.Outputs {

M internal/core/screens_test.go +25 -14


@@ -361,14 +361,8 @@ func TestMoveColumnCrossesOutputs(t *testing.T) {
361	361		if out := lastOutputs(t, r.commands); out.Focused != "DP-2" {
362	362		t.Fatal(out.Focused)
363	363		}
364		-	// It is DP-2's only column now: it stays. With a second one, the
365		-	// focused column goes back and lands on the right side of DP-1.
366		-	set = r.key(t, "Left", ports.ModAlt\|ports.ModShift)
367		-	if got := shown(set); len(got["DP-1"]) != 1 \|\| len(got["DP-2"]) != 1 {
368		-	t.Fatal(got)
369		-	}
370		-	r.mapWindow(t, 3)
371		-	r.key(t, "Left", ports.ModAlt) // focus window 2, the left column
	364	+	// Back left (no terminal kept here, so a last column may move): it
	365	+	// lands on the right side of DP-1.
372	366		set = r.key(t, "Left", ports.ModAlt\|ports.ModShift)
373	367		if got := shown(set)["DP-1"]; len(got) != 2 {
374	368		t.Fatal(got)

@@ -415,23 +409,40 @@ func TestEmptyWorkspaceGetsTerminal(t *testing.T) {
415	409		if got := shown(set); len(got["DP-1"]) != 1 \|\| len(got["DP-2"]) != 1 \|\| got["DP-1"][0] == got["DP-2"][0] {
416	410		t.Fatal(got)
417	411		}
418		-	// Closing the last window spawns a new terminal; nothing while pending.
	412	+	// A terminal that exits right after mapping is not respawned at once
	413	+	// (no loop for a broken terminal command).
419	414		r.client <- ports.WindowUnmapped{ID: 2}
420	415		receive(t, r.scenes)
421		-	if v := receive(t, r.spawn); v.Argv[0] != "foot" {
422		-	t.Fatal(v)
423		-	}
424	416		r.key(t, "Left", ports.ModAlt\|ports.ModCtrl)
425	417		if len(r.spawn) != 0 {
426		-	t.Fatal("spawned twice")
	418	+	t.Fatal("respawned at once")
427	419		}
428	420		}
429	421
430	422		func TestLastColumnStaysOnItsOutput(t *testing.T) {
431		-	r := startMulti(t, nil, left, right)
	423	+	r := startRig(t, true, nil, left, right)
432	424		r.mapWindow(t, 1)
433	425		set := r.key(t, "Right", ports.ModAlt\|ports.ModShift)
434	426		if got := shown(set); len(got["DP-1"]) != 1 \|\| len(got["DP-2"]) != 0 {
435	427		t.Fatal(got)
436	428		}
437	429		}
	430	+
	431	+	func TestKeyboardScreenFocusSticksUntilPointerLeaves(t *testing.T) {
	432	+	r := startMulti(t, nil, left, right)
	433	+	r.mapWindow(t, 1)
	434	+	r.input <- ports.PointerMotion{X: 10, Y: 10}
	435	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	436	+	// Jitter on DP-1 keeps DP-2 focused: the next window opens there.
	437	+	r.input <- ports.PointerMotion{X: 11, Y: 10}
	438	+	if got := shown(r.mapWindow(t, 2)); len(got["DP-2"]) != 1 {
	439	+	t.Fatal(got)
	440	+	}
	441	+	// Entering DP-1 again focuses it.
	442	+	r.input <- ports.PointerMotion{X: 250, Y: 10}
	443	+	r.input <- ports.PointerMotion{X: 10, Y: 10}
	444	+	receive(t, r.scenes)
	445	+	if got := shown(r.mapWindow(t, 3)); len(got["DP-1"]) != 2 {
	446	+	t.Fatal(got)
	447	+	}
	448	+	}

 	if out := lastOutputs(t, r.commands); out.Focused != "DP-2" {
 		t.Fatal(out.Focused)
 	}
-	// It is DP-2's only column now: it stays. With a second one, the
+	// Back left (no terminal kept here, so a last column may move): it
-	// focused column goes back and lands on the right side of DP-1.
+	// lands on the right side of DP-1.
-	set = r.key(t, "Left", ports.ModAlt|ports.ModShift)
-	if got := shown(set); len(got["DP-1"]) != 1 || len(got["DP-2"]) != 1 {
-		t.Fatal(got)
-	}
-	r.mapWindow(t, 3)
-	r.key(t, "Left", ports.ModAlt) // focus window 2, the left column
 	set = r.key(t, "Left", ports.ModAlt|ports.ModShift)
 	if got := shown(set)["DP-1"]; len(got) != 2 {
 		t.Fatal(got)
 	if got := shown(set); len(got["DP-1"]) != 1 || len(got["DP-2"]) != 1 || got["DP-1"][0] == got["DP-2"][0] {
 		t.Fatal(got)
 	}
-	// Closing the last window spawns a new terminal; nothing while pending.
+	// A terminal that exits right after mapping is not respawned at once
+	// (no loop for a broken terminal command).
 	r.client <- ports.WindowUnmapped{ID: 2}
 	receive(t, r.scenes)
-	if v := receive(t, r.spawn); v.Argv[0] != "foot" {
-		t.Fatal(v)
-	}
 	r.key(t, "Left", ports.ModAlt|ports.ModCtrl)
 	if len(r.spawn) != 0 {
-		t.Fatal("spawned twice")
+		t.Fatal("respawned at once")
 	}
 }
 func TestLastColumnStaysOnItsOutput(t *testing.T) {
-	r := startMulti(t, nil, left, right)
+	r := startRig(t, true, nil, left, right)
 	r.mapWindow(t, 1)
 	set := r.key(t, "Right", ports.ModAlt|ports.ModShift)
 	if got := shown(set); len(got["DP-1"]) != 1 || len(got["DP-2"]) != 0 {
 		t.Fatal(got)
 	}
 }
+func TestKeyboardScreenFocusSticksUntilPointerLeaves(t *testing.T) {
+	r := startMulti(t, nil, left, right)
+	r.mapWindow(t, 1)
+	r.input <- ports.PointerMotion{X: 10, Y: 10}
+	r.key(t, "Right", ports.ModAlt|ports.ModCtrl)
+	// Jitter on DP-1 keeps DP-2 focused: the next window opens there.
+	r.input <- ports.PointerMotion{X: 11, Y: 10}
+	if got := shown(r.mapWindow(t, 2)); len(got["DP-2"]) != 1 {
+		t.Fatal(got)
+	}
+	// Entering DP-1 again focuses it.
+	r.input <- ports.PointerMotion{X: 250, Y: 10}
+	r.input <- ports.PointerMotion{X: 10, Y: 10}
+	receive(t, r.scenes)
+	if got := shown(r.mapWindow(t, 3)); len(got["DP-1"]) != 2 {
+		t.Fatal(got)
+	}
+}

M internal/core/terminal.go +22 -16


@@ -12,8 +12,8 @@ import (
12	12		// one is, core spawns the configured terminal with a SlotEnv token, and the
13	13		// window carrying it fills that workspace, wherever the focus is by then.
14	14
15		-	// termRetry is how long a terminal may take to map before another is spawned
16		-	// (the first one failed, or the terminal command is broken).
	15	+	// termRetry is the least time between two terminals for one workspace: a
	16	+	// terminal that fails, or maps and exits at once, is not respawned in a loop.
17	17		const termRetry = 5 * time.Second
18	18
19	19		type termSpawn struct {

@@ -21,39 +21,45 @@ type termSpawn struct {
21	21		at time.Time
22	22		}
23	23
	24	+	// keepsTerminal reports whether empty workspaces get a terminal.
	25	+	func (c *Core) keepsTerminal() bool { return c.ch.Terminal && len(c.cfg.Terminal.Command) > 0 }
	26	+
24	27		// fillEmpty returns the terminals to spawn for empty workspaces on screen.
25	28		// Workspaces with slots are left to them.
26	29		func (c *Core) fillEmpty() []ports.SpawnRequest {
27		-	if !c.ch.Terminal \|\| len(c.cfg.Terminal.Command) == 0 {
	30	+	now := time.Now()
	31	+	// Expired spawns go first, whatever is on screen: pending tokens keep
	32	+	// wayland reading /proc on every map.
	33	+	for token, t := range c.terms {
	34	+	if now.Sub(t.at) > termRetry {
	35	+	delete(c.terms, token)
	36	+	}
	37	+	}
	38	+	if !c.keepsTerminal() {
28	39		return nil
29	40		}
30		-	now := time.Now()
31	41		var reqs []ports.SpawnRequest
32	42		for _, s := range c.screens {
33	43		w := s.mon.Current()
34		-	if s.name() == "" \|\| !w.empty() \|\| c.hasSlots(w) \|\| c.termPending(w, now) {
	44	+	if s.name() == "" \|\| !w.empty() \|\| c.hasSlots(w) \|\| c.termPending(w) \|\| now.Sub(w.termAt) < termRetry {
35	45		continue
36	46		}
37	47		token := rand.Text()
	48	+	w.termAt = now
38	49		c.terms[token] = &termSpawn{w: w, at: now}
39	50		reqs = append(reqs, ports.SpawnRequest{Argv: slices.Clone(c.cfg.Terminal.Command), Env: []string{ports.SlotEnv + "=" + token}})
40	51		}
41	52		return reqs
42	53		}
43	54
44		-	// termPending reports whether a recent terminal spawn waits for w; it drops
45		-	// expired ones.
46		-	func (c Core) termPending(w Workspace, now time.Time) bool {
47		-	found := false
48		-	for token, t := range c.terms {
49		-	switch {
50		-	case now.Sub(t.at) > termRetry:
51		-	delete(c.terms, token)
52		-	case t.w == w:
53		-	found = true
	55	+	// termPending reports whether a terminal spawn waits for w.
	56	+	func (c Core) termPending(w Workspace) bool {
	57	+	for _, t := range c.terms {
	58	+	if t.w == w {
	59	+	return true
54	60		}
55	61		}
56		-	return found
	62	+	return false
57	63		}
58	64
59	65		func (c Core) hasSlots(w Workspace) bool {

 // one is, core spawns the configured terminal with a SlotEnv token, and the
 // window carrying it fills that workspace, wherever the focus is by then.
-// termRetry is how long a terminal may take to map before another is spawned
+// termRetry is the least time between two terminals for one workspace: a
-// (the first one failed, or the terminal command is broken).
+// terminal that fails, or maps and exits at once, is not respawned in a loop.
 const termRetry = 5 * time.Second
 type termSpawn struct {
 	at time.Time
 }
+// keepsTerminal reports whether empty workspaces get a terminal.
+func (c *Core) keepsTerminal() bool { return c.ch.Terminal && len(c.cfg.Terminal.Command) > 0 }
 // fillEmpty returns the terminals to spawn for empty workspaces on screen.
 // Workspaces with slots are left to them.
 func (c *Core) fillEmpty() []ports.SpawnRequest {
-	if !c.ch.Terminal || len(c.cfg.Terminal.Command) == 0 {
+	now := time.Now()
+	// Expired spawns go first, whatever is on screen: pending tokens keep
+	// wayland reading /proc on every map.
+	for token, t := range c.terms {
+		if now.Sub(t.at) > termRetry {
+			delete(c.terms, token)
+		}
+	}
+	if !c.keepsTerminal() {
 		return nil
 	}
-	now := time.Now()
 	var reqs []ports.SpawnRequest
 	for _, s := range c.screens {
 		w := s.mon.Current()
-		if s.name() == "" || !w.empty() || c.hasSlots(w) || c.termPending(w, now) {
+		if s.name() == "" || !w.empty() || c.hasSlots(w) || c.termPending(w) || now.Sub(w.termAt) < termRetry {
 			continue
 		}
 		token := rand.Text()
+		w.termAt = now
 		c.terms[token] = &termSpawn{w: w, at: now}
 		reqs = append(reqs, ports.SpawnRequest{Argv: slices.Clone(c.cfg.Terminal.Command), Env: []string{ports.SlotEnv + "=" + token}})
 	}
 	return reqs
 }
-// termPending reports whether a recent terminal spawn waits for w; it drops
+// termPending reports whether a terminal spawn waits for w.
-// expired ones.
+func (c *Core) termPending(w *Workspace) bool {
-func (c *Core) termPending(w *Workspace, now time.Time) bool {
+	for _, t := range c.terms {
-	found := false
+		if t.w == w {
-	for token, t := range c.terms {
+			return true
-		switch {
-		case now.Sub(t.at) > termRetry:
-			delete(c.terms, token)
-		case t.w == w:
-			found = true
 		}
 	}
-	return found
+	return false
 }
 func (c *Core) hasSlots(w *Workspace) bool {