From f261f630f67639910403d8d7e75724c4ab8f2318 Mon Sep 17 00:00:00 2001
From: Owen McGirr <o.a.mcgirr@gmail.com>
Date: Mon, 27 Jul 2026 15:09:24 +0100
Subject: [PATCH 1/5] Add PC Switch Control profiles and output engine
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add validated atomic profile persistence with immutable built-in Grid 3 and keyboard profiles
- Add mapped desktop and Grid output sessions with state reconciliation and deterministic cleanup
- Add an accessible eight-slot profile manager and focused engine tests

🤖 Auto-generated
---
 src/SwitchifyPc.App/App.xaml.cs               |  23 +-
 src/SwitchifyPc.App/SettingsWindow.xaml       |  14 +
 src/SwitchifyPc.App/SettingsWindow.xaml.cs    |   6 +-
 .../SwitchControlProfileWindow.xaml           | 102 ++++++
 .../SwitchControlProfileWindow.xaml.cs        | 217 +++++++++++++
 .../SwitchControl/SwitchControlProfile.cs     | 139 ++++++++
 .../SwitchControlProfileStore.cs              | 167 ++++++++++
 .../SwitchControlSessionManager.cs            | 305 ++++++++++++++++++
 .../SwitchControl/SwitchOutputSessions.cs     | 238 ++++++++++++++
 .../SwitchControlProfileTests.cs              | 103 ++++++
 .../SwitchControlSessionManagerTests.cs       |  94 ++++++
 .../SwitchOutputSessionTests.cs               | 120 +++++++
 .../Input/WindowsInputMapper.cs               |   6 +
 13 files changed, 1532 insertions(+), 2 deletions(-)
 create mode 100644 src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
 create mode 100644 src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs
 create mode 100644 src/SwitchifyPc.Core/SwitchControl/SwitchControlProfile.cs
 create mode 100644 src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs
 create mode 100644 src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
 create mode 100644 src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs
 create mode 100644 src/SwitchifyPc.Tests/SwitchControlProfileTests.cs
 create mode 100644 src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs
 create mode 100644 src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs

diff --git a/src/SwitchifyPc.App/App.xaml.cs b/src/SwitchifyPc.App/App.xaml.cs
index 80c292a..5dd7331 100644
--- a/src/SwitchifyPc.App/App.xaml.cs
+++ b/src/SwitchifyPc.App/App.xaml.cs
@@ -9,6 +9,7 @@
 using SwitchifyPc.Core.Input;
 using SwitchifyPc.Core.Pairing;
 using SwitchifyPc.Core.Settings;
+using SwitchifyPc.Core.SwitchControl;
 using SwitchifyPc.Core.AppLifecycle;
 using SwitchifyPc.Core.Diagnostics;
 using SwitchifyPc.Core.Startup;
@@ -36,6 +37,7 @@ public partial class App : System.Windows.Application
     private WindowsExistingInstanceSignal? existingInstanceSignal;
     private NativeTrayIcon? trayIcon;
     private SettingsWindow? settingsWindow;
+    private SwitchControlProfileWindow? switchControlProfileWindow;
     private SetupGuideWindow? setupGuideWindow;
     private MainWindowViewModel mainWindowViewModel = new();
     private SetupGuideViewModel setupGuideViewModel = new();
@@ -45,6 +47,7 @@ public partial class App : System.Windows.Application
     private WindowsBluetoothGattServer? bluetoothServer;
     private BluetoothRemoteFrameProcessor? bluetoothFrameProcessor;
     private DesktopCommandExecutor? commandExecutor;
+    private JsonSwitchControlProfileStore? switchControlProfileStore;
     private MouseRepeatController? mouseRepeatController;
     private WindowsCursorOverlayNotifier? cursorOverlay;
     private WindowsModifierKeyOverlayNotifier? modifierOverlay;
@@ -154,6 +157,7 @@ protected override void OnExit(ExitEventArgs e)
         themeManager?.Dispose();
         themeManager = null;
         commandExecutor = null;
+        switchControlProfileStore = null;
         bluetoothFrameProcessor = null;
         bluetoothStatusTracker = null;
         pairingApprovalManager = null;
@@ -164,6 +168,7 @@ protected override void OnExit(ExitEventArgs e)
         trayIcon?.Dispose();
         trayIcon = null;
         settingsWindow = null;
+        switchControlProfileWindow = null;
         setupGuideWindow = null;
         telemetryReporter?.Dispose();
         telemetryReporter = null;
@@ -273,7 +278,7 @@ private SetupGuideWindow CreateSetupGuideWindow()
 
     private SettingsWindow CreateSettingsWindow()
     {
-        SettingsWindow window = new(CreateSettingsController());
+        SettingsWindow window = new(CreateSettingsController(), ShowSwitchControlProfiles);
         window.Closing += (_, eventArgs) =>
         {
             if (isQuitting) return;
@@ -284,6 +289,22 @@ private SettingsWindow CreateSettingsWindow()
         return window;
     }
 
+    private void ShowSwitchControlProfiles()
+    {
+        switchControlProfileStore ??= new JsonSwitchControlProfileStore(
+            Path.Combine(UserDataDirectory(), "switch-control-profiles.json"));
+        if (switchControlProfileWindow is null)
+        {
+            switchControlProfileWindow = new SwitchControlProfileWindow(
+                switchControlProfileStore,
+                () => null);
+            switchControlProfileWindow.Closed += (_, _) => switchControlProfileWindow = null;
+        }
+        switchControlProfileWindow.Owner = settingsWindow;
+        switchControlProfileWindow.Show();
+        switchControlProfileWindow.Activate();
+    }
+
     private static void CenterWindow(Window window)
     {
         window.Left = SystemParameters.WorkArea.Left + (SystemParameters.WorkArea.Width - window.Width) / 2;
diff --git a/src/SwitchifyPc.App/SettingsWindow.xaml b/src/SwitchifyPc.App/SettingsWindow.xaml
index 7b99159..78751cc 100644
--- a/src/SwitchifyPc.App/SettingsWindow.xaml
+++ b/src/SwitchifyPc.App/SettingsWindow.xaml
@@ -368,6 +368,20 @@
                                 </ItemsControl>
                             </StackPanel>
                         </Border>
+                        <Border Margin="0,14,0,0" Style="{StaticResource PanelBorder}">
+                            <StackPanel>
+                                <TextBlock Text="PC Switch Control" Style="{StaticResource SectionTitle}" />
+                                <TextBlock Margin="0,6,0,0"
+                                           Text="Map physical switches to Grid 3, keyboard, mouse, scrolling, shortcuts, and media controls."
+                                           TextWrapping="Wrap"
+                                           Style="{StaticResource MutedText}" />
+                                <Button Margin="0,14,0,0"
+                                        HorizontalAlignment="Left"
+                                        Content="Manage profiles"
+                                        Click="ManageSwitchProfiles_Click"
+                                        AutomationProperties.Name="Manage PC Switch Control profiles" />
+                            </StackPanel>
+                        </Border>
                     </StackPanel>
 
                     <StackPanel x:Name="PointerPanel" Visibility="Collapsed">
diff --git a/src/SwitchifyPc.App/SettingsWindow.xaml.cs b/src/SwitchifyPc.App/SettingsWindow.xaml.cs
index 915f617..bf78405 100644
--- a/src/SwitchifyPc.App/SettingsWindow.xaml.cs
+++ b/src/SwitchifyPc.App/SettingsWindow.xaml.cs
@@ -15,10 +15,12 @@ public partial class SettingsWindow : Window
     private bool isApplyingSettings;
     private bool settingsLoaded;
     private bool isInstallingUpdate;
+    private readonly Action? manageSwitchProfiles;
 
-    public SettingsWindow(SettingsController controller) : this(controller.ViewModel)
+    public SettingsWindow(SettingsController controller, Action? manageSwitchProfiles = null) : this(controller.ViewModel)
     {
         this.controller = controller;
+        this.manageSwitchProfiles = manageSwitchProfiles;
     }
 
     public SettingsWindow(SettingsViewModel? viewModel = null)
@@ -129,6 +131,8 @@ private void OpenPrivacyPolicy_Click(object sender, RoutedEventArgs e)
         }
     }
 
