+mod nswindow_overlay;

+/// Per-overlay state: an NSWindow drawing the rounded-rect border via

+/// CAShapeLayer. Replaces the old SLS-only overlay window — see

+/// nswindow_overlay.rs for the rationale (screencaptureui on Tahoe

+/// only honors NSWindow.sharingType, not SLS sharing-state nor tag

+/// bits, for raw SLS-only windows).

+    window: nswindow_overlay::OverlayWindow,

+}

+

+impl Overlay {

+    fn wid(&self) -> u32 {

+        self.window.wid()

+    }

+    fn bounds(&self) -> CGRect {

+        CGRect {

+            origin: CGPoint {

+                x: self.window.bounds_cg_x,

+                y: self.window.bounds_cg_y,

+            },

+            size: CGSize {

+                width: self.window.bounds_cg_w,

+                height: self.window.bounds_cg_h,

+            },

+        }

+    }

+    mtm: objc2::MainThreadMarker,

+    fn new(

+        cid: CGSConnectionID,

+        own_pid: i32,

+        border_width: f64,

+        mtm: objc2::MainThreadMarker,

+    ) -> Self {

+            mtm,

+        self.overlays.values().any(|o| o.wid() == wid)

+        if let Some(window) = nswindow_overlay::OverlayWindow::new(

+            bounds.origin.x,

+            bounds.origin.y,

+            bounds.size.width,

+            bounds.size.height,

+            self.mtm,

+            window.order_above(target_wid);

+            self.overlays.insert(target_wid, Overlay { window });

+            debug!(

+                "[remove] target={} overlay_wid={} dropping NSWindow",

+                target_wid,

+                overlay.wid()

+            );

+            // OverlayWindow's Drop runs orderOut + close.

+            drop(overlay);

+        } else {

+            debug!("[remove] target={} not tracked", target_wid);

+        if !self.overlays.contains_key(&target_wid) {

+        }

+        let mut bounds = CGRect::default();

+                // Window is gone (destroyed). Reap the overlay.

+                debug!(

+                    "[sync_overlay] target={} SLSGetWindowBounds failed — reaping overlay",

+                    target_wid

+                );

+                self.remove(target_wid);

+                return true;

+        }

+

+        let active_only = self.active_only;

+        let focused = self.focused_wid;

+        if let Some(overlay) = self.overlays.get_mut(&target_wid) {

+            let prev = overlay.bounds();

+            if size_changed(prev, bounds) || origin_changed(prev, bounds) {

+                    "[sync_overlay] target={} geometry ({:.1},{:.1},{:.1},{:.1}) -> ({:.1},{:.1},{:.1},{:.1})",

+                    prev.origin.x,

+                    prev.origin.y,

+                    prev.size.width,

+                    prev.size.height,

+                    bounds.origin.x,

+                    bounds.origin.y,

+                    bounds.size.width,

+                    bounds.size.height

+                );

+                overlay.window.set_bounds(

+                // orderWindow:relativeTo: re-shows an off-screen window

+                // as a side effect. In active_only mode, non-focused

+                // overlays must remain hidden — otherwise stack peek

+                // positions cause every stacked window's overlay to

+                // pop onto the screen as their bounds shift.

+                if !active_only || target_wid == focused {

+                    overlay.window.order_above(target_wid);

+                }

+    /// Re-apply each overlay's CAShapeLayer geometry. Called on a slow

+    /// periodic schedule (and on hotplug) to repair layer state that

+    /// macOS occasionally resets during display sleep/wake without

+    /// changing the NSWindow's frame — sync_overlay won't fix it on

+    /// its own because the SLS bounds match what we already stored.

+    fn refresh_all_layers(&self) {

+        for overlay in self.overlays.values() {

+            overlay.window.reapply_layer();

+    }

+

+    /// Re-apply set_bounds for every tracked overlay even when the

+    /// stored CG bounds match the current SLS bounds. After a display

+    /// reconfiguration the cocoa frame depends on the (possibly new)

+    /// primary screen height, so unchanged CG bounds still need their

+    /// cocoa frame recomputed.

+    fn reconcile_all_force(&mut self) {

+        let tracked: Vec<u32> = self.overlays.keys().copied().collect();

+        let active_only = self.active_only;

+        let focused = self.focused_wid;

+        for wid in tracked {

+            let mut bounds = CGRect::default();

+            unsafe {

+                if SLSGetWindowBounds(self.main_cid, wid, &mut bounds) != kCGErrorSuccess {

+                    self.remove(wid);

+                    continue;

+                }

+            }

+            if let Some(overlay) = self.overlays.get_mut(&wid) {

+                overlay.window.set_bounds(

+                    bounds.origin.x,

+                    bounds.origin.y,

+                    bounds.size.width,

+                    bounds.size.height,

+                );

+                if !active_only || wid == focused {

+                    overlay.window.order_above(wid);

+                }

+            }

+            debug!("[hide] target={} overlay_wid={}", target_wid, o.wid());

+            o.window.order_out();

+            debug!("[unhide] target={} overlay_wid={}", target_wid, o.wid());

+            o.window.order_above(target_wid);

+            overlay.window.set_color(self.color_for(target_wid));

+        if front == 0 {

+            return;

+        }

+        if front == self.focused_wid {

+            // Same focus as last poll. But a freshly-spawned window may

+            // have been focused before its SLS state was complete enough

+            // to pass the add_fresh filter — retry on every poll until

+            // it sticks.

+            if !self.overlays.contains_key(&front) {

+                self.add_fresh(front);

+                if self.overlays.contains_key(&front) {

+                    debug!("[focus-retry] front={} now tracked", front);

+                    self.subscribe_target(front);

+                    if self.active_only {

+                        self.unhide(front);

+                    }

+                }

+            }

+

+        // tarmac-style workspace switching can swap focus to a window

+        // that wasn't visible (and therefore not discovered) at ers

+        // startup. Discover_windows only enumerates on-current-space

+        // windows; tarmac stages other workspaces' windows in a hidden

+        // state ers never picked up. If focus lands on such a wid,

+        // create an overlay for it on demand.

+        let new_target = !self.overlays.contains_key(&front);

+        debug!(

+            "[focus] {} -> {} {}(tracked targets: {:?})",

+            old,

+            front,

+            if new_target { "[NEW] " } else { "" },

+            self.overlays.keys().collect::<Vec<_>>()

+        );

+        if new_target {

+            self.add_fresh(front);

+            self.subscribe_target(front);

+        }

+

+        // Pull both overlays' positions to the targets' current SLS bounds

+        // before un/hiding. AX-driven moves during a stack cycle frequently

+        // don't fire SLS WINDOW_MOVE notifications, so a stored overlay

+        // can be at stale coordinates. SLSGetWindowBounds (inside

+        // sync_overlay) is real-time and doesn't wait for a notification.

+        self.sync_overlay(old);

+        self.sync_overlay(front);

+                o.window.order_above(target_wid);

+                o.window.order_out();

+    let env_filter = tracing_subscriber::EnvFilter::try_from_default_env()

+        .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("ers=info"));

+        .with_env_filter(env_filter)

+    debug!("[main] ers starting, pid={}", std::process::id());

+    // Initialize NSApplication on the main thread before we touch any

+    // AppKit APIs. NSWindow operations (used by nswindow_overlay) all

+    // require a main-thread context.

+    let mtm = nswindow_overlay::init_application();

+    nswindow_overlay::log_screens(mtm);

+    register_display_hotplug_callback();

+

+    let mut borders = BorderMap::new(cid, own_pid, border_width, mtm);

+    // Process events on the main thread via a CFRunLoopTimer.

+    // BorderMap holds Retained<NSWindow> handles, which are

+    // !Send/!Sync — AppKit calls must originate from the main thread.

+    // Stash state in thread_local for the C callback to access.

+    MAIN_STATE.with(|cell| {

+        *cell.borrow_mut() = Some(MainState {

+            borders,

+            rx,

+            pending: HashMap::new(),

+            batch_events: Vec::new(),

+            batch_first_seen: None,

+        });

+    });

+    unsafe {

+        let mut ctx = CFRunLoopTimerContext {

+            version: 0,

+            info: ptr::null_mut(),

+            retain: None,

+            release: None,

+            copy_description: None,

+        };

+        let timer = CFRunLoopTimerCreate(

+            ptr::null(),

+            CFAbsoluteTimeGetCurrent() + 0.05,

+            0.016,

+            0u64,

+            0i64,

+            timer_callback,

+            &mut ctx,

+        );

+        CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopDefaultMode);

+    }

+

+    unsafe { CFRunLoopRun() };

+

+    // Drop everything on the main thread (NSWindow.close in Drop).

+    MAIN_STATE.with(|cell| cell.borrow_mut().take());

+

+    SIGNAL_STOP_REQUESTED.store(true, Ordering::Relaxed);

+    let _ = signal_watcher.join();

+    drop(running);

+}

+

+struct MainState {

+    borders: BorderMap,

+    rx: mpsc::Receiver<Event>,

+    pending: HashMap<u32, std::time::Instant>,

+    batch_events: Vec<Event>,

+    batch_first_seen: Option<std::time::Instant>,

+}

+

+thread_local! {

+    static MAIN_STATE: std::cell::RefCell<Option<MainState>> = const { std::cell::RefCell::new(None) };

+}

+

+extern "C" fn timer_callback(_timer: *mut std::ffi::c_void, _info: *mut std::ffi::c_void) {

+    use std::time::{Duration, Instant};

+    use std::sync::atomic::AtomicUsize;

+    static TICK_COUNT: AtomicUsize = AtomicUsize::new(0);

+    let tick = TICK_COUNT.fetch_add(1, Ordering::Relaxed);

+    if tick == 0 {

+        debug!("[timer] first fire — main-thread event loop is alive");

+    } else if tick % 600 == 0 {

+        // every ~10s if interval is 16ms

+        debug!("[timer] tick {}", tick);

+    }

+    MAIN_STATE.with(|cell| {

+        let mut state_opt = cell.borrow_mut();

+        let s = match state_opt.as_mut() {

+            Some(s) => s,

+            None => return,

+        };

+        let mut received = 0usize;

+        loop {

+            match s.rx.try_recv() {

+                Ok(e) => {

+                    if s.batch_events.is_empty() {

+                        s.batch_first_seen = Some(Instant::now());

+                    s.batch_events.push(e);

+                    received += 1;

+                Err(mpsc::TryRecvError::Empty) => break,

+                Err(mpsc::TryRecvError::Disconnected) => break,

+        }

+        if received > 0 {

+            debug!(

+                "[timer] received {} new events; batch size now {}",

+                received,

+                s.batch_events.len()

+            );

+        }

+        // Process the accumulated batch after a 16ms quiet window

+        // (matches the old bg-thread behavior where it slept 16ms after

+        // the first event then drained). Events keep arriving, the batch

+        // grows; once 16ms passes without new events we flush.

+        let should_flush = s.batch_first_seen.is_some_and(|t| {

+            t.elapsed() >= Duration::from_millis(16) && received == 0

+        }) || s

+            .batch_first_seen

+            .is_some_and(|t| t.elapsed() >= Duration::from_millis(120));

+        if should_flush {

+            let events = std::mem::take(&mut s.batch_events);

+            s.batch_first_seen = None;

+            debug!("[timer] processing batch of {}", events.len());

+            process_event_batch(&mut s.borders, &mut s.pending, events);

+        } else {

+            // Even with no events, poll focus periodically so a missed

+            // FrontChange notification doesn't strand the active border.

+            // Cheap operation when focus hasn't changed.

+            s.borders.update_focus();

+            // Once per second, reconcile tracked overlays against

+            // current SLS state. Catches missed Close/Destroy events

+            // that would otherwise leave a dead border on screen.

+            if tick % 60 == 0 && tick > 0 {

+                let removed = s.borders.reconcile_tracked();

+                if removed {

+                    debug!("[timer] periodic reconcile removed stale overlays");

+                }

+                // Cheap: re-applies just the CAShapeLayer frame/path

+                // for every overlay. Recovers from layer state that

+                // macOS resets during display sleep/wake without

+                // touching the NSWindow frame.

+                s.borders.refresh_all_layers();

+        }

+    });

+}

+fn process_event_batch(

+    borders: &mut BorderMap,

+    pending: &mut HashMap<u32, std::time::Instant>,

+    events: Vec<Event>,

+) {

+    use std::collections::HashSet;

+    use std::time::{Duration, Instant};

+

+    let mut moved: HashSet<u32> = HashSet::new();

+    let mut resized: HashSet<u32> = HashSet::new();

+    let mut destroyed: HashSet<u32> = HashSet::new();

+    let mut needs_resubscribe = false;

+

+    for event in events {

+        match event {

+            Event::Move(wid) => {

+                if !borders.is_overlay(wid) {

+                    moved.insert(wid);

+            Event::Resize(wid) => {

+                if !borders.is_overlay(wid) {

+                    resized.insert(wid);

+            Event::Close(wid) | Event::Destroy(wid) => {

+                if !borders.is_overlay(wid) {

+                    debug!("[event] Close/Destroy target_wid={}", wid);

+                    destroyed.insert(wid);

+                    pending.remove(&wid);

+            Event::Create(wid) => {

+                if !borders.is_overlay(wid) {

+                    pending.entry(wid).or_insert_with(Instant::now);

+                    borders.subscribe_target(wid);

+            Event::Hide(wid) => borders.hide(wid),

+            Event::Unhide(wid) => {

+                if !borders.is_overlay(wid) {

+                    if !borders.overlays.contains_key(&wid) {

+                        borders.add_fresh(wid);

+                        borders.subscribe_target(wid);

+                    }

+                    if !borders.active_only || wid == borders.focused_wid {

+                        borders.unhide(wid);

+                    }

+            Event::FrontChange => {

+                needs_resubscribe = true;

+            }

+            Event::SpaceChange => {

+                needs_resubscribe = true;

+        }

+    }

+    for wid in &destroyed {

+        borders.remove(*wid);

+    }

+    let now = Instant::now();

+    let ready: Vec<u32> = pending

+        .iter()

+        .filter(|(wid, seen_at)| {

+            !destroyed.contains(wid) && now.duration_since(**seen_at) >= Duration::from_millis(100)

+        })

+        .map(|(wid, _)| *wid)

+        .collect();

+

+    let mut bounds_map: Vec<(u32, CGRect)> = Vec::new();

+    for &wid in &ready {

+        unsafe {

+            let mut b = CGRect::default();

+            SLSGetWindowBounds(borders.main_cid, wid, &mut b);

+            bounds_map.push((wid, b));

+        }

+    }

+    let mut skip: std::collections::HashSet<u32> = HashSet::new();

+    for i in 0..bounds_map.len() {

+        for j in (i + 1)..bounds_map.len() {

+            let (wid_a, a) = &bounds_map[i];

+            let (wid_b, b) = &bounds_map[j];

+            if let Some(preference) = surface_preference(*a, *b) {

+                match preference {

+                    SurfacePreference::KeepExisting => {

+                        skip.insert(*wid_b);

+                    }

+                    SurfacePreference::ReplaceExisting => {

+                        skip.insert(*wid_a);

+                    }

+                }

+        }

+    }

+    for &wid in &ready {

+        pending.remove(&wid);

+        if !skip.contains(&wid) {

+            borders.add_fresh(wid);

+            if borders.active_only && wid != borders.focused_wid {

+                borders.hide(wid);

+            }

+            needs_resubscribe = true;

+    }

+    for wid in &moved {

+        if !resized.contains(wid) && !ready.contains(wid) && borders.sync_overlay(*wid) {

+            needs_resubscribe = true;

+        }

+    }

+    for wid in &resized {

+        if !ready.contains(wid)

+            && borders.overlays.contains_key(wid)

+            && borders.sync_overlay(*wid)

+        {

+            needs_resubscribe = true;

+        }

+    }

+    if needs_resubscribe {

+        borders.discover_untracked();

+    }

+

+    needs_resubscribe |= borders.reconcile_tracked();

+

+    borders.update_focus();

+

+    if needs_resubscribe || !destroyed.is_empty() {

+        borders.subscribe_all();

+    }

+

+    borders.enforce_active_only();

+}

+

+/// Re-log the screen layout when the display configuration changes

+/// (monitor plug/unplug, resolution change). The callback also nudges

+/// every tracked overlay to re-fetch its bounds so any cached cocoa Y

+/// computed against the old primary height gets refreshed.

+unsafe extern "C" fn display_reconfig_callback(

+    display_id: u32,

+    flags: u32,

+    _user_info: *mut std::ffi::c_void,

+) {

+    debug!(display_id, flags, "[hotplug] CGDisplay reconfiguration");

+    if let Some(mtm) = objc2::MainThreadMarker::new() {

+        nswindow_overlay::log_screens(mtm);

+    }

+    MAIN_STATE.with(|cell| {

+        if let Some(s) = cell.borrow_mut().as_mut() {

+            s.borders.reconcile_all_force();

+            s.borders.refresh_all_layers();

+        }

+    });

+}

+

+fn register_display_hotplug_callback() {

+    unsafe {

+        let rc = CGDisplayRegisterReconfigurationCallback(

+            Some(display_reconfig_callback),

+            std::ptr::null_mut(),

+        );

+        debug!("[hotplug] register CGDisplayReconfiguration rc={}", rc);

+    }