Fix foreground scope for Global Search shortcut

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Keys/KeyboardShortcutsCatalogSection.swift

@@ -25,6 +25,19 @@ public struct KeyboardShortcutsCatalogSection: SettingCatalogSection {
         defaultValue: [:]
     )
 
+    /// Read projection that preserves every managed action ID even when its
+    /// binding is malformed. Derived from ``bindings`` so the catalog retains
+    /// one stored declaration for the `shortcuts.bindings` path.
+    public var bindingSnapshot: JSONKey<ShortcutBindingsSnapshot> {
+        JSONKey(
+            id: bindings.id,
+            defaultValue: ShortcutBindingsSnapshot(
+                bindings: [:],
+                managedActionIDs: []
+            )
+        )
+    }
+
     /// Per-action focus predicates (`shortcuts.when`), keyed by action id, as
     /// raw expression strings. The app target owns parsing/evaluation; the
     /// Settings UI only needs to know which actions are context-scoped so its

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction+Defaults.swift

@@ -161,6 +161,7 @@ extension ShortcutAction {
         case .toggleBrowserDeveloperTools: return ShortcutStroke(key: "i", command: true, option: true)
         case .showBrowserJavaScriptConsole: return ShortcutStroke(key: "c", command: true, option: true)
         case .toggleBrowserFocusMode: return ShortcutStroke(key: "\r", command: true, option: true)
+        case .toggleBrowserDesignMode: return ShortcutStroke(key: "d", command: true, option: true, control: true)
         case .toggleReactGrab: return ShortcutStroke(key: "g", command: true, shift: true)
         case .diffViewerScrollDown: return ShortcutStroke(key: "j")
         case .diffViewerScrollUp: return ShortcutStroke(key: "k")

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction+DisplayName.swift

@@ -156,6 +156,7 @@ extension ShortcutAction {
         case .toggleBrowserDeveloperTools: return "Toggle Browser Developer Tools"
         case .showBrowserJavaScriptConsole: return "Show Browser JavaScript Console"
         case .toggleBrowserFocusMode: return "Enter Browser Focus Mode"
+        case .toggleBrowserDesignMode: return String(localized: "shortcut.toggleBrowserDesignMode.label", defaultValue: "Toggle Browser Design Mode")
         case .toggleReactGrab: return "Toggle React Grab"
         case .diffViewerScrollDown:
             return String(localized: "shortcut.diffViewerScrollDown.label", defaultValue: "Viewers: Scroll Down")

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction+Group.swift

@@ -45,7 +45,8 @@ extension ShortcutAction {
              .markdownZoomIn, .markdownZoomOut, .markdownZoomReset,
              .find, .findInDirectory, .findNext, .findPrevious,
              .hideFind, .useSelectionForFind, .toggleBrowserDeveloperTools,
-             .showBrowserJavaScriptConsole, .toggleBrowserFocusMode, .toggleReactGrab,
+             .showBrowserJavaScriptConsole, .toggleBrowserFocusMode,
+             .toggleBrowserDesignMode, .toggleReactGrab,
              .diffViewerScrollDown, .diffViewerScrollUp,
              .diffViewerScrollHalfPageDown, .diffViewerScrollHalfPageUp,
              .diffViewerScrollDownEmacs, .diffViewerScrollUpEmacs,

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction+Validation.swift

@@ -0,0 +1,52 @@
+extension ShortcutAction {
+    /// Whether this action rejects `shortcut` because it contains a system-defined media key.
+    ///
+    /// Global Search is handled by the foreground AppKit key path, which cannot
+    /// receive media-key events. Other actions retain their existing validation.
+    ///
+    /// - Parameter shortcut: The shortcut being validated.
+    /// - Returns: `true` when the shortcut cannot execute for this action.
+    public func rejectsSystemDefinedMediaKey(_ shortcut: StoredShortcut) -> Bool {
+        rejectsSystemDefinedMediaKey(
+            firstKey: shortcut.first.key,
+            secondKey: shortcut.second?.key
+        )
+    }
+
+    /// Whether this action rejects shortcut keys from a legacy binding representation.
+    ///
+    /// - Parameters:
+    ///   - firstKey: The persisted key identifier for the first stroke.
+    ///   - secondKey: The persisted key identifier for the optional chord suffix.
+    /// - Returns: `true` when either key is a media key this action cannot execute.
+    public func rejectsSystemDefinedMediaKey(
+        firstKey: String,
+        secondKey: String?
+    ) -> Bool {
+        guard self == .globalSearch else { return false }
+        return firstKey.lowercased().hasPrefix("media.")
+            || secondKey?.lowercased().hasPrefix("media.") == true
+    }
+
+    /// Whether the system reserves this complete shortcut before the action can execute it.
+    ///
+    /// Command-Period is AppKit's standard cancel keystroke for modal alerts
+    /// and open/save panels. The system-wide Show/Hide action must not capture
+    /// that first instinctive cancel press.
+    ///
+    /// - Parameter shortcut: The shortcut being validated.
+    /// - Returns: `true` when the shortcut is reserved for system interaction.
+    public func rejectsSystemReservedShortcut(
+        _ shortcut: StoredShortcut
+    ) -> Bool {
+        guard self == .showHideAllWindows, !shortcut.hasChord else {
+            return false
+        }
+        let first = shortcut.first.canonicalized()
+        return first.key == "."
+            && first.command
+            && !first.shift
+            && !first.option
+            && !first.control
+    }
+}

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction.swift

@@ -160,6 +160,8 @@ public enum ShortcutAction: String, CaseIterable, Sendable, Hashable, SettingCod
     case toggleBrowserDeveloperTools
     case showBrowserJavaScriptConsole
     case toggleBrowserFocusMode
+    /// Toggles design-mode editing for the focused browser.
+    case toggleBrowserDesignMode
     case toggleReactGrab
     /// Scrolls the focused diff viewer down one step.
     case diffViewerScrollDown
@@ -245,7 +247,8 @@ extension ShortcutAction {
 
     /// Whether this action supports a two-stroke shortcut chord.
     public var allowsChordShortcut: Bool {
-        self != .fileExplorerOpenSelection
+        self != .showHideAllWindows
+            && self != .fileExplorerOpenSelection
             && self != .fileExplorerOpenSelectionFinderAlias
             && self != .cycleTextBoxSubmitAction
     }
@@ -272,7 +275,8 @@ extension ShortcutAction {
             return .and(.not(.atom(.browserFocus)), .not(.atom(.sidebarFocus)))
         case .browserBack, .browserForward, .browserReload, .browserHardReload,
              .toggleBrowserDeveloperTools, .showBrowserJavaScriptConsole, .toggleBrowserFocusMode,
-             .diffViewerOpenFileSearch, .diffViewerNextFile, .diffViewerPreviousFile:
+             .toggleBrowserDesignMode, .diffViewerOpenFileSearch, .diffViewerNextFile,
+             .diffViewerPreviousFile:
             return .atom(.browserFocus)
         case .diffViewerScrollDown, .diffViewerScrollUp,
              .diffViewerScrollHalfPageDown, .diffViewerScrollHalfPageUp,

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutBindingPolicyResult.swift

@@ -0,0 +1,128 @@
+/// The action-owned validity of a persisted shortcut's shape.
+///
+/// Persistence adapters use this result before accepting a binding so Settings,
+/// `cmux.json`, and legacy `UserDefaults` cannot disagree about whether an
+/// action can execute the stored shortcut.
+public enum ShortcutBindingPolicyResult: Sendable, Equatable {
+    /// The action can execute the shortcut shape.
+    case accepted
+
+    /// The action requires a modifier on this first stroke.
+    case bareFirstStrokeNotAllowed
+
+    /// The system-wide action requires Command, Option, or Control.
+    case primaryModifierRequired
+
+    /// The action does not support two-stroke shortcuts.
+    case chordNotAllowed
+
+    /// The foreground action cannot receive a system-defined media key.
+    case systemDefinedMediaKeyNotAllowed
+
+    /// The system reserves this shortcut before the action can execute it.
+    case systemReservedShortcutNotAllowed
+}
+
+extension ShortcutAction {
+    /// Validates the representation-independent shape of a persisted shortcut.
+    ///
+    /// This policy intentionally excludes conflicts with other actions because
+    /// conflict checks require the caller's complete effective-binding snapshot.
+    ///
+    /// - Parameter shortcut: The shortcut loaded or proposed by a persistence adapter.
+    /// - Returns: The action-owned validity of the shortcut shape.
+    public func shortcutBindingPolicyResult(
+        for shortcut: StoredShortcut
+    ) -> ShortcutBindingPolicyResult {
+        guard !shortcut.isUnbound else { return .accepted }
+
+        if shortcut.hasChord && !allowsChordShortcut {
+            return .chordNotAllowed
+        }
+        if rejectsSystemDefinedMediaKey(shortcut) {
+            return .systemDefinedMediaKeyNotAllowed
+        }
+        if rejectsSystemReservedShortcut(shortcut) {
+            return .systemReservedShortcutNotAllowed
+        }
+
+        let first = shortcut.first
+        if self == .showHideAllWindows,
+           !first.command,
+           !first.option,
+           !first.control {
+            return .primaryModifierRequired
+        }
+        let supportsLegacyBareSpace = first.key.lowercased() == "space"
+            && self != .globalSearch
+        guard allowsBareFirstStroke
+            || first.hasAnyModifier
+            || supportsLegacyBareSpace else {
+            return .bareFirstStrokeNotAllowed
+        }
+
+        return .accepted
+    }
+
+    /// Resolves a persisted candidate into the shortcut the action executes.
+    ///
+    /// Unsupported Show/Hide candidates fail closed because silently registering
+    /// its default would create an unexpected system-wide hotkey. Other actions
+    /// fall back to their valid built-in default.
+    ///
+    /// - Parameters:
+    ///   - candidate: The configured shortcut, or `nil` when no override exists.
+    ///   - conflictsWithReservedShortcut: Whether a normalized shortcut is reserved
+    ///     by a higher-priority system-wide binding.
+    /// - Returns: The executable shortcut, or `nil` when the action is unbound.
+    public func effectivePersistedShortcut(
+        _ candidate: StoredShortcut?,
+        conflictsWithReservedShortcut: (StoredShortcut) -> Bool = { _ in false }
+    ) -> StoredShortcut? {
+        effectivePersistedShortcut(
+            candidate,
+            normalizing: { shortcut in
+                shortcutBindingPolicyResult(for: shortcut) == .accepted
+                    ? shortcut.canonicalized()
+                    : nil
+            },
+            conflictsWithReservedShortcut: conflictsWithReservedShortcut
+        )
+    }
+
+    /// Resolves a persisted candidate using the consumer's runtime normalizer.
+    ///
+    /// - Parameters:
+    ///   - candidate: The configured shortcut, or `nil` when no override exists.
+    ///   - normalizing: Returns the executable representation of a shortcut, or
+    ///     `nil` when the consumer cannot execute it.
+    ///   - conflictsWithReservedShortcut: Whether a normalized shortcut is reserved
+    ///     by a higher-priority system-wide binding.
+    /// - Returns: The executable shortcut, or `nil` when the action is unbound.
+    public func effectivePersistedShortcut(
+        _ candidate: StoredShortcut?,
+        normalizing: (StoredShortcut) -> StoredShortcut?,
+        conflictsWithReservedShortcut: (StoredShortcut) -> Bool
+    ) -> StoredShortcut? {
+        if let candidate {
+            if candidate.isUnbound {
+                return nil
+            }
+            if let normalized = normalizing(candidate),
+               !conflictsWithReservedShortcut(normalized) {
+                return normalized
+            }
+            if self == .showHideAllWindows {
+                return nil
+            }
+        }
+
+        guard let defaultShortcut,
+              !defaultShortcut.isUnbound,
+              let normalizedDefault = normalizing(defaultShortcut),
+              !conflictsWithReservedShortcut(normalizedDefault) else {
+            return nil
+        }
+        return normalizedDefault
+    }
+}

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutBindingsSnapshot.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+/// A decoded shortcut-binding map plus every action ID managed by that map.
+///
+/// Shortcut values are decoded independently so one malformed binding cannot
+/// hide valid siblings. ``managedActionIDs`` retains malformed entries as
+/// managed, allowing consumers to suppress lower-precedence legacy values.
+public struct ShortcutBindingsSnapshot: Sendable, Equatable, SettingCodable {
+    /// Successfully decoded bindings, keyed by shortcut action ID.
+    public let bindings: [String: StoredShortcut]
+
+    /// Every action ID present in the persisted map, including invalid entries.
+    public let managedActionIDs: Set<String>
+
+    /// Creates a shortcut-binding snapshot.
+    ///
+    /// - Parameters:
+    ///   - bindings: Successfully decoded shortcut bindings.
+    ///   - managedActionIDs: Every action ID present in the persisted map.
+    public init(
+        bindings: [String: StoredShortcut],
+        managedActionIDs: Set<String>
+    ) {
+        self.bindings = bindings
+        self.managedActionIDs = managedActionIDs
+    }
+
+    /// Decodes a property-list binding map while retaining every action ID.
+    public static func decodeFromUserDefaults(_ raw: Any?) -> ShortcutBindingsSnapshot? {
+        decode(raw, using: StoredShortcut.decodeFromUserDefaults(_:))
+    }
+
+    /// Encodes the successfully decoded bindings for property-list storage.
+    public func encodeForUserDefaults() -> Any {
+        bindings.mapValues { $0.encodeForUserDefaults() }
+    }
+
+    /// Decodes a JSON binding map while retaining every action ID.
+    public static func decodeFromJSON(_ raw: Any?) -> ShortcutBindingsSnapshot? {
+        decode(raw, using: StoredShortcut.decodeFromJSON(_:))
+    }
+
+    /// Encodes the successfully decoded bindings for JSON storage.
+    public func encodeForJSON() -> Any {
+        bindings.mapValues { $0.encodeForJSON() }
+    }
+
+    private static func decode(
+        _ raw: Any?,
+        using decodeValue: (Any?) -> StoredShortcut?
+    ) -> ShortcutBindingsSnapshot? {
+        guard let dictionary = raw as? [String: Any] else { return nil }
+
+        var bindings: [String: StoredShortcut] = [:]
+        bindings.reserveCapacity(dictionary.count)
+        for (actionID, rawValue) in dictionary {
+            bindings[actionID] = decodeValue(rawValue)
+        }
+        return ShortcutBindingsSnapshot(
+            bindings: bindings,
+            managedActionIDs: Set(dictionary.keys)
+        )
+    }
+}