+    private void ManageSwitchProfiles_Click(object sender, RoutedEventArgs e) => manageSwitchProfiles?.Invoke();
+
     private async void ForgetPairedDevice_Click(object sender, RoutedEventArgs e)
     {
         if (controller is null || sender is not WpfButton { Tag: string deviceId }) return;
diff --git a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
new file mode 100644
index 0000000..af927fb
--- /dev/null
+++ b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
@@ -0,0 +1,102 @@
+<Window x:Class="SwitchifyPc.App.SwitchControlProfileWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="PC Switch Control profiles"
+        Width="980"
+        Height="680"
+        MinWidth="820"
+        MinHeight="560"
+        WindowStartupLocation="CenterOwner">
+    <Grid Margin="20">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+        <StackPanel>
+            <TextBlock Text="PC Switch Control" FontSize="24" FontWeight="SemiBold" />
+            <TextBlock Margin="0,6,0,16"
+                       Text="Create profiles that map up to eight physical switches to Windows input."
+                       TextWrapping="Wrap" />
+        </StackPanel>
+        <Grid Grid.Row="1">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="260" />
+                <ColumnDefinition Width="18" />
+                <ColumnDefinition Width="*" />
+            </Grid.ColumnDefinitions>
+            <DockPanel>
+                <TextBlock DockPanel.Dock="Top"
+                           Margin="0,0,0,8"
+                           Text="Profiles"
+                           FontWeight="SemiBold" />
+                <ListBox x:Name="ProfilesList"
+                         SelectionChanged="ProfilesList_SelectionChanged"
+                         AutomationProperties.Name="Switch control profiles"
+                         DisplayMemberPath="Name" />
+            </DockPanel>
+            <ScrollViewer Grid.Column="2" VerticalScrollBarVisibility="Auto">
+                <StackPanel>
+                    <TextBlock Text="Profile name" FontWeight="SemiBold" />
+                    <TextBox x:Name="ProfileName"
+                             Margin="0,6,0,4"
+                             MaxLength="50"
+                             AutomationProperties.Name="Profile name" />
+                    <TextBlock x:Name="ReadOnlyMessage"
+                               Margin="0,0,0,12"
+                               TextWrapping="Wrap" />
+                    <TextBlock Text="Switch bindings" FontWeight="SemiBold" />
+                    <TextBlock Margin="0,4,0,12"
+                               Text="For shortcuts, enter keys separated by +. Other values use the selected action's available Windows value."
+                               TextWrapping="Wrap" />
+                    <ItemsControl x:Name="BindingRows">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Grid Margin="0,0,0,10">
+                                    <Grid.ColumnDefinitions>
+                                        <ColumnDefinition Width="90" />
+                                        <ColumnDefinition Width="180" />
+                                        <ColumnDefinition Width="*" />
+                                    </Grid.ColumnDefinitions>
+                                    <TextBlock VerticalAlignment="Center"
+                                               Text="{Binding SwitchLabel}"
+                                               FontWeight="SemiBold" />
+                                    <ComboBox Grid.Column="1"
+                                              Margin="0,0,10,0"
+                                              ItemsSource="{Binding Types}"
+                                              SelectedItem="{Binding SelectedType, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                                              IsEnabled="{Binding IsEditable}"
+                                              AutomationProperties.Name="{Binding TypeAutomationName}" />
+                                    <TextBox Grid.Column="2"
+                                             Text="{Binding Value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                                             IsEnabled="{Binding IsEditable}"
+                                             AutomationProperties.Name="{Binding ValueAutomationName}" />
+                                </Grid>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                    <TextBlock x:Name="ValidationMessage"
+                               Foreground="DarkRed"
+                               TextWrapping="Wrap"
+                               AutomationProperties.LiveSetting="Assertive" />
+                </StackPanel>
+            </ScrollViewer>
+        </Grid>
+        <Grid Grid.Row="2" Margin="0,18,0,0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+            <StackPanel Orientation="Horizontal">
+                <Button Content="New" MinWidth="84" Click="New_Click" />
+                <Button Margin="8,0,0,0" Content="Duplicate" MinWidth="84" Click="Duplicate_Click" />
+                <Button x:Name="DeleteButton" Margin="8,0,0,0" Content="Delete" MinWidth="84" Click="Delete_Click" />
+            </StackPanel>
+            <StackPanel Grid.Column="1" Orientation="Horizontal">
+                <Button x:Name="CancelButton" Content="Cancel changes" MinWidth="110" Click="Cancel_Click" />
+                <Button x:Name="SaveButton" Margin="8,0,0,0" Content="Save" MinWidth="84" Click="Save_Click" />
+                <Button Margin="8,0,0,0" Content="Close" MinWidth="84" IsCancel="True" Click="Close_Click" />
+            </StackPanel>
+        </Grid>
+    </Grid>
+</Window>
diff --git a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs
new file mode 100644
index 0000000..10f71e6
--- /dev/null
+++ b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs
@@ -0,0 +1,217 @@
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using SwitchifyPc.Core.SwitchControl;
+using WpfMessageBox = System.Windows.MessageBox;
+
+namespace SwitchifyPc.App;
+
+public partial class SwitchControlProfileWindow : Window
+{
+    private readonly ISwitchControlProfileStore store;
+    private readonly Func<string?> activeProfileId;
+    private IReadOnlyList<SwitchControlProfile> profiles = [];
+    private SwitchControlProfile? selected;
+    private readonly BindingRowViewModel[] rows =
+        Enumerable.Range(1, 8).Select(id => new BindingRowViewModel(id)).ToArray();
+
+    public SwitchControlProfileWindow(
+        ISwitchControlProfileStore store,
+        Func<string?> activeProfileId)
+    {
+        this.store = store;
+        this.activeProfileId = activeProfileId;
+        InitializeComponent();
+        BindingRows.ItemsSource = rows;
+        Reload();
+    }
+
+    private void Reload(string? selectId = null)
+    {
+        profiles = store.Load();
+        ProfilesList.ItemsSource = profiles;
+        ProfilesList.SelectedItem = profiles.FirstOrDefault(profile => profile.Id == selectId) ?? profiles.FirstOrDefault();
+    }
+
+    private void ProfilesList_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    {
+        if (ProfilesList.SelectedItem is not SwitchControlProfile profile) return;
+        selected = profile;
+        bool editable = !profile.IsBuiltIn && profile.Id != activeProfileId();
+        ProfileName.Text = profile.Name;
+        ProfileName.IsEnabled = editable;
+        ReadOnlyMessage.Text = profile.IsBuiltIn
+            ? "Built-in profiles are read-only. Duplicate this profile to customize it."
+            : editable
+                ? ""
+                : "This profile is active and cannot be changed until PC Switch Control stops.";
+        foreach ((BindingRowViewModel row, SwitchControlBinding binding) in rows.Zip(profile.Bindings))
+        {
+            row.Load(binding, editable);
+        }
+        SaveButton.IsEnabled = editable;
+        CancelButton.IsEnabled = editable;
+        DeleteButton.IsEnabled = editable;
+        ValidationMessage.Text = "";
+    }
+
+    private void New_Click(object sender, RoutedEventArgs e)
+    {
+        EditUnsaved(new SwitchControlProfile(
+            Guid.NewGuid().ToString(),
+            1,
+            UniqueName("New profile"),
+            SwitchControlProviderKind.Mapped,
+            Enumerable.Range(1, 8).Select(id => new SwitchControlBinding(id, SwitchBindingType.None)).ToArray()));
+    }
+
+    private void Duplicate_Click(object sender, RoutedEventArgs e)
+    {
+        if (selected is null) return;
+        EditUnsaved(selected with
+        {
+            Id = Guid.NewGuid().ToString(),
+            Version = 1,
+            Name = UniqueName($"{selected.Name} copy"),
+            IsBuiltIn = false,
+            Kind = SwitchControlProviderKind.Mapped,
+            Bindings = selected.Kind == SwitchControlProviderKind.Grid3
+                ? Enumerable.Range(1, 8).Select(id => new SwitchControlBinding(id, SwitchBindingType.None)).ToArray()
+                : selected.Bindings.Select(binding => binding with { }).ToArray()
+        });
+    }
+
+    private void EditUnsaved(SwitchControlProfile profile)
+    {
+        profiles = [.. profiles, profile];
+        ProfilesList.ItemsSource = profiles;
+        ProfilesList.SelectedItem = profile;
+        ProfilesList.ScrollIntoView(profile);
+    }
+
+    private void Save_Click(object sender, RoutedEventArgs e)
+    {
+        if (selected is null || selected.IsBuiltIn || selected.Id == activeProfileId()) return;
+        try
+        {
+            SwitchControlProfile saved = selected with
+            {
+                Name = ProfileName.Text,
+                Version = store.Load().Any(profile => profile.Id == selected.Id)
+                    ? selected.Version + 1
+                    : 1,
+                Bindings = rows.Select(row => row.ToBinding()).ToArray()
+            };
+            IReadOnlyList<SwitchControlProfile> custom = profiles
+                .Where(profile => !profile.IsBuiltIn && profile.Id != selected.Id)
+                .Append(saved)
+                .ToArray();
+            store.Save(custom);
+            Reload(saved.Id);
+        }
+        catch (Exception error) when (error is InvalidDataException or IOException or UnauthorizedAccessException)
+        {
+            ValidationMessage.Text = error.Message;
+            ProfileName.Focus();
+        }
+    }
+
+    private void Cancel_Click(object sender, RoutedEventArgs e) => Reload(selected?.Id);
+
+    private void Delete_Click(object sender, RoutedEventArgs e)
+    {
+        if (selected is null || selected.IsBuiltIn || selected.Id == activeProfileId()) return;
+        MessageBoxResult answer = WpfMessageBox.Show(
+            $"Delete “{selected.Name}”?",
+            "Delete PC Switch Control profile",
+            MessageBoxButton.YesNo,
+            MessageBoxImage.Warning);
+        if (answer != MessageBoxResult.Yes) return;
+        store.Save(profiles.Where(profile => !profile.IsBuiltIn && profile.Id != selected.Id).ToArray());
+        Reload();
+    }
+
+    private void Close_Click(object sender, RoutedEventArgs e) => Close();
+
+    private string UniqueName(string proposed)
+    {
+        string name = proposed;
+        int suffix = 2;
+        while (profiles.Any(profile => string.Equals(profile.Name, name, StringComparison.OrdinalIgnoreCase)))
+        {
+            name = $"{proposed} {suffix++}";
+        }
+        return name;
+    }
+
+    private sealed class BindingRowViewModel : INotifyPropertyChanged
+    {
+        private SwitchBindingType selectedType;
+        private string value = "";
+        private bool isEditable;
+
+        public BindingRowViewModel(int switchId)
+        {
+            SwitchId = switchId;
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+        public int SwitchId { get; }
+        public string SwitchLabel => $"Switch {SwitchId}";
+        public string TypeAutomationName => $"Switch {SwitchId} action type";
+        public string ValueAutomationName => $"Switch {SwitchId} action value";
+        public IReadOnlyList<SwitchBindingType> Types { get; } = Enum.GetValues<SwitchBindingType>();
+
+        public SwitchBindingType SelectedType
+        {
+            get => selectedType;
+            set { selectedType = value; Changed(); }
+        }
+
+        public string Value
+        {
+            get => value;
+            set { this.value = value; Changed(); }
+        }
+
+        public bool IsEditable
+        {
+            get => isEditable;
+            private set { isEditable = value; Changed(); }
+        }
+
+        public void Load(SwitchControlBinding binding, bool editable)
+        {
+            SelectedType = binding.Type;
+            Value = binding.Type == SwitchBindingType.Shortcut
+                ? string.Join(" + ", binding.Keys ?? [])
+                : binding.Type == SwitchBindingType.MouseClick
+                    ? $"{binding.Value}:{binding.ClickCount}"
+                    : binding.Value ?? "";
+            IsEditable = editable;
+        }
+
+        public SwitchControlBinding ToBinding()
+        {
+            string trimmed = Value.Trim();
+            if (SelectedType == SwitchBindingType.Shortcut)
+            {
+                return new(SwitchId, SelectedType, Keys: trimmed.Split(
+                    '+',
+                    StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries));
+            }
+            if (SelectedType == SwitchBindingType.MouseClick)
+            {
+                string[] parts = trimmed.Split(':', StringSplitOptions.TrimEntries);
+                int clicks = parts.Length == 2 && int.TryParse(parts[1], out int parsed) ? parsed : 1;
+                return new(SwitchId, SelectedType, parts[0], ClickCount: clicks);
+            }
+            return new(SwitchId, SelectedType, string.IsNullOrEmpty(trimmed) ? null : trimmed);
+        }
+
+        private void Changed([CallerMemberName] string? propertyName = null) =>
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfile.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfile.cs
new file mode 100644
index 0000000..2c5dd1b
--- /dev/null
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfile.cs
@@ -0,0 +1,139 @@
+namespace SwitchifyPc.Core.SwitchControl;
+
+public enum SwitchControlProviderKind
+{
+    Grid3,
+    Mapped
+}
+
+public enum SwitchBindingType
+{
+    None,
+    Key,
+    MouseButton,
+    Shortcut,
+    MouseClick,
+    Scroll,
+    Media
+}
+
+public enum SwitchBindingBehavior
+{
+    Unassigned,
+    Stateful,
+    Pulse
+}
+
+public sealed record SwitchControlBinding(
+    int SwitchId,
+    SwitchBindingType Type,
+    string? Value = null,
+    IReadOnlyList<string>? Keys = null,
+    int ClickCount = 1)
+{
+    public SwitchBindingBehavior Behavior => Type switch
+    {
+        SwitchBindingType.Key or SwitchBindingType.MouseButton => SwitchBindingBehavior.Stateful,
+        SwitchBindingType.None => SwitchBindingBehavior.Unassigned,
+        _ => SwitchBindingBehavior.Pulse
+    };
+
+    public string Label => Type switch
+    {
+        SwitchBindingType.None => "Unassigned",
+        SwitchBindingType.Key => Value ?? "Key",
+        SwitchBindingType.MouseButton => $"{Title(Value)} mouse button",
+        SwitchBindingType.Shortcut => string.Join(" + ", Keys ?? []),
+        SwitchBindingType.MouseClick => $"{(ClickCount == 2 ? "Double " : "")}{Title(Value)} click",
+        SwitchBindingType.Scroll => $"Scroll {Value}",
+        SwitchBindingType.Media => MediaLabel(Value),
+        _ => "Unassigned"
+    };
+
+    private static string Title(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? "" : char.ToUpperInvariant(value[0]) + value[1..];
+
+    private static string MediaLabel(string? value) => value switch
+    {
+        "playPause" => "Play / pause",
+        "nextTrack" => "Next track",
+        "previousTrack" => "Previous track",
+        "volumeUp" => "Volume up",
+        "volumeDown" => "Volume down",
+        "mute" => "Mute",
+        _ => "Media"
+    };
+}
+
+public sealed record SwitchControlProfile(
+    string Id,
+    int Version,
+    string Name,
+    SwitchControlProviderKind Kind,
+    IReadOnlyList<SwitchControlBinding> Bindings,
+    bool IsBuiltIn = false);
+
+public sealed record SwitchControlBindingSummary(
+    int SwitchId,
+    string Label,
+    string Behavior);
+
+public sealed record SwitchControlProfileSummary(
+    string Id,
+    int Version,
+    string Name,
+    string Kind,
+    IReadOnlyList<SwitchControlBindingSummary> Bindings);
+
+public sealed record SwitchControlProfileCatalog(
+    int CatalogRevision,
+    IReadOnlyList<SwitchControlProfileSummary> Profiles);
+
+public static class SwitchControlProfiles
+{
+    public const string Grid3Id = "builtin.grid3";
+    public const string GenericKeyboardId = "builtin.keyboard";
+    public const int MaximumCustomProfiles = 32;
+
+    public static IReadOnlyList<SwitchControlProfile> BuiltIns { get; } =
+    [
+        new(
+            Grid3Id,
+            1,
+            "Grid 3",
+            SwitchControlProviderKind.Grid3,
+            Enumerable.Range(1, 8)
+                .Select(id => new SwitchControlBinding(id, SwitchBindingType.None, $"Grid switch {id}"))
+                .ToArray(),
+            true),
+        new(
+            GenericKeyboardId,
+            1,
+            "Generic keyboard",
+            SwitchControlProviderKind.Mapped,
+            [
+                new(1, SwitchBindingType.Key, "Space"),
+                new(2, SwitchBindingType.Key, "Enter"),
+                .. Enumerable.Range(3, 6).Select(id => new SwitchControlBinding(id, SwitchBindingType.None))
+            ],
+            true)
+    ];
+
+    public static SwitchControlProfileSummary Summarize(SwitchControlProfile profile) =>
+        new(
+            profile.Id,
+            profile.Version,
+            profile.Name,
+            profile.Kind == SwitchControlProviderKind.Grid3 ? "grid3" : "mapped",
+            profile.Bindings.Select(binding => new SwitchControlBindingSummary(
+                binding.SwitchId,
+                profile.Kind == SwitchControlProviderKind.Grid3 ? $"Grid switch {binding.SwitchId}" : binding.Label,
+                profile.Kind == SwitchControlProviderKind.Grid3 ? "stateful" : BehaviorValue(binding.Behavior))).ToArray());
+
+    private static string BehaviorValue(SwitchBindingBehavior behavior) => behavior switch
+    {
+        SwitchBindingBehavior.Stateful => "stateful",
+        SwitchBindingBehavior.Pulse => "pulse",
+        _ => "unassigned"
+    };
+}
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs
new file mode 100644
index 0000000..19c187e
--- /dev/null
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs
@@ -0,0 +1,167 @@
+using System.Text.Json;
+using SwitchifyPc.Core.Storage;
+
+namespace SwitchifyPc.Core.SwitchControl;
+
+public interface ISwitchControlProfileStore
+{
+    IReadOnlyList<SwitchControlProfile> Load();
+    IReadOnlyList<SwitchControlProfile> Save(IReadOnlyList<SwitchControlProfile> customProfiles);
+}
+
+public sealed class JsonSwitchControlProfileStore : ISwitchControlProfileStore
+{
+    private const int SchemaVersion = 1;
+    private readonly string filePath;
+    private readonly Action<string> warn;
+
+    public JsonSwitchControlProfileStore(string filePath, Action<string>? warn = null)
+    {
+        this.filePath = filePath;
+        this.warn = warn ?? Console.WriteLine;
+    }
+
+    public IReadOnlyList<SwitchControlProfile> Load()
+    {
+        if (!File.Exists(filePath))
+        {
+            return SwitchControlProfiles.BuiltIns;
+        }
+
+        try
+        {
+            StoredProfiles stored = JsonSerializer.Deserialize<StoredProfiles>(
+                File.ReadAllText(filePath),
+                JsonOptions) ?? throw new JsonException();
+            if (stored.SchemaVersion != SchemaVersion)
+            {
+                throw new JsonException();
+            }
+
+            return [.. SwitchControlProfiles.BuiltIns, .. NormalizeCustom(stored.Profiles)];
+        }
+        catch
+        {
+            warn("Switchify PC Switch Control profiles could not be loaded. Built-in profiles will be used.");
+            return SwitchControlProfiles.BuiltIns;
+        }
+    }
+
+    public IReadOnlyList<SwitchControlProfile> Save(IReadOnlyList<SwitchControlProfile> customProfiles)
+    {
+        IReadOnlyList<SwitchControlProfile> normalized = NormalizeCustom(customProfiles);
+        string json = JsonSerializer.Serialize(new StoredProfiles(SchemaVersion, normalized), JsonOptions) + "\n";
+        JsonFileStore.WriteJsonFileAtomicSync(filePath, json);
+        return [.. SwitchControlProfiles.BuiltIns, .. normalized];
+    }
+
+    public static IReadOnlyList<SwitchControlProfile> NormalizeCustom(IReadOnlyList<SwitchControlProfile> profiles)
+    {
+        if (profiles.Count > SwitchControlProfiles.MaximumCustomProfiles)
+        {
+            throw new InvalidDataException("Too many custom profiles.");
+        }
+
+        var names = new HashSet<string>(
+            SwitchControlProfiles.BuiltIns.Select(profile => profile.Name),
+            StringComparer.OrdinalIgnoreCase);
+        var ids = new HashSet<string>(SwitchControlProfiles.BuiltIns.Select(profile => profile.Id), StringComparer.Ordinal);
+        var normalized = new List<SwitchControlProfile>(profiles.Count);
+        foreach (SwitchControlProfile profile in profiles)
+        {
+            string name = profile.Name.Trim();
+            if (name.Length is < 1 or > 50 || !names.Add(name))
+            {
+                throw new InvalidDataException("Profile names must be unique and contain 1 to 50 characters.");
+            }
+
+            if (!Guid.TryParse(profile.Id, out _) || !ids.Add(profile.Id) || profile.Version < 1)
+            {
+                throw new InvalidDataException("Custom profile metadata is invalid.");
+            }
+
+            if (profile.Kind != SwitchControlProviderKind.Mapped || profile.Bindings.Count != 8)
+            {
+                throw new InvalidDataException("Custom profiles must contain eight mapped bindings.");
+            }
+
+            SwitchControlBinding[] bindings = profile.Bindings
+                .OrderBy(binding => binding.SwitchId)
+                .Select(NormalizeBinding)
+                .ToArray();
+            if (!bindings.Select(binding => binding.SwitchId).SequenceEqual(Enumerable.Range(1, 8)))
+            {
+                throw new InvalidDataException("Switch IDs must be 1 through 8.");
+            }
+
+            normalized.Add(profile with { Name = name, Bindings = bindings, IsBuiltIn = false });
+        }
+
+        return normalized;
+    }
+
+    private static SwitchControlBinding NormalizeBinding(SwitchControlBinding binding)
+    {
+        HashSet<string> keys = AllowedKeys;
+        return binding.Type switch
+        {
+            SwitchBindingType.None => new(binding.SwitchId, SwitchBindingType.None),
+            SwitchBindingType.Key when binding.Value is not null && keys.Contains(binding.Value) =>
+                new(binding.SwitchId, binding.Type, binding.Value),
+            SwitchBindingType.MouseButton when AllowedMouseButtons.Contains(binding.Value ?? "") =>
+                new(binding.SwitchId, binding.Type, binding.Value),
+            SwitchBindingType.Shortcut => NormalizeShortcut(binding, keys),
+            SwitchBindingType.MouseClick when AllowedMouseButtons.Contains(binding.Value ?? "") && binding.ClickCount is 1 or 2 =>
+                new(binding.SwitchId, binding.Type, binding.Value, ClickCount: binding.ClickCount),
+            SwitchBindingType.Scroll when AllowedScrollDirections.Contains(binding.Value ?? "") =>
+                new(binding.SwitchId, binding.Type, binding.Value),
+            SwitchBindingType.Media when AllowedMediaActions.Contains(binding.Value ?? "") =>
+                new(binding.SwitchId, binding.Type, binding.Value),
+            _ => throw new InvalidDataException("A profile binding is invalid.")
+        };
+    }
+
+    private static SwitchControlBinding NormalizeShortcut(SwitchControlBinding binding, HashSet<string> allowedKeys)
+    {
+        string[] keys = (binding.Keys ?? []).ToArray();
+        if (keys.Length is < 1 or > 4 ||
+            keys.Distinct(StringComparer.OrdinalIgnoreCase).Count() != keys.Length ||
+            keys.Any(key => !allowedKeys.Contains(key)) ||
+            keys.All(ModifierKeys.Contains))
+        {
+            throw new InvalidDataException("A shortcut binding is invalid.");
+        }
+
+        return new(binding.SwitchId, SwitchBindingType.Shortcut, Keys: keys);
+    }
+
+    private static readonly HashSet<string> ModifierKeys = new(
+        ["Ctrl", "Alt", "Shift", "Meta"],
+        StringComparer.OrdinalIgnoreCase);
+
+    private static readonly HashSet<string> AllowedKeys = new(
+        [
+            .. Enumerable.Range('A', 26).Select(value => ((char)value).ToString()),
+            .. Enumerable.Range(0, 10).Select(value => value.ToString()),
+            .. Enumerable.Range(1, 12).Select(value => $"F{value}"),
+            "Space", "Enter", "Escape", "Tab", "Backspace", "Delete",
+            "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown",
+            "Ctrl", "Alt", "Shift", "Meta"
+        ],
+        StringComparer.OrdinalIgnoreCase);
+
+    private static readonly HashSet<string> AllowedMouseButtons = new(["left", "right", "middle"], StringComparer.Ordinal);
+    private static readonly HashSet<string> AllowedScrollDirections = new(["up", "down", "left", "right"], StringComparer.Ordinal);
+    private static readonly HashSet<string> AllowedMediaActions = new(
+        ["playPause", "nextTrack", "previousTrack", "volumeUp", "volumeDown", "mute"],
+        StringComparer.Ordinal);
+
+    private sealed record StoredProfiles(int SchemaVersion, IReadOnlyList<SwitchControlProfile> Profiles);
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        WriteIndented = true
+    };
+}
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
new file mode 100644
index 0000000..c85a694
--- /dev/null
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
@@ -0,0 +1,305 @@
+using SwitchifyPc.Core.Input;
+
+namespace SwitchifyPc.Core.SwitchControl;
+
+public sealed record SwitchSessionResult(bool Ok, string? Code = null, string? Message = null)
+{
+    public static SwitchSessionResult Success { get; } = new(true);
+    public static SwitchSessionResult Failure(string code, string message) => new(false, code, message);
+}
+
+public sealed class SwitchControlSessionManager
+{
+    private readonly ISwitchControlProfileStore profiles;
+    private readonly ISwitchOutputSessionFactory outputs;
+    private readonly SemaphoreSlim gate = new(1, 1);
+    private ActiveSession? active;
+    private long catalogRevision = 1;
+
+    public SwitchControlSessionManager(
+        ISwitchControlProfileStore profiles,
+        ISwitchOutputSessionFactory outputs)
+    {
+        this.profiles = profiles;
+        this.outputs = outputs;
+    }
+
+    public bool IsActive => active is not null;
+    public string? ActiveProfileId => active?.Profile.Id;
+
+    public SwitchControlProfileCatalog GetCatalog()
+    {
+        IReadOnlyList<SwitchControlProfile> loaded = profiles.Load();
+        return new SwitchControlProfileCatalog(
+            checked((int)catalogRevision),
+            loaded.Select(SwitchControlProfiles.Summarize).ToArray());
+    }
+
+    public async Task<SwitchSessionResult> StartAsync(
+        string deviceId,
+        string sessionId,
+        string profileId,
+        int profileVersion,
+        CancellationToken token = default)
+    {
+        if (!Guid.TryParse(sessionId, out _))
+        {
+            return SwitchSessionResult.Failure("invalid_payload", "Session ID must be a UUID.");
+        }
+
+        SwitchControlProfile? profile = profiles.Load().FirstOrDefault(candidate => candidate.Id == profileId);
+        if (profile is null || profile.Version != profileVersion)
+        {
+            return SwitchSessionResult.Failure("profile_changed", "The selected profile changed or is no longer available.");
+        }
+
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            await StopLockedAsync(token).ConfigureAwait(false);
+            ISwitchOutputSession output;
+            try
+            {
+                output = outputs.Create(profile);
+            }
+            catch (DesktopInputException error)
+            {
+                return SwitchSessionResult.Failure(error.Code, error.Message);
+            }
+
+            active = new ActiveSession(deviceId, sessionId, profile, output);
+            return SwitchSessionResult.Success;
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    public Task<SwitchSessionResult> ApplyEdgeAsync(
+        string deviceId,
+        string sessionId,
+        long sequence,
+        int switchId,
+        bool pressed,
+        CancellationToken token = default) =>
+        ExecuteSequencedAsync(deviceId, sessionId, sequence, output => output.ApplyEdgeAsync(switchId, pressed, token), token);
+
+    public Task<SwitchSessionResult> SynchronizeAsync(
+        string deviceId,
+        string sessionId,
+        long sequence,
+        IReadOnlySet<int> pressedSwitchIds,
+        CancellationToken token = default) =>
+        ExecuteSequencedAsync(deviceId, sessionId, sequence, output => output.SynchronizeAsync(pressedSwitchIds, token), token);
+
+    public async Task<SwitchSessionResult> StopAsync(
+        string deviceId,
+        string sessionId,
+        long sequence,
+        CancellationToken token = default)
+    {
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            if (active is null || active.DeviceId != deviceId || active.SessionId != sessionId)
+            {
+                return SwitchSessionResult.Success;
+            }
+            if (sequence <= active.LastSequence)
+            {
+                return SwitchSessionResult.Success;
+            }
+
+            await StopLockedAsync(token).ConfigureAwait(false);
+            return SwitchSessionResult.Success;
+        }
+        catch
+        {
+            active = null;
+            return SwitchSessionResult.Failure("output_failure", "The active switch output could not be released.");
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    public async Task<SwitchSessionResult> ApplyLegacyGridEdgeAsync(
+        string deviceId,
+        string? sessionId,
+        long? sequence,
+        int switchId,
+        bool pressed,
+        CancellationToken token = default)
+    {
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            SwitchSessionResult ready = await EnsureLegacyGridSessionLockedAsync(deviceId, sessionId, token).ConfigureAwait(false);
+            if (!ready.Ok) return ready;
+            long effectiveSequence = sequence ?? active!.LastSequence + 1;
+            return await ExecuteActiveLockedAsync(effectiveSequence, output =>
+                output.ApplyEdgeAsync(switchId, pressed, token)).ConfigureAwait(false);
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    public async Task<SwitchSessionResult> SynchronizeLegacyGridAsync(
+        string deviceId,
+        string sessionId,
+        long sequence,
+        IReadOnlySet<int> pressedSwitchIds,
+        CancellationToken token = default)
+    {
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            SwitchSessionResult ready = await EnsureLegacyGridSessionLockedAsync(deviceId, sessionId, token).ConfigureAwait(false);
+            return ready.Ok
+                ? await ExecuteActiveLockedAsync(sequence, output =>
+                    output.SynchronizeAsync(pressedSwitchIds, token)).ConfigureAwait(false)
+                : ready;
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    public async Task StopForDeviceAsync(string deviceId, CancellationToken token = default)
+    {
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            if (active?.DeviceId == deviceId)
+            {
+                await StopLockedAsync(token).ConfigureAwait(false);
+            }
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    public async Task StopAllAsync(CancellationToken token = default)
+    {
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            await StopLockedAsync(token).ConfigureAwait(false);
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    private async Task<SwitchSessionResult> ExecuteSequencedAsync(
+        string deviceId,
+        string sessionId,
+        long sequence,
+        Func<ISwitchOutputSession, Task> operation,
+        CancellationToken token)
+    {
+        if (sequence < 1)
+        {
+            return SwitchSessionResult.Failure("invalid_payload", "Sequence must be positive.");
+        }
+
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            if (active is null || active.DeviceId != deviceId || active.SessionId != sessionId)
+            {
+                return SwitchSessionResult.Failure("session_not_active", "The switch-control session is not active.");
+            }
+            return await ExecuteActiveLockedAsync(sequence, operation).ConfigureAwait(false);
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    private async Task<SwitchSessionResult> EnsureLegacyGridSessionLockedAsync(
+        string deviceId,
+        string? sessionId,
+        CancellationToken token)
+    {
+        string effectiveSessionId = sessionId ?? $"legacy:{deviceId}";
+        if (active is not null &&
+            active.DeviceId == deviceId &&
+            active.SessionId == effectiveSessionId &&
+            active.Profile.Id == SwitchControlProfiles.Grid3Id)
+        {
+            return SwitchSessionResult.Success;
+        }
+
+        await StopLockedAsync(token).ConfigureAwait(false);
+        SwitchControlProfile profile = SwitchControlProfiles.BuiltIns[0];
+        try
+        {
+            active = new ActiveSession(deviceId, effectiveSessionId, profile, outputs.Create(profile));
+            return SwitchSessionResult.Success;
+        }
+        catch (DesktopInputException error)
+        {
+            return SwitchSessionResult.Failure(error.Code, error.Message);
+        }
+    }
+
+    private async Task<SwitchSessionResult> ExecuteActiveLockedAsync(
+        long sequence,
+        Func<ISwitchOutputSession, Task> operation)
+    {
+        if (active!.Faulted)
+        {
+            return SwitchSessionResult.Failure("output_failure", "The switch output provider has faulted.");
+        }
+        if (sequence <= active.LastSequence)
+        {
+            return SwitchSessionResult.Success;
+        }
+
+        try
+        {
+            await operation(active.Output).ConfigureAwait(false);
+            active.LastSequence = sequence;
+            return SwitchSessionResult.Success;
+        }
+        catch
+        {
+            active.Faulted = true;
+            return SwitchSessionResult.Failure("output_failure", "The switch output operation failed.");
+        }
+    }
+
+    private async Task StopLockedAsync(CancellationToken token)
+    {
+        ActiveSession? previous = active;
+        active = null;
+        if (previous is not null)
+        {
+            await previous.Output.StopAsync(token).ConfigureAwait(false);
+        }
+    }
+
+    private sealed class ActiveSession(
+        string deviceId,
+        string sessionId,
+        SwitchControlProfile profile,
+        ISwitchOutputSession output)
+    {
+        public string DeviceId { get; } = deviceId;
+        public string SessionId { get; } = sessionId;
+        public SwitchControlProfile Profile { get; } = profile;
+        public ISwitchOutputSession Output { get; } = output;
+        public long LastSequence { get; set; }
+        public bool Faulted { get; set; }
+    }
+}
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs
new file mode 100644
index 0000000..922e16a
--- /dev/null
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs
@@ -0,0 +1,238 @@
+using SwitchifyPc.Core.Input;
+
+namespace SwitchifyPc.Core.SwitchControl;
+
+public interface ISwitchOutputSession
+{
+    Task ApplyEdgeAsync(int switchId, bool pressed, CancellationToken token);
+    Task SynchronizeAsync(IReadOnlySet<int> pressedSwitchIds, CancellationToken token);
+    Task StopAsync(CancellationToken token);
+}
+
+public interface ISwitchOutputSessionFactory
+{
+    ISwitchOutputSession Create(SwitchControlProfile profile);
+}
+
+public sealed class SwitchOutputSessionFactory(
+    IDesktopInputAdapter desktopInput,
+    IGridSwitchBroadcaster? gridSwitchBroadcaster) : ISwitchOutputSessionFactory
+{
+    public ISwitchOutputSession Create(SwitchControlProfile profile) => profile.Kind switch
+    {
+        SwitchControlProviderKind.Grid3 when gridSwitchBroadcaster is not null =>
+            new Grid3SwitchOutputSession(gridSwitchBroadcaster),
+        SwitchControlProviderKind.Grid3 =>
+            throw new DesktopInputException("output_unavailable", "Grid 3 output is unavailable."),
+        _ => new MappedDesktopSwitchOutputSession(desktopInput, profile.Bindings)
+    };
+}
+
+public sealed class Grid3SwitchOutputSession(IGridSwitchBroadcaster broadcaster) : ISwitchOutputSession
+{
+    private readonly HashSet<int> pressed = [];
+
+    public async Task ApplyEdgeAsync(int switchId, bool isPressed, CancellationToken token)
+    {
+        if (isPressed ? pressed.Contains(switchId) : !pressed.Contains(switchId))
+        {
+            return;
+        }
+
+        await broadcaster.SetSwitchStateAsync(switchId, isPressed, token).ConfigureAwait(false);
+        if (isPressed) pressed.Add(switchId); else pressed.Remove(switchId);
+    }
+
+    public async Task SynchronizeAsync(IReadOnlySet<int> pressedSwitchIds, CancellationToken token)
+    {
+        foreach (int switchId in pressed.Except(pressedSwitchIds).Order())
+        {
+            await ApplyEdgeAsync(switchId, false, token).ConfigureAwait(false);
+        }
+        foreach (int switchId in pressedSwitchIds.Except(pressed).Order())
+        {
+            await ApplyEdgeAsync(switchId, true, token).ConfigureAwait(false);
+        }
+    }
+
+    public Task StopAsync(CancellationToken token) => SynchronizeAsync(new HashSet<int>(), token);
+}
+
+public sealed class MappedDesktopSwitchOutputSession : ISwitchOutputSession
+{
+    private readonly IDesktopInputAdapter input;
+    private readonly IReadOnlyDictionary<int, SwitchControlBinding> bindings;
+    private readonly HashSet<int> pressedSources = [];
+    private readonly Dictionary<string, int> heldOutputCounts = new(StringComparer.OrdinalIgnoreCase);
+    private readonly List<string> outputAcquisitionOrder = [];
+
+    public MappedDesktopSwitchOutputSession(
+        IDesktopInputAdapter input,
+        IReadOnlyList<SwitchControlBinding> bindings)
+    {
+        this.input = input;
+        this.bindings = bindings.ToDictionary(binding => binding.SwitchId);
+    }
+
+    public async Task ApplyEdgeAsync(int switchId, bool pressed, CancellationToken token)
+    {
+        bool changed = pressed ? pressedSources.Add(switchId) : pressedSources.Remove(switchId);
+        if (!changed || !bindings.TryGetValue(switchId, out SwitchControlBinding? binding))
+        {
+            return;
+        }
+
+        try
+        {
+            if (binding.Behavior == SwitchBindingBehavior.Stateful)
+            {
+                await SetStatefulBindingAsync(binding, pressed, token).ConfigureAwait(false);
+            }
+            else if (pressed && binding.Behavior == SwitchBindingBehavior.Pulse)
+            {
+                await ExecutePulseAsync(binding, token).ConfigureAwait(false);
+            }
+        }
+        catch
+        {
+            if (pressed) pressedSources.Remove(switchId); else pressedSources.Add(switchId);
+            throw;
+        }
+    }
+
+    public async Task SynchronizeAsync(IReadOnlySet<int> pressedSwitchIds, CancellationToken token)
+    {
+        foreach (int switchId in pressedSources.Except(pressedSwitchIds).Order().ToArray())
+        {
+            if (bindings.TryGetValue(switchId, out SwitchControlBinding? binding) &&
+                binding.Behavior == SwitchBindingBehavior.Stateful)
+            {
+                await ApplyEdgeAsync(switchId, false, token).ConfigureAwait(false);
+            }
+            else
+            {
+                pressedSources.Remove(switchId);
+            }
+        }
+
+        foreach (int switchId in pressedSwitchIds.Except(pressedSources).Order())
+        {
+            if (bindings.TryGetValue(switchId, out SwitchControlBinding? binding) &&
+                binding.Behavior == SwitchBindingBehavior.Stateful)
+            {
+                await ApplyEdgeAsync(switchId, true, token).ConfigureAwait(false);
+            }
+            else
+            {
+                pressedSources.Add(switchId);
+            }
+        }
+    }
+
+    public async Task StopAsync(CancellationToken token)
+    {
+        string[] outputs = outputAcquisitionOrder
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .OrderBy(output => IsModifier(output) ? 1 : 0)
+            .ThenByDescending(output => outputAcquisitionOrder.LastIndexOf(output))
+            .ToArray();
+        Exception? firstError = null;
+        foreach (string output in outputs)
+        {
+            try
+            {
+                await SetOutputAsync(output, false, token).ConfigureAwait(false);
+                heldOutputCounts.Remove(output);
+            }
+            catch (Exception error)
+            {
+                firstError ??= error;
+            }
+        }
+        pressedSources.Clear();
+        outputAcquisitionOrder.Clear();
+        if (firstError is not null) throw firstError;
+    }
+
+    private async Task SetStatefulBindingAsync(SwitchControlBinding binding, bool pressed, CancellationToken token)
+    {
+        string output = binding.Type == SwitchBindingType.Key
+            ? $"key:{binding.Value}"
+            : $"mouse:{binding.Value}";
+        int count = heldOutputCounts.GetValueOrDefault(output);
+        int next = pressed ? count + 1 : Math.Max(0, count - 1);
+        if (count == 0 && next == 1)
+        {
+            await SetOutputAsync(output, true, token).ConfigureAwait(false);
+            outputAcquisitionOrder.Add(output);
+        }
+        else if (count == 1 && next == 0)
+        {
+            await SetOutputAsync(output, false, token).ConfigureAwait(false);
+        }
+
+        if (next == 0) heldOutputCounts.Remove(output); else heldOutputCounts[output] = next;
+    }
+
+    private async Task ExecutePulseAsync(SwitchControlBinding binding, CancellationToken token)
+    {
+        switch (binding.Type)
+        {
+            case SwitchBindingType.Shortcut:
+                await ExecuteShortcutAsync(binding.Keys ?? [], token).ConfigureAwait(false);
+                break;
+            case SwitchBindingType.MouseClick when binding.ClickCount == 2:
+                await input.DoubleClickMouseAsync(binding.Value ?? "", token).ConfigureAwait(false);
+                break;
+            case SwitchBindingType.MouseClick:
+                await input.ClickMouseAsync(binding.Value ?? "", token).ConfigureAwait(false);
+                break;
+            case SwitchBindingType.Scroll:
+                (double dx, double dy) = binding.Value switch
+                {
+                    "up" => (0, 1),
+                    "down" => (0, -1),
+                    "left" => (-1, 0),
+                    _ => (1, 0)
+                };
+                await input.ScrollMouseAsync(dx, dy, token).ConfigureAwait(false);
+                break;
+            case SwitchBindingType.Media:
+                await input.MediaControlAsync(binding.Value ?? "", token).ConfigureAwait(false);
+                break;
+        }
+    }
+
+    private async Task ExecuteShortcutAsync(IReadOnlyList<string> keys, CancellationToken token)
+    {
+        List<string> temporary = [];
+        try
+        {
+            foreach (string key in keys)
+            {
+                string output = $"key:{key}";
+                if (heldOutputCounts.ContainsKey(output)) continue;
+                await input.SetKeyDownAsync(key, true, token).ConfigureAwait(false);
+                temporary.Add(key);
+            }
+        }
+        finally
+        {
+            foreach (string key in temporary.AsEnumerable().Reverse())
+            {
+                await input.SetKeyDownAsync(key, false, token).ConfigureAwait(false);
+            }
+        }
+    }
+
+    private Task SetOutputAsync(string output, bool down, CancellationToken token)
+    {
+        string value = output[(output.IndexOf(':') + 1)..];
+        return output.StartsWith("mouse:", StringComparison.Ordinal)
+            ? input.SetMouseButtonDownAsync(value, down, token)
+            : input.SetKeyDownAsync(value, down, token);
+    }
+
+    private static bool IsModifier(string output) =>
+        output is "key:Ctrl" or "key:Alt" or "key:Shift" or "key:Meta";
+}
diff --git a/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs b/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs
new file mode 100644
index 0000000..7d057cc
--- /dev/null
+++ b/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs
@@ -0,0 +1,103 @@
+using SwitchifyPc.Core.SwitchControl;
+
+namespace SwitchifyPc.Tests;
+
+public sealed class SwitchControlProfileTests
+{
+    [Fact]
+    public void BuiltInsHaveStableIdentityAndMappings()
+    {
+        SwitchControlProfile grid = SwitchControlProfiles.BuiltIns[0];
+        SwitchControlProfile keyboard = SwitchControlProfiles.BuiltIns[1];
+
+        Assert.Equal("builtin.grid3", grid.Id);
+        Assert.Equal("Grid 3", grid.Name);
+        Assert.Equal(1, grid.Version);
+        Assert.Equal("builtin.keyboard", keyboard.Id);
+        Assert.Equal("Generic keyboard", keyboard.Name);
+        Assert.Equal(SwitchBindingType.Key, keyboard.Bindings[0].Type);
+        Assert.Equal("Space", keyboard.Bindings[0].Value);
+        Assert.Equal("Enter", keyboard.Bindings[1].Value);
+        Assert.All(keyboard.Bindings.Skip(2), binding => Assert.Equal(SwitchBindingType.None, binding.Type));
+    }
+
+    [Fact]
+    public void StoreRoundTripsValidatedCustomProfiles()
+    {
+        string path = Path.Combine(Path.GetTempPath(), $"switch-control-{Guid.NewGuid():N}.json");
+        try
+        {
+            var store = new JsonSwitchControlProfileStore(path);
+            SwitchControlProfile custom = CustomProfile("My profile");
+
+            IReadOnlyList<SwitchControlProfile> saved = store.Save([custom]);
+            IReadOnlyList<SwitchControlProfile> loaded = store.Load();
+
+            Assert.Equal(3, saved.Count);
+            Assert.Equal(custom.Id, loaded[2].Id);
+            Assert.Equal(custom.Name, loaded[2].Name);
+            Assert.Equal(custom.Version, loaded[2].Version);
+            Assert.Equal(custom.Bindings, loaded[2].Bindings);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public void StorePreservesMalformedFileAndLoadsBuiltIns()
+    {
+        string path = Path.Combine(Path.GetTempPath(), $"switch-control-{Guid.NewGuid():N}.json");
+        File.WriteAllText(path, "{broken");
+        try
+        {
+            var warnings = new List<string>();
+            var store = new JsonSwitchControlProfileStore(path, warnings.Add);
+
+            IReadOnlyList<SwitchControlProfile> loaded = store.Load();
+
+            Assert.Equal(2, loaded.Count);
+            Assert.Equal("{broken", File.ReadAllText(path));
+            Assert.Single(warnings);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public void DuplicateNamesAreRejectedCaseInsensitively()
+    {
+        SwitchControlProfile first = CustomProfile("Writing");
+        SwitchControlProfile second = CustomProfile(" writing ");
+
+        Assert.Throws<InvalidDataException>(() =>
+            JsonSwitchControlProfileStore.NormalizeCustom([first, second]));
+    }
+
+    [Fact]
+    public void ShortcutRequiresUniqueKeysAndNonModifier()
+    {
+        SwitchControlProfile invalid = CustomProfile(
+            "Shortcut",
+            new(1, SwitchBindingType.Shortcut, Keys: ["Ctrl", "Alt"]));
+
+        Assert.Throws<InvalidDataException>(() =>
+            JsonSwitchControlProfileStore.NormalizeCustom([invalid]));
+    }
+
+    private static SwitchControlProfile CustomProfile(
+        string name,
+        SwitchControlBinding? firstBinding = null) =>
+        new(
+            Guid.NewGuid().ToString(),
+            1,
+            name,
+            SwitchControlProviderKind.Mapped,
+            [
+                firstBinding ?? new(1, SwitchBindingType.Key, "Space"),
+                .. Enumerable.Range(2, 7).Select(id => new SwitchControlBinding(id, SwitchBindingType.None))
+            ]);
+}
diff --git a/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs b/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs
new file mode 100644
index 0000000..ac61473
--- /dev/null
+++ b/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs
@@ -0,0 +1,94 @@
+using SwitchifyPc.Core.SwitchControl;
+
+namespace SwitchifyPc.Tests;
+
+public sealed class SwitchControlSessionManagerTests
+{
+    [Fact]
+    public async Task StaleSequencesAreIdempotent()
+    {
+        SwitchControlProfile profile = SwitchControlProfiles.BuiltIns[1];
+        var output = new RecordingOutputSession();
+        var manager = Manager(profile, output);
+        string sessionId = Guid.NewGuid().ToString();
+        await manager.StartAsync("device", sessionId, profile.Id, profile.Version);
+
+        await manager.ApplyEdgeAsync("device", sessionId, 2, 1, true);
+        await manager.ApplyEdgeAsync("device", sessionId, 1, 1, false);
+
+        Assert.Equal(["1:down"], output.Events);
+    }
+
+    [Fact]
+    public async Task ReplacementStopsOldOutputBeforeStartingNewSession()
+    {
+        SwitchControlProfile profile = SwitchControlProfiles.BuiltIns[1];
+        var first = new RecordingOutputSession();
+        var second = new RecordingOutputSession();
+        var factory = new QueueOutputFactory(first, second);
+        var manager = new SwitchControlSessionManager(new StaticProfileStore(profile), factory);
+
+        await manager.StartAsync("one", Guid.NewGuid().ToString(), profile.Id, profile.Version);
+        await manager.StartAsync("two", Guid.NewGuid().ToString(), profile.Id, profile.Version);
+
+        Assert.Equal(1, first.StopCount);
+        Assert.Equal(0, second.StopCount);
+    }
+
+    [Fact]
+    public async Task OutputFailureFaultsSessionAndDoesNotAdvanceSequence()
+    {
+        SwitchControlProfile profile = SwitchControlProfiles.BuiltIns[1];
+        var output = new RecordingOutputSession { Fail = true };
+        var manager = Manager(profile, output);
+        string sessionId = Guid.NewGuid().ToString();
+        await manager.StartAsync("device", sessionId, profile.Id, profile.Version);
+
+        SwitchSessionResult first = await manager.ApplyEdgeAsync("device", sessionId, 1, 1, true);
+        output.Fail = false;
+        SwitchSessionResult second = await manager.ApplyEdgeAsync("device", sessionId, 1, 1, true);
+
+        Assert.Equal("output_failure", first.Code);
+        Assert.Equal("output_failure", second.Code);
+        Assert.Empty(output.Events);
+    }
+
+    private static SwitchControlSessionManager Manager(
+        SwitchControlProfile profile,
+        RecordingOutputSession output) =>
+        new(new StaticProfileStore(profile), new QueueOutputFactory(output));
+
+    private sealed class StaticProfileStore(params SwitchControlProfile[] profiles) : ISwitchControlProfileStore
+    {
+        public IReadOnlyList<SwitchControlProfile> Load() => profiles;
+        public IReadOnlyList<SwitchControlProfile> Save(IReadOnlyList<SwitchControlProfile> customProfiles) => customProfiles;
+    }
+
+    private sealed class QueueOutputFactory(params RecordingOutputSession[] outputs) : ISwitchOutputSessionFactory
+    {
+        private readonly Queue<RecordingOutputSession> queue = new(outputs);
+        public ISwitchOutputSession Create(SwitchControlProfile profile) => queue.Dequeue();
+    }
+
+    private sealed class RecordingOutputSession : ISwitchOutputSession
+    {
+        public List<string> Events { get; } = [];
+        public int StopCount { get; private set; }
+        public bool Fail { get; set; }
+
+        public Task ApplyEdgeAsync(int switchId, bool pressed, CancellationToken token)
+        {
+            if (Fail) throw new InvalidOperationException();
+            Events.Add($"{switchId}:{(pressed ? "down" : "up")}");
+            return Task.CompletedTask;
+        }
+
+        public Task SynchronizeAsync(IReadOnlySet<int> pressedSwitchIds, CancellationToken token) => Task.CompletedTask;
+
+        public Task StopAsync(CancellationToken token)
+        {
+            StopCount++;
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs b/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs
new file mode 100644
index 0000000..2e1b56b
--- /dev/null
+++ b/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs
@@ -0,0 +1,120 @@
+using SwitchifyPc.Core.Input;
+using SwitchifyPc.Core.SwitchControl;
+
+namespace SwitchifyPc.Tests;
+
+public sealed class SwitchOutputSessionTests
+{
+    [Fact]
+    public async Task SharedStatefulOutputUsesReferenceCounting()
+    {
+        var input = new RecordingInputAdapter();
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.Key, "Space"),
+            new(2, SwitchBindingType.Key, "Space")
+        ]);
+
+        await session.ApplyEdgeAsync(1, true, default);
+        await session.ApplyEdgeAsync(2, true, default);
+        await session.ApplyEdgeAsync(1, false, default);
+        await session.ApplyEdgeAsync(2, false, default);
+
+        Assert.Equal(["key:Space:down", "key:Space:up"], input.Events);
+    }
+
+    [Fact]
+    public async Task PulseRunsOnceAndNeverFromSnapshot()
+    {
+        var input = new RecordingInputAdapter();
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.MouseClick, "left")
+        ]);
+
+        await session.ApplyEdgeAsync(1, true, default);
+        await session.ApplyEdgeAsync(1, true, default);
+        await session.SynchronizeAsync(new HashSet<int> { 1 }, default);
+
+        Assert.Equal(["click:left"], input.Events);
+    }
+
+    [Fact]
+    public async Task SnapshotReleasesBeforePresses()
+    {
+        var input = new RecordingInputAdapter();
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.Key, "Space"),
+            new(2, SwitchBindingType.Key, "Enter")
+        ]);
+        await session.ApplyEdgeAsync(1, true, default);
+
+        await session.SynchronizeAsync(new HashSet<int> { 2 }, default);
+
+        Assert.Equal(["key:Space:down", "key:Space:up", "key:Enter:down"], input.Events);
+    }
+
+    [Fact]
+    public async Task ShortcutDoesNotReleaseAlreadyHeldKey()
+    {
+        var input = new RecordingInputAdapter();
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.Key, "Ctrl"),
+            new(2, SwitchBindingType.Shortcut, Keys: ["Ctrl", "C"])
+        ]);
+
+        await session.ApplyEdgeAsync(1, true, default);
+        await session.ApplyEdgeAsync(2, true, default);
+
+        Assert.Equal(["key:Ctrl:down", "key:C:down", "key:C:up"], input.Events);
+    }
+
+    [Fact]
+    public async Task FailedDownDoesNotMutateTrackedOutput()
+    {
+        var input = new RecordingInputAdapter { FailNext = true };
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.Key, "Space")
+        ]);
+
+        await Assert.ThrowsAsync<DesktopInputException>(() => session.ApplyEdgeAsync(1, true, default));
+        await session.ApplyEdgeAsync(1, true, default);
+
+        Assert.Equal(["key:Space:down"], input.Events);
+    }
+
+    private sealed class RecordingInputAdapter : IDesktopInputAdapter
+    {
+        public List<string> Events { get; } = [];
+        public bool FailNext { get; set; }
+
+        public Task SetKeyDownAsync(string key, bool down, CancellationToken cancellationToken = default) =>
+            Record($"key:{key}:{(down ? "down" : "up")}");
+        public Task SetMouseButtonDownAsync(string button, bool down, CancellationToken cancellationToken = default) =>
+            Record($"mouse:{button}:{(down ? "down" : "up")}");
+        public Task ClickMouseAsync(string button, CancellationToken cancellationToken = default) => Record($"click:{button}");
+        public Task DoubleClickMouseAsync(string button, CancellationToken cancellationToken = default) => Record($"double:{button}");
+        public Task ScrollMouseAsync(double dx, double dy, CancellationToken cancellationToken = default) => Record($"scroll:{dx}:{dy}");
+        public Task MediaControlAsync(string action, CancellationToken cancellationToken = default) => Record($"media:{action}");
+        public Task MoveMouseByAsync(double dx, double dy, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task PressKeyAsync(string key, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task PressShortcutAsync(IReadOnlyList<string> keys, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task TypeTextAsync(string text, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task TypeCharacterAsync(string text, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task ControlWindowAsync(string action, CancellationToken cancellationToken = default) => Task.CompletedTask;
+
+        private Task Record(string value)
+        {
+            if (FailNext)
+            {
+                FailNext = false;
+                throw new DesktopInputException("adapter_failure", "Failed.");
+            }
+            Events.Add(value);
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/src/SwitchifyPc.Windows/Input/WindowsInputMapper.cs b/src/SwitchifyPc.Windows/Input/WindowsInputMapper.cs
index 7084595..357f49d 100644
--- a/src/SwitchifyPc.Windows/Input/WindowsInputMapper.cs
+++ b/src/SwitchifyPc.Windows/Input/WindowsInputMapper.cs
@@ -66,6 +66,7 @@ public static ushort KeyboardVirtualKey(string key)
             "Shift" => VkShift,
             "Meta" => VkLeftWindows,
             _ when IsUppercaseLetterKey(key) => key[0],
+            _ when IsDigitKey(key) => key[0],
             _ when IsFunctionKey(key, out ushort virtualKey) => virtualKey,
             _ => throw new ArgumentOutOfRangeException(nameof(key), key, null)
         };
@@ -111,4 +112,9 @@ private static bool IsUppercaseLetterKey(string key)
     {
         return key.Length == 1 && key[0] is >= 'A' and <= 'Z';
     }
+
+    private static bool IsDigitKey(string key)
+    {
+        return key.Length == 1 && key[0] is >= '0' and <= '9';
+    }
 }

From 647a5ca070a25a7e89efbeb21cb57bf853f2faaf Mon Sep 17 00:00:00 2001
From: Owen McGirr <o.a.mcgirr@gmail.com>
Date: Mon, 27 Jul 2026 16:01:08 +0100
Subject: [PATCH 2/5] Harden switch profile output cleanup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Canonicalize stored key and shortcut tokens for Windows input
- Retain failed provider cleanup state for deterministic retries
- Make binding values discoverable and focus invalid switch rows
- Add regression coverage for cleanup and normalization failures

🤖 Auto-generated
---
 .../SwitchControlProfileWindow.xaml           |  26 ++++-
 .../SwitchControlProfileWindow.xaml.cs        | 108 +++++++++++++++++-
 .../SwitchControlProfileStore.cs              |  16 ++-
 .../SwitchControl/SwitchOutputSessions.cs     |  34 ++++--
 .../SwitchControlProfileTests.cs              |  13 +++
 .../SwitchOutputSessionTests.cs               |  39 ++++++-
 6 files changed, 216 insertions(+), 20 deletions(-)

diff --git a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
index af927fb..7410107 100644
--- a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
+++ b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
@@ -47,12 +47,16 @@
                                TextWrapping="Wrap" />
                     <TextBlock Text="Switch bindings" FontWeight="SemiBold" />
                     <TextBlock Margin="0,4,0,12"
-                               Text="For shortcuts, enter keys separated by +. Other values use the selected action's available Windows value."
+                               Text="Choose a suggested value or type one. Each switch row explains the accepted values for its selected action."
                                TextWrapping="Wrap" />
                     <ItemsControl x:Name="BindingRows">
                         <ItemsControl.ItemTemplate>
                             <DataTemplate>
                                 <Grid Margin="0,0,0,10">
+                                    <Grid.RowDefinitions>
+                                        <RowDefinition Height="Auto" />
+                                        <RowDefinition Height="Auto" />
+                                    </Grid.RowDefinitions>
                                     <Grid.ColumnDefinitions>
                                         <ColumnDefinition Width="90" />
                                         <ColumnDefinition Width="180" />
@@ -67,10 +71,22 @@
                                               SelectedItem="{Binding SelectedType, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
                                               IsEnabled="{Binding IsEditable}"
                                               AutomationProperties.Name="{Binding TypeAutomationName}" />
-                                    <TextBox Grid.Column="2"
-                                             Text="{Binding Value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
-                                             IsEnabled="{Binding IsEditable}"
-                                             AutomationProperties.Name="{Binding ValueAutomationName}" />
+                                    <ComboBox x:Name="BindingValueInput"
+                                              Grid.Column="2"
+                                              ItemsSource="{Binding ValueOptions}"
+                                              Text="{Binding Value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                                              IsEditable="True"
+                                              IsTextSearchEnabled="True"
+                                              IsEnabled="{Binding IsEditable}"
+                                              AutomationProperties.Name="{Binding ValueAutomationName}"
+                                              AutomationProperties.HelpText="{Binding ValueHelp}" />
+                                    <TextBlock Grid.Row="1"
+                                               Grid.Column="1"
+                                               Grid.ColumnSpan="2"
+                                               Margin="0,4,0,0"
+                                               Text="{Binding ValueHelp}"
+                                               TextWrapping="Wrap"
+                                               Foreground="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                                 </Grid>
                             </DataTemplate>
                         </ItemsControl.ItemTemplate>
diff --git a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs
index 10f71e6..cfe741c 100644
--- a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs
+++ b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml.cs
@@ -2,7 +2,9 @@
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Windows;
+using System.Windows.Automation;
 using System.Windows.Controls;
+using System.Windows.Media;
 using SwitchifyPc.Core.SwitchControl;
 using WpfMessageBox = System.Windows.MessageBox;
 
@@ -94,6 +96,13 @@ private void EditUnsaved(SwitchControlProfile profile)
     private void Save_Click(object sender, RoutedEventArgs e)
     {
         if (selected is null || selected.IsBuiltIn || selected.Id == activeProfileId()) return;
+        BindingRowViewModel? invalidRow = rows.FirstOrDefault(row => !row.IsLocallyValid());
+        if (invalidRow is not null)
+        {
+            ValidationMessage.Text = $"Switch {invalidRow.SwitchId}: {invalidRow.ValueHelp}";
+            FocusBindingValue(invalidRow);
+            return;
+        }
         try
         {
             SwitchControlProfile saved = selected with
@@ -146,6 +155,30 @@ private string UniqueName(string proposed)
         return name;
     }
 
+    private void FocusBindingValue(BindingRowViewModel row)
+    {
+        BindingRows.UpdateLayout();
+        if (BindingRows.ItemContainerGenerator.ContainerFromItem(row) is not DependencyObject container)
+        {
+            return;
+        }
+        FindDescendants<System.Windows.Controls.ComboBox>(container)
+            .FirstOrDefault(control =>
+                AutomationProperties.GetName(control) == row.ValueAutomationName)
+            ?.Focus();
+    }
+
+    private static IEnumerable<T> FindDescendants<T>(DependencyObject parent)
+        where T : DependencyObject
+    {
+        for (int index = 0; index < VisualTreeHelper.GetChildrenCount(parent); index++)
+        {
+            DependencyObject child = VisualTreeHelper.GetChild(parent, index);
+            if (child is T match) yield return match;
+            foreach (T descendant in FindDescendants<T>(child)) yield return descendant;
+        }
+    }
+
     private sealed class BindingRowViewModel : INotifyPropertyChanged
     {
         private SwitchBindingType selectedType;
@@ -167,7 +200,13 @@ public BindingRowViewModel(int switchId)
         public SwitchBindingType SelectedType
         {
             get => selectedType;
-            set { selectedType = value; Changed(); }
+            set
+            {
+                selectedType = value;
+                Changed();
+                Changed(nameof(ValueOptions));
+                Changed(nameof(ValueHelp));
+            }
         }
 
         public string Value
@@ -182,6 +221,51 @@ public bool IsEditable
             private set { isEditable = value; Changed(); }
         }
 
+        public IReadOnlyList<string> ValueOptions => SelectedType switch
+        {
+            SwitchBindingType.Key => KeyValues,
+            SwitchBindingType.MouseButton => ["left", "right", "middle"],
+            SwitchBindingType.Shortcut => ["Ctrl + C", "Ctrl + V", "Alt + Tab", "Ctrl + Shift + Escape"],
+            SwitchBindingType.MouseClick => ["left", "left:2", "right", "right:2", "middle", "middle:2"],
+            SwitchBindingType.Scroll => ["up", "down", "left", "right"],
+            SwitchBindingType.Media => ["playPause", "nextTrack", "previousTrack", "volumeUp", "volumeDown", "mute"],
+            _ => []
+        };
+
+        public string ValueHelp => SelectedType switch
+        {
+            SwitchBindingType.None => "No value is required.",
+            SwitchBindingType.Key => "Choose one keyboard key.",
+            SwitchBindingType.MouseButton => "Choose left, right, or middle.",
+            SwitchBindingType.Shortcut => "Enter one to four unique keys separated by +, including a non-modifier.",
+            SwitchBindingType.MouseClick => "Choose a button, with :2 for a double click.",
+            SwitchBindingType.Scroll => "Choose up, down, left, or right.",
+            SwitchBindingType.Media => "Choose play/pause, track, volume, or mute.",
+            _ => "Choose a valid value."
+        };
+
+        public bool IsLocallyValid()
+        {
+            string trimmed = Value.Trim();
+            return SelectedType switch
+            {
+                SwitchBindingType.None => true,
+                SwitchBindingType.Key => KeyValues.Contains(trimmed, StringComparer.OrdinalIgnoreCase),
+                SwitchBindingType.MouseButton =>
+                    new[] { "left", "right", "middle" }.Contains(trimmed, StringComparer.Ordinal),
+                SwitchBindingType.Shortcut => IsValidShortcut(trimmed),
+                SwitchBindingType.MouseClick =>
+                    new[] { "left", "left:2", "right", "right:2", "middle", "middle:2" }
+                        .Contains(trimmed, StringComparer.Ordinal),
+                SwitchBindingType.Scroll =>
+                    new[] { "up", "down", "left", "right" }.Contains(trimmed, StringComparer.Ordinal),
+                SwitchBindingType.Media =>
+                    new[] { "playPause", "nextTrack", "previousTrack", "volumeUp", "volumeDown", "mute" }
+                        .Contains(trimmed, StringComparer.Ordinal),
+                _ => false
+            };
+        }
+
         public void Load(SwitchControlBinding binding, bool editable)
         {
             SelectedType = binding.Type;
@@ -213,5 +297,27 @@ public SwitchControlBinding ToBinding()
 
         private void Changed([CallerMemberName] string? propertyName = null) =>
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+
+        private static bool IsValidShortcut(string value)
+        {
+            string[] keys = value.Split(
+                '+',
+                StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+            return keys.Length is >= 1 and <= 4 &&
+                keys.Distinct(StringComparer.OrdinalIgnoreCase).Count() == keys.Length &&
+                keys.All(key => KeyValues.Contains(key, StringComparer.OrdinalIgnoreCase)) &&
+                keys.Any(key => !ModifierValues.Contains(key, StringComparer.OrdinalIgnoreCase));
+        }
+
+        private static readonly string[] ModifierValues = ["Ctrl", "Alt", "Shift", "Meta"];
+        private static readonly string[] KeyValues =
+        [
+            .. Enumerable.Range('A', 26).Select(value => ((char)value).ToString()),
+            .. Enumerable.Range(0, 10).Select(value => value.ToString()),
+            .. Enumerable.Range(1, 12).Select(value => $"F{value}"),
+            "Space", "Enter", "Escape", "Tab", "Backspace", "Delete",
+            "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight",
+            "Home", "End", "PageUp", "PageDown", "Ctrl", "Alt", "Shift", "Meta"
+        ];
     }
 }
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs
index 19c187e..eb92d91 100644
--- a/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchControlProfileStore.cs
@@ -107,7 +107,7 @@ private static SwitchControlBinding NormalizeBinding(SwitchControlBinding bindin
         {
             SwitchBindingType.None => new(binding.SwitchId, SwitchBindingType.None),
             SwitchBindingType.Key when binding.Value is not null && keys.Contains(binding.Value) =>
-                new(binding.SwitchId, binding.Type, binding.Value),
+                new(binding.SwitchId, binding.Type, CanonicalKey(binding.Value)),
             SwitchBindingType.MouseButton when AllowedMouseButtons.Contains(binding.Value ?? "") =>
                 new(binding.SwitchId, binding.Type, binding.Value),
             SwitchBindingType.Shortcut => NormalizeShortcut(binding, keys),
@@ -123,18 +123,22 @@ SwitchBindingType.Media when AllowedMediaActions.Contains(binding.Value ?? "") =
 
     private static SwitchControlBinding NormalizeShortcut(SwitchControlBinding binding, HashSet<string> allowedKeys)
     {
-        string[] keys = (binding.Keys ?? []).ToArray();
-        if (keys.Length is < 1 or > 4 ||
-            keys.Distinct(StringComparer.OrdinalIgnoreCase).Count() != keys.Length ||
-            keys.Any(key => !allowedKeys.Contains(key)) ||
-            keys.All(ModifierKeys.Contains))
+        string[] suppliedKeys = (binding.Keys ?? []).ToArray();
+        if (suppliedKeys.Length is < 1 or > 4 ||
+            suppliedKeys.Distinct(StringComparer.OrdinalIgnoreCase).Count() != suppliedKeys.Length ||
+            suppliedKeys.Any(key => !allowedKeys.Contains(key)) ||
+            suppliedKeys.All(ModifierKeys.Contains))
         {
             throw new InvalidDataException("A shortcut binding is invalid.");
         }
 
+        string[] keys = suppliedKeys.Select(CanonicalKey).ToArray();
         return new(binding.SwitchId, SwitchBindingType.Shortcut, Keys: keys);
     }
 
+    private static string CanonicalKey(string key) =>
+        AllowedKeys.First(allowed => string.Equals(allowed, key, StringComparison.OrdinalIgnoreCase));
+
     private static readonly HashSet<string> ModifierKeys = new(
         ["Ctrl", "Alt", "Shift", "Meta"],
         StringComparer.OrdinalIgnoreCase);
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs
index 922e16a..b4d1438 100644
--- a/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchOutputSessions.cs
@@ -65,6 +65,7 @@ public sealed class MappedDesktopSwitchOutputSession : ISwitchOutputSession
     private readonly HashSet<int> pressedSources = [];
     private readonly Dictionary<string, int> heldOutputCounts = new(StringComparer.OrdinalIgnoreCase);
     private readonly List<string> outputAcquisitionOrder = [];
+    private readonly List<string> temporaryShortcutKeys = [];
 
     public MappedDesktopSwitchOutputSession(
         IDesktopInputAdapter input,
@@ -132,6 +133,7 @@ public async Task SynchronizeAsync(IReadOnlySet<int> pressedSwitchIds, Cancellat
     public async Task StopAsync(CancellationToken token)
     {
         string[] outputs = outputAcquisitionOrder
+            .Concat(temporaryShortcutKeys.Select(key => $"key:{key}"))
             .Distinct(StringComparer.OrdinalIgnoreCase)
             .OrderBy(output => IsModifier(output) ? 1 : 0)
             .ThenByDescending(output => outputAcquisitionOrder.LastIndexOf(output))
@@ -143,15 +145,22 @@ public async Task StopAsync(CancellationToken token)
             {
                 await SetOutputAsync(output, false, token).ConfigureAwait(false);
                 heldOutputCounts.Remove(output);
+                outputAcquisitionOrder.RemoveAll(item =>
+                    string.Equals(item, output, StringComparison.OrdinalIgnoreCase));
+                if (output.StartsWith("key:", StringComparison.Ordinal))
+                {
+                    string key = output["key:".Length..];
+                    temporaryShortcutKeys.RemoveAll(item =>
+                        string.Equals(item, key, StringComparison.OrdinalIgnoreCase));
+                }
             }
             catch (Exception error)
             {
                 firstError ??= error;
             }
         }
-        pressedSources.Clear();
-        outputAcquisitionOrder.Clear();
         if (firstError is not null) throw firstError;
+        pressedSources.Clear();
     }
 
     private async Task SetStatefulBindingAsync(SwitchControlBinding binding, bool pressed, CancellationToken token)
@@ -205,7 +214,7 @@ private async Task ExecutePulseAsync(SwitchControlBinding binding, CancellationT
 
     private async Task ExecuteShortcutAsync(IReadOnlyList<string> keys, CancellationToken token)
     {
-        List<string> temporary = [];
+        Exception? firstError = null;
         try
         {
             foreach (string key in keys)
@@ -213,16 +222,27 @@ private async Task ExecuteShortcutAsync(IReadOnlyList<string> keys, Cancellation
                 string output = $"key:{key}";
                 if (heldOutputCounts.ContainsKey(output)) continue;
                 await input.SetKeyDownAsync(key, true, token).ConfigureAwait(false);
-                temporary.Add(key);
+                temporaryShortcutKeys.Add(key);
             }
         }
-        finally
+        catch (Exception error)
+        {
+            firstError = error;
+        }
+
+        foreach (string key in temporaryShortcutKeys.AsEnumerable().Reverse().ToArray())
         {
-            foreach (string key in temporary.AsEnumerable().Reverse())
+            try
+            {
+                await input.SetKeyDownAsync(key, false, CancellationToken.None).ConfigureAwait(false);
+                temporaryShortcutKeys.Remove(key);
+            }
+            catch (Exception error)
             {
-                await input.SetKeyDownAsync(key, false, token).ConfigureAwait(false);
+                firstError ??= error;
             }
         }
+        if (firstError is not null) throw firstError;
     }
 
     private Task SetOutputAsync(string output, bool down, CancellationToken token)
diff --git a/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs b/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs
index 7d057cc..15ff093 100644
--- a/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs
+++ b/src/SwitchifyPc.Tests/SwitchControlProfileTests.cs
@@ -88,6 +88,19 @@ public void ShortcutRequiresUniqueKeysAndNonModifier()
             JsonSwitchControlProfileStore.NormalizeCustom([invalid]));
     }
 
+    [Fact]
+    public void KeyTokensAreCanonicalizedBeforePersistence()
+    {
+        SwitchControlProfile profile = CustomProfile(
+            "Canonical",
+            new(1, SwitchBindingType.Shortcut, Keys: ["ctrl", "a"]));
+
+        SwitchControlProfile normalized =
+            Assert.Single(JsonSwitchControlProfileStore.NormalizeCustom([profile]));
+
+        Assert.Equal(["Ctrl", "A"], normalized.Bindings[0].Keys);
+    }
+
     private static SwitchControlProfile CustomProfile(
         string name,
         SwitchControlBinding? firstBinding = null) =>
diff --git a/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs b/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs
index 2e1b56b..c09a019 100644
--- a/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs
+++ b/src/SwitchifyPc.Tests/SwitchOutputSessionTests.cs
@@ -86,10 +86,46 @@ public async Task FailedDownDoesNotMutateTrackedOutput()
         Assert.Equal(["key:Space:down"], input.Events);
     }
 
+    [Fact]
+    public async Task FailedStopRetainsOutputForRetry()
+    {
+        var input = new RecordingInputAdapter();
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.Key, "Space")
+        ]);
+        await session.ApplyEdgeAsync(1, true, default);
+        input.FailValueOnce = "key:Space:up";
+
+        await Assert.ThrowsAsync<DesktopInputException>(() => session.StopAsync(default));
+        await session.StopAsync(default);
+
+        Assert.Equal(["key:Space:down", "key:Space:up"], input.Events);
+    }
+
+    [Fact]
+    public async Task ShortcutCleanupContinuesAndRetainsFailedKeyForStop()
+    {
+        var input = new RecordingInputAdapter { FailValueOnce = "key:C:up" };
+        var session = new MappedDesktopSwitchOutputSession(input,
+        [
+            new(1, SwitchBindingType.Shortcut, Keys: ["Ctrl", "C"])
+        ]);
+
+        await Assert.ThrowsAsync<DesktopInputException>(
+            () => session.ApplyEdgeAsync(1, true, default));
+        await session.StopAsync(default);
+
+        Assert.Equal(
+            ["key:Ctrl:down", "key:C:down", "key:Ctrl:up", "key:C:up"],
+            input.Events);
+    }
+
     private sealed class RecordingInputAdapter : IDesktopInputAdapter
     {
         public List<string> Events { get; } = [];
         public bool FailNext { get; set; }
+        public string? FailValueOnce { get; set; }
 
         public Task SetKeyDownAsync(string key, bool down, CancellationToken cancellationToken = default) =>
             Record($"key:{key}:{(down ? "down" : "up")}");
@@ -108,9 +144,10 @@ public Task SetMouseButtonDownAsync(string button, bool down, CancellationToken
 
         private Task Record(string value)
         {
-            if (FailNext)
+            if (FailNext || value == FailValueOnce)
             {
                 FailNext = false;
+                FailValueOnce = null;
                 throw new DesktopInputException("adapter_failure", "Failed.");
             }
             Events.Add(value);

From a1b3facaf2b666c62c715ff8f773e489ffb0d3b5 Mon Sep 17 00:00:00 2001
From: Owen McGirr <o.a.mcgirr@gmail.com>
Date: Mon, 27 Jul 2026 15:12:11 +0100
Subject: [PATCH 3/5] Add generic PC Switch Control protocol
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add authenticated profile catalog, session, edge, synchronization, and stop commands
- Route generic and legacy Grid sessions through one device-owned session manager
- Advertise no-ack switch edges and reject conflicting desktop input while forwarding
- Surface the active switch profile and cover validation and authenticated routing

🤖 Auto-generated
---
 src/SwitchifyPc.App/App.xaml.cs               |  23 ++-
 src/SwitchifyPc.App/MainWindow.xaml           |   6 +
 .../Control/ControlSession.cs                 | 157 +++++++++++++++++-
 .../SwitchControlSessionManager.cs            |   5 +
 .../Ui/MainWindowViewModel.cs                 |  14 ++
 src/SwitchifyPc.Protocol/ProtocolConstants.cs |  13 +-
 src/SwitchifyPc.Protocol/ProtocolValidator.cs |  76 +++++++++
 src/SwitchifyPc.Tests/ControlSessionTests.cs  |  74 ++++++++-
 .../ProtocolConstantsTests.cs                 |   7 +
 .../ProtocolValidatorTests.cs                 |  49 ++++++
 10 files changed, 416 insertions(+), 8 deletions(-)

diff --git a/src/SwitchifyPc.App/App.xaml.cs b/src/SwitchifyPc.App/App.xaml.cs
index 5dd7331..5726dd1 100644
--- a/src/SwitchifyPc.App/App.xaml.cs
+++ b/src/SwitchifyPc.App/App.xaml.cs
@@ -48,6 +48,7 @@ public partial class App : System.Windows.Application
     private BluetoothRemoteFrameProcessor? bluetoothFrameProcessor;
     private DesktopCommandExecutor? commandExecutor;
     private JsonSwitchControlProfileStore? switchControlProfileStore;
+    private SwitchControlSessionManager? switchControlSessionManager;
     private MouseRepeatController? mouseRepeatController;
     private WindowsCursorOverlayNotifier? cursorOverlay;
     private WindowsModifierKeyOverlayNotifier? modifierOverlay;
@@ -143,6 +144,7 @@ protected override void OnExit(ExitEventArgs e)
         mouseRepeatController = null;
         try
         {
+            switchControlSessionManager?.StopAllAsync().GetAwaiter().GetResult();
             commandExecutor?.ReleaseHeldInputsAsync().GetAwaiter().GetResult();
         }
         catch
@@ -157,6 +159,7 @@ protected override void OnExit(ExitEventArgs e)
         themeManager?.Dispose();
         themeManager = null;
         commandExecutor = null;
+        switchControlSessionManager = null;
         switchControlProfileStore = null;
         bluetoothFrameProcessor = null;
         bluetoothStatusTracker = null;
@@ -297,7 +300,7 @@ private void ShowSwitchControlProfiles()
         {
             switchControlProfileWindow = new SwitchControlProfileWindow(
                 switchControlProfileStore,
-                () => null);
+                () => switchControlSessionManager?.ActiveProfileId);
             switchControlProfileWindow.Closed += (_, _) => switchControlProfileWindow = null;
         }
         switchControlProfileWindow.Owner = settingsWindow;
@@ -384,6 +387,9 @@ private async Task StartBluetoothAsync()
             JsonCursorOverlaySettingsStore cursorOverlaySettingsStore = new(Path.Combine(userDataDirectory, "cursor-overlay-settings.json"));
             SendInputWindowsNativeInput nativeInput = new();
             WindowsDesktopInputAdapter inputAdapter = new(nativeInput, pointerSettingsStore.Load());
+            WindowsGridSwitchBroadcaster gridSwitchBroadcaster = new();
+            switchControlProfileStore = new JsonSwitchControlProfileStore(
+                Path.Combine(userDataDirectory, "switch-control-profiles.json"));
             cursorOverlay = new WindowsCursorOverlayNotifier(
                 nativeInput,
                 cursorOverlaySettingsStore,
@@ -397,7 +403,12 @@ private async Task StartBluetoothAsync()
                 inputAdapter,
                 cursorOverlay,
                 modifierOverlay: modifierOverlay,
-                gridSwitchBroadcaster: new WindowsGridSwitchBroadcaster());
+                gridSwitchBroadcaster: gridSwitchBroadcaster);
+            switchControlSessionManager = new SwitchControlSessionManager(
+                switchControlProfileStore,
+                new SwitchOutputSessionFactory(inputAdapter, gridSwitchBroadcaster));
+            switchControlSessionManager.ActiveProfileChanged += profileName =>
+                Dispatcher.BeginInvoke(() => mainWindowViewModel.SetActiveSwitchControlProfile(profileName));
             mouseRepeatController = new MouseRepeatController(
                 commandExecutor,
                 mouseRepeatSettingsStore,
@@ -408,7 +419,8 @@ private async Task StartBluetoothAsync()
                 commandExecutor,
                 new WindowsPointerProfileProvider(nativeInput, pointerSettingsStore, mouseRepeatSettingsStore),
                 mouseRepeatController,
-                pointerSpeedController);
+                pointerSpeedController,
+                switchControlSessionManager);
 
             pairingApprovalManager ??= new PairingApprovalManager(pairingStore);
             RemoteControlSession remoteSession = new(
@@ -465,6 +477,11 @@ private void HandleBluetoothEvent(BluetoothHelperEvent helperEvent)
                     bluetoothFrameProcessor?.RemoveConnection(disconnected.ConnectionId);
                     if (status.ConnectedClientCount == 0)
                     {
+                        if (switchControlSessionManager is not null)
+                        {
+                            await switchControlSessionManager.StopAllAsync();
+                        }
+
                         if (mouseRepeatController is not null)
                         {
                             await mouseRepeatController.StopAllAsync();
diff --git a/src/SwitchifyPc.App/MainWindow.xaml b/src/SwitchifyPc.App/MainWindow.xaml
index a5d4c88..63f5be0 100644
--- a/src/SwitchifyPc.App/MainWindow.xaml
+++ b/src/SwitchifyPc.App/MainWindow.xaml
@@ -265,6 +265,12 @@
                                                FontWeight="Bold" />
                                 </StackPanel>
                             </Border>
+                            <TextBlock Margin="0,12,0,0"
+                                       HorizontalAlignment="Center"
+                                       Text="{Binding ActiveSwitchControlProfile}"
+                                       FontWeight="SemiBold"
+                                       AutomationProperties.LiveSetting="Polite"
+                                       Visibility="{Binding HasActiveSwitchControlProfile, Converter={StaticResource BooleanToVisibilityConverter}}" />
 
                             <Border Margin="0,14,0,0"
                                     Background="{DynamicResource AccentContainer}"
diff --git a/src/SwitchifyPc.Core/Control/ControlSession.cs b/src/SwitchifyPc.Core/Control/ControlSession.cs
index a23b265..d4df06b 100644
--- a/src/SwitchifyPc.Core/Control/ControlSession.cs
+++ b/src/SwitchifyPc.Core/Control/ControlSession.cs
@@ -3,6 +3,7 @@
 using SwitchifyPc.Core.Input;
 using SwitchifyPc.Core.Pairing;
 using SwitchifyPc.Core.Settings;
+using SwitchifyPc.Core.SwitchControl;
 using SwitchifyPc.Protocol;
 
 namespace SwitchifyPc.Core.Control;
@@ -46,19 +47,22 @@ public sealed class ControlSession
     private readonly IPointerProfileProvider pointerProfileProvider;
     private readonly MouseRepeatController? mouseRepeatController;
     private readonly PointerSpeedController? pointerSpeedController;
+    private readonly SwitchControlSessionManager? switchControlSessions;
 
     public ControlSession(
         CommandAuthValidator authValidator,
         DesktopCommandExecutor commandExecutor,
         IPointerProfileProvider pointerProfileProvider,
         MouseRepeatController? mouseRepeatController = null,
-        PointerSpeedController? pointerSpeedController = null)
+        PointerSpeedController? pointerSpeedController = null,
+        SwitchControlSessionManager? switchControlSessions = null)
     {
         this.authValidator = authValidator;
         this.commandExecutor = commandExecutor;
         this.pointerProfileProvider = pointerProfileProvider;
         this.mouseRepeatController = mouseRepeatController;
         this.pointerSpeedController = pointerSpeedController;
+        this.switchControlSessions = switchControlSessions;
     }
 
     public async Task<ControlSessionResult> ProcessMessageAsync(string rawMessage, CancellationToken cancellationToken = default)
@@ -91,6 +95,10 @@ public async Task<ControlSessionResult> ProcessMessageAsync(string rawMessage, C
             }
 
             await commandExecutor.ReleaseHeldInputsAsync(cancellationToken).ConfigureAwait(false);
+            if (failedDeviceId is not null && switchControlSessions is not null)
+            {
+                await switchControlSessions.StopForDeviceAsync(failedDeviceId, cancellationToken).ConfigureAwait(false);
+            }
             commandExecutor.EndControlSession();
             return ControlSessionResult.Response(ErrorResponse(RequestIdOrNull(request), auth.Reason ?? "invalid_auth", "Command authentication failed."))
                 with { AuthFailureReason = auth.Reason ?? "invalid_auth" };
@@ -100,6 +108,10 @@ public async Task<ControlSessionResult> ProcessMessageAsync(string rawMessage, C
         {
             await StopRepeatAsync(auth.DeviceId ?? "").ConfigureAwait(false);
             await commandExecutor.ReleaseHeldInputsAsync(cancellationToken).ConfigureAwait(false);
+            if (switchControlSessions is not null)
+            {
+                await switchControlSessions.StopForDeviceAsync(auth.DeviceId ?? "", cancellationToken).ConfigureAwait(false);
+            }
             commandExecutor.EndControlSession();
             return WithAuth(AckOrNoResponse(request), auth);
         }
@@ -111,8 +123,109 @@ public async Task<ControlSessionResult> ProcessMessageAsync(string rawMessage, C
                 auth);
         }
 
+        if (type == ProtocolConstants.SwitchProfileListCommandType)
+        {
+            if (switchControlSessions is null)
+            {
+                return WithAuth(ControlSessionResult.Response(ErrorResponse(
+                    RequestIdOrNull(request),
+                    "unsupported_command",
+                    "PC Switch Control is unavailable.")), auth);
+            }
+
+            return WithAuth(ResponseOrNoResponse(
+                request,
+                SwitchProfileCatalogResponse(
+                    request.GetProperty("id").GetString() ?? "",
+                    switchControlSessions.GetCatalog())), auth);
+        }
+
         CommandExecutionResult result;
-        if (type == "mouse.repeat.start")
+        if (type == ProtocolConstants.SwitchSessionStartCommandType)
+        {
+            if (switchControlSessions is null)
+            {
+                result = CommandExecutionResult.Failure("unsupported_command", "PC Switch Control is unavailable.");
+            }
+            else
+            {
+                await StopRepeatAsync(auth.DeviceId ?? "").ConfigureAwait(false);
+                await commandExecutor.ReleaseHeldInputsAsync(cancellationToken).ConfigureAwait(false);
+                JsonElement payload = request.GetProperty("payload");
+                SwitchSessionResult sessionResult = await switchControlSessions.StartAsync(
+                    auth.DeviceId ?? "",
+                    payload.GetProperty("sessionId").GetString() ?? "",
+                    payload.GetProperty("profileId").GetString() ?? "",
+                    payload.GetProperty("profileVersion").GetInt32(),
+                    cancellationToken).ConfigureAwait(false);
+                result = SessionResult(sessionResult);
+            }
+        }
+        else if (type == ProtocolConstants.SwitchEdgeCommandType)
+        {
+            JsonElement payload = request.GetProperty("payload");
+            result = switchControlSessions is null
+                ? CommandExecutionResult.Failure("unsupported_command", "PC Switch Control is unavailable.")
+                : SessionResult(await switchControlSessions.ApplyEdgeAsync(
+                    auth.DeviceId ?? "",
+                    payload.GetProperty("sessionId").GetString() ?? "",
+                    payload.GetProperty("sequence").GetInt64(),
+                    payload.GetProperty("switchId").GetInt32(),
+                    payload.GetProperty("state").GetString() == "down",
+                    cancellationToken).ConfigureAwait(false));
+        }
+        else if (type == ProtocolConstants.SwitchSyncCommandType)
+        {
+            JsonElement payload = request.GetProperty("payload");
+            result = switchControlSessions is null
+                ? CommandExecutionResult.Failure("unsupported_command", "PC Switch Control is unavailable.")
+                : SessionResult(await switchControlSessions.SynchronizeAsync(
+                    auth.DeviceId ?? "",
+                    payload.GetProperty("sessionId").GetString() ?? "",
+                    payload.GetProperty("sequence").GetInt64(),
+                    payload.GetProperty("pressedSwitchIds").EnumerateArray().Select(value => value.GetInt32()).ToHashSet(),
+                    cancellationToken).ConfigureAwait(false));
+        }
+        else if (type == ProtocolConstants.SwitchSessionStopCommandType)
+        {
+            JsonElement payload = request.GetProperty("payload");
+            result = switchControlSessions is null
+                ? CommandExecutionResult.Failure("unsupported_command", "PC Switch Control is unavailable.")
+                : SessionResult(await switchControlSessions.StopAsync(
+                    auth.DeviceId ?? "",
+                    payload.GetProperty("sessionId").GetString() ?? "",
+                    payload.GetProperty("sequence").GetInt64(),
+                    cancellationToken).ConfigureAwait(false));
+        }
+        else if (type == ProtocolConstants.GridSwitchSetCommandType && switchControlSessions is not null)
+        {
+            JsonElement payload = request.GetProperty("payload");
+            result = SessionResult(await switchControlSessions.ApplyLegacyGridEdgeAsync(
+                auth.DeviceId ?? "",
+                payload.TryGetProperty("sessionId", out JsonElement sessionId) ? sessionId.GetString() : null,
+                payload.TryGetProperty("sequence", out JsonElement sequence) ? sequence.GetInt64() : null,
+                payload.GetProperty("switchId").GetInt32(),
+                payload.GetProperty("state").GetString() == "down",
+                cancellationToken).ConfigureAwait(false));
+        }
+        else if (type == ProtocolConstants.GridSwitchSyncCommandType && switchControlSessions is not null)
+        {
+            JsonElement payload = request.GetProperty("payload");
+            result = SessionResult(await switchControlSessions.SynchronizeLegacyGridAsync(
+                auth.DeviceId ?? "",
+                payload.GetProperty("sessionId").GetString() ?? "",
+                payload.GetProperty("sequence").GetInt64(),
+                payload.GetProperty("pressedSwitchIds").EnumerateArray().Select(value => value.GetInt32()).ToHashSet(),
+                cancellationToken).ConfigureAwait(false));
+        }
+        else if (switchControlSessions?.IsActive == true &&
+            type != "connection.ping")
+        {
+            result = CommandExecutionResult.Failure(
+                "switch_session_active",
+                "Stop PC Switch Control before using other PC control commands.");
+        }
+        else if (type == "mouse.repeat.start")
         {
             if (mouseRepeatController is null)
             {
@@ -169,6 +282,10 @@ public async Task EndControlSessionAsync(CancellationToken cancellationToken = d
     {
         await StopAllRepeatsAsync().ConfigureAwait(false);
         await commandExecutor.ReleaseHeldInputsAsync(cancellationToken).ConfigureAwait(false);
+        if (switchControlSessions is not null)
+        {
+            await switchControlSessions.StopAllAsync(cancellationToken).ConfigureAwait(false);
+        }
         commandExecutor.EndControlSession();
     }
 
@@ -317,4 +434,40 @@ private static JsonObject PointerProfileResponse(string id, PointerMovementProfi
             ["error"] = null
         };
     }
+
+    private static CommandExecutionResult SessionResult(SwitchSessionResult result) =>
+        result.Ok
+            ? CommandExecutionResult.Success
+            : CommandExecutionResult.Failure(
+                result.Code ?? "command_failed",
+                result.Message ?? "PC Switch Control command failed.");
+
+    private static JsonObject SwitchProfileCatalogResponse(string id, SwitchControlProfileCatalog catalog)
+    {
+        return new JsonObject
+        {
+            ["version"] = ProtocolConstants.ProtocolVersion,
+            ["id"] = id,
+            ["type"] = ProtocolConstants.SwitchProfileListCommandType,
+            ["ok"] = true,
+            ["payload"] = new JsonObject
+            {
+                ["catalogRevision"] = catalog.CatalogRevision,
+                ["profiles"] = new JsonArray(catalog.Profiles.Select(profile => new JsonObject
+                {
+                    ["id"] = profile.Id,
+                    ["version"] = profile.Version,
+                    ["name"] = profile.Name,
+                    ["kind"] = profile.Kind,
+                    ["bindings"] = new JsonArray(profile.Bindings.Select(binding => new JsonObject
+                    {
+                        ["switchId"] = binding.SwitchId,
+                        ["label"] = binding.Label,
+                        ["behavior"] = binding.Behavior
+                    }).ToArray<JsonNode?>())
+                }).ToArray<JsonNode?>())
+            },
+            ["error"] = null
+        };
+    }
 }
diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
index c85a694..a47da84 100644
--- a/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
@@ -16,6 +16,8 @@ public sealed class SwitchControlSessionManager
     private ActiveSession? active;
     private long catalogRevision = 1;
 
+    public event Action<string?>? ActiveProfileChanged;
+
     public SwitchControlSessionManager(
         ISwitchControlProfileStore profiles,
         ISwitchOutputSessionFactory outputs)
@@ -68,6 +70,7 @@ public async Task<SwitchSessionResult> StartAsync(
             }
 
             active = new ActiveSession(deviceId, sessionId, profile, output);
+            ActiveProfileChanged?.Invoke(profile.Name);
             return SwitchSessionResult.Success;
         }
         finally
@@ -245,6 +248,7 @@ private async Task<SwitchSessionResult> EnsureLegacyGridSessionLockedAsync(
         try
         {
             active = new ActiveSession(deviceId, effectiveSessionId, profile, outputs.Create(profile));
+            ActiveProfileChanged?.Invoke(profile.Name);
             return SwitchSessionResult.Success;
         }
         catch (DesktopInputException error)
@@ -286,6 +290,7 @@ private async Task StopLockedAsync(CancellationToken token)
         if (previous is not null)
         {
             await previous.Output.StopAsync(token).ConfigureAwait(false);
+            ActiveProfileChanged?.Invoke(null);
         }
     }
 
diff --git a/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs b/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs
index d509318..12246c8 100644
--- a/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs
+++ b/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs
@@ -16,6 +16,7 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged
     };
     private UpdateState updateState = UpdateState.CreateInitial("0.2.0");
     private IReadOnlyList<PendingPairingApprovalView> pairingApprovals = [];
+    private string? activeSwitchControlProfile;
 
     public event PropertyChangedEventHandler? PropertyChanged;
 
@@ -57,6 +58,12 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged
 
     public string RecentBluetoothError => MainWindowCopy.BluetoothRecentError(bluetooth);
 
+    public bool HasActiveSwitchControlProfile => activeSwitchControlProfile is not null;
+
+    public string ActiveSwitchControlProfile => activeSwitchControlProfile is null
+        ? ""
+        : $"PC Switch Control: {activeSwitchControlProfile}";
+
     public bool HasUpdateBanner => MainWindowCopy.UpdateBanner(updateState) is not null;
 
     public string UpdateBannerTitle => MainWindowCopy.UpdateBanner(updateState)?.Title ?? "";
@@ -101,6 +108,13 @@ public void SetPairingApprovals(IReadOnlyList<PendingPairingApprovalView> approv
         OnPropertyChanged(nameof(ShowConnectedDeviceUi));
     }
 
+    public void SetActiveSwitchControlProfile(string? profileName)
+    {
+        activeSwitchControlProfile = profileName;
+        OnPropertyChanged(nameof(HasActiveSwitchControlProfile));
+        OnPropertyChanged(nameof(ActiveSwitchControlProfile));
+    }
+
     private void NotifyStatusChanged()
     {
         OnPropertyChanged(nameof(StatusTitle));
diff --git a/src/SwitchifyPc.Protocol/ProtocolConstants.cs b/src/SwitchifyPc.Protocol/ProtocolConstants.cs
index b1cd451..0bfe0c1 100644
--- a/src/SwitchifyPc.Protocol/ProtocolConstants.cs
+++ b/src/SwitchifyPc.Protocol/ProtocolConstants.cs
@@ -13,6 +13,11 @@ public static class ProtocolConstants
     public const int MaxErrorMessageLength = 300;
     public const string GridSwitchSetCommandType = "grid.switch.set";
     public const string GridSwitchSyncCommandType = "grid.switch.sync";
+    public const string SwitchProfileListCommandType = "switch.profile.list";
+    public const string SwitchSessionStartCommandType = "switch.session.start";
+    public const string SwitchEdgeCommandType = "switch.edge";
+    public const string SwitchSyncCommandType = "switch.sync";
+    public const string SwitchSessionStopCommandType = "switch.session.stop";
     public const int MinimumGridSwitchId = 1;
     public const int MaximumGridSwitchId = 8;
 
@@ -41,6 +46,11 @@ public static class ProtocolConstants
         "window.control",
         GridSwitchSetCommandType,
         GridSwitchSyncCommandType,
+        SwitchProfileListCommandType,
+        SwitchSessionStartCommandType,
+        SwitchEdgeCommandType,
+        SwitchSyncCommandType,
+        SwitchSessionStopCommandType,
         "pointer.profile",
         "pointer.display.move",
         "pointer.speed.set",
@@ -72,7 +82,8 @@ public static class ProtocolConstants
         "keyboard.textStream.key",
         "media.control",
         "window.control",
-        GridSwitchSetCommandType
+        GridSwitchSetCommandType,
+        SwitchEdgeCommandType
     };
 
     public static readonly IReadOnlySet<string> MouseButtons = new HashSet<string>(StringComparer.Ordinal)
diff --git a/src/SwitchifyPc.Protocol/ProtocolValidator.cs b/src/SwitchifyPc.Protocol/ProtocolValidator.cs
index ecfc0f1..29e1fbc 100644
--- a/src/SwitchifyPc.Protocol/ProtocolValidator.cs
+++ b/src/SwitchifyPc.Protocol/ProtocolValidator.cs
@@ -185,10 +185,86 @@ private static ProtocolValidationResult ValidateCommandPayload(string type, Json
                     : Invalid("invalid_payload", "Window control action is invalid."),
             ProtocolConstants.GridSwitchSetCommandType => ValidateGridSwitchSetPayload(payload),
             ProtocolConstants.GridSwitchSyncCommandType => ValidateGridSwitchSyncPayload(payload),
+            ProtocolConstants.SwitchProfileListCommandType =>
+                ObjectPropertyCount(payload) == 0 ? Valid(payload) : Invalid("invalid_payload", "Payload must be empty."),
+            ProtocolConstants.SwitchSessionStartCommandType => ValidateSwitchSessionStartPayload(payload),
+            ProtocolConstants.SwitchEdgeCommandType => ValidateSwitchEdgePayload(payload),
+            ProtocolConstants.SwitchSyncCommandType => ValidateSwitchSyncPayload(payload),
+            ProtocolConstants.SwitchSessionStopCommandType => ValidateSwitchSessionStopPayload(payload),
             _ => Invalid("invalid_type", "Unsupported message type.")
         };
     }
 
+    private static ProtocolValidationResult ValidateSwitchSessionStartPayload(JsonElement payload)
+    {
+        return ObjectPropertyCount(payload) == 4 &&
+            TryGetString(payload, "sessionId", out string? sessionId) &&
+            Guid.TryParse(sessionId, out _) &&
+            TryGetString(payload, "profileId", out string? profileId) &&
+            profileId.Length is >= 1 and <= 80 &&
+            TryGetInteger(payload, "profileVersion", out int profileVersion) &&
+            profileVersion > 0 &&
+            TryGetInteger(payload, "switchCount", out int switchCount) &&
+            switchCount is >= 1 and <= ProtocolConstants.MaximumGridSwitchId
+                ? Valid(payload)
+                : Invalid("invalid_payload", "Switch session start payload is invalid.");
+    }
+
+    private static ProtocolValidationResult ValidateSwitchEdgePayload(JsonElement payload)
+    {
+        return ObjectPropertyCount(payload) == 4 &&
+            ValidateSwitchSequence(payload) &&
+            TryGetInteger(payload, "switchId", out int switchId) &&
+            switchId is >= ProtocolConstants.MinimumGridSwitchId and <= ProtocolConstants.MaximumGridSwitchId &&
+            TryGetString(payload, "state", out string? state) &&
+            state is "down" or "up"
+                ? Valid(payload)
+                : Invalid("invalid_payload", "Switch edge payload is invalid.");
+    }
+
+    private static ProtocolValidationResult ValidateSwitchSyncPayload(JsonElement payload)
+    {
+        if (ObjectPropertyCount(payload) != 3 ||
+            !ValidateSwitchSequence(payload) ||
+            !payload.TryGetProperty("pressedSwitchIds", out JsonElement pressedSwitchIds) ||
+            pressedSwitchIds.ValueKind != JsonValueKind.Array ||
+            pressedSwitchIds.GetArrayLength() > ProtocolConstants.MaximumGridSwitchId)
+        {
+            return Invalid("invalid_payload", "Switch synchronization payload is invalid.");
+        }
+
+        int previous = 0;
+        foreach (JsonElement element in pressedSwitchIds.EnumerateArray())
+        {
+            if (element.ValueKind != JsonValueKind.Number ||
+                !element.TryGetInt32(out int switchId) ||
+                switchId is < ProtocolConstants.MinimumGridSwitchId or > ProtocolConstants.MaximumGridSwitchId ||
+                switchId <= previous)
+            {
+                return Invalid("invalid_payload", "Switch synchronization IDs must be unique and sorted.");
+            }
+            previous = switchId;
+        }
+        return Valid(payload);
+    }
+
+    private static ProtocolValidationResult ValidateSwitchSessionStopPayload(JsonElement payload)
+    {
+        return ObjectPropertyCount(payload) == 2 && ValidateSwitchSequence(payload)
+            ? Valid(payload)
+            : Invalid("invalid_payload", "Switch session stop payload is invalid.");
+    }
+
+    private static bool ValidateSwitchSequence(JsonElement payload)
+    {
+        return TryGetString(payload, "sessionId", out string? sessionId) &&
+            Guid.TryParse(sessionId, out _) &&
+            payload.TryGetProperty("sequence", out JsonElement sequence) &&
+            sequence.ValueKind == JsonValueKind.Number &&
+            sequence.TryGetInt64(out long value) &&
+            value > 0;
+    }
+
     private static ProtocolValidationResult ValidateGridSwitchSetPayload(JsonElement payload)
     {
         bool basePayloadValid = TryGetInteger(payload, "switchId", out int switchId) &&
diff --git a/src/SwitchifyPc.Tests/ControlSessionTests.cs b/src/SwitchifyPc.Tests/ControlSessionTests.cs
index 1908a3a..620ade1 100644
--- a/src/SwitchifyPc.Tests/ControlSessionTests.cs
+++ b/src/SwitchifyPc.Tests/ControlSessionTests.cs
@@ -4,6 +4,7 @@
 using SwitchifyPc.Core.Input;
 using SwitchifyPc.Core.Pairing;
 using SwitchifyPc.Core.Settings;
+using SwitchifyPc.Core.SwitchControl;
 using SwitchifyPc.Protocol;
 
 namespace SwitchifyPc.Tests;
@@ -91,6 +92,60 @@ public async Task AuthenticatedModifierCommandsRouteToExecutor()
         Assert.Equal(["setKeyDown:Ctrl:True", "setKeyDown:Ctrl:False"], adapter.Calls);
     }
 
+    [Fact]
+    public async Task ListsAndStartsPcSwitchControlProfile()
+    {
+        FakeInputAdapter adapter = new();
+        ControlSession session = CreateSession(adapter, enableSwitchControl: true);
+        string sessionId = Guid.NewGuid().ToString();
+
+        ControlSessionResult catalog = await session.ProcessMessageAsync(
+            SignedCommand("switch.profile.list", new { }));
+        ControlSessionResult start = await session.ProcessMessageAsync(SignedCommand(
+            "switch.session.start",
+            new
+            {
+                sessionId,
+                profileId = SwitchControlProfiles.GenericKeyboardId,
+                profileVersion = 1,
+                switchCount = 2
+            },
+            id: "request-2"));
+        ControlSessionResult edge = await session.ProcessMessageAsync(SignedCommand(
+            "switch.edge",
+            new { sessionId, sequence = 1, switchId = 1, state = "down" },
+            id: "request-3",
+            responseMode: "none"));
+
+        using JsonDocument response = JsonDocument.Parse(catalog.ResponseJson!);
+        Assert.Equal(2, response.RootElement.GetProperty("payload").GetProperty("profiles").GetArrayLength());
+        Assert.True(start.HasResponse);
+        Assert.False(edge.HasResponse);
+        Assert.Contains("setKeyDown:Space:True", adapter.Calls);
+    }
+
+    [Fact]
+    public async Task RejectsOrdinaryControlWhileSwitchSessionIsActive()
+    {
+        FakeInputAdapter adapter = new();
+        ControlSession session = CreateSession(adapter, enableSwitchControl: true);
+        string sessionId = Guid.NewGuid().ToString();
+        await session.ProcessMessageAsync(SignedCommand(
+            "switch.session.start",
+            new
+            {
+                sessionId,
+                profileId = SwitchControlProfiles.GenericKeyboardId,
+                profileVersion = 1,
+                switchCount = 2
+            }));
+
+        ControlSessionResult result = await session.ProcessMessageAsync(
+            SignedCommand("mouse.move", new { dx = 1, dy = 1 }, id: "request-2"));
+
+        AssertError(result, "request-2", "switch_session_active");
+    }
+
     [Fact]
     public async Task RejectsInvalidJsonAndMalformedPayloads()
     {
@@ -269,7 +324,8 @@ private static ControlSession CreateSession(
         IMouseRepeatSettingsStore? mouseRepeatSettings = null,
         FakePointerSettings? pointerSettings = null,
         Action<PointerMovementSettings>? applyPointerSettings = null,
-        IGridSwitchBroadcaster? gridSwitchBroadcaster = null)
+        IGridSwitchBroadcaster? gridSwitchBroadcaster = null,
+        bool enableSwitchControl = false)
     {
         MemoryPairingStore store = new(new PairingState(
             DesktopId: "desktop-1",
@@ -297,12 +353,26 @@ private static ControlSession CreateSession(
             ? null
             : new PointerSpeedController(pointerSettings, applyPointerSettings ?? (_ => { }));
 
+        SwitchControlSessionManager? switchControlSessions = enableSwitchControl
+            ? new SwitchControlSessionManager(
+                new BuiltInProfileStore(),
+                new SwitchOutputSessionFactory(adapter, gridSwitchBroadcaster))
+            : null;
+
         return new ControlSession(
             new CommandAuthValidator(store, () => Now),
             executor,
             new FixedPointerProfileProvider(profile),
             repeatController,
-            pointerSpeedController);
+            pointerSpeedController,
+            switchControlSessions);
+    }
+
+    private sealed class BuiltInProfileStore : ISwitchControlProfileStore
+    {
+        public IReadOnlyList<SwitchControlProfile> Load() => SwitchControlProfiles.BuiltIns;
+        public IReadOnlyList<SwitchControlProfile> Save(IReadOnlyList<SwitchControlProfile> customProfiles) =>
+            [.. SwitchControlProfiles.BuiltIns, .. customProfiles];
     }
 
     private static PointerCapabilities TestPointerCapabilities()
diff --git a/src/SwitchifyPc.Tests/ProtocolConstantsTests.cs b/src/SwitchifyPc.Tests/ProtocolConstantsTests.cs
index 9a815a2..289e86c 100644
--- a/src/SwitchifyPc.Tests/ProtocolConstantsTests.cs
+++ b/src/SwitchifyPc.Tests/ProtocolConstantsTests.cs
@@ -63,6 +63,11 @@ public void IncludesCurrentCommandTypes()
             "window.control",
             "grid.switch.set",
             "grid.switch.sync",
+            "switch.profile.list",
+            "switch.session.start",
+            "switch.edge",
+            "switch.sync",
+            "switch.session.stop",
             "pointer.display.move",
             "pointer.profile",
             "pointer.speed.set",
@@ -87,6 +92,8 @@ public void StatefulControlCapabilitiesUseExpectedResponseModes()
         Assert.DoesNotContain("pointer.speed.set", ProtocolConstants.NoAckControlCommandTypes);
         Assert.Contains(ProtocolConstants.GridSwitchSetCommandType, ProtocolConstants.NoAckControlCommandTypes);
         Assert.DoesNotContain(ProtocolConstants.GridSwitchSyncCommandType, ProtocolConstants.NoAckControlCommandTypes);
+        Assert.Contains(ProtocolConstants.SwitchEdgeCommandType, ProtocolConstants.NoAckControlCommandTypes);
+        Assert.DoesNotContain(ProtocolConstants.SwitchSyncCommandType, ProtocolConstants.NoAckControlCommandTypes);
     }
 
     [Fact]
diff --git a/src/SwitchifyPc.Tests/ProtocolValidatorTests.cs b/src/SwitchifyPc.Tests/ProtocolValidatorTests.cs
index 0a3412d..e481fc1 100644
--- a/src/SwitchifyPc.Tests/ProtocolValidatorTests.cs
+++ b/src/SwitchifyPc.Tests/ProtocolValidatorTests.cs
@@ -64,6 +64,48 @@ public void AcceptsCurrentCommandPayloads()
                     pressedSwitchIds = new[] { 1, 8 }
                 }
             },
+            new { type = "switch.profile.list", payload = new { } },
+            new
+            {
+                type = "switch.session.start",
+                payload = new
+                {
+                    sessionId = "99a1dbcf-6be4-4c6c-8664-d33fd698e32b",
+                    profileId = "builtin.keyboard",
+                    profileVersion = 1,
+                    switchCount = 2
+                }
+            },
+            new
+            {
+                type = "switch.edge",
+                payload = new
+                {
+                    sessionId = "99a1dbcf-6be4-4c6c-8664-d33fd698e32b",
+                    sequence = 1,
+                    switchId = 1,
+                    state = "down"
+                }
+            },
+            new
+            {
+                type = "switch.sync",
+                payload = new
+                {
+                    sessionId = "99a1dbcf-6be4-4c6c-8664-d33fd698e32b",
+                    sequence = 2,
+                    pressedSwitchIds = new[] { 1, 2 }
+                }
+            },
+            new
+            {
+                type = "switch.session.stop",
+                payload = new
+                {
+                    sessionId = "99a1dbcf-6be4-4c6c-8664-d33fd698e32b",
+                    sequence = 3
+                }
+            },
             new { type = "pointer.profile", payload = new { } },
             new { type = "pointer.display.move", payload = new { direction = "left" } },
             new { type = "pointer.speed.set", payload = new { scalePercent = 125 } },
@@ -107,6 +149,13 @@ public void AcceptsNoResponseModeOnlyForUserControlCommands()
                 state = "down",
                 sessionId = "99a1dbcf-6be4-4c6c-8664-d33fd698e32b",
                 sequence = 1
+            },
+            ["switch.edge"] = new
+            {
+                sessionId = "99a1dbcf-6be4-4c6c-8664-d33fd698e32b",
+                sequence = 1,
+                switchId = 1,
+                state = "down"
             }
         };
 

From 9e39a6b42ea4232dc10faa821898239b5ff6f6b5 Mon Sep 17 00:00:00 2001
From: Owen McGirr <o.a.mcgirr@gmail.com>
Date: Mon, 27 Jul 2026 15:59:57 +0100
Subject: [PATCH 4/5] Harden switch profile output cleanup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Canonicalize stored key and shortcut tokens for Windows input
- Retain failed output cleanup state for deterministic retries
- Make binding values discoverable and focus invalid switch rows
- Add regression coverage for cleanup and normalization failures

🤖 Auto-generated
---
 .../SwitchControlSessionManager.cs            | 25 ++++++++++++++++---
 .../SwitchControlSessionManagerTests.cs       | 22 ++++++++++++++++
 2 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs b/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
index a47da84..2bd40d8 100644
--- a/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
+++ b/src/SwitchifyPc.Core/SwitchControl/SwitchControlSessionManager.cs
@@ -58,7 +58,16 @@ public async Task<SwitchSessionResult> StartAsync(
         await gate.WaitAsync(token).ConfigureAwait(false);
         try
         {
-            await StopLockedAsync(token).ConfigureAwait(false);
+            try
+            {
+                await StopLockedAsync(token).ConfigureAwait(false);
+            }
+            catch
+            {
+                return SwitchSessionResult.Failure(
+                    "output_failure",
+                    "The previous switch output could not be released.");
+            }
             ISwitchOutputSession output;
             try
             {
@@ -119,7 +128,6 @@ public async Task<SwitchSessionResult> StopAsync(
         }
         catch
         {
-            active = null;
             return SwitchSessionResult.Failure("output_failure", "The active switch output could not be released.");
         }
         finally
@@ -243,7 +251,16 @@ private async Task<SwitchSessionResult> EnsureLegacyGridSessionLockedAsync(
             return SwitchSessionResult.Success;
         }
 
-        await StopLockedAsync(token).ConfigureAwait(false);
+        try
+        {
+            await StopLockedAsync(token).ConfigureAwait(false);
+        }
+        catch
+        {
+            return SwitchSessionResult.Failure(
+                "output_failure",
+                "The previous switch output could not be released.");
+        }
         SwitchControlProfile profile = SwitchControlProfiles.BuiltIns[0];
         try
         {
@@ -286,10 +303,10 @@ private async Task<SwitchSessionResult> ExecuteActiveLockedAsync(
     private async Task StopLockedAsync(CancellationToken token)
     {
         ActiveSession? previous = active;
-        active = null;
         if (previous is not null)
         {
             await previous.Output.StopAsync(token).ConfigureAwait(false);
+            active = null;
             ActiveProfileChanged?.Invoke(null);
         }
     }
diff --git a/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs b/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs
index ac61473..88554dd 100644
--- a/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs
+++ b/src/SwitchifyPc.Tests/SwitchControlSessionManagerTests.cs
@@ -53,6 +53,26 @@ public async Task OutputFailureFaultsSessionAndDoesNotAdvanceSequence()
         Assert.Empty(output.Events);
     }
 
+    [Fact]
+    public async Task FailedStopKeepsSessionAvailableForCleanupRetry()
+    {
+        SwitchControlProfile profile = SwitchControlProfiles.BuiltIns[1];
+        var output = new RecordingOutputSession { FailStop = true };
+        var manager = Manager(profile, output);
+        string sessionId = Guid.NewGuid().ToString();
+        await manager.StartAsync("device", sessionId, profile.Id, profile.Version);
+
+        SwitchSessionResult failed = await manager.StopAsync("device", sessionId, 1);
+        Assert.True(manager.IsActive);
+        output.FailStop = false;
+        SwitchSessionResult retried = await manager.StopAsync("device", sessionId, 1);
+
+        Assert.Equal("output_failure", failed.Code);
+        Assert.False(manager.IsActive);
+        Assert.True(retried.Ok);
+        Assert.Equal(2, output.StopCount);
+    }
+
     private static SwitchControlSessionManager Manager(
         SwitchControlProfile profile,
         RecordingOutputSession output) =>
@@ -75,6 +95,7 @@ private sealed class RecordingOutputSession : ISwitchOutputSession
         public List<string> Events { get; } = [];
         public int StopCount { get; private set; }
         public bool Fail { get; set; }
+        public bool FailStop { get; set; }
 
         public Task ApplyEdgeAsync(int switchId, bool pressed, CancellationToken token)
         {
@@ -88,6 +109,7 @@ public Task ApplyEdgeAsync(int switchId, bool pressed, CancellationToken token)
         public Task StopAsync(CancellationToken token)
         {
             StopCount++;
+            if (FailStop) throw new InvalidOperationException();
             return Task.CompletedTask;
         }
     }

From e9fc9813bf53998f6629e5757437a3859cf802a1 Mon Sep 17 00:00:00 2001
From: enaboapps <60785457+enaboapps@users.noreply.github.com>
Date: Mon, 27 Jul 2026 18:53:31 +0100
Subject: [PATCH 5/5] Match switch control profile UI

---
 .../SwitchControlProfileWindow.xaml           | 593 +++++++++++++++---
 src/SwitchifyPc.Tests/ButtonStyleTests.cs     |  27 +
 .../SwitchControlProfileWindowTests.cs        | 139 ++++
 src/SwitchifyPc.Tests/ThemeXamlGuardTests.cs  |   1 +
 4 files changed, 661 insertions(+), 99 deletions(-)
 create mode 100644 src/SwitchifyPc.Tests/SwitchControlProfileWindowTests.cs

diff --git a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
index 7410107..0c9ea86 100644
--- a/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
+++ b/src/SwitchifyPc.App/SwitchControlProfileWindow.xaml
@@ -1,118 +1,513 @@
 <Window x:Class="SwitchifyPc.App.SwitchControlProfileWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:shell="clr-namespace:System.Windows.Shell;assembly=PresentationFramework"
+        xmlns:chrome="clr-namespace:SwitchifyPc.App.Chrome"
         Title="PC Switch Control profiles"
         Width="980"
-        Height="680"
-        MinWidth="820"
-        MinHeight="560"
-        WindowStartupLocation="CenterOwner">
-    <Grid Margin="20">
+        Height="720"
+        ResizeMode="NoResize"
+        WindowStartupLocation="CenterOwner"
+        Icon="Assets/icon.ico"
+        FontFamily="Segoe UI"
+        Background="{DynamicResource ChromeBackground}"
+        Foreground="{DynamicResource Text}"
+        WindowStyle="None">
+    <shell:WindowChrome.WindowChrome>
+        <shell:WindowChrome CaptionHeight="44"
+                            CornerRadius="0"
+                            GlassFrameThickness="0"
+                            ResizeBorderThickness="6"
+                            UseAeroCaptionButtons="False" />
+    </shell:WindowChrome.WindowChrome>
+
+    <Window.Resources>
+        <Style TargetType="Button">
+            <Setter Property="MinHeight" Value="38" />
+            <Setter Property="Padding" Value="14,0" />
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderColor}" />
+            <Setter Property="BorderThickness" Value="1" />
+            <Setter Property="Background" Value="{DynamicResource Surface}" />
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="FontWeight" Value="Bold" />
+            <Setter Property="Cursor" Value="Hand" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Root"
+                                MinHeight="{TemplateBinding MinHeight}"
+                                Padding="{TemplateBinding Padding}"
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="10">
+                            <ContentPresenter HorizontalAlignment="Center"
+                                              VerticalAlignment="Center"
+                                              RecognizesAccessKey="True" />
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Root" Property="BorderBrush" Value="{DynamicResource BrandPrimary}" />
+                                <Setter TargetName="Root" Property="Background" Value="{DynamicResource SurfaceMuted}" />
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Root" Property="Opacity" Value="0.55" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <Style x:Key="PrimaryButton" TargetType="Button">
+            <Setter Property="MinHeight" Value="38" />
+            <Setter Property="Padding" Value="14,0" />
+            <Setter Property="BorderBrush" Value="{DynamicResource BrandPrimary}" />
+            <Setter Property="BorderThickness" Value="1" />
+            <Setter Property="Background" Value="{DynamicResource BrandPrimary}" />
+            <Setter Property="Foreground" Value="{DynamicResource ChromeForeground}" />
+            <Setter Property="FontWeight" Value="Bold" />
+            <Setter Property="Cursor" Value="Hand" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Root"
+                                MinHeight="{TemplateBinding MinHeight}"
+                                Padding="{TemplateBinding Padding}"
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="10">
+                            <ContentPresenter HorizontalAlignment="Center"
+                                              VerticalAlignment="Center"
+                                              RecognizesAccessKey="True" />
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Root" Property="Background" Value="{DynamicResource BrandPrimaryHover}" />
+                                <Setter TargetName="Root" Property="BorderBrush" Value="{DynamicResource BrandPrimaryHover}" />
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Root" Property="Opacity" Value="0.55" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <Style x:Key="PanelBorder" TargetType="Border">
+            <Setter Property="Background" Value="{DynamicResource Surface}" />
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderColor}" />
+            <Setter Property="BorderThickness" Value="1" />
+            <Setter Property="CornerRadius" Value="12" />
+            <Setter Property="Padding" Value="18" />
+        </Style>
+
+        <Style x:Key="SectionTitle" TargetType="TextBlock">
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="FontSize" Value="17" />
+            <Setter Property="FontWeight" Value="Bold" />
+        </Style>
+
+        <Style x:Key="MutedText" TargetType="TextBlock">
+            <Setter Property="Foreground" Value="{DynamicResource TextMuted}" />
+            <Setter Property="FontSize" Value="13" />
+            <Setter Property="LineHeight" Value="19" />
+            <Setter Property="TextWrapping" Value="Wrap" />
+        </Style>
+
+        <Style x:Key="FieldLabel" TargetType="TextBlock">
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="FontSize" Value="13" />
+            <Setter Property="FontWeight" Value="Bold" />
+        </Style>
+
+        <Style TargetType="TextBox">
+            <Setter Property="MinHeight" Value="38" />
+            <Setter Property="Padding" Value="10,7" />
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="Background" Value="{DynamicResource Surface}" />
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderColor}" />
+            <Setter Property="BorderThickness" Value="1" />
+            <Setter Property="CaretBrush" Value="{DynamicResource Text}" />
+            <Style.Triggers>
+                <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                    <Setter Property="BorderBrush" Value="{DynamicResource BrandPrimary}" />
+                </Trigger>
+                <Trigger Property="IsEnabled" Value="False">
+                    <Setter Property="Background" Value="{DynamicResource SurfaceMuted}" />
+                    <Setter Property="Opacity" Value="0.72" />
+                </Trigger>
+            </Style.Triggers>
+        </Style>
+
+        <Style TargetType="ComboBox">
+            <Setter Property="MinHeight" Value="38" />
+            <Setter Property="Padding" Value="10,5" />
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="Background" Value="{DynamicResource Surface}" />
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderColor}" />
+            <Setter Property="BorderThickness" Value="1" />
+            <Setter Property="VerticalContentAlignment" Value="Center" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="ComboBox">
+                        <Grid SnapsToDevicePixels="True">
+                            <ToggleButton x:Name="DropDownToggle"
+                                          Focusable="False"
+                                          ClickMode="Press"
+                                          Background="{TemplateBinding Background}"
+                                          BorderBrush="{TemplateBinding BorderBrush}"
+                                          BorderThickness="{TemplateBinding BorderThickness}"
+                                          IsChecked="{Binding IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}">
+                                <ToggleButton.Template>
+                                    <ControlTemplate TargetType="ToggleButton">
+                                        <Border x:Name="ToggleBorder"
+                                                Background="{TemplateBinding Background}"
+                                                BorderBrush="{TemplateBinding BorderBrush}"
+                                                BorderThickness="{TemplateBinding BorderThickness}"
+                                                CornerRadius="8">
+                                            <Path Width="8"
+                                                  Height="5"
+                                                  Margin="0,0,12,0"
+                                                  HorizontalAlignment="Right"
+                                                  VerticalAlignment="Center"
+                                                  Data="M 0 0 L 4 4 L 8 0"
+                                                  Stroke="{DynamicResource TextMuted}"
+                                                  StrokeThickness="1.5" />
+                                        </Border>
+                                        <ControlTemplate.Triggers>
+                                            <Trigger Property="IsMouseOver" Value="True">
+                                                <Setter TargetName="ToggleBorder"
+                                                        Property="BorderBrush"
+                                                        Value="{DynamicResource BrandPrimary}" />
+                                            </Trigger>
+                                        </ControlTemplate.Triggers>
+                                    </ControlTemplate>
+                                </ToggleButton.Template>
+                            </ToggleButton>
+
+                            <ContentPresenter x:Name="SelectionContent"
+                                              Margin="10,0,36,0"
+                                              HorizontalAlignment="Left"
+                                              VerticalAlignment="Center"
+                                              IsHitTestVisible="False"
+                                              Content="{TemplateBinding SelectionBoxItem}"
+                                              ContentStringFormat="{TemplateBinding SelectionBoxItemStringFormat}"
+                                              ContentTemplate="{TemplateBinding SelectionBoxItemTemplate}"
+                                              TextElement.Foreground="{TemplateBinding Foreground}" />
+
+                            <TextBox x:Name="PART_EditableTextBox"
+                                     Margin="8,2,36,2"
+                                     Padding="2,0"
+                                     HorizontalContentAlignment="Left"
+                                     VerticalContentAlignment="Center"
+                                     Background="Transparent"
+                                     BorderThickness="0"
+                                     Foreground="{TemplateBinding Foreground}"
+                                     CaretBrush="{DynamicResource Text}"
+                                     IsReadOnly="{TemplateBinding IsReadOnly}"
+                                     Visibility="Hidden" />
+
+                            <Popup x:Name="PART_Popup"
+                                   AllowsTransparency="True"
+                                   Focusable="False"
+                                   IsOpen="{TemplateBinding IsDropDownOpen}"
+                                   Placement="Bottom"
+                                   PopupAnimation="Fade">
+                                <Border MinWidth="{TemplateBinding ActualWidth}"
+                                        MaxHeight="260"
+                                        Margin="0,3,0,0"
+                                        Padding="4"
+                                        Background="{DynamicResource Surface}"
+                                        BorderBrush="{DynamicResource BorderColor}"
+                                        BorderThickness="1"
+                                        CornerRadius="8">
+                                    <ScrollViewer CanContentScroll="True">
+                                        <ItemsPresenter KeyboardNavigation.DirectionalNavigation="Contained" />
+                                    </ScrollViewer>
+                                </Border>
+                            </Popup>
+                        </Grid>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsEditable" Value="True">
+                                <Setter TargetName="SelectionContent" Property="Visibility" Value="Hidden" />
+                                <Setter TargetName="PART_EditableTextBox" Property="Visibility" Value="Visible" />
+                            </Trigger>
+                            <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                                <Setter TargetName="DropDownToggle"
+                                        Property="BorderBrush"
+                                        Value="{DynamicResource BrandPrimary}" />
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="DropDownToggle"
+                                        Property="Background"
+                                        Value="{DynamicResource SurfaceMuted}" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+            <Style.Triggers>
+                <Trigger Property="IsEnabled" Value="False">
+                    <Setter Property="Background" Value="{DynamicResource SurfaceMuted}" />
+                    <Setter Property="Opacity" Value="0.72" />
+                </Trigger>
+            </Style.Triggers>
+        </Style>
+
+        <Style TargetType="ComboBoxItem">
+            <Setter Property="Padding" Value="10,7" />
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="Background" Value="{DynamicResource Surface}" />
+            <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="ComboBoxItem">
+                        <Border x:Name="ItemBorder"
+                                Padding="{TemplateBinding Padding}"
+                                Background="{TemplateBinding Background}"
+                                CornerRadius="6">
+                            <ContentPresenter />
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsHighlighted" Value="True">
+                                <Setter TargetName="ItemBorder"
+                                        Property="Background"
+                                        Value="{DynamicResource SurfaceMuted}" />
+                            </Trigger>
+                            <Trigger Property="IsSelected" Value="True">
+                                <Setter TargetName="ItemBorder"
+                                        Property="Background"
+                                        Value="{DynamicResource SegmentSelectedBackground}" />
+                                <Setter Property="Foreground" Value="{DynamicResource BrandPrimary}" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <Style TargetType="ListBox">
+            <Setter Property="Background" Value="Transparent" />
+            <Setter Property="BorderThickness" Value="0" />
+            <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled" />
+        </Style>
+
+        <Style TargetType="ListBoxItem">
+            <Setter Property="Margin" Value="0,0,0,4" />
+            <Setter Property="Padding" Value="10,8" />
+            <Setter Property="Foreground" Value="{DynamicResource Text}" />
+            <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+            <Setter Property="Cursor" Value="Hand" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="ListBoxItem">
+                        <Border x:Name="Root"
+                                Padding="{TemplateBinding Padding}"
+                                Background="Transparent"
+                                BorderBrush="Transparent"
+                                BorderThickness="1"
+                                CornerRadius="9">
+                            <ContentPresenter />
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Root" Property="Background" Value="{DynamicResource SurfaceMuted}" />
+                            </Trigger>
+                            <Trigger Property="IsSelected" Value="True">
+                                <Setter TargetName="Root" Property="Background" Value="{DynamicResource SegmentSelectedBackground}" />
+                                <Setter TargetName="Root" Property="BorderBrush" Value="{DynamicResource BrandPrimary}" />
+                                <Setter Property="Foreground" Value="{DynamicResource BrandPrimary}" />
+                                <Setter Property="FontWeight" Value="Bold" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <Style TargetType="ScrollBar">
+            <Setter Property="Width" Value="10" />
+            <Setter Property="MinWidth" Value="10" />
+        </Style>
+    </Window.Resources>
+
+    <Grid Background="{DynamicResource ChromeBackground}">
         <Grid.RowDefinitions>
+            <RowDefinition Height="44" />
             <RowDefinition Height="Auto" />
             <RowDefinition Height="*" />
-            <RowDefinition Height="Auto" />
         </Grid.RowDefinitions>
-        <StackPanel>
-            <TextBlock Text="PC Switch Control" FontSize="24" FontWeight="SemiBold" />
-            <TextBlock Margin="0,6,0,16"
+
+        <chrome:SwitchifyTitleBar Grid.Row="0"
+                                  TitleText="PC Switch Control profiles"
+                                  ShowMinimizeButton="True" />
+
+        <Border Grid.Row="1"
+                Grid.RowSpan="2"
+                Margin="0,80,0,0"
+                Background="{DynamicResource AppBackground}" />
+
+        <StackPanel Grid.Row="1" Margin="24,20,24,18">
+            <TextBlock Text="PC Switch Control"
+                       FontSize="18"
+                       FontWeight="Bold"
+                       Foreground="{DynamicResource ChromeForeground}" />
+            <TextBlock Margin="0,4,0,0"
                        Text="Create profiles that map up to eight physical switches to Windows input."
-                       TextWrapping="Wrap" />
+                       Foreground="{DynamicResource ChromeSubtleForeground}"
+                       Style="{StaticResource MutedText}" />
         </StackPanel>
-        <Grid Grid.Row="1">
+
+        <Grid Grid.Row="2" Margin="24,0,24,24">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="*" />
+                <RowDefinition Height="Auto" />
+            </Grid.RowDefinitions>
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="260" />
+                <ColumnDefinition Width="230" />
                 <ColumnDefinition Width="18" />
                 <ColumnDefinition Width="*" />
             </Grid.ColumnDefinitions>
-            <DockPanel>
-                <TextBlock DockPanel.Dock="Top"
-                           Margin="0,0,0,8"
-                           Text="Profiles"
-                           FontWeight="SemiBold" />
-                <ListBox x:Name="ProfilesList"
-                         SelectionChanged="ProfilesList_SelectionChanged"
-                         AutomationProperties.Name="Switch control profiles"
-                         DisplayMemberPath="Name" />
-            </DockPanel>
-            <ScrollViewer Grid.Column="2" VerticalScrollBarVisibility="Auto">
-                <StackPanel>
-                    <TextBlock Text="Profile name" FontWeight="SemiBold" />
-                    <TextBox x:Name="ProfileName"
-                             Margin="0,6,0,4"
-                             MaxLength="50"
-                             AutomationProperties.Name="Profile name" />
-                    <TextBlock x:Name="ReadOnlyMessage"
-                               Margin="0,0,0,12"
-                               TextWrapping="Wrap" />
-                    <TextBlock Text="Switch bindings" FontWeight="SemiBold" />
-                    <TextBlock Margin="0,4,0,12"
-                               Text="Choose a suggested value or type one. Each switch row explains the accepted values for its selected action."
-                               TextWrapping="Wrap" />
-                    <ItemsControl x:Name="BindingRows">
-                        <ItemsControl.ItemTemplate>
-                            <DataTemplate>
-                                <Grid Margin="0,0,0,10">
-                                    <Grid.RowDefinitions>
-                                        <RowDefinition Height="Auto" />
-                                        <RowDefinition Height="Auto" />
-                                    </Grid.RowDefinitions>
-                                    <Grid.ColumnDefinitions>
-                                        <ColumnDefinition Width="90" />
-                                        <ColumnDefinition Width="180" />
-                                        <ColumnDefinition Width="*" />
-                                    </Grid.ColumnDefinitions>
-                                    <TextBlock VerticalAlignment="Center"
-                                               Text="{Binding SwitchLabel}"
-                                               FontWeight="SemiBold" />
-                                    <ComboBox Grid.Column="1"
-                                              Margin="0,0,10,0"
-                                              ItemsSource="{Binding Types}"
-                                              SelectedItem="{Binding SelectedType, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
-                                              IsEnabled="{Binding IsEditable}"
-                                              AutomationProperties.Name="{Binding TypeAutomationName}" />
-                                    <ComboBox x:Name="BindingValueInput"
-                                              Grid.Column="2"
-                                              ItemsSource="{Binding ValueOptions}"
-                                              Text="{Binding Value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
-                                              IsEditable="True"
-                                              IsTextSearchEnabled="True"
-                                              IsEnabled="{Binding IsEditable}"
-                                              AutomationProperties.Name="{Binding ValueAutomationName}"
-                                              AutomationProperties.HelpText="{Binding ValueHelp}" />
-                                    <TextBlock Grid.Row="1"
-                                               Grid.Column="1"
-                                               Grid.ColumnSpan="2"
-                                               Margin="0,4,0,0"
-                                               Text="{Binding ValueHelp}"
-                                               TextWrapping="Wrap"
-                                               Foreground="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                                </Grid>
-                            </DataTemplate>
-                        </ItemsControl.ItemTemplate>
-                    </ItemsControl>
-                    <TextBlock x:Name="ValidationMessage"
-                               Foreground="DarkRed"
-                               TextWrapping="Wrap"
-                               AutomationProperties.LiveSetting="Assertive" />
+
+            <Border Grid.Row="0"
+                    Grid.Column="0"
+                    Style="{StaticResource PanelBorder}"
+                    Padding="12">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                    </Grid.RowDefinitions>
+                    <TextBlock Margin="6,2,6,10"
+                               Text="Profiles"
+                               Style="{StaticResource SectionTitle}" />
+                    <ListBox x:Name="ProfilesList"
+                             Grid.Row="1"
+                             SelectionChanged="ProfilesList_SelectionChanged"
+                             AutomationProperties.Name="Switch control profiles"
+                             DisplayMemberPath="Name" />
+                </Grid>
+            </Border>
+
+            <Border Grid.Row="0"
+                    Grid.Column="2"
+                    Style="{StaticResource PanelBorder}">
+                <ScrollViewer HorizontalScrollBarVisibility="Disabled"
+                              VerticalScrollBarVisibility="Auto">
+                    <StackPanel Margin="0,0,8,0">
+                        <TextBlock Text="Profile details" Style="{StaticResource SectionTitle}" />
+                        <TextBlock Margin="0,6,0,16"
+                                   Text="Name the profile and choose what each connected switch should do."
+                                   Style="{StaticResource MutedText}" />
+
+                        <TextBlock Text="Profile name" Style="{StaticResource FieldLabel}" />
+                        <TextBox x:Name="ProfileName"
+                                 Margin="0,6,0,0"
+                                 MaxLength="50"
+                                 AutomationProperties.Name="Profile name" />
+                        <TextBlock x:Name="ReadOnlyMessage"
+                                   Margin="0,7,0,18"
+                                   Style="{StaticResource MutedText}" />
+
+                        <TextBlock Text="Switch bindings" Style="{StaticResource SectionTitle}" />
+                        <TextBlock Margin="0,6,0,4"
+                                   Text="Choose a suggested value or type one. Each row explains the accepted values for its selected action."
+                                   Style="{StaticResource MutedText}" />
+
+                        <ItemsControl x:Name="BindingRows">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate>
+                                    <Border Padding="0,12"
+                                            BorderBrush="{DynamicResource BorderColor}"
+                                            BorderThickness="0,0,0,1">
+                                        <Grid>
+                                            <Grid.RowDefinitions>
+                                                <RowDefinition Height="Auto" />
+                                                <RowDefinition Height="Auto" />
+                                            </Grid.RowDefinitions>
+                                            <Grid.ColumnDefinitions>
+                                                <ColumnDefinition Width="82" />
+                                                <ColumnDefinition Width="170" />
+                                                <ColumnDefinition Width="*" />
+                                            </Grid.ColumnDefinitions>
+                                            <TextBlock VerticalAlignment="Center"
+                                                       Text="{Binding SwitchLabel}"
+                                                       Style="{StaticResource FieldLabel}" />
+                                            <ComboBox Grid.Column="1"
+                                                      Margin="0,0,10,0"
+                                                      ItemsSource="{Binding Types}"
+                                                      SelectedItem="{Binding SelectedType, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                                                      IsEnabled="{Binding IsEditable}"
+                                                      AutomationProperties.Name="{Binding TypeAutomationName}" />
+                                            <ComboBox x:Name="BindingValueInput"
+                                                      Grid.Column="2"
+                                                      ItemsSource="{Binding ValueOptions}"
+                                                      Text="{Binding Value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                                                      IsEditable="True"
+                                                      IsTextSearchEnabled="True"
+                                                      IsEnabled="{Binding IsEditable}"
+                                                      AutomationProperties.Name="{Binding ValueAutomationName}"
+                                                      AutomationProperties.HelpText="{Binding ValueHelp}" />
+                                            <TextBlock Grid.Row="1"
+                                                       Grid.Column="1"
+                                                       Grid.ColumnSpan="2"
+                                                       Margin="0,5,0,0"
+                                                       Text="{Binding ValueHelp}"
+                                                       Style="{StaticResource MutedText}" />
+                                        </Grid>
+                                    </Border>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+
+                        <TextBlock x:Name="ValidationMessage"
+                                   Margin="0,12,0,0"
+                                   Foreground="{DynamicResource StatusError}"
+                                   FontWeight="SemiBold"
+                                   TextWrapping="Wrap"
+                                   AutomationProperties.LiveSetting="Assertive" />
+                    </StackPanel>
+                </ScrollViewer>
+            </Border>
+
+            <Grid Grid.Row="1"
+                  Grid.Column="0"
+                  Grid.ColumnSpan="3"
+                  Margin="0,14,0,0">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="*" />
+                    <ColumnDefinition Width="Auto" />
+                </Grid.ColumnDefinitions>
+                <StackPanel Orientation="Horizontal">
+                    <Button Content="New" MinWidth="84" Click="New_Click" />
+                    <Button Margin="8,0,0,0" Content="Duplicate" MinWidth="84" Click="Duplicate_Click" />
+                    <Button x:Name="DeleteButton"
+                            Margin="8,0,0,0"
+                            Content="Delete"
+                            MinWidth="84"
+                            Click="Delete_Click" />
                 </StackPanel>
-            </ScrollViewer>
-        </Grid>
-        <Grid Grid.Row="2" Margin="0,18,0,0">
-            <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="*" />
-                <ColumnDefinition Width="Auto" />
-            </Grid.ColumnDefinitions>
-            <StackPanel Orientation="Horizontal">
-                <Button Content="New" MinWidth="84" Click="New_Click" />
-                <Button Margin="8,0,0,0" Content="Duplicate" MinWidth="84" Click="Duplicate_Click" />
-                <Button x:Name="DeleteButton" Margin="8,0,0,0" Content="Delete" MinWidth="84" Click="Delete_Click" />
-            </StackPanel>
-            <StackPanel Grid.Column="1" Orientation="Horizontal">
-                <Button x:Name="CancelButton" Content="Cancel changes" MinWidth="110" Click="Cancel_Click" />
-                <Button x:Name="SaveButton" Margin="8,0,0,0" Content="Save" MinWidth="84" Click="Save_Click" />
-                <Button Margin="8,0,0,0" Content="Close" MinWidth="84" IsCancel="True" Click="Close_Click" />
-            </StackPanel>
+                <StackPanel Grid.Column="1" Orientation="Horizontal">
+                    <Button x:Name="CancelButton"
+                            Content="Cancel changes"
+                            MinWidth="110"
+                            Click="Cancel_Click" />
+                    <Button x:Name="SaveButton"
+                            Margin="8,0,0,0"
+                            Content="Save"
+                            MinWidth="84"
+                            Style="{StaticResource PrimaryButton}"
+                            Click="Save_Click" />
+                    <Button Margin="8,0,0,0"
+                            Content="Close"
+                            MinWidth="84"
+                            IsCancel="True"
+                            Click="Close_Click" />
+                </StackPanel>
+            </Grid>
         </Grid>
     </Grid>
 </Window>
diff --git a/src/SwitchifyPc.Tests/ButtonStyleTests.cs b/src/SwitchifyPc.Tests/ButtonStyleTests.cs
index 0eb40fc..3e47f0a 100644
--- a/src/SwitchifyPc.Tests/ButtonStyleTests.cs
+++ b/src/SwitchifyPc.Tests/ButtonStyleTests.cs
@@ -2,6 +2,7 @@
 using System.Windows;
 using System.Windows.Media;
 using SwitchifyPc.App;
+using SwitchifyPc.Core.SwitchControl;
 using WpfBorder = System.Windows.Controls.Border;
 using WpfControl = System.Windows.Controls.Control;
 using WpfControlTemplate = System.Windows.Controls.ControlTemplate;
@@ -47,6 +48,24 @@ public void SettingsWindowPrimaryButtonStyleUsesRedHoverBrush()
         });
     }
 
+    [Fact]
+    public void ProfileWindowPrimaryButtonStyleUsesRedHoverBrush()
+    {
+        RunOnSta(() =>
+        {
+            WpfTestApplication.ApplyTheme(SwitchifyPc.App.Themes.AppTheme.Light);
+            SwitchControlProfileWindow window = new(new StaticProfileStore(), () => null);
+            try
+            {
+                AssertPrimaryButtonStyleUsesRedHoverBrush(window);
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
+
     private static void AssertPrimaryButtonStyleUsesRedHoverBrush(FrameworkElement element)
     {
         Style style = Assert.IsType<Style>(element.FindResource("PrimaryButton"));
@@ -94,4 +113,12 @@ private static void RunOnSta(Action action)
 
         if (exception is not null) throw exception;
     }
+
+    private sealed class StaticProfileStore : ISwitchControlProfileStore
+    {
+        public IReadOnlyList<SwitchControlProfile> Load() => SwitchControlProfiles.BuiltIns;
+
+        public IReadOnlyList<SwitchControlProfile> Save(IReadOnlyList<SwitchControlProfile> customProfiles) =>
+            [.. SwitchControlProfiles.BuiltIns, .. customProfiles];
+    }
 }
diff --git a/src/SwitchifyPc.Tests/SwitchControlProfileWindowTests.cs b/src/SwitchifyPc.Tests/SwitchControlProfileWindowTests.cs
new file mode 100644
index 0000000..0dca07d
--- /dev/null
+++ b/src/SwitchifyPc.Tests/SwitchControlProfileWindowTests.cs
@@ -0,0 +1,139 @@
+using System.Threading;
+using System.Windows;
+using System.Windows.Automation;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Shell;
+using SwitchifyPc.App;
+using SwitchifyPc.App.Themes;
+using SwitchifyPc.Core.SwitchControl;
+using WpfButton = System.Windows.Controls.Button;
+using WpfColor = System.Windows.Media.Color;
+
+namespace SwitchifyPc.Tests;
+
+[Collection(WpfTestCollection.Name)]
+public sealed class SwitchControlProfileWindowTests
+{
+    [Fact]
+    public void ProfileWindowUsesSwitchifyChromeAndFixedLayout()
+    {
+        RunOnSta(() =>
+        {
+            WpfTestApplication.ApplyTheme(AppTheme.Light);
+            SwitchControlProfileWindow window = CreateWindow();
+            try
+            {
+                window.Show();
+                window.UpdateLayout();
+
+                Assert.Equal(WindowStyle.None, window.WindowStyle);
+                Assert.Equal(ResizeMode.NoResize, window.ResizeMode);
+                Assert.Equal(980, window.Width);
+                Assert.Equal(720, window.Height);
+                Assert.NotNull(WindowChrome.GetWindowChrome(window));
+                Assert.Contains("PC Switch Control profiles", TextBlocks(window));
+                Assert.NotNull(ButtonByAutomationName(window, "Minimize"));
+                Assert.NotNull(ButtonByAutomationName(window, "Close"));
+
+                WpfButton save = Assert.IsType<WpfButton>(window.FindName("SaveButton"));
+                Assert.Same(window.FindResource("PrimaryButton"), save.Style);
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
+
+    [Fact]
+    public void ProfileWindowLoadsWithDarkTheme()
+    {
+        RunOnSta(() =>
+        {
+            WpfTestApplication.ApplyTheme(AppTheme.Dark);
+            SwitchControlProfileWindow window = CreateWindow();
+            try
+            {
+                window.Show();
+                window.UpdateLayout();
+
+                SolidColorBrush appBackground = Assert.IsType<SolidColorBrush>(window.FindResource("AppBackground"));
+                Assert.Equal(WpfColor.FromRgb(0x14, 0x13, 0x18), appBackground.Color);
+                Assert.Contains("Profile details", TextBlocks(window));
+                Assert.Contains("Switch bindings", TextBlocks(window));
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
+
+    private static SwitchControlProfileWindow CreateWindow() =>
+        new(new StaticProfileStore(), () => null);
+
+    private static void RunOnSta(Action action)
+    {
+        Exception? exception = null;
+        Thread thread = new(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception error)
+            {
+                exception = error;
+            }
+        });
+
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (exception is not null) throw exception;
+    }
+
+    private static IReadOnlyList<string> TextBlocks(DependencyObject root)
+    {
+        List<string> text = [];
+        Collect(root, node =>
+        {
+            if (node is TextBlock textBlock) text.Add(textBlock.Text);
+        });
+        return text;
+    }
+
+    private static WpfButton? ButtonByAutomationName(DependencyObject root, string name)
+    {
+        WpfButton? result = null;
+        Collect(root, node =>
+        {
+            if (result is null &&
+                node is WpfButton button &&
+                AutomationProperties.GetName(button) == name)
+            {
+                result = button;
+            }
+        });
+        return result;
+    }
+
+    private static void Collect(DependencyObject node, Action<DependencyObject> visit)
+    {
+        visit(node);
+        for (int index = 0; index < VisualTreeHelper.GetChildrenCount(node); index++)
+        {
+            Collect(VisualTreeHelper.GetChild(node, index), visit);
+        }
+    }
+
+    private sealed class StaticProfileStore : ISwitchControlProfileStore
+    {
+        public IReadOnlyList<SwitchControlProfile> Load() => SwitchControlProfiles.BuiltIns;
+
+        public IReadOnlyList<SwitchControlProfile> Save(IReadOnlyList<SwitchControlProfile> customProfiles) =>
+            [.. SwitchControlProfiles.BuiltIns, .. customProfiles];
+    }
+}
diff --git a/src/SwitchifyPc.Tests/ThemeXamlGuardTests.cs b/src/SwitchifyPc.Tests/ThemeXamlGuardTests.cs
index b9c469c..cd3ce9f 100644
--- a/src/SwitchifyPc.Tests/ThemeXamlGuardTests.cs
+++ b/src/SwitchifyPc.Tests/ThemeXamlGuardTests.cs
@@ -15,6 +15,7 @@ public sealed class ThemeXamlGuardTests
     [Theory]
     [InlineData("src/SwitchifyPc.App/MainWindow.xaml")]
     [InlineData("src/SwitchifyPc.App/SettingsWindow.xaml")]
+    [InlineData("src/SwitchifyPc.App/SwitchControlProfileWindow.xaml")]
     [InlineData("src/SwitchifyPc.App/Chrome/SwitchifyTitleBar.xaml")]
     public void ThemedXamlDoesNotReintroduceHardCodedLightThemeColors(string path)
     {