Merge fix-composer-kbd: composer keyboard context + New message button

Author: mannasdev

Sources/HudsonUI/Model/AppModel.swift

@@ -337,6 +337,10 @@ public final class AppModel {
     /// event — derived, never stored, so it can never drift from the
     /// overlay flags that actually drive what's on screen.
     var keyboardContext: KeyboardContext {
+        // The composer is a text-entry modal — it takes keyboard priority so
+        // the list's single-letter triage shortcuts never eat characters you're
+        // typing into an email.
+        if isComposerVisible { return .composer }
         if isPaletteVisible { return .palette }
         if isSearchVisible { return .search }
         return .list
@@ -362,6 +366,7 @@ public final class AppModel {
         case .togglePalette: togglePalette()
         case .toggleSearch: toggleSearch()
         case .composeNew: composeNew()
+        case .closeComposer: isComposerVisible = false
         }
     }
 

Sources/HudsonUI/Model/KeyboardMap.swift

@@ -7,6 +7,11 @@ import Foundation
 public enum KeyboardContext: Sendable, Equatable {
     case palette
     case search
+    /// The compose/reply sheet is open and owns the keyboard: EVERY key is
+    /// typed into the body (only Esc is special), so the list's single-letter
+    /// triage shortcuts (j/k/e/s/u/o) must NOT fire — otherwise you can't type
+    /// those letters in an email.
+    case composer
     case list
 }
 
@@ -57,6 +62,7 @@ public enum KeyAction: Sendable, Equatable {
     case togglePalette
     case toggleSearch
     case composeNew
+    case closeComposer
 }
 
 /// Hudson's global keymap, as a single pure function: `(context, key) ->
@@ -79,10 +85,20 @@ public enum KeyRouter {
         switch context {
         case .palette: return routeInPalette(event)
         case .search: return routeInSearch(event)
+        case .composer: return routeInComposer(event)
         case .list: return routeInList(event)
         }
     }
 
+    /// The compose/reply sheet owns the keyboard entirely: only Esc is routed
+    /// (to close the sheet); EVERYTHING else — every letter, including j/k/e/s/
+    /// u/o — passes straight through to the body field. Without this, the
+    /// list's single-letter triage shortcuts would eat those letters and you
+    /// couldn't type them in an email.
+    private static func routeInComposer(_ event: KeyDescriptor) -> KeyAction? {
+        event.special == .escape ? .closeComposer : nil
+    }
+
     /// Arrow/Return/Esc drive the palette's highlight and dismissal; every
     /// other key (ordinary typing) passes through untouched so the query
     /// field keeps working — CONSUME only what we explicitly route.

Sources/HudsonUI/Views/RootView.swift

@@ -148,7 +148,8 @@ public struct RootView: View {
                         break
                     }
                 },
-                onSyncNow: { Task { await model.syncNow() } })
+                onSyncNow: { Task { await model.syncNow() } },
+                onCompose: { model.composeNew() })
                 .frame(minWidth: 200, idealWidth: Metrics.sidebarWidth, maxWidth: 300)
 
             InboxListView(inbox: model.inbox, onOpen: { model.openThread($0) })

Sources/HudsonUI/Views/SidebarView.swift

@@ -34,12 +34,14 @@ public struct SidebarView: View {
     private let onSelect: (Selection) -> Void
     private let onSyncNow: () -> Void
     private let onSettings: () -> Void
+    private let onCompose: () -> Void
 
     public init(
         accountEmail: String?, unreadCount: Int, labels: [LabelRecord], pendingCount: Int,
         isSyncing: Bool = false, syncBanner: String? = nil,
         selection: Selection, onSelect: @escaping (Selection) -> Void,
-        onSyncNow: @escaping () -> Void = {}, onSettings: @escaping () -> Void = {}
+        onSyncNow: @escaping () -> Void = {}, onSettings: @escaping () -> Void = {},
+        onCompose: @escaping () -> Void = {}
     ) {
         self.accountEmail = accountEmail
         self.unreadCount = unreadCount
@@ -51,6 +53,7 @@ public struct SidebarView: View {
         self.onSelect = onSelect
         self.onSyncNow = onSyncNow
         self.onSettings = onSettings
+        self.onCompose = onCompose
     }
 
     public var body: some View {
@@ -64,6 +67,12 @@ public struct SidebarView: View {
                 .foregroundStyle(Palette.ink)
                 .lineLimit(1)
                 .truncationMode(.middle)
+                .padding(.horizontal, Metrics.unit * 3)
+                .padding(.bottom, Metrics.unit * 3)
+
+            // The primary "start a new email" affordance (also ⌘N). Was
+            // missing — you could reply but not compose from scratch.
+            PrimaryButton(title: "New message", action: onCompose)
                 .padding(.horizontal, Metrics.unit * 3)
                 .padding(.bottom, Metrics.unit * 4)
 

Tests/HudsonUITests/AppModelTests.swift

@@ -323,3 +323,14 @@ import Testing
     model.startAutoSync(makeStack: { nil })  // idempotent
     #expect(model.isAutoSyncActive == true)
 }
+
+/// When the composer is visible, keyboard routing switches to the `.composer`
+/// context (so triage letters don't eat what you're typing).
+@MainActor
+@Test func keyboardContextIsComposerWhenComposerVisible() {
+    let db = try! HudsonDatabase.inMemory()
+    let model = AppModel(database: db, account: nil)
+    #expect(model.keyboardContext == .list)
+    model.isComposerVisible = true
+    #expect(model.keyboardContext == .composer)
+}

Tests/HudsonUITests/KeyboardMapTests.swift

@@ -100,3 +100,15 @@ import Testing
     #expect(KeyRouter.route(KeyDescriptor(special: .upArrow), context: .list) == nil)
     #expect(KeyRouter.route(KeyDescriptor(special: .downArrow), context: .list) == nil)
 }
+
+/// Regression: the compose/reply sheet owns the keyboard. Single letters that
+/// are list triage shortcuts (s/o/k/j/e/u) MUST pass through so you can type
+/// them into an email — only Esc is routed (to close the sheet). This is the
+/// "can't type s/o/k when replying" bug.
+@Test func composerContextLetsTypingThroughAndOnlyEscCloses() {
+    for letter in ["s", "o", "k", "j", "e", "u", "a", "z"] {
+        #expect(KeyRouter.route(KeyDescriptor(characters: letter), context: .composer) == nil)
+    }
+    #expect(KeyRouter.route(KeyDescriptor(special: .return), context: .composer) == nil)
+    #expect(KeyRouter.route(KeyDescriptor(special: .escape), context: .composer) == .closeComposer)
+}