Anchor the webcam overlay to the recorded region, not the monitor (#6384)

* Anchor the webcam overlay to the recorded region, not the monitor

Recording a single window on an ultrawide put the camera outside the frame.
The overlay is placed twice, and neither placement knows what is being
captured: the window rules in default/hypr/apps/webcam-overlay.lua position it
from monitor_w/monitor_h, and omarchy-capture-webcam-resize recomputes the same
corner from hyprctl monitors. Both resolve to the monitor's bottom-right, so a
window anywhere but the far right of the display records without the camera in
it, and dragging it into frame by hand is undone by the next resize.

The geometry is already known. select_capture_target resolves the picked window
to a region rectangle before start_webcam_overlay runs, and a bare click in
smart mode snaps that rectangle to the window's own bounds. gpu-screen-recorder
takes the region in the compositor's logical coordinate space, which is the
same space window moves take, so the value needs no conversion to be reused as
an anchor.

Publish it for the resize helper, which becomes the single place that positions
the overlay. It anchors to the region when one is recorded and falls back to
the monitor otherwise, so full-monitor captures, the portal backend, and manual
resizes outside a recording all keep their current behaviour. A malformed or
empty file falls back the same way.

Presets scale from the anchor's height rather than the monitor's, so the camera
keeps its proportion of the frame instead of covering a small capture outright.
A tall, narrow region cannot fit a preset derived from its height, so widths are
capped to the space available and heights follow at the same 8:9 aspect.

Placement happens inside start_webcam_overlay rather than after it returns.
Correcting the position once that function had returned left the move adjacent
to gpu-screen-recorder starting, and the camera was recorded sliding the last
stretch into its corner over the opening frames. The overlay is waited for
explicitly instead, positioned, and only then does capture start.

Waiting for the map is what the blind second was partly guessing at, so the
remainder is trimmed to hold the delay before capture where it was. Starting
later is not free: it eats the opening words of whatever is being narrated.

* Keep the webcam size ladder usable in a narrow region

Capping each preset's width to the region separately collapsed small,
medium and large onto the same width, so Super + Alt + [ and ] had
nothing to step between, and integer division left small taller than
medium. Cap the height the presets scale from instead, which shrinks
the ladder as a whole and keeps the three sizes ordered and distinct.

Cover the anchoring in the test suite: a region the camera follows, the
fallback for an unreadable one, and the narrow-region ladder. Point
XDG_RUNTIME_DIR at the test's own directory while doing so — the resize
helper now reads a region file from there, and the existing geometry
assertions would pick up a real one from a live recording.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: David Heinemeier Hansson <david@hey.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

bin/omarchy-capture-screenrecording

@@ -35,6 +35,7 @@ RESOLUTION=""
 FULLSCREEN="false"
 STOP_RECORDING="false"
 RECORDING_FILE="/tmp/omarchy-screenrecord-filename"
+REGION_FILE="${XDG_RUNTIME_DIR:-/tmp}/omarchy-screenrecord-region"
 LOG_FILE=$([[ ${OMARCHY_SCREENRECORD_DEBUG:-false} == "true" ]] && echo "/tmp/omarchy-screenrecord.log" || echo "/dev/null")
 
 for arg in "$@"; do
@@ -89,11 +90,26 @@ start_webcam_overlay() {
     --title="WebcamOverlay" --wayland-app-id="WebcamOverlay-$WEBCAM_SIZE" \
     --no-border --no-audio --no-osc --osd-level=0 \
     --really-quiet &>/dev/null &
-  sleep 1
+
+  # The move has to settle before gpu-screen-recorder starts, or the camera is
+  # recorded sliding into its corner. Waiting for the map is what the blind
+  # second was partly guessing at, so the remainder is trimmed to hold the
+  # pre-capture delay where it was: starting later costs the first words spoken.
+  local waited=0
+  while ((waited < 40)) && ! hyprctl clients -j | jq -e 'any(.[]; .title == "WebcamOverlay")' >/dev/null 2>&1; do
+    sleep 0.05
+    ((waited++))
+  done
+
+  [[ ${1:-} == region:* ]] && echo "${1#region:}" >"$REGION_FILE"
+  omarchy-capture-webcam-resize "$WEBCAM_SIZE"
+
+  sleep 0.6
 }
 
 cleanup_webcam() {
   pkill -f "WebcamOverlay" 2>/dev/null
+  rm -f "$REGION_FILE"
 }
 
 default_resolution() {
@@ -155,7 +171,7 @@ start_screenrecording() {
     esac
   fi
 
-  [[ $WEBCAM == "true" ]] && start_webcam_overlay
+  [[ $WEBCAM == "true" ]] && start_webcam_overlay "$target"
 
   local filename="$OUTPUT_DIR/screenrecording-$(date +'%Y-%m-%d_%H-%M-%S').mp4"
   local audio_devices=""

bin/omarchy-capture-webcam-resize

@@ -8,6 +8,7 @@
 set -euo pipefail
 
 readonly MARGIN=40
+readonly REGION_FILE="${XDG_RUNTIME_DIR:-/tmp}/omarchy-screenrecord-region"
 
 usage() {
   echo "Usage: omarchy-capture-webcam-resize <smaller|larger|reset|small|medium|large>" >&2
@@ -57,13 +58,39 @@ read -r monitor_x monitor_y monitor_width monitor_height < <(
 
 [[ $monitor_x =~ ^-?[0-9]+$ && $monitor_y =~ ^-?[0-9]+$ && $monitor_width =~ ^[0-9]+$ && $monitor_height =~ ^[0-9]+$ ]] || exit 0
 
-# Scale the 8:9 portrait presets from monitor height so they occupy the same
+# Anchor to the recorded region when there is one, so a window picked on a wide
+# display keeps the camera in its own corner. Full-monitor captures, the portal
+# backend, and resizes outside a recording publish none and fall back here.
+anchor_x=$monitor_x
+anchor_y=$monitor_y
+anchor_width=$monitor_width
+anchor_height=$monitor_height
+
+if [[ -f $REGION_FILE ]] && region=$(<"$REGION_FILE"); then
+  if [[ $region =~ ^([0-9]+)x([0-9]+)\+(-?[0-9]+)\+(-?[0-9]+)$ ]]; then
+    anchor_width=${BASH_REMATCH[1]}
+    anchor_height=${BASH_REMATCH[2]}
+    anchor_x=${BASH_REMATCH[3]}
+    anchor_y=${BASH_REMATCH[4]}
+  fi
+fi
+
+# A tall, narrow region can't fit presets scaled from its own height, so cap the
+# height they scale from to what the width allows — the large preset is the
+# widest at 3/10 of it. Scaling the ladder as a whole leaves small, medium and
+# large distinct sizes for smaller and larger to step between.
+scale_height=$anchor_height
+available_width=$((anchor_width - 2 * MARGIN))
+((available_width > 0 && scale_height * 3 / 10 > available_width)) &&
+  scale_height=$((available_width * 10 / 3))
+
+# Scale the 8:9 portrait presets from that height so they occupy the same
 # proportion of a 1080p, HiDPI, ultrawide, or 6K recording.
-small_height=$(((monitor_height * 9 + 25) / 50))
+small_height=$(((scale_height * 9 + 25) / 50))
 small_width=$(((small_height * 8 + 4) / 9))
-medium_height=$(((monitor_height + 2) / 4))
+medium_height=$(((scale_height + 2) / 4))
 medium_width=$(((medium_height * 8 + 4) / 9))
-large_height=$(((monitor_height * 27 + 40) / 80))
+large_height=$(((scale_height * 27 + 40) / 80))
 large_width=$(((large_height * 8 + 4) / 9))
 
 target_width=$current_width
@@ -107,11 +134,11 @@ larger)
   ;;
 esac
 
-target_x=$((monitor_x + monitor_width - target_width - MARGIN))
-target_y=$((monitor_y + monitor_height - target_height - MARGIN))
+target_x=$((anchor_x + anchor_width - target_width - MARGIN))
+target_y=$((anchor_y + anchor_height - target_height - MARGIN))
 
-((target_x < monitor_x + MARGIN)) && target_x=$((monitor_x + MARGIN))
-((target_y < monitor_y + MARGIN)) && target_y=$((monitor_y + MARGIN))
+((target_x < anchor_x + MARGIN)) && target_x=$((anchor_x + MARGIN))
+((target_y < anchor_y + MARGIN)) && target_y=$((anchor_y + MARGIN))
 
 window="address:$address"
 hypr_dispatch \