@lattices/cli 0.4.9 → 0.4.11

package/{app → apps/mac}/Sources/Core/Desktop/WindowDragSnapController.swift

@@ -36,7 +36,6 @@ final class WindowDragSnapController {
 
     private var dragCandidate: DragWindowCandidate?
     private var activeSession: DragSession?
-    private var overlayPanels: [String: WindowSnapOverlayPanel] = [:]
     private var modifierModeEnabled = false
     private var windowHasMoved = false
 
@@ -203,9 +202,7 @@ final class WindowDragSnapController {
     }
 
     private func hideOverlays() {
-        for panel in overlayPanels.values {
-            panel.orderOut(nil)
-        }
+        ScreenOverlayCanvasController.shared.removeLayers(owner: .dragSnap)
     }
 
     private func captureFocusedWindow(at mouseLocation: NSPoint) -> DragWindowCandidate? {
@@ -271,7 +268,7 @@ final class WindowDragSnapController {
 
         var resolved: [ResolvedSnapZone] = []
         for screen in NSScreen.screens {
-            let screenID = Self.screenID(for: screen)
+            let screenID = ScreenOverlayCanvasController.screenID(for: screen)
             for (zone, placement, triggerFractions, priority) in baseZones {
                 let triggerRect = Self.screenRect(for: triggerFractions, on: screen)
                 let previewRect = Self.screenRect(fromAX: WindowTiler.tileFrame(for: placement, on: screen))
@@ -312,17 +309,14 @@ final class WindowDragSnapController {
     private func render(zones: [ResolvedSnapZone], hoveredZone: ResolvedSnapZone?) {
         let config = WorkspaceManager.shared.snapZonesConfig
         let grouped = Dictionary(grouping: zones, by: \.screenID)
-        let activeScreenIDs = Set(grouped.keys)
+        var layers: [ScreenOverlayLayerSnapshot] = []
 
         for screen in NSScreen.screens {
-            let screenID = Self.screenID(for: screen)
+            let screenID = ScreenOverlayCanvasController.screenID(for: screen)
             guard let screenZones = grouped[screenID], !screenZones.isEmpty else { continue }
 
-            let panel = overlayPanels[screenID] ?? makeOverlayPanel(for: screen)
-            panel.setFrame(screen.frame, display: false)
-
             let localZones = screenZones.map {
-                WindowSnapOverlayView.Zone(
+                ScreenOverlaySnapZone(
                     id: $0.id,
                     label: $0.label,
                     rect: $0.visibleRect.offsetBy(dx: -screen.frame.minX, dy: -screen.frame.minY),
@@ -334,7 +328,7 @@ final class WindowDragSnapController {
                 ? hoveredZone?.previewRect.offsetBy(dx: -screen.frame.minX, dy: -screen.frame.minY)
                 : nil
 
-            panel.overlayView.model = WindowSnapOverlayView.Model(
+            let payload = ScreenOverlaySnapZonesPayload(
                 zones: localZones,
                 previewRect: previewRect,
                 previewLabel: nil,
@@ -344,26 +338,20 @@ final class WindowDragSnapController {
                 cornerRadius: config.cornerRadius ?? SnapZonesConfig.defaults.cornerRadius ?? 18
             )
 
-            panel.orderFrontRegardless()
-        }
-
-        for (screenID, panel) in overlayPanels where !activeScreenIDs.contains(screenID) {
-            panel.orderOut(nil)
+            layers.append(
+                ScreenOverlayLayerSnapshot(
+                    id: ScreenOverlayLayerID("dragSnap.\(screenID)"),
+                    owner: .dragSnap,
+                    screen: .screen(id: screenID),
+                    zIndex: 100,
+                    opacity: 1,
+                    payload: .snapZones(payload),
+                    expiresAt: nil
+                )
+            )
         }
-    }
 
-    private func makeOverlayPanel(for screen: NSScreen) -> WindowSnapOverlayPanel {
-        let panel = WindowSnapOverlayPanel(frame: screen.frame)
-        overlayPanels[Self.screenID(for: screen)] = panel
-        return panel
-    }
-
-    private static func screenID(for screen: NSScreen) -> String {
-        let key = NSDeviceDescriptionKey("NSScreenNumber")
-        if let number = screen.deviceDescription[key] as? NSNumber {
-            return number.stringValue
-        }
-        return screen.localizedName
+        ScreenOverlayCanvasController.shared.replaceLayers(owner: .dragSnap, with: layers)
     }
 
     private static func screenRect(for fractions: (CGFloat, CGFloat, CGFloat, CGFloat), on screen: NSScreen) -> CGRect {
@@ -439,190 +427,3 @@ final class WindowDragSnapController {
         Swift.max(lower, Swift.min(upper, value))
     }
 }
-
-private final class WindowSnapOverlayPanel: NSPanel {
-    let overlayView = WindowSnapOverlayView(frame: .zero)
-
-    init(frame: CGRect) {
-        super.init(
-            contentRect: frame,
-            styleMask: [.borderless, .nonactivatingPanel],
-            backing: .buffered,
-            defer: false
-        )
-
-        isOpaque = false
-        backgroundColor = .clear
-        hasShadow = false
-        ignoresMouseEvents = true
-        level = NSWindow.Level(rawValue: Int(CGWindowLevelForKey(.maximumWindow)))
-        collectionBehavior = [.canJoinAllSpaces, .stationary, .fullScreenAuxiliary]
-        isMovable = false
-        hidesOnDeactivate = false
-        animationBehavior = .none
-        overlayView.frame = NSRect(origin: .zero, size: frame.size)
-        overlayView.autoresizingMask = [.width, .height]
-        contentView = overlayView
-    }
-
-    override var canBecomeKey: Bool { false }
-    override var canBecomeMain: Bool { false }
-}
-
-private final class WindowSnapOverlayView: NSView {
-    struct Zone {
-        let id: String
-        let label: String
-        let rect: CGRect
-        let isHovered: Bool
-    }
-
-    struct Model {
-        let zones: [Zone]
-        let previewRect: CGRect?
-        let previewLabel: String?
-        let zoneOpacity: CGFloat
-        let highlightOpacity: CGFloat
-        let previewOpacity: CGFloat
-        let cornerRadius: CGFloat
-
-        static let empty = Model(
-            zones: [],
-            previewRect: nil,
-            previewLabel: nil,
-            zoneOpacity: 0.10,
-            highlightOpacity: 0.22,
-            previewOpacity: 0.18,
-            cornerRadius: 18
-        )
-    }
-
-    var model: Model = .empty {
-        didSet { needsDisplay = true }
-    }
-
-    override init(frame frameRect: NSRect) {
-        super.init(frame: frameRect)
-        wantsLayer = true
-        layer?.backgroundColor = NSColor.clear.cgColor
-    }
-
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-
-    override func draw(_ dirtyRect: NSRect) {
-        NSColor.clear.setFill()
-        bounds.fill()
-
-        for zone in model.zones {
-            drawZone(zone)
-        }
-
-        if let previewRect = model.previewRect {
-            drawPreview(previewRect, label: model.previewLabel)
-        }
-    }
-
-    private func drawZone(_ zone: Zone) {
-        let rect = zone.rect.insetBy(dx: 1.5, dy: 1.5)
-        let radius = min(model.cornerRadius, min(rect.width, rect.height) * 0.34)
-        let path = NSBezierPath(roundedRect: rect, xRadius: radius, yRadius: radius)
-        let idleStrength = max(0.35, min(model.zoneOpacity / 0.10, 1.4))
-        let hoverStrength = max(0.35, min(model.highlightOpacity / 0.22, 1.4))
-
-        let shadow = NSShadow()
-        shadow.shadowBlurRadius = zone.isHovered ? 18 : 10
-        shadow.shadowOffset = NSSize(width: 0, height: -2)
-        shadow.shadowColor = NSColor.black.withAlphaComponent(zone.isHovered ? 0.20 : 0.10)
-
-        NSGraphicsContext.saveGraphicsState()
-        shadow.set()
-        let baseTop = NSColor(
-            calibratedWhite: 0.13,
-            alpha: zone.isHovered ? 0.42 * hoverStrength : 0.22 * idleStrength
-        )
-        let baseBottom = NSColor(
-            calibratedWhite: 0.07,
-            alpha: zone.isHovered ? 0.34 * hoverStrength : 0.15 * idleStrength
-        )
-        NSGradient(starting: baseTop, ending: baseBottom)?.draw(in: path, angle: -90)
-        NSGraphicsContext.restoreGraphicsState()
-
-        if zone.isHovered {
-            let glowPath = path.copy() as! NSBezierPath
-            glowPath.lineWidth = 6
-            NSColor(calibratedRed: 0.25, green: 0.84, blue: 0.58, alpha: model.highlightOpacity * 0.28).setStroke()
-            glowPath.stroke()
-        }
-
-        path.lineWidth = zone.isHovered ? 1.6 : 1.0
-        NSColor(
-            calibratedRed: 0.52,
-            green: 0.94,
-            blue: 0.72,
-            alpha: zone.isHovered ? 0.54 * hoverStrength : 0.10 * idleStrength
-        ).setStroke()
-        path.stroke()
-
-        let lipRect = CGRect(x: rect.minX + 1.5, y: rect.maxY - 2.5, width: rect.width - 3, height: 2)
-        if lipRect.width > 0 {
-            let lipPath = NSBezierPath(roundedRect: lipRect, xRadius: 1, yRadius: 1)
-            NSColor.white.withAlphaComponent(zone.isHovered ? 0.18 : 0.08).setFill()
-            lipPath.fill()
-        }
-
-        drawLabel(zone.label, in: rect, emphasized: zone.isHovered)
-    }
-
-    private func drawPreview(_ rect: CGRect, label: String?) {
-        let previewRect = rect.insetBy(dx: 10, dy: 10)
-        let radius = min(model.cornerRadius, min(previewRect.width, previewRect.height) * 0.14)
-        let path = NSBezierPath(roundedRect: previewRect, xRadius: radius, yRadius: radius)
-
-        NSColor(calibratedWhite: 1.0, alpha: model.previewOpacity * 0.22).setFill()
-        path.fill()
-
-        path.lineWidth = 1.6
-        path.setLineDash([10, 8], count: 2, phase: 0)
-        NSColor(
-            calibratedRed: 0.44,
-            green: 0.90,
-            blue: 0.68,
-            alpha: max(0.34, model.previewOpacity * 3.2)
-        ).setStroke()
-        path.stroke()
-        path.setLineDash([], count: 0, phase: 0)
-
-        let innerPath = NSBezierPath(roundedRect: previewRect.insetBy(dx: 7, dy: 7), xRadius: max(radius - 4, 8), yRadius: max(radius - 4, 8))
-        innerPath.lineWidth = 1
-        NSColor.white.withAlphaComponent(max(0.08, model.previewOpacity * 1.2)).setStroke()
-        innerPath.stroke()
-
-        if let label {
-            let tagRect = CGRect(x: previewRect.minX + 14, y: previewRect.maxY - 34, width: 110, height: 24)
-            let tagPath = NSBezierPath(roundedRect: tagRect, xRadius: 12, yRadius: 12)
-            NSColor(calibratedWhite: 0.08, alpha: 0.62).setFill()
-            tagPath.fill()
-            NSColor.white.withAlphaComponent(0.10).setStroke()
-            tagPath.lineWidth = 1
-            tagPath.stroke()
-            drawLabel(label, in: tagRect, emphasized: true)
-        }
-    }
-
-    private func drawLabel(_ label: String, in rect: CGRect, emphasized: Bool) {
-        let font = NSFont.monospacedSystemFont(ofSize: emphasized ? 11 : 10, weight: emphasized ? .semibold : .medium)
-        let attributes: [NSAttributedString.Key: Any] = [
-            .font: font,
-            .foregroundColor: NSColor.white.withAlphaComponent(emphasized ? 0.92 : 0.72),
-        ]
-        let attr = NSAttributedString(string: label.uppercased(), attributes: attributes)
-        let size = attr.size()
-        let drawPoint = CGPoint(
-            x: rect.midX - size.width / 2,
-            y: rect.midY - size.height / 2
-        )
-        attr.draw(at: drawPoint)
-    }
-}

package/{app → apps/mac}/Sources/Core/Desktop/WindowPreviewStore.swift

@@ -53,11 +53,10 @@ final class WindowPreviewStore: ObservableObject {
         queue.async { [weak self] in
             guard let self else { return }
 
-            let cgImage = CGWindowListCreateImage(
-                .null,
-                .optionIncludingWindow,
-                CGWindowID(wid),
-                [.boundsIgnoreFraming, .nominalResolution]
+            let cgImage = WindowCapture.image(
+                listOption: .optionIncludingWindow,
+                windowID: CGWindowID(wid),
+                imageOption: [.boundsIgnoreFraming, .nominalResolution]
             )
 
             let image = cgImage.map {

package/{app → apps/mac}/Sources/Core/Desktop/WindowTiler.swift

@@ -641,6 +641,14 @@ enum WindowTiler {
             "switchToAdjacentSpace: offset=\(offset) point=\(formatCGPoint(context.point)) displayId=\(context.display.displayId) active=\(context.activeSpaceId) displayCurrent=\(context.display.currentSpaceId) resolved=\(context.currentSpaceId) target=\(targetText) spaces=\(spaces)"
         )
 
+        if let target = context.target {
+            let switched = switchToSpace(spaceId: target.id)
+            DiagnosticLog.shared.info("switchToAdjacentSpace: SkyLight \(switched ? "reached" : "missed") target \(target.id)")
+            if switched {
+                return true
+            }
+        }
+
         if getDisplaySpaces().count == 1 {
             if let finalSpaceId = switchToAdjacentSpaceViaSystemShortcut(
                 offset: offset,
@@ -663,10 +671,7 @@ enum WindowTiler {
             DiagnosticLog.shared.warn("switchToAdjacentSpace: system shortcut stayed on \(context.currentSpaceId), falling back to SkyLight target \(target.id)")
         }
 
-        guard let target = context.target else { return false }
-        let switched = switchToSpace(spaceId: target.id)
-        DiagnosticLog.shared.info("switchToAdjacentSpace: SkyLight \(switched ? "reached" : "missed") target \(target.id)")
-        return switched
+        return false
     }
 
     /// Find a window by its title tag and return its CGWindowID and owner PID
@@ -2094,16 +2099,17 @@ enum WindowTiler {
 
     private static func switchToAdjacentSpaceViaSystemShortcut(offset: Int, displayId: String, initialSpaceId: Int) -> Int? {
         let keyCode: CGKeyCode = offset < 0 ? 123 : 124
-        let script = """
-        tell application "System Events"
-            key code \(keyCode) using control down
-        end tell
-        return "ok"
-        """
-        let result = ProcessQuery.shell(["/usr/bin/osascript", "-e", script])
-        if result != "ok" {
-            DiagnosticLog.shared.warn("switchToAdjacentSpace: system shortcut script did not complete for offset \(offset)")
+        guard let source = CGEventSource(stateID: .combinedSessionState),
+              let down = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: true),
+              let up = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: false) else {
+            DiagnosticLog.shared.warn("switchToAdjacentSpace: system shortcut event source unavailable for offset \(offset)")
+            return nil
         }
+        down.flags = .maskControl
+        up.flags = .maskControl
+        down.post(tap: .cghidEventTap)
+        usleep(12_000)
+        up.post(tap: .cghidEventTap)
         return waitForSpaceChange(displayId: displayId, initialSpaceId: initialSpaceId, timeout: 1.2)
     }
 

package/apps/mac/Sources/Core/Input/EventTapBreaker.swift

@@ -0,0 +1,124 @@
+import Foundation
+
+/// Self-healing circuit breaker for session-wide `CGEventTap`s.
+///
+/// macOS disables a tap (`tapDisabledByTimeout`) when its callback exceeds
+/// the OS budget. The naive recovery — re-enable and continue — fights the
+/// OS in a loop when the underlying cause is still present, and the system
+/// input pipeline keeps stuttering.
+///
+/// This breaker counts trips inside a rolling window and backs off in
+/// escalating cooldowns: 30s → 2 min → permanent (until app restart or
+/// manual re-arm). During cooldown the tap stays disabled — input flows
+/// through the OS without our interference. On cooldown expiry, `rearm`
+/// fires on the main queue to re-enable the tap.
+///
+/// Thread-safe; `recordTrip()` is safe to call from the event-tap thread.
+final class EventTapBreaker {
+    enum State: Equatable {
+        case armed
+        case paused(cooldownSec: Int)
+        case disabled
+    }
+
+    private let label: String
+    private let trippedWindow: TimeInterval = 600          // 10 min rolling window
+    private let cooldowns: [TimeInterval] = [30, 120]      // trip 1 → 30s, trip 2 → 2 min, trip 3+ → permanent
+
+    private let lock = NSLock()
+    private var tripsInWindow: [Date] = []
+    private var permanentlyDisabled = false
+    private var pendingRearm: DispatchWorkItem?
+    private var _state: State = .armed
+
+    /// Called on the main queue when a cooldown elapses. Caller wires this
+    /// to `CGEvent.tapEnable(tap:, enable: true)`.
+    var rearm: (() -> Void)?
+
+    /// Called on the main queue whenever `state` transitions. UI uses this
+    /// to surface "paused" / "disabled" messages and re-enable affordances.
+    var onStateChanged: ((State) -> Void)?
+
+    init(label: String) {
+        self.label = label
+    }
+
+    var state: State {
+        lock.lock(); defer { lock.unlock() }
+        return _state
+    }
+
+    /// Record that the OS just delivered `.tapDisabledByTimeout`. Schedules
+    /// a re-enable after the appropriate cooldown, or marks the breaker
+    /// permanently open after too many trips.
+    @discardableResult
+    func recordTrip() -> Bool {
+        lock.lock()
+        if permanentlyDisabled { lock.unlock(); return false }
+
+        let now = Date()
+        tripsInWindow.removeAll { now.timeIntervalSince($0) > trippedWindow }
+        tripsInWindow.append(now)
+
+        let count = tripsInWindow.count
+        if count > cooldowns.count {
+            permanentlyDisabled = true
+            pendingRearm?.cancel()
+            pendingRearm = nil
+            _state = .disabled
+            lock.unlock()
+            DiagnosticLog.shared.error("\(label): tap tripped \(count)× in \(Int(trippedWindow))s — disabled until app restart or manual re-arm")
+            notifyStateChanged(.disabled)
+            return false
+        }
+
+        let cooldown = cooldowns[count - 1]
+        _state = .paused(cooldownSec: Int(cooldown))
+        let nextState: State = .paused(cooldownSec: Int(cooldown))
+
+        pendingRearm?.cancel()
+        let work = DispatchWorkItem { [weak self] in
+            guard let self else { return }
+            DiagnosticLog.shared.info("\(self.label): tap auto-recovering")
+            self.lock.lock()
+            self._state = .armed
+            self.lock.unlock()
+            self.notifyStateChanged(.armed)
+            self.rearm?()
+        }
+        pendingRearm = work
+        lock.unlock()
+
+        DiagnosticLog.shared.warn("\(label): tap disabled by OS (trip #\(count)) — paused for \(Int(cooldown))s")
+        notifyStateChanged(nextState)
+        DispatchQueue.main.asyncAfter(deadline: .now() + cooldown, execute: work)
+        return false
+    }
+
+    /// Clears all trip history and any pending cooldown. Caller should
+    /// re-enable the tap after this to actually recover.
+    /// Use cases: tap (re)install, manual re-arm from Settings.
+    func reset() {
+        lock.lock()
+        let wasNotArmed = _state != .armed
+        pendingRearm?.cancel()
+        pendingRearm = nil
+        tripsInWindow.removeAll()
+        permanentlyDisabled = false
+        _state = .armed
+        lock.unlock()
+        if wasNotArmed {
+            DiagnosticLog.shared.info("\(label): tap state reset (armed)")
+            notifyStateChanged(.armed)
+        }
+    }
+
+    private func notifyStateChanged(_ newState: State) {
+        guard let callback = onStateChanged else { return }
+        if Thread.isMainThread {
+            callback(newState)
+        } else {
+            DispatchQueue.main.async { callback(newState) }
+        }
+    }
+}

package/apps/mac/Sources/Core/Input/EventTapThread.swift

@@ -0,0 +1,54 @@
+import Foundation
+import CoreFoundation
+
+/// Hosts a long-lived thread + CFRunLoop dedicated to CGEventTap callbacks,
+/// so taps installed at `.headInsertEventTap` don't add main-thread latency
+/// to every keyboard/mouse event in the user's session.
+///
+/// Callbacks fire on this thread — callers must hop AppKit/UI work back to
+/// main themselves (DispatchQueue.main.async).
+final class EventTapThread {
+    static let shared = EventTapThread()
+
+    private let lock = NSLock()
+    private var runLoop: CFRunLoop?
+
+    private init() {
+        let ready = DispatchSemaphore(value: 0)
+        let thread = Thread { [unowned self] in
+            let loop = CFRunLoopGetCurrent()
+            // Keep the run loop alive across add/remove cycles by anchoring a
+            // no-op port; otherwise CFRunLoopRun() returns when the last
+            // source is removed.
+            let keepalive = NSMachPort()
+            RunLoop.current.add(keepalive, forMode: .common)
+            self.lock.lock()
+            self.runLoop = loop
+            self.lock.unlock()
+            ready.signal()
+            CFRunLoopRun()
+        }
+        thread.qualityOfService = .userInteractive
+        thread.name = "com.arach.lattices.EventTapThread"
+        thread.start()
+        ready.wait()
+    }
+
+    func add(source: CFRunLoopSource) {
+        lock.lock()
+        let loop = runLoop
+        lock.unlock()
+        guard let loop else { return }
+        CFRunLoopAddSource(loop, source, .commonModes)
+        CFRunLoopWakeUp(loop)
+    }
+
+    func remove(source: CFRunLoopSource) {
+        lock.lock()
+        let loop = runLoop
+        lock.unlock()
+        guard let loop else { return }
+        CFRunLoopRemoveSource(loop, source, .commonModes)
+        CFRunLoopWakeUp(loop)
+    }
+}

package/apps/mac/Sources/Core/Input/InputCaptureResetCenter.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+enum InputCaptureResetCenter {
+    static func reset(reason: String) {
+        if Thread.isMainThread {
+            performReset(reason: reason)
+        } else {
+            DispatchQueue.main.async {
+                performReset(reason: reason)
+            }
+        }
+    }
+
+    private static func performReset(reason: String) {
+        DiagnosticLog.shared.warn("InputCapture: reset for \(reason)")
+        ScreenOverlayCanvasController.shared.resetInputCapture(reason: reason)
+        MouseGestureController.shared.resetForSystemInputBoundary(reason: reason)
+        KeyboardRemapController.shared.resetForSystemInputBoundary(reason: reason)
+    }
+}