bc1ec78 feat(outputs): multiple monitors and hotplug · neferwl

M cmd/nefertty/main.go +14 -7

 	flags := flag.NewFlagSet("nefertty", flag.ContinueOnError)
 	backend := flags.String("backend", "drm", "drm or headless")
 	screenshot := flags.String("screenshot", "", "write PNG frames to directory")
-	size := flags.String("size", "1920x1080", "headless output size WxH")
+	size := flags.String("size", "1920x1080", "headless output sizes WxH, comma-separated for several outputs")
 	inputPath := flags.String("input", "", "headless input script path (- for stdin)")
 	noTerminal := flags.Bool("no-terminal", false, "skip initial terminal")
 	timeout := flags.Duration("timeout", 0, "duration before exit (0 disables timeout)")
 		fmt.Fprintln(os.Stderr, err)
 		return err
 	}
-	outW, outH, _, sizeErr := config.ParseMode(*size)
+	var sizes [][2]int
-	if sizeErr != nil {
+	for _, s := range strings.Split(*size, ",") {
-		err := usageError{fmt.Errorf("--size: %w", sizeErr)}
+		w, h, _, sizeErr := config.ParseMode(strings.TrimSpace(s))
-		fmt.Fprintln(os.Stderr, err)
+		if sizeErr != nil || w == 0 {
-		return err
+			err := usageError{fmt.Errorf("--size: %w", sizeErr)}
+			if sizeErr == nil {
+				err = usageError{fmt.Errorf("--size: need WxH, got %q", s)}
+			}
+			fmt.Fprintln(os.Stderr, err)
+			return err
+		}
+		sizes = append(sizes, [2]int{w, h})
 	}
 	if *inputPath != "" && *backend != "headless" {
 		err := usageError{fmt.Errorf("--input requires --backend=headless")}
 	for _, w := range warnings {
 		configLog.Warn().Int("line", w.Line).Msg(w.Msg)
 	}
-	err = app.Run(ctx, app.Options{Backend: *backend, Config: cfg, ConfigPath: path, Timeout: *timeout, NoTerminal: *noTerminal, ScreenshotDir: *screenshot, Width: outW, Height: outH, Script: script})
+	err = app.Run(ctx, app.Options{Backend: *backend, Config: cfg, ConfigPath: path, Timeout: *timeout, NoTerminal: *noTerminal, ScreenshotDir: *screenshot, Sizes: sizes, Script: script})
 	// SIGINT and SIGTERM cancel the context and are clean exits.
 	if err != nil && ctx.Err() != nil && errors.Is(err, context.Canceled) {
 		err = nil

M internal/adapters/config/config.go +9 -2

 	{"cmd+pagedown", "focus-workspace-down"},
 	{"cmd+shift+pageup", "move-to-workspace-up"},
 	{"cmd+shift+pagedown", "move-to-workspace-down"},
+	{"cmd+ctrl+left", "focus-monitor-left"},
+	{"cmd+ctrl+right", "focus-monitor-right"},
+	{"cmd+ctrl+shift+left", "move-workspace-to-monitor-left"},
+	{"cmd+ctrl+shift+right", "move-workspace-to-monitor-right"},
 }
-var actions = map[string]bool{"scale-up": true, "scale-down": true, "focus-workspace-up": true, "focus-workspace-down": true, "move-to-workspace-up": true, "move-to-workspace-down": true, "none": true, "spawn-terminal": true, "focus-column-left": true, "focus-column-right": true, "focus-window-up": true, "focus-window-down": true, "move-column-left": true, "move-column-right": true, "cycle-column-width": true, "toggle-fullscreen": true, "close-window": true, "quit": true}
+var actions = map[string]bool{"focus-monitor-left": true, "focus-monitor-right": true, "move-workspace-to-monitor-left": true, "move-workspace-to-monitor-right": true, "scale-up": true, "scale-down": true, "focus-workspace-up": true, "focus-workspace-down": true, "move-to-workspace-up": true, "move-to-workspace-down": true, "none": true, "spawn-terminal": true, "focus-column-left": true, "focus-column-right": true, "focus-window-up": true, "focus-window-down": true, "move-column-left": true, "move-column-right": true, "cycle-column-width": true, "toggle-fullscreen": true, "close-window": true, "quit": true}
 var components = map[string]bool{"core": true, "wayland": true, "input": true, "drm": true, "seat": true, "render": true, "sync": true, "config": true, "app": true}
 var color = regexp.MustCompile(`^#[0-9a-fA-F]{6}$`)
 		w.Hidden = b
 		return err
 	case "monitor":
-		return fmt.Errorf("not supported yet: one monitor only")
+		if v == "" {
+			return fmt.Errorf("needs a connector (DP-2) or a monitor key")
+		}
+		w.Monitor = v
 	case "max-columns":
 		return positive(&w.MaxColumns, v, 16)
 	case "overflow":

M internal/adapters/config/config_test.go +3 -3


@@ -21,7 +21,7 @@ func parseString(t *testing.T, s string) (ports.Config, []Warning) {
21			21
22		func TestDefaultsAndLoad(t *testing.T) {	22		func TestDefaultsAndLoad(t *testing.T) {
23		d := Defaults()	23		d := Defaults()
24	-	if d.Keyboard.RepeatRate != 25 \|\| d.Keyboard.CmdKey != "super" \|\| !d.Render.DirectScanout \|\| len(d.Binds) != 36 \|\| d.Layout.MaxColumns != 2 {	24	+	if d.Keyboard.RepeatRate != 25 \|\| d.Keyboard.CmdKey != "super" \|\| !d.Render.DirectScanout \|\| len(d.Binds) != 40 \|\| d.Layout.MaxColumns != 2 {
25		t.Fatalf("defaults: %+v", d)	25		t.Fatalf("defaults: %+v", d)
26		}	26		}
27		if d.Binds["Cmd+Ctrl+space"] != "spawn fuzzel" \|\| d.Binds["Alt+Ctrl+BackSpace"] != "quit" {	27		if d.Binds["Cmd+Ctrl+space"] != "spawn fuzzel" \|\| d.Binds["Alt+Ctrl+BackSpace"] != "quit" {

@@ -249,7 +249,7 @@ bind.cmd+x = workspace typo
249		workspace.lost.hidden = on	249		workspace.lost.hidden = on
250		`)	250		`)
251		want := []ports.WorkspaceConfig{	251		want := []ports.WorkspaceConfig{
252	-	{Name: "dev", Hidden: true, MaxColumns: 3},	252	+	{Name: "dev", Monitor: "DP-2", Hidden: true, MaxColumns: 3},
253		{Name: "web", Overflow: "scroll"},	253		{Name: "web", Overflow: "scroll"},
254		{Name: "lost", Hidden: true},	254		{Name: "lost", Hidden: true},
255		}	255		}

@@ -263,7 +263,7 @@ workspace.lost.hidden = on
263		for _, x := range w {	263		for _, x := range w {
264		lines = append(lines, x.Line)	264		lines = append(lines, x.Line)
265		}	265		}
266	-	if !reflect.DeepEqual(lines, []int{5, 6, 7, 8, 10, 11, 12}) {	266	+	if !reflect.DeepEqual(lines, []int{6, 7, 8, 10, 11, 12}) {
267		t.Fatal(w)	267		t.Fatal(w)
268		}	268		}
269		}	269		}

A internal/adapters/drm/card.go +157 -0

@@ -0,0 +1,157 @@
	1	+	package drm
	2	+
	3	+	import (
	4	+	"context"
	5	+	"errors"
	6	+	"fmt"
	7	+	"slices"
	8	+
	9	+	"github.com/bnema/zerowrap"
	10	+	"golang.org/x/sys/unix"
	11	+	)
	12	+
	13	+	// Card is one DRM device and the outputs it drives. Scan finds connected
	14	+	// connectors; each gets its own Output (CRTC, buffers, cursor) run by one
	15	+	// goroutine. One reader goroutine reads page-flip events for all of them
	16	+	// and hands each to its output by CRTC.
	17	+	type Card struct {
	18	+	fd int
	19	+	path string
	20	+	want Want
	21	+	log zerowrap.Logger
	22	+	crtcs []uint32
	23	+	// outputs by connector name; owned by the goroutine that calls Scan.
	24	+	outputs map[string]*Output
	25	+	flips map[uint32]chan int // by CRTC; set before the reader starts
	26	+	}
	27	+
	28	+	// OpenCard reads the card's CRTCs. fd stays owned by the caller.
	29	+	func OpenCard(fd int, path string, want Want, log zerowrap.Logger) (*Card, error) {
	30	+	crtcs, _, err := resources(fd)
	31	+	if err != nil {
	32	+	return nil, fmt.Errorf("%s: %w", path, err)
	33	+	}
	34	+	flips := make(map[uint32]chan int, len(crtcs))
	35	+	for _, c := range crtcs {
	36	+	flips[c] = make(chan int, 4)
	37	+	}
	38	+	return &Card{fd: fd, path: path, want: want, log: log, crtcs: crtcs, outputs: map[string]*Output{}, flips: flips}, nil
	39	+	}
	40	+
	41	+	// Path is the device path, e.g. /dev/dri/card1.
	42	+	func (c *Card) Path() string { return c.path }
	43	+
	44	+	// SetWant replaces the connector config; the next Scan applies it.
	45	+	func (c *Card) SetWant(w Want) { c.want = w }
	46	+
	47	+	// Scan compares connectors with the outputs driven now. It returns outputs to
	48	+	// start (newly connected, or with a new mode after Release), names of
	49	+	// outputs to stop because they are gone (disconnected or disabled), and
	50	+	// names to stop because they need a new mode. A stopped output must be
	51	+	// closed by its goroutine before its CRTC is reused: call Release.
	52	+	func (c Card) Scan() (added []Output, removed, replaced []string, err error) {
	53	+	_, ids, err := resources(c.fd)
	54	+	if err != nil {
	55	+	return nil, nil, nil, err
	56	+	}
	57	+	seen := map[string]bool{}
	58	+	for _, id := range ids {
	59	+	conn, err := readConnector(c.fd, id)
	60	+	if err != nil {
	61	+	c.log.Warn().Err(err).Uint32("connector", id).Msg("read connector")
	62	+	continue
	63	+	}
	64	+	if !c.want.usable(conn) {
	65	+	continue
	66	+	}
	67	+	seen[conn.name] = true
	68	+	mode := c.want.pickMode(conn)
	69	+	if o := c.outputs[conn.name]; o != nil {
	70	+	if o.mode == mode {
	71	+	continue
	72	+	}
	73	+	replaced = append(replaced, conn.name)
	74	+	continue
	75	+	}
	76	+	o, err := c.open(conn, mode)
	77	+	if err != nil {
	78	+	c.log.Warn().Err(err).Str("connector", conn.name).Msg("output unusable")
	79	+	continue
	80	+	}
	81	+	c.outputs[conn.name] = o
	82	+	added = append(added, o)
	83	+	}
	84	+	for name := range c.outputs {
	85	+	if !seen[name] {
	86	+	removed = append(removed, name)
	87	+	}
	88	+	}
	89	+	slices.Sort(removed)
	90	+	slices.Sort(replaced)
	91	+	return added, removed, replaced, nil
	92	+	}
	93	+
	94	+	// Release forgets an output closed by its goroutine, freeing its CRTC for the
	95	+	// next Scan.
	96	+	func (c *Card) Release(name string) { delete(c.outputs, name) }
	97	+
	98	+	// Outputs returns the driven outputs.
	99	+	func (c Card) Outputs() []Output {
	100	+	out := make([]*Output, 0, len(c.outputs))
	101	+	for _, o := range c.outputs {
	102	+	out = append(out, o)
	103	+	}
	104	+	slices.SortFunc(out, func(a, b *Output) int {
	105	+	if a.conn.name < b.conn.name {
	106	+	return -1
	107	+	}
	108	+	return 1
	109	+	})
	110	+	return out
	111	+	}
	112	+
	113	+	func (c Card) open(conn connector, mode modeInfo) (Output, error) {
	114	+	used := map[uint32]bool{}
	115	+	for _, o := range c.outputs {
	116	+	used[o.crtc] = true
	117	+	}
	118	+	crtc, err := pickCrtc(c.fd, conn, c.crtcs, used)
	119	+	if err != nil {
	120	+	return nil, err
	121	+	}
	122	+	return newOutput(c, conn, mode, crtc)
	123	+	}
	124	+
	125	+	// ReadEvents reads page-flip events until ctx ends and routes them to the
	126	+	// output of their CRTC. Run it once per card.
	127	+	func (c *Card) ReadEvents(ctx context.Context) error {
	128	+	buf := make([]byte, 1024)
	129	+	for ctx.Err() == nil {
	130	+	fds := []unix.PollFd{{Fd: int32(c.fd), Events: unix.POLLIN}}
	131	+	n, err := unix.Poll(fds, 100)
	132	+	if err != nil && !errors.Is(err, unix.EINTR) {
	133	+	return fmt.Errorf("drm poll: %w", err)
	134	+	}
	135	+	if n <= 0 {
	136	+	continue
	137	+	}
	138	+	m, err := unix.Read(c.fd, buf)
	139	+	if err != nil {
	140	+	if errors.Is(err, unix.EINTR) \|\| errors.Is(err, unix.EAGAIN) {
	141	+	continue
	142	+	}
	143	+	return fmt.Errorf("drm read: %w", err)
	144	+	}
	145	+	for _, crtc := range flipCrtcs(buf[:m]) {
	146	+	ch := c.flips[crtc]
	147	+	if ch == nil {
	148	+	continue
	149	+	}
	150	+	select {
	151	+	case ch <- 1:
	152	+	default: // the output is busy; the flip is counted on its next event
	153	+	}
	154	+	}
	155	+	}
	156	+	return nil
	157	+	}

M internal/adapters/drm/cursor.go +20 -2

 	size       int // buffer side
 	hotX, hotY int
 	shown      bool
+	hidden     bool // Hide was called; the next move shows it again
 	plane      cursorPlane
 	mu    sync.Mutex // guards x, y and stats; never held across an ioctl
 				// fails too and Reapply restores the cursor.
 				_ = c.plane.WaitVblank()
 				c.io.Lock()
-				if c.shown && c.buf != nil {
+				if c.hidden {
+					// A move shows it again, even before its first image.
+					c.hidden = false
+					_ = c.apply()
+				} else if c.shown && c.buf != nil {
 					x, y := c.position()
 					v := modeCursor2{flags: cursorMove, crtcID: c.crtc, x: int32(x - c.hotX), y: int32(y - c.hotY)}
 					// Errors while another session owns the card (VT switched
 // apply (re)attaches the buffer at the current position. Callers hold c.io.
 func (c *Cursor) apply() error {
-	if !c.shown || c.buf == nil {
+	if !c.shown || c.hidden || c.buf == nil {
 		return nil
 	}
 	x, y := c.position()
 	}
 }
+// Hide removes the cursor from the output until the next move (the pointer
+// is on another output).
+func (c *Cursor) Hide() {
+	c.io.Lock()
+	defer c.io.Unlock()
+	if c.buf == nil || c.hidden {
+		return
+	}
+	c.hidden = true
+	v := modeCursor2{flags: cursorBO, crtcID: c.crtc}
+	_ = c.plane.Set(&v)
+}
 // Reapply shows the cursor again after a modeset (VT switch back).
 func (c *Cursor) Reapply() error {
 	c.io.Lock()

A internal/adapters/drm/hotplug.go +104 -0

@@ -0,0 +1,104 @@
	1	+	package drm
	2	+
	3	+	import (
	4	+	"context"
	5	+	"errors"
	6	+	"fmt"
	7	+	"sync"
	8	+
	9	+	"github.com/bnema/purego"
	10	+	"golang.org/x/sys/unix"
	11	+	)
	12	+
	13	+	// Hotplug reports connector changes through a udev netlink monitor on the
	14	+	// drm subsystem (the kernel sends HOTPLUG=1 on the card). libudev is loaded
	15	+	// with purego.
	16	+
	17	+	var (
	18	+	udevOnce sync.Once
	19	+	udevErr error
	20	+
	21	+	udevNew func() uintptr
	22	+	udevUnref func(uintptr) uintptr
	23	+	monitorNew func(udev uintptr, name string) uintptr
	24	+	monitorUnref func(uintptr) uintptr
	25	+	monitorFilter func(mon uintptr, subsystem string, devtype uintptr) int32
	26	+	monitorEnable func(uintptr) int32
	27	+	monitorFD func(uintptr) int32
	28	+	monitorReceive func(uintptr) uintptr
	29	+	deviceUnref func(uintptr) uintptr
	30	+	devicePropertyVal func(dev uintptr, key string) string
	31	+	)
	32	+
	33	+	func loadUdev() error {
	34	+	udevOnce.Do(func() {
	35	+	lib, err := purego.Dlopen("libudev.so.1", purego.RTLD_NOW\|purego.RTLD_LOCAL)
	36	+	if err != nil {
	37	+	udevErr = fmt.Errorf("open libudev.so.1: %w", err)
	38	+	return
	39	+	}
	40	+	defer func() {
	41	+	if r := recover(); r != nil {
	42	+	udevErr = fmt.Errorf("libudev: %v", r)
	43	+	}
	44	+	}()
	45	+	reg := func(fn any, name string) { purego.RegisterLibFunc(fn, lib, "udev_"+name) }
	46	+	reg(&udevNew, "new")
	47	+	reg(&udevUnref, "unref")
	48	+	reg(&monitorNew, "monitor_new_from_netlink")
	49	+	reg(&monitorUnref, "monitor_unref")
	50	+	reg(&monitorFilter, "monitor_filter_add_match_subsystem_devtype")
	51	+	reg(&monitorEnable, "monitor_enable_receiving")
	52	+	reg(&monitorFD, "monitor_get_fd")
	53	+	reg(&monitorReceive, "monitor_receive_device")
	54	+	reg(&deviceUnref, "device_unref")
	55	+	reg(&devicePropertyVal, "device_get_property_value")
	56	+	})
	57	+	return udevErr
	58	+	}
	59	+
	60	+	// WatchHotplug sends on changed after every DRM hotplug event until ctx
	61	+	// ends. Events that arrive while a send is pending are merged.
	62	+	func WatchHotplug(ctx context.Context, changed chan<- struct{}) error {
	63	+	if err := loadUdev(); err != nil {
	64	+	return err
	65	+	}
	66	+	udev := udevNew()
	67	+	if udev == 0 {
	68	+	return errors.New("udev_new failed")
	69	+	}
	70	+	defer udevUnref(udev)
	71	+	mon := monitorNew(udev, "udev")
	72	+	if mon == 0 {
	73	+	return errors.New("udev_monitor_new_from_netlink failed")
	74	+	}
	75	+	defer monitorUnref(mon)
	76	+	if monitorFilter(mon, "drm", 0) < 0 \|\| monitorEnable(mon) < 0 {
	77	+	return errors.New("udev monitor setup failed")
	78	+	}
	79	+	fd := monitorFD(mon)
	80	+	for ctx.Err() == nil {
	81	+	fds := []unix.PollFd{{Fd: fd, Events: unix.POLLIN}}
	82	+	n, err := unix.Poll(fds, 100)
	83	+	if err != nil && !errors.Is(err, unix.EINTR) {
	84	+	return fmt.Errorf("udev poll: %w", err)
	85	+	}
	86	+	if n <= 0 {
	87	+	continue
	88	+	}
	89	+	dev := monitorReceive(mon)
	90	+	if dev == 0 {
	91	+	continue
	92	+	}
	93	+	hot := devicePropertyVal(dev, "HOTPLUG") == "1"
	94	+	deviceUnref(dev)
	95	+	if !hot {
	96	+	continue
	97	+	}
	98	+	select {
	99	+	case changed <- struct{}{}:
	100	+	default:
	101	+	}
	102	+	}
	103	+	return nil
	104	+	}

M internal/adapters/drm/kms.go +35 -47

-// Package drm drives one KMS output with raw ioctls and dumb buffers.
+// Package drm drives KMS outputs with raw ioctls and dumb buffers.
 package drm
 import (
-	"errors"
+	"encoding/binary"
 	"fmt"
 	"math"
 	"unsafe"
 var connectorTypes = map[uint32]string{1: "VGA", 2: "DVI-I", 3: "DVI-D", 10: "DP", 11: "HDMI-A", 12: "HDMI-B", 7: "LVDS", 14: "eDP", 15: "Virtual", 16: "DSI", 17: "DPI", 20: "USB"}
-// Want selects a connector and mode; see ports.OutputConfig.
+// Want configures connectors; see ports.OutputConfig.
 type Want struct {
-	Name     string
-	W, H     int
-	Hz       float64 // 0: highest refresh at W x H
 	Disabled map[string]bool
-	// Strict accepts only the connector named Name (used to search every card first).
+	// Modes maps a connector to W, H and Hz (0: highest refresh at W x H).
-	Strict bool
+	Modes map[string][3]float64
+}
+// usable reports whether a connector should be driven.
+func (w Want) usable(c connector) bool {
+	return c.connected && len(c.modes) > 0 && !w.Disabled[c.name]
 }
 // refreshMilli is the exact refresh in mHz, computed from the timings like wlroots.
 	return int(r)
 }
-// pickConnector applies want: the named connector if connected, else the first
+// pickMode returns the configured mode of the connector, else its preferred
-// connected one that is not disabled. The mode is the requested one, else preferred.
+// one, else the first.
-func pickConnector(conns []connector, want Want) (connector, modeInfo, error) {
+func (w Want) pickMode(c connector) modeInfo {
-	var chosen *connector
+	if m, ok := w.Modes[c.name]; ok {
-	for i := range conns {
+		if mode, ok := pickMode(c.modes, int(m[0]), int(m[1]), m[2]); ok {
-		c := &conns[i]
+			return mode
-		if !c.connected || len(c.modes) == 0 || want.Disabled[c.name] {
-			continue
-		}
-		if c.name == want.Name {
-			chosen = c
-			break
-		}
-		if chosen == nil && !want.Strict {
-			chosen = c
-		}
-	}
-	if chosen == nil {
-		return connector{}, modeInfo{}, errors.New("no connected display")
-	}
-	if chosen.name == want.Name && want.W > 0 {
-		if m, ok := pickMode(chosen.modes, want.W, want.H, want.Hz); ok {
-			return *chosen, m, nil
 		}
 	}
-	for _, m := range chosen.modes {
+	for _, m := range c.modes {
 		if m.Type&modeTypePrefered != 0 {
-			return *chosen, m, nil
+			return m
 		}
 	}
-	return *chosen, chosen.modes[0], nil
+	return c.modes[0]
 }
 // pickMode finds W x H with the refresh closest to hz, or the highest when hz is 0.
 	}, nil
 }
-// pickCrtc prefers the connector's current encoder CRTC, else any CRTC an encoder allows.
+// pickCrtc prefers the connector's current encoder CRTC, else any free CRTC
-func pickCrtc(fd int, c connector, crtcs []uint32) (uint32, error) {
+// an encoder allows. used holds CRTCs already driving other outputs.
+func pickCrtc(fd int, c connector, crtcs []uint32, used map[uint32]bool) (uint32, error) {
 	encs := c.encoders
 	if c.encoderID != 0 {
 		encs = append([]uint32{c.encoderID}, encs...)
 		if ioctl(fd, ioctlGetEncoder, unsafe.Pointer(&e)) != nil {
 			continue
 		}
-		if id == c.encoderID && e.crtcID != 0 {
+		if id == c.encoderID && e.crtcID != 0 && !used[e.crtcID] {
 			return e.crtcID, nil
 		}
 		for i, crtc := range crtcs {
-			if e.possibleCrtcs&(1<<i) != 0 {
+			if e.possibleCrtcs&(1<<i) != 0 && !used[crtc] {
 				return crtc, nil
 			}
 		}
 	}
-	return 0, fmt.Errorf("no CRTC for %s", c.name)
+	return 0, fmt.Errorf("no free CRTC for %s", c.name)
 }
 type dumbBuffer struct {
 	return ioctl(fd, ioctlPageFlip, unsafe.Pointer(&p))
 }
-// countFlipEvents parses DRM events read from the card fd.
+// flipCrtcs parses DRM events read from the card fd and returns the CRTC of
-func countFlipEvents(buf []byte) int {
+// each completed page flip.
-	n := 0
+func flipCrtcs(buf []byte) []uint32 {
+	var out []uint32
 	for len(buf) >= 8 {
-		typ := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+		typ := binary.LittleEndian.Uint32(buf)
-		length := int(uint32(buf[4]) | uint32(buf[5])<<8 | uint32(buf[6])<<16 | uint32(buf[7])<<24)
+		length := int(binary.LittleEndian.Uint32(buf[4:]))
 		if length < 8 || length > len(buf) {
 			break
 		}
-		if typ == eventFlipDone {
+		// struct drm_event_vblank: base(8) user_data(8) sec usec sequence crtc_id.
-			n++
+		if typ == eventFlipDone && length >= 32 {
+			out = append(out, binary.LittleEndian.Uint32(buf[28:]))
 		}
 		buf = buf[length:]
 	}
-	return n
+	return out
 }

M internal/adapters/drm/kms_test.go +23 -31

 	}
 }
-func TestPickConnector(t *testing.T) {
+func TestWantPicksMode(t *testing.T) {
 	mode := func(w, h uint16, hz uint32, pref bool) modeInfo {
 		// htotal*vtotal = w*h keeps refreshMilli = clock*1000/(w*h).
 		m := modeInfo{HDisplay: w, VDisplay: h, HTotal: w, VTotal: h, Clock: uint32(uint64(w) * uint64(h) * uint64(hz) / 1000), VRefresh: hz}
 		return m
 	}
 	lg := connector{name: "DP-2", connected: true, modes: []modeInfo{mode(5120, 2160, 165, true), mode(3440, 1440, 100, true), mode(5120, 2160, 100, false), mode(5120, 2160, 60, false)}}
-	tv := connector{name: "HDMI-A-1", connected: true, modes: []modeInfo{mode(3840, 2160, 60, true), mode(3840, 2160, 120, false)}}
 	off := connector{name: "DP-1", modes: []modeInfo{mode(1920, 1080, 60, true)}}
 	for _, tc := range []struct {
-		name  string
+		name string
-		conns []connector
+		want Want
-		want  Want
+		mode string
-		conn  string
-		mode  string
-		err   bool
 	}{
-		{"none", nil, Want{}, "", "", true},
+		{"first preferred", Want{}, "5120x2160@165.000"},
-		{"first connected, first preferred", []connector{off, tv, lg}, Want{}, "HDMI-A-1", "3840x2160@60.000", false},
+		{"closest refresh", Want{Modes: map[string][3]float64{"DP-2": {5120, 2160, 99}}}, "5120x2160@100.000"},
-		{"named", []connector{tv, lg}, Want{Name: "DP-2"}, "DP-2", "5120x2160@165.000", false},
+		{"highest refresh", Want{Modes: map[string][3]float64{"DP-2": {5120, 2160, 0}}}, "5120x2160@165.000"},
-		{"named mode closest refresh", []connector{tv, lg}, Want{Name: "DP-2", W: 5120, H: 2160, Hz: 99}, "DP-2", "5120x2160@100.000", false},
+		{"unknown mode falls back to preferred", Want{Modes: map[string][3]float64{"DP-2": {800, 600, 0}}}, "5120x2160@165.000"},
-		{"named mode highest refresh", []connector{lg}, Want{Name: "DP-2", W: 5120, H: 2160}, "DP-2", "5120x2160@165.000", false},
-		{"unknown mode falls back to preferred", []connector{lg}, Want{Name: "DP-2", W: 800, H: 600}, "DP-2", "5120x2160@165.000", false},
-		{"missing name falls back", []connector{tv}, Want{Name: "DP-2"}, "HDMI-A-1", "3840x2160@60.000", false},
-		{"disabled skipped", []connector{tv, lg}, Want{Disabled: map[string]bool{"HDMI-A-1": true}}, "DP-2", "5120x2160@165.000", false},
-		{"strict finds named", []connector{tv, lg}, Want{Name: "DP-2", Strict: true}, "DP-2", "5120x2160@165.000", false},
-		{"strict without named", []connector{tv}, Want{Name: "DP-2", Strict: true}, "", "", true},
-		{"all disabled", []connector{tv}, Want{Disabled: map[string]bool{"HDMI-A-1": true}}, "", "", true},
 	} {
-		c, m, err := pickConnector(tc.conns, tc.want)
+		if m := tc.want.pickMode(lg); m.String() != tc.mode {
-		if (err != nil) != tc.err || c.name != tc.conn || (err == nil && m.String() != tc.mode) {
+			t.Errorf("%s: got %s", tc.name, m)
-			t.Errorf("%s: got %q %s %v", tc.name, c.name, m, err)
 		}
 	}
+	if (Want{}).usable(off) || !(Want{}).usable(lg) || (Want{Disabled: map[string]bool{"DP-2": true}}).usable(lg) {
+		t.Fatal("usable")
+	}
 }
 func TestRefreshMilliLG(t *testing.T) {
 	}
 }
-func TestCountFlipEvents(t *testing.T) {
+func TestFlipCrtcs(t *testing.T) {
-	ev := func(typ uint32, n int) []byte {
+	ev := func(typ, crtc uint32) []byte {
-		b := make([]byte, n)
+		b := make([]byte, 32)
 		binary.LittleEndian.PutUint32(b, typ)
-		binary.LittleEndian.PutUint32(b[4:], uint32(n))
+		binary.LittleEndian.PutUint32(b[4:], 32)
+		binary.LittleEndian.PutUint32(b[28:], crtc)
 		return b
 	}
-	buf := append(append(ev(eventFlipDone, 32), ev(1, 32)...), ev(eventFlipDone, 32)...)
+	buf := append(append(ev(eventFlipDone, 41), ev(1, 7)...), ev(eventFlipDone, 42)...)
-	if n := countFlipEvents(buf); n != 2 {
+	if got := flipCrtcs(buf); len(got) != 2 || got[0] != 41 || got[1] != 42 {
-		t.Fatalf("got %d flips", n)
+		t.Fatalf("got %v", got)
 	}
-	if n := countFlipEvents(buf[:20]); n != 0 {
+	if got := flipCrtcs(buf[:20]); len(got) != 0 {
-		t.Fatalf("truncated: got %d", n)
+		t.Fatalf("truncated: got %v", got)
 	}
 }

M internal/adapters/drm/output.go +37 -100

 	"errors"
 	"fmt"
 	"slices"
-	"sync"
 	"time"
 	"github.com/bnema/nefertty/internal/ports"
 	"golang.org/x/sys/unix"
 )
-// Output is one KMS connector driven with two dumb buffers.
+// Output is one KMS connector driven with two dumb buffers. One goroutine
+// runs it (Run) and closes it.
 type Output struct {
 	fd        int
+	flipped   <-chan int // page flips of this CRTC, from Card.ReadEvents
 	crtc      uint32
 	conn      connector
 	mode      modeInfo
 // pixels on a side.
 type CursorLoader func(scale float64, limit int) (ports.CursorImage, error)
-// Info describes the chosen output for clients (wl_output, xdg-output).
+// newOutput allocates buffers and the cursor for a connector on crtc.
-type Info struct {
+func newOutput(card *Card, c connector, mode modeInfo, crtc uint32) (*Output, error) {
-	Name                 string
+	log := card.log
-	Monitor              Monitor
+	o := &Output{fd: card.fd, flipped: card.flips[crtc], crtc: crtc, conn: c, mode: mode, log: log, monitor: readMonitor(card.path, c.name)}
-	Width, Height        int
+	var err error
-	RefreshMilli         int
+	if o.saved, err = getCrtc(card.fd, crtc); err != nil {
-	PhysicalW, PhysicalH int // millimetres
-}
-// Open picks a connector on the card fd according to want and allocates buffers.
-func Open(fd int, card string, want Want, log zerowrap.Logger) (*Output, error) {
-	crtcs, ids, err := resources(fd)
-	if err != nil {
-		return nil, err
-	}
-	var conns []connector
-	for _, id := range ids {
-		c, err := readConnector(fd, id)
-		if err != nil {
-			log.Warn().Err(err).Uint32("connector", id).Msg("read connector")
-			continue
-		}
-		ev := log.Info().Str("connector", c.name).Bool("connected", c.connected)
-		if c.connected {
-			mon := readMonitor(card, c.name)
-			modes := make([]string, 0, len(c.modes))
-			for _, m := range c.modes {
-				modes = append(modes, m.String())
-			}
-			ev = ev.Str("make", mon.Make).Str("model", mon.Model).Int("mm_w", c.mmW).Int("mm_h", c.mmH).Strs("modes", modes)
-		}
-		ev.Msg("connector")
-		conns = append(conns, c)
-	}
-	c, mode, err := pickConnector(conns, want)
-	if err != nil {
-		return nil, fmt.Errorf("%s: %w", card, err)
-	}
-	crtc, err := pickCrtc(fd, c, crtcs)
-	if err != nil {
-		return nil, err
-	}
-	o := &Output{fd: fd, crtc: crtc, conn: c, mode: mode, log: log, monitor: readMonitor(card, c.name)}
-	if want.Name != "" && want.Name != c.name {
-		log.Warn().Str("wanted", want.Name).Str("using", c.name).Msg("configured output not connected")
-	}
-	if o.saved, err = getCrtc(fd, crtc); err != nil {
 		log.Warn().Err(err).Uint32("crtc", crtc).Msg("save crtc; it will not be restored on exit")
 	}
 	for i := range o.bufs {
-		if o.bufs[i], err = newDumb(fd, o.Width(), o.Height()); err != nil {
+		if o.bufs[i], err = newDumb(card.fd, o.Width(), o.Height()); err != nil {
 			o.Close()
 			return nil, err
 		}
 	}
-	if o.cursor, err = newCursor(fd, crtc, slices.Index(crtcs, crtc)); err != nil {
+	if o.cursor, err = newCursor(card.fd, crtc, slices.Index(card.crtcs, crtc)); err != nil {
-		log.Warn().Err(err).Msg("no hardware cursor")
+		log.Warn().Err(err).Str("connector", c.name).Msg("no hardware cursor")
 	}
-	log.Info().Str("card", card).Str("connector", c.name).Str("mode", mode.String()).Str("make", o.monitor.Make).Str("model", o.monitor.Model).Uint32("crtc", crtc).Msg("output")
+	log.Info().Str("card", card.path).Str("connector", c.name).Str("mode", mode.String()).Str("make", o.monitor.Make).Str("model", o.monitor.Model).Uint32("crtc", crtc).Msg("output")
 	return o, nil
 }
 // Cursor is the hardware cursor, or nil when the driver has none.
 func (o *Output) Cursor() *Cursor { return o.cursor }
-// Info returns the chosen connector, monitor and mode.
+// Info describes the output for core and clients. Unknown EDID fields are empty.
-func (o *Output) Info() Info {
+func (o *Output) Info() ports.OutputInfo {
-	return Info{Name: o.conn.name, Monitor: o.monitor, Width: o.Width(), Height: o.Height(), RefreshMilli: o.mode.refreshMilli(), PhysicalW: o.conn.mmW, PhysicalH: o.conn.mmH}
+	known := func(v string) string {
+		if v == "Unknown" {
+			return ""
+		}
+		return v
+	}
+	return ports.OutputInfo{Name: o.conn.name, Make: known(o.monitor.Make), Model: known(o.monitor.Model), Serial: o.monitor.Serial, Width: o.Width(), Height: o.Height(), RefreshMilli: o.mode.refreshMilli(), PhysicalW: o.conn.mmW, PhysicalH: o.conn.mmH}
 }
 func (o *Output) Width() int  { return int(o.mode.HDisplay) }
 	return nil
 }
-// Close restores the CRTC state found at startup and frees buffers.
+// Close restores the CRTC state found at startup, when it had a mode, and
+// frees buffers.
 func (o *Output) Close() {
 	if o.cursor != nil {
 		o.cursor.close()
 		return fmt.Errorf("create renderer: %w", err)
 	}
 	defer r.Close()
-	if err := o.modeset(); err != nil {
+	// The seat sends its state first; while switched away (e.g. a monitor
-		return err
+	// plugged in on another VT) the modeset waits for the enable.
+	enabled := true
+	select {
+	case enabled = <-active:
+	default:
+	}
+	if enabled {
+		if err := o.modeset(); err != nil {
+			return err
+		}
 	}
-	events := make(chan int, 4)
-	evErr := make(chan error, 1)
-	evCtx, stop := context.WithCancel(ctx)
-	var reader sync.WaitGroup
-	reader.Go(func() { o.readEvents(evCtx, events, evErr) })
-	// Join the reader before the card fd can be closed by the caller.
-	defer func() { stop(); reader.Wait() }()
 	surfaces := make(map[ports.WindowID]ports.SurfaceContent)
 	var scene ports.Scene
-	haveScene, dirty, enabled := false, false, true
+	haveScene, dirty := false, false
 	cursorScale := -1.0 // not loaded yet
 	frame := 0
 	stats := time.NewTicker(10 * time.Second)
 		select {
 		case <-ctx.Done():
 			return nil
-		case err := <-evErr:
-			return err
 		case on := <-active:
 			// Modeset on every enable: a fast disable+enable can coalesce to one true.
 			if on {
 			}
 			enabled = on
 			o.log.Info().Bool("enabled", on).Msg("output")
-		case n := <-events:
+		case n := <-o.flipped:
 			if !o.pending {
 				continue // stale event from before a modeset
 			}
 	}
 	o.log.Info().Float64("scale", scale).Int("w", img.W).Int("h", img.H).Msg("cursor image")
 }
-func (o *Output) readEvents(ctx context.Context, events chan<- int, errs chan<- error) {
-	buf := make([]byte, 1024)
-	for ctx.Err() == nil {
-		fds := []unix.PollFd{{Fd: int32(o.fd), Events: unix.POLLIN}}
-		n, err := unix.Poll(fds, 100)
-		if err != nil && !errors.Is(err, unix.EINTR) {
-			errs <- fmt.Errorf("drm poll: %w", err)
-			return
-		}
-		if n <= 0 {
-			continue
-		}
-		m, err := unix.Read(o.fd, buf)
-		if err != nil {
-			if errors.Is(err, unix.EINTR) || errors.Is(err, unix.EAGAIN) {
-				continue
-			}
-			errs <- fmt.Errorf("drm read: %w", err)
-			return
-		}
-		if c := countFlipEvents(buf[:m]); c > 0 {
-			select {
-			case events <- c:
-			case <-ctx.Done():
-				return
-			}
-		}
-	}
-}

M internal/adapters/headless/cursor.go +15 -4

 // Cursor is the software cursor drawn into screenshots; it plays the role of
 // the DRM cursor plane. Move is called from the input goroutine.
 type Cursor struct {
-	mu   sync.Mutex
+	mu     sync.Mutex
-	x, y float64
+	x, y   float64
-	img  ports.CursorImage
+	img    ports.CursorImage
+	hidden bool
 }
 func (c *Cursor) Move(x, y float64) {
 	c.mu.Lock()
-	c.x, c.y = x, y
+	c.x, c.y, c.hidden = x, y, false
+	c.mu.Unlock()
+}
+// Hide stops drawing the cursor until the next move.
+func (c *Cursor) Hide() {
+	c.mu.Lock()
+	c.hidden = true
 	c.mu.Unlock()
 }
 func (c *Cursor) draw(dst *image.RGBA) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
+	if c.hidden {
+		return
+	}
 	img := c.img
 	ox, oy := int(c.x)-img.HotX, int(c.y)-img.HotY
 	b := dst.Bounds()

M internal/adapters/headlessinput/input.go +9 -5

 )
 // Run owns the keymap and converts script lines into input events. A keymap
-// received on keymaps replaces the current one, which is closed.
+// received on keymaps replaces the current one, which is closed. Scripted
-// moveCursor, when set, places the software cursor on every scripted move.
+// moves are global logical coordinates; moveCursor, when set, places the
-func Run(ctx context.Context, km *xkb.Keymap, keymaps <-chan *xkb.Keymap, script <-chan string, input chan<- ports.InputEvent, moveCursor func(x, y float64), log zerowrap.Logger) error {
+// software cursor of the output under them (physical position on it), using
+// the latest layout from layouts.
+func Run(ctx context.Context, km *xkb.Keymap, keymaps <-chan *xkb.Keymap, script <-chan string, input chan<- ports.InputEvent, layouts <-chan ports.Layout, moveCursor func(output string, x, y float64), log zerowrap.Logger) error {
+	var layout ports.Layout
 	defer func() { km.Close() }()
 	emit := func(code uint32, down bool) error {
 		ev := km.Key(code, down, uint32(time.Now().UnixMilli()))
 			km.Close()
 			km = next
 			log.Info().Msg("keymap replaced")
+		case layout = <-layouts:
 		case line, ok := <-script:
 			if !ok {
 				return nil
 					x, ex := strconv.ParseFloat(fields[1], 64)
 					y, ey := strconv.ParseFloat(fields[2], 64)
 					if ex == nil && ey == nil && !math.IsNaN(x) && !math.IsNaN(y) && !math.IsInf(x, 0) && !math.IsInf(y, 0) {
-						if moveCursor != nil {
+						if o, ok := layout.At(x, y); ok && moveCursor != nil {
-							moveCursor(x, y)
+							moveCursor(o.Info.Name, (x-float64(o.X))*o.Scale, (y-float64(o.Y))*o.Scale)
 						}
 						if err := sendPointer(ports.PointerMotion{X: x, Y: y, TimeMsec: now}); err != nil {
 							return err

M internal/adapters/headlessinput/input_test.go +2 -2


@@ -31,7 +31,7 @@ func TestScript(t *testing.T) {
31		script <- tt.line	31		script <- tt.line
32		close(script)	32		close(script)
33		input := make(chan ports.InputEvent, 32)	33		input := make(chan ports.InputEvent, 32)
34	-	if err := Run(context.Background(), km, nil, script, input, nil, logging.For(context.Background(), "input")); err != nil {	34	+	if err := Run(context.Background(), km, nil, script, input, nil, nil, logging.For(context.Background(), "input")); err != nil {
35		t.Fatal(err)	35		t.Fatal(err)
36		}	36		}
37		if len(input) != len(tt.names) {	37		if len(input) != len(tt.names) {

@@ -67,7 +67,7 @@ func TestPointerScript(t *testing.T) {
67		}	67		}
68		close(script)	68		close(script)
69		input := make(chan ports.InputEvent, 8)	69		input := make(chan ports.InputEvent, 8)
70	-	if err := Run(context.Background(), km, nil, script, input, nil, logging.For(context.Background(), "input")); err != nil {	70	+	if err := Run(context.Background(), km, nil, script, input, nil, nil, logging.For(context.Background(), "input")); err != nil {
71		t.Fatal(err)	71		t.Fatal(err)
72		}	72		}
73		if len(input) != 5 {	73		if len(input) != 5 {

M internal/adapters/libinput/libinput.go +71 -23

 	SeatName string
 	Keymap   *xkb.Keymap
 	// Keymaps replaces Keymap live; Run takes ownership and closes the old one.
-	Keymaps       <-chan *xkb.Keymap
+	Keymaps <-chan *xkb.Keymap
-	Width, Height int
+	// Layout is the initial output layout; Layouts replaces it live.
-	Active        <-chan bool
+	Layout  ports.Layout
-	// MoveCursor, when set, places the hardware cursor at the new physical
+	Layouts <-chan ports.Layout
-	// position as soon as motion is read, before core sees the event.
+	Active  <-chan bool
-	MoveCursor func(x, y float64)
+	// MoveCursor, when set, places the hardware cursor as soon as motion is
+	// read, before core sees the event: the output under the pointer and
+	// the physical position on it.
+	MoveCursor func(output string, x, y float64)
 	Log        zerowrap.Logger
 }
 	if assignSeat(li, name) != 0 {
 		return fmt.Errorf("libinput_udev_assign_seat %s failed", name)
 	}
-	p := pointer{w: float64(opts.Width), h: float64(opts.Height)}
+	p := newPointer(opts.Layout)
-	p.x, p.y = p.w/2, p.h/2
+	p.moved(opts.MoveCursor)
-	if opts.MoveCursor != nil {
-		opts.MoveCursor(p.x, p.y)
-	}
 	fd := getFD(li)
 	fwd := newForwarder()
 	fwdCtx, stopFwd := context.WithCancel(ctx)
 			opts.Keymap.Close()
 			opts.Keymap = km
 			opts.Log.Info().Msg("keymap replaced")
+		case l := <-opts.Layouts:
+			p.setLayout(l)
+			p.moved(opts.MoveCursor)
 		default:
 		}
 		fds := []unix.PollFd{{Fd: fd, Events: unix.POLLIN}}
 			opts.Log.Warn().Msg("libinput_dispatch failed")
 		}
 		for ev := getEvent(li); ev != 0; ev = getEvent(li) {
-			out, err := translate(ev, opts, &p)
+			out, err := translate(ev, opts, p)
 			eventDestroy(ev)
 			if err != nil {
 				return err
 	case evPointerMotion:
 		pe := pointerEvent(ev)
 		x, y := p.move(pointerDX(pe), pointerDY(pe))
-		if opts.MoveCursor != nil {
+		p.moved(opts.MoveCursor)
-			opts.MoveCursor(x, y)
-		}
 		log.Debug().Float64("x", x).Float64("y", y).Msg("pointer")
 		return ports.PointerMotion{X: x, Y: y, TimeMsec: now}, nil
 	case evPointerAbs:
+		// Absolute devices (tablets, VMs) map to the whole layout.
 		pe := pointerEvent(ev)
-		x, y := p.set(pointerAbsX(pe, uint32(p.w)), pointerAbsY(pe, uint32(p.h)))
+		b := p.bounds()
-		if opts.MoveCursor != nil {
+		x, y := p.set(float64(b.X)+pointerAbsX(pe, uint32(b.W)), float64(b.Y)+pointerAbsY(pe, uint32(b.H)))
-			opts.MoveCursor(x, y)
+		p.moved(opts.MoveCursor)
-		}
 		return ports.PointerMotion{X: x, Y: y, TimeMsec: now}, nil
 	case evPointerButton:
 		pe := pointerEvent(ev)
 	return hotkeyNone, 0
 }
-type pointer struct{ x, y, w, h float64 }
+// pointer tracks the cursor in global logical coordinates. Relative motion
+// is divided by the scale of the output under the pointer, so it moves the
+// same number of physical pixels on every output.
+type pointer struct {
+	x, y   float64
+	layout ports.Layout
+}
+// newPointer starts at the centre of the first output.
+func newPointer(l ports.Layout) *pointer {
+	p := &pointer{layout: l}
+	if len(l) > 0 {
+		p.x, p.y = float64(l[0].X)+float64(l[0].Width)/2, float64(l[0].Y)+float64(l[0].Height)/2
+	}
+	return p
+}
-func (p *pointer) move(dx, dy float64) (float64, float64) { return p.set(p.x+dx, p.y+dy) }
+// setLayout keeps the pointer where it is, or clamps it onto an output.
+func (p *pointer) setLayout(l ports.Layout) {
+	p.layout = l
+	p.x, p.y = l.Clamp(p.x, p.y, p.x, p.y)
+}
+func (p *pointer) scale() float64 {
+	if o, ok := p.layout.At(p.x, p.y); ok && o.Scale > 0 {
+		return o.Scale
+	}
+	return 1
+}
+func (p *pointer) move(dx, dy float64) (float64, float64) {
+	s := p.scale()
+	return p.set(p.x+dx/s, p.y+dy/s)
+}
 func (p *pointer) set(x, y float64) (float64, float64) {
-	p.x = min(max(x, 0), p.w-1)
+	p.x, p.y = p.layout.Clamp(p.x, p.y, x, y)
-	p.y = min(max(y, 0), p.h-1)
 	return p.x, p.y
 }
+// bounds is the rectangle holding every output.
+func (p *pointer) bounds() ports.Rect {
+	var r ports.Rect
+	for _, o := range p.layout {
+		r.W = max(r.W, o.X+o.Width)
+		r.H = max(r.H, o.Y+o.Height)
+	}
+	return r
+}
+// moved reports the physical position on the output under the pointer.
+func (p *pointer) moved(move func(output string, x, y float64)) {
+	if o, ok := p.layout.At(p.x, p.y); ok && move != nil {
+		move(o.Info.Name, (p.x-float64(o.X))*o.Scale, (p.y-float64(o.Y))*o.Scale)
+	}
+}

M internal/adapters/libinput/libinput_test.go +25 -4


@@ -29,12 +29,33 @@ func TestHotkey(t *testing.T) {
29		}	29		}
30		}	30		}
31			31
32	-	func TestPointerClamp(t *testing.T) {	32	+	func TestPointerAcrossOutputs(t *testing.T) {
33	-	p := pointer{x: 10, y: 10, w: 100, h: 50}	33	+	layout := ports.Layout{
34	-	if x, y := p.move(-20, 100); x != 0 \|\| y != 49 {	34	+	{Info: ports.OutputInfo{Name: "A"}, Width: 100, Height: 50, Scale: 1},
			35	+	{Info: ports.OutputInfo{Name: "B"}, X: 100, Width: 200, Height: 100, Scale: 2},
			36	+	}
			37	+	p := newPointer(layout)
			38	+	if p.x != 50 \|\| p.y != 25 {
			39	+	t.Fatal(p.x, p.y)
			40	+	}
			41	+	// Off the bottom of A: clamped to A.
			42	+	if x, y := p.move(-80, 100); x != 0 \|\| y != 49 {
35		t.Fatalf("got %v %v", x, y)	43		t.Fatalf("got %v %v", x, y)
36		}	44		}
37	-	if x, y := p.move(30.5, -5); x != 30.5 \|\| y != 44 {	45	+	// Into B, where deltas count in physical pixels (scale 2).
			46	+	p.set(150, 20)
			47	+	if x, y := p.move(20, 10); x != 160 \|\| y != 25 {
38		t.Fatalf("got %v %v", x, y)	48		t.Fatalf("got %v %v", x, y)
39		}	49		}
			50	+	var out string
			51	+	var px, py float64
			52	+	p.moved(func(o string, x, y float64) { out, px, py = o, x, y })
			53	+	if out != "B" \|\| px != 120 \|\| py != 50 {
			54	+	t.Fatal(out, px, py)
			55	+	}
			56	+	// B unplugged: the pointer lands on A.
			57	+	p.setLayout(layout[:1])
			58	+	if p.x != 99 \|\| p.y != 25 {
			59	+	t.Fatal(p.x, p.y)
			60	+	}
40		}	61		}

M internal/adapters/seat/seat.go +8 -0


@@ -6,6 +6,7 @@ import (
6	"errors"	6		"errors"
7	"fmt"	7		"fmt"
8	"runtime"	8		"runtime"
		9	+	"slices"
9	"sync"	10		"sync"
10	"unsafe"	11		"unsafe"
11		12

@@ -138,6 +139,13 @@ func (s *Seat) Subscribe() <-chan bool {
138	return c	139		return c
139	}	140		}
140		141
		142	+	// Unsubscribe stops sending to a channel from Subscribe.
		143	+	func (s *Seat) Unsubscribe(c <-chan bool) {
		144	+	s.mu.Lock()
		145	+	defer s.mu.Unlock()
		146	+	s.subs = slices.DeleteFunc(s.subs, func(x chan bool) bool { return x == c })
		147	+	}
		148	+
141	func (s *Seat) dispatchLocked(ctx context.Context, timeoutMs int) error {	149		func (s *Seat) dispatchLocked(ctx context.Context, timeoutMs int) error {
142	if ctx.Err() != nil {	150		if ctx.Err() != nil {
143	return ctx.Err()	151		return ctx.Err()

M internal/adapters/wayland/commands_test.go +1 -1


@@ -41,7 +41,7 @@ func TestDrainCommandsCollapsesMotion(t *testing.T) {
41		// must be absorbed without core blocking.	41		// must be absorbed without core blocking.
42		func TestCommandThroughput(t *testing.T) {	42		func TestCommandThroughput(t *testing.T) {
43		cmds := make(chan ports.ClientCommand, 32)	43		cmds := make(chan ports.ClientCommand, 32)
44	-	s, err := New(Options{RuntimeDir: t.TempDir(), OutputWidth: 1920, OutputHeight: 1080}, Channels{Commands: cmds}, logging.For(context.Background(), "wayland"))	44	+	s, err := New(Options{RuntimeDir: t.TempDir(), Outputs: testOutputs}, Channels{Commands: cmds}, logging.For(context.Background(), "wayland"))
45		if err != nil {	45		if err != nil {
46		t.Fatal(err)	46		t.Fatal(err)
47		}	47		}

M internal/adapters/wayland/globals.go +3 -31


@@ -11,8 +11,8 @@ import (
11		func registerGlobals(d server.Display, o Options, s Server) error {	11		func registerGlobals(d server.Display, o Options, s Server) error {
12		for _, register := range []func() error{	12		for _, register := range []func() error{
13		func() error { return registerXDG(d, s) },	13		func() error { return registerXDG(d, s) },
14	-	func() error { return registerLayer(d, o, s) },	14	+	func() error { return registerLayer(d, s) },
15	-	func() error { return registerXDGOutput(d, o, s) },	15	+	func() error { return registerXDGOutput(d, s) },
16		func() error { return registerDecoration(d, s) },	16		func() error { return registerDecoration(d, s) },
17		func() error { return registerScale(d, s) },	17		func() error { return registerScale(d, s) },
18		func() error {	18		func() error {

@@ -32,30 +32,6 @@ func registerGlobals(d server.Display, o Options, s Server) error {
32		}	32		}
33		})	33		})
34		},	34		},
35	-	func() error {
36	-	return wayland.NewOutputGlobal(d, 4, func(c server.Client, v, id uint32) {
37	-	r, e := wayland.NewOutput(c, int32(v), id, output{})
38	-	if e != nil {
39	-	return
40	-	}
41	-	s.scale.outputs = append(s.scale.outputs, r)
42	-	r.OnDestroy = func() { s.scale.outputs = removeItem(s.scale.outputs, r) }
43	-	info := o.output()
44	-	r.SendGeometry(0, 0, int32(info.PhysicalW), int32(info.PhysicalH), 0, info.Make, info.Model, 0)
45	-	// The mode stays physical; the scale tells clients how to divide it.
46	-	r.SendMode(3, int32(o.OutputWidth), int32(o.OutputHeight), int32(info.RefreshMilli))
47	-	if v >= 2 {
48	-	r.SendScale(s.scale.integerScale())
49	-	}
50	-	if v >= 4 {
51	-	r.SendName(info.Name)
52	-	r.SendDescription(info.Description)
53	-	}
54	-	if v >= 2 {
55	-	r.SendDone()
56	-	}
57	-	})
58	-	},
59		func() error {	35		func() error {
60		return wayland.NewSeatGlobal(d, 7, func(c server.Client, v, id uint32) {	36		return wayland.NewSeatGlobal(d, 7, func(c server.Client, v, id uint32) {
61		r, e := wayland.NewSeat(c, int32(v), id, seat{s})	37		r, e := wayland.NewSeat(c, int32(v), id, seat{s})

@@ -89,7 +65,7 @@ func (c compositor) CreateSurface(r *wayland.Compositor, id uint32) {
89		if w, err := wayland.NewSurface(r.Client(), r.Version(), id, state); err == nil {	65		if w, err := wayland.NewSurface(r.Client(), r.Version(), id, state); err == nil {
90		state.wl = w	66		state.wl = w
91		c.server.surfaces[w.Resource] = state	67		c.server.surfaces[w.Resource] = state
92	-	c.server.sendSurfaceScale(w)	68	+	state.sendScale()
93		w.OnDestroy = func() { delete(c.server.surfaces, w.Resource); state.Destroy(w) }	69		w.OnDestroy = func() { delete(c.server.surfaces, w.Resource); state.Destroy(w) }
94		}	70		}
95		}	71		}

@@ -247,10 +223,6 @@ func (b *buffer) content(id ports.WindowID) (content ports.SurfaceContent, ok bo
247		return ports.SurfaceContent{ID: id, Width: b.width, Height: b.height, Stride: b.stride, Opaque: b.format == uint32(wayland.ShmFormatXrgb8888), Pixels: pixels}, true	223		return ports.SurfaceContent{ID: id, Width: b.width, Height: b.height, Stride: b.stride, Opaque: b.format == uint32(wayland.ShmFormatXrgb8888), Pixels: pixels}, true
248		}	224		}
249			225
250	-	type output struct{}
251	-
252	-	func (output) Release(*wayland.Output) {}
253	-
254		type seat struct{ server *Server }	226		type seat struct{ server *Server }
255			227
256		func (h seat) GetPointer(r *wayland.Seat, id uint32) {	228		func (h seat) GetPointer(r *wayland.Seat, id uint32) {

M internal/adapters/wayland/keyboard_test.go +1 -1


@@ -32,7 +32,7 @@ func keyboardServer(t testing.T, setup ...func(Server)) (*Server, chan ports.C
32		dir := t.TempDir()	32		dir := t.TempDir()
33		events := make(chan ports.ClientEvent, 16)	33		events := make(chan ports.ClientEvent, 16)
34		commands := make(chan ports.ClientCommand, 32)	34		commands := make(chan ports.ClientCommand, 32)
35	-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080, Keymap: keymapText(t), RepeatRate: 25, RepeatDelay: 600}, Channels{Events: events, Commands: commands}, logging.For(context.Background(), "wayland"))	35	+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs, Keymap: keymapText(t), RepeatRate: 25, RepeatDelay: 600}, Channels{Events: events, Commands: commands}, logging.For(context.Background(), "wayland"))
36		if err != nil {	36		if err != nil {
37		t.Fatal(err)	37		t.Fatal(err)
38		}	38		}

M internal/adapters/wayland/layer.go +39 -5

 	pending, current          layerState
 	configured, acked, mapped bool
 	serials                   []uint32
+	// output is the output the client asked for, else the focused one at
+	// creation. The surface is closed when it is unplugged.
+	output *output
+	closed bool // output gone: commits are ignored until destroy
 }
-func registerLayer(d *server.Display, o Options, s *Server) error {
+func registerLayer(d *server.Display, s *Server) error {
 	return wlrlayershell.NewZwlrLayerShellV1Global(d, 4, func(c server.Client, v, id uint32) {
 		_, _ = wlrlayershell.NewZwlrLayerShellV1(c, int32(v), id, layerShell{s})
 	})
 }
 func (h layerShell) Destroy(*wlrlayershell.ZwlrLayerShellV1) {}
-func (h layerShell) GetLayerSurface(r *wlrlayershell.ZwlrLayerShellV1, id uint32, w *wayland.Surface, _ *wayland.Output, layer uint32, namespace string) {
+func (h layerShell) GetLayerSurface(r *wlrlayershell.ZwlrLayerShellV1, id uint32, w *wayland.Surface, wl *wayland.Output, layer uint32, namespace string) {
 	if w == nil || h.server.surfaces[w.Resource] == nil {
 		return
 	}
 		r.PostError(uint32(wlrlayershell.ZwlrLayerShellV1ErrorInvalidLayer), "invalid layer")
 		return
 	}
-	l := &layerSurface{shell: h, surface: state, id: h.server.nextWindow, namespace: namespace}
+	out := h.server.outputOf(wl)
+	gone := wl != nil && out == nil // its output was unplugged
+	if wl == nil {
+		out = h.server.outputByName("")
+	}
+	l := &layerSurface{shell: h, surface: state, id: h.server.nextWindow, namespace: namespace, output: out}
 	l.pending.layer = ports.Layer(layer)
 	resource, err := wlrlayershell.NewZwlrLayerSurfaceV1(r.Client(), r.Version(), id, l)
 	if err != nil {
 	state.layer = l
 	state.role = l.commit
 	h.server.layers[l.id] = l
+	if gone {
+		l.close()
+	}
 	resource.OnDestroy = func() {
 		l.unmap()
 		delete(h.server.layers, l.id)
 	l.shell.server.layerChanged()
 	l.shell.server.emitContent(ports.SurfaceContent{ID: l.id})
 }
+// close tells the client its output is gone; the surface stays unmapped
+// until the client destroys it.
+func (l *layerSurface) close() {
+	l.unmap()
+	l.output = nil
+	l.closed = true
+	if l.resource.Resource.Alive() {
+		l.resource.SendClosed()
+	}
+}
 func (s *Server) layerChanged() {
 	list := make([]ports.LayerSurface, 0)
 	for _, l := range s.layers {
 			continue
 		}
 		v := ports.LayerSurface{ID: l.id, Layer: l.current.layer, Anchor: l.current.anchor, ExclusiveZone: l.current.zone, Margin: l.current.margin, Namespace: l.namespace, Keyboard: l.current.keyboard}
+		if l.output != nil {
+			v.Output = l.output.name()
+		}
 		if l.surface.current != nil {
 			if b := s.buffers[l.surface.current.Resource]; b != nil {
 				v.Width, v.Height = l.surface.logicalSize(b.width, b.height)
 // the logical output size.
 func (l *layerSurface) sendConfigure() {
 	w, h := l.current.width, l.current.height
+	var ow, oh int
+	if l.output != nil {
+		ow, oh = l.output.place.Width, l.output.place.Height
+	}
 	if w == 0 {
-		w = uint32(l.shell.server.scale.width)
+		w = uint32(ow)
 	}
 	if h == 0 {
-		h = uint32(l.shell.server.scale.height)
+		h = uint32(oh)
 	}
 	l.shell.server.serial++
 	l.resource.SendConfigure(l.shell.server.serial, w, h)
 		delete(l.shell.server.layers, l.id)
 		return
 	}
+	if l.closed {
+		return
+	}
 	p := l.pending
 	if (p.width == 0 && p.anchor&(ports.AnchorLeft|ports.AnchorRight) != ports.AnchorLeft|ports.AnchorRight) || (p.height == 0 && p.anchor&(ports.AnchorTop|ports.AnchorBottom) != ports.AnchorTop|ports.AnchorBottom) {
 		l.resource.PostError(uint32(wlrlayershell.ZwlrLayerSurfaceV1ErrorInvalidSize), "zero size requires opposing anchors")

A internal/adapters/wayland/outputs.go +254 -0

@@ -0,0 +1,254 @@
	1	+	package wayland
	2	+
	3	+	import (
	4	+	"math"
	5	+	"strings"
	6	+
	7	+	"github.com/bnema/nefertty/internal/ports"
	8	+	"github.com/bnema/purego-libwayland/protocol/wayland"
	9	+	"github.com/bnema/purego-libwayland/protocol/xdgoutput"
	10	+	"github.com/bnema/purego-libwayland/server"
	11	+	)
	12	+
	13	+	// Outputs. Core sends the global layout (ports.SetOutputs); each output is
	14	+	// one wl_output global, removed when the display is unplugged. Every size
	15	+	// sent to clients (configures, xdg-output, layer configures, pointer
	16	+	// coordinates) is logical. Clients that bind wp_fractional_scale_v1 get the
	17	+	// exact scale of their output in 1/120 steps and draw at physical size
	18	+	// through wp_viewporter; others get wl_output.scale rounded up and the
	19	+	// renderer downscales.
	20	+
	21	+	// output is one advertised display and the resources clients bound to it.
	22	+	type output struct {
	23	+	place ports.OutputPlacement
	24	+	global *server.Global
	25	+	resources []*wayland.Output
	26	+	xdgOutputs []*xdgoutput.ZxdgOutputV1
	27	+	}
	28	+
	29	+	func (o *output) name() string { return o.place.Info.Name }
	30	+
	31	+	// integerScale is wl_output.scale: the fractional scale rounded up.
	32	+	func integerScale(scale float64) int32 { return int32(math.Ceil(max(scale, 1) - 1e-9)) }
	33	+
	34	+	func (o *output) description() string {
	35	+	i := o.place.Info
	36	+	return strings.Join(strings.Fields(i.Make+" "+i.Model+" "+i.Serial+" ("+i.Name+")"), " ")
	37	+	}
	38	+
	39	+	// sendAll sends the full wl_output state, then done (v2+).
	40	+	func (o output) sendAll(r wayland.Output) {
	41	+	i := o.place.Info
	42	+	make, model := i.Make, i.Model
	43	+	if make == "" {
	44	+	make, model = "nefertty", "headless"
	45	+	}
	46	+	refresh := i.RefreshMilli
	47	+	if refresh == 0 {
	48	+	refresh = 60000
	49	+	}
	50	+	r.SendGeometry(int32(o.place.X), int32(o.place.Y), int32(i.PhysicalW), int32(i.PhysicalH), 0, make, model, 0)
	51	+	// The mode stays physical; the scale tells clients how to divide it.
	52	+	r.SendMode(3, int32(i.Width), int32(i.Height), int32(refresh))
	53	+	if r.Version() >= 2 {
	54	+	r.SendScale(integerScale(o.place.Scale))
	55	+	}
	56	+	if r.Version() >= 4 {
	57	+	r.SendName(i.Name)
	58	+	r.SendDescription(o.description())
	59	+	}
	60	+	if r.Version() >= 2 {
	61	+	r.SendDone()
	62	+	}
	63	+	}
	64	+
	65	+	func (o output) sendXDG(x xdgoutput.ZxdgOutputV1, withName bool) {
	66	+	x.SendLogicalPosition(int32(o.place.X), int32(o.place.Y))
	67	+	x.SendLogicalSize(int32(o.place.Width), int32(o.place.Height))
	68	+	if withName && x.Version() >= 2 {
	69	+	x.SendName(o.name())
	70	+	x.SendDescription(o.description())
	71	+	}
	72	+	}
	73	+
	74	+	// outputOf returns the output a wl_output resource belongs to, or nil for a
	75	+	// removed one.
	76	+	func (s Server) outputOf(r wayland.Output) *output {
	77	+	if r == nil {
	78	+	return nil
	79	+	}
	80	+	for _, o := range s.outputs {
	81	+	for _, v := range o.resources {
	82	+	if v.Resource == r.Resource {
	83	+	return o
	84	+	}
	85	+	}
	86	+	}
	87	+	return nil
	88	+	}
	89	+
	90	+	// outputByName returns the output with that connector, else the focused one,
	91	+	// else the first; nil when there is none.
	92	+	func (s Server) outputByName(name string) output {
	93	+	var first, focused *output
	94	+	for _, o := range s.outputs {
	95	+	if o.name() == name {
	96	+	return o
	97	+	}
	98	+	if first == nil {
	99	+	first = o
	100	+	}
	101	+	if o.name() == s.focusedOutput {
	102	+	focused = o
	103	+	}
	104	+	}
	105	+	if focused != nil {
	106	+	return focused
	107	+	}
	108	+	return first
	109	+	}
	110	+
	111	+	// addOutput advertises a new wl_output global.
	112	+	func (s *Server) addOutput(p ports.OutputPlacement) {
	113	+	o := &output{place: p}
	114	+	g, err := s.display.AddGlobal(wayland.OutputInterface, 4, func(c server.Client, v, id uint32) {
	115	+	r, err := wayland.NewOutput(c, int32(v), id, outputHandler{})
	116	+	if err != nil {
	117	+	return
	118	+	}
	119	+	// A client may bind a global just removed: it gets the last state
	120	+	// and no updates.
	121	+	o.resources = append(o.resources, r)
	122	+	r.OnDestroy = func() { o.resources = removeItem(o.resources, r) }
	123	+	o.sendAll(r)
	124	+	})
	125	+	if err != nil {
	126	+	s.log.Warn().Err(err).Str("output", p.Info.Name).Msg("add wl_output")
	127	+	return
	128	+	}
	129	+	o.global = g
	130	+	s.outputs = append(s.outputs, o)
	131	+	s.log.Info().Str("output", p.Info.Name).Int("x", p.X).Int("w", p.Width).Int("h", p.Height).Float64("scale", p.Scale).Msg("output added")
	132	+	}
	133	+
	134	+	// setOutputs applies the global layout from core: new outputs are
	135	+	// advertised, gone ones withdrawn (their layer surfaces are closed), and
	136	+	// changed ones resent.
	137	+	func (s *Server) setOutputs(c ports.SetOutputs) {
	138	+	s.focusedOutput = c.Focused
	139	+	want := map[string]ports.OutputPlacement{}
	140	+	for _, p := range c.Outputs {
	141	+	want[p.Info.Name] = p
	142	+	}
	143	+	kept := s.outputs[:0]
	144	+	for _, o := range s.outputs {
	145	+	if _, ok := want[o.name()]; ok {
	146	+	kept = append(kept, o)
	147	+	continue
	148	+	}
	149	+	o.global.Remove()
	150	+	s.log.Info().Str("output", o.name()).Msg("output removed")
	151	+	for _, l := range s.layers {
	152	+	if l.output == o {
	153	+	l.close()
	154	+	}
	155	+	}
	156	+	for _, surf := range s.surfaces {
	157	+	surf.leave(o)
	158	+	}
	159	+	}
	160	+	s.outputs = kept
	161	+	for _, p := range c.Outputs {
	162	+	o := s.outputByNameExact(p.Info.Name)
	163	+	if o == nil {
	164	+	s.addOutput(p)
	165	+	continue
	166	+	}
	167	+	if o.place == p {
	168	+	continue
	169	+	}
	170	+	scaleChanged := o.place.Scale != p.Scale
	171	+	o.place = p
	172	+	for _, r := range o.resources {
	173	+	o.sendAll(r)
	174	+	}
	175	+	for _, x := range o.xdgOutputs {
	176	+	o.sendXDG(x, false)
	177	+	if x.Version() < 3 {
	178	+	x.SendDone()
	179	+	}
	180	+	}
	181	+	if scaleChanged {
	182	+	s.log.Info().Str("output", p.Info.Name).Float64("scale", p.Scale).Int("w", p.Width).Int("h", p.Height).Msg("output scale")
	183	+	}
	184	+	}
	185	+	// Surfaces follow the scale of their output.
	186	+	for _, surf := range s.surfaces {
	187	+	surf.sendScale()
	188	+	}
	189	+	// Layer surfaces sized from the output follow its new logical size.
	190	+	adopted := false
	191	+	for _, l := range s.layers {
	192	+	if l.output == nil && !l.closed {
	193	+	// Created before any output: it takes the focused one.
	194	+	if l.output = s.outputByName(""); l.output != nil && l.configured {
	195	+	l.sendConfigure()
	196	+	adopted = adopted \|\| l.mapped
	197	+	continue
	198	+	}
	199	+	}
	200	+	// Uses committed state only: pending requests wait for the client's commit.
	201	+	if l.configured && (l.current.width == 0 \|\| l.current.height == 0) {
	202	+	l.sendConfigure()
	203	+	}
	204	+	}
	205	+	if adopted {
	206	+	s.layerChanged()
	207	+	}
	208	+	}
	209	+
	210	+	func (s Server) outputByNameExact(name string) output {
	211	+	for _, o := range s.outputs {
	212	+	if o.name() == name {
	213	+	return o
	214	+	}
	215	+	}
	216	+	return nil
	217	+	}
	218	+
	219	+	type outputHandler struct{}
	220	+
	221	+	func (outputHandler) Release(*wayland.Output) {}
	222	+
	223	+	func registerXDGOutput(d server.Display, s Server) error {
	224	+	return xdgoutput.NewZxdgOutputManagerV1Global(d, 3, func(c server.Client, v, id uint32) {
	225	+	_, _ = xdgoutput.NewZxdgOutputManagerV1(c, int32(v), id, xdgOutputManager{s})
	226	+	})
	227	+	}
	228	+
	229	+	type xdgOutputManager struct{ server *Server }
	230	+
	231	+	func (xdgOutputManager) Destroy(*xdgoutput.ZxdgOutputManagerV1) {}
	232	+	func (m xdgOutputManager) GetXdgOutput(r xdgoutput.ZxdgOutputManagerV1, id uint32, wl wayland.Output) {
	233	+	x, err := xdgoutput.NewZxdgOutputV1(r.Client(), r.Version(), id, xdgOutput{})
	234	+	if err != nil {
	235	+	return
	236	+	}
	237	+	o := m.server.outputOf(wl)
	238	+	if o == nil {
	239	+	// Removed output: the object stays inert.
	240	+	return
	241	+	}
	242	+	o.xdgOutputs = append(o.xdgOutputs, x)
	243	+	x.OnDestroy = func() { o.xdgOutputs = removeItem(o.xdgOutputs, x) }
	244	+	o.sendXDG(x, true)
	245	+	if r.Version() < 3 \|\| wl.Version() < 2 {
	246	+	x.SendDone()
	247	+	} else {
	248	+	wl.SendDone()
	249	+	}
	250	+	}
	251	+
	252	+	type xdgOutput struct{}
	253	+
	254	+	func (xdgOutput) Destroy(*xdgoutput.ZxdgOutputV1) {}

A internal/adapters/wayland/outputs_test.go +108 -0

@@ -0,0 +1,108 @@
	1	+	package wayland
	2	+
	3	+	import (
	4	+	"testing"
	5	+	"time"
	6	+
	7	+	"github.com/bnema/nefertty/internal/ports"
	8	+	"github.com/bnema/purego-libwayland/protocol/wayland"
	9	+	"github.com/bnema/purego-libwayland/protocol/wlrlayershell"
	10	+	"github.com/bnema/wlturbo"
	11	+	)
	12	+
	13	+	var second = ports.OutputPlacement{Info: ports.OutputInfo{Name: "HEADLESS-2", Width: 1280, Height: 1024}, X: 1920, Width: 1280, Height: 1024, Scale: 1}
	14	+
	15	+	// outputCount counts wl_output globals the client sees.
	16	+	func outputCount(c *wlturbo.Display) int {
	17	+	n := 0
	18	+	for _, g := range c.Registry().GetGlobals() {
	19	+	if g.Interface == "wl_output" {
	20	+	n++
	21	+	}
	22	+	}
	23	+	return n
	24	+	}
	25	+
	26	+	// waitOutputs round-trips until the client sees n wl_output globals.
	27	+	func waitOutputs(t testing.T, c wlturbo.Display, n int) {
	28	+	t.Helper()
	29	+	for deadline := time.Now().Add(2 * time.Second); time.Now().Before(deadline); {
	30	+	if err := c.Roundtrip(); err != nil {
	31	+	t.Fatal(err)
	32	+	}
	33	+	if outputCount(c) == n {
	34	+	return
	35	+	}
	36	+	time.Sleep(5 * time.Millisecond)
	37	+	}
	38	+	t.Fatalf("wl_output globals: %d, want %d", outputCount(c), n)
	39	+	}
	40	+
	41	+	type closedProxy struct {
	42	+	wlturbo.BaseProxy
	43	+	configured chan [3]uint32
	44	+	closed chan struct{}
	45	+	}
	46	+
	47	+	func (p closedProxy) Dispatch(e wlturbo.Event) {
	48	+	switch e.Opcode {
	49	+	case uint16(wlrlayershell.ZwlrLayerSurfaceV1EventConfigure):
	50	+	p.configured <- [3]uint32{e.Uint32(), e.Uint32(), e.Uint32()}
	51	+	case uint16(wlrlayershell.ZwlrLayerSurfaceV1EventClosed):
	52	+	close(p.closed)
	53	+	}
	54	+	}
	55	+
	56	+	func TestOutputHotplugAndLayerOutput(t *testing.T) {
	57	+	s, _, commands, dir := lifecycleServer(t)
	58	+	c := protocolClient(t, s, dir)
	59	+	if outputCount(c) != 1 {
	60	+	t.Fatal(outputCount(c))
	61	+	}
	62	+	commands <- ports.SetOutputs{Outputs: ports.Layout{testOutputs[0], second}, Focused: "HEADLESS-1"}
	63	+	waitOutputs(t, c, 2)
	64	+	// A layer surface on the second output is sized from it.
	65	+	var name uint32
	66	+	for n, g := range c.Registry().GetGlobals() {
	67	+	if g.Interface == "wl_output" && (name == 0 \|\| n > name) {
	68	+	name = n
	69	+	}
	70	+	}
	71	+	out, err := c.Registry().BindID(name, "wl_output", 4)
	72	+	if err != nil {
	73	+	t.Fatal(err)
	74	+	}
	75	+	registerProtocol(t, c, out)
	76	+	comp := bindProtocol(t, c, "wl_compositor")
	77	+	shell := bindProtocol(t, c, "zwlr_layer_shell_v1")
	78	+	surf := c.AllocateID()
	79	+	requestProtocol(t, c, comp, wayland.CompositorRequestCreateSurface, surf)
	80	+	registerProtocol(t, c, surf)
	81	+	layer := c.AllocateID()
	82	+	proxy := &closedProxy{configured: make(chan [3]uint32, 2), closed: make(chan struct{})}
	83	+	proxy.SetID(layer)
	84	+	c.Context().Register(proxy)
	85	+	requestProtocol(t, c, shell, wlrlayershell.ZwlrLayerShellV1RequestGetLayerSurface, layer, surf, out, uint32(ports.LayerTop), "bar")
	86	+	requestProtocol(t, c, layer, wlrlayershell.ZwlrLayerSurfaceV1RequestSetAnchor, uint32(13))
	87	+	requestProtocol(t, c, layer, wlrlayershell.ZwlrLayerSurfaceV1RequestSetSize, uint32(0), uint32(30))
	88	+	requestProtocol(t, c, surf, wayland.SurfaceRequestCommit)
	89	+	if err := c.Roundtrip(); err != nil {
	90	+	t.Fatal(err)
	91	+	}
	92	+	select {
	93	+	case cfg := <-proxy.configured:
	94	+	if cfg[1] != 1280 {
	95	+	t.Fatalf("configure %v", cfg)
	96	+	}
	97	+	case <-time.After(2 * time.Second):
	98	+	t.Fatal("configure timeout")
	99	+	}
	100	+	// Unplugged: the global goes away and the layer surface is closed.
	101	+	commands <- ports.SetOutputs{Outputs: ports.Layout{testOutputs[0]}, Focused: "HEADLESS-1"}
	102	+	waitOutputs(t, c, 1)
	103	+	select {
	104	+	case <-proxy.closed:
	105	+	case <-time.After(2 * time.Second):
	106	+	t.Fatal("layer not closed")
	107	+	}
	108	+	}

M internal/adapters/wayland/scale.go +65 -54


@@ -3,72 +3,79 @@ package wayland
3		import (	3		import (
4		"math"	4		"math"
5			5
6	-	"github.com/bnema/nefertty/internal/ports"
7		"github.com/bnema/purego-libwayland/protocol/fractionalscale"	6		"github.com/bnema/purego-libwayland/protocol/fractionalscale"
8		"github.com/bnema/purego-libwayland/protocol/viewporter"	7		"github.com/bnema/purego-libwayland/protocol/viewporter"
9		"github.com/bnema/purego-libwayland/protocol/wayland"	8		"github.com/bnema/purego-libwayland/protocol/wayland"
10	-	"github.com/bnema/purego-libwayland/protocol/xdgoutput"
11		"github.com/bnema/purego-libwayland/server"	9		"github.com/bnema/purego-libwayland/server"
12		)	10		)
13			11
14	-	// Output scale (HiDPI). Clients that bind wp_fractional_scale_v1 get the exact	12	+	// Surfaces follow the output of their window or layer (the focused output
15	-	// scale in 1/120 steps and draw at physical size through wp_viewporter. Others	13	+	// until they are shown): wl_surface.enter/leave, preferred buffer scale and
16	-	// get wl_output.scale rounded up, draw at that integer, and the renderer	14	+	// fractional scale all come from it.
17	-	// downscales. Every size sent to clients (configures, xdg-output, layer	15	+
18	-	// configures, pointer coordinates) stays logical.	16	+	// outputOfSurface is the output a surface is on: its window's configured
19	-		17	+	// output, its layer output, or the focused one.
20	-	// scaleState is what clients were last told about the output.	18	+	func (s Server) outputOfSurface(surf surface) *output {
21	-	type scaleState struct {	19	+	name := ""
22	-	scale float64	20	+	switch {
23	-	width, height int // logical	21	+	case surf.xdg != nil && surf.xdg.window != nil:
24	-	outputs []*wayland.Output	22	+	name = surf.xdg.window.last.Output
25	-	xdgOutputs []*xdgoutput.ZxdgOutputV1	23	+	case surf.layer != nil && surf.layer.output != nil:
26	-	fractions map[surface]fractionalscale.WpFractionalScaleV1	24	+	return surf.layer.output
			25	+	}
			26	+	return s.outputByName(name)
27		}	27		}
28			28
29	-	// integerScale is wl_output.scale: the fractional scale rounded up.	29	+	// sendScale tells the surface about its output: enter/leave, the integer
30	-	func (st *scaleState) integerScale() int32 { return int32(math.Ceil(st.scale - 1e-9)) }	30	+	// buffer scale (wl_surface v6+) and the fractional scale.
31	-		31	+	func (surf *surface) sendScale() {
32	-	func (s *Server) setOutputScale(c ports.SetOutputScale) {	32	+	s := surf.server
33	-	st := &s.scale	33	+	if surf.destroyed \|\| surf.wl == nil \|\| !surf.wl.Resource.Alive() {
34	-	scaleChanged := c.Scale != st.scale	34	+	return
35	-	st.scale, st.width, st.height = c.Scale, c.Width, c.Height
36	-	s.log.Info().Float64("scale", c.Scale).Int("w", c.Width).Int("h", c.Height).Msg("output scale")
37	-	for _, x := range st.xdgOutputs {
38	-	x.SendLogicalSize(int32(c.Width), int32(c.Height))
39	-	if x.Version() < 3 {
40	-	x.SendDone()
41	-	}
42	-	}
43	-	for _, o := range st.outputs {
44	-	if o.Version() >= 2 {
45	-	o.SendScale(st.integerScale())
46	-	o.SendDone()
47	-	}
48		}	35		}
49	-	if scaleChanged {	36	+	o := s.outputOfSurface(surf)
50	-	for _, surf := range s.surfaces {	37	+	if o != surf.on {
51	-	s.sendSurfaceScale(surf.wl)	38	+	if surf.on != nil {
			39	+	surf.leave(surf.on)
52		}	40		}
53	-	for surf, f := range st.fractions {	41	+	surf.on = o
54	-	if !surf.destroyed {	42	+	if o != nil {
55	-	f.SendPreferredScale(uint32(math.Round(st.scale * 120)))	43	+	for _, r := range o.resources {
			44	+	if r.Client() == surf.wl.Client() {
			45	+	surf.wl.SendEnter(r)
			46	+	}
56		}	47		}
57		}	48		}
58		}	49		}
59	-	// Layer surfaces sized from the output follow its new logical size.	50	+	scale := 1.0
60	-	for _, l := range s.layers {	51	+	if o != nil {
61	-	// Uses committed state only: pending requests wait for the client's commit.	52	+	scale = o.place.Scale
62	-	if l.configured && (l.current.width == 0 \|\| l.current.height == 0) {	53	+	}
63	-	l.sendConfigure()	54	+	if scale == surf.scale {
64	-	}	55	+	return
			56	+	}
			57	+	surf.scale = scale
			58	+	if surf.wl.Version() >= 6 {
			59	+	surf.wl.SendPreferredBufferScale(integerScale(scale))
			60	+	}
			61	+	if f := s.fractions[surf]; f != nil {
			62	+	f.SendPreferredScale(uint32(math.Round(scale * 120)))
65		}	63		}
66		}	64		}
67			65
68	-	// sendSurfaceScale tells a wl_surface v6+ which integer buffer scale to use.	66	+	// leave sends wl_surface.leave for o when the surface is on it.
69	-	func (s Server) sendSurfaceScale(w wayland.Surface) {	67	+	func (surf surface) leave(o output) {
70	-	if w != nil && w.Version() >= 6 {	68	+	if surf.on != o \|\| o == nil {
71	-	w.SendPreferredBufferScale(s.scale.integerScale())	69	+	return
			70	+	}
			71	+	surf.on = nil
			72	+	if surf.destroyed \|\| !surf.wl.Resource.Alive() {
			73	+	return
			74	+	}
			75	+	for _, r := range o.resources {
			76	+	if r.Client() == surf.wl.Client() && r.Resource.Alive() {
			77	+	surf.wl.SendLeave(r)
			78	+	}
72		}	79		}
73		}	80		}
74			81

@@ -92,7 +99,7 @@ func (m fractionManager) GetFractionalScale(r *fractionalscale.WpFractionalScale
92		if surf == nil {	99		if surf == nil {
93		return	100		return
94		}	101		}
95	-	if _, dup := s.scale.fractions[surf]; dup {	102	+	if _, dup := s.fractions[surf]; dup {
96		r.PostError(uint32(fractionalscale.WpFractionalScaleManagerV1ErrorFractionalScaleExists), "fractional scale already exists")	103		r.PostError(uint32(fractionalscale.WpFractionalScaleManagerV1ErrorFractionalScaleExists), "fractional scale already exists")
97		return	104		return
98		}	105		}

@@ -100,9 +107,13 @@ func (m fractionManager) GetFractionalScale(r *fractionalscale.WpFractionalScale
100		if err != nil {	107		if err != nil {
101		return	108		return
102		}	109		}
103	-	s.scale.fractions[surf] = f	110	+	s.fractions[surf] = f
104	-	f.OnDestroy = func() { delete(s.scale.fractions, surf) }	111	+	f.OnDestroy = func() { delete(s.fractions, surf) }
105	-	f.SendPreferredScale(uint32(math.Round(s.scale.scale * 120)))	112	+	scale := 1.0
			113	+	if o := s.outputOfSurface(surf); o != nil {
			114	+	scale = o.place.Scale
			115	+	}
			116	+	f.SendPreferredScale(uint32(math.Round(scale * 120)))
106		}	117		}
107			118
108		type fraction struct{}	119		type fraction struct{}

M internal/adapters/wayland/scale_test.go +2 -2


@@ -44,7 +44,7 @@ func contentServer(t testing.T) (Server, chan ports.ClientEvent, chan ports.Cl
44		events := make(chan ports.ClientEvent, 16)	44		events := make(chan ports.ClientEvent, 16)
45		commands := make(chan ports.ClientCommand, 16)	45		commands := make(chan ports.ClientCommand, 16)
46		contents := make(chan ports.SurfaceContent, 16)	46		contents := make(chan ports.SurfaceContent, 16)
47	-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080}, Channels{Events: events, Commands: commands, Contents: contents}, logging.For(context.Background(), "wayland"))	47	+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs}, Channels{Events: events, Commands: commands, Contents: contents}, logging.For(context.Background(), "wayland"))
48		if err != nil {	48		if err != nil {
49		t.Fatal(err)	49		t.Fatal(err)
50		}	50		}

@@ -92,7 +92,7 @@ func TestFractionalScaleAndViewport(t *testing.T) {
92		t.Fatalf("initial scale %d", v)	92		t.Fatalf("initial scale %d", v)
93		}	93		}
94		// Core switches to 1.5: the surface gets 180/120.	94		// Core switches to 1.5: the surface gets 180/120.
95	-	commands <- ports.SetOutputScale{Scale: 1.5, Width: 1280, Height: 720}	95	+	commands <- ports.SetOutputs{Outputs: ports.Layout{{Info: testOutputs[0].Info, Width: 1280, Height: 720, Scale: 1.5}}}
96		// Events are read by Roundtrip; the command is applied asynchronously.	96		// Events are read by Roundtrip; the command is applied asynchronously.
97		var got uint32	97		var got uint32
98		for deadline := time.Now().Add(2 * time.Second); got == 0 && time.Now().Before(deadline); {	98		for deadline := time.Now().Add(2 * time.Second); got == 0 && time.Now().Before(deadline); {

M internal/adapters/wayland/server.go +18 -31

 	"golang.org/x/sys/unix"
 )
+// Options configures the server. Outputs is the initial layout; core
+// replaces it with ports.SetOutputs.
 type Options struct {
-	RuntimeDir                string
+	RuntimeDir              string
-	OutputWidth, OutputHeight int
+	Outputs                 ports.Layout
-	Output                    OutputInfo
+	Keymap                  string
-	Keymap                    string
+	RepeatRate, RepeatDelay int
-	RepeatRate, RepeatDelay   int
-}
-// OutputInfo describes the advertised wl_output. Zero values fall back to the headless output.
-type OutputInfo struct {
-	Name, Description    string
-	Make, Model          string
-	RefreshMilli         int
-	PhysicalW, PhysicalH int
-}
-func (o Options) output() OutputInfo {
-	i := o.Output
-	if i.Name == "" {
-		i.Name, i.Description = "HEADLESS-1", "NeferTTY headless output"
-	}
-	if i.Make == "" {
-		i.Make, i.Model = "nefertty", "headless"
-	}
-	if i.RefreshMilli == 0 {
-		i.RefreshMilli = 60000
-	}
-	return i
 }
 // Channels carries client notifications and commands. Events may be unbuffered.
 	contentSeq    map[ports.WindowID]uint64
 	contentNotify chan struct{}
 	contentReady  chan struct{}
-	scale         scaleState
+	outputs       []*output
+	focusedOutput string
+	fractions     map[*surface]*fractionalscale.WpFractionalScaleV1
 }
 func removeItem[T comparable](list []T, v T) []T {
 		return nil, err
 	}
 	s := &Server{display: d, env: linuxProcEnv{}, name: name, cleanup: cleanup, log: log, channels: ch, surfaces: make(map[*server.Resource]*surface), buffers: make(map[*server.Resource]*buffer), windows: make(map[ports.WindowID]*window), layers: make(map[ports.WindowID]*layerSurface), nextWindow: 1, eventReady: make(chan struct{}, 1), contents: make(map[ports.WindowID]ports.SurfaceContent), contentSeq: make(map[ports.WindowID]uint64), contentReady: make(chan struct{}, 1), contentNotify: make(chan struct{}), keymapFD: -1, keyboards: make(map[server.Client][]*wayland.Keyboard), pointers: make(map[server.Client][]*wayland.Pointer), repeatRate: opts.RepeatRate, repeatDelay: opts.RepeatDelay}
-	s.scale = scaleState{scale: 1, width: opts.OutputWidth, height: opts.OutputHeight, fractions: map[*surface]*fractionalscale.WpFractionalScaleV1{}}
+	s.fractions = map[*surface]*fractionalscale.WpFractionalScaleV1{}
 	if opts.Keymap != "" {
 		fd, size, e := keymapFile(opts.Keymap)
 		if e != nil {
 		d.Close()
 		return nil, err
 	}
+	for _, p := range opts.Outputs {
+		s.addOutput(p)
+	}
 	return s, nil
 }
 func (s *Server) SocketName() string { return s.name }
 		s.log.Info().Uint64("id", uint64(c.ID)).Int("w", c.Width).Int("h", c.Height).Bool("fullscreen", c.Fullscreen).Bool("activated", c.Activated).Msg("configure")
 		w.last, w.hasLast = c, true
 		w.sendConfigure()
-	case ports.SetOutputScale:
+		if surf := w.xdg.surface; surf != nil && c.Output != "" {
-		s.setOutputScale(c)
+			surf.sendScale()
+		}
+	case ports.SetOutputs:
+		s.setOutputs(c)
 	case ports.SlotsPending:
 		s.slotsPending = c.Pending
 	case ports.CloseWindow:

M internal/adapters/wayland/server_test.go +8 -5

 		t.Skip("wayland-info not installed")
 	}
 	dir := t.TempDir()
-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080}, Channels{}, logging.For(context.Background(), "wayland"))
+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs}, Channels{}, logging.For(context.Background(), "wayland"))
 	if err != nil {
 		t.Fatal(err)
 	}
 		t.Skip("weston-simple-shm not installed")
 	}
 	dir := t.TempDir()
-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080}, Channels{}, logging.For(context.Background(), "wayland"))
+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs}, Channels{}, logging.For(context.Background(), "wayland"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	dir := t.TempDir()
 	events := make(chan ports.ClientEvent, 16)
 	commands := make(chan ports.ClientCommand, 16)
-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080}, Channels{Events: events, Commands: commands}, logging.For(context.Background(), "wayland"))
+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs}, Channels{Events: events, Commands: commands}, logging.For(context.Background(), "wayland"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	}
 	dir := t.TempDir()
 	events := make(chan ports.ClientEvent)
-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080}, Channels{Events: events}, logging.For(context.Background(), "wayland"))
+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs}, Channels{Events: events}, logging.For(context.Background(), "wayland"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	dir := t.TempDir()
 	events := make(chan ports.ClientEvent, 16)
 	contents := make(chan ports.SurfaceContent, 16)
-	s, err := New(Options{RuntimeDir: dir, OutputWidth: 1920, OutputHeight: 1080}, Channels{Events: events, Contents: contents}, logging.For(context.Background(), "wayland"))
+	s, err := New(Options{RuntimeDir: dir, Outputs: testOutputs}, Channels{Events: events, Contents: contents}, logging.For(context.Background(), "wayland"))
 	if err != nil {
 		t.Fatal(err)
 	}
 		}
 	}
 }
+// testOutputs is the 1920x1080 output tests start with.
+var testOutputs = ports.Layout{{Info: ports.OutputInfo{Name: "HEADLESS-1", Width: 1920, Height: 1080}, Width: 1920, Height: 1080, Scale: 1}}

M internal/adapters/wayland/surface.go +3 -0


@@ -32,6 +32,9 @@ type surface struct {
32	role func(bool)	32		role func(bool)
33	destroyed bool	33		destroyed bool
34	released bool	34		released bool
		35	+	// on is the output the surface entered; scale is the last scale sent.
		36	+	on *output
		37	+	scale float64
35	}	38		}
36		39
37	func (s surface) Destroy(wayland.Surface) {	40		func (s surface) Destroy(wayland.Surface) {

D internal/adapters/wayland/xdgoutput.go +0 -43

@@ -1,43 +0,0 @@
1	-	package wayland
2	-
3	-	import (
4	-	"github.com/bnema/purego-libwayland/protocol/wayland"
5	-	"github.com/bnema/purego-libwayland/protocol/xdgoutput"
6	-	"github.com/bnema/purego-libwayland/server"
7	-	)
8	-
9	-	type xdgOutputManager struct {
10	-	server *Server
11	-	info OutputInfo
12	-	}
13	-
14	-	func registerXDGOutput(d server.Display, o Options, s Server) error {
15	-	return xdgoutput.NewZxdgOutputManagerV1Global(d, 3, func(c server.Client, v, id uint32) {
16	-	_, _ = xdgoutput.NewZxdgOutputManagerV1(c, int32(v), id, xdgOutputManager{s, o.output()})
17	-	})
18	-	}
19	-	func (xdgOutputManager) Destroy(*xdgoutput.ZxdgOutputManagerV1) {}
20	-	func (m xdgOutputManager) GetXdgOutput(r xdgoutput.ZxdgOutputManagerV1, id uint32, output wayland.Output) {
21	-	x, err := xdgoutput.NewZxdgOutputV1(r.Client(), r.Version(), id, xdgOutput{})
22	-	if err != nil {
23	-	return
24	-	}
25	-	st := &m.server.scale
26	-	st.xdgOutputs = append(st.xdgOutputs, x)
27	-	x.OnDestroy = func() { st.xdgOutputs = removeItem(st.xdgOutputs, x) }
28	-	x.SendLogicalPosition(0, 0)
29	-	x.SendLogicalSize(int32(st.width), int32(st.height))
30	-	if r.Version() >= 2 {
31	-	x.SendName(m.info.Name)
32	-	x.SendDescription(m.info.Description)
33	-	}
34	-	if r.Version() < 3 \|\| output == nil \|\| output.Version() < 2 {
35	-	x.SendDone()
36	-	} else {
37	-	output.SendDone()
38	-	}
39	-	}
40	-
41	-	type xdgOutput struct{}
42	-
43	-	func (xdgOutput) Destroy(*xdgoutput.ZxdgOutputV1) {}

M internal/app/app.go +47 -53

 	"time"
 	"github.com/bnema/nefertty/internal/adapters/config"
-	"github.com/bnema/nefertty/internal/adapters/headless"
+	"github.com/bnema/nefertty/internal/adapters/drm"
 	"github.com/bnema/nefertty/internal/adapters/headlessinput"
 	"github.com/bnema/nefertty/internal/adapters/launcher"
 	"github.com/bnema/nefertty/internal/adapters/libinput"
 	Timeout       time.Duration
 	NoTerminal    bool
 	ScreenshotDir string
-	// Width and Height size the headless output; 0 means 1920x1080.
+	// Sizes are the headless outputs (width, height), left to right; empty
-	Width, Height int
+	// means one 1920x1080 output. With several outputs, screenshots go to
+	// one subdirectory per output (HEADLESS-1, HEADLESS-2, ...).
+	Sizes [][2]int
 	// Run closes Script on shutdown; the reader goroutine exits after Close.
 	Script     io.ReadCloser
-	testScenes chan<- ports.Scene
+	testScenes chan<- []ports.Scene
 }
 func Run(ctx context.Context, opts Options) error { return run(ctx, opts, nil) }
 		ctx, cancel = context.WithCancel(ctx)
 	}
 	defer cancel()
-	width, height := opts.Width, opts.Height
+	sizes := opts.Sizes
-	if width <= 0 || height <= 0 {
+	if len(sizes) == 0 {
-		width, height = 1920, 1080
+		sizes = [][2]int{{1920, 1080}}
 	}
-	var outInfo wayland.OutputInfo
 	var hw *drmBackend
 	if opts.Backend == "drm" {
 		var err error
 			return err
 		}
 		defer hw.close()
-		width, height = hw.out.Width(), hw.out.Height()
-		outInfo = hw.outputInfo()
-		hw.inputActive, hw.outputActive = hw.seat.Subscribe(), hw.seat.Subscribe()
 	}
 	client := make(chan ports.ClientEvent, 32)
 	input := make(chan ports.InputEvent, 32)
 	configChanges := make(chan ports.ConfigChanged, 8)
 	commands := make(chan ports.ClientCommand, 32)
 	spawn := make(chan ports.SpawnRequest, 32)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
+	layouts := make(chan ports.Layout, 1)
 	configErrors := make(chan error, 8)
-	renderScenes := make(chan ports.Scene, 1)
+	renderScenes := make(chan []ports.Scene, 1)
 	contents := make(chan ports.SurfaceContent, 64)
-	ch := core.Channels{Client: client, Input: input, Output: output, Config: configChanges, Commands: commands, Spawn: spawn, Scenes: scenes, ConfigErrors: configErrors}
+	ch := core.Channels{Client: client, Input: input, Output: output, Config: configChanges, Commands: commands, Spawn: spawn, Scenes: scenes, Layouts: layouts, ConfigErrors: configErrors}
 	c, err := core.New(opts.Config, ch)
 	if err != nil {
 		return err
 	}
-	outName := outInfo.Name
-	if outName == "" {
-		outName = "HEADLESS-1"
-	}
-	output <- ports.OutputMode{Width: width, Height: height, Name: outName}
 	km, err := xkb.New(xkb.RMLVO{Layout: opts.Config.Keyboard.Layout, Variant: opts.Config.Keyboard.Variant, Options: opts.Config.Keyboard.Options})
 	if err != nil {
 		return err
 	}
 	keymap := km.String()
 	runtimeDir := os.Getenv("XDG_RUNTIME_DIR")
-	server, err := wayland.New(wayland.Options{RuntimeDir: runtimeDir, OutputWidth: width, OutputHeight: height, Output: outInfo, Keymap: keymap, RepeatRate: opts.Config.Keyboard.RepeatRate, RepeatDelay: opts.Config.Keyboard.RepeatDelay}, wayland.Channels{Events: client, Commands: commands, Contents: contents}, logging.For(ctx, "wayland"))
+	server, err := wayland.New(wayland.Options{RuntimeDir: runtimeDir, Keymap: keymap, RepeatRate: opts.Config.Keyboard.RepeatRate, RepeatDelay: opts.Config.Keyboard.RepeatDelay}, wayland.Channels{Events: client, Commands: commands, Contents: contents}, logging.For(ctx, "wayland"))
 	if err != nil {
 		km.Close()
 		return err
 		relayConfig(ctx, opts.Config, watched, configChanges, keymaps, commands, logging.For(ctx, "config"))
 	}()
 	script := make(chan string)
-	// The software cursor starts centred, like libinput's pointer.
+	curs := newCursors()
-	softCursor := &headless.Cursor{}
-	softCursor.Move(float64(width)/2, float64(height)/2)
 	go func() {
 		defer workers.Done()
 		if hw != nil {
+			// Core sends the first layout once DRM reports the outputs.
+			var layout ports.Layout
+			select {
+			case layout = <-layouts:
+			case <-ctx.Done():
+				km.Close()
+				return
+			}
 			done <- safe("input", func() error {
-				var move func(x, y float64)
+				return libinput.Run(ctx, libinput.Options{Seat: hw.seat, SeatName: hw.seat.Name(), Keymap: km, Keymaps: keymaps, Layout: layout, Layouts: layouts, Active: hw.seat.Subscribe(), MoveCursor: curs.move, Log: logging.For(ctx, "input")}, input)
-				if cur := hw.out.Cursor(); cur != nil {
-					move = cur.Move
-				}
-				return libinput.Run(ctx, libinput.Options{Seat: hw.seat, SeatName: hw.seat.Name(), Keymap: km, Keymaps: keymaps, Width: width, Height: height, Active: hw.inputActive, MoveCursor: move, Log: logging.For(ctx, "input")}, input)
 			})
 			return
 		}
-		_ = headlessinput.Run(ctx, km, keymaps, script, input, softCursor.Move, logging.For(ctx, "input"))
+		_ = headlessinput.Run(ctx, km, keymaps, script, input, layouts, curs.move, logging.For(ctx, "input"))
 	}()
 	if opts.Script != nil {
 		go func() { <-ctx.Done(); _ = opts.Script.Close() }()
 	go func() {
 		defer workers.Done()
-		if hw != nil {
+		newRenderer := func(w, h int) (ports.Renderer, error) {
-			done <- safe("output", func() error {
-				return hw.out.Run(ctx, func(w, h int) (ports.Renderer, error) {
-					r, err := vulkan.New(w, h)
-					if err != nil {
-						return nil, err
-					}
-					return r, nil
-				}, loadCursor, hw.outputActive, renderScenes, contents)
-			})
-			return
-		}
-		done <- headless.Run(ctx, headless.Options{Cursor: softCursor, LoadCursor: loadCursor, Width: width, Height: height, ScreenshotDir: opts.ScreenshotDir, Log: logging.For(ctx, "render"), NewRenderer: func(w, h int) (ports.Renderer, error) {
 			r, err := vulkan.New(w, h)
 			if err != nil {
 				return nil, err
 			}
 			return r, nil
-		}}, renderScenes, contents)
+		}
+		if hw != nil {
+			done <- safe("output", func() error {
+				want := func() drm.Want { return wantFromConfig(opts.Config.Outputs) }
+				return hw.runOutputs(ctx, want, output, renderScenes, contents, curs, newRenderer, logging.For(ctx, "drm"))
+			})
+			return
+		}
+		done <- runHeadless(ctx, sizes, opts.ScreenshotDir, output, renderScenes, contents, curs, newRenderer, logging.For(ctx, "render"))
 	}()
 	if hw != nil {
 	}
 }
-func consumeScenes(ctx context.Context, scenes <-chan ports.Scene, configErrors <-chan error, tap chan<- ports.Scene, renderScenes chan ports.Scene) {
+func consumeScenes(ctx context.Context, scenes <-chan []ports.Scene, configErrors <-chan error, tap chan<- []ports.Scene, renderScenes chan []ports.Scene) {
 	log := logging.For(ctx, "core")
 	configLog := logging.For(ctx, "config")
 	for {
 		select {
 		case <-ctx.Done():
 			return
-		case s := <-scenes:
+		case set := <-scenes:
 			if tap != nil {
 				select {
-				case tap <- s:
+				case tap <- set:
 				default:
 				}
 			}
 			select {
-			case renderScenes <- s:
+			case renderScenes <- set:
 			default:
 				select {
 				case <-renderScenes:
 				default:
 				}
 				select {
-				case renderScenes <- s:
+				case renderScenes <- set:
 				default:
 				}
 			}
-			ev := log.Debug().Uint64("seq", s.Seq).Int("out_w", s.OutputWidth).Int("out_h", s.OutputHeight).Float64("scale", s.Scale)
+			for _, s := range set {
-			rects := make([]string, 0, len(s.Windows))
+				ev := log.Debug().Str("output", s.Output).Uint64("seq", s.Seq).Int("out_w", s.OutputWidth).Int("out_h", s.OutputHeight).Float64("scale", s.Scale)
-			for _, w := range s.Windows {
+				rects := make([]string, 0, len(s.Windows))
-				rects = append(rects, fmt.Sprintf("%d:%d,%d %dx%d", w.ID, w.Rect.X, w.Rect.Y, w.Rect.W, w.Rect.H))
+				for _, w := range s.Windows {
+					rects = append(rects, fmt.Sprintf("%d:%d,%d %dx%d", w.ID, w.Rect.X, w.Rect.Y, w.Rect.W, w.Rect.H))
+				}
+				ev.Strs("windows", rects).Msg("scene")
 			}
-			ev.Strs("windows", rects).Msg("scene")
 		case err := <-configErrors:
 			configLog.Warn().Err(err).Msg("config rejected")
 		}

M internal/app/app_test.go +30 -4

 	t.Setenv("XDG_STATE_HOME", t.TempDir())
 	cfg := config.Defaults()
 	cfg.Terminal.Command = []string{"weston-simple-shm"}
-	scenes := make(chan ports.Scene, 64)
+	scenes := make(chan []ports.Scene, 64)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	inputReady := make(chan chan<- ports.InputEvent, 1)
 		defer timer.Stop()
 		for {
 			select {
-			case s := <-scenes:
+			case set := <-scenes:
+				s := set[0]
 				if len(s.Windows) == count {
 					// A lone column fills the 1920 output (default zero gaps).
 					if count == 1 && s.Windows[0].Rect.W != 1920 {
 	t.Setenv("XDG_STATE_HOME", t.TempDir())
 	cfg := config.Defaults()
 	cfg.Terminal.Command = []string{"foot", "-c", "/dev/null", "sh"}
-	scenes := make(chan ports.Scene, 128)
+	scenes := make(chan []ports.Scene, 128)
 	err := Run(context.Background(), Options{Backend: "headless", Config: cfg, Script: io.NopCloser(strings.NewReader("sleep 1s\nkey Super+Return\nsleep 1s\nmove 600 300\nclick\nsleep 500ms\n")), Timeout: 5 * time.Second, testScenes: scenes})
 	if err != nil {
 		if strings.Contains(strings.ToLower(err.Error()), "vulkan") {
 	}
 	two, focused := false, false
 	for len(scenes) > 0 {
-		s := <-scenes
+		s := (<-scenes)[0]
 		if len(s.Windows) == 2 {
 			two = true
 			for _, w := range s.Windows {
 		t.Fatalf("bad layout command: keymap=%t rate=%d", cmd.Keymap != "", cmd.RepeatRate)
 	}
 }
+func TestHeadlessTwoOutputs(t *testing.T) {
+	t.Setenv("XDG_RUNTIME_DIR", t.TempDir())
+	scenes := make(chan []ports.Scene, 64)
+	shots := t.TempDir()
+	err := Run(context.Background(), Options{Backend: "headless", Config: config.Defaults(), NoTerminal: true, ScreenshotDir: shots, Sizes: [][2]int{{640, 480}, {320, 240}}, Timeout: 2 * time.Second, testScenes: scenes})
+	if err != nil {
+		if strings.Contains(strings.ToLower(err.Error()), "vulkan") {
+			t.Skipf("Vulkan unavailable: %v", err)
+		}
+		t.Fatal(err)
+	}
+	var last []ports.Scene
+	for len(scenes) > 0 {
+		last = <-scenes
+	}
+	if len(last) != 2 || last[0].Output != "HEADLESS-1" || last[1].OutputWidth != 320 {
+		t.Fatalf("%+v", last)
+	}
+	for _, name := range []string{"HEADLESS-1", "HEADLESS-2"} {
+		if _, err := os.Stat(filepath.Join(shots, name, "latest.png")); err != nil {
+			t.Fatal(err)
+		}
+	}
+}

M internal/app/drm.go +173 -56


@@ -7,24 +7,27 @@ import (
7		"path/filepath"	7		"path/filepath"
8		"runtime/debug"	8		"runtime/debug"
9		"sort"	9		"sort"
10	-	"strings"	10	+	"sync"
11			11
12		"github.com/bnema/nefertty/internal/adapters/config"	12		"github.com/bnema/nefertty/internal/adapters/config"
13		"github.com/bnema/nefertty/internal/adapters/drm"	13		"github.com/bnema/nefertty/internal/adapters/drm"
14		"github.com/bnema/nefertty/internal/adapters/seat"	14		"github.com/bnema/nefertty/internal/adapters/seat"
15	-	"github.com/bnema/nefertty/internal/adapters/wayland"
16		"github.com/bnema/nefertty/internal/logging"	15		"github.com/bnema/nefertty/internal/logging"
17		"github.com/bnema/nefertty/internal/ports"	16		"github.com/bnema/nefertty/internal/ports"
			17	+	"github.com/bnema/zerowrap"
18		)	18		)
19			19
20		var errTimeout = errors.New("timeout")	20		var errTimeout = errors.New("timeout")
21			21
			22	+	// drmBackend is the seat and the cards with at least one usable output.
22		type drmBackend struct {	23		type drmBackend struct {
23	-	seat *seat.Seat	24	+	seat *seat.Seat
24	-	out *drm.Output	25	+	cards []*drmCard
25	-	fd int	26	+	}
26			27
27	-	inputActive, outputActive <-chan bool	28	+	type drmCard struct {
			29	+	*drm.Card
			30	+	fd int
28		}	31		}
29			32
30		// safe turns a panic in a hardware goroutine into an error, so the TTY is still restored.	33		// safe turns a panic in a hardware goroutine into an error, so the TTY is still restored.

@@ -37,7 +40,8 @@ func safe(name string, fn func() error) (err error) {
37		return fn()	40		return fn()
38		}	41		}
39			42
40	-	// openDRM opens the seat and the first card with a connected display.	43	+	// openDRM opens the seat and every card with a connected display. Outputs
			44	+	// are found by the first Scan of each card.
41		func openDRM(ctx context.Context, outputs []ports.OutputConfig) (*drmBackend, error) {	45		func openDRM(ctx context.Context, outputs []ports.OutputConfig) (*drmBackend, error) {
42		log := logging.For(ctx, "drm")	46		log := logging.For(ctx, "drm")
43		s, err := seat.Open(ctx, logging.For(ctx, "seat"))	47		s, err := seat.Open(ctx, logging.For(ctx, "seat"))

@@ -46,74 +50,187 @@ func openDRM(ctx context.Context, outputs []ports.OutputConfig) (*drmBackend, er
46		return nil, fmt.Errorf("open seat: %w", err)	50		return nil, fmt.Errorf("open seat: %w", err)
47		}	51		}
48		want := wantFromConfig(outputs)	52		want := wantFromConfig(outputs)
49	-	cards, _ := filepath.Glob("/dev/dri/card[0-9]*")	53	+	paths, _ := filepath.Glob("/dev/dri/card[0-9]*")
50	-	sort.Strings(cards)	54	+	sort.Strings(paths)
			55	+	b := &drmBackend{seat: s}
51		var errs []error	56		var errs []error
52	-	// First pass: the configured output on any card; second: any usable output.	57	+	for _, path := range paths {
53	-	passes := []drm.Want{want}	58	+	fd, err := s.OpenDevice(path)
54	-	if want.Name != "" {	59	+	if err != nil {
55	-	strict := want	60	+	errs = append(errs, err)
56	-	strict.Strict = true	61	+	continue
57	-	passes = []drm.Want{strict, want}	62	+	}
58	-	}	63	+	card, err := drm.OpenCard(fd, path, want, log)
59	-	for _, w := range passes {	64	+	if err != nil {
60	-	for _, card := range cards {	65	+	log.Warn().Err(err).Str("card", path).Msg("card unusable")
61	-	fd, err := s.OpenDevice(card)	66	+	errs = append(errs, err)
62	-	if err != nil {	67	+	s.CloseDevice(fd)
63	-	errs = append(errs, err)	68	+	continue
64	-	continue
65	-	}
66	-	out, err := drm.Open(fd, card, w, log)
67	-	if err != nil {
68	-	if !w.Strict {
69	-	log.Warn().Err(err).Str("card", card).Msg("card unusable")
70	-	errs = append(errs, err)
71	-	}
72	-	s.CloseDevice(fd)
73	-	continue
74	-	}
75	-	return &drmBackend{seat: s, out: out, fd: fd}, nil
76		}	69		}
			70	+	b.cards = append(b.cards, &drmCard{Card: card, fd: fd})
77		}	71		}
78	-	s.Close()	72	+	if len(b.cards) == 0 {
79	-	err = fmt.Errorf("no usable DRM card in %v: %w", cards, errors.Join(errs...))	73	+	s.Close()
80	-	log.Error().Err(err).Msg("open drm")	74	+	err = fmt.Errorf("no usable DRM card in %v: %w", paths, errors.Join(errs...))
81	-	return nil, err	75	+	log.Error().Err(err).Msg("open drm")
			76	+	return nil, err
			77	+	}
			78	+	return b, nil
82		}	79		}
83			80
84	-	// wantFromConfig turns [[output]] entries into a connector choice: the first enabled entry wins.	81	+	// wantFromConfig turns output.<name> entries into connector choices.
85		func wantFromConfig(outputs []ports.OutputConfig) drm.Want {	82		func wantFromConfig(outputs []ports.OutputConfig) drm.Want {
86	-	want := drm.Want{Disabled: map[string]bool{}}	83	+	want := drm.Want{Disabled: map[string]bool{}, Modes: map[string][3]float64{}}
87		for _, o := range outputs {	84		for _, o := range outputs {
88		if o.Off {	85		if o.Off {
89		want.Disabled[o.Name] = true	86		want.Disabled[o.Name] = true
90		continue	87		continue
91		}	88		}
92	-	if want.Name != "" \|\| o.ScaleOnly {
93	-	continue
94	-	}
95	-	want.Name = o.Name
96		if o.Mode != "" {	89		if o.Mode != "" {
97		// Validated at config load.	90		// Validated at config load.
98	-	want.W, want.H, want.Hz, _ = config.ParseMode(o.Mode)	91	+	w, h, hz, _ := config.ParseMode(o.Mode)
			92	+	want.Modes[o.Name] = [3]float64{float64(w), float64(h), hz}
99		}	93		}
100		}	94		}
101		return want	95		return want
102		}	96		}
103			97
104	-	// outputInfo describes the chosen output for wl_output and xdg-output.	98	+	// close releases the cards and the seat so the TTY comes back. Outputs are
105	-	func (b *drmBackend) outputInfo() wayland.OutputInfo {	99	+	// closed by their goroutines first.
106	-	i := b.out.Info()	100	+	func (b *drmBackend) close() {
107	-	return wayland.OutputInfo{	101	+	for _, c := range b.cards {
108	-	Name: i.Name, Make: i.Monitor.Make, Model: i.Monitor.Model,	102	+	b.seat.CloseDevice(c.fd)
109	-	Description: strings.TrimSpace(i.Monitor.Make + " " + i.Monitor.Model + " " + i.Monitor.Serial + " (" + i.Name + ")"),
110	-	RefreshMilli: i.RefreshMilli, PhysicalW: i.PhysicalW, PhysicalH: i.PhysicalH,
111		}	103		}
			104	+	b.seat.Close()
112		}	105		}
113			106
114	-	// close restores the CRTC, then releases the card and the seat so the TTY comes back.	107	+	// runOutputs drives every output of every card: one goroutine per output,
115	-	func (b *drmBackend) close() {	108	+	// one flip reader per card, and a udev watcher that rescans connectors on
116	-	b.out.Close()	109	+	// hotplug. Core learns about outputs through events. It returns when ctx
117	-	b.seat.CloseDevice(b.fd)	110	+	// ends, after every output is closed.
118	-	b.seat.Close()	111	+	func (b drmBackend) runOutputs(ctx context.Context, want func() drm.Want, events chan<- ports.OutputEvent, scenes <-chan []ports.Scene, contents <-chan ports.SurfaceContent, curs cursors, newRenderer func(w, h int) (ports.Renderer, error), log zerowrap.Logger) error {
			112	+	ctx, cancel := context.WithCancel(ctx)
			113	+	defer cancel()
			114	+	var readers sync.WaitGroup
			115	+	readerErr := make(chan error, len(b.cards))
			116	+	for _, c := range b.cards {
			117	+	readers.Go(func() {
			118	+	if err := safe("drm events", func() error { return c.ReadEvents(ctx) }); err != nil {
			119	+	readerErr <- fmt.Errorf("%s: %w", c.Path(), err)
			120	+	}
			121	+	})
			122	+	}
			123	+	defer readers.Wait()
			124	+	hotplug := make(chan struct{}, 1)
			125	+	go func() {
			126	+	if err := safe("hotplug", func() error { return drm.WatchHotplug(ctx, hotplug) }); err != nil {
			127	+	log.Warn().Err(err).Msg("hotplug watch disabled")
			128	+	}
			129	+	}()
			130	+	set := newOutputSet()
			131	+	cards := map[string]*drmCard{}
			132	+	send := func(ev ports.OutputEvent) {
			133	+	select {
			134	+	case events <- ev:
			135	+	case <-ctx.Done():
			136	+	}
			137	+	}
			138	+	// stopping holds outputs asked to stop: true when they restart with a
			139	+	// new mode (core keeps the screen), false when they are gone.
			140	+	stopping := map[string]bool{}
			141	+	scan := func() {
			142	+	for _, c := range b.cards {
			143	+	c.SetWant(want())
			144	+	added, removed, replaced, err := c.Scan()
			145	+	if err != nil {
			146	+	log.Warn().Err(err).Msg("scan connectors")
			147	+	continue
			148	+	}
			149	+	stop := func(name string, restart bool) {
			150	+	if r := set.outs[name]; r != nil && cards[name] == c {
			151	+	if _, ok := stopping[name]; !ok {
			152	+	stopping[name] = restart
			153	+	r.stop()
			154	+	}
			155	+	}
			156	+	}
			157	+	for _, name := range removed {
			158	+	log.Info().Str("connector", name).Msg("output unplugged")
			159	+	stop(name, false)
			160	+	}
			161	+	for _, name := range replaced {
			162	+	log.Info().Str("connector", name).Msg("output mode change")
			163	+	stop(name, true)
			164	+	}
			165	+	for _, o := range added {
			166	+	name := o.Info().Name
			167	+	if other := cards[name]; other != nil && other != c {
			168	+	// Core and clients know outputs by connector name.
			169	+	log.Warn().Str("connector", name).Str("card", c.Path()).Msg("connector name already used by another card; ignored")
			170	+	o.Close()
			171	+	c.Release(name)
			172	+	continue
			173	+	}
			174	+	cards[name] = c
			175	+	if cur := o.Cursor(); cur != nil {
			176	+	curs.set(name, cur)
			177	+	}
			178	+	active := b.seat.Subscribe()
			179	+	set.start(ctx, name, func(octx context.Context, sc <-chan ports.Scene, cc <-chan ports.SurfaceContent) error {
			180	+	defer b.seat.Unsubscribe(active)
			181	+	return safe("output "+name, func() error {
			182	+	defer o.Close()
			183	+	return o.Run(octx, newRenderer, loadCursor, active, sc, cc)
			184	+	})
			185	+	})
			186	+	send(ports.OutputAdded{Info: o.Info()})
			187	+	}
			188	+	}
			189	+	}
			190	+	scan()
			191	+	if len(set.outs) == 0 {
			192	+	return errors.Join(errors.New("no connected display"), set.wait())
			193	+	}
			194	+	for {
			195	+	select {
			196	+	case <-ctx.Done():
			197	+	return set.wait()
			198	+	case err := <-readerErr:
			199	+	// No more flips on that card: its outputs would freeze.
			200	+	return errors.Join(err, set.wait())
			201	+	case <-hotplug:
			202	+	log.Info().Msg("hotplug")
			203	+	scan()
			204	+	case s := <-scenes:
			205	+	set.scenes(s)
			206	+	case c := <-contents:
			207	+	set.content(c)
			208	+	case name := <-set.stopped:
			209	+	err := set.finish(name)
			210	+	if ctx.Err() != nil {
			211	+	return errors.Join(err, set.wait())
			212	+	}
			213	+	restart := stopping[name]
			214	+	delete(stopping, name)
			215	+	curs.set(name, nil)
			216	+	cards[name].Release(name)
			217	+	delete(cards, name)
			218	+	if err != nil {
			219	+	// A broken output (e.g. its renderer) must not take the
			220	+	// session down. It stays off until the next hotplug, so a
			221	+	// lasting failure does not loop.
			222	+	log.Error().Err(err).Str("connector", name).Msg("output stopped")
			223	+	restart = false
			224	+	}
			225	+	if restart {
			226	+	// Same connector, new mode: core keeps its screen and
			227	+	// workspaces; OutputAdded updates the size.
			228	+	scan()
			229	+	if set.outs[name] != nil {
			230	+	continue
			231	+	}
			232	+	}
			233	+	send(ports.OutputRemoved{Name: name})
			234	+	}
			235	+	}
119		}	236		}

D internal/app/drm_scale_test.go +0 -14

@@ -1,14 +0,0 @@
1	-	package app
2	-
3	-	import (
4	-	"testing"
5	-
6	-	"github.com/bnema/nefertty/internal/ports"
7	-	)
8	-
9	-	func TestScaleOnlyDoesNotSelectOutput(t *testing.T) {
10	-	want := wantFromConfig([]ports.OutputConfig{{Name: "eDP-1", Scale: 2, ScaleOnly: true}, {Name: "HDMI-A-1", Mode: "1920x1080"}})
11	-	if want.Name != "HDMI-A-1" \|\| want.W != 1920 {
12	-	t.Fatalf("%+v", want)
13	-	}
14	-	}

A internal/app/drm_test.go +14 -0

@@ -0,0 +1,14 @@
	1	+	package app
	2	+
	3	+	import (
	4	+	"testing"
	5	+
	6	+	"github.com/bnema/nefertty/internal/ports"
	7	+	)
	8	+
	9	+	func TestWantFromConfig(t *testing.T) {
	10	+	want := wantFromConfig([]ports.OutputConfig{{Name: "eDP-1", Scale: 2, ScaleOnly: true}, {Name: "HDMI-A-1", Mode: "1920x1080@60"}, {Name: "DP-3", Off: true}})
	11	+	if m := want.Modes["HDMI-A-1"]; m != [3]float64{1920, 1080, 60} \|\| !want.Disabled["DP-3"] \|\| len(want.Modes) != 1 {
	12	+	t.Fatalf("%+v", want)
	13	+	}
	14	+	}

A internal/app/headless.go +62 -0

@@ -0,0 +1,62 @@
	1	+	package app
	2	+
	3	+	import (
	4	+	"context"
	5	+	"fmt"
	6	+	"os"
	7	+	"path/filepath"
	8	+
	9	+	"github.com/bnema/nefertty/internal/adapters/headless"
	10	+	"github.com/bnema/nefertty/internal/ports"
	11	+	"github.com/bnema/zerowrap"
	12	+	)
	13	+
	14	+	// runHeadless drives one virtual output per size, named HEADLESS-1, -2, ...
	15	+	// With several outputs, screenshots go to a subdirectory per output.
	16	+	func runHeadless(ctx context.Context, sizes [][2]int, shots string, events chan<- ports.OutputEvent, scenes <-chan []ports.Scene, contents <-chan ports.SurfaceContent, curs *cursors, newRenderer func(w, h int) (ports.Renderer, error), log zerowrap.Logger) error {
	17	+	set := newOutputSet()
	18	+	for i, size := range sizes {
	19	+	name := fmt.Sprintf("HEADLESS-%d", i+1)
	20	+	dir := shots
	21	+	if dir != "" && len(sizes) > 1 {
	22	+	dir = filepath.Join(shots, name)
	23	+	if err := os.MkdirAll(dir, 0o755); err != nil {
	24	+	return err
	25	+	}
	26	+	}
	27	+	cur := &headless.Cursor{}
	28	+	curs.set(name, cur)
	29	+	opts := headless.Options{Cursor: cur, LoadCursor: loadCursor, Width: size[0], Height: size[1], ScreenshotDir: dir, Log: log, NewRenderer: newRenderer}
	30	+	set.start(ctx, name, func(octx context.Context, sc <-chan ports.Scene, cc <-chan ports.SurfaceContent) error {
	31	+	return headless.Run(octx, opts, sc, cc)
	32	+	})
	33	+	select {
	34	+	case events <- ports.OutputAdded{Info: ports.OutputInfo{Name: name, Width: size[0], Height: size[1]}}:
	35	+	case <-ctx.Done():
	36	+	return set.wait()
	37	+	}
	38	+	}
	39	+	// The pointer starts centred on the first output, like libinput's.
	40	+	curs.move("HEADLESS-1", float64(sizes[0][0])/2, float64(sizes[0][1])/2)
	41	+	for {
	42	+	select {
	43	+	case <-ctx.Done():
	44	+	return set.wait()
	45	+	case s := <-scenes:
	46	+	set.scenes(s)
	47	+	case c := <-contents:
	48	+	set.content(c)
	49	+	case name := <-set.stopped:
	50	+	// A headless output only stops on error: the run ends.
	51	+	err := set.finish(name)
	52	+	return joinErr(err, set.wait())
	53	+	}
	54	+	}
	55	+	}
	56	+
	57	+	func joinErr(a, b error) error {
	58	+	if a != nil {
	59	+	return a
	60	+	}
	61	+	return b
	62	+	}

A internal/app/outputs.go +163 -0

@@ -0,0 +1,163 @@
	1	+	package app
	2	+
	3	+	import (
	4	+	"context"
	5	+	"sync"
	6	+
	7	+	"github.com/bnema/nefertty/internal/ports"
	8	+	)
	9	+
	10	+	// outputRun drives one output until ctx ends: it renders the scenes and
	11	+	// surface contents it receives.
	12	+	type outputRun func(ctx context.Context, scenes <-chan ports.Scene, contents <-chan ports.SurfaceContent) error
	13	+
	14	+	// outputSet owns the running outputs and feeds them. Core sends one scene
	15	+	// per output; each goes to its output, latest first. Surface contents go to
	16	+	// every output, since windows move between outputs; the latest content of
	17	+	// each window is kept so a new output starts with every window drawn.
	18	+	// Only the goroutine running loop touches the set.
	19	+	type outputSet struct {
	20	+	outs map[string]*runningOutput
	21	+	latest map[ports.WindowID]ports.SurfaceContent
	22	+	stopped chan string
	23	+	quit chan struct{} // closed by wait: nobody reads stopped any more
	24	+	}
	25	+
	26	+	type runningOutput struct {
	27	+	scenes chan ports.Scene
	28	+	contents chan ports.SurfaceContent
	29	+	ctx context.Context
	30	+	stop context.CancelFunc
	31	+	err error
	32	+	done chan struct{}
	33	+	}
	34	+
	35	+	func newOutputSet() *outputSet {
	36	+	return &outputSet{outs: map[string]*runningOutput{}, latest: map[ports.WindowID]ports.SurfaceContent{}, stopped: make(chan string), quit: make(chan struct{})}
	37	+	}
	38	+
	39	+	// start runs an output in its own goroutine and replays the window contents.
	40	+	func (s *outputSet) start(ctx context.Context, name string, run outputRun) {
	41	+	octx, stop := context.WithCancel(ctx)
	42	+	r := &runningOutput{scenes: make(chan ports.Scene, 1), contents: make(chan ports.SurfaceContent, 64), ctx: octx, stop: stop, done: make(chan struct{})}
	43	+	s.outs[name] = r
	44	+	go func() {
	45	+	r.err = run(octx, r.scenes, r.contents)
	46	+	close(r.done)
	47	+	select {
	48	+	case s.stopped <- name:
	49	+	case <-s.quit:
	50	+	}
	51	+	}()
	52	+	for _, c := range s.latest {
	53	+	r.send(c)
	54	+	}
	55	+	}
	56	+
	57	+	// send hands content to the output unless it has stopped.
	58	+	func (r *runningOutput) send(c ports.SurfaceContent) {
	59	+	select {
	60	+	case r.contents <- c:
	61	+	case <-r.ctx.Done():
	62	+	case <-r.done:
	63	+	}
	64	+	}
	65	+
	66	+	// scenes routes each scene to its output, replacing an unread one.
	67	+	func (s *outputSet) scenes(set []ports.Scene) {
	68	+	for _, sc := range set {
	69	+	if r := s.outs[sc.Output]; r != nil {
	70	+	select {
	71	+	case <-r.scenes:
	72	+	default:
	73	+	}
	74	+	r.scenes <- sc
	75	+	}
	76	+	}
	77	+	}
	78	+
	79	+	func (s *outputSet) content(c ports.SurfaceContent) {
	80	+	if c.Pixels == nil {
	81	+	delete(s.latest, c.ID)
	82	+	} else {
	83	+	s.latest[c.ID] = c
	84	+	}
	85	+	for _, r := range s.outs {
	86	+	r.send(c)
	87	+	}
	88	+	}
	89	+
	90	+	// finish forgets a stopped output and returns its error.
	91	+	func (s *outputSet) finish(name string) error {
	92	+	r := s.outs[name]
	93	+	if r == nil {
	94	+	return nil
	95	+	}
	96	+	<-r.done
	97	+	r.stop()
	98	+	delete(s.outs, name)
	99	+	return r.err
	100	+	}
	101	+
	102	+	// wait stops every output and returns the first error.
	103	+	func (s *outputSet) wait() error {
	104	+	var first error
	105	+	close(s.quit)
	106	+	for name, r := range s.outs {
	107	+	r.stop()
	108	+	<-r.done
	109	+	if first == nil && r.err != nil {
	110	+	first = r.err
	111	+	}
	112	+	delete(s.outs, name)
	113	+	}
	114	+	return first
	115	+	}
	116	+
	117	+	// cursors routes pointer moves from the input goroutine to the cursor of
	118	+	// the output under the pointer and hides the others.
	119	+	type cursors struct {
	120	+	mu sync.Mutex
	121	+	all map[string]cursor
	122	+	last string
	123	+	}
	124	+
	125	+	// cursor is a hardware or software cursor of one output.
	126	+	type cursor interface {
	127	+	Move(x, y float64)
	128	+	Hide()
	129	+	}
	130	+
	131	+	func newCursors() *cursors { return &cursors{all: map[string]cursor{}} }
	132	+
	133	+	// set registers the cursor of an output; nil removes it.
	134	+	func (c *cursors) set(output string, cur cursor) {
	135	+	c.mu.Lock()
	136	+	defer c.mu.Unlock()
	137	+	if cur == nil {
	138	+	delete(c.all, output)
	139	+	return
	140	+	}
	141	+	c.all[output] = cur
	142	+	// Before the first move nothing is shown yet: hiding would stick.
	143	+	if c.last != "" && output != c.last {
	144	+	cur.Hide()
	145	+	}
	146	+	}
	147	+
	148	+	// move places the cursor on output at physical (x, y).
	149	+	func (c *cursors) move(output string, x, y float64) {
	150	+	c.mu.Lock()
	151	+	defer c.mu.Unlock()
	152	+	if output != c.last {
	153	+	for name, cur := range c.all {
	154	+	if name != output {
	155	+	cur.Hide()
	156	+	}
	157	+	}
	158	+	c.last = output
	159	+	}
	160	+	if cur := c.all[output]; cur != nil {
	161	+	cur.Move(x, y)
	162	+	}
	163	+	}

M internal/core/action.go +41 -0


@@ -24,6 +24,11 @@ const (
24	ActionFocusWorkspaceDown Action = "focus-workspace-down"	24		ActionFocusWorkspaceDown Action = "focus-workspace-down"
25	ActionMoveToWorkspaceUp Action = "move-to-workspace-up"	25		ActionMoveToWorkspaceUp Action = "move-to-workspace-up"
26	ActionMoveToWorkspaceDown Action = "move-to-workspace-down"	26		ActionMoveToWorkspaceDown Action = "move-to-workspace-down"
		27	+	// Monitors are ordered left to right (ADR 011).
		28	+	ActionFocusMonitorLeft Action = "focus-monitor-left"
		29	+	ActionFocusMonitorRight Action = "focus-monitor-right"
		30	+	ActionMoveWorkspaceLeft Action = "move-workspace-to-monitor-left"
		31	+	ActionMoveWorkspaceRight Action = "move-workspace-to-monitor-right"
27	// Scale steps through the clean scales of the output (see CleanScales).	32		// Scale steps through the clean scales of the output (see CleanScales).
28	ActionScaleUp Action = "scale-up"	33		ActionScaleUp Action = "scale-up"
29	ActionScaleDown Action = "scale-down"	34		ActionScaleDown Action = "scale-down"

@@ -77,6 +82,42 @@ type Effect struct {
77	Quit bool	82		Quit bool
78	}	83		}
79		84
		85	+	// applyAction runs a bind action. Monitor actions change the focused
		86	+	// screen; column focus past the edge column moves to the neighbor screen;
		87	+	// everything else applies to the focused screen's monitor.
		88	+	func (c *Core) applyAction(a Action) Effect {
		89	+	dir := 0
		90	+	switch a {
		91	+	case ActionFocusMonitorLeft, ActionMoveWorkspaceLeft:
		92	+	dir = -1
		93	+	case ActionFocusMonitorRight, ActionMoveWorkspaceRight:
		94	+	dir = 1
		95	+	}
		96	+	switch a {
		97	+	case ActionFocusMonitorLeft, ActionFocusMonitorRight:
		98	+	if i := c.neighbor(dir); i >= 0 {
		99	+	c.focusScreen = i
		100	+	}
		101	+	return Effect{}
		102	+	case ActionMoveWorkspaceLeft, ActionMoveWorkspaceRight:
		103	+	c.moveWorkspace(dir)
		104	+	return Effect{}
		105	+	case ActionFocusColumnLeft, ActionFocusColumnRight:
		106	+	w := c.cur().mon.Current()
		107	+	edge := len(w.Columns) == 0 \|\| (a == ActionFocusColumnLeft && w.Focus == 0) \|\| (a == ActionFocusColumnRight && w.Focus == len(w.Columns)-1)
		108	+	if a == ActionFocusColumnLeft {
		109	+	dir = -1
		110	+	} else {
		111	+	dir = 1
		112	+	}
		113	+	if i := c.neighbor(dir); edge && i >= 0 {
		114	+	c.focusScreen = i
		115	+	return Effect{}
		116	+	}
		117	+	}
		118	+	return c.cur().mon.Apply(a)
		119	+	}
		120	+
80	// Apply runs a bind action on the monitor.	121		// Apply runs a bind action on the monitor.
81	func (m *Monitor) Apply(a Action) Effect {	122		func (m *Monitor) Apply(a Action) Effect {
82	if n, move, ok := WorkspaceArg(a); ok {	123		if n, move, ok := WorkspaceArg(a); ok {

M internal/core/core.go +184 -135

 	"errors"
 	"fmt"
 	"github.com/bnema/nefertty/internal/ports"
+	"slices"
 	"strconv"
 	"strings"
 	"unicode"
 var ErrQuit = errors.New("quit requested")
-// Channels connects the owner to adapters. scenes must have capacity 1: core is
+// Channels connects the owner to adapters. Scenes must have capacity 1: core is
-// its only sender and may drain a stale scene; consumers only receive.
+// its only sender and may drain a stale set; consumers only receive. Each
+// send holds one scene per output.
 type Channels struct {
-	Client       <-chan ports.ClientEvent
+	Client   <-chan ports.ClientEvent
-	Input        <-chan ports.InputEvent
+	Input    <-chan ports.InputEvent
-	Output       <-chan ports.OutputEvent
+	Output   <-chan ports.OutputEvent
-	Config       <-chan ports.ConfigChanged
+	Config   <-chan ports.ConfigChanged
-	Commands     chan<- ports.ClientCommand
+	Commands chan<- ports.ClientCommand
-	Spawn        chan<- ports.SpawnRequest
+	Spawn    chan<- ports.SpawnRequest
-	Scenes       chan ports.Scene
+	Scenes   chan []ports.Scene
+	// Layouts, when set, receives the output layout whenever it changes,
+	// latest first (capacity 1, drained like Scenes). Input and cursors use it.
+	Layouts      chan ports.Layout
 	ConfigErrors chan<- error
 }
 type binding struct {
 type Core struct {
 	ch               Channels
 	cfg              ports.Config
-	ws               *Monitor
+	screens          []*screen
+	focusScreen      int
 	binds            map[binding]Action
 	pressed          map[string]bool
 	sent             map[WindowID]ports.ConfigureWindow
 	pointer          WindowID
 	grab             WindowID
 	buttons          map[uint32]bool
-	cursorX, cursorY float64
+	cursorX, cursorY float64 // global, logical
 	seq              uint64
-	layers           []ports.LayerSurface
+	// layerChanged is set once layer state arrives from wayland.
-	placed           []ports.SceneLayer
+	layerChanged bool
-	layerChanged     bool
+	sentOutputs  ports.SetOutputs
-	// Output in physical pixels. scale comes from output.<name>.scale and
+	specs        []NamedWorkspace
-	// changes live with scale-up/scale-down until the config value changes.
+	presets      []Width
-	outName         string
+	overflow     Overflow
-	physW, physH    int
+	slots        map[slotKey]*slotState
-	scale, cfgScale float64
-	sentScale       ports.SetOutputScale
-	slots           map[slotKey]*slotState
 	// toSpawn holds slots to start; Run sends them (apply has no context).
 	toSpawn     []slotKey
 	sentPending bool
 			continue
 		}
 		switch Action(a) {
-		case "none", ActionSpawnTerminal, ActionFocusColumnLeft, ActionFocusColumnRight, ActionFocusWindowUp, ActionFocusWindowDown, ActionMoveColumnLeft, ActionMoveColumnRight, ActionCycleColumnWidth, ActionToggleFullscreen, ActionCloseWindow, ActionQuit, ActionFocusWorkspaceUp, ActionFocusWorkspaceDown, ActionMoveToWorkspaceUp, ActionMoveToWorkspaceDown:
+		case "none", ActionSpawnTerminal, ActionFocusColumnLeft, ActionFocusColumnRight, ActionFocusWindowUp, ActionFocusWindowDown, ActionMoveColumnLeft, ActionMoveColumnRight, ActionCycleColumnWidth, ActionToggleFullscreen, ActionCloseWindow, ActionQuit, ActionFocusWorkspaceUp, ActionFocusWorkspaceDown, ActionMoveToWorkspaceUp, ActionMoveToWorkspaceDown, ActionFocusMonitorLeft, ActionFocusMonitorRight, ActionMoveWorkspaceLeft, ActionMoveWorkspaceRight:
 		default:
 			return fmt.Errorf("invalid action %q", a)
 		}
 			return fmt.Errorf("invalid workspace %q", ws.Name)
 		}
 		seen[ws.Name] = true
-		named = append(named, NamedWorkspace{Name: ws.Name, Hidden: ws.Hidden, MaxColumns: ws.MaxColumns, Overflow: o})
+		named = append(named, NamedWorkspace{Name: ws.Name, Monitor: ws.Monitor, Hidden: ws.Hidden, MaxColumns: ws.MaxColumns, Overflow: o})
 	}
 	specs, err := parseSlots(cfg.Workspaces)
 	if err != nil {
 	}
 	c.cfg = cfg
 	c.binds = binds
-	c.applyConfigScale()
+	c.specs, c.presets, c.overflow = named, presets, defOverflow
 	c.toSpawn = append(c.toSpawn, c.updateSlots(specs)...)
-	c.ws.SetNamed(named)
+	c.named()
-	c.ws.SetOverflow(defOverflow)
+	for _, s := range c.screens {
-	c.ws.SetMaxColumns(cfg.Layout.MaxColumns)
+		c.settings(s.mon)
-	c.ws.SetPresets(presets)
+	}
-	c.ws.SetGaps(cfg.Layout.Gaps)
+	c.applyConfigScales()
 	return nil
 }
 	return nil
 }
 func New(cfg ports.Config, ch Channels) (*Core, error) {
-	if cap(ch.Scenes) != 1 {
+	if cap(ch.Scenes) != 1 || (ch.Layouts != nil && cap(ch.Layouts) != 1) {
-		return nil, fmt.Errorf("scenes must have capacity 1")
+		return nil, fmt.Errorf("scenes and layouts must have capacity 1")
 	}
-	c := &Core{scale: 1, ws: NewMonitor(), slots: map[slotKey]*slotState{}, ch: ch, pressed: map[string]bool{}, buttons: map[uint32]bool{}, sent: map[WindowID]ports.ConfigureWindow{}}
+	// A placeholder screen holds windows until the first output arrives.
+	c := &Core{screens: []*screen{{mon: NewMonitor(), scale: 1, cfgScale: 1}}, slots: map[slotKey]*slotState{}, ch: ch, pressed: map[string]bool{}, buttons: map[uint32]bool{}, sent: map[WindowID]ports.ConfigureWindow{}}
 	if err := c.apply(cfg); err != nil {
 		return nil, err
 	}
 	}
 }
-// applyConfigScale picks up output.<name>.scale when it changed in the config,
-// replacing any live scale-up/scale-down adjustment.
-func (c *Core) applyConfigScale() {
-	s := 1.0
-	for _, o := range c.cfg.Outputs {
-		if o.Name == c.outName && o.Scale != 0 {
-			s = o.Scale
-		}
-	}
-	s = SnapScale(s)
-	if s != c.cfgScale {
-		c.cfgScale = s
-		c.setScale(s)
-	}
-}
-// setScale resizes the logical output; layer placement follows.
-func (c *Core) setScale(s float64) {
-	c.scale = SnapScale(s)
-	c.ws.SetOutput(logical(c.physW, c.scale), logical(c.physH, c.scale))
-	if c.layerChanged {
-		var usable ports.Rect
-		c.placed, usable = arrangeLayers(c.ws.Output().W, c.ws.Output().H, c.layers)
-		c.ws.SetUsable(usable)
-	}
-}
 // clientRect is the placement minus the border drawn around the client.
 // The renderer applies the same inset (ports.Border).
 func (c *Core) clientRect(p Placement) Rect {
 	return Rect{X: r.X + b, Y: r.Y + b, W: r.W - 2*b, H: r.H - 2*b}
 }
-// visible reports whether the window is on screen on the active workspace.
+// visible reports whether the window is on screen on any output.
 func (c *Core) visible(id WindowID) bool {
-	for _, p := range c.ws.Layout() {
+	for _, sc := range c.screens {
-		if p.ID == id {
+		for _, p := range sc.mon.Layout() {
-			return !p.Hidden
+			if p.ID == id {
+				return !p.Hidden
+			}
 		}
 	}
 	return false
 }
 // keyboardFocus is the mapped top/overlay layer with exclusive keyboard
-// interactivity and the highest ID, else the focused window. On-demand layers
+// interactivity and the highest ID on any output, else the focused window of
-// never take focus automatically. When the layer unmaps, focus returns to the window.
+// the focused output. On-demand layers never take focus automatically. When
+// the layer unmaps, focus returns to the window.
 func (c *Core) keyboardFocus() WindowID {
 	var layer WindowID
-	for _, l := range c.layers {
+	for _, sc := range c.screens {
-		if l.Keyboard == 1 && (l.Layer == ports.LayerTop || l.Layer == ports.LayerOverlay) && l.ID > layer {
+		for _, l := range sc.layers {
-			layer = l.ID
+			if l.Keyboard == 1 && (l.Layer == ports.LayerTop || l.Layer == ports.LayerOverlay) && l.ID > layer {
+				layer = l.ID
+			}
 		}
 	}
 	if layer != 0 {
 		return layer
 	}
-	id, _ := c.ws.Focused()
+	id, _ := c.cur().mon.Focused()
 	return id
 }
+// setLayers splits the mapped layer surfaces by output. A surface without an
+// output, or on an unknown one, goes to the focused output.
+func (c *Core) setLayers(all []ports.LayerSurface) {
+	for _, sc := range c.screens {
+		sc.layers = nil
+	}
+	for _, l := range all {
+		sc := c.cur()
+		if i := c.screenIndex(l.Output); i >= 0 {
+			sc = c.screens[i]
+		}
+		sc.layers = append(sc.layers, l)
+	}
+	for _, sc := range c.screens {
+		sc.arrange()
+	}
+}
 func (c *Core) publish(ctx context.Context) error {
-	// Clients learn the new scale before the configures sized for it.
+	// Clients learn outputs and scales before the configures sized for them.
-	if v := (ports.SetOutputScale{Scale: c.scale, Width: c.ws.Output().W, Height: c.ws.Output().H}); v != c.sentScale {
+	if v := (ports.SetOutputs{Outputs: c.layout(), Focused: c.cur().name()}); !sameOutputs(v, c.sentOutputs) {
 		if err := c.command(ctx, v); err != nil {
 			return err
 		}
-		c.sentScale = v
+		if !slices.Equal(v.Outputs, c.sentOutputs.Outputs) && c.ch.Layouts != nil {
+			latest(c.ch.Layouts, v.Outputs)
+		}
+		c.sentOutputs = v
 	}
 	if err := c.publishPending(ctx); err != nil {
 		return err
 	}
-	c.seq++
-	scene := ports.Scene{Seq: c.seq, OutputWidth: c.ws.Output().W, OutputHeight: c.ws.Output().H, Scale: c.scale, Background: c.cfg.Background.Color, Border: ports.Border{Width: c.cfg.Border.Width, Active: c.cfg.Border.Active, Inactive: c.cfg.Border.Inactive}, Windows: make([]ports.SceneWindow, 0), Layers: append([]ports.SceneLayer(nil), c.placed...)}
 	alive := map[WindowID]bool{}
 	focus := c.keyboardFocus()
-	for _, p := range c.ws.Layout() {
+	scenes := make([]ports.Scene, 0, len(c.screens))
-		alive[p.ID] = true
+	// Before the first output (and after the last is unplugged) the
-		scene.Windows = append(scene.Windows, ports.SceneWindow{ID: p.ID, Rect: p.Rect, Focused: p.Focused, Fullscreen: p.Fullscreen, Hidden: p.Hidden, Borderless: p.Borderless})
+	// placeholder's scene has no output name: no renderer draws it.
-		if p.Hidden {
+	for i, sc := range c.screens {
-			if old, ok := c.sent[p.ID]; ok && old.Activated {
+		c.seq++
-				old.Activated = false
+		o := sc.mon.Output()
-				if err := c.command(ctx, old); err != nil {
+		scene := ports.Scene{Output: sc.name(), Seq: c.seq, OutputWidth: o.W, OutputHeight: o.H, Scale: sc.scale, Background: c.cfg.Background.Color, Border: ports.Border{Width: c.cfg.Border.Width, Active: c.cfg.Border.Active, Inactive: c.cfg.Border.Inactive}, Windows: make([]ports.SceneWindow, 0), Layers: append([]ports.SceneLayer(nil), sc.placed...)}
-					return err
+		for _, p := range sc.mon.Layout() {
+			alive[p.ID] = true
+			// Only the focused output shows the focused border.
+			focused := p.Focused && i == c.focusScreen
+			scene.Windows = append(scene.Windows, ports.SceneWindow{ID: p.ID, Rect: p.Rect, Focused: focused, Fullscreen: p.Fullscreen, Hidden: p.Hidden, Borderless: p.Borderless})
+			if p.Hidden {
+				if old, ok := c.sent[p.ID]; ok && (old.Activated || old.Output != "") {
+					old.Activated, old.Output = false, ""
+					if err := c.command(ctx, old); err != nil {
+						return err
+					}
+					c.sent[p.ID] = old
 				}
-				c.sent[p.ID] = old
+				continue
 			}
-			continue
+			r := c.clientRect(p)
-		}
+			v := ports.ConfigureWindow{ID: p.ID, Width: r.W, Height: r.H, Fullscreen: p.Fullscreen, Activated: focused, Output: sc.name()}
-		r := c.clientRect(p)
+			if old, ok := c.sent[p.ID]; !ok || old != v {
-		v := ports.ConfigureWindow{ID: p.ID, Width: r.W, Height: r.H, Fullscreen: p.Fullscreen, Activated: p.Focused}
+				if err := c.command(ctx, v); err != nil {
-		if old, ok := c.sent[p.ID]; !ok || old != v {
+					return err
-			if err := c.command(ctx, v); err != nil {
+				}
-				return err
+				c.sent[p.ID] = v
 			}
-			c.sent[p.ID] = v
 		}
+		scenes = append(scenes, scene)
 	}
 	for id := range c.sent {
 		if !alive[id] {
 		}
 		c.focus = focus
 	}
-	// Only the owner sends and drains; a renderer only receives.
+	latest(c.ch.Scenes, scenes)
+	return nil
+}
+// latest replaces any unread value: only the owner sends and drains;
+// consumers only receive.
+func latest[T any](ch chan T, v T) {
 	select {
-	case c.ch.Scenes <- scene:
+	case ch <- v:
 	default:
 		select {
-		case <-c.ch.Scenes:
+		case <-ch:
 		default:
 		}
 		select {
-		case c.ch.Scenes <- scene:
+		case ch <- v:
 		default:
 		}
 	}
-	return nil
 }
+func sameOutputs(a, b ports.SetOutputs) bool {
+	return a.Focused == b.Focused && slices.Equal(a.Outputs, b.Outputs)
+}
+// allLayers lists the layer surfaces of every output.
+func (c *Core) allLayers() []ports.LayerSurface {
+	var all []ports.LayerSurface
+	for _, sc := range c.screens {
+		all = append(all, sc.layers...)
+	}
+	return all
+}
+// hit returns the window under the global logical point and the point in
+// its surface coordinates. Fullscreen wins; otherwise the last visible
+// placement is topmost.
+func (c *Core) hit(x, y float64) (WindowID, float64, float64) {
+	o, ok := c.layout().At(x, y)
+	if !ok {
+		return 0, 0, 0
+	}
+	lx, ly := x-float64(o.X), y-float64(o.Y)
+	var id WindowID
+	var sx, sy float64
+	for _, p := range c.screens[c.screenIndex(o.Info.Name)].mon.Layout() {
+		r := c.clientRect(p)
+		if !p.Hidden && r.W > 0 && r.H > 0 && lx >= float64(r.X) && lx < float64(r.X+r.W) && ly >= float64(r.Y) && ly < float64(r.Y+r.H) {
+			if id == 0 || p.Fullscreen {
+				id, sx, sy = p.ID, lx-float64(r.X), ly-float64(r.Y)
+			}
+			if p.Fullscreen {
+				break
+			}
+		}
+	}
+	return id, sx, sy
+}
 func (c *Core) Run(ctx context.Context) error {
 	if c.spawnSlots(ctx, false) != nil || c.publishPending(ctx) != nil {
 		return nil
 			}
 			switch v := ev.(type) {
 			case ports.LayerChanged:
-				c.layers = append([]ports.LayerSurface(nil), v.Layers...)
 				c.layerChanged = true
-				var usable ports.Rect
+				c.setLayers(v.Layers)
-				c.placed, usable = arrangeLayers(c.ws.Output().W, c.ws.Output().H, c.layers)
-				c.ws.SetUsable(usable)
 			case ports.WindowMapped:
 				if v.Slot == "" || !c.placeSlotWindow(v.ID, v.Slot) {
-					c.ws.AddWindow(v.ID)
+					if s, _ := c.screenOf(v.ID); s == nil {
+						c.cur().mon.AddWindow(v.ID)
+					}
 				}
 			case ports.WindowUnmapped:
-				c.ws.RemoveWindow(v.ID)
+				if s, _ := c.screenOf(v.ID); s != nil {
+					s.mon.RemoveWindow(v.ID)
+				}
 				c.releaseSlots()
 				if c.pointer == v.ID {
 					c.pointer = 0
 					}
 				}
 			case ports.WindowFullscreenRequest:
-				c.ws.SetFullscreen(v.ID, v.Fullscreen)
+				if s, _ := c.screenOf(v.ID); s != nil {
+					s.mon.SetFullscreen(v.ID, v.Fullscreen)
+				}
 			}
 			if err := c.publish(ctx); err != nil {
 				return nil
 				continue
 			}
 			switch v := ev.(type) {
-			case ports.OutputMode:
+			case ports.OutputAdded:
-				c.physW, c.physH = v.Width, v.Height
+				c.addScreen(v.Info)
-				if v.Name != c.outName {
+				if c.layerChanged {
-					c.outName, c.cfgScale = v.Name, 0
+					c.setLayers(c.allLayers())
 				}
-				c.applyConfigScale()
+			case ports.OutputRemoved:
-				c.setScale(c.scale)
+				c.removeScreen(v.Name)
-			case ports.OutputUsable:
+				if c.layerChanged {
-				// Once layer state arrives, its exclusive zones take precedence.
+					c.setLayers(c.allLayers())
-				if !c.layerChanged {
-					c.ws.SetUsable(v.Rect)
 				}
+				c.cursorX, c.cursorY = c.layout().Clamp(c.cursorX, c.cursorY, c.cursorX, c.cursorY)
 			}
 			if err := c.publish(ctx); err != nil {
 				return nil
 			}
 			switch v := ev.(type) {
 			case ports.PointerMotion:
-				// Input reports physical pixels; hit-testing is logical.
+				c.cursorX, c.cursorY = c.layout().Clamp(c.cursorX, c.cursorY, v.X, v.Y)
-				c.cursorX = min(max(v.X/c.scale, 0), float64(max(c.ws.Output().W-1, 0)))
+				id, x, y := c.hit(c.cursorX, c.cursorY)
-				c.cursorY = min(max(v.Y/c.scale, 0), float64(max(c.ws.Output().H-1, 0)))
-				var id WindowID
-				var x, y float64
-				// Fullscreen wins; otherwise the last visible placement is topmost.
-				for _, p := range c.ws.Layout() {
-					r := c.clientRect(p)
-					if !p.Hidden && r.W > 0 && r.H > 0 && c.cursorX >= float64(r.X) && c.cursorX < float64(r.X+r.W) && c.cursorY >= float64(r.Y) && c.cursorY < float64(r.Y+r.H) {
-						if id == 0 || p.Fullscreen {
-							id, x, y = p.ID, c.cursorX-float64(r.X), c.cursorY-float64(r.Y)
-						}
-						if p.Fullscreen {
-							break
-						}
-					}
-				}
 				// Layout changes are intentionally re-hit-tested only on motion.
 				if id != c.pointer {
 					c.pointer = id
 					if err := c.command(ctx, ports.PointerButtonTo{ID: id, Button: v.Button, Pressed: v.Pressed, TimeMsec: v.TimeMsec}); err != nil {
 						return nil
 					}
-					if v.Pressed && c.focus != id && c.ws.Current().FocusID(id) {
+					// A click focuses the window and its output.
+					if s, w := c.screenOf(id); v.Pressed && s != nil && w == s.mon.Current() && (c.focus != id || s != c.cur()) {
+						w.FocusID(id)
+						c.focusScreen = c.screenIndex(s.name())
 						if err := c.publish(ctx); err != nil {
 							return nil
 						}
 						if action == ActionScaleDown {
 							dir = -1
 						}
-						c.setScale(StepScale(c.physW, c.physH, c.scale, dir))
+						sc := c.cur()
+						sc.setScale(StepScale(sc.info.Width, sc.info.Height, sc.scale, dir))
+						c.order()
 						if err := c.publish(ctx); err != nil {
 							return nil
 						}
 						continue
 					}
-					before := c.ws.Current()
+					before := c.cur().mon.Current()
-					effect := c.ws.Apply(action)
+					effect := c.applyAction(action)
 					if effect.Quit {
 						return ErrQuit
 					}
 					}
 					// Showing a declared workspace refills its empty slots.
 					c.releaseSlots()
-					if c.spawnSlots(ctx, c.ws.Current() != before) != nil {
+					c.settleGuests()
+					if c.spawnSlots(ctx, c.cur().mon.Current() != before) != nil {
 						return nil
 					}
 					if effect.Close != 0 {

M internal/core/core_test.go +75 -69

 	}
 }
+// scene receives the next scene set and returns the first output's scene.
+func scene(t *testing.T, ch <-chan []ports.Scene) ports.Scene {
+	t.Helper()
+	return receive(t, ch)[0]
+}
 // command receives the next client command, skipping output scale updates.
 func command(t *testing.T, ch <-chan ports.ClientCommand) ports.ClientCommand {
 	t.Helper()
 	for {
 		if v := receive(t, ch); v != nil {
-			if _, ok := v.(ports.SetOutputScale); !ok {
+			if _, ok := v.(ports.SetOutputs); !ok {
 				return v
 			}
 		}
 	reload := make(chan ports.ConfigChanged, 8)
 	commands := make(chan ports.ClientCommand, 256)
 	spawn := make(chan ports.SpawnRequest, 8)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	errs := make(chan error, 8)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Config: reload, Commands: commands, Spawn: spawn, Scenes: scenes, ConfigErrors: errs})
 	if err != nil {
 	defer cancel()
 	done := make(chan error, 1)
 	go func() { done <- c.Run(ctx) }()
-	output <- ports.OutputMode{Width: 100, Height: 80}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
-	s := receive(t, scenes)
+	s := scene(t, scenes)
 	if s.OutputWidth != 100 {
 		t.Fatal(s)
 	}
 	client <- ports.WindowMapped{ID: 1}
-	s = receive(t, scenes)
+	s = scene(t, scenes)
 	// A single column fills the usable width.
 	if len(s.Windows) != 1 || s.Windows[0].Rect.W != 84 || !s.Windows[0].Borderless {
 		t.Fatal(s)
 	}
-	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: 84, Height: 64, Activated: true}) {
+	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: 84, Height: 64, Activated: true, Output: "OUT-1"}) {
 		t.Fatal(v)
 	}
 	command(t, commands)
 	client <- ports.WindowMapped{ID: 2}
-	s = receive(t, scenes)
+	s = scene(t, scenes)
 	if len(s.Windows) != 2 {
 		t.Fatal(s)
 	}
 		<-commands
 	}
 	client <- ports.WindowMapped{ID: 2}
-	receive(t, scenes)
+	scene(t, scenes)
 	if len(commands) != 0 {
 		t.Fatal("duplicate configure")
 	}
 	input <- ports.KeyEvent{Keysym: "Return", Mods: ports.ModAlt, Pressed: true}
-	receive(t, scenes)
+	scene(t, scenes)
 	if v := receive(t, spawn); len(v.Argv) != 1 || v.Argv[0] != "foot" {
 		t.Fatal(v)
 	}
 		t.Fatal(v)
 	}
 	input <- ports.KeyEvent{Keysym: "Q", Mods: ports.ModAlt, Pressed: true}
-	receive(t, scenes)
+	scene(t, scenes)
 	if v := command(t, commands); v != (ports.CloseWindow{ID: 2}) {
 		t.Fatal(v)
 	}
 	client <- ports.WindowUnmapped{ID: 2}
-	receive(t, scenes)
+	scene(t, scenes)
 	for len(commands) > 0 {
 		<-commands
 	}
 	cfg.Layout.Gaps = 4
 	reload <- ports.ConfigChanged{Config: cfg}
-	s = receive(t, scenes)
+	s = scene(t, scenes)
 	if s.Windows[0].Rect.W != 92 {
 		t.Fatal(s)
 	}
-	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: 92, Height: 72, Activated: true}) {
+	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: 92, Height: 72, Activated: true, Output: "OUT-1"}) {
 		t.Fatal(v)
 	}
 	cfg.Layout.MaxColumns = 0
 }
 func TestCancelAndSceneCapacity(t *testing.T) {
 	cfg := config.Defaults()
-	if _, err := core.New(cfg, core.Channels{Scenes: make(chan ports.Scene, 2)}); err == nil {
+	if _, err := core.New(cfg, core.Channels{Scenes: make(chan []ports.Scene, 2)}); err == nil {
 		t.Fatal("capacity")
 	}
 	ctx, cancel := context.WithCancel(context.Background())
-	c, err := core.New(cfg, core.Channels{Scenes: make(chan ports.Scene, 1)})
+	c, err := core.New(cfg, core.Channels{Scenes: make(chan []ports.Scene, 1)})
 	if err != nil {
 		t.Fatal(err)
 	}
 	client := make(chan ports.ClientEvent, 8)
 	input := make(chan ports.InputEvent, 8)
 	commands := make(chan ports.ClientCommand, 16)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	go func() { done <- c.Run(ctx) }()
 	defer func() { cancel(); receive(t, done) }()
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
 	command(t, commands)
 	command(t, commands)
 	press := ports.KeyEvent{Keysym: "Left", Mods: ports.ModSuper, Pressed: true}
 	input <- press
-	receive(t, scenes)
+	scene(t, scenes)
 	input <- ports.KeyEvent{Keysym: "Left", Mods: ports.ModSuper}
 	input <- ports.KeyEvent{Keysym: "Left", Pressed: true}
 	if v := command(t, commands); v != (ports.ForwardKey{ID: 1, Key: ports.KeyEvent{Keysym: "Left", Pressed: true}}) {
 		t.Fatal(v)
 	}
 	input <- press
-	receive(t, scenes)
+	scene(t, scenes)
 	input <- ports.KeyEvent{Keysym: "Left", Pressed: true}
 	command(t, commands)
 	input <- ports.KeyEvent{Keysym: "Left"}
 	input := make(chan ports.InputEvent, 4)
 	client := make(chan ports.ClientEvent, 2)
 	commands := make(chan ports.ClientCommand, 8)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Input: input, Client: client, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	go func() { done <- c.Run(ctx) }()
 	defer func() { cancel(); receive(t, done) }()
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
 	command(t, commands)
 	command(t, commands)
 	input <- ports.KeyEvent{Keysym: "Left", Mods: ports.ModSuper, Pressed: true}
-	receive(t, scenes)
+	scene(t, scenes)
 	input <- ports.KeyEvent{Keysym: "Left"}
 	input <- ports.KeyEvent{Keysym: "x", Pressed: true}
 	if v := command(t, commands); v != (ports.ForwardKey{ID: 1, Key: ports.KeyEvent{Keysym: "x", Pressed: true}}) {
 	input := make(chan ports.InputEvent, 8)
 	output := make(chan ports.OutputEvent, 8)
 	commands := make(chan ports.ClientCommand, 64)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	go c.Run(ctx)
-	output <- ports.OutputMode{Width: 100, Height: 80}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
-	receive(t, scenes)
+	scene(t, scenes)
 	client <- ports.WindowMapped{ID: 1}
-	first := receive(t, scenes).Windows[0].Rect
+	first := scene(t, scenes).Windows[0].Rect
 	client <- ports.WindowMapped{ID: 2}
-	receive(t, scenes)
+	scene(t, scenes)
 	for len(commands) > 0 {
 		<-commands
 	}
 	if v := command(t, commands); v != (ports.PointerButtonTo{ID: 1, Button: 0x110, Pressed: true}) {
 		t.Fatal(v)
 	}
-	receive(t, scenes)
+	scene(t, scenes)
 	found := false
 	for len(commands) > 0 {
 		if v, ok := (<-commands).(ports.FocusWindow); ok && v.ID == 1 {
 	input := make(chan ports.InputEvent, 8)
 	output := make(chan ports.OutputEvent, 8)
 	commands := make(chan ports.ClientCommand, 64)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	go c.Run(ctx)
-	output <- ports.OutputMode{Width: 100, Height: 80}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
-	receive(t, scenes)
+	scene(t, scenes)
 	// Alone, the window is borderless and gets the full rect.
 	client <- ports.WindowMapped{ID: 1}
-	r := receive(t, scenes).Windows[0].Rect
+	r := scene(t, scenes).Windows[0].Rect
-	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: r.W, Height: r.H, Activated: true}) {
+	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: r.W, Height: r.H, Activated: true, Output: "OUT-1"}) {
 		t.Fatalf("%v for outer %v", v, r)
 	}
 	// With a second column, the scene keeps the outer rect and the client is
 	// configured 2px smaller on each side.
 	client <- ports.WindowMapped{ID: 2}
-	s := receive(t, scenes)
+	s := scene(t, scenes)
 	r = s.Windows[1].Rect
 	if s.Windows[1].ID != 2 || s.Windows[1].Borderless {
 		t.Fatal(s)
 	}
-	want := ports.ConfigureWindow{ID: 2, Width: r.W - 4, Height: r.H - 4, Activated: true}
+	want := ports.ConfigureWindow{ID: 2, Width: r.W - 4, Height: r.H - 4, Activated: true, Output: "OUT-1"}
 	found := false
 	for len(commands) > 0 {
 		if v := <-commands; v == want {
 	input := make(chan ports.InputEvent, 8)
 	output := make(chan ports.OutputEvent, 8)
 	commands := make(chan ports.ClientCommand, 64)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	go c.Run(ctx)
-	output <- ports.OutputMode{Width: 100, Height: 80}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
-	receive(t, scenes)
+	scene(t, scenes)
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
 	focusOf := func() ports.WindowID {
 		t.Helper()
 		for {
 	launcher := ports.LayerSurface{ID: 7, Layer: ports.LayerOverlay, Width: 40, Height: 20, Keyboard: 1}
 	bar := ports.LayerSurface{ID: 6, Layer: ports.LayerTop, Anchor: ports.AnchorTop | ports.AnchorLeft | ports.AnchorRight, Height: 5, Keyboard: 2}
 	client <- ports.LayerChanged{Layers: []ports.LayerSurface{bar, launcher}}
-	receive(t, scenes)
+	scene(t, scenes)
 	if id := focusOf(); id != 7 {
 		t.Fatalf("layer focus %d", id)
 	}
 		}
 	}
 	client <- ports.LayerChanged{Layers: []ports.LayerSurface{bar}}
-	receive(t, scenes)
+	scene(t, scenes)
 	if id := focusOf(); id != 1 {
 		t.Fatalf("focus not restored: %d", id)
 	}
 	input := make(chan ports.InputEvent, 8)
 	output := make(chan ports.OutputEvent, 8)
 	commands := make(chan ports.ClientCommand, 64)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	go c.Run(ctx)
-	output <- ports.OutputMode{Width: 100, Height: 80}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
-	receive(t, scenes)
+	scene(t, scenes)
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
 	for len(commands) > 0 {
 		<-commands
 	}
 	// AZERTY: the 2 key prints eacute; the default bind is on its physical key (code 3).
 	input <- ports.KeyEvent{Keysym: "eacute", Base: "eacute", Keycode: 3, Mods: ports.ModSuper, Pressed: true}
-	s := receive(t, scenes)
+	s := scene(t, scenes)
 	if len(s.Windows) != 1 || !s.Windows[0].Hidden {
 		t.Fatal(s)
 	}
 	}
 	// A new window opens on workspace 2, alone and borderless.
 	client <- ports.WindowMapped{ID: 2}
-	s = receive(t, scenes)
+	s = scene(t, scenes)
 	if len(s.Windows) != 2 || s.Windows[1].ID != 2 || s.Windows[1].Hidden || !s.Windows[1].Borderless {
 		t.Fatal(s)
 	}
 	input := make(chan ports.InputEvent, 8)
 	output := make(chan ports.OutputEvent, 8)
 	commands := make(chan ports.ClientCommand, 64)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	go c.Run(ctx)
-	output <- ports.OutputMode{Width: 100, Height: 80}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
-	receive(t, scenes)
+	scene(t, scenes)
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
 	input <- ports.PointerMotion{X: 50, Y: 40}
 	for len(commands) < 3 {
 		time.Sleep(time.Millisecond)
 	}
 	// Cmd+2 hides window 1; the pointer must leave it.
 	input <- ports.KeyEvent{Keysym: "2", Keycode: 3, Mods: ports.ModSuper, Pressed: true}
-	receive(t, scenes)
+	scene(t, scenes)
 	var cleared bool
 	for len(commands) > 0 {
 		if v, ok := (<-commands).(ports.PointerFocus); ok && v.ID == 0 {
 	input <- ports.PointerButton{Button: 0x110, Pressed: true}
 	input <- ports.PointerButton{Button: 0x110}
 	client <- ports.WindowMapped{ID: 2}
-	s := receive(t, scenes)
+	s := scene(t, scenes)
 	if s.Windows[0].ID != 1 || !s.Windows[0].Hidden || s.Windows[1].Hidden {
 		t.Fatal(s)
 	}
 	input := make(chan ports.InputEvent, 8)
 	client := make(chan ports.ClientEvent, 2)
 	commands := make(chan ports.ClientCommand, 16)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Input: input, Client: client, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	defer cancel()
 	go c.Run(ctx)
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
 	for len(commands) > 0 {
 		<-commands
 	}
 	// US Cmd+Shift+1 prints exclam; the physical key (code 2) matches move-to-workspace 1.
 	input <- ports.KeyEvent{Keysym: "exclam", Base: "1", Keycode: 2, Mods: ports.ModSuper | ports.ModShift, Pressed: true}
-	receive(t, scenes)
+	scene(t, scenes)
 	// Shift goes up first, so the release reports "1": still swallowed.
 	input <- ports.KeyEvent{Keysym: "1", Keycode: 2, Mods: ports.ModSuper}
 	input <- ports.KeyEvent{Keysym: "x", Keycode: 45, Pressed: true}
 	output := make(chan ports.OutputEvent, 8)
 	reload := make(chan ports.ConfigChanged, 1)
 	commands := make(chan ports.ClientCommand, 64)
-	scenes := make(chan ports.Scene, 1)
+	scenes := make(chan []ports.Scene, 1)
 	c, err := core.New(cfg, core.Channels{Client: client, Input: input, Output: output, Config: reload, Commands: commands, Scenes: scenes})
 	if err != nil {
 		t.Fatal(err)
 	defer cancel()
 	go c.Run(ctx)
 	// 5120x2160 at scale 2 is 2560x1080 logical.
-	output <- ports.OutputMode{Width: 5120, Height: 2160, Name: "DP-2"}
+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "DP-2", Width: 5120, Height: 2160}}
-	s := receive(t, scenes)
+	s := scene(t, scenes)
 	if s.Scale != 2 || s.OutputWidth != 2560 || s.OutputHeight != 1080 {
 		t.Fatal(s.Scale, s.OutputWidth, s.OutputHeight)
 	}
-	if v := receive(t, commands); v != (ports.SetOutputScale{Scale: 2, Width: 2560, Height: 1080}) {
+	if v := receive(t, commands).(ports.SetOutputs); len(v.Outputs) != 1 || v.Outputs[0].Scale != 2 || v.Outputs[0].Width != 2560 || v.Outputs[0].Height != 1080 || v.Focused != "DP-2" {
 		t.Fatal(v)
 	}
 	client <- ports.WindowMapped{ID: 1}
-	receive(t, scenes)
+	scene(t, scenes)
-	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: 2560, Height: 1080, Activated: true}) {
+	if v := command(t, commands); v != (ports.ConfigureWindow{ID: 1, Width: 2560, Height: 1080, Activated: true, Output: "DP-2"}) {
 		t.Fatal(v)
 	}
 	for len(commands) > 0 {
 		<-commands
 	}
-	// The pointer arrives in physical pixels; the client sees logical ones.
+	// The pointer arrives in global logical pixels.
-	input <- ports.PointerMotion{X: 1000, Y: 400}
+	input <- ports.PointerMotion{X: 500, Y: 200}
 	if v := command(t, commands); v != (ports.PointerFocus{ID: 1, X: 500, Y: 200}) {
 		t.Fatal(v)
 	}
 	// Cmd+- steps down through the clean scales of 5120x2160: 2 → 5/3.
 	input <- ports.KeyEvent{Keysym: "minus", Keycode: 12, Mods: ports.ModSuper, Pressed: true}
-	s = receive(t, scenes)
+	s = scene(t, scenes)
 	if s.Scale != 5.0/3 || s.OutputWidth != 3072 || s.OutputHeight != 1296 {
 		t.Fatal(s.Scale, s.OutputWidth, s.OutputHeight)
 	}
 	input <- ports.KeyEvent{Keysym: "minus", Keycode: 12, Mods: ports.ModSuper}
 	input <- ports.KeyEvent{Keysym: "equal", Keycode: 13, Mods: ports.ModSuper, Pressed: true}
-	if s = receive(t, scenes); s.Scale != 2 {
+	if s = scene(t, scenes); s.Scale != 2 {
 		t.Fatal(s.Scale)
 	}
 	// A reload that keeps the config scale keeps the live one too.
 	input <- ports.KeyEvent{Keysym: "equal", Keycode: 13, Mods: ports.ModSuper}
 	input <- ports.KeyEvent{Keysym: "equal", Keycode: 13, Mods: ports.ModSuper, Pressed: true}
-	if s = receive(t, scenes); s.Scale != 2.5 {
+	if s = scene(t, scenes); s.Scale != 2.5 {
 		t.Fatal(s.Scale)
 	}
 	cfg.Layout.Gaps = 1
 	reload <- ports.ConfigChanged{Config: cfg}
-	if s = receive(t, scenes); s.Scale != 2.5 {
+	if s = scene(t, scenes); s.Scale != 2.5 {
 		t.Fatal(s.Scale)
 	}
 	// Changing the config scale wins.
 	cfg.Outputs = []ports.OutputConfig{{Name: "DP-2", Scale: 1.25}}
 	reload <- ports.ConfigChanged{Config: cfg}
-	if s = receive(t, scenes); s.Scale != 1.25 || s.OutputWidth != 4096 {
+	if s = scene(t, scenes); s.Scale != 1.25 || s.OutputWidth != 4096 {
 		t.Fatal(s.Scale, s.OutputWidth)
 	}
 }

M internal/core/layers_test.go +3 -3


@@ -53,7 +53,7 @@ func TestLayerChangedChannels(t *testing.T) {
53		client := make(chan ports.ClientEvent)	53		client := make(chan ports.ClientEvent)
54		output := make(chan ports.OutputEvent)	54		output := make(chan ports.OutputEvent)
55		commands := make(chan ports.ClientCommand, 16)	55		commands := make(chan ports.ClientCommand, 16)
56	-	scenes := make(chan ports.Scene, 1)	56	+	scenes := make(chan []ports.Scene, 1)
57		cfg := ports.Config{}	57		cfg := ports.Config{}
58		cfg.Keyboard.CmdKey = "super"	58		cfg.Keyboard.CmdKey = "super"
59		cfg.Layout.MaxColumns = 2	59		cfg.Layout.MaxColumns = 2

@@ -69,13 +69,13 @@ func TestLayerChangedChannels(t *testing.T) {
69		t.Helper()	69		t.Helper()
70		select {	70		select {
71		case s := <-scenes:	71		case s := <-scenes:
72	-	return s	72	+	return s[0]
73		case <-time.After(time.Second):	73		case <-time.After(time.Second):
74		t.Fatal("scene timeout")	74		t.Fatal("scene timeout")
75		return ports.Scene{}	75		return ports.Scene{}
76		}	76		}
77		}	77		}
78	-	output <- ports.OutputMode{Width: 1920, Height: 1080}	78	+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 1920, Height: 1080}}
79		recv()	79		recv()
80		client <- ports.WindowMapped{ID: 1}	80		client <- ports.WindowMapped{ID: 1}
81		before := recv()	81		before := recv()

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


@@ -120,6 +120,11 @@ type Workspace struct {
120	MaxColumns int	120		MaxColumns int
121	presets []Width	121		presets []Width
122	fullscreen WindowID	122		fullscreen WindowID
		123	+	// home is the monitor (key or connector) the workspace belongs to; ""
		124	+	// means the one it is on. On another monitor it is a guest; homePos is
		125	+	// its position there, where it returns.
		126	+	home string
		127	+	homePos int
123	}	128		}
124		129
125	func (w *Workspace) empty() bool { return len(w.Columns) == 0 }	130		func (w *Workspace) empty() bool { return len(w.Columns) == 0 }

M internal/core/monitor.go +76 -3

@@ -1,5 +1,7 @@
1		package core	1		package core
2			2
			3	+	import "slices"
			4	+
3		// Monitor owns an ordered list of workspaces for one output (ADR 011). Numbers	5		// Monitor owns an ordered list of workspaces for one output (ADR 011). Numbers
4		// are positions: Cmd+N targets Workspaces[N-1]. An empty workspace always sits	6		// are positions: Cmd+N targets Workspaces[N-1]. An empty workspace always sits
5		// below the last one, and an empty unnamed workspace is removed once left,	7		// below the last one, and an empty unnamed workspace is removed once left,

@@ -9,6 +11,10 @@ package core
9		// A hidden one is not numbered and not reachable by up/down: only its	11		// A hidden one is not numbered and not reachable by up/down: only its
10		// `workspace <name>` bind shows it.	12		// `workspace <name>` bind shows it.
11		type Monitor struct {	13		type Monitor struct {
			14	+	// Name is the connector; Key identifies the physical monitor (make,
			15	+	// model and serial, else the connector). Workspaces remember the Key of
			16	+	// their home monitor.
			17	+	Name, Key string
12		Workspaces []*Workspace	18		Workspaces []*Workspace
13		Active int	19		Active int
14		hidden []*Workspace	20		hidden []*Workspace

@@ -21,18 +27,84 @@ type Monitor struct {
21		// NamedWorkspace configures a named workspace. Zero MaxColumns and an empty	27		// NamedWorkspace configures a named workspace. Zero MaxColumns and an empty
22		// Overflow follow the monitor defaults.	28		// Overflow follow the monitor defaults.
23		type NamedWorkspace struct {	29		type NamedWorkspace struct {
24	-	Name string	30	+	Name string
			31	+	// Monitor is the home monitor (connector or key); "" for the first one.
			32	+	Monitor string
25		Hidden bool	33		Hidden bool
26		MaxColumns int	34		MaxColumns int
27		Overflow Overflow	35		Overflow Overflow
28		}	36		}
29			37
30	-	func NewMonitor() *Monitor {	38	+	func NewMonitor() *Monitor { return newMonitor("", "") }
31	-	m := &Monitor{}	39	+
			40	+	func newMonitor(name, key string) *Monitor {
			41	+	m := &Monitor{Name: name, Key: key}
32		m.normalize()	42		m.normalize()
33		return m	43		return m
34		}	44		}
35			45
			46	+	// matches reports whether home designates this monitor, by key or connector.
			47	+	func (m *Monitor) matches(home string) bool {
			48	+	return home != "" && (home == m.Key \|\| home == m.Name)
			49	+	}
			50	+
			51	+	// all lists every workspace, numbered then hidden.
			52	+	func (m Monitor) all() []Workspace {
			53	+	return append(append([]*Workspace(nil), m.Workspaces...), m.hidden...)
			54	+	}
			55	+
			56	+	// isHidden reports whether w is in the hidden list.
			57	+	func (m Monitor) isHidden(w Workspace) bool { return indexOf(m.hidden, w) >= 0 }
			58	+
			59	+	// take removes w from the monitor. The monitor keeps a workspace on screen:
			60	+	// the one at the same position, or the numbered active one.
			61	+	func (m Monitor) take(w Workspace) {
			62	+	if m.back == w {
			63	+	m.back = nil
			64	+	}
			65	+	if i := indexOf(m.hidden, w); i >= 0 {
			66	+	m.hidden = append(m.hidden[:i], m.hidden[i+1:]...)
			67	+	if m.shown == w {
			68	+	m.shown = nil
			69	+	}
			70	+	m.normalize()
			71	+	return
			72	+	}
			73	+	if i := indexOf(m.Workspaces, w); i >= 0 {
			74	+	m.removeNumbered(i)
			75	+	m.normalize()
			76	+	}
			77	+	}
			78	+
			79	+	// adopt adds a workspace from another monitor: hidden, or numbered at pos
			80	+	// (clamped above the trailing empty workspace). It takes this monitor's
			81	+	// output-wide settings and does not change what is on screen.
			82	+	func (m Monitor) adopt(w Workspace, hidden bool, pos int) {
			83	+	w.presets = append([]Width(nil), m.template.presets...)
			84	+	w.Gaps = m.template.Gaps
			85	+	w.SetOutput(m.template.Output.W, m.template.Output.H)
			86	+	w.SetUsable(m.template.Usable)
			87	+	if hidden {
			88	+	m.hidden = append(m.hidden, w)
			89	+	} else {
			90	+	// normalize keeps a trailing empty workspace: stay above it.
			91	+	at := min(max(pos, 0), len(m.Workspaces)-1)
			92	+	m.Workspaces = slices.Insert(m.Workspaces, at, w)
			93	+	if at <= m.Active {
			94	+	m.Active++
			95	+	}
			96	+	}
			97	+	m.applyNamed()
			98	+	m.normalize()
			99	+	}
			100	+
			101	+	// useSpecs sets the overrides of every named workspace, including those
			102	+	// that live on other monitors and may move here.
			103	+	func (m *Monitor) useSpecs(all []NamedWorkspace) {
			104	+	m.named = append([]NamedWorkspace(nil), all...)
			105	+	m.applyNamed()
			106	+	}
			107	+
36		// Current is the workspace on screen.	108		// Current is the workspace on screen.
37		func (m Monitor) Current() Workspace {	109		func (m Monitor) Current() Workspace {
38		if m.shown != nil {	110		if m.shown != nil {

@@ -44,6 +116,7 @@ func (m Monitor) Current() Workspace {
44		func (m Monitor) newWorkspace() Workspace {	116		func (m Monitor) newWorkspace() Workspace {
45		w := m.template	117		w := m.template
46		w.presets = append([]Width(nil), m.template.presets...)	118		w.presets = append([]Width(nil), m.template.presets...)
			119	+	w.Columns, w.home = nil, ""
47		return &w	120		return &w
48		}	121		}
49			122

A internal/core/screens.go +308 -0

@@ -0,0 +1,308 @@
	1	+	package core
	2	+
	3	+	import (
	4	+	"slices"
	5	+
	6	+	"github.com/bnema/nefertty/internal/ports"
	7	+	)
	8	+
	9	+	// screen is one connected output: its monitor tree, scale, layer surfaces and
	10	+	// place in the global layout (ADR 011). Outputs are placed left to right, in
	11	+	// config order (output.<name>.*), then in connection order.
	12	+	type screen struct {
	13	+	info ports.OutputInfo
	14	+	mon *Monitor
	15	+	scale, cfgScale float64
	16	+	x int // logical left edge in the global layout
	17	+	layers []ports.LayerSurface
	18	+	placed []ports.SceneLayer
	19	+	}
	20	+
	21	+	func (s *screen) name() string { return s.info.Name }
	22	+
	23	+	func (s *screen) placement() ports.OutputPlacement {
	24	+	o := s.mon.Output()
	25	+	return ports.OutputPlacement{Info: s.info, X: s.x, Width: o.W, Height: o.H, Scale: s.scale}
	26	+	}
	27	+
	28	+	// setScale resizes the logical output; layer placement follows.
	29	+	func (s *screen) setScale(v float64) {
	30	+	s.scale = SnapScale(v)
	31	+	s.mon.SetOutput(logical(s.info.Width, s.scale), logical(s.info.Height, s.scale))
	32	+	s.arrange()
	33	+	}
	34	+
	35	+	// arrange places the layer surfaces and gives workspaces the usable area.
	36	+	func (s *screen) arrange() {
	37	+	var usable ports.Rect
	38	+	o := s.mon.Output()
	39	+	s.placed, usable = arrangeLayers(o.W, o.H, s.layers)
	40	+	s.mon.SetUsable(usable)
	41	+	}
	42	+
	43	+	// order sorts screens by config order, then connection order, and assigns x.
	44	+	func (c *Core) order() {
	45	+	rank := func(s *screen) int {
	46	+	for i, o := range c.cfg.Outputs {
	47	+	if o.Name == s.name() {
	48	+	return i
	49	+	}
	50	+	}
	51	+	return len(c.cfg.Outputs)
	52	+	}
	53	+	focused := c.cur()
	54	+	slices.SortStableFunc(c.screens, func(a, b *screen) int { return rank(a) - rank(b) })
	55	+	c.focusScreen = slices.Index(c.screens, focused)
	56	+	x := 0
	57	+	for _, s := range c.screens {
	58	+	s.x = x
	59	+	x += s.mon.Output().W
	60	+	}
	61	+	}
	62	+
	63	+	// layout lists the connected outputs; the placeholder is not one.
	64	+	func (c *Core) layout() ports.Layout {
	65	+	l := make(ports.Layout, 0, len(c.screens))
	66	+	for _, s := range c.screens {
	67	+	if s.name() != "" {
	68	+	l = append(l, s.placement())
	69	+	}
	70	+	}
	71	+	return l
	72	+	}
	73	+
	74	+	// cur is the focused screen: new windows open there and binds apply to it.
	75	+	func (c Core) cur() screen { return c.screens[c.focusScreen] }
	76	+
	77	+	func (c *Core) screenIndex(name string) int {
	78	+	return slices.IndexFunc(c.screens, func(s *screen) bool { return s.name() == name })
	79	+	}
	80	+
	81	+	// screenOf returns the screen and workspace holding the window.
	82	+	func (c Core) screenOf(id WindowID) (screen, *Workspace) {
	83	+	for _, s := range c.screens {
	84	+	if w, _ := s.mon.find(id); w != nil {
	85	+	return s, w
	86	+	}
	87	+	}
	88	+	return nil, nil
	89	+	}
	90	+
	91	+	// byName finds a named workspace on any screen.
	92	+	func (c Core) byName(name string) (screen, *Workspace) {
	93	+	for _, s := range c.screens {
	94	+	if w := s.mon.byName(name); w != nil {
	95	+	return s, w
	96	+	}
	97	+	}
	98	+	return nil, nil
	99	+	}
	100	+
	101	+	// configScale is output.<name>.scale, else 1.
	102	+	func (c *Core) configScale(name string) float64 {
	103	+	v := 1.0
	104	+	for _, o := range c.cfg.Outputs {
	105	+	if o.Name == name && o.Scale != 0 {
	106	+	v = o.Scale
	107	+	}
	108	+	}
	109	+	return SnapScale(v)
	110	+	}
	111	+
	112	+	// applyConfigScales picks up output.<name>.scale when it changed in the
	113	+	// config, replacing any live scale-up/scale-down adjustment.
	114	+	func (c *Core) applyConfigScales() {
	115	+	for _, s := range c.screens {
	116	+	if v := c.configScale(s.name()); v != s.cfgScale {
	117	+	s.cfgScale = v
	118	+	s.setScale(v)
	119	+	}
	120	+	}
	121	+	c.order()
	122	+	}
	123	+
	124	+	// addScreen handles a connected output or a new mode for a known one. The
	125	+	// first output takes over the placeholder screen core starts with; a new
	126	+	// monitor gets its named workspaces and takes its guests back.
	127	+	func (c *Core) addScreen(info ports.OutputInfo) {
	128	+	if i := c.screenIndex(info.Name); i >= 0 {
	129	+	s := c.screens[i]
	130	+	s.info = info
	131	+	s.setScale(s.scale)
	132	+	c.order()
	133	+	return
	134	+	}
	135	+	var s *screen
	136	+	if len(c.screens) == 1 && c.screens[0].name() == "" {
	137	+	s = c.screens[0]
	138	+	s.info = info
	139	+	} else {
	140	+	s = &screen{info: info, mon: newMonitor(info.Name, info.Key())}
	141	+	c.settings(s.mon)
	142	+	c.screens = append(c.screens, s)
	143	+	}
	144	+	s.mon.Name, s.mon.Key = info.Name, info.Key()
	145	+	s.cfgScale = c.configScale(info.Name)
	146	+	s.setScale(s.cfgScale)
	147	+	c.order()
	148	+	c.named()
	149	+	c.settleGuests()
	150	+	}
	151	+
	152	+	// removeScreen moves every workspace of an unplugged output to the focused
	153	+	// screen (another one if it was focused), numbered ones below its numbered
	154	+	// workspaces, hidden ones hidden. They remember their home and position and
	155	+	// return when it is plugged in again. The last output becomes the
	156	+	// placeholder again: it keeps its windows for the next output.
	157	+	func (c *Core) removeScreen(name string) {
	158	+	i := c.screenIndex(name)
	159	+	if i < 0 {
	160	+	return
	161	+	}
	162	+	if len(c.screens) == 1 {
	163	+	c.screens[0].info = ports.OutputInfo{}
	164	+	c.screens[0].layers = nil
	165	+	return
	166	+	}
	167	+	gone := c.screens[i]
	168	+	focused := c.cur()
	169	+	c.screens = slices.Delete(c.screens, i, i+1)
	170	+	c.focusScreen = max(slices.Index(c.screens, focused), 0)
	171	+	host := c.cur()
	172	+	for pos, w := range gone.mon.Workspaces {
	173	+	if w.empty() && w.Name == "" {
	174	+	continue
	175	+	}
	176	+	switch {
	177	+	case host.mon.matches(w.home):
	178	+	// A guest from the host goes home.
	179	+	w.home = ""
	180	+	host.mon.adopt(w, false, w.homePos)
	181	+	continue
	182	+	case w.home == "":
	183	+	w.home, w.homePos = gone.info.Key(), pos
	184	+	}
	185	+	host.mon.adopt(w, false, len(host.mon.Workspaces))
	186	+	}
	187	+	for _, w := range gone.mon.hidden {
	188	+	switch {
	189	+	case host.mon.matches(w.home):
	190	+	w.home = ""
	191	+	case w.home == "":
	192	+	w.home = gone.info.Key()
	193	+	}
	194	+	host.mon.adopt(w, true, 0)
	195	+	}
	196	+	c.order()
	197	+	}
	198	+
	199	+	// settleGuests returns guests to their connected home monitor, at their
	200	+	// original positions. A guest on screen stays until the user leaves it
	201	+	// (golden rule: automatic events never move the user).
	202	+	func (c *Core) settleGuests() {
	203	+	for _, home := range c.screens {
	204	+	type guest struct {
	205	+	w *Workspace
	206	+	hidden bool
	207	+	}
	208	+	var list []guest
	209	+	for _, host := range c.screens {
	210	+	if host == home {
	211	+	continue
	212	+	}
	213	+	for _, w := range host.mon.all() {
	214	+	if home.mon.matches(w.home) && host.mon.Current() != w {
	215	+	list = append(list, guest{w, host.mon.isHidden(w)})
	216	+	host.mon.take(w)
	217	+	}
	218	+	}
	219	+	}
	220	+	slices.SortStableFunc(list, func(a, b guest) int { return a.w.homePos - b.w.homePos })
	221	+	// A monitor showing an empty workspace (just plugged in) shows
	222	+	// its first returning workspace instead.
	223	+	idle := home.mon.Current().empty() && home.mon.Current().Name == ""
	224	+	for _, g := range list {
	225	+	g.w.home = ""
	226	+	home.mon.adopt(g.w, g.hidden, g.w.homePos)
	227	+	if idle && !g.hidden {
	228	+	home.mon.show(g.w)
	229	+	idle = false
	230	+	}
	231	+	}
	232	+	}
	233	+	}
	234	+
	235	+	// named applies the named workspaces from config. One that exists stays on
	236	+	// its screen; a new one is created on its home monitor, or on the first
	237	+	// screen as a guest when its home is not connected.
	238	+	func (c *Core) named() {
	239	+	target := map[string]*screen{}
	240	+	for _, spec := range c.specs {
	241	+	if s, _ := c.byName(spec.Name); s != nil {
	242	+	target[spec.Name] = s
	243	+	continue
	244	+	}
	245	+	target[spec.Name] = c.screens[0]
	246	+	for _, s := range c.screens {
	247	+	if s.mon.matches(spec.Monitor) {
	248	+	target[spec.Name] = s
	249	+	}
	250	+	}
	251	+	}
	252	+	for _, s := range c.screens {
	253	+	var mine []NamedWorkspace
	254	+	for _, spec := range c.specs {
	255	+	if target[spec.Name] == s {
	256	+	mine = append(mine, spec)
	257	+	}
	258	+	}
	259	+	s.mon.SetNamed(mine)
	260	+	s.mon.useSpecs(c.specs)
	261	+	}
	262	+	for _, spec := range c.specs {
	263	+	s, w := c.byName(spec.Name)
	264	+	w.home = ""
	265	+	if spec.Monitor != "" && !s.mon.matches(spec.Monitor) {
	266	+	w.home = spec.Monitor
	267	+	}
	268	+	}
	269	+	}
	270	+
	271	+	// settings applies output-wide config to a monitor.
	272	+	func (c Core) settings(m Monitor) {
	273	+	m.SetOverflow(c.overflow)
	274	+	m.SetMaxColumns(c.cfg.Layout.MaxColumns)
	275	+	m.SetPresets(c.presets)
	276	+	m.SetGaps(c.cfg.Layout.Gaps)
	277	+	}
	278	+
	279	+	// neighbor returns the screen index left (-1) or right (+1) of the focused
	280	+	// one, or -1 at the edge.
	281	+	func (c *Core) neighbor(dir int) int {
	282	+	i := c.focusScreen + dir
	283	+	if i < 0 \|\| i >= len(c.screens) {
	284	+	return -1
	285	+	}
	286	+	return i
	287	+	}
	288	+
	289	+	// moveWorkspace moves the workspace on screen to the neighbor screen, where
	290	+	// it is appended and shown; it becomes its new home (ADR 011).
	291	+	func (c *Core) moveWorkspace(dir int) {
	292	+	to := c.neighbor(dir)
	293	+	if to < 0 {
	294	+	return
	295	+	}
	296	+	from := c.cur()
	297	+	w := from.mon.Current()
	298	+	if w.empty() && w.Name == "" {
	299	+	return
	300	+	}
	301	+	hidden := from.mon.isHidden(w)
	302	+	from.mon.take(w)
	303	+	w.home = ""
	304	+	dst := c.screens[to]
	305	+	dst.mon.adopt(w, hidden, len(dst.mon.Workspaces))
	306	+	dst.mon.show(w)
	307	+	c.focusScreen = to
	308	+	}

A internal/core/screens_test.go +326 -0

@@ -0,0 +1,326 @@
	1	+	package core_test
	2	+
	3	+	import (
	4	+	"context"
	5	+	"testing"
	6	+
	7	+	"github.com/bnema/nefertty/internal/adapters/config"
	8	+	"github.com/bnema/nefertty/internal/core"
	9	+	"github.com/bnema/nefertty/internal/ports"
	10	+	)
	11	+
	12	+	type multiRig struct {
	13	+	client chan ports.ClientEvent
	14	+	input chan ports.InputEvent
	15	+	output chan ports.OutputEvent
	16	+	reload chan ports.ConfigChanged
	17	+	commands chan ports.ClientCommand
	18	+	scenes chan []ports.Scene
	19	+	cfg ports.Config
	20	+	}
	21	+
	22	+	var (
	23	+	left = ports.OutputInfo{Name: "DP-1", Make: "Acme", Model: "A", Serial: "1", Width: 200, Height: 100}
	24	+	right = ports.OutputInfo{Name: "DP-2", Make: "Acme", Model: "B", Serial: "2", Width: 400, Height: 200}
	25	+	)
	26	+
	27	+	// startMulti runs core with Alt as Cmd, no border and no gaps, and plugs
	28	+	// the given outputs in order.
	29	+	func startMulti(t testing.T, edit func(ports.Config), outs ...ports.OutputInfo) *multiRig {
	30	+	t.Helper()
	31	+	cfg := config.Defaults()
	32	+	cfg.Keyboard.CmdKey = "alt"
	33	+	cfg.Border.Width = 0
	34	+	if edit != nil {
	35	+	edit(&cfg)
	36	+	}
	37	+	r := &multiRig{
	38	+	client: make(chan ports.ClientEvent, 16), input: make(chan ports.InputEvent, 16),
	39	+	output: make(chan ports.OutputEvent, 4), reload: make(chan ports.ConfigChanged, 4),
	40	+	commands: make(chan ports.ClientCommand, 1024), scenes: make(chan []ports.Scene, 1), cfg: cfg,
	41	+	}
	42	+	c, err := core.New(cfg, core.Channels{Client: r.client, Input: r.input, Output: r.output, Config: r.reload, Commands: r.commands, Scenes: r.scenes})
	43	+	if err != nil {
	44	+	t.Fatal(err)
	45	+	}
	46	+	ctx, cancel := context.WithCancel(context.Background())
	47	+	done := make(chan error, 1)
	48	+	go func() { done <- c.Run(ctx) }()
	49	+	t.Cleanup(func() { cancel(); <-done })
	50	+	for _, o := range outs {
	51	+	r.plug(t, o)
	52	+	}
	53	+	return r
	54	+	}
	55	+
	56	+	func (r multiRig) plug(t testing.T, o ports.OutputInfo) []ports.Scene {
	57	+	t.Helper()
	58	+	r.output <- ports.OutputAdded{Info: o}
	59	+	return receive(t, r.scenes)
	60	+	}
	61	+
	62	+	func (r multiRig) key(t testing.T, sym string, mods ports.Mods) []ports.Scene {
	63	+	t.Helper()
	64	+	r.input <- ports.KeyEvent{Keysym: sym, Mods: mods, Pressed: true}
	65	+	s := receive(t, r.scenes)
	66	+	r.input <- ports.KeyEvent{Keysym: sym, Mods: mods}
	67	+	return s
	68	+	}
	69	+
	70	+	func (r multiRig) mapWindow(t testing.T, id ports.WindowID) []ports.Scene {
	71	+	t.Helper()
	72	+	r.client <- ports.WindowMapped{ID: id}
	73	+	return receive(t, r.scenes)
	74	+	}
	75	+
	76	+	// shown returns the visible window IDs of each output, by connector.
	77	+	func shown(set []ports.Scene) map[string][]ports.WindowID {
	78	+	out := map[string][]ports.WindowID{}
	79	+	for _, s := range set {
	80	+	out[s.Output] = []ports.WindowID{}
	81	+	for _, w := range s.Windows {
	82	+	if !w.Hidden {
	83	+	out[s.Output] = append(out[s.Output], w.ID)
	84	+	}
	85	+	}
	86	+	}
	87	+	return out
	88	+	}
	89	+
	90	+	func lastOutputs(t *testing.T, ch chan ports.ClientCommand) ports.SetOutputs {
	91	+	t.Helper()
	92	+	var last ports.SetOutputs
	93	+	found := false
	94	+	for len(ch) > 0 {
	95	+	if v, ok := (<-ch).(ports.SetOutputs); ok {
	96	+	last, found = v, true
	97	+	}
	98	+	}
	99	+	if !found {
	100	+	t.Fatal("no SetOutputs")
	101	+	}
	102	+	return last
	103	+	}
	104	+
	105	+	func TestOutputsLeftToRight(t *testing.T) {
	106	+	r := startMulti(t, func(c *ports.Config) {
	107	+	c.Outputs = []ports.OutputConfig{{Name: "DP-2", Scale: 2}, {Name: "DP-1"}}
	108	+	}, left, right)
	109	+	out := lastOutputs(t, r.commands)
	110	+	// Config order wins: DP-2 (200x100 logical at scale 2), then DP-1.
	111	+	if len(out.Outputs) != 2 \|\| out.Outputs[0].Info.Name != "DP-2" \|\| out.Outputs[0].X != 0 \|\| out.Outputs[0].Width != 200 \|\|
	112	+	out.Outputs[1].Info.Name != "DP-1" \|\| out.Outputs[1].X != 200 \|\| out.Focused != "DP-1" {
	113	+	t.Fatalf("%+v", out)
	114	+	}
	115	+	}
	116	+
	117	+	func TestWindowsOpenOnFocusedOutput(t *testing.T) {
	118	+	r := startMulti(t, nil, left, right)
	119	+	r.mapWindow(t, 1)
	120	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	121	+	set := r.mapWindow(t, 2)
	122	+	if got := shown(set); len(got["DP-1"]) != 1 \|\| got["DP-1"][0] != 1 \|\| len(got["DP-2"]) != 1 \|\| got["DP-2"][0] != 2 {
	123	+	t.Fatal(got)
	124	+	}
	125	+	// Only the focused output draws a focused window.
	126	+	for _, s := range set {
	127	+	for _, w := range s.Windows {
	128	+	if w.Focused != (s.Output == "DP-2") {
	129	+	t.Fatalf("%s: %+v", s.Output, w)
	130	+	}
	131	+	}
	132	+	}
	133	+	}
	134	+
	135	+	func TestFocusColumnCrossesOutputs(t *testing.T) {
	136	+	r := startMulti(t, nil, left, right)
	137	+	r.mapWindow(t, 1)
	138	+	// The only column is the edge: focus moves to the right output.
	139	+	r.key(t, "Right", ports.ModAlt)
	140	+	r.mapWindow(t, 2)
	141	+	for len(r.commands) > 0 {
	142	+	<-r.commands
	143	+	}
	144	+	r.key(t, "Left", ports.ModAlt)
	145	+	var focus ports.WindowID
	146	+	for len(r.commands) > 0 {
	147	+	if v, ok := (<-r.commands).(ports.FocusWindow); ok {
	148	+	focus = v.ID
	149	+	}
	150	+	}
	151	+	if focus != 1 {
	152	+	t.Fatal(focus)
	153	+	}
	154	+	}
	155	+
	156	+	func TestPointerCrossesOutputs(t *testing.T) {
	157	+	r := startMulti(t, nil, left, right)
	158	+	r.mapWindow(t, 1)
	159	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	160	+	r.mapWindow(t, 2)
	161	+	for len(r.commands) > 0 {
	162	+	<-r.commands
	163	+	}
	164	+	// DP-2 starts at x 200: global (250, 50) is (50, 50) on window 2.
	165	+	r.input <- ports.PointerMotion{X: 250, Y: 50}
	166	+	if v := command(t, r.commands); v != (ports.PointerFocus{ID: 2, X: 50, Y: 50}) {
	167	+	t.Fatal(v)
	168	+	}
	169	+	// Back on DP-1, then below it (100 high): off every output, y stays on DP-1.
	170	+	r.input <- ports.PointerMotion{X: 10, Y: 50}
	171	+	r.input <- ports.PointerMotion{X: 10, Y: 150}
	172	+	for {
	173	+	if v, ok := command(t, r.commands).(ports.PointerMotionTo); ok && v.Y == 99 {
	174	+	if v.ID != 1 \|\| v.X != 10 {
	175	+	t.Fatal(v)
	176	+	}
	177	+	break
	178	+	}
	179	+	}
	180	+	// A click focuses the output under the pointer.
	181	+	r.input <- ports.PointerButton{Button: 0x110, Pressed: true}
	182	+	set := receive(t, r.scenes)
	183	+	for _, s := range set {
	184	+	for _, w := range s.Windows {
	185	+	if w.Focused != (w.ID == 1) {
	186	+	t.Fatalf("%s: %+v", s.Output, w)
	187	+	}
	188	+	}
	189	+	}
	190	+	}
	191	+
	192	+	func TestMoveWorkspaceToMonitor(t *testing.T) {
	193	+	r := startMulti(t, nil, left, right)
	194	+	r.mapWindow(t, 1)
	195	+	set := r.key(t, "Right", ports.ModAlt\|ports.ModCtrl\|ports.ModShift)
	196	+	if got := shown(set); len(got["DP-1"]) != 0 \|\| len(got["DP-2"]) != 1 {
	197	+	t.Fatal(got)
	198	+	}
	199	+	// It is DP-2's now: unplugging DP-1 does not move it.
	200	+	r.output <- ports.OutputRemoved{Name: "DP-1"}
	201	+	set = receive(t, r.scenes)
	202	+	if len(set) != 1 \|\| set[0].Output != "DP-2" \|\| len(shown(set)["DP-2"]) != 1 {
	203	+	t.Fatal(shown(set))
	204	+	}
	205	+	}
	206	+
	207	+	func TestUnplugMovesWorkspacesAndReplugReturnsThem(t *testing.T) {
	208	+	r := startMulti(t, nil, left, right)
	209	+	r.mapWindow(t, 1)
	210	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	211	+	r.mapWindow(t, 2)
	212	+	// Unplug DP-2 while it is focused: its workspace joins DP-1 below its own.
	213	+	r.output <- ports.OutputRemoved{Name: "DP-2"}
	214	+	set := receive(t, r.scenes)
	215	+	if len(set) != 1 \|\| len(shown(set)["DP-1"]) != 1 \|\| shown(set)["DP-1"][0] != 1 {
	216	+	t.Fatal(shown(set))
	217	+	}
	218	+	// Cmd+2 shows the guest.
	219	+	r.input <- ports.KeyEvent{Keysym: "2", Keycode: 3, Mods: ports.ModAlt, Pressed: true}
	220	+	set = receive(t, r.scenes)
	221	+	r.input <- ports.KeyEvent{Keysym: "2", Keycode: 3, Mods: ports.ModAlt}
	222	+	if got := shown(set)["DP-1"]; len(got) != 1 \|\| got[0] != 2 {
	223	+	t.Fatal(got)
	224	+	}
	225	+	// Replugged while on screen: the guest stays until the user leaves it.
	226	+	set = r.plug(t, right)
	227	+	if got := shown(set); len(got["DP-1"]) != 1 \|\| got["DP-1"][0] != 2 \|\| len(got["DP-2"]) != 0 {
	228	+	t.Fatal(got)
	229	+	}
	230	+	r.input <- ports.KeyEvent{Keysym: "1", Keycode: 2, Mods: ports.ModAlt, Pressed: true}
	231	+	set = receive(t, r.scenes)
	232	+	if got := shown(set); len(got["DP-1"]) != 1 \|\| got["DP-1"][0] != 1 \|\| len(got["DP-2"]) != 1 \|\| got["DP-2"][0] != 2 {
	233	+	t.Fatal(got)
	234	+	}
	235	+	}
	236	+
	237	+	func TestReplugReturnsHiddenGuestAtOnce(t *testing.T) {
	238	+	r := startMulti(t, nil, left, right)
	239	+	r.mapWindow(t, 1)
	240	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	241	+	r.mapWindow(t, 2)
	242	+	r.key(t, "Left", ports.ModAlt\|ports.ModCtrl)
	243	+	r.output <- ports.OutputRemoved{Name: "DP-2"}
	244	+	receive(t, r.scenes)
	245	+	// Not on screen: it goes home as soon as DP-2 is back.
	246	+	set := r.plug(t, right)
	247	+	if got := shown(set); len(got["DP-2"]) != 1 \|\| got["DP-2"][0] != 2 {
	248	+	t.Fatal(got)
	249	+	}
	250	+	}
	251	+
	252	+	func TestNamedWorkspaceOnItsMonitor(t *testing.T) {
	253	+	r := startMulti(t, func(c *ports.Config) {
	254	+	c.Workspaces = []ports.WorkspaceConfig{{Name: "web", Monitor: "DP-2", Hidden: true}}
	255	+	c.Binds["Alt+w"] = "workspace web"
	256	+	}, left)
	257	+	// DP-2 is not plugged: web lives on DP-1 as a guest.
	258	+	r.key(t, "w", ports.ModAlt)
	259	+	r.mapWindow(t, 1)
	260	+	r.key(t, "w", ports.ModAlt)
	261	+	// DP-2 arrives: web goes home (not on screen).
	262	+	r.plug(t, right)
	263	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	264	+	set := r.key(t, "w", ports.ModAlt)
	265	+	if got := shown(set); len(got["DP-2"]) != 1 \|\| got["DP-2"][0] != 1 {
	266	+	t.Fatal(got)
	267	+	}
	268	+	}
	269	+
	270	+	func TestLayersStayOnTheirOutput(t *testing.T) {
	271	+	r := startMulti(t, nil, left, right)
	272	+	bar := ports.LayerSurface{ID: 9, Layer: ports.LayerTop, Anchor: ports.AnchorTop \| ports.AnchorLeft \| ports.AnchorRight, Height: 10, ExclusiveZone: 10, Output: "DP-2"}
	273	+	r.client <- ports.LayerChanged{Layers: []ports.LayerSurface{bar}}
	274	+	set := receive(t, r.scenes)
	275	+	for _, s := range set {
	276	+	if (len(s.Layers) == 1) != (s.Output == "DP-2") {
	277	+	t.Fatalf("%s: %+v", s.Output, s.Layers)
	278	+	}
	279	+	}
	280	+	if set[1].Layers[0].Rect != (ports.Rect{W: 400, H: 10}) {
	281	+	t.Fatal(set[1].Layers)
	282	+	}
	283	+	}
	284	+
	285	+	func TestScaleBindTargetsFocusedOutput(t *testing.T) {
	286	+	r := startMulti(t, func(c *ports.Config) { c.Binds["Alt+equal"] = "scale-up" }, left, right)
	287	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	288	+	set := r.key(t, "equal", ports.ModAlt)
	289	+	if set[0].Scale != 1 \|\| set[1].Scale == 1 {
	290	+	t.Fatal(set[0].Scale, set[1].Scale)
	291	+	}
	292	+	}
	293	+
	294	+	func TestLastOutputUnpluggedKeepsWindows(t *testing.T) {
	295	+	r := startMulti(t, nil, left)
	296	+	r.mapWindow(t, 1)
	297	+	r.output <- ports.OutputRemoved{Name: "DP-1"}
	298	+	if set := receive(t, r.scenes); len(set) != 1 \|\| set[0].Output != "" {
	299	+	t.Fatal(shown(set))
	300	+	}
	301	+	if out := lastOutputs(t, r.commands); len(out.Outputs) != 0 {
	302	+	t.Fatalf("%+v", out)
	303	+	}
	304	+	// Another monitor takes the windows over.
	305	+	set := r.plug(t, right)
	306	+	if got := shown(set); len(got) != 1 \|\| len(got["DP-2"]) != 1 \|\| got["DP-2"][0] != 1 {
	307	+	t.Fatal(got)
	308	+	}
	309	+	}
	310	+
	311	+	func TestModeChangeKeepsScreen(t *testing.T) {
	312	+	r := startMulti(t, nil, left, right)
	313	+	r.mapWindow(t, 1)
	314	+	r.key(t, "Right", ports.ModAlt\|ports.ModCtrl)
	315	+	r.mapWindow(t, 2)
	316	+	// A new mode on DP-2 is only a new size: nothing moves, focus stays.
	317	+	bigger := right
	318	+	bigger.Width, bigger.Height = 800, 400
	319	+	set := r.plug(t, bigger)
	320	+	if got := shown(set); len(got["DP-2"]) != 1 \|\| got["DP-2"][0] != 2 \|\| len(got["DP-1"]) != 1 {
	321	+	t.Fatal(got)
	322	+	}
	323	+	if out := lastOutputs(t, r.commands); out.Focused != "DP-2" \|\| out.Outputs[1].Width != 800 {
	324	+	t.Fatalf("%+v", out)
	325	+	}
	326	+	}

M internal/core/slots.go +8 -8


@@ -64,8 +64,8 @@ func parseSlots(ws []ports.WorkspaceConfig) ([]slotSpec, error) {
64			64
65		// updateSlots applies the config and returns the slots to spawn: new ones,	65		// updateSlots applies the config and returns the slots to spawn: new ones,
66		// and empty ones whose command changed. A slot dropped from config keeps its	66		// and empty ones whose command changed. A slot dropped from config keeps its
67	-	// window as a normal column. Call before Monitor.SetNamed, so a renamed or	67	+	// window as a normal column. Call before named workspaces are applied, so a
68	-	// dropped workspace can still be found.	68	+	// renamed or dropped workspace can still be found.
69		func (c *Core) updateSlots(specs []slotSpec) []slotKey {	69		func (c *Core) updateSlots(specs []slotSpec) []slotKey {
70		want := map[slotKey]slotSpec{}	70		want := map[slotKey]slotSpec{}
71		for _, s := range specs {	71		for _, s := range specs {

@@ -75,7 +75,7 @@ func (c *Core) updateSlots(specs []slotSpec) []slotKey {
75		if _, ok := want[key]; ok {	75		if _, ok := want[key]; ok {
76		continue	76		continue
77		}	77		}
78	-	if w := c.ws.byName(key.workspace); w != nil {	78	+	if _, w := c.byName(key.workspace); w != nil {
79		w.unslot(key.index)	79		w.unslot(key.index)
80		}	80		}
81		delete(c.slots, key)	81		delete(c.slots, key)

@@ -90,7 +90,7 @@ func (c *Core) updateSlots(specs []slotSpec) []slotKey {
90		}	90		}
91		if st.width != s.width {	91		if st.width != s.width {
92		st.width = s.width	92		st.width = s.width
93	-	if w := c.ws.byName(s.key.workspace); w != nil {	93	+	if _, w := c.byName(s.key.workspace); w != nil {
94		w.setSlotWidth(s.key.index, s.width)	94		w.setSlotWidth(s.key.index, s.width)
95		}	95		}
96		}	96		}

@@ -122,13 +122,13 @@ func (c *Core) placeSlotWindow(id WindowID, token string) bool {
122		if !st.pending() \|\| st.token != token \|\| st.window != 0 {	122		if !st.pending() \|\| st.token != token \|\| st.window != 0 {
123		continue	123		continue
124		}	124		}
125	-	w := c.ws.byName(key.workspace)	125	+	sc, w := c.byName(key.workspace)
126		if w == nil {	126		if w == nil {
127		return false	127		return false
128		}	128		}
129		st.window, st.token = id, ""	129		st.window, st.token = id, ""
130		w.AddSlotWindow(id, key.index, st.width)	130		w.AddSlotWindow(id, key.index, st.width)
131	-	c.ws.normalize()	131	+	sc.mon.normalize()
132		return true	132		return true
133		}	133		}
134		return false	134		return false

@@ -141,7 +141,7 @@ func (c *Core) releaseSlots() {
141		if st.window == 0 {	141		if st.window == 0 {
142		continue	142		continue
143		}	143		}
144	-	w := c.ws.byName(key.workspace)	144	+	_, w := c.byName(key.workspace)
145		if w == nil \|\| !w.inSlot(st.window, key.index) {	145		if w == nil \|\| !w.inSlot(st.window, key.index) {
146		st.window = 0	146		st.window = 0
147		}	147		}

@@ -152,7 +152,7 @@ func (c *Core) releaseSlots() {
152		// still pending for the second show in a row is respawned: its command	152		// still pending for the second show in a row is respawned: its command
153		// failed, exited or handed off to another instance without a window.	153		// failed, exited or handed off to another instance without a window.
154		func (c *Core) refill() []slotKey {	154		func (c *Core) refill() []slotKey {
155	-	name := c.ws.Current().Name	155	+	name := c.cur().mon.Current().Name
156		if name == "" {	156		if name == "" {
157		return nil	157		return nil
158		}	158		}

M internal/core/slots_test.go +26 -26


@@ -17,7 +17,7 @@ type slotRig struct {
17		input chan ports.InputEvent	17		input chan ports.InputEvent
18		reload chan ports.ConfigChanged	18		reload chan ports.ConfigChanged
19		spawn chan ports.SpawnRequest	19		spawn chan ports.SpawnRequest
20	-	scenes chan ports.Scene	20	+	scenes chan []ports.Scene
21		errs chan error	21		errs chan error
22		cfg ports.Config	22		cfg ports.Config
23		}	23		}

@@ -37,7 +37,7 @@ func startSlots(t testing.T, numbered ...bool) slotRig {
37		r := &slotRig{	37		r := &slotRig{
38		client: make(chan ports.ClientEvent, 16), input: make(chan ports.InputEvent, 16),	38		client: make(chan ports.ClientEvent, 16), input: make(chan ports.InputEvent, 16),
39		reload: make(chan ports.ConfigChanged, 4), spawn: make(chan ports.SpawnRequest, 16),	39		reload: make(chan ports.ConfigChanged, 4), spawn: make(chan ports.SpawnRequest, 16),
40	-	scenes: make(chan ports.Scene, 1), errs: make(chan error, 4), cfg: cfg,	40	+	scenes: make(chan []ports.Scene, 1), errs: make(chan error, 4), cfg: cfg,
41		}	41		}
42		output := make(chan ports.OutputEvent, 1)	42		output := make(chan ports.OutputEvent, 1)
43		commands := make(chan ports.ClientCommand, 1024)	43		commands := make(chan ports.ClientCommand, 1024)

@@ -53,8 +53,8 @@ func startSlots(t testing.T, numbered ...bool) slotRig {
53		for range commands {	53		for range commands {
54		}	54		}
55		}()	55		}()
56	-	output <- ports.OutputMode{Width: 100, Height: 80}	56	+	output <- ports.OutputAdded{Info: ports.OutputInfo{Name: "OUT-1", Width: 100, Height: 80}}
57	-	receive(t, r.scenes)	57	+	scene(t, r.scenes)
58		return r	58		return r
59		}	59		}
60			60

@@ -86,7 +86,7 @@ func (r slotRig) press(t testing.T, key string) ports.Scene {
86		t.Helper()	86		t.Helper()
87		r.input <- ports.KeyEvent{Keysym: key, Mods: ports.ModAlt, Pressed: true}	87		r.input <- ports.KeyEvent{Keysym: key, Mods: ports.ModAlt, Pressed: true}
88		r.input <- ports.KeyEvent{Keysym: key, Mods: ports.ModAlt}	88		r.input <- ports.KeyEvent{Keysym: key, Mods: ports.ModAlt}
89	-	return receive(t, r.scenes)	89	+	return scene(t, r.scenes)
90		}	90		}
91			91
92		// sync waits for core to handle everything sent so far.	92		// sync waits for core to handle everything sent so far.

@@ -102,19 +102,19 @@ func (r slotRig) fill(t testing.T) (code, foot ports.SpawnRequest) {
102		code, foot = receive(t, r.spawn), receive(t, r.spawn)	102		code, foot = receive(t, r.spawn), receive(t, r.spawn)
103		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}	103		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}
104		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}	104		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}
105	-	scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 2 })	105	+	sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 2 })
106		return code, foot	106		return code, foot
107		}	107		}
108			108
109	-	// scene waits for a scene matching ok.	109	+	// sceneMatch waits for a first-output scene matching ok.
110	-	func scene(t *testing.T, ch <-chan ports.Scene, ok func(ports.Scene) bool) ports.Scene {	110	+	func sceneMatch(t *testing.T, ch <-chan []ports.Scene, ok func(ports.Scene) bool) ports.Scene {
111		t.Helper()	111		t.Helper()
112		deadline := time.After(time.Second)	112		deadline := time.After(time.Second)
113		for {	113		for {
114		select {	114		select {
115		case s := <-ch:	115		case s := <-ch:
116	-	if ok(s) {	116	+	if ok(s[0]) {
117	-	return s	117	+	return s[0]
118		}	118		}
119		case <-deadline:	119		case <-deadline:
120		t.Fatal("no matching scene")	120		t.Fatal("no matching scene")

@@ -143,7 +143,7 @@ func TestSlotsSpawnAtStartAndFillInOrder(t *testing.T) {
143		// foot maps first; code's window still goes left of it.	143		// foot maps first; code's window still goes left of it.
144		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}	144		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}
145		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}	145		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}
146	-	s := scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 3 })	146	+	s := sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 3 })
147		for _, w := range s.Windows {	147		for _, w := range s.Windows {
148		if w.ID != 1 && !w.Hidden \|\| w.ID == 1 && !w.Focused {	148		if w.ID != 1 && !w.Hidden \|\| w.ID == 1 && !w.Focused {
149		t.Fatalf("slot window on screen or focus moved: %+v", s.Windows)	149		t.Fatalf("slot window on screen or focus moved: %+v", s.Windows)

@@ -163,7 +163,7 @@ func TestSlotRefilledOnlyWhenShown(t *testing.T) {
163		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}	163		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}
164		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}	164		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}
165		r.client <- ports.WindowUnmapped{ID: 3} // foot exits	165		r.client <- ports.WindowUnmapped{ID: 3} // foot exits
166	-	scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })	166	+	sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })
167		noSpawn(t, r.spawn) // nothing relaunches on its own	167		noSpawn(t, r.spawn) // nothing relaunches on its own
168		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt, Pressed: true}	168		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt, Pressed: true}
169		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt}	169		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt}

@@ -172,7 +172,7 @@ func TestSlotRefilledOnlyWhenShown(t *testing.T) {
172		t.Fatal(again)	172		t.Fatal(again)
173		}	173		}
174		r.client <- ports.WindowMapped{ID: 4, Slot: token(t, again)}	174		r.client <- ports.WindowMapped{ID: 4, Slot: token(t, again)}
175	-	s := scene(t, r.scenes, func(s ports.Scene) bool { return len(visible(s)) == 2 })	175	+	s := sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(visible(s)) == 2 })
176		if got := visible(s); got[4].X != 70 {	176		if got := visible(s); got[4].X != 70 {
177		t.Fatal(got)	177		t.Fatal(got)
178		}	178		}

@@ -190,7 +190,7 @@ func TestSlotExtraWindowsAreNormal(t *testing.T) {
190		// A second window of the same process: the slot is taken, normal rules.	190		// A second window of the same process: the slot is taken, normal rules.
191		r.client <- ports.WindowMapped{ID: 5, Slot: token(t, code)}	191		r.client <- ports.WindowMapped{ID: 5, Slot: token(t, code)}
192		r.client <- ports.WindowMapped{ID: 6, Slot: "unknown"}	192		r.client <- ports.WindowMapped{ID: 6, Slot: "unknown"}
193	-	s := scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 3 })	193	+	s := sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 3 })
194		if got := visible(s); len(got) != 2 \|\| got[5] == (ports.Rect{}) \|\| got[6] == (ports.Rect{}) {	194		if got := visible(s); len(got) != 2 \|\| got[5] == (ports.Rect{}) \|\| got[6] == (ports.Rect{}) {
195		t.Fatalf("extra windows not on the workspace on screen: %v", got)	195		t.Fatalf("extra windows not on the workspace on screen: %v", got)
196		}	196		}

@@ -200,7 +200,7 @@ func TestSlotReload(t *testing.T) {
200		r := startSlots(t)	200		r := startSlots(t)
201		code, foot := receive(t, r.spawn), receive(t, r.spawn)	201		code, foot := receive(t, r.spawn), receive(t, r.spawn)
202		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}	202		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}
203	-	scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })	203	+	sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })
204		cfg := r.cfg	204		cfg := r.cfg
205		ws := cfg.Workspaces[0]	205		ws := cfg.Workspaces[0]
206		ws.Slots = []ports.SlotConfig{	206		ws.Slots = []ports.SlotConfig{

@@ -218,18 +218,18 @@ func TestSlotReload(t *testing.T) {
218		if !slices.Equal(argv, []string{"btop", "kitty"}) {	218		if !slices.Equal(argv, []string{"btop", "kitty"}) {
219		t.Fatal(argv)	219		t.Fatal(argv)
220		}	220		}
221	-	receive(t, r.scenes)	221	+	scene(t, r.scenes)
222		noSpawn(t, r.spawn)	222		noSpawn(t, r.spawn)
223		// The old foot spawn no longer fills slot 2 (its command changed): it	223		// The old foot spawn no longer fills slot 2 (its command changed): it
224		// opens as a normal window on workspace 1, on screen.	224		// opens as a normal window on workspace 1, on screen.
225		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}	225		r.client <- ports.WindowMapped{ID: 3, Slot: token(t, foot)}
226	-	s := scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 2 })	226	+	s := sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 2 })
227		if got := visible(s); len(got) != 1 \|\| got[3] == (ports.Rect{}) {	227		if got := visible(s); len(got) != 1 \|\| got[3] == (ports.Rect{}) {
228		t.Fatal(got)	228		t.Fatal(got)
229		}	229		}
230		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt, Pressed: true}	230		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt, Pressed: true}
231		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt}	231		r.input <- ports.KeyEvent{Keysym: "d", Mods: ports.ModAlt}
232	-	s = scene(t, r.scenes, func(s ports.Scene) bool { return len(visible(s)) == 1 })	232	+	s = sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(visible(s)) == 1 })
233		if got := visible(s); got[2].W != 50 {	233		if got := visible(s); got[2].W != 50 {
234		t.Fatal(got)	234		t.Fatal(got)
235		}	235		}

@@ -238,7 +238,7 @@ func TestSlotReload(t *testing.T) {
238		ws.Slots = nil	238		ws.Slots = nil
239		cfg.Workspaces = []ports.WorkspaceConfig{ws}	239		cfg.Workspaces = []ports.WorkspaceConfig{ws}
240		r.reload <- ports.ConfigChanged{Config: cfg}	240		r.reload <- ports.ConfigChanged{Config: cfg}
241	-	receive(t, r.scenes)	241	+	scene(t, r.scenes)
242		noSpawn(t, r.spawn)	242		noSpawn(t, r.spawn)
243		}	243		}
244			244

@@ -271,7 +271,7 @@ func TestSlotReloadWhileShownSpawnsOnce(t *testing.T) {
271		if v := receive(t, r.spawn); v.Argv[0] != "btop" {	271		if v := receive(t, r.spawn); v.Argv[0] != "btop" {
272		t.Fatal(v)	272		t.Fatal(v)
273		}	273		}
274	-	receive(t, r.scenes)	274	+	scene(t, r.scenes)
275		noSpawn(t, r.spawn)	275		noSpawn(t, r.spawn)
276		}	276		}
277			277

@@ -282,7 +282,7 @@ func TestSlotNotRefilledByOtherBinds(t *testing.T) {
282		r.fill(t)	282		r.fill(t)
283		r.press(t, "d")	283		r.press(t, "d")
284		r.client <- ports.WindowUnmapped{ID: 3}	284		r.client <- ports.WindowUnmapped{ID: 3}
285	-	scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })	285	+	sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })
286		r.sync(t)	286		r.sync(t)
287		noSpawn(t, r.spawn)	287		noSpawn(t, r.spawn)
288		r.press(t, "d")	288		r.press(t, "d")

@@ -299,7 +299,7 @@ func TestSlotOldTokenIsNormal(t *testing.T) {
299		_, foot := r.fill(t)	299		_, foot := r.fill(t)
300		r.client <- ports.WindowUnmapped{ID: 3}	300		r.client <- ports.WindowUnmapped{ID: 3}
301		r.client <- ports.WindowMapped{ID: 9, Slot: token(t, foot)}	301		r.client <- ports.WindowMapped{ID: 9, Slot: token(t, foot)}
302	-	s := scene(t, r.scenes, func(s ports.Scene) bool { return len(visible(s)) == 1 })	302	+	s := sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(visible(s)) == 1 })
303		if got := visible(s); got[9] == (ports.Rect{}) {	303		if got := visible(s); got[9] == (ports.Rect{}) {
304		t.Fatalf("old-token window hidden in the slot: %v", got)	304		t.Fatalf("old-token window hidden in the slot: %v", got)
305		}	305		}

@@ -311,7 +311,7 @@ func TestPendingSlotRespawnedOnSecondShow(t *testing.T) {
311		r := startSlots(t)	311		r := startSlots(t)
312		code, foot := receive(t, r.spawn), receive(t, r.spawn)	312		code, foot := receive(t, r.spawn), receive(t, r.spawn)
313		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}	313		r.client <- ports.WindowMapped{ID: 2, Slot: token(t, code)}
314	-	scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })	314	+	sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 1 })
315		r.press(t, "d") // foot still starting: not respawned	315		r.press(t, "d") // foot still starting: not respawned
316		noSpawn(t, r.spawn)	316		noSpawn(t, r.spawn)
317		r.press(t, "d")	317		r.press(t, "d")

@@ -321,12 +321,12 @@ func TestPendingSlotRespawnedOnSecondShow(t *testing.T) {
321		t.Fatal(again)	321		t.Fatal(again)
322		}	322		}
323		r.client <- ports.WindowMapped{ID: 7, Slot: token(t, foot)}	323		r.client <- ports.WindowMapped{ID: 7, Slot: token(t, foot)}
324	-	s := scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 2 })	324	+	s := sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 2 })
325		if got := visible(s); got[7] == (ports.Rect{}) {	325		if got := visible(s); got[7] == (ports.Rect{}) {
326		t.Fatalf("stale-token window not placed as a normal one: %v", got)	326		t.Fatalf("stale-token window not placed as a normal one: %v", got)
327		}	327		}
328		r.client <- ports.WindowMapped{ID: 8, Slot: token(t, again)}	328		r.client <- ports.WindowMapped{ID: 8, Slot: token(t, again)}
329	-	s = scene(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 3 })	329	+	s = sceneMatch(t, r.scenes, func(s ports.Scene) bool { return len(s.Windows) == 3 })
330		if got := visible(s); got[8].W != 30 {	330		if got := visible(s); got[8].W != 30 {
331		t.Fatalf("respawned window not in its slot: %v", got)	331		t.Fatalf("respawned window not in its slot: %v", got)
332		}	332		}

