Fix invisible/flashing clock, map Protect's 8-camera preset, warn on gaps

Three separate faults made cameras "not load" and the clock misbehave.

Clock rendered as nothing, or flashed ~200ms/second. The time was drawn as
an ASS osd-overlay pushed over mpv IPC, but on mpv 0.35 + Mesa/V3D + sway an
OSD overlay is rendered only on the frame where its content *changes*. Every
layer reports success while this happens (mpv returns error:success,
vo-configured is true, and sway reports the window visible at the right
rect), so it looks like a stacking or font bug and is neither. Ruled out:
pushing at 20Hz (identical content is ignored, so it still only redrew when
the second flipped), osd-msg1, show-text, and --pause (mpv stops redrawing
entirely). Fonts were never the issue.

The time is now baked into every frame by a drawtext filter re-reading a
small file the ticker rewrites once a second, with two constraints that cost
real time to find and are pinned by tests:

- The canvas alpha must be > 0. A fully transparent canvas (black@0.0 with
  --alpha=yes) makes the glyphs inherit alpha 0 and the compositor draws
  nothing -- this was the original invisible clock. New clock
  background_opacity (default 0.45) is clamped in config *and* in args() so
  no code path can produce an invisible clock.
- Readahead must be off. drawtext stamps the time when a frame is
  *generated*, so buffering ahead makes the visible clock lag by the
  readahead and swallows text-file updates entirely.

Since the text now arrives through a file, the clock needs no IPC socket:
dropped --input-ipc-server, the ipcPath field, and the stale-socket removal.
assEscape goes with the ASS path.

`views import` produced layouts with holes. viewmap derived the grid from
the slot count alone and ignored Protect's `layout` field, so Protect's
asymmetric 8-camera preset (four 2x2 tiles plus a right column of four 1x1)
landed as 8 tiles in a 3x3 grid -- the bottom-right cell was simply empty
and rendered as a blank rectangle. That preset is now mapped exactly; other
counts keep the uniform GridForSlots fallback rather than guessing at
presets I have not observed. Import also warns when a mapping would leave
empty cells or references a camera missing from the config, so a silent hole
cannot reach the screen again.

Also:

- clock.corner gains bottom-center and top-center (centered horizontally,
  Margin still applies vertically).
- placeClock no longer re-issues `resize set` every tick. Re-asserting
  geometry on a correctly-sized window makes sway send a configure event,
  which makes mpv reallocate buffers and blank for a frame. New
  compositor.Raise re-asserts z-order only, which is all the 2s tick needs;
  geometry is re-placed only when it has actually drifted.
- README documents why the clock is drawn this way, the preset table and how
  to add another from `views dump`, and three troubleshooting entries for
  failure modes that all look like bugs: a blank tile whose mpv is running
  (a stale camera entry -- re-adopting a camera in Protect assigns a new id
  and often a slightly different name, and `discover` never prunes), cameras
  in `cameras:` not being on screen (only the active layout's tiles stream),
  and black bars inside tiles (non-16:9 grid cells; --panscan=1.0 crops to
  fill instead).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LYhTnkp7VzJ67THeicgfAQ

internal/viewmap/viewmap.go

@@ -31,18 +31,66 @@ func GridForSlots(n int) (cols, rows int) {
 	}
 }
 
