@lattices/cli 0.4.2 → 0.4.6

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

@@ -31,7 +31,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
     // Tiling
     case tileLeft, tileRight, tileMaximize, tileCenter
     case tileTopLeft, tileTopRight, tileBottomLeft, tileBottomRight
-    case tileTop, tileBottom, tileDistribute
+    case tileTop, tileBottom, tileDistribute, tileTypeGrid
     case tileLeftThird, tileCenterThird, tileRightThird
 
     var label: String {
@@ -40,11 +40,11 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .screenMap:       return "Screen Map"
         case .bezel:           return "Window Bezel"
         case .cheatSheet:      return "Cheat Sheet"
-        case .desktopInventory: return "Desktop Inventory"
-        case .omniSearch:      return "Omni Search"
+        case .desktopInventory: return "Window Selector"
+        case .omniSearch:      return "Search"
         case .voiceCommand:    return "Voice Command"
         case .handsOff:        return "Hands-Off Mode"
-        case .unifiedWindow:   return "Unified Window"
+        case .unifiedWindow:   return "Workspace Home"
         case .hud:             return "HUD"
         case .mouseFinder:     return "Find Mouse"
         case .layer1:          return "Layer 1"
@@ -70,6 +70,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .tileTop:         return "Top Half"
         case .tileBottom:      return "Bottom Half"
         case .tileDistribute:  return "Distribute"
+        case .tileTypeGrid:    return "Grid Type"
         case .tileLeftThird:   return "Left Third"
         case .tileCenterThird: return "Center Third"
         case .tileRightThird:  return "Right Third"
@@ -122,6 +123,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .tileTop:         return 308
         case .tileBottom:      return 309
         case .tileDistribute:  return 310
+        case .tileTypeGrid:    return 314
         case .tileLeftThird:   return 311
         case .tileCenterThird: return 312
         case .tileRightThird:  return 313
@@ -226,9 +228,10 @@ class HotkeyStore: ObservableObject {
 
         // App
         bind(.palette,   46, cmdShift)   // Cmd+Shift+M
-        bind(.unifiedWindow, 18, hyper)  // Hyper+1 (Screen Map + Desktop Inventory)
+        bind(.unifiedWindow, 18, hyper)  // Hyper+1 (Workspace Home)
         bind(.bezel,     19, hyper)      // Hyper+2
         bind(.hud,       20, hyper)      // Hyper+3 (HUD overlay)
+        bind(.desktopInventory, 5, hyper) // Hyper+G
         bind(.voiceCommand, 21, hyper)   // Hyper+4 (moved from Hyper+3)
         let cmdCtrl = UInt32(cmdKey | controlKey)
         bind(.handsOff, 46, cmdCtrl)          // Ctrl+Cmd+M
@@ -259,6 +262,7 @@ class HotkeyStore: ObservableObject {
         bind(.tileBottomLeft,   38, ctrlOpt)  // Ctrl+Opt+J
         bind(.tileBottomRight,  40, ctrlOpt)  // Ctrl+Opt+K
         bind(.tileDistribute,    2, ctrlOpt)  // Ctrl+Opt+D
+        bind(.tileTypeGrid,      5, hyper)    // Hyper+G
         bind(.tileLeftThird,    18, ctrlOpt)  // Ctrl+Opt+1
         bind(.tileCenterThird,  19, ctrlOpt)  // Ctrl+Opt+2
         bind(.tileRightThird,   20, ctrlOpt)  // Ctrl+Opt+3

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

@@ -1,31 +1,5 @@
 import AppKit
 
-// MARK: - Intent Definition
-
-struct IntentDef {
-    let name: String
-    let description: String
-    let examples: [String]           // Example phrases that map to this intent
-    let slots: [IntentSlot]          // Named parameters extracted from the utterance
-    let handler: (IntentRequest) throws -> JSON
-}
-
-struct IntentSlot {
-    let name: String
-    let type: String                 // "string", "int", "position", "query"
-    let required: Bool
-    let description: String
-    let enumValues: [String]?        // For constrained slots like tile positions
-}
-
-struct IntentRequest {
-    let intent: String
-    let slots: [String: JSON]
-    let rawText: String?             // Original transcription, for fallback matching
-    let confidence: Double?          // Transcription confidence from voice service
-    let source: String?              // "vox", "siri", "cli", etc.
-}
-
 // MARK: - Intent Engine
 
 final class IntentEngine {
@@ -133,6 +107,8 @@ final class IntentEngine {
                            description: "Target window ID", enumValues: nil),
                 IntentSlot(name: "session", type: "string", required: false,
                            description: "Target session name", enumValues: nil),
+                IntentSlot(name: "selection", type: "bool", required: false,
+                           description: "Apply to the active multi-window selection instead of a single window", enumValues: nil),
             ],
             handler: { req in
                 guard let posStr = req.slots["position"]?.stringValue else {
@@ -176,6 +152,34 @@ final class IntentEngine {
                     throw IntentError.targetNotFound("No window found for app '\(app)'")
                 }
 
+                if req.slots["selection"]?.boolValue == true {
+                    let selectionIds = WindowSelectionStore.shared.windowIds
+                    guard !selectionIds.isEmpty else {
+                        throw IntentError.targetNotFound("No active window selection")
+                    }
+
+                    if selectionIds.count == 1,
+                       let wid = selectionIds.first,
+                       let entry = DesktopModel.shared.windows[wid] {
+                        tileEntry(entry)
+                        return .object([
+                            "ok": .bool(true),
+                            "target": .string("selection"),
+                            "wid": .int(Int(wid)),
+                            "position": .string(posStr)
+                        ])
+                    }
+
+                    return try LatticesApi.shared.dispatch(
+                        method: "space.optimize",
+                        params: .object([
+                            "scope": .string("selection"),
+                            "windowIds": .array(selectionIds.map { .int(Int($0)) }),
+                            "region": .string(posStr)
+                        ])
+                    )
+                }
+
                 // Default: tile frontmost window
                 DispatchQueue.main.async {
                     WindowTiler.tileFrontmostViaAX(to: placement)
@@ -381,7 +385,7 @@ final class IntentEngine {
 
         register(IntentDef(
             name: "distribute",
-            description: "Distribute windows evenly in a grid, optionally filtered by app and constrained to a screen region",
+            description: "Distribute windows evenly in a grid, optionally filtered by app or window type and constrained to a screen region",
             examples: [
                 "spread out the windows",
                 "distribute everything",
@@ -394,19 +398,39 @@ final class IntentEngine {
             slots: [
                 IntentSlot(name: "app", type: "string", required: false,
                            description: "Filter to windows of this app (e.g. 'iTerm2', 'Google Chrome')", enumValues: nil),
+                IntentSlot(name: "type", type: "string", required: false,
+                           description: "Filter to a window type (e.g. 'terminal', 'browser', 'editor')",
+                           enumValues: AppType.allCases.map(\.rawValue)),
                 IntentSlot(name: "region", type: "position", required: false,
                            description: "Constrain the grid to a screen region. Uses tile position names.",
                            enumValues: ["left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right",
                                         "left-third", "center-third", "right-third"]),
+                IntentSlot(name: "selection", type: "bool", required: false,
+                           description: "Use the active selected windows instead of all visible windows", enumValues: nil),
             ],
             handler: { req in
                 var params: [String: JSON] = [:]
                 if let app = req.slots["app"]?.stringValue {
                     params["app"] = .string(app)
                 }
+                if let type = req.slots["type"]?.stringValue {
+                    params["type"] = .string(type)
+                }
                 if let region = req.slots["region"]?.stringValue {
                     params["region"] = .string(region)
                 }
+                if req.slots["selection"]?.boolValue == true {
+                    let selectionIds = WindowSelectionStore.shared.windowIds
+                    guard !selectionIds.isEmpty else {
+                        throw IntentError.targetNotFound("No active window selection")
+                    }
+                    params["scope"] = .string("selection")
+                    params["windowIds"] = .array(selectionIds.map { .int(Int($0)) })
+                    return try LatticesApi.shared.dispatch(
+                        method: "space.optimize",
+                        params: .object(params)
+                    )
+                }
                 return try LatticesApi.shared.dispatch(
                     method: "layout.distribute",
                     params: params.isEmpty ? nil : .object(params)

package/app/Sources/Core/Actions/IntentSchema.swift

@@ -0,0 +1,94 @@
+import Foundation
+
+struct IntentDef {
+    let name: String
+    let description: String
+    let examples: [String]
+    let slots: [IntentSlot]
+    let handler: (IntentRequest) throws -> JSON
+}
+
+struct IntentSlot {
+    let name: String
+    let type: String
+    let required: Bool
+    let description: String
+    let enumValues: [String]?
+    let defaultValue: JSON?
+
+    init(
+        name: String,
+        type: String,
+        required: Bool,
+        description: String,
+        enumValues: [String]? = nil,
+        defaultValue: JSON? = nil
+    ) {
+        self.name = name
+        self.type = type
+        self.required = required
+        self.description = description
+        self.enumValues = enumValues
+        self.defaultValue = defaultValue
+    }
+}
+
+struct IntentRequest {
+    let intent: String
+    let slots: [String: JSON]
+    let rawText: String?
+    let confidence: Double?
+    let source: String?
+}
+
+enum SlotType {
+    case string
+    case int
+    case bool
+    case position
+    case query
+    case app
+    case session
+    case layer
+    case enumerated([String])
+
+    var typeLabel: String {
+        switch self {
+        case .string: return "string"
+        case .int: return "int"
+        case .bool: return "bool"
+        case .position: return "position"
+        case .query: return "query"
+        case .app: return "app"
+        case .session: return "session"
+        case .layer: return "layer"
+        case .enumerated: return "string"
+        }
+    }
+
+    var enumValues: [String]? {
+        guard case .enumerated(let values) = self else { return nil }
+        return values
+    }
+}
+
+typealias SlotDef = IntentSlot
+
+extension IntentSlot {
+    init(
+        name: String,
+        type: SlotType,
+        required: Bool = true,
+        description: String = "",
+        defaultValue: JSON? = nil
+    ) {
+        self.init(
+            name: name,
+            type: type.typeLabel,
+            required: required,
+            description: description,
+            enumValues: type.enumValues,
+            defaultValue: defaultValue
+        )
+    }
+}

package/app/Sources/{Intents → Core/Actions/Intents}/LatticeIntent.swift

@@ -12,31 +12,6 @@ protocol LatticeIntent {
     func perform(slots: [String: JSON]) throws -> JSON
 }
 
-// MARK: - Slot Definition
-
-enum SlotType {
-    case string                           // Free-form text
-    case position                         // Tile position (left, right, maximize, etc.)
-    case app                              // Running app name
-    case session                          // Active tmux session
-    case layer                            // Layer name
-    case enumerated([String])             // Fixed set of values
-}
-
-struct SlotDef {
-    let name: String
-    let type: SlotType
-    let required: Bool
-    let defaultValue: JSON?
-
-    init(name: String, type: SlotType, required: Bool = true, defaultValue: JSON? = nil) {
-        self.name = name
-        self.type = type
-        self.required = required
-        self.defaultValue = defaultValue
-    }
-}
-
 // MARK: - Compiled Phrase Template
 
 struct CompiledPhrase {

package/app/Sources/{PaletteCommand.swift → Core/Actions/PaletteCommand.swift}

@@ -364,24 +364,44 @@ enum CommandBuilder {
             }
         ))
 
+        commands.append(PaletteCommand(
+            id: "app-home",
+            title: "Home",
+            subtitle: "Open the workspace home view",
+            icon: "house",
+            category: .app,
+            badge: nil,
+            action: { ScreenMapWindowController.shared.showPage(.home) }
+        ))
+
         commands.append(PaletteCommand(
             id: "app-windows-list",
-            title: "Windows List",
-            subtitle: "Browse all windows across displays",
-            icon: "rectangle.split.2x1",
+            title: "Search",
+            subtitle: "Browse windows, displays, spaces, and screen text",
+            icon: "magnifyingglass",
             category: .app,
             badge: nil,
-            action: { CommandModeWindow.shared.show() }
+            action: { ScreenMapWindowController.shared.showPage(.desktopInventory) }
         ))
 
         commands.append(PaletteCommand(
             id: "app-screen-map",
-            title: "Window Map",
+            title: "Layout",
             subtitle: "Visual window editor",
             icon: "rectangle.3.group",
             category: .app,
             badge: nil,
-            action: { ScreenMapWindowController.shared.show() }
+            action: { ScreenMapWindowController.shared.showPage(.screenMap) }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "app-workspace-chat",
+            title: "Workspace Chat",
+            subtitle: "Open the longer-form assistant surface",
+            icon: "bubble.left.and.bubble.right",
+            category: .app,
+            badge: nil,
+            action: { ScreenMapWindowController.shared.showPage(.pi) }
         ))
 
         commands.append(PaletteCommand(

package/app/Sources/{VoiceIntentResolver.swift → Core/Actions/VoiceIntentResolver.swift}

@@ -141,10 +141,43 @@ final class VoiceIntentResolver {
     private func extractSlots(for intentName: String, input: String) -> ExtractedSlots {
         switch intentName {
         case "tile_window":
-            guard let position = resolvePosition(in: input) else {
+            var slots: [String: JSON] = [:]
+            var boost = 0.0
+
+            if let position = resolvePosition(in: input) {
+                slots["position"] = .string(position)
+                boost += 0.28
+            } else {
                 return ExtractedSlots(slots: [:], boost: 0)
             }
-            return ExtractedSlots(slots: ["position": .string(position)], boost: 0.28)
+
+            if refersToSelection(in: input) {
+                slots["selection"] = .bool(true)
+                boost += 0.08
+            }
+
+            return ExtractedSlots(slots: slots, boost: boost)
+
+        case "distribute":
+            var slots: [String: JSON] = [:]
+            var boost = 0.0
+
+            if let region = resolvePosition(in: input) {
+                slots["region"] = .string(region)
+                boost += 0.18
+            }
+
+            if let app = detectKnownApp(in: input) {
+                slots["app"] = .string(app)
+                boost += 0.14
+            }
+
+            if refersToSelection(in: input) {
+                slots["selection"] = .bool(true)
+                boost += 0.12
+            }
+
+            return ExtractedSlots(slots: slots, boost: boost)
 
         case "focus":
             if let app = detectKnownApp(in: input) ?? extractEntity(in: input, prefixes: focusPrefixes) {
@@ -426,6 +459,15 @@ final class VoiceIntentResolver {
         return nil
     }
 
+    private func refersToSelection(in input: String) -> Bool {
+        let markers = [
+            "grid that", "grid these", "grid those",
+            "tile that", "tile these", "tile those",
+            "selected windows", "selection", "selected", "these windows", "those windows", "them"
+        ]
+        return markers.contains(where: input.contains)
+    }
+
     private func detectKnownApp(in input: String) -> String? {
         for app in knownApps() {
             let lower = app.lowercased()
@@ -601,7 +643,7 @@ final class VoiceIntentResolver {
         "search": ["find", "search", "look for", "where is", "where d", "locate", "lost", "show me all", "windows"],
         "list_windows": ["what s open", "list windows", "which windows", "what do i have open"],
         "list_sessions": ["list sessions", "what s running", "which projects", "show my sessions"],
-        "distribute": ["distribute", "spread", "organize", "arrange", "tidy", "clean up", "grid"],
+        "distribute": ["distribute", "spread", "organize", "arrange", "tidy", "clean up", "grid", "selected", "selection"],
         "create_layer": ["create layer", "save layout", "snapshot", "remember this layout"],
         "kill": ["kill", "stop", "shut down", "close", "terminate", "end"],
         "scan": ["scan", "rescan", "ocr", "read the screen", "what s on my screen", "screen text"],
@@ -662,7 +704,7 @@ final class VoiceIntentResolver {
         "search": ["where d my slack go", "pull up everything with dewey in it", "show me all the chrome windows", "dewey"],
         "list_windows": ["what do i have open", "what windows do i have"],
         "list_sessions": ["show me my sessions", "which projects are active"],
-        "distribute": ["tidy up", "line everything up", "clean up the windows"],
+        "distribute": ["tidy up", "line everything up", "clean up the windows", "grid that in the bottom half", "arrange the selected windows"],
         "create_layer": ["snapshot this", "remember this layout"],
         "kill": ["close the dewey session", "stop my session"],
         "scan": ["what s on my screen", "read the screen", "give me a fresh scan"],

package/app/Sources/Core/Companion/CompanionActivityLog.swift

@@ -0,0 +1,70 @@
+import DeckKit
+import Foundation
+
+final class CompanionActivityLog {
+    static let shared = CompanionActivityLog()
+
+    private let lock = NSLock()
+    private var entries: [DeckActivityLogEntry] = []
+    private let maxEntries = 120
+
+    private init() {
+        EventBus.shared.subscribe { [weak self] event in
+            self?.record(event)
+        }
+    }
+
+    func record(tag: String, tint: String?, text: String) {
+        let entry = DeckActivityLogEntry(
+            id: UUID().uuidString,
+            createdAt: Date(),
+            tag: tag,
+            tint: tint,
+            text: text
+        )
+
+        lock.lock()
+        entries.append(entry)
+        if entries.count > maxEntries {
+            entries.removeFirst(entries.count - maxEntries)
+        }
+        lock.unlock()
+    }
+
+    func snapshot(limit: Int = 80) -> [DeckActivityLogEntry] {
+        lock.lock()
+        let copy = entries
+        lock.unlock()
+
+        return Array(copy.suffix(limit).reversed())
+    }
+}
+
+private extension CompanionActivityLog {
+    func record(_ event: ModelEvent) {
+        switch event {
+        case .windowsChanged(let windows, let added, let removed):
+            let delta = [added.isEmpty ? nil : "+\(added.count)", removed.isEmpty ? nil : "-\(removed.count)"]
+                .compactMap { $0 }
+                .joined(separator: " ")
+            let suffix = delta.isEmpty ? "" : " (\(delta))"
+            record(tag: "WIN", tint: "blue", text: "\(windows.count) desktop windows\(suffix)")
+
+        case .tmuxChanged(let sessions):
+            record(tag: "TMUX", tint: "green", text: "\(sessions.count) tmux sessions indexed")
+
+        case .layerSwitched(let index):
+            record(tag: "LAYER", tint: "violet", text: "Switched workspace layer \(index + 1)")
+
+        case .processesChanged(let interesting):
+            record(tag: "PROC", tint: "amber", text: "\(interesting.count) terminal processes changed")
+
+        case .ocrScanComplete(let windowCount, let totalBlocks):
+            record(tag: "OCR", tint: "teal", text: "Scanned \(totalBlocks) text blocks across \(windowCount) windows")
+
+        case .voiceCommand(let text, let confidence):
+            let pct = Int((confidence * 100).rounded())
+            record(tag: "VOICE", tint: "red", text: "\"\(text)\" · \(pct)%")
+        }
+    }
+}

package/app/Sources/Core/Companion/CompanionKeyboardController.swift

@@ -0,0 +1,141 @@
+import AppKit
+import Foundation
+
+enum CompanionKeyboardError: LocalizedError {
+    case unknownKey(String)
+    case eventSourceUnavailable
+
+    var errorDescription: String? {
+        switch self {
+        case .unknownKey(let key):
+            return "Unsupported key for forwarding: \(key)"
+        case .eventSourceUnavailable:
+            return "Unable to create a keyboard event source."
+        }
+    }
+}
+
+final class CompanionKeyboardController {
+    static let shared = CompanionKeyboardController()
+
+    private init() {}
+
+    func send(key rawKey: String, modifiers rawModifiers: [String]) throws -> String {
+        let parsed = parse(key: rawKey, modifiers: rawModifiers)
+        guard let keyCode = keyCode(for: parsed.key) else {
+            throw CompanionKeyboardError.unknownKey(rawKey)
+        }
+        guard let source = CGEventSource(stateID: .combinedSessionState) else {
+            throw CompanionKeyboardError.eventSourceUnavailable
+        }
+
+        let flags = eventFlags(for: parsed.modifiers)
+        guard
+            let down = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: true),
+            let up = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: false)
+        else {
+            throw CompanionKeyboardError.eventSourceUnavailable
+        }
+
+        down.flags = flags
+        up.flags = flags
+        down.post(tap: .cghidEventTap)
+        usleep(12_000)
+        up.post(tap: .cghidEventTap)
+
+        return displayName(key: parsed.key, modifiers: parsed.modifiers)
+    }
+}
+
+private extension CompanionKeyboardController {
+    func parse(key rawKey: String, modifiers rawModifiers: [String]) -> (key: String, modifiers: Set<String>) {
+        var modifiers = Set(rawModifiers.map(normalizeModifier).filter { !$0.isEmpty })
+        var key = rawKey
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+
+        let symbolModifiers: [(String, String)] = [
+            ("⌘", "command"),
+            ("cmd", "command"),
+            ("command", "command"),
+            ("⌥", "option"),
+            ("option", "option"),
+            ("alt", "option"),
+            ("⌃", "control"),
+            ("ctrl", "control"),
+            ("control", "control"),
+            ("⇧", "shift"),
+            ("shift", "shift"),
+        ]
+
+        for (symbol, modifier) in symbolModifiers where key.contains(symbol) {
+            modifiers.insert(modifier)
+            key = key.replacingOccurrences(of: symbol, with: "")
+        }
+
+        key = key
+            .replacingOccurrences(of: "+", with: "")
+            .replacingOccurrences(of: " ", with: "")
+            .replacingOccurrences(of: "⎋", with: "escape")
+            .replacingOccurrences(of: "⇥", with: "tab")
+            .replacingOccurrences(of: "↩", with: "enter")
+            .replacingOccurrences(of: "⏎", with: "enter")
+            .replacingOccurrences(of: "return", with: "enter")
+            .replacingOccurrences(of: "←", with: "left")
+            .replacingOccurrences(of: "→", with: "right")
+            .replacingOccurrences(of: "↑", with: "up")
+            .replacingOccurrences(of: "↓", with: "down")
+
+        if key == "esc" {
+            key = "escape"
+        }
+
+        return (key.isEmpty ? rawKey.lowercased() : key, modifiers)
+    }
+
+    func normalizeModifier(_ modifier: String) -> String {
+        switch modifier.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
+        case "cmd", "command", "meta", "⌘":
+            return "command"
+        case "opt", "option", "alt", "⌥":
+            return "option"
+        case "ctrl", "control", "⌃":
+            return "control"
+        case "shift", "⇧":
+            return "shift"
+        default:
+            return ""
+        }
+    }
+
+    func eventFlags(for modifiers: Set<String>) -> CGEventFlags {
+        var flags: CGEventFlags = []
+        if modifiers.contains("command") { flags.insert(.maskCommand) }
+        if modifiers.contains("option") { flags.insert(.maskAlternate) }
+        if modifiers.contains("control") { flags.insert(.maskControl) }
+        if modifiers.contains("shift") { flags.insert(.maskShift) }
+        return flags
+    }
+
+    func keyCode(for key: String) -> CGKeyCode? {
+        let codes: [String: CGKeyCode] = [
+            "a": 0, "s": 1, "d": 2, "f": 3, "h": 4, "g": 5, "z": 6, "x": 7,
+            "c": 8, "v": 9, "b": 11, "q": 12, "w": 13, "e": 14, "r": 15,
+            "y": 16, "t": 17, "1": 18, "2": 19, "3": 20, "4": 21, "6": 22,
+            "5": 23, "=": 24, "9": 25, "7": 26, "-": 27, "8": 28, "0": 29,
+            "]": 30, "o": 31, "u": 32, "[": 33, "i": 34, "p": 35, "enter": 36,
+            "l": 37, "j": 38, "'": 39, "k": 40, ";": 41, "\\": 42, ",": 43,
+            "/": 44, "n": 45, "m": 46, ".": 47, "tab": 48, "space": 49,
+            "`": 50, "delete": 51, "backspace": 51, "escape": 53,
+            "command": 55, "cmd": 55, "shift": 56, "capslock": 57, "option": 58,
+            "alt": 58, "control": 59, "left": 123, "right": 124, "down": 125,
+            "up": 126,
+        ]
+        return codes[key]
+    }
+
+    func displayName(key: String, modifiers: Set<String>) -> String {
+        let ordered = ["control", "option", "shift", "command"].filter { modifiers.contains($0) }
+        return (ordered + [key]).joined(separator: "+")
+    }
+}