fusuma-plugin-remap 0.11.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eb6be3cd4ee3e56a0fa412b29381e336c0b25207ca42d716a8a124cf907a5f8
-  data.tar.gz: d3b19a185e0cc03b7abcb00be6a8d7f63340827dafd1136adc941671457b2a80
+  metadata.gz: ac440e4e38328075243e062af637b5bd00aa71a9d5afe32cc68d39a1410d2bc9
+  data.tar.gz: c629dc8add177f2a69e4cc6901a499633028458e4ccaf3ce9dd04563011b3960
 SHA512:
-  metadata.gz: 593c365c6ef1ffc67a3865e188baeb8c59fa69a37aaaa3f75bad64b251d77d9abd9f914f2b90739f59dffc40b94dbb29c50fb894b8a524ba5820980ba364d8e6
-  data.tar.gz: 4cbd18fda7bfa3a05622f82cb4d558e7d00ea4b6d1a97c7c6617003eec64e1b6cb6caabd3fcfff91ef9c6c5c957b7681004c4a234f5c3a5e75a6878ba05526ca
+  metadata.gz: 257834827d4e8a1c05eeb5f52d2c1c803e32f2617d699373208cb41513d54abaa01937468087fb9b382ff67b76ebdde9bbb2a14ae9c8c89a3ea8d37259c1bde7
+  data.tar.gz: e8f5b3f9ab09e6c2575c747ed7a9f2abf52e85ad685974ddf7aa95f07f1f8ade8f594ba303f2cf0bb18dce4da6d4c64f82e78f3f9d8df32aea41214f4b011d49

data/README.md

@@ -41,20 +41,83 @@ $ sudo gem install fusuma-plugin-remap
 
 ### Remap
 