-// LayoutFromView maps a Protect live view to a layout. Cameras are placed
-// row-major, one per slot (the first camera of a cycling slot). Sizing uses a
-// slot-count grid for now; asymmetric Protect presets need the `layout` int
-// mapping. The returned layout is linked back to the view (ProtectView) so the
-// daemon can re-sync it. Returns warnings for unmappable cameras.
+// preset is a Protect arrangement: a base grid plus one cell placement per
+// slot, in slot order. Camera is filled in by LayoutFromView.
+type preset struct {
+	cols, rows int
+	cells      []config.Tile
+}
+
+// presets holds the Protect arrangements that are NOT a uniform grid, keyed by
+// slot count. Protect picks these presets by camera count, so a count that is
+// absent here is a plain row-major grid and falls through to uniformPreset.
+var presets = map[int]preset{
+	// Protect's 8-camera preset: four 2x2 tiles with a right-hand column of
+	// four 1x1 tiles. Numbers are slot order:
+	//   1 1 2 2 3
+	//   1 1 2 2 4
+	//   5 5 6 6 7
+	//   5 5 6 6 8
+	8: {cols: 5, rows: 4, cells: []config.Tile{
+		{Col: 0, Row: 0, ColSpan: 2, RowSpan: 2},
+		{Col: 2, Row: 0, ColSpan: 2, RowSpan: 2},
+		{Col: 4, Row: 0, ColSpan: 1, RowSpan: 1},
+		{Col: 4, Row: 1, ColSpan: 1, RowSpan: 1},
+		{Col: 0, Row: 2, ColSpan: 2, RowSpan: 2},
+		{Col: 2, Row: 2, ColSpan: 2, RowSpan: 2},
+		{Col: 4, Row: 2, ColSpan: 1, RowSpan: 1},
+		{Col: 4, Row: 3, ColSpan: 1, RowSpan: 1},
+	}},
+}
+
+// uniformPreset builds a plain row-major grid of 1x1 cells.
+func uniformPreset(cols, rows int) preset {
+	p := preset{cols: cols, rows: rows}
+	for i := 0; i < cols*rows; i++ {
+		p.cells = append(p.cells, config.Tile{Col: i % cols, Row: i / cols, ColSpan: 1, RowSpan: 1})
+	}
+	return p
+}
+
+// presetForSlots returns the arrangement Protect uses for n slots.
+func presetForSlots(n int) preset {
+	if p, ok := presets[n]; ok {
+		return p
+	}
+	cols, rows := GridForSlots(n)
+	return uniformPreset(cols, rows)
+}
+
+// LayoutFromView maps a Protect live view to a layout. Each slot's first camera
+// (slots may cycle several) is placed into that slot's cell in the arrangement
+// Protect uses for the slot count — see presets. The returned layout is linked
+// back to the view (ProtectView) so the daemon can re-sync it. Returns warnings
+// for unmappable cameras and for any arrangement that leaves the wall with
+// empty cells, which would otherwise show as blank rectangles on screen.
 func LayoutFromView(v protect.LiveView, idToName map[string]string) (config.Layout, []string) {
-	cols, rows := GridForSlots(len(v.Slots))
+	p := presetForSlots(len(v.Slots))
 	var tiles []config.Tile
 	var warns []string
 	for i, slot := range v.Slots {
-		if i >= cols*rows {
-			warns = append(warns, fmt.Sprintf("more slots than the %dx%d grid holds; extra dropped", cols, rows))
+		if i >= len(p.cells) {
+			warns = append(warns, fmt.Sprintf("more slots than the %dx%d grid holds; extra dropped", p.cols, p.rows))
 			break
 		}
 		if len(slot.Cameras) == 0 {
@@ -50,19 +98,51 @@ func LayoutFromView(v protect.LiveView, idToName map[string]string) (config.Layo
 		}
 		name := idToName[slot.Cameras[0]]
 		if name == "" {
-			warns = append(warns, fmt.Sprintf("slot %d camera %s not in config", i, slot.Cameras[0]))
+			warns = append(warns, fmt.Sprintf("slot %d camera %s not in config (run `discover`)", i, slot.Cameras[0]))
 			continue
 		}
-		tiles = append(tiles, config.Tile{Camera: name, Col: i % cols, Row: i / cols, ColSpan: 1, RowSpan: 1})
+		t := p.cells[i]
+		t.Camera = name
+		tiles = append(tiles, t)
+	}
+	if gaps := unfilled(p, tiles); gaps > 0 {
+		warns = append(warns, fmt.Sprintf("%d of %d cells in the %dx%d grid are empty and will show as blank areas",
+			gaps, p.cols*p.rows, p.cols, p.rows))
 	}
 	return config.Layout{
 		Name:        Sanitize(v.Name),
-		Grid:        fmt.Sprintf("%dx%d", cols, rows),
+		Grid:        fmt.Sprintf("%dx%d", p.cols, p.rows),
 		Tiles:       tiles,
 		ProtectView: v.Name,
 	}, warns
 }
 
+// unfilled counts grid cells no tile covers. A non-zero result means the wall
+// has holes: either the preset does not tile its own grid or slots were skipped.
+func unfilled(p preset, tiles []config.Tile) int {
+	if p.cols <= 0 || p.rows <= 0 {
+		return 0
+	}
+	covered := make([]bool, p.cols*p.rows)
+	for _, t := range tiles {
+		cs, rs := t.Span()
+		for r := t.Row; r < t.Row+rs; r++ {
+			for c := t.Col; c < t.Col+cs; c++ {
+				if r >= 0 && r < p.rows && c >= 0 && c < p.cols {
+					covered[r*p.cols+c] = true
+				}
+			}
+		}
+	}
+	n := 0
+	for _, ok := range covered {
+		if !ok {
+			n++
+		}
+	}
+	return n
+}
+
 // Sanitize turns a view name into a layout name (lowercase, dashed).
 func Sanitize(s string) string {
 	s = strings.ToLower(strings.TrimSpace(s))