feat(osm): add configurable quick_release option for one-shot modifiers

Add `quick_release` boolean to `OneShotModifiersConfig` (default false,
preserving existing chain-mode behavior). When enabled, OSM releases on
the next key press instead of release, equivalent to ZMK's `&skq`.

Key changes:
- oneshot.rs: update_osm checks quick_release to decide release timing
- keyboard.rs: send follow-up report after OSM clear in quick-release
  mode to stop host from repeating the modified key
- Fix combo interaction: reset_sub_combos replaces reset_combo to avoid
  premature OSM clearing from buffered combo constituent keys
- Config pipeline: quick_release field threaded tesolved config, and codegen
- Tests: cover both quick-release and chain-mode behaviors, including
  combo interactions

Configuration example (keyboard.toml):
  [behavior.one_shot_modifiers]
  quick_release = true

Author: yekingyan

docs/docs/main/docs/configuration/behavior.md

@@ -52,10 +52,16 @@ This behavior is also known as One-Shot Sticky Modifiers (OSSM).
 
 If you press One-Shot Modifier again, it will be sent as a normal modifier key press and, therefore, released.
 
+The `quick_release` option controls when the one-shot modifier is released:
+
+- `false` (default): the modifier is released when the next key is **released** (chain mode, equivalent to ZMK `&skn`). The modifier stays active for the entire duration of the next keypress, including key repeat.
+- `true`: the modifier is released when the next key is **pressed** (equivalent to ZMK `&skq`). Only the initial press of the next key is modified; key repeat will not include the modifier.
+
 Default values:
 ```toml
 [behavior.one_shot_modifiers]
 activate_on_keypress = false
+quick_release = false
 ```
 
 OSSM example:
@@ -64,6 +70,12 @@ OSSM example:
 activate_on_keypress = true
 ```
 
+Quick-release example:
+```toml
+[behavior.one_shot_modifiers]
+quick_release = true
+```
+
 ## Combo
 
 In the `combo` sub-table, you can configure the keyboard's combo key functionality. Combo allows you to define a group of keys that, when pressed simultaneously, will trigger a specific output action.

rmk-config/src/lib.rs

@@ -619,6 +619,7 @@ pub(crate) struct OneShotConfig {
 #[serde(deny_unknown_fields)]
 pub struct OneShotModifiersConfig {
     pub activate_on_keypress: Option<bool>,
+    pub quick_release: Option<bool>,
 }
 
 /// Configurations for combos

rmk-config/src/resolved/behavior.rs

@@ -13,6 +13,7 @@ pub struct Behavior {
 
 pub struct OneShot {
     pub activate_on_keypress: Option<bool>,
+    pub quick_release: Option<bool>,
 }
 
 pub struct Combos {
@@ -104,6 +105,7 @@ impl crate::KeyboardTomlConfig {
 
         let one_shot_modifiers = toml_behavior.one_shot_modifiers.map(|o| OneShot {
             activate_on_keypress: o.activate_on_keypress,
+            quick_release: o.quick_release,
         });
 
         let combos = toml_behavior.combo.map(|c| Combos {

rmk-macro/src/codegen/behavior.rs

@@ -47,10 +47,15 @@ fn expand_one_shot_modifiers(one_shot_modifiers: &Option<OneShot>) -> proc_macro
                 Some(value) => quote! { activate_on_keypress: #value, },
                 None => quote! {},
             };
+            let quick_release = match one_shot_modifier.quick_release {
+                Some(value) => quote! { quick_release: #value, },
+                None => quote! {},
+            };
 
             quote! {
                 ::rmk::config::OneShotModifiersConfig {
                     #activate_on_keypress
+                    #quick_release
                     ..Default::default()
                 }
             }

rmk/src/config/behavior.rs

@@ -77,6 +77,8 @@ impl Default for OneShotConfig {
 pub struct OneShotModifiersConfig {
     /// Should modifiers be active from keypress (sticky modifiers)
     pub activate_on_keypress: bool,
+    /// If true, OSM releases on next key press (ZMK skq); if false, on next key release (ZMK skn)
+    pub quick_release: bool,
 }
 
 /// Config for combo behavior

rmk/src/keyboard.rs

@@ -1004,21 +1004,21 @@ impl<'a> Keyboard<'a> {
             self.process_key_action(&action, new_event, true, Instant::now()).await;
             debug!("[Combo] {:?} triggered", action);
             embassy_time::Timer::after_millis(20).await;
-            // Reset other combos' state
-            self.reset_combo(key_action);
+            // Reset non-triggered sub-combos of the combo that just won.
+            self.reset_sub_combos(&combo_actions);
         }
     }
 
-    // Reset combos that contain a key_action but not triggered yet
-    fn reset_combo(&mut self, key_action: &KeyAction) {
-        // Reset other sub-combo states
+    /// Reset all non-triggered combos whose keys are a subset of the triggered combo's keys.
+    /// Prevents sub-combos (e.g. E+T when E+R+T triggered) from firing spuriously,
+    /// while preserving state bits for overlapping combos that share some but not all keys.
+    fn reset_sub_combos(&mut self, triggered_actions: &[KeyAction]) {
         self.keymap.with_combos_mut(|combos| {
-            combos.iter_mut().filter_map(|c| c.as_mut()).for_each(|c| {
-                if c.is_all_pressed() && !c.is_triggered() && c.config.contains(key_action) {
-                    info!("Resetting combo: {:?}", c,);
-                    c.reset();
+            for combo in combos.iter_mut().filter_map(|c| c.as_mut()) {
+                if !combo.is_triggered() && combo.config.actions.iter().all(|a| triggered_actions.contains(a)) {
+                    combo.reset();
                 }
-            });
+            }
         });
     }
 
@@ -1100,22 +1100,22 @@ impl<'a> Keyboard<'a> {
             ));
 
             // Only one combo is updated, and triggered
-            let next_action = self.keymap.with_combos_mut(|combos| {
+            let triggered_combo = self.keymap.with_combos_mut(|combos| {
                 combos.iter_mut().filter_map(|c| c.as_mut()).find_map(|c| {
                     if c.is_all_pressed() && !c.is_triggered() && c.size() == max_size {
-                        Some(c.trigger())
+                        Some((c.trigger(), c.config.actions.clone()))
                     } else {
                         None
                     }
                 })
             });
 
-            if let Some(next_action) = next_action {
+            if let Some((next_action, combo_actions)) = triggered_combo {
                 debug!("[Combo] {:?} triggered", next_action);
                 self.held_buffer
                     .keys
                     .retain(|item| item.state != KeyState::WaitingCombo);
-                self.reset_combo(key_action);
+                self.reset_sub_combos(&combo_actions);
                 return (Some(next_action), true);
             }
             (None, false)
@@ -1533,7 +1533,12 @@ impl<'a> Keyboard<'a> {
             _ => warn!("KeyCode variant not supported: {:?}", key),
         }
 
+        let quick_release = self.keymap.one_shot_modifiers_config().quick_release;
+        let osm_active_before = self.osm_state.value().is_some();
         self.update_osm(event);
+        if quick_release && osm_active_before && self.osm_state.value().is_none() && event.pressed {
+            self.send_keyboard_report_with_resolved_modifiers(true).await;
+        }
         self.update_osl(event);
     }
 

rmk/src/keyboard/oneshot.rs

@@ -161,9 +161,13 @@ impl<'a> Keyboard<'a> {
     }
 
     pub(crate) fn update_osm(&mut self, event: KeyboardEvent) {
+        let quick_release = self.keymap.one_shot_modifiers_config().quick_release;
         match self.osm_state {
             OneShotState::Initial(m) => self.osm_state = OneShotState::Held(m),
-            OneShotState::Single(_) if !event.pressed => {
+            OneShotState::Single(_) if quick_release && event.pressed => {
+                self.osm_state = OneShotState::None;
+            }
+            OneShotState::Single(_) if !quick_release && !event.pressed => {
                 self.osm_state = OneShotState::None;
             }
             _ => (),

rmk/tests/keyboard_combo_test.rs

@@ -1,7 +1,7 @@
 pub mod common;
 
 use embassy_time::Duration;
-use rmk::config::{BehaviorConfig, CombosConfig, MorsesConfig, OneShotConfig};
+use rmk::config::{BehaviorConfig, CombosConfig, MorsesConfig, OneShotConfig, OneShotModifiersConfig};
 use rmk::keyboard::combo::{Combo, ComboConfig};
 use rmk::types::keycode::HidKeyCode;
 use rmk::types::modifier::ModifierCombination;
@@ -154,6 +154,10 @@ fn test_combo_with_one_shot_modifier() {
                 timeout: Duration::from_millis(300),
                 ..Default::default()
             },
+            one_shot_modifiers: OneShotModifiersConfig {
+                quick_release: true,
+                ..Default::default()
+            },
             ..Default::default()
         }),
         sequence: [
@@ -166,6 +170,7 @@ fn test_combo_with_one_shot_modifier() {
         ],
         expected_reports: [
             [KC_LSHIFT, [HidKeyCode::E as u8, 0, 0, 0, 0, 0]],
+            [0, [HidKeyCode::E as u8, 0, 0, 0, 0, 0]], // Quick-release: modifier removed
             [0, [0; 6]],
         ]
     }
@@ -240,6 +245,10 @@ fn test_fully_overlapped_combo() {
     key_sequence_test! {
         keyboard: create_test_keyboard_with_config(BehaviorConfig {
             combo: get_combos_config(),
+            one_shot_modifiers: OneShotModifiersConfig {
+                quick_release: true,
+                ..Default::default()
+            },
             ..Default::default()
         }),
         sequence: [
@@ -269,6 +278,7 @@ fn test_fully_overlapped_combo() {
             [0, [HidKeyCode::Space as u8, 0, 0, 0, 0, 0]],
             [0, [0; 6]],
             [KC_LSHIFT, [HidKeyCode::A as u8, 0, 0, 0, 0, 0]],
+            [0, [HidKeyCode::A as u8, 0, 0, 0, 0, 0]], // Quick-release: modifier removed
             [0, [0; 6]],
             [0, [HidKeyCode::Space as u8, 0, 0, 0, 0, 0]],
             [0, [0; 6]],
@@ -281,6 +291,10 @@ fn test_overlapped_combo() {
     key_sequence_test! {
         keyboard: create_test_keyboard_with_config(BehaviorConfig {
             combo: get_combos_config(),
+            one_shot_modifiers: OneShotModifiersConfig {
+                quick_release: true,
+                ..Default::default()
+            },
             ..Default::default()
         }),
         sequence: [
@@ -295,6 +309,7 @@ fn test_overlapped_combo() {
         ],
         expected_reports: [
             [KC_LSHIFT, [HidKeyCode::A as u8, 0, 0, 0, 0, 0]],
+            [0, [HidKeyCode::A as u8, 0, 0, 0, 0, 0]], // Quick-release: modifier removed
             [0, [0; 6]],
         ]
     }