Webcam-bubble overlay — M-BUBBLE.0 + .1 + .3

cargo run -p screen-app --features custom-protocol (or just test-recorder) puts a "Show webcam bubble" toggle in the Recorder surface of the AppShell. Clicking it reveals a borderless, transparent, always-on-top 200×200 Tauri window — the future home of the recognisable Screen-Studio-style floating webcam circle. For v0 the bubble shows an indigo "Webcam" placeholder; the live wisp-rendered canvas inside it is M-BUBBLE.2, which is blocked on the M-CAM.3 pipeline (see "Blockers downstream" below).

The bubble's position is persisted across hide / show cycles AND across app launches — drag the bubble anywhere on screen, hide it, reopen it: it reappears at the spot you left it. After a display unplug (so the saved position lands off-screen) the bubble falls back to a sensible default (bottom-right of the primary monitor, 16 px inset).

What ships across the two tickets

End-to-end flow

sequenceDiagram
    participant User
    participant Bundle as app-ui wasm bundle (in the AppShell webview)
    participant Tauri as Tauri shell (main.rs / commands.rs)
    participant State as BubbleState (commands.rs)
    participant Disk as bubble-position.txt
    participant Window as `webcam-bubble` window

    User->>Bundle: Click "Show webcam bubble" button
    Bundle->>Tauri: __TAURI__.core.invoke("toggle_webcam_bubble")
    Tauri->>State: BubbleVisibility::on_click() → Show
    Tauri->>State: last_position?
    alt In-memory cache hit
        State-->>Tauri: Some(pos)
    else Cold launch, no in-memory state
        Tauri->>Disk: read bubble-position.txt
        Disk-->>Tauri: "x,y\n" → BubblePosition
        Tauri->>State: cache it for next show
    else No persisted file, or persisted pos off-screen
        Tauri->>Tauri: default_position(primary_monitor)
    end
    Tauri->>Window: set_position(physical) BEFORE show()
    Tauri->>Window: window.show()
    Window->>Bundle: Load index.html?mount=bubble
    Bundle->>Bundle: parse_mount_point() → MountPoint::Bubble
    Bundle->>User: <BubbleRoot /> with indigo placeholder
    User->>Window: Drag bubble to new spot
    Window->>Tauri: WindowEvent::Moved(physical)
    Tauri->>State: update_bubble_position_from_event(x, y)
    User->>Bundle: Click "Show webcam bubble" again
    Bundle->>Tauri: __TAURI__.core.invoke("toggle_webcam_bubble")
    Tauri->>State: BubbleVisibility::on_click() → Hide
    Tauri->>Window: outer_position()
    Window-->>Tauri: PhysicalPosition(x, y)
    Tauri->>State: cache the position
    Tauri->>Disk: write "x,y\n"
    Tauri->>Window: window.hide()

Coordinate-system contract

Persistence file format

Why M-BUBBLE.1 ships v0, not full

The original ticket scoped per-pixel hit-testing: on macOS, a custom NSView subclass via objc2 overrides hitTest: to return nil for pixels outside the inscribed circle — so clicks on the four transparent corners pass through to whatever's underneath, but clicks on the visible circle still hit the bubble (drag-to-move works). The original "hover toggle" alternative (auto-disable click-through when the cursor enters the visible area, re-enable when it leaves) doesn't work: macOS's setIgnoresMouseEvents(true) filters at the NSWindow level, so the webview never receives the mouseenter event that's supposed to flip it back to false. Chicken-and-egg.

The v0 ship target here is a user-driven toggle: a button in the AppShell that flips the whole bubble between "interactive" (drag works, corners catch clicks) and "click-through" (whole window passes mouse events through). To turn click-through off the user clicks the AppShell button — the bubble itself can't receive the click while passthrough is on, so the out-of-band trigger is required.

The proper per-pixel hitTest: is filed as the v1 follow-up under the same ticket. It needs a small NSView subclass injected at window-creation time (via Tauri's plugin hook + objc2) plus Windows SetWindowRgn(CreateEllipticRgn) and Linux X11/Wayland shape-extension equivalents. Substantial native plumbing per OS; the v0 toggle is an honest middle step.

Why snap-on-drag is inert in v0

The pure-Rust snap_to_nearest_corner helper is fully implemented + tested in crates/app/src/recp/bubble_position.rs — given a current position + monitor bounds + a snap radius, it returns the snapped position OR None if the bubble is far from every corner.

It's not wired to WindowEvent::Moved yet. The reason: calling window.set_position(snapped) from inside the Moved handler triggers another Moved event for the new position. Without a "last-snap-applied-was" guard or a leading-edge debounce, that's an infinite event loop that pegs the OS event queue.

Wiring it cleanly requires either:

1. A small last_snap_applied: AtomicI32 × 2 to short-circuit re-snapping to the same coords, OR
2. A trailing debounce (250 ms via tokio::time::sleep) that fires snap only after the drag stops, OR
3. A separate WindowEvent::MouseUp / DragEnd signal Tauri 2 doesn't expose today on all OSes.

Option 1 is the obvious choice for a follow-up; the math is the load-bearing piece and it's tested. Filed as a v1 polish ticket alongside the resize-handle work that's also deferred from AUT-276.

Tests

• BubbleVisibility state machine (4 tests) — round-trips, default-state, ten-alternating-clicks parity check.
• MountPoint parsing (4 tests) — ?surface=… wins over ?mount=…, unknown queries fall through to DropZone, ?mount=bubble lands in the new Bubble mount.
• default_position — bottom-right of monitor with inset; respects secondary-monitor offsets.
• is_on_any_monitor — true for fully-inside, true for partial overlap, false for fully-off-screen and for positions that assumed a now-gone secondary display.
• snap_to_nearest_corner — snaps to bottom-right when near, snaps to top-left when near, chooses nearest corner when two are in range, returns None for dead-center, respects monitor offsets.
• BubbleState + persistence helpers — encode_position / decode_position round-trip; rejects malformed inputs (missing comma, non-integer, empty); tolerates whitespace + missing trailing newline; update_bubble_position_from_event updates the in-memory cache atomically.

Total: 26+ unit tests covering the M-BUBBLE.0 + .3 surface.

Manually verifiable

Blockers downstream

Cross-link

• Tauri tray → AppShell flow — the existing tray-popover machinery this work parallels (same state-machine shape, same URL-routed mount pattern).