@lattices/cli 0.4.10 → 0.4.12

package/{app → apps/mac}/Sources/AppShell/SettingsWindow.swift

@@ -12,12 +12,22 @@ final class SettingsWindowController {
 
     func show() {
         ScreenMapWindowController.shared.showPage(.settings)
+        DispatchQueue.main.async {
+            NotificationCenter.default.post(name: .latticesShowGeneralSettings, object: nil)
+        }
     }
 
     func showCompanion() {
         ScreenMapWindowController.shared.showPage(.companionSettings)
     }
 
+    func showAssistant() {
+        ScreenMapWindowController.shared.showPage(.settings)
+        DispatchQueue.main.async {
+            NotificationCenter.default.post(name: .latticesShowAssistantSettings, object: nil)
+        }
+    }
+
     func close() {
         ScreenMapWindowController.shared.close()
     }

package/apps/mac/Sources/AppShell/WorkspaceInspectorPresenter.swift

@@ -0,0 +1,13 @@
+import AppKit
+
+enum WorkspaceInspectorPresenter {
+    static func show() {
+        guard let entry = DesktopModel.shared.frontmostWindow(),
+              entry.app != "Lattices" else {
+            ScreenMapWindowController.shared.showPage(.screenMap)
+            return
+        }
+
+        ScreenMapWindowController.shared.showWindow(wid: entry.wid)
+    }
+}

package/{app → apps/mac}/Sources/Core/Actions/HotkeyStore.swift

@@ -25,6 +25,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
     case unifiedWindow
     case hud
     case mouseFinder
+    case overlayActors
     // Layers
     case layer1, layer2, layer3, layer4, layer5, layer6, layer7, layer8, layer9
     case layerNext, layerPrev, layerTag
@@ -47,6 +48,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .unifiedWindow:   return "Workspace Home"
         case .hud:             return "HUD"
         case .mouseFinder:     return "Find Mouse"
+        case .overlayActors:   return "Toggle Overlay Actors"
         case .layer1:          return "Layer 1"
         case .layer2:          return "Layer 2"
         case .layer3:          return "Layer 3"
@@ -80,7 +82,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
 
     var group: HotkeyGroup {
         switch self {
-        case .palette, .screenMap, .bezel, .cheatSheet, .desktopInventory, .omniSearch, .voiceCommand, .handsOff, .unifiedWindow, .hud, .mouseFinder: return .app
+        case .palette, .screenMap, .bezel, .cheatSheet, .desktopInventory, .omniSearch, .voiceCommand, .handsOff, .unifiedWindow, .hud, .mouseFinder, .overlayActors: return .app
         case .layer1, .layer2, .layer3, .layer4, .layer5,
              .layer6, .layer7, .layer8, .layer9,
              .layerNext, .layerPrev, .layerTag: return .layers
@@ -101,6 +103,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .unifiedWindow:   return 207
         case .hud:             return 208
         case .mouseFinder:     return 209
+        case .overlayActors:   return 210
         case .layer1:          return 101
         case .layer2:          return 102
         case .layer3:          return 103
@@ -240,6 +243,7 @@ class HotkeyStore: ObservableObject {
         // App
         bind(.palette,   46, cmdShift)   // Cmd+Shift+M
         bind(.unifiedWindow, 18, hyper)  // Hyper+1 (Workspace Home)
+        bind(.screenMap, 37, hyper)      // Hyper+L (Layout)
         bind(.bezel,     19, hyper)      // Hyper+2
         bind(.hud,       20, hyper)      // Hyper+3 (HUD overlay)
         bind(.desktopInventory, 5, hyper) // Hyper+G
@@ -249,6 +253,7 @@ class HotkeyStore: ObservableObject {
         bind(.omniSearch, 23, hyper)       // Hyper+5
         bind(.cheatSheet, 22, hyper)       // Hyper+6
         bind(.mouseFinder, 26, hyper)      // Hyper+7
+        bind(.overlayActors, 28, hyper)    // Hyper+8
 
         // Layers: Cmd+Option+1-9
         let layerKeyCodes: [UInt32] = [18, 19, 20, 21, 23, 22, 26, 28, 25]

package/{app → apps/mac}/Sources/Core/Actions/IntentEngine.swift

@@ -845,6 +845,8 @@ struct ClaudeResolvedIntent {
     let slots: [String: JSON]
 }
 
+typealias ResolvedIntent = ClaudeResolvedIntent
+
 struct ClaudeAgentPlan {
     let steps: [ClaudeResolvedIntent]
     let reasoning: String

package/{app → apps/mac}/Sources/Core/Daemon/DaemonServer.swift

@@ -121,6 +121,11 @@ final class DaemonServer: ObservableObject {
         }
         guard clientFd >= 0 else { return }
 
+        // A client can disconnect immediately after a large response. On Darwin,
+        // writing to that socket can otherwise raise SIGPIPE and terminate the app.
+        var noSigPipe: Int32 = 1
+        setsockopt(clientFd, SOL_SOCKET, SO_NOSIGPIPE, &noSigPipe, socklen_t(MemoryLayout<Int32>.size))
+
         let id = UUID()
         let client = WebSocketClient(id: id, fd: clientFd)
 

package/{app → apps/mac}/Sources/Core/Daemon/LatticesApi.swift

@@ -287,6 +287,13 @@ final class LatticesApi {
             Field(name: "tmuxSessionCount", type: "int", required: true, description: "Active tmux session count"),
         ]))
 
+        api.model(ApiModel(name: "OverlayLayer", fields: [
+            Field(name: "id", type: "string", required: true, description: "Overlay layer identifier"),
+            Field(name: "kind", type: "string", required: true, description: "Overlay kind: toast, label, highlight, pet"),
+            Field(name: "owner", type: "string", required: true, description: "Layer owner namespace"),
+            Field(name: "expiresAt", type: "double", required: false, description: "Expiration timestamp (Unix seconds)"),
+        ]))
+
         // ── Endpoints: Read ─────────────────────────────────────
 
         api.register(Endpoint(
@@ -815,6 +822,96 @@ final class LatticesApi {
             }
         ))
 
+        api.register(Endpoint(
+            method: "overlay.publish",
+            description: "Publish a transient visual layer on the invisible screen overlay canvas",
+            access: .mutate,
+            params: [
+                Param(name: "kind", type: "string", required: true, description: "toast, label, highlight, or pet"),
+                Param(name: "id", type: "string", required: false, description: "Stable layer id; generated if omitted"),
+                Param(name: "text", type: "string", required: false, description: "Toast/label text"),
+                Param(name: "detail", type: "string", required: false, description: "Secondary toast/label text"),
+                Param(name: "message", type: "string", required: false, description: "Pet speech/message"),
+                Param(name: "glyph", type: "string", required: false, description: "Pet glyph, emoji, or short symbol"),
+                Param(name: "petId", type: "string", required: false, description: "Bundled pet id from Resources/Pets"),
+                Param(name: "state", type: "string", required: false, description: "Pet animation state"),
+                Param(name: "name", type: "string", required: false, description: "Pet name"),
+                Param(name: "x", type: "double", required: false, description: "Screen-local x coordinate"),
+                Param(name: "y", type: "double", required: false, description: "Screen-local y coordinate"),
+                Param(name: "w", type: "double", required: false, description: "Highlight width"),
+                Param(name: "h", type: "double", required: false, description: "Highlight height"),
+                Param(name: "placement", type: "string", required: false, description: "top, bottom, center, cursor, or point"),
+                Param(name: "style", type: "string", required: false, description: "info, success, warning, danger, or playful"),
+                Param(name: "display", type: "int", required: false, description: "Display index; omit for all displays"),
+                Param(name: "ttlMs", type: "int", required: false, description: "Time to live in milliseconds"),
+                Param(name: "opacity", type: "double", required: false, description: "Opacity 0-1"),
+                Param(name: "zIndex", type: "int", required: false, description: "Layer ordering"),
+                Param(name: "dismissible", type: "bool", required: false, description: "Whether click-away dismissal removes the layer"),
+            ],
+            returns: .object(model: "OverlayLayer"),
+            handler: { params in
+                try Self.publishOverlay(params)
+            }
+        ))
+
+        api.register(Endpoint(
+            method: "overlay.clear",
+            description: "Clear overlay layers published through the daemon API",
+            access: .mutate,
+            params: [
+                Param(name: "id", type: "string", required: false, description: "Specific layer id to clear"),
+                Param(name: "owner", type: "string", required: false, description: "Owner namespace to clear; defaults to agentApi"),
+            ],
+            returns: .ok,
+            handler: { params in
+                try Self.clearOverlay(params)
+            }
+        ))
+
+        api.register(Endpoint(
+            method: "overlay.actor.publish",
+            description: "Create or update a small generative overlay actor",
+            access: .mutate,
+            params: [
+                Param(name: "id", type: "string", required: false, description: "Stable actor id; generated if omitted"),
+                Param(name: "renderer", type: "string", required: false, description: "Renderer type; sprite is currently supported"),
+                Param(name: "asset", type: "string", required: false, description: "Bundled sprite asset id"),
+                Param(name: "state", type: "string", required: false, description: "Actor state or animation name"),
+                Param(name: "name", type: "string", required: false, description: "Actor display name"),
+                Param(name: "message", type: "string", required: false, description: "Attached message text"),
+                Param(name: "x", type: "double", required: false, description: "Screen-local x coordinate"),
+                Param(name: "y", type: "double", required: false, description: "Screen-local y coordinate"),
+                Param(name: "placement", type: "string", required: false, description: "top, bottom, center, cursor, or point"),
+                Param(name: "style", type: "string", required: false, description: "info, success, warning, danger, or playful"),
+                Param(name: "display", type: "int", required: false, description: "Display index; omit for all displays"),
+                Param(name: "ttlMs", type: "int", required: false, description: "Time to live in milliseconds; omit or pass 0 for persistent"),
+                Param(name: "opacity", type: "double", required: false, description: "Opacity 0-1"),
+                Param(name: "zIndex", type: "int", required: false, description: "Layer ordering"),
+                Param(name: "dismissible", type: "bool", required: false, description: "Whether click-away dismissal removes the actor; defaults false"),
+            ],
+            returns: .object(model: "OverlayLayer"),
+            handler: { params in
+                try Self.publishOverlayActor(params)
+            }
+        ))
+
+        api.register(Endpoint(
+            method: "overlay.actor.moveTo",
+            description: "Move an overlay actor with app-owned easing",
+            access: .mutate,
+            params: [
+                Param(name: "id", type: "string", required: true, description: "Actor id"),
+                Param(name: "x", type: "double", required: true, description: "Target screen-local x coordinate"),
+                Param(name: "y", type: "double", required: true, description: "Target screen-local y coordinate"),
+                Param(name: "durationMs", type: "int", required: false, description: "Animation duration in milliseconds"),
+                Param(name: "easing", type: "string", required: false, description: "linear, easeInOut, or spring"),
+            ],
+            returns: .ok,
+            handler: { params in
+                try Self.moveOverlayActor(params)
+            }
+        ))
+
         api.register(Endpoint(
             method: "daemon.status",
             description: "Get daemon status including uptime and counts",
@@ -1918,6 +2015,274 @@ final class LatticesApi {
 }
 
 private extension LatticesApi {
+    static func publishOverlay(_ params: JSON?) throws -> JSON {
+        guard let params else {
+            throw RouterError.missingParam("kind")
+        }
+        guard let kind = params["kind"]?.stringValue?.lowercased(), !kind.isEmpty else {
+            throw RouterError.missingParam("kind")
+        }
+
+        let id = params["id"]?.stringValue ?? "agent-\(UUID().uuidString)"
+        let style = try parseOverlayStyle(params["style"]?.stringValue)
+        let placement = try parseOverlayPlacement(params["placement"]?.stringValue)
+        let screen = try parseOverlayScreen(params["display"]?.intValue)
+        let point = parseOverlayPoint(params)
+        let opacity = CGFloat(max(0.05, min(params["opacity"]?.numericDouble ?? 1.0, 1.0)))
+        let zIndex = params["zIndex"]?.intValue ?? 500
+        let ttlMs = params["ttlMs"]?.intValue ?? defaultOverlayTTL(for: kind)
+        let expiresAt = ttlMs > 0 ? Date().addingTimeInterval(Double(ttlMs) / 1000.0) : nil
+        let payload: ScreenOverlayPayload
+
+        switch kind {
+        case "toast":
+            let text = try requiredString(params, "text")
+            payload = .toast(ScreenOverlayTextPayload(
+                text: text,
+                detail: params["detail"]?.stringValue,
+                point: point,
+                placement: placement,
+                style: style
+            ))
+        case "label":
+            let text = try requiredString(params, "text")
+            payload = .label(ScreenOverlayTextPayload(
+                text: text,
+                detail: params["detail"]?.stringValue,
+                point: point,
+                placement: placement == .top ? .point : placement,
+                style: style
+            ))
+        case "highlight":
+            guard let rect = parseOverlayRect(params) else {
+                throw RouterError.custom("highlight requires x, y, w, and h")
+            }
+            payload = .highlight(ScreenOverlayHighlightPayload(
+                rect: rect,
+                label: params["text"]?.stringValue ?? params["label"]?.stringValue,
+                style: style,
+                cornerRadius: CGFloat(params["cornerRadius"]?.numericDouble ?? 10)
+            ))
+        case "pet":
+            let glyph = params["glyph"]?.stringValue ?? "✦"
+            payload = .pet(ScreenOverlayPetPayload(
+                glyph: String(glyph.prefix(4)),
+                petID: params["petId"]?.stringValue,
+                state: params["state"]?.stringValue,
+                name: params["name"]?.stringValue,
+                message: params["message"]?.stringValue ?? params["text"]?.stringValue,
+                point: point,
+                placement: placement,
+                style: style,
+                isDragging: false,
+                dismissible: params["dismissible"]?.boolValue ?? true
+            ))
+        default:
+            throw RouterError.custom("Unsupported overlay kind: \(kind)")
+        }
+
+        let layer = ScreenOverlayLayerSnapshot(
+            id: ScreenOverlayLayerID(id),
+            owner: .agentApi,
+            screen: screen,
+            zIndex: zIndex,
+            opacity: opacity,
+            payload: payload,
+            expiresAt: expiresAt
+        )
+
+        runOnMain {
+            ScreenOverlayCanvasController.shared.publishLayer(layer)
+        }
+
+        var result: [String: JSON] = [
+            "id": .string(id),
+            "kind": .string(kind),
+            "owner": .string(ScreenOverlayOwner.agentApi.rawValue),
+        ]
+        if let expiresAt {
+            result["expiresAt"] = .double(expiresAt.timeIntervalSince1970)
+        }
+        return .object(result)
+    }
+
+    static func clearOverlay(_ params: JSON?) throws -> JSON {
+        let owner = try parseOverlayOwner(params?["owner"]?.stringValue)
+        if let id = params?["id"]?.stringValue, !id.isEmpty {
+            runOnMain {
+                ScreenOverlayCanvasController.shared.removeLayer(id: ScreenOverlayLayerID(id))
+            }
+        } else {
+            runOnMain {
+                ScreenOverlayCanvasController.shared.removeLayers(owner: owner)
+            }
+        }
+        return .object(["ok": .bool(true)])
+    }
+
+    static func publishOverlayActor(_ params: JSON?) throws -> JSON {
+        guard let params else {
+            throw RouterError.missingParam("id")
+        }
+        let id = params["id"]?.stringValue ?? "actor-\(UUID().uuidString)"
+        let renderer = params["renderer"]?.stringValue?.lowercased() ?? "sprite"
+        guard renderer == "sprite" || renderer == "pet" else {
+            throw RouterError.custom("Unsupported overlay actor renderer: \(renderer)")
+        }
+
+        let style = try parseOverlayStyle(params["style"]?.stringValue)
+        let point = parseOverlayPoint(params)
+        let placement = try parseOverlayPlacement(params["placement"]?.stringValue ?? (point == nil ? "bottom" : "point"))
+        let screen = try parseOverlayScreen(params["display"]?.intValue)
+        let opacity = CGFloat(max(0.05, min(params["opacity"]?.numericDouble ?? 1.0, 1.0)))
+        let zIndex = params["zIndex"]?.intValue ?? 520
+        let ttlMs = params["ttlMs"]?.intValue ?? 0
+        let expiresAt = ttlMs > 0 ? Date().addingTimeInterval(Double(ttlMs) / 1000.0) : nil
+        let asset = params["asset"]?.stringValue ?? params["petId"]?.stringValue
+        let message = params["message"]?.stringValue ?? params["text"]?.stringValue
+
+        let layer = ScreenOverlayLayerSnapshot(
+            id: ScreenOverlayLayerID(id),
+            owner: .agentApi,
+            screen: screen,
+            zIndex: zIndex,
+            opacity: opacity,
+            payload: .pet(ScreenOverlayPetPayload(
+                glyph: String((params["glyph"]?.stringValue ?? "✦").prefix(4)),
+                petID: asset,
+                state: params["state"]?.stringValue ?? "idle",
+                name: params["name"]?.stringValue,
+                message: message,
+                point: point,
+                placement: placement,
+                style: style,
+                isDragging: false,
+                dismissible: params["dismissible"]?.boolValue ?? false
+            )),
+            expiresAt: expiresAt
+        )
+
+        runOnMain {
+            ScreenOverlayCanvasController.shared.publishLayer(layer)
+        }
+
+        var result: [String: JSON] = [
+            "id": .string(id),
+            "kind": .string("actor"),
+            "owner": .string(ScreenOverlayOwner.agentApi.rawValue),
+            "renderer": .string(renderer),
+        ]
+        if let expiresAt {
+            result["expiresAt"] = .double(expiresAt.timeIntervalSince1970)
+        }
+        return .object(result)
+    }
+
+    static func moveOverlayActor(_ params: JSON?) throws -> JSON {
+        guard let params else {
+            throw RouterError.missingParam("id")
+        }
+        let id = try requiredString(params, "id")
+        guard let x = params["x"]?.numericDouble else {
+            throw RouterError.missingParam("x")
+        }
+        guard let y = params["y"]?.numericDouble else {
+            throw RouterError.missingParam("y")
+        }
+        let durationMs = params["durationMs"]?.intValue ?? 700
+        let easing = params["easing"]?.stringValue
+        var moved = false
+        runOnMain {
+            moved = ScreenOverlayCanvasController.shared.moveLayer(
+                id: ScreenOverlayLayerID(id),
+                to: CGPoint(x: x, y: y),
+                durationMs: durationMs,
+                easing: easing
+            )
+        }
+        guard moved else {
+            throw RouterError.custom("Overlay actor not found or not movable: \(id)")
+        }
+        return .object([
+            "ok": .bool(true),
+            "id": .string(id),
+            "x": .double(x),
+            "y": .double(y),
+        ])
+    }
+
+    static func runOnMain(_ work: @escaping () -> Void) {
+        if Thread.isMainThread {
+            work()
+        } else {
+            DispatchQueue.main.sync(execute: work)
+        }
+    }
+
+    static func parseOverlayScreen(_ displayIndex: Int?) throws -> ScreenOverlayScreenTarget {
+        guard let displayIndex else { return .all }
+        guard displayIndex >= 0, displayIndex < NSScreen.screens.count else {
+            throw RouterError.custom("Invalid display index: \(displayIndex)")
+        }
+        return .screen(id: ScreenOverlayCanvasController.screenID(for: NSScreen.screens[displayIndex]))
+    }
+
+    static func parseOverlayPoint(_ params: JSON) -> CGPoint? {
+        guard let x = params["x"]?.numericDouble,
+              let y = params["y"]?.numericDouble else { return nil }
+        return CGPoint(x: x, y: y)
+    }
+
+    static func parseOverlayRect(_ params: JSON) -> CGRect? {
+        guard let x = params["x"]?.numericDouble,
+              let y = params["y"]?.numericDouble,
+              let w = params["w"]?.numericDouble,
+              let h = params["h"]?.numericDouble else { return nil }
+        return CGRect(x: x, y: y, width: w, height: h)
+    }
+
+    static func parseOverlayPlacement(_ value: String?) throws -> ScreenOverlayPlacement {
+        let raw = value?.lowercased() ?? ScreenOverlayPlacement.top.rawValue
+        guard let placement = ScreenOverlayPlacement(rawValue: raw) else {
+            throw RouterError.custom("Unsupported overlay placement: \(raw)")
+        }
+        return placement
+    }
+
+    static func parseOverlayStyle(_ value: String?) throws -> ScreenOverlayStyle {
+        let raw = value?.lowercased() ?? ScreenOverlayStyle.info.rawValue
+        guard let style = ScreenOverlayStyle(rawValue: raw) else {
+            throw RouterError.custom("Unsupported overlay style: \(raw)")
+        }
+        return style
+    }
+
+    static func parseOverlayOwner(_ value: String?) throws -> ScreenOverlayOwner {
+        let raw = value ?? ScreenOverlayOwner.agentApi.rawValue
+        guard let owner = ScreenOverlayOwner(rawValue: raw) else {
+            throw RouterError.custom("Unsupported overlay owner: \(raw)")
+        }
+        return owner
+    }
+
+    static func defaultOverlayTTL(for kind: String) -> Int {
+        switch kind {
+        case "highlight":
+            return 2500
+        case "pet":
+            return 4200
+        default:
+            return 2800
+        }
+    }
+
+    static func requiredString(_ params: JSON, _ key: String) throws -> String {
+        guard let value = params[key]?.stringValue, !value.isEmpty else {
+            throw RouterError.missingParam(key)
+        }
+        return value
+    }
+
     static func decodeDeckActionRequest(from json: JSON?) throws -> DeckActionRequest {
         guard let json else {
             throw RouterError.missingParam("actionID")

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

@@ -86,9 +86,15 @@ final class OcrModel: ObservableObject {
     func setEnabled(_ on: Bool) {
         enabled = on
         prefs.ocrEnabled = on
-        if on && timer == nil {
-            start()
-        } else if !on {
+        if on {
+            // User intentionally turning on OCR clears any prior snooze and is
+            // the moment we ask macOS for Screen Recording.
+            prefs.clearDismissal(Capability.screenSearch.rawValue)
+            if timer == nil {
+                PermissionChecker.shared.requestScreenRecording()
+                start()
+            }
+        } else {
             stop()
         }
     }
@@ -207,11 +213,10 @@ final class OcrModel: ObservableObject {
 
             // Phase 1: capture + hash all windows (cheap)
             for win in windows {
-                if let cgImage = CGWindowListCreateImage(
-                    .null,
-                    .optionIncludingWindow,
-                    CGWindowID(win.wid),
-                    [.boundsIgnoreFraming, .bestResolution]
+                if let cgImage = WindowCapture.image(
+                    listOption: .optionIncludingWindow,
+                    windowID: CGWindowID(win.wid),
+                    imageOption: [.boundsIgnoreFraming, .bestResolution]
                 ) {
                     let hash = self.imageHash(cgImage)
                     newHashes[win.wid] = hash
@@ -314,11 +319,10 @@ final class OcrModel: ObservableObject {
 
         let win = windows[index]
 
-        if let cgImage = CGWindowListCreateImage(
-            .null,
-            .optionIncludingWindow,
-            CGWindowID(win.wid),
-            [.boundsIgnoreFraming, .bestResolution]
+        if let cgImage = WindowCapture.image(
+            listOption: .optionIncludingWindow,
+            windowID: CGWindowID(win.wid),
+            imageOption: [.boundsIgnoreFraming, .bestResolution]
         ) {
             let hash = imageHash(cgImage)
             newHashes[win.wid] = hash

package/apps/mac/Sources/Core/Desktop/WindowCapture.swift

@@ -0,0 +1,33 @@
+import CoreGraphics
+import Darwin
+
+enum WindowCapture {
+    // Transitional wrapper for the old CoreGraphics window snapshot API.
+    // macOS 26 rejects direct references because ScreenCaptureKit is the supported path;
+    // this can return nil if Apple removes the symbol, so preview/OCR callers must degrade.
+    private typealias CGWindowListCreateImageFn = @convention(c) (
+        CGRect,
+        CGWindowListOption,
+        CGWindowID,
+        CGWindowImageOption
+    ) -> Unmanaged<CGImage>?
+
+    private static let createImage: CGWindowListCreateImageFn? = {
+        guard let handle = dlopen("/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics", RTLD_LAZY) else {
+            return nil
+        }
+        guard let symbol = dlsym(handle, "CGWindowListCreateImage") else {
+            return nil
+        }
+        return unsafeBitCast(symbol, to: CGWindowListCreateImageFn.self)
+    }()
+
+    static func image(
+        bounds: CGRect = .null,
+        listOption: CGWindowListOption,
+        windowID: CGWindowID,
+        imageOption: CGWindowImageOption
+    ) -> CGImage? {
+        createImage?(bounds, listOption, windowID, imageOption)?.takeRetainedValue()
+    }
+}