-Currently, remapping is only possible in the thumbsense context.
-Please install [fusuma-plugin-thumbsense](https://github.com/iberianpig/fusuma-plugin-thumbsense)
+You can remap keys in `~/.config/fusuma/config.yml`. The `remap` section defines key remappings.
 
-First, add the 'thumbsense' context to `~/.config/fusuma/config.yml`.
-The context is separated by `---` and specified by `context: { thumbsense: true }`.
+#### Basic Remap
 
-### Example
+Simple key-to-key remapping without any context:
 
-Set the following code in `~/.config/fusuma/config.yml`.
+```yaml
+remap:
+  CAPSLOCK: LEFTCTRL
+  LEFTALT: LEFTMETA
+  LEFTMETA: LEFTALT
+```
+
+#### Key Alias for Modifiers
+
+When a simple key remap is defined (e.g., `CAPSLOCK: LEFTCTRL`), the key acts as an **alias** for the target modifier. The modifier state tracks the remapped key, not the physical key.
+
+```yaml
+remap:
+  CAPSLOCK: LEFTCTRL  # CAPSLOCK acts as LEFTCTRL alias
+  LEFTCTRL+LEFTSHIFT+J: LEFTMETA+LEFTCTRL+DOWN  # Combination using the alias
+```
+
+With this configuration:
+- Physical `CAPSLOCK` is treated as `LEFTCTRL`
+- Physical `CAPSLOCK+LEFTSHIFT+J` triggers `LEFTCTRL+LEFTSHIFT+J` combination
+- This outputs `LEFTMETA+LEFTCTRL+DOWN`
+
+#### Output Sequence
+
+You can send multiple key combinations in sequence using an array:
+
+```yaml
+remap:
+  LEFTCTRL+U: [LEFTSHIFT+HOME, DELETE]  # Select to line start, then delete
+  LEFTCTRL+K: [LEFTSHIFT+END, DELETE]   # Select to line end, then delete
+```
+
+#### Modifier + Key Combinations
+
+Remap modifier key combinations to other keys or combinations:
+
+```yaml
+remap:
+  LEFTCTRL+J: DOWN
+  LEFTCTRL+K: UP
+  LEFTCTRL+H: LEFT
+  LEFTCTRL+L: RIGHT
+  LEFTALT+N: LEFTCTRL+TAB           # Next tab
+  LEFTALT+P: LEFTCTRL+LEFTSHIFT+TAB # Previous tab
+```
+
+### Context
+
+You can define different remappings for different contexts. Contexts are separated by `---`.
+
+#### Application Context
+
+Remap keys only for specific applications:
 
 ```yaml
+---
+context:
+  application: Alacritty
 
+remap:
+  LEFTMETA+N: LEFTCTRL+LEFTSHIFT+T  # New tab in terminal
+  LEFTMETA+W: LEFTCTRL+LEFTSHIFT+W  # Close tab
+```
+
+#### Thumbsense Context
+
+For thumbsense mode, install [fusuma-plugin-thumbsense](https://github.com/iberianpig/fusuma-plugin-thumbsense):
+
+```yaml
 ---
-context: 
+context:
   thumbsense: true
 
 remap:
@@ -65,6 +128,78 @@ remap:
   SPACE: BTN_LEFT
 ```
 
+#### Device Context
+
+You can define different remappings for specific keyboard devices. The `device` pattern uses case-insensitive partial matching against the physical device name.
+
+```yaml
+---
+# HHKB-specific remappings (matches device names containing "HHKB")
+context:
+  device: HHKB
+
+remap:
+  LEFTCTRL: LEFTMETA  # Swap Ctrl to Meta on HHKB
+
+---
+# Built-in keyboard remappings (matches "AT Translated Set 2 keyboard")
+context:
+  device: AT Translated
+
+remap:
+  LEFTALT: LEFTCTRL   # Remap Alt to Ctrl on built-in keyboard
+```
+
+To find your keyboard's device name, run:
+```sh
+libinput list-devices
+```
+
+#### Combined Contexts
+
+You can combine multiple context conditions. When multiple contexts are active, mappings are merged with priority order: `device` < `thumbsense` < `application`.
+
+```yaml
+---
+# HHKB + Thumbsense mode
+context:
+  device: HHKB
+  thumbsense: true
+
+remap:
+  J: BTN_LEFT
+  K: BTN_RIGHT
+```
+
+### Complete Example
+
+```yaml
+# Default remappings (always active)
+remap:
+  CAPSLOCK: LEFTCTRL
+  LEFTALT: LEFTMETA
+  LEFTMETA: LEFTALT
+  LEFTCTRL+J: DOWN
+  LEFTCTRL+K: UP
+
+---
+# Application-specific remappings
+context:
+  application: Alacritty
+
+remap:
+  LEFTMETA+N: LEFTCTRL+LEFTSHIFT+T
+
+---
+# Thumbsense mode
+context:
+  thumbsense: true
+
+remap:
+  J: BTN_LEFT
+  K: BTN_RIGHT
+```
+
 ## Emergency Stop Keybind for Virtual Keyboard
 
 This plugin includes a special keybind for emergency stop. Pressing this key combination will ungrab the physical keyboard and terminate the Fusuma process. This feature is particularly useful in situations where the plugin or system becomes unresponsive.

data/fusuma-plugin-remap.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
   # support focal (20.04LTS) 2.7
 
-  spec.add_dependency "fusuma", ">= 3.4"
+  spec.add_dependency "fusuma", ">= 3.11.0"
   spec.add_dependency "fusuma-plugin-keypress", ">= 0.11.0"
   spec.add_dependency "fusuma-plugin-sendkey", ">= 0.12.0"
   spec.add_dependency "msgpack"

data/lib/fusuma/plugin/inputs/remap_touchpad_input.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../remap/touchpad_remapper"
+require_relative "../remap/device_selector"
 
 module Fusuma
   module Plugin
@@ -46,51 +47,37 @@ module Fusuma
         private
 
         def setup_remapper
-          source_touchpads = TouchpadSelector.new(config_params(:touchpad_name_patterns)).select
-          if source_touchpads.empty?
-            MultiLogger.error("No touchpad found: #{config_params(:touchpad_name_patterns)}")
-            exit
-          end
-
-          MultiLogger.info("set up remapper")
-          MultiLogger.info("touchpad: #{source_touchpads}")
-
           # layer_manager = Remap::LayerManager.instance
 
           # physical touchpad input event
           @fusuma_reader, fusuma_writer = IO.pipe
+          touchpad_name_patterns = config_params(:touchpad_name_patterns)
 
           fork do
             # layer_manager.writer.close
             @fusuma_reader.close
+
+            # DeviceSelector waits until touchpad is found (like KeyboardSelector)
+            # NOTE: This must be inside fork to avoid blocking the main Fusuma process
+            source_touchpads = Remap::DeviceSelector.new(
+              name_patterns: touchpad_name_patterns,
+              device_type: :touchpad
+            ).select(wait: true)
+
+            MultiLogger.info("set up remapper")
+            MultiLogger.info("touchpad: #{source_touchpads}")
+
             remapper = Remap::TouchpadRemapper.new(
               # layer_manager: layer_manager,
               fusuma_writer: fusuma_writer,
-              source_touchpads: source_touchpads
+              source_touchpads: source_touchpads,
+              touchpad_name_patterns: touchpad_name_patterns
             )
             remapper.run
           end
           # layer_manager.reader.close
           fusuma_writer.close
         end
-
-        class TouchpadSelector
-          def initialize(names = nil)
-            @names = names
-          end
-
-          # @return [Array<Revdev::EventDevice>]
-          def select
-            devices = if @names
-              Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
-            else
-              # available returns only touchpad devices
-              Fusuma::Device.available
-            end
-
-            devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
-          end
-        end
       end
     end
   end

data/lib/fusuma/plugin/remap/device_matcher.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "fusuma/config"
+
+module Fusuma
+  module Plugin
+    module Remap
+      # Matches device names against device patterns defined in config
+      class DeviceMatcher
+        def initialize
+          @patterns = nil
+        end
+
+        # Find matching device pattern for a device name
+        # @param device_name [String] physical device name (e.g., "PFU HHKB-Hybrid")
+        # @return [String, nil] matched pattern (e.g., "HHKB"), or nil if no match
+        def match(device_name)
+          return nil if device_name.nil?
+
+          patterns.find { |pattern| device_name =~ /#{pattern}/i }
+        end
+
+        private
+
+        # Collect device patterns from config (cached)
+        # @return [Array<String>] device patterns (e.g., ["HHKB", "AT Translated"])
+        def patterns
+          @patterns ||= collect_patterns
+        end
+
+        # Collect unique device patterns from all context sections in keymap
+        def collect_patterns
+          keymap = Config.instance.keymap
+          return [] unless keymap.is_a?(Array)
+
+          keymap.filter_map { |section| section.dig(:context, :device) }.uniq
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/remap/device_selector.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "revdev"
+require "fusuma/device"
+
+module Fusuma
+  module Plugin
+    module Remap
+      # Common device selector for touchpad and keyboard detection
+      # Unifies TouchpadSelector implementations across the codebase
+      class DeviceSelector
+        POLL_INTERVAL = 3 # seconds
+
+        # @param name_patterns [Array, String, nil] patterns for device names
+        # @param device_type [Symbol] :touchpad or :keyboard (for logging)
+        def initialize(name_patterns: nil, device_type: :touchpad)
+          @name_patterns = name_patterns
+          @device_type = device_type
+          @displayed_waiting = false
+        end
+
+        # Select devices that match the name patterns
+        # @param wait [Boolean] if true, wait until device is found (polling loop)
+        # @return [Array<Revdev::EventDevice>]
+        def select(wait: false)
+          loop do
+            Fusuma::Device.reset # reset cache to get the latest device information
+            devices = find_devices
+            return to_event_devices(devices) unless devices.empty?
+            return [] unless wait
+
+            log_waiting_message unless @displayed_waiting
+            sleep POLL_INTERVAL
+          end
+        end
+
+        private
+
+        def find_devices
+          if @name_patterns
+            Fusuma::Device.all.select { |d|
+              Array(@name_patterns).any? { |name| d.name =~ /#{name}/ }
+            }
+          else
+            # available returns only touchpad devices
+            Fusuma::Device.available
+          end
+        end
+
+        def to_event_devices(devices)
+          devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+        end
+
+        def log_waiting_message
+          MultiLogger.warn "No #{@device_type} found: #{@name_patterns || "(default patterns)"}"
+          MultiLogger.warn "Waiting for #{@device_type} to be connected..."
+          @displayed_waiting = true
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/remap/keyboard_remapper.rb

@@ -3,6 +3,9 @@ require "msgpack"
 require "set"
 require_relative "layer_manager"
 require_relative "uinput_keyboard"
+require_relative "device_selector"
+require_relative "device_matcher"
+require_relative "modifier_state"
 require "fusuma/device"
 
 module Fusuma
@@ -13,6 +16,7 @@ module Fusuma
 
         VIRTUAL_KEYBOARD_NAME = "fusuma_virtual_keyboard"
         DEFAULT_EMERGENCY_KEYBIND = "RIGHTCTRL+LEFTCTRL".freeze
+        DEVICE_CHECK_INTERVAL = 3 # seconds - interval for checking new devices
 
         # Key conversion tables for better performance and readability
         KEYMAP = Revdev.constants.select { |c| c.start_with?("KEY_", "BTN_") }
@@ -29,20 +33,44 @@ module Fusuma
           @layer_manager = layer_manager # request to change layer
           @fusuma_writer = fusuma_writer # write event to original keyboard
           @config = config
+          @device_matcher = DeviceMatcher.new
+          @device_mappings = {}
         end
 
         def run
           create_virtual_keyboard
           @source_keyboards = reload_keyboards
 
+          # Manage modifier key states
+          @modifier_state = ModifierState.new
+
           old_ie = nil
           layer = nil
-          next_mapping = nil
           current_mapping = {}
 
           loop do
-            ios = IO.select([*@source_keyboards.map(&:file), @layer_manager.reader])
-            io = ios.first.first
+            ios = IO.select(
+              [*@source_keyboards.map(&:file), @layer_manager.reader],
+              nil,
+              nil,
+              DEVICE_CHECK_INTERVAL
+            )
+
+            # Timeout - check for new devices
+            if ios.nil?
+              check_and_add_new_devices
+              next
+            end
+
+            readable_ios = ios.first
+
+            # Prioritize layer changes over keyboard events to ensure
+            # layer state is updated before processing key inputs
+            io = if readable_ios.include?(@layer_manager.reader)
+              @layer_manager.reader
+            else
+              readable_ios.first
+            end
 
             if io == @layer_manager.reader
               layer = @layer_manager.receive_layer # update @current_layer
@@ -50,24 +78,40 @@ module Fusuma
                 next
               end
 
-              next_mapping = @layer_manager.find_mapping(layer)
+              # Clear device mapping cache when layer changes
+              @device_mappings = {}
+              @layer_changed = true
               next
             end
 
-            if next_mapping && virtual_keyboard_all_key_released?
-              if current_mapping != next_mapping
-                current_mapping = next_mapping
-              end
-              next_mapping = nil
+            source_keyboard = @source_keyboards.find { |kbd| kbd.file == io }
+            input_event = source_keyboard.read_input_event
+            current_device_name = source_keyboard.device_name
+
+            # Get device-specific mapping
+            device_mapping = get_mapping_for_device(current_device_name, layer || {})
+
+            # Wait until all virtual keys are released before applying new mapping
+            if @layer_changed && virtual_keyboard_all_key_released?
+              @layer_changed = false
             end
 
-            input_event = @source_keyboards.find { |kbd| kbd.file == io }.read_input_event
+            # Use device-specific mapping (wait during layer change to prevent key stuck)
+            current_mapping = @layer_changed ? current_mapping : device_mapping
+
             input_key = code_to_key(input_event.code)
 
+            # Apply simple key-to-key remapping first (modmap-style)
+            # e.g., CAPSLOCK -> LEFTCTRL, so modifier state tracks the remapped key
+            effective_key = apply_simple_remap(current_mapping, input_key)
+
             if input_event.type == EV_KEY
               @emergency_stop.call(old_ie, input_event)
 
               old_ie = input_event
+
+              @modifier_state.update(effective_key, input_event.value)
+
               if input_event.value != 2 # repeat
                 data = {key: input_key, status: input_event.value, layer: layer}
                 begin
@@ -80,28 +124,60 @@ module Fusuma
               end
             end
 
-            remapped = current_mapping.fetch(input_key.to_sym, nil)
+            remapped, is_modifier_remap = find_remapping(current_mapping, effective_key)
             case remapped
             when String, Symbol
-              # Remapped to another key - continue processing below
+              # Continue to key output processing below
+            when Array
+              # Output sequence: e.g., [LEFTSHIFT+HOME, DELETE]
+              if input_event.value == 1
+                execute_modifier_remap(remapped, input_event)
+              end
+              next
             when Hash
               # Command execution (e.g., {:SENDKEY=>"LEFTCTRL+BTN_LEFT", :CLEARMODIFIERS=>true})
               # Skip input event processing and let Fusuma's Executor handle this
               next
             when nil
-              # Not remapped - write original key event as-is
-              uinput_keyboard.write_input_event(input_event)
+              if effective_key != input_key
+                # Output simple-remapped key (e.g., CAPSLOCK -> LEFTCTRL)
+                remapped_code = key_to_code(effective_key)
+                if remapped_code
+                  remapped_event = InputEvent.new(nil, input_event.type, remapped_code, input_event.value)
+                  update_virtual_key_state(effective_key, remapped_event.value)
+                  write_event_with_log(remapped_event, context: "simple remap from #{input_key}")
+                else
+                  write_event_with_log(input_event, context: "simple remap failed")
+                end
+              else
+                write_event_with_log(input_event, context: "passthrough")
+              end
               next
             else
-              # Invalid remapping configuration
               MultiLogger.warn("Invalid remapped value - type: #{remapped.class}, key: #{input_key}")
               next
             end
 
+            # For modifier remaps, handle specially:
+            # Release currently pressed modifiers → Send remapped key → Re-press modifiers
+            if is_modifier_remap && input_event.value == 1
+              execute_modifier_remap(remapped, input_event)
+              next
+            end
+
+            # Handle key combination output (e.g., "LEFTALT+LEFT")
+            # If remapped value contains "+", it's a key combination that needs special handling
+            if remapped.to_s.include?("+")
+              if input_event.value == 1 # only on key press
+                send_key_combination(remapped, input_event.type)
+              end
+              next
+            end
+
             remapped_code = key_to_code(remapped)
             if remapped_code.nil?
               MultiLogger.warn("Invalid remapped value - unknown key: #{remapped}, input: #{input_key}")
-              uinput_keyboard.write_input_event(input_event)
+              write_event_with_log(input_event, context: "remap failed")
               next
             end
 
@@ -121,9 +197,10 @@ module Fusuma
             # this is because the command will be executed by fusuma process
             next if remapped_event.code.nil?
 
-            uinput_keyboard.write_input_event(remapped_event)
+            write_event_with_log(remapped_event, context: "remapped from #{input_key}")
           rescue Errno::ENODEV => e # device is removed
             MultiLogger.error "Device is removed: #{e.message}"
+            @device_mappings = {} # Clear cache for new device configuration
             @source_keyboards = reload_keyboards
           end
         rescue EOFError => e # device is closed
@@ -147,6 +224,56 @@ module Fusuma
           MultiLogger.error e.backtrace.join("\n")
         end
 
+        # Get mapping for specific device from cache or LayerManager
+        # @param device_name [String] Physical device name
+        # @param layer [Hash] Layer information
+        # @return [Hash] Mapping for the device
+        def get_mapping_for_device(device_name, layer)
+          matched_pattern = @device_matcher.match(device_name)
+          effective_layer = matched_pattern ? layer.merge(device: matched_pattern) : layer
+          cache_key = [device_name, layer].hash
+          @device_mappings[cache_key] ||= @layer_manager.find_merged_mapping(effective_layer)
+        end
+
+        # Check for newly connected devices and add them to source_keyboards
+        # Called periodically via IO.select timeout
+        def check_and_add_new_devices
+          current_device_paths = @source_keyboards.map { |kbd| kbd.file.path }
+
+          selector = KeyboardSelector.new(@config[:keyboard_name_patterns])
+          available_devices = selector.try_open_devices
+
+          new_devices = available_devices.reject do |device|
+            current_device_paths.include?(device.file.path)
+          end
+
+          # Close devices that are already in source_keyboards to avoid duplicate file handles
+          available_devices.each do |device|
+            device.file.close if current_device_paths.include?(device.file.path)
+          end
+
+          return if new_devices.empty?
+
+          MultiLogger.info("New keyboard(s) detected: #{new_devices.map(&:device_name)}")
+
+          grabbed_devices = []
+          new_devices.each do |device|
+            wait_release_all_keys(device)
+            device.grab
+            MultiLogger.info "Grabbed keyboard: #{device.device_name}"
+            grabbed_devices << device
+          rescue Errno::EBUSY
+            MultiLogger.error "Failed to grab keyboard: #{device.device_name}"
+          rescue Errno::ENODEV
+            MultiLogger.warn "Device removed during grab: #{device.device_name}"
+          end
+
+          return if grabbed_devices.empty?
+
+          @source_keyboards.concat(grabbed_devices)
+          @device_mappings = {} # Clear cache for new device configuration
+        end
+
         def uinput_keyboard
           @uinput_keyboard ||= UinputKeyboard.new("/dev/uinput")
         end
@@ -192,29 +319,36 @@ module Fusuma
 
         def create_virtual_keyboard
           touchpad_name_patterns = @config[:touchpad_name_patterns]
-          internal_touchpad = TouchpadSelector.new(touchpad_name_patterns).select.first
-
-          if internal_touchpad.nil?
-            MultiLogger.error("No touchpad found: #{touchpad_name_patterns}")
-            exit
-          end
+          # Use DeviceSelector without wait - keyboard remap should work even without touchpad
+          internal_touchpad = DeviceSelector.new(
+            name_patterns: touchpad_name_patterns,
+            device_type: :touchpad
+          ).select(wait: false).first
 
           MultiLogger.info "Create virtual keyboard: #{VIRTUAL_KEYBOARD_NAME}"
 
-          uinput_keyboard.create VIRTUAL_KEYBOARD_NAME,
-            Revdev::InputId.new(
-              # disable while typing is enabled when
-              # - Both the keyboard and touchpad are BUS_I8042
-              # - The touchpad and keyboard have the same vendor/product
-              # ref: (https://wayland.freedesktop.org/libinput/doc/latest/palm-detection.html#disable-while-typing)
-              #
-              {
-                bustype: Revdev::BUS_I8042,
-                vendor: internal_touchpad.device_id.vendor,
-                product: internal_touchpad.device_id.product,
-                version: internal_touchpad.device_id.version
-              }
-            )
+          if internal_touchpad.nil?
+            MultiLogger.warn("No touchpad found: #{touchpad_name_patterns}")
+            MultiLogger.warn("Disable-while-typing feature will not work without a touchpad")
+            # Create virtual keyboard without touchpad device ID
+            # disable-while-typing will not work in this case
+            uinput_keyboard.create VIRTUAL_KEYBOARD_NAME
+          else
+            uinput_keyboard.create VIRTUAL_KEYBOARD_NAME,
+              Revdev::InputId.new(
+                # disable while typing is enabled when
+                # - Both the keyboard and touchpad are BUS_I8042
+                # - The touchpad and keyboard have the same vendor/product
+                # ref: (https://wayland.freedesktop.org/libinput/doc/latest/palm-detection.html#disable-while-typing)
+                #
+                {
+                  bustype: Revdev::BUS_I8042,
+                  vendor: internal_touchpad.device_id.vendor,
+                  product: internal_touchpad.device_id.product,
+                  version: internal_touchpad.device_id.version
+                }
+              )
+          end
         end
 
         def grab_keyboards(keyboards)
@@ -276,7 +410,7 @@ module Fusuma
           second_keycode = key_to_code(keybinds[1])
 
           @emergency_stop = lambda do |prev, current|
-            if (prev&.code == first_keycode && prev.value != 0) && (current.code == second_keycode && current.value != 0)
+            if prev&.code == first_keycode && prev.value != 0 && current.code == second_keycode && current.value != 0
               MultiLogger.info "Emergency ungrab keybind is pressed: #{keybinds[0]}+#{keybinds[1]}"
               @destroy.call
             end
@@ -359,6 +493,160 @@ module Fusuma
           end
         end
 
+        # Apply simple key-to-key remapping (modmap-style)
+        # - Returns remapped key if simple remap exists
+        # - Skips combinations (containing "+"), Arrays, and Hashes
+        # - Returns original key if no match
+        #
+        # @param mapping [Hash] remapping configuration
+        # @param key [String] input key name
+        # @return [String] remapped key or original key
+        def apply_simple_remap(mapping, key)
+          remapped = mapping.fetch(key.to_sym, nil)
+          if remapped.is_a?(String) && !remapped.include?("+")
+            remapped
+          else
+            key
+          end
+        end
+
+        # Search for remapping
+        # If modifier keys are pressed, first search with modifier+key
+        #
+        # @param mapping [Hash] remapping configuration
+        # @param input_key [String] input key name
+        # @return [Array] [remapped key, is modifier remap]
+        def find_remapping(mapping, input_key)
+          # If modifier keys are pressed, first search with modifier+key (e.g., "LEFTCTRL+A")
+          if @modifier_state&.pressed_modifiers&.any?
+            combined_key = @modifier_state.current_combination(input_key)
+            remapped = mapping.fetch(combined_key.to_sym, nil)
+            if remapped
+              # For modifier key remapping (e.g., LEFTMETA: LEFTALT), set is_modifier_remap to false
+              # This distinguishes it from modifier+key combinations (e.g., LEFTCTRL+A: HOME)
+              # Modifier key itself should be remapped directly without execute_modifier_remap
+              is_modifier_remap = !@modifier_state.modifier?(input_key)
+              return [remapped.is_a?(Array) ? remapped : remapped.to_s, is_modifier_remap]
+            end
+          end
+
+          # If not found, search with simple key (e.g., "A")
+          remapped = mapping.fetch(input_key.to_sym, nil)
+          # If remapped is an Array (output sequence), return as is
+          result = remapped.is_a?(Array) ? remapped : remapped&.to_s
+          [result, false]
+        end
+
+        # Execute remapping with modifier keys
+        # @param remapped [String, Array] remapped key (single or array)
+        # @param input_event [InputEvent] original input event
+        #
+        # === Output sequence support ===
+        # If remapped is an Array, send each element in order
+        # e.g., ["LEFTSHIFT+HOME", "DELETE"]
+        #      → Shift+Home (press/release) → Delete (press/release)
+        def execute_modifier_remap(remapped, input_event)
+          # 1. Temporarily release currently pressed modifier keys
+          release_current_modifiers
+
+          # 2. Send remapped key(s) (press + release)
+          # === Output sequence support ===
+          send_key_combination(remapped, input_event.type)
+
+          # 3. Re-press modifier keys
+          restore_current_modifiers
+        end
+
+        # Release currently pressed modifier keys
+        def release_current_modifiers
+          return unless @modifier_state
+
+          @modifier_state.pressed_modifiers.each do |modifier_key|
+            code = key_to_code(modifier_key)
+            next unless code
+
+            release_event = InputEvent.new(nil, EV_KEY, code, 0)
+            write_event_with_log(release_event, context: "modifier release")
+          end
+        end
+
+        # Re-press modifier keys
+        def restore_current_modifiers
+          return unless @modifier_state
+
+          @modifier_state.pressed_modifiers.each do |modifier_key|
+            code = key_to_code(modifier_key)
+            next unless code
+
+            press_event = InputEvent.new(nil, EV_KEY, code, 1)
+            write_event_with_log(press_event, context: "modifier restore")
+          end
+        end
+
+        # Send a key combination (e.g., "LEFTCTRL+O" → press Ctrl, press O, release O, release Ctrl)
+        # @param key_input [String, Array] Key string or array
+        #   - String: Single key combination (e.g., "Q", "LEFTCTRL+O")
+        #   - Array: Output sequence (e.g., ["LEFTSHIFT+HOME", "DELETE"])
+        # @param event_type [Integer] Event type
+        # @return [void]
+        #
+        # === Output sequence support ===
+        # If Array, send each element in order
+        def send_key_combination(key_input, event_type)
+          # If Array, send each element in order
+          if key_input.is_a?(Array)
+            key_input.each { |key| send_key_combination(key.to_s, event_type) }
+            return
+          end
+
+          keys = key_input.to_s.split("+")
+
+          # Press all keys
+          keys.each do |key|
+            code = key_to_code(key)
+            next unless code
+
+            press_event = InputEvent.new(nil, event_type, code, 1)
+            write_event_with_log(press_event, context: "combination")
+          end
+
+          # Release all keys in reverse order
+          keys.reverse.each do |key|
+            code = key_to_code(key)
+            next unless code
+
+            release_event = InputEvent.new(nil, event_type, code, 0)
+            write_event_with_log(release_event, context: "combination")
+          end
+        end
+
+        # Convert key event value to state string
+        # @param value [Integer] 0=released, 1=pressed, 2=repeat
+        # @return [String]
+        def value_to_state(value)
+          case value
+          when 0 then "released"
+          when 1 then "pressed"
+          when 2 then "repeat"
+          else "unknown(#{value})"
+          end
+        end
+
+        # Write input event with debug logging
+        # @param event [InputEvent] event to send
+        # @param context [String, nil] additional context info
+        def write_event_with_log(event, context: nil)
+          if event.type == EV_KEY
+            key = code_to_key(event.code)
+            state = value_to_state(event.value)
+            msg = "[REMAP] #{key} #{state}"
+            msg += " (#{context})" if context
+            MultiLogger.debug(msg)
+          end
+
+          uinput_keyboard.write_input_event(event)
+        end
+
         # Devices to detect key presses and releases
         class KeyboardSelector
           def initialize(names)
@@ -369,48 +657,43 @@ module Fusuma
           # If no device is found, it will wait for 3 seconds and try again
           # @return [Array<Revdev::EventDevice>]
           def select
-            displayed_no_keyboard = false
+            logged_no_device = false
             loop do
-              Fusuma::Device.reset # reset cache to get the latest device information
-              devices = Fusuma::Device.all.select do |d|
-                next if d.name == VIRTUAL_KEYBOARD_NAME
+              keyboards = try_open_devices
 
-                Array(@names).any? { |name| d.name =~ /#{name}/ }
-              end
-              if devices.empty?
-                unless displayed_no_keyboard
+              if keyboards.empty?
+                unless logged_no_device
                   MultiLogger.warn "No keyboard found: #{@names}"
-                  displayed_no_keyboard = true
+                  logged_no_device = true
                 end
-                wait_for_device
 
-                next
+                wait_for_device
+              else
+                return keyboards
               end
-
-              return devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
             end
           end
 
-          def wait_for_device
-            sleep 3
-          end
-        end
+          def try_open_devices
+            Fusuma::Device.reset # reset cache to get the latest device information
+            devices = Fusuma::Device.all.select do |d|
+              next if d.name == VIRTUAL_KEYBOARD_NAME
 
-        class TouchpadSelector
-          def initialize(names = nil)
-            @names = names
-          end
+              Array(@names).any? { |name| d.name =~ /#{name}/ }
+            end
 
-          # @return [Array<Revdev::EventDevice>]
-          def select
-            devices = if @names
-              Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
-            else
-              # available returns only touchpad devices
-              Fusuma::Device.available
+            devices.filter_map do |d|
+              Revdev::EventDevice.new("/dev/input/#{d.id}")
+            rescue Errno::ENOENT, Errno::ENODEV, Errno::EACCES => e
+              MultiLogger.warn "Failed to open #{d.name} (/dev/input/#{d.id}): #{e.message}"
+              nil
             end
+          end
 
-            devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+          private
+
+          def wait_for_device
+            sleep 3
           end
         end
       end

data/lib/fusuma/plugin/remap/layer_manager.rb

@@ -8,6 +8,14 @@ module Fusuma
       class LayerManager
         require "singleton"
         include Singleton
+
+        # Priority order for context types (higher number = higher priority)
+        CONTEXT_PRIORITIES = {
+          device: 1,
+          thumbsense: 2,
+          application: 3
+        }.freeze
+
         attr_reader :reader, :writer, :current_layer, :layers
 
         def initialize
@@ -74,6 +82,56 @@ module Fusuma
             result || {}
           end
         end
+
+        # Find merged mapping from all applicable layers
+        # Merges mappings from default, individual contexts, and complete match
+        # Higher priority contexts override lower priority ones
+        # @param [Hash] layer current active layer (e.g., { thumbsense: true, application: "Google-chrome" })
+        # @return [Hash] merged remap mapping
+        def find_merged_mapping(layer)
+          @merged_layers ||= {}
+          @merged_layers[layer] ||= merge_all_applicable_mappings(layer)
+        end
+
+        private
+
+        def merge_all_applicable_mappings(layer)
+          mappings = []
+
+          # 1. default (no context) - priority 0
+          default_mapping = find_mapping_for_context({})
+          mappings << [0, default_mapping] if default_mapping
+
+          # 2. Each single context key's mapping
+          layer.each do |key, value|
+            single_context = {key => value}
+            mapping = find_mapping_for_context(single_context)
+            if mapping
+              priority = CONTEXT_PRIORITIES.fetch(key, 1)
+              mappings << [priority, mapping]
+            end
+          end
+
+          # 3. Complete match (multiple keys) - highest priority
+          if layer.keys.size > 1
+            complete_mapping = find_mapping_for_context(layer)
+            mappings << [100, complete_mapping] if complete_mapping
+          end
+
+          # Merge in priority order (lower priority first, higher priority overwrites)
+          mappings.sort_by(&:first).reduce({}) { |merged, (_, m)| merged.merge(m) }
+        end
+
+        def find_mapping_for_context(context)
+          result = nil
+          Fusuma::Config::Searcher.with_context(context) do
+            result = Fusuma::Config.search(Fusuma::Config::Index.new(:remap))
+            next unless result
+
+            result = result.deep_transform_keys { |key| key.upcase.to_sym }
+          end
+          result
+        end
       end
     end
   end

data/lib/fusuma/plugin/remap/modifier_state.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Fusuma
+  module Plugin
+    module Remap
+      # Tracks the pressed state of modifier keys
+      class ModifierState
+        MODIFIERS = Set.new(%w[
+          LEFTCTRL RIGHTCTRL
+          LEFTALT RIGHTALT
+          LEFTSHIFT RIGHTSHIFT
+          LEFTMETA RIGHTMETA
+        ]).freeze
+
+        def initialize
+          @pressed = Set.new
+        end
+
+        def update(key, event_value)
+          return unless modifier?(key)
+
+          case event_value
+          when 1 then @pressed.add(key)
+          when 0 then @pressed.delete(key)
+          end
+        end
+
+        def current_combination(key)
+          return key if modifier?(key)
+
+          modifiers = pressed_modifiers
+          if modifiers.empty?
+            key
+          else
+            "#{modifiers.join("+")}+#{key}"
+          end
+        end
+
+        def pressed_modifiers
+          @pressed.to_a.sort
+        end
+
+        def modifier?(key)
+          MODIFIERS.include?(key)
+        end
+
+        def reset
+          @pressed.clear
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/remap/touchpad_remapper.rb

@@ -3,6 +3,8 @@ require "msgpack"
 require "set"
 
 require_relative "uinput_touchpad"
+require_relative "device_selector"
+require "fusuma/device"
 
 module Fusuma
   module Plugin
@@ -14,9 +16,11 @@ module Fusuma
 
         # @param fusuma_writer [IO]
         # @param source_touchpads [Revdev::Device]
-        def initialize(fusuma_writer:, source_touchpads:)
+        # @param touchpad_name_patterns [Array, String, nil] patterns for touchpad device names (for reconnection)
+        def initialize(fusuma_writer:, source_touchpads:, touchpad_name_patterns: nil)
           @source_touchpads = source_touchpads # original touchpad
           @fusuma_writer = fusuma_writer # write event to fusuma_input
+          @touchpad_name_patterns = touchpad_name_patterns # for reconnection
 
           @palm_detectors = @source_touchpads.each_with_object({}) do |source_touchpad, palm_detectors|
             palm_detectors[source_touchpad] = PalmDetection.new(source_touchpad)
@@ -157,7 +161,19 @@ module Fusuma
               prev_status = status
               prev_valid_touch = valid_touch
             end
+          rescue Errno::ENODEV => e
+            MultiLogger.error "Touchpad device is removed: #{e.message}"
+            MultiLogger.info "Waiting for touchpad to reconnect..."
+            reload_touchpads
+            touch_state = {}
+            mt_slot = 0
+            finger_state = nil
+            prev_valid_touch = false
+            prev_status = nil
+            retry
           end
+        rescue IOError => e
+          MultiLogger.error "Touchpad IO error: #{e.message}"
         rescue => e
           MultiLogger.error "An error occurred: #{e.message}"
         ensure
@@ -176,6 +192,34 @@ module Fusuma
           uinput.create_from_device(name: VIRTUAL_TOUCHPAD_NAME, device: @source_touchpads.first)
         end
 
+        # Reload touchpads after device disconnection
+        # This method waits until a touchpad is reconnected
+        def reload_touchpads
+          # Destroy virtual touchpad
+          begin
+            uinput.destroy
+          rescue IOError
+            # already destroyed
+          end
+          @uinput = nil
+
+          # Wait and detect touchpad using DeviceSelector
+          @source_touchpads = DeviceSelector.new(
+            name_patterns: @touchpad_name_patterns,
+            device_type: :touchpad
+          ).select(wait: true)
+
+          # Reinitialize palm detectors
+          @palm_detectors = @source_touchpads.each_with_object({}) do |source_touchpad, palm_detectors|
+            palm_detectors[source_touchpad] = PalmDetection.new(source_touchpad)
+          end
+
+          # Recreate virtual touchpad
+          create_virtual_touchpad
+
+          MultiLogger.info "Touchpad reconnected: #{@source_touchpads}"
+        end
+
         def set_trap
           @destroy = lambda do
             begin

data/lib/fusuma/plugin/remap/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Remap
-      VERSION = "0.11.2"
+      VERSION = "0.13.0"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-remap
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.13.0
 platform: ruby
 authors:
 - iberianpig
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-14 00:00:00.000000000 Z
+date: 2026-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 3.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 3.11.0
 - !ruby/object:Gem::Dependency
   name: fusuma-plugin-keypress
   requirement: !ruby/object:Gem::Requirement
@@ -120,8 +120,11 @@ files:
 - lib/fusuma/plugin/inputs/remap_touchpad_input.rb
 - lib/fusuma/plugin/inputs/remap_touchpad_input.yml
 - lib/fusuma/plugin/remap.rb
+- lib/fusuma/plugin/remap/device_matcher.rb
+- lib/fusuma/plugin/remap/device_selector.rb
 - lib/fusuma/plugin/remap/keyboard_remapper.rb
 - lib/fusuma/plugin/remap/layer_manager.rb
+- lib/fusuma/plugin/remap/modifier_state.rb
 - lib/fusuma/plugin/remap/touchpad_remapper.rb
 - lib/fusuma/plugin/remap/uinput_keyboard.rb
 - lib/fusuma/plugin/remap/uinput_touchpad.rb