@@ -339,7 +339,7 @@ func TestSlotReleasedWhenWindowMoved(t *testing.T) {
339		r.fill(t)	339		r.fill(t)
340		r.press(t, "d") // on dev, focus on code (slot 1)	340		r.press(t, "d") // on dev, focus on code (slot 1)
341		r.input <- ports.KeyEvent{Keysym: "Prior", Mods: ports.ModAlt \| ports.ModShift, Pressed: true}	341		r.input <- ports.KeyEvent{Keysym: "Prior", Mods: ports.ModAlt \| ports.ModShift, Pressed: true}
342	-	receive(t, r.scenes) // move-to-workspace-up: code goes to workspace 1	342	+	scene(t, r.scenes) // move-to-workspace-up: code goes to workspace 1
343		noSpawn(t, r.spawn)	343		noSpawn(t, r.spawn)
344		r.press(t, "d") // back to workspace 1	344		r.press(t, "d") // back to workspace 1
345		r.press(t, "d") // dev again: slot 1 is empty	345		r.press(t, "d") // dev again: slot 1 is empty

M internal/ports/config.go +5 -2

 // OutputConfig configures one connector. Name is the connector (e.g. "DP-2").
 // Mode is "WxH" (highest refresh) or "WxH@Hz" (closest refresh); empty picks the
 // monitor's preferred mode. Off disables the connector.
-// The first listed, connected, enabled output is used; without a match, the first
+// Every connected output that is not off is used. Outputs are placed left to
-// connected output that is not off.
+// right in config order, then in connection order.
 // Scale is the output scale (0 means 1); layout works in logical pixels,
 // physical = logical × Scale.
 // ScaleOnly marks an entry set by output.<name>.scale alone: it does not
 // Zero MaxColumns and an empty Overflow use the layout.* defaults.
 type WorkspaceConfig struct {
 	Name string
+	// Monitor is the home monitor: a connector name (DP-2) or a monitor key
+	// ("make model serial"); empty means the first output.
+	Monitor string
 	// Slots are the declared columns (workspace.<name>.column.N), by N.
 	Slots      []SlotConfig
 	Hidden     bool

M internal/ports/messages.go +86 -19


@@ -61,6 +61,8 @@ type LayerSurface struct {
61		Namespace string	61		Namespace string
62		// Keyboard is the requested interactivity: 0 none, 1 exclusive, 2 on-demand.	62		// Keyboard is the requested interactivity: 0 none, 1 exclusive, 2 on-demand.
63		Keyboard uint32	63		Keyboard uint32
			64	+	// Output is the connector the surface is on.
			65	+	Output string
64		}	66		}
65			67
66		// LayerChanged carries wayland → core the full list of mapped layer surfaces,	68		// LayerChanged carries wayland → core the full list of mapped layer surfaces,

@@ -102,7 +104,7 @@ type ModState struct{ Depressed, Latched, Locked, Group uint32 }
102			104
103		func (KeyEvent) inputEvent() {}	105		func (KeyEvent) inputEvent() {}
104			106
105	-	// PointerMotion uses absolute output coordinates in physical pixels.	107	+	// PointerMotion uses global layout coordinates in logical pixels (see OutputPlacement).
106		type PointerMotion struct {	108		type PointerMotion struct {
107		X, Y float64	109		X, Y float64
108		TimeMsec uint32	110		TimeMsec uint32

@@ -122,19 +124,36 @@ func (PointerButton) inputEvent() {}
122		// OutputEvent carries output → core notifications.	124		// OutputEvent carries output → core notifications.
123		type OutputEvent interface{ outputEvent() }	125		type OutputEvent interface{ outputEvent() }
124			126
125	-	// OutputMode carries output → core resolution changes in physical pixels.	127	+	// OutputInfo describes a connected display. Sizes are physical pixels.
126	-	// Name is the connector, matched against output.<name>.scale.	128	+	type OutputInfo struct {
127	-	type OutputMode struct {	129	+	// Name is the connector (e.g. DP-2), matched against output.<name>.* config.
128	-	Width, Height int	130	+	Name string
129	-	Name string	131	+	// Make, Model and Serial come from EDID; empty when unknown.
			132	+	Make, Model, Serial string
			133	+	Width, Height int
			134	+	RefreshMilli int
			135	+	PhysicalW, PhysicalH int // millimetres
			136	+	}
			137	+
			138	+	// Key identifies the monitor across connectors: make, model and serial, or
			139	+	// the connector name when EDID has no serial.
			140	+	func (i OutputInfo) Key() string {
			141	+	if i.Serial == "" {
			142	+	return i.Name
			143	+	}
			144	+	return i.Make + " " + i.Model + " " + i.Serial
130		}	145		}
131			146
132	-	func (OutputMode) outputEvent() {}	147	+	// OutputAdded carries output → core a new display, or a new mode for a known
			148	+	// connector.
			149	+	type OutputAdded struct{ Info OutputInfo }
			150	+
			151	+	func (OutputAdded) outputEvent() {}
133			152
134	-	// OutputUsable carries output → core usable area after layer-shell exclusive zones.	153	+	// OutputRemoved carries output → core an unplugged display.
135	-	type OutputUsable struct{ Rect Rect }	154	+	type OutputRemoved struct{ Name string }
136			155
137	-	func (OutputUsable) outputEvent() {}	156	+	func (OutputRemoved) outputEvent() {}
138			157
139		// ConfigChanged carries config → core reloads.	158		// ConfigChanged carries config → core reloads.
140		type ConfigChanged struct{ Config Config }	159		type ConfigChanged struct{ Config Config }

@@ -142,23 +161,69 @@ type ConfigChanged struct{ Config Config }
142		// ClientCommand carries core → wayland commands.	161		// ClientCommand carries core → wayland commands.
143		type ClientCommand interface{ clientCommand() }	162		type ClientCommand interface{ clientCommand() }
144			163
145	-	// ConfigureWindow carries core → wayland geometry and state.	164	+	// ConfigureWindow carries core → wayland geometry and state. Output is the
			165	+	// connector showing the window, empty while it is hidden.
146		type ConfigureWindow struct {	166		type ConfigureWindow struct {
147		ID WindowID	167		ID WindowID
148		Width, Height int	168		Width, Height int
149		Fullscreen, Activated bool	169		Fullscreen, Activated bool
			170	+	Output string
150		}	171		}
151			172
152		func (ConfigureWindow) clientCommand() {}	173		func (ConfigureWindow) clientCommand() {}
153			174
154	-	// SetOutputScale carries core → wayland the output scale and its logical size.	175	+	// OutputPlacement is one output in the global layout. X, Y, Width and
155	-	// Window and pointer coordinates in other commands are logical.	176	+	// Height are logical; physical = logical × Scale.
156	-	type SetOutputScale struct {	177	+	type OutputPlacement struct {
157	-	Scale float64	178	+	Info OutputInfo
158	-	Width, Height int	179	+	X, Y, Width, Height int
			180	+	Scale float64
			181	+	}
			182	+
			183	+	// Contains reports whether the logical point is on the output.
			184	+	func (o OutputPlacement) Contains(x, y float64) bool {
			185	+	return x >= float64(o.X) && x < float64(o.X+o.Width) && y >= float64(o.Y) && y < float64(o.Y+o.Height)
			186	+	}
			187	+
			188	+	// Layout is the global arrangement of outputs, left to right.
			189	+	type Layout []OutputPlacement
			190	+
			191	+	// At returns the output under the logical point.
			192	+	func (l Layout) At(x, y float64) (OutputPlacement, bool) {
			193	+	for _, o := range l {
			194	+	if o.Contains(x, y) {
			195	+	return o, true
			196	+	}
			197	+	}
			198	+	return OutputPlacement{}, false
			199	+	}
			200	+
			201	+	// Clamp keeps the pointer on an output: a point outside every output stays
			202	+	// on the output under (fromX, fromY), or the first one, clamped to its edges.
			203	+	func (l Layout) Clamp(fromX, fromY, x, y float64) (float64, float64) {
			204	+	if len(l) == 0 {
			205	+	return x, y
			206	+	}
			207	+	if _, ok := l.At(x, y); ok {
			208	+	return x, y
			209	+	}
			210	+	o, ok := l.At(fromX, fromY)
			211	+	if !ok {
			212	+	o = l[0]
			213	+	}
			214	+	x = min(max(x, float64(o.X)), float64(o.X+o.Width)-1)
			215	+	y = min(max(y, float64(o.Y)), float64(o.Y+o.Height)-1)
			216	+	return x, y
			217	+	}
			218	+
			219	+	// SetOutputs carries core → wayland every output and the focused one (where
			220	+	// new surfaces start). It is sent when the list, a placement or the focus changes.
			221	+	type SetOutputs struct {
			222	+	Outputs Layout
			223	+	Focused string
159		}	224		}
160			225
161	-	func (SetOutputScale) clientCommand() {}	226	+	func (SetOutputs) clientCommand() {}
162			227
163		// SlotsPending tells wayland whether a slot waits for its window. Only then	228		// SlotsPending tells wayland whether a slot waits for its window. Only then
164		// does it read the SlotEnv of mapping clients.	229		// does it read the SlotEnv of mapping clients.

@@ -232,9 +297,11 @@ type SpawnRequest struct {
232		Env []string	297		Env []string
233		}	298		}
234			299
235	-	// Scene carries core → renderer immutable snapshots with fresh Windows slices.	300	+	// Scene carries core → renderer immutable snapshots with fresh Windows slices,
236	-	// Rects and the output size are logical; the renderer multiplies by Scale.	301	+	// one per output. Rects and the output size are logical and local to the
			302	+	// output; the renderer multiplies by Scale.
237		type Scene struct {	303		type Scene struct {
			304	+	Output string
238		Seq uint64	305		Seq uint64
239		OutputWidth, OutputHeight int	306		OutputWidth, OutputHeight int
240		Scale float64	307		Scale float64