Merge remote-tracking branch 'origin/develop'

28 files changed, 308 insertions, 146 deletions

diff --git a/quantum/process_keycode/process_audio.c b/quantum/process_keycode/process_audio.c
index 3b5fa8490b..e7fe453308 100644
--- a/quantum/process_keycode/process_audio.c
+++ b/quantum/process_keycode/process_audio.c
@@ -50,10 +50,17 @@ bool process_audio(uint16_t keycode, keyrecord_t *record) {
     return true;
 }
 
-void process_audio_noteon(uint8_t note) { play_note(compute_freq_for_midi_note(note), 0xF); }
+void process_audio_noteon(uint8_t note) {
+    play_note(compute_freq_for_midi_note(note), 0xF);
+}
 
-void process_audio_noteoff(uint8_t note) { stop_note(compute_freq_for_midi_note(note)); }
+void process_audio_noteoff(uint8_t note) {
+    stop_note(compute_freq_for_midi_note(note));
+}
 
-void process_audio_all_notes_off(void) { stop_all_notes(); }
+void process_audio_all_notes_off(void) {
+    stop_all_notes();
+}
 
 __attribute__((weak)) void audio_on_user() {}
+__attribute__((weak)) void audio_off_user() {}
diff --git a/quantum/process_keycode/process_audio.h b/quantum/process_keycode/process_audio.h
index d89a834ea8..42cfab4af2 100644
--- a/quantum/process_keycode/process_audio.h
+++ b/quantum/process_keycode/process_audio.h
@@ -8,3 +8,4 @@ void process_audio_noteoff(uint8_t note);
 void process_audio_all_notes_off(void);
 
 void audio_on_user(void);
+void audio_off_user(void);
diff --git a/quantum/process_keycode/process_auto_shift.c b/quantum/process_keycode/process_auto_shift.c
index bbc6367ff1..2150edd7b2 100644
--- a/quantum/process_keycode/process_auto_shift.c
+++ b/quantum/process_keycode/process_auto_shift.c
@@ -62,7 +62,9 @@ static struct {
 // clang-format on
 
 /** \brief Called on physical press, returns whether key should be added to Auto Shift */
-__attribute__((weak)) bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) { return false; }
+__attribute__((weak)) bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
+    return false;
+}
 
 /** \brief Called on physical press, returns whether is Auto Shift key */
 __attribute__((weak)) bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
@@ -82,8 +84,12 @@ __attribute__((weak)) bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *r
 }
 
 /** \brief Called to check whether defines should apply if PER_KEY is set for it */
-__attribute__((weak)) bool get_auto_shift_repeat(uint16_t keycode, keyrecord_t *record) { return true; }
-__attribute__((weak)) bool get_auto_shift_no_auto_repeat(uint16_t keycode, keyrecord_t *record) { return true; }
+__attribute__((weak)) bool get_auto_shift_repeat(uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
+__attribute__((weak)) bool get_auto_shift_no_auto_repeat(uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
 
 /** \brief Called when an Auto Shift key needs to be pressed */
 __attribute__((weak)) void autoshift_press_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
@@ -94,7 +100,9 @@ __attribute__((weak)) void autoshift_press_user(uint16_t keycode, bool shifted,
 }
 
 /** \brief Called when an Auto Shift key needs to be released */
-__attribute__((weak)) void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) { unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode); }
+__attribute__((weak)) void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
+    unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+}
 
 /** \brief Sets the shift state to use when keyrepeating, required by custom shifts */
 void set_autoshift_shift_state(uint16_t keycode, bool shifted) {
@@ -311,7 +319,9 @@ void autoshift_toggle(void) {
     autoshift_flush_shift();
 }
 
-void autoshift_enable(void) { autoshift_flags.enabled = true; }
+void autoshift_enable(void) {
+    autoshift_flags.enabled = true;
+}
 
 void autoshift_disable(void) {
     autoshift_flags.enabled = false;
@@ -328,12 +338,20 @@ void autoshift_timer_report(void) {
 }
 #    endif
 
-bool get_autoshift_state(void) { return autoshift_flags.enabled; }
+bool get_autoshift_state(void) {
+    return autoshift_flags.enabled;
+}
 
-uint16_t                       get_generic_autoshift_timeout() { return autoshift_timeout; }
-__attribute__((weak)) uint16_t get_autoshift_timeout(uint16_t keycode, keyrecord_t *record) { return autoshift_timeout; }
+uint16_t get_generic_autoshift_timeout() {
+    return autoshift_timeout;
+}
+__attribute__((weak)) uint16_t get_autoshift_timeout(uint16_t keycode, keyrecord_t *record) {
+    return autoshift_timeout;
+}
 
-void set_autoshift_timeout(uint16_t timeout) { autoshift_timeout = timeout; }
+void set_autoshift_timeout(uint16_t timeout) {
+    autoshift_timeout = timeout;
+}
 
 bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
     // Note that record->event.time isn't reliable, see:
diff --git a/quantum/process_keycode/process_clicky.c b/quantum/process_keycode/process_clicky.c
index 6ab382d4aa..9795734984 100644
--- a/quantum/process_keycode/process_clicky.c
+++ b/quantum/process_keycode/process_clicky.c
@@ -5,40 +5,40 @@
 
 #    ifndef AUDIO_CLICKY_DELAY_DURATION
 #        define AUDIO_CLICKY_DELAY_DURATION 1
-#    endif  // !AUDIO_CLICKY_DELAY_DURATION
+#    endif // !AUDIO_CLICKY_DELAY_DURATION
 #    ifndef AUDIO_CLICKY_FREQ_DEFAULT
 #        define AUDIO_CLICKY_FREQ_DEFAULT 440.0f
-#    endif  // !AUDIO_CLICKY_FREQ_DEFAULT
+#    endif // !AUDIO_CLICKY_FREQ_DEFAULT
 #    ifndef AUDIO_CLICKY_FREQ_MIN
 #        define AUDIO_CLICKY_FREQ_MIN 65.0f
-#    endif  // !AUDIO_CLICKY_FREQ_MIN
+#    endif // !AUDIO_CLICKY_FREQ_MIN
 #    ifndef AUDIO_CLICKY_FREQ_MAX
 #        define AUDIO_CLICKY_FREQ_MAX 1500.0f
-#    endif  // !AUDIO_CLICKY_FREQ_MAX
+#    endif // !AUDIO_CLICKY_FREQ_MAX
 #    ifndef AUDIO_CLICKY_FREQ_FACTOR
 #        define AUDIO_CLICKY_FREQ_FACTOR 1.18921f
-#    endif  // !AUDIO_CLICKY_FREQ_FACTOR
+#    endif // !AUDIO_CLICKY_FREQ_FACTOR
 #    ifndef AUDIO_CLICKY_FREQ_RANDOMNESS
 #        define AUDIO_CLICKY_FREQ_RANDOMNESS 0.05f
-#    endif  // !AUDIO_CLICKY_FREQ_RANDOMNESS
+#    endif // !AUDIO_CLICKY_FREQ_RANDOMNESS
 
 float clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT;
 float clicky_rand = AUDIO_CLICKY_FREQ_RANDOMNESS;
 
 // the first "note" is an intentional delay; the 2nd and 3rd notes are the "clicky"
-float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_MIN, AUDIO_CLICKY_DELAY_DURATION}, {AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}};  // 3 and 1 --> durations
+float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_MIN, AUDIO_CLICKY_DELAY_DURATION}, {AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}}; // 3 and 1 --> durations
 
 extern audio_config_t audio_config;
 
 #    ifndef NO_MUSIC_MODE
 extern bool music_activated;
 extern bool midi_activated;
-#    endif  // !NO_MUSIC_MODE
+#    endif // !NO_MUSIC_MODE
 
 void clicky_play(void) {
 #    ifndef NO_MUSIC_MODE
     if (music_activated || midi_activated || !audio_config.enable) return;
-#    endif  // !NO_MUSIC_MODE
+#    endif // !NO_MUSIC_MODE
     clicky_song[1][0] = 2.0f * clicky_freq * (1.0f + clicky_rand * (((float)rand()) / ((float)(RAND_MAX))));
     clicky_song[2][0] = clicky_freq * (1.0f + clicky_rand * (((float)rand()) / ((float)(RAND_MAX))));
     PLAY_SONG(clicky_song);
@@ -58,7 +58,9 @@ void clicky_freq_down(void) {
     }
 }
 
-void clicky_freq_reset(void) { clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT; }
+void clicky_freq_reset(void) {
+    clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT;
+}
 
 void clicky_toggle(void) {
     audio_config.clicky_enable ^= 1;
@@ -75,7 +77,9 @@ void clicky_off(void) {
     eeconfig_update_audio(audio_config.raw);
 }
 
-bool is_clicky_on(void) { return (audio_config.clicky_enable != 0); }
+bool is_clicky_on(void) {
+    return (audio_config.clicky_enable != 0);
+}
 
 bool process_clicky(uint16_t keycode, keyrecord_t *record) {
     if (keycode == CLICKY_TOGGLE && record->event.pressed) {
@@ -101,8 +105,8 @@ bool process_clicky(uint16_t keycode, keyrecord_t *record) {
     }
 
     if (audio_config.enable && audio_config.clicky_enable) {
-        if (record->event.pressed) {                       // Leave this separate so it's easier to add upstroke sound
-            if (keycode != AU_OFF && keycode != AU_TOG) {  // DO NOT PLAY if audio will be disabled, and causes issuse on ARM
+        if (record->event.pressed) {                      // Leave this separate so it's easier to add upstroke sound
+            if (keycode != AU_OFF && keycode != AU_TOG) { // DO NOT PLAY if audio will be disabled, and causes issuse on ARM
                 clicky_play();
             }
         }
@@ -110,4 +114,4 @@ bool process_clicky(uint16_t keycode, keyrecord_t *record) {
     return true;
 }
 
-#endif  // AUDIO_CLICKY
+#endif // AUDIO_CLICKY
diff --git a/quantum/process_keycode/process_combo.c b/quantum/process_keycode/process_combo.c
index a050161edf..efaf8fe0e9 100644
--- a/quantum/process_keycode/process_combo.c
+++ b/quantum/process_keycode/process_combo.c
@@ -17,6 +17,7 @@
 #include "print.h"
 #include "process_combo.h"
 #include "action_tapping.h"
+#include "action.h"
 
 #ifdef COMBO_COUNT
 __attribute__((weak)) combo_t key_combos[COMBO_COUNT];
@@ -29,25 +30,45 @@ extern uint16_t COMBO_LEN;
 __attribute__((weak)) void process_combo_event(uint16_t combo_index, bool pressed) {}
 
 #ifdef COMBO_MUST_HOLD_PER_COMBO
-__attribute__((weak)) bool get_combo_must_hold(uint16_t index, combo_t *combo) { return false; }
+__attribute__((weak)) bool get_combo_must_hold(uint16_t index, combo_t *combo) {
+    return false;
+}
 #endif
 
 #ifdef COMBO_MUST_TAP_PER_COMBO
-__attribute__((weak)) bool get_combo_must_tap(uint16_t index, combo_t *combo) { return false; }
+__attribute__((weak)) bool get_combo_must_tap(uint16_t index, combo_t *combo) {
+    return false;
+}
 #endif
 
 #ifdef COMBO_TERM_PER_COMBO
-__attribute__((weak)) uint16_t get_combo_term(uint16_t index, combo_t *combo) { return COMBO_TERM; }
+__attribute__((weak)) uint16_t get_combo_term(uint16_t index, combo_t *combo) {
+    return COMBO_TERM;
+}
+#endif
+
+#ifdef COMBO_MUST_PRESS_IN_ORDER_PER_COMBO
+__attribute__((weak)) bool get_combo_must_press_in_order(uint16_t combo_index, combo_t *combo) {
+    return true;
+}
 #endif
 
 #ifdef COMBO_PROCESS_KEY_RELEASE
-__attribute__((weak)) bool process_combo_key_release(uint16_t combo_index, combo_t *combo, uint8_t key_index, uint16_t keycode) { return false; }
+__attribute__((weak)) bool process_combo_key_release(uint16_t combo_index, combo_t *combo, uint8_t key_index, uint16_t keycode) {
+    return false;
+}
+#endif
+
+#ifdef COMBO_SHOULD_TRIGGER
+__attribute__((weak)) bool combo_should_trigger(uint16_t combo_index, combo_t *combo, uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
 #endif
 
 #ifndef COMBO_NO_TIMER
 static uint16_t timer = 0;
 #endif
-static bool     b_combo_enable = true;  // defaults to enabled
+static bool     b_combo_enable = true; // defaults to enabled
 static uint16_t longest_term   = 0;
 
 typedef struct {
@@ -185,6 +206,9 @@ void clear_combos(void) {
 static inline void dump_key_buffer(void) {
     /* First call start from 0 index; recursive calls need to start from i+1 index */
     static uint8_t key_buffer_next = 0;
+#if TAP_CODE_DELAY > 0
+    bool delay_done = false;
+#endif
 
     if (key_buffer_size == 0) {
         return;
@@ -210,6 +234,15 @@ static inline void dump_key_buffer(void) {
 #endif
         }
         record->event.time = 0;
+        clear_weak_mods();
+
+#if TAP_CODE_DELAY > 0
+        // only delay once and for a non-tapping key
+        if (!delay_done && !is_tap_record(record)) {
+            delay_done = true;
+            wait_ms(TAP_CODE_DELAY);
+        }
+#endif
     }
 
     key_buffer_next = key_buffer_size = 0;
@@ -350,6 +383,28 @@ combo_t *overlaps(combo_t *combo1, combo_t *combo2) {
     return combo1;
 }
 
+#if defined(COMBO_MUST_PRESS_IN_ORDER) || defined(COMBO_MUST_PRESS_IN_ORDER_PER_COMBO)
+static bool keys_pressed_in_order(uint16_t combo_index, combo_t *combo, uint16_t key_index, uint16_t keycode, keyrecord_t *record) {
+#    ifdef COMBO_MUST_PRESS_IN_ORDER_PER_COMBO
+    if (!get_combo_must_press_in_order(combo_index, combo)) {
+        return true;
+    }
+#    endif
+    if (
+        // The `state` bit for the key being pressed.
+        (1 << key_index) ==
+        // The *next* combo key's bit.
+        (COMBO_STATE(combo) + 1)
+        // E.g. two keys already pressed: `state == 11`.
+        // Next possible `state` is `111`.
+        // So the needed bit is `100` which we get with `11 + 1`.
+    ) {
+        return true;
+    }
+    return false;
+}
+#endif
+
 static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *record, uint16_t combo_index) {
     uint8_t  key_count = 0;
     uint16_t key_index = -1;
@@ -360,7 +415,14 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
         return false;
     }
 
-    bool key_is_part_of_combo = !COMBO_DISABLED(combo) && is_combo_enabled();
+    bool key_is_part_of_combo = (!COMBO_DISABLED(combo) && is_combo_enabled()
+#if defined(COMBO_MUST_PRESS_IN_ORDER) || defined(COMBO_MUST_PRESS_IN_ORDER_PER_COMBO)
+                                 && keys_pressed_in_order(combo_index, combo, key_index, keycode, record)
+#endif
+#ifdef COMBO_SHOULD_TRIGGER
+                                 && combo_should_trigger(combo_index, combo, keycode, record)
+#endif
+    );
 
     if (record->event.pressed && key_is_part_of_combo) {
         uint16_t time = _get_combo_term(combo_index, combo);
@@ -412,7 +474,7 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
                     // get possible longer waiting time for tap-/hold-only combos.
                     longest_term = _get_wait_time(combo_index, combo);
                 }
-            }  // if timer elapsed end
+            } // if timer elapsed end
         }
     } else {
         // chord releases
@@ -427,7 +489,7 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
             else if (get_combo_must_tap(combo_index, combo)) {
                 // immediately apply tap-only combo
                 apply_combo(combo_index, combo);
-                apply_combos();  // also apply other prepared combos and dump key buffer
+                apply_combos(); // also apply other prepared combos and dump key buffer
 #    ifdef COMBO_PROCESS_KEY_RELEASE
                 if (process_combo_key_release(combo_index, combo, key_index, keycode)) {
                     release_combo(combo_index, combo);
@@ -509,7 +571,7 @@ bool process_combo(uint16_t keycode, keyrecord_t *record) {
             key_buffer[key_buffer_size++] = (queued_record_t){
                 .record      = *record,
                 .keycode     = keycode,
-                .combo_index = -1,  // this will be set when applying combos
+                .combo_index = -1, // this will be set when applying combos
             };
         }
     } else {
@@ -548,7 +610,9 @@ void combo_task(void) {
 #endif
 }
 
-void combo_enable(void) { b_combo_enable = true; }
+void combo_enable(void) {
+    b_combo_enable = true;
+}
 
 void combo_disable(void) {
 #ifndef COMBO_NO_TIMER
@@ -568,4 +632,6 @@ void combo_toggle(void) {
     }
 }
 
-bool is_combo_enabled(void) { return b_combo_enable; }
+bool is_combo_enabled(void) {
+    return b_combo_enable;
+}
diff --git a/quantum/process_keycode/process_dynamic_macro.c b/quantum/process_keycode/process_dynamic_macro.c
index 18c8d7ca2e..a1ada2d5a2 100644
--- a/quantum/process_keycode/process_dynamic_macro.c
+++ b/quantum/process_keycode/process_dynamic_macro.c
@@ -29,13 +29,21 @@ void dynamic_macro_led_blink(void) {
 
 /* User hooks for Dynamic Macros */
 
-__attribute__((weak)) void dynamic_macro_record_start_user(void) { dynamic_macro_led_blink(); }
+__attribute__((weak)) void dynamic_macro_record_start_user(void) {
+    dynamic_macro_led_blink();
+}
 
-__attribute__((weak)) void dynamic_macro_play_user(int8_t direction) { dynamic_macro_led_blink(); }
+__attribute__((weak)) void dynamic_macro_play_user(int8_t direction) {
+    dynamic_macro_led_blink();
+}
 
-__attribute__((weak)) void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record) { dynamic_macro_led_blink(); }
+__attribute__((weak)) void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record) {
+    dynamic_macro_led_blink();
+}
 
-__attribute__((weak)) void dynamic_macro_record_end_user(int8_t direction) { dynamic_macro_led_blink(); }
+__attribute__((weak)) void dynamic_macro_record_end_user(int8_t direction) {
+    dynamic_macro_led_blink();
+}
 
 /* Convenience macros used for retrieving the debug info. All of them
  * need a `direction` variable accessible at the call site.
@@ -82,7 +90,7 @@ void dynamic_macro_play(keyrecord_t *macro_buffer, keyrecord_t *macro_end, int8_
 
     clear_keyboard();
 
-    layer_state = saved_layer_state;
+    layer_state_set(saved_layer_state);
 
     dynamic_macro_play_user(direction);
 }
diff --git a/quantum/process_keycode/process_grave_esc.c b/quantum/process_keycode/process_grave_esc.c
index 41c50f5cb8..ddf027391d 100644
--- a/quantum/process_keycode/process_grave_esc.c
+++ b/quantum/process_keycode/process_grave_esc.c
@@ -15,13 +15,13 @@
  */
 #include "process_grave_esc.h"
 
-/* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
+/* true if the last press of QK_GRAVE_ESCAPE was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
  * Used to ensure that the correct keycode is released if the key is released.
  */
 static bool grave_esc_was_shifted = false;
 
 bool process_grave_esc(uint16_t keycode, keyrecord_t *record) {
-    if (keycode == GRAVE_ESC) {
+    if (keycode == QK_GRAVE_ESCAPE) {
         const uint8_t mods    = get_mods();
         uint8_t       shifted = mods & MOD_MASK_SG;
 
diff --git a/quantum/process_keycode/process_haptic.c b/quantum/process_keycode/process_haptic.c
index 85b2ffcddd..0f07f9ac75 100644
--- a/quantum/process_keycode/process_haptic.c
+++ b/quantum/process_keycode/process_haptic.c
@@ -35,9 +35,6 @@ __attribute__((weak)) bool get_haptic_enabled_key(uint16_t keycode, keyrecord_t
         case QK_MOMENTARY ... QK_MOMENTARY_MAX:
         case QK_LAYER_MOD ... QK_LAYER_MOD_MAX:
 #endif
-#ifdef NO_HAPTIC_FN
-        case KC_FN0 ... KC_FN31:
-#endif
 #ifdef NO_HAPTIC_ALPHA
         case KC_A ... KC_Z:
 #endif
diff --git a/quantum/process_keycode/process_joystick.c b/quantum/process_keycode/process_joystick.c
index fa9c2c1dbc..2fb092c573 100644
--- a/quantum/process_keycode/process_joystick.c
+++ b/quantum/process_keycode/process_joystick.c
@@ -74,7 +74,9 @@ void restorePinState(pin_t pin, uint16_t restoreState) {
 #endif
 }
 
-__attribute__((weak)) bool process_joystick_analogread() { return process_joystick_analogread_quantum(); }
+__attribute__((weak)) bool process_joystick_analogread() {
+    return process_joystick_analogread_quantum();
+}
 
 bool process_joystick_analogread_quantum() {
 #if JOYSTICK_AXES_COUNT > 0
diff --git a/quantum/process_keycode/process_key_lock.c b/quantum/process_keycode/process_key_lock.c
index 4bd58f0c1e..941a2c5780 100644
--- a/quantum/process_keycode/process_key_lock.c
+++ b/quantum/process_keycode/process_key_lock.c
@@ -56,6 +56,11 @@ static inline uint16_t translate_keycode(uint16_t keycode) {
     }
 }
 
+void cancel_key_lock(void) {
+    watching = false;
+    UNSET_KEY_STATE(0x0);
+}
+
 bool process_key_lock(uint16_t *keycode, keyrecord_t *record) {
     // We start by categorizing the keypress event. In the event of a down
     // event, there are several possibilities:
diff --git a/quantum/process_keycode/process_key_lock.h b/quantum/process_keycode/process_key_lock.h
index baa0b39077..5159b0ba02 100644
--- a/quantum/process_keycode/process_key_lock.h
+++ b/quantum/process_keycode/process_key_lock.h
@@ -18,4 +18,5 @@
 
 #include "quantum.h"
 
+void cancel_key_lock(void);
 bool process_key_lock(uint16_t *keycode, keyrecord_t *record);
diff --git a/quantum/process_keycode/process_key_override.c b/quantum/process_keycode/process_key_override.c
index 09b2725079..ad9683d106 100644
--- a/quantum/process_keycode/process_key_override.c
+++ b/quantum/process_keycode/process_key_override.c
@@ -106,7 +106,9 @@ void key_override_toggle(void) {
     }
 }
 
-bool key_override_is_enabled(void) { return enabled; }
+bool key_override_is_enabled(void) {
+    return enabled;
+}
 
 // Returns whether the modifiers that are pressed are such that the override should activate
 static bool key_override_matches_active_modifiers(const key_override_t *override, const uint8_t mods) {
@@ -150,7 +152,7 @@ static void schedule_deferred_register(const uint16_t keycode) {
     } else {
         // Wait a very short time when a modifier event triggers the override to avoid false activations when e.g. a modifier is pressed just before a key is released (with the intention of pairing the modifier with a different key), or a modifier is lifted shortly before the trigger key is lifted. Operating systems by default reject modifier-events that happen very close to a non-modifier event.
         defer_reference_time = timer_read32();
-        defer_delay          = 50;  // 50ms
+        defer_delay          = 50; // 50ms
     }
     deferred_register = keycode;
 }
@@ -174,8 +176,8 @@ const key_override_t *clear_active_override(const bool allow_reregister) {
 
     const uint8_t mod_free_replacement = clear_mods_from(active_override->replacement);
 
-    bool unregister_replacement = mod_free_replacement != KC_NO &&    // KC_NO is never registered
-                                  mod_free_replacement < SAFE_RANGE;  // Custom keycodes are never registered
+    bool unregister_replacement = mod_free_replacement != KC_NO &&   // KC_NO is never registered
+                                  mod_free_replacement < SAFE_RANGE; // Custom keycodes are never registered
 
     // Try firing the custom handler
     if (active_override->custom_action != NULL) {
@@ -195,11 +197,11 @@ const key_override_t *clear_active_override(const bool allow_reregister) {
 
     const uint16_t trigger = active_override->trigger;
 
-    const bool reregister_trigger = allow_reregister &&                                                   // Check if allowed from caller
-                                    (active_override->options & ko_option_no_reregister_trigger) == 0 &&  // Check if override allows
-                                    active_override_trigger_is_down &&                                    // Check if trigger is even down
-                                    trigger != KC_NO &&                                                   // KC_NO is never registered
-                                    trigger < SAFE_RANGE;                                                 // A custom keycode should not be registered
+    const bool reregister_trigger = allow_reregister &&                                                  // Check if allowed from caller
+                                    (active_override->options & ko_option_no_reregister_trigger) == 0 && // Check if override allows
+                                    active_override_trigger_is_down &&                                   // Check if trigger is even down
+                                    trigger != KC_NO &&                                                  // KC_NO is never registered
+                                    trigger < SAFE_RANGE;                                                // A custom keycode should not be registered
 
     // Optionally re-register the trigger if it is still down
     if (reregister_trigger) {
@@ -336,8 +338,8 @@ static bool try_activating_override(const uint16_t keycode, const uint8_t layer,
 
         const uint16_t mod_free_replacement = clear_mods_from(override->replacement);
 
-        bool register_replacement = mod_free_replacement != KC_NO &&    // KC_NO is never registered
-                                    mod_free_replacement < SAFE_RANGE;  // Custom keycodes are never registered
+        bool register_replacement = mod_free_replacement != KC_NO &&   // KC_NO is never registered
+                                    mod_free_replacement < SAFE_RANGE; // Custom keycodes are never registered
 
         // Try firing the custom handler
         if (override->custom_action != NULL) {
diff --git a/quantum/process_keycode/process_leader.c b/quantum/process_keycode/process_leader.c
index cf63f25141..c2fd02e5c7 100644
--- a/quantum/process_keycode/process_leader.c
+++ b/quantum/process_keycode/process_leader.c
@@ -51,13 +51,13 @@ bool process_leader(uint16_t keycode, keyrecord_t *record) {
         if (leading) {
 #    ifndef LEADER_NO_TIMEOUT
             if (timer_elapsed(leader_time) < LEADER_TIMEOUT)
-#    endif  // LEADER_NO_TIMEOUT
+#    endif // LEADER_NO_TIMEOUT
             {
 #    ifndef LEADER_KEY_STRICT_KEY_PROCESSING
                 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) {
                     keycode = keycode & 0xFF;
                 }
-#    endif  // LEADER_KEY_STRICT_KEY_PROCESSING
+#    endif // LEADER_KEY_STRICT_KEY_PROCESSING
                 if (leader_sequence_size < (sizeof(leader_sequence) / sizeof(leader_sequence[0]))) {
                     leader_sequence[leader_sequence_size] = keycode;
                     leader_sequence_size++;
diff --git a/quantum/process_keycode/process_magic.c b/quantum/process_keycode/process_magic.c
index d5cff4f12a..10161adda3 100644
--- a/quantum/process_keycode/process_magic.c
+++ b/quantum/process_keycode/process_magic.c
@@ -44,6 +44,7 @@ bool process_magic(uint16_t keycode, keyrecord_t *record) {
             case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_ALT_GUI:
             case MAGIC_SWAP_LCTL_LGUI ... MAGIC_EE_HANDS_RIGHT:
             case MAGIC_TOGGLE_GUI:
+            case MAGIC_TOGGLE_CONTROL_CAPSLOCK:
                 /* keymap config */
                 keymap_config.raw = eeconfig_read_keymap();
                 switch (keycode) {
@@ -75,7 +76,7 @@ bool process_magic(uint16_t keycode, keyrecord_t *record) {
                         keymap_config.swap_backslash_backspace = true;
                         break;
                     case MAGIC_HOST_NKRO:
-                        clear_keyboard();  // clear first buffer to prevent stuck keys
+                        clear_keyboard(); // clear first buffer to prevent stuck keys
                         keymap_config.nkro = true;
                         break;
                     case MAGIC_SWAP_ALT_GUI:
@@ -118,7 +119,7 @@ bool process_magic(uint16_t keycode, keyrecord_t *record) {
                         keymap_config.swap_backslash_backspace = false;
                         break;
                     case MAGIC_UNHOST_NKRO:
-                        clear_keyboard();  // clear first buffer to prevent stuck keys
+                        clear_keyboard(); // clear first buffer to prevent stuck keys
                         keymap_config.nkro = false;
                         break;
                     case MAGIC_UNSWAP_ALT_GUI:
@@ -156,7 +157,7 @@ bool process_magic(uint16_t keycode, keyrecord_t *record) {
 #endif
                         break;
                     case MAGIC_TOGGLE_NKRO:
-                        clear_keyboard();  // clear first buffer to prevent stuck keys
+                        clear_keyboard(); // clear first buffer to prevent stuck keys
                         keymap_config.nkro = !keymap_config.nkro;
                         break;
                     case MAGIC_EE_HANDS_LEFT:
@@ -168,10 +169,13 @@ bool process_magic(uint16_t keycode, keyrecord_t *record) {
                     case MAGIC_TOGGLE_GUI:
                         keymap_config.no_gui = !keymap_config.no_gui;
                         break;
+                    case MAGIC_TOGGLE_CONTROL_CAPSLOCK:
+                        keymap_config.swap_control_capslock = !keymap_config.swap_control_capslock;
+                        break;
                 }
 
                 eeconfig_update_keymap(keymap_config.raw);
-                clear_keyboard();  // clear to prevent stuck keys
+                clear_keyboard(); // clear to prevent stuck keys
 
                 return false;
         }
diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c
index 9632d2b757..c49c31a525 100644
--- a/quantum/process_keycode/process_midi.c
+++ b/quantum/process_keycode/process_midi.c
@@ -22,13 +22,19 @@
 
 #    ifdef MIDI_BASIC
 
-void process_midi_basic_noteon(uint8_t note) { midi_send_noteon(&midi_device, 0, note, 127); }
+void process_midi_basic_noteon(uint8_t note) {
+    midi_send_noteon(&midi_device, 0, note, 127);
+}
 
-void process_midi_basic_noteoff(uint8_t note) { midi_send_noteoff(&midi_device, 0, note, 0); }
+void process_midi_basic_noteoff(uint8_t note) {
+    midi_send_noteoff(&midi_device, 0, note, 0);
+}
 
-void process_midi_all_notes_off(void) { midi_send_cc(&midi_device, 0, 0x7B, 0); }
+void process_midi_all_notes_off(void) {
+    midi_send_cc(&midi_device, 0, 0x7B, 0);
+}
 
-#    endif  // MIDI_BASIC
+#    endif // MIDI_BASIC
 
 #    ifdef MIDI_ADVANCED
 
@@ -41,7 +47,9 @@ static int8_t   midi_modulation_step;
 static uint16_t midi_modulation_timer;
 midi_config_t   midi_config;
 
-inline uint8_t compute_velocity(uint8_t setting) { return setting * (128 / (MIDI_VELOCITY_MAX - MIDI_VELOCITY_MIN)); }
+inline uint8_t compute_velocity(uint8_t setting) {
+    return setting * (128 / (MIDI_VELOCITY_MAX - MIDI_VELOCITY_MIN));
+}
 
 void midi_init(void) {
     midi_config.octave              = MI_OCT_2 - MIDI_OCTAVE_MIN;
@@ -60,7 +68,9 @@ void midi_init(void) {
     midi_modulation_timer = 0;
 }
 
-uint8_t midi_compute_note(uint16_t keycode) { return 12 * midi_config.octave + (keycode - MIDI_TONE_MIN) + midi_config.transpose; }
+uint8_t midi_compute_note(uint16_t keycode) {
+    return 12 * midi_config.octave + (keycode - MIDI_TONE_MIN) + midi_config.transpose;
+}
 
 bool process_midi(uint16_t keycode, keyrecord_t *record) {
     switch (keycode) {
@@ -238,7 +248,7 @@ bool process_midi(uint16_t keycode, keyrecord_t *record) {
     return true;
 }
 
-#    endif  // MIDI_ADVANCED
+#    endif // MIDI_ADVANCED
 
 void midi_task(void) {
     midi_device_process(&midi_device);
@@ -263,4 +273,4 @@ void midi_task(void) {
 #    endif
 }
 
-#endif  // MIDI_ENABLE
+#endif // MIDI_ENABLE
diff --git a/quantum/process_keycode/process_midi.h b/quantum/process_keycode/process_midi.h
index 68c6eda666..e528c6ec0c 100644
--- a/quantum/process_keycode/process_midi.h
+++ b/quantum/process_keycode/process_midi.h
@@ -49,6 +49,6 @@ bool process_midi(uint16_t keycode, keyrecord_t *record);
 #        define MIDI_TONE_COUNT (MIDI_TONE_MAX - MIDI_TONE_MIN + 1)
 
 uint8_t midi_compute_note(uint16_t keycode);
-#    endif  // MIDI_ADVANCED
+#    endif // MIDI_ADVANCED
 
-#endif  // MIDI_ENABLE
+#endif // MIDI_ENABLE
diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
index 6822c5e289..eeec0c28a4 100644
--- a/quantum/process_keycode/process_music.c
+++ b/quantum/process_keycode/process_music.c
@@ -146,7 +146,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
 
     if (music_activated || midi_activated) {
         if (record->event.pressed) {
-            if (keycode == KC_LEFT_CTRL) {  // Start recording
+            if (keycode == KC_LEFT_CTRL) { // Start recording
                 music_all_notes_off();
                 music_sequence_recording = true;
                 music_sequence_recorded  = false;
@@ -155,9 +155,9 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
                 return false;
             }
 
-            if (keycode == KC_LEFT_ALT) {  // Stop recording/playing
+            if (keycode == KC_LEFT_ALT) { // Stop recording/playing
                 music_all_notes_off();
-                if (music_sequence_recording) {  // was recording
+                if (music_sequence_recording) { // was recording
                     music_sequence_recorded = true;
                 }
                 music_sequence_recording = false;
@@ -165,7 +165,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
                 return false;
             }
 
-            if (keycode == KC_LEFT_GUI && music_sequence_recorded) {  // Start playing
+            if (keycode == KC_LEFT_GUI && music_sequence_recorded) { // Start playing
                 music_all_notes_off();
                 music_sequence_recording = false;
                 music_sequence_playing   = true;
@@ -230,11 +230,17 @@ bool music_mask(uint16_t keycode) {
 #    endif
 }
 
-__attribute__((weak)) bool music_mask_kb(uint16_t keycode) { return music_mask_user(keycode); }
+__attribute__((weak)) bool music_mask_kb(uint16_t keycode) {
+    return music_mask_user(keycode);
+}
 
-__attribute__((weak)) bool music_mask_user(uint16_t keycode) { return keycode < 0xFF; }
+__attribute__((weak)) bool music_mask_user(uint16_t keycode) {
+    return keycode < 0xFF;
+}
 
-bool is_music_on(void) { return (music_activated != 0); }
+bool is_music_on(void) {
+    return (music_activated != 0);
+}
 
 void music_toggle(void) {
     if (!music_activated) {
@@ -260,7 +266,9 @@ void music_off(void) {
 #    endif
 }
 
-bool is_midi_on(void) { return (midi_activated != 0); }
+bool is_midi_on(void) {
+    return (midi_activated != 0);
+}
 
 void midi_toggle(void) {
     if (!midi_activated) {
@@ -315,4 +323,4 @@ __attribute__((weak)) void midi_on_user() {}
 
 __attribute__((weak)) void music_scale_user() {}
 
-#endif  // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
+#endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
diff --git a/quantum/process_keycode/process_music.h b/quantum/process_keycode/process_music.h
index e275cd9d26..83726a05ba 100644
--- a/quantum/process_keycode/process_music.h
+++ b/quantum/process_keycode/process_music.h
@@ -51,8 +51,10 @@ bool music_mask_kb(uint16_t keycode);
 bool music_mask_user(uint16_t keycode);
 
 #    ifndef SCALE
-#        define SCALE \
-            (int8_t[]) { 0 + (12 * 0), 2 + (12 * 0), 4 + (12 * 0), 5 + (12 * 0), 7 + (12 * 0), 9 + (12 * 0), 11 + (12 * 0), 0 + (12 * 1), 2 + (12 * 1), 4 + (12 * 1), 5 + (12 * 1), 7 + (12 * 1), 9 + (12 * 1), 11 + (12 * 1), 0 + (12 * 2), 2 + (12 * 2), 4 + (12 * 2), 5 + (12 * 2), 7 + (12 * 2), 9 + (12 * 2), 11 + (12 * 2), 0 + (12 * 3), 2 + (12 * 3), 4 + (12 * 3), 5 + (12 * 3), 7 + (12 * 3), 9 + (12 * 3), 11 + (12 * 3), 0 + (12 * 4), 2 + (12 * 4), 4 + (12 * 4), 5 + (12 * 4), 7 + (12 * 4), 9 + (12 * 4), 11 + (12 * 4), }
+#        define SCALE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+            (int8_t[]) {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                0 + (12 * 0), 2 + (12 * 0), 4 + (12 * 0), 5 + (12 * 0), 7 + (12 * 0), 9 + (12 * 0), 11 + (12 * 0), 0 + (12 * 1), 2 + (12 * 1), 4 + (12 * 1), 5 + (12 * 1), 7 + (12 * 1), 9 + (12 * 1), 11 + (12 * 1), 0 + (12 * 2), 2 + (12 * 2), 4 + (12 * 2), 5 + (12 * 2), 7 + (12 * 2), 9 + (12 * 2), 11 + (12 * 2), 0 + (12 * 3), 2 + (12 * 3), 4 + (12 * 3), 5 + (12 * 3), 7 + (12 * 3), 9 + (12 * 3), 11 + (12 * 3), 0 + (12 * 4), 2 + (12 * 4), 4 + (12 * 4), 5 + (12 * 4), 7 + (12 * 4), 9 + (12 * 4), 11 + (12 * 4), \
+            }
 #    endif
 
-#endif  // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
+#endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
diff --git a/quantum/process_keycode/process_printer.c b/quantum/process_keycode/process_printer.c
index 82528cc680..6dd1f28c9b 100644
--- a/quantum/process_keycode/process_printer.c
+++ b/quantum/process_keycode/process_printer.c
@@ -16,16 +16,19 @@
 
 #include "process_printer.h"
 #include "action_util.h"
+#include "uart.h"
 
 bool    printing_enabled = false;
 uint8_t character_shift  = 0;
 
 void enable_printing(void) {
     printing_enabled = true;
-    serial_init();
+    uart_init(19200);
 }
 
-void disable_printing(void) { printing_enabled = false; }
+void disable_printing(void) {
+    printing_enabled = false;
+}
 
 uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
 
@@ -35,12 +38,13 @@ uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0
 
 void print_char(char c) {
     USB_Disable();
-    serial_send(c);
+    uart_write(c);
     USB_Init();
 }
 
 void print_string(char c[]) {
-    for (uint8_t i = 0; i < strlen(c); i++) print_char(c[i]);
+    for (uint8_t i = 0; i < strlen(c); i++)
+        print_char(c[i]);
 }
 
 void print_box_string(const char text[]) {
diff --git a/quantum/process_keycode/process_printer.h b/quantum/process_keycode/process_printer.h
index 3c6d06ff94..6f4d09f333 100644
--- a/quantum/process_keycode/process_printer.h
+++ b/quantum/process_keycode/process_printer.h
@@ -18,6 +18,4 @@
 
 #include "quantum.h"
 
-#include "protocol/serial.h"
-
 bool process_printer(uint16_t keycode, keyrecord_t *record);
diff --git a/quantum/process_keycode/process_printer_bb.c b/quantum/process_keycode/process_printer_bb.c
index 6c91bd27ef..88a9f33994 100644
--- a/quantum/process_keycode/process_printer_bb.c
+++ b/quantum/process_keycode/process_printer_bb.c
@@ -25,13 +25,21 @@ uint8_t character_shift  = 0;
 #define SERIAL_PIN_MASK _BV(PD3)
 #define SERIAL_DELAY 52
 
-inline static void serial_delay(void) { _delay_us(SERIAL_DELAY); }
+inline static void serial_delay(void) {
+    _delay_us(SERIAL_DELAY);
+}
 
-inline static void serial_high(void) { SERIAL_PIN_PORT |= SERIAL_PIN_MASK; }
+inline static void serial_high(void) {
+    SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
+}
 
-inline static void serial_low(void) { SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK; }
+inline static void serial_low(void) {
+    SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
+}
 
-inline static void serial_output(void) { SERIAL_PIN_DDR |= SERIAL_PIN_MASK; }
+inline static void serial_output(void) {
+    SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
+}
 
 void enable_printing() {
     printing_enabled = true;
@@ -39,7 +47,9 @@ void enable_printing() {
     serial_high();
 }
 
-void disable_printing() { printing_enabled = false; }
+void disable_printing() {
+    printing_enabled = false;
+}
 
 uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
 
@@ -61,7 +71,8 @@ void print_char(char c) {
 }
 
 void print_string(char c[]) {
-    for (uint8_t i = 0; i < strlen(c); i++) print_char(c[i]);
+    for (uint8_t i = 0; i < strlen(c); i++)
+        print_char(c[i]);
 }
 
 bool process_printer(uint16_t keycode, keyrecord_t *record) {
diff --git a/quantum/process_keycode/process_rgb.c b/quantum/process_keycode/process_rgb.c
index 69853cd5c4..c805bd615d 100644
--- a/quantum/process_keycode/process_rgb.c
+++ b/quantum/process_keycode/process_rgb.c
@@ -51,12 +51,8 @@ static void __attribute__((noinline, unused)) handleKeycodeRGBMode(const uint8_t
  * Handle keycodes for both rgblight and rgbmatrix
  */
 bool process_rgb(const uint16_t keycode, const keyrecord_t *record) {
-#ifndef SPLIT_KEYBOARD
-    if (record->event.pressed) {
-#else
-    // Split keyboards need to trigger on key-up for edge-case issue
+    // need to trigger on key-up for edge-case issue
     if (!record->event.pressed) {
-#endif
 #if (defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)) || (defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES))
         uint8_t shifted = get_mods() & MOD_MASK_SHIFT;
 #endif
diff --git a/quantum/process_keycode/process_steno.c b/quantum/process_keycode/process_steno.c
index 5d0bb313b4..12ee898212 100644
--- a/quantum/process_keycode/process_steno.c
+++ b/quantum/process_keycode/process_steno.c
@@ -102,11 +102,17 @@ void steno_set_mode(steno_mode_t new_mode) {
 /* override to intercept chords right before they get sent.
  * return zero to suppress normal sending behavior.
  */
-__attribute__((weak)) bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { return true; }
+__attribute__((weak)) bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) {
+    return true;
+}
 
-__attribute__((weak)) bool postprocess_steno_user(uint16_t keycode, keyrecord_t *record, steno_mode_t mode, uint8_t chord[6], int8_t pressed) { return true; }
+__attribute__((weak)) bool postprocess_steno_user(uint16_t keycode, keyrecord_t *record, steno_mode_t mode, uint8_t chord[6], int8_t pressed) {
+    return true;
+}
 
-__attribute__((weak)) bool process_steno_user(uint16_t keycode, keyrecord_t *record) { return true; }
+__attribute__((weak)) bool process_steno_user(uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
 
 static void send_steno_chord(void) {
     if (send_steno_chord_user(mode, chord)) {
@@ -114,11 +120,11 @@ static void send_steno_chord(void) {
             case STENO_MODE_BOLT:
                 send_steno_state(BOLT_STATE_SIZE, false);
 #ifdef VIRTSER_ENABLE
-                virtser_send(0);  // terminating byte
+                virtser_send(0); // terminating byte
 #endif
                 break;
             case STENO_MODE_GEMINI:
-                chord[0] |= 0x80;  // Indicate start of packet
+                chord[0] |= 0x80; // Indicate start of packet
                 send_steno_state(GEMINI_STATE_SIZE, true);
                 break;
         }
@@ -126,9 +132,13 @@ static void send_steno_chord(void) {
     steno_clear_state();
 }
 
-uint8_t *steno_get_state(void) { return &state[0]; }
+uint8_t *steno_get_state(void) {
+    return &state[0];
+}
 
-uint8_t *steno_get_chord(void) { return &chord[0]; }
+uint8_t *steno_get_chord(void) {
+    return &chord[0];
+}
 
 static bool update_state_bolt(uint8_t key, bool press) {
     uint8_t boltcode = pgm_read_byte(boltmap + key);
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index c707fdea30..e99119b2ae 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -86,7 +86,9 @@ static inline void _process_tap_dance_action_fn(qk_tap_dance_state_t *state, voi
     }
 }
 
-static inline void process_tap_dance_action_on_each_tap(qk_tap_dance_action_t *action) { _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_each_tap); }
+static inline void process_tap_dance_action_on_each_tap(qk_tap_dance_action_t *action) {
+    _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_each_tap);
+}
 
 static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_action_t *action) {
     if (action->state.finished) return;
@@ -173,7 +175,7 @@ void tap_dance_task() {
             tap_user_defined = action->custom_tapping_term;
         } else {
 #ifdef TAPPING_TERM_PER_KEY
-            tap_user_defined = get_tapping_term(action->state.keycode, NULL);
+            tap_user_defined = get_tapping_term(action->state.keycode, &(keyrecord_t){});
 #else
             tap_user_defined = TAPPING_TERM;
 #endif
diff --git a/quantum/process_keycode/process_terminal.c b/quantum/process_keycode/process_terminal.c
index a059f3a521..da1c4d506f 100644
--- a/quantum/process_keycode/process_terminal.c
+++ b/quantum/process_keycode/process_terminal.c
@@ -27,12 +27,12 @@
 bool terminal_enabled = false;
 char buffer[80]       = "";
 char cmd_buffer[CMD_BUFF_SIZE][80];
-bool cmd_buffer_enabled = true;  // replace with ifdef?
+bool cmd_buffer_enabled = true; // replace with ifdef?
 char newline[2]         = "\n";
 char arguments[6][20];
 bool firstTime = true;
 
-short int current_cmd_buffer_pos = 0;  // used for up/down arrows - keeps track of where you are in the command buffer
+short int current_cmd_buffer_pos = 0; // used for up/down arrows - keeps track of where you are in the command buffer
 
 __attribute__((weak)) const char terminal_prompt[8] = "> ";
 
@@ -59,7 +59,8 @@ void enable_terminal(void) {
     terminal_enabled = true;
     strcpy(buffer, "");
     memset(cmd_buffer, 0, CMD_BUFF_SIZE * 80);
-    for (int i = 0; i < 6; i++) strcpy(arguments[i], "");
+    for (int i = 0; i < 6; i++)
+        strcpy(arguments[i], "");
     // select all text to start over
     // SEND_STRING(SS_LCTL("a"));
     send_string(terminal_prompt);
@@ -160,7 +161,7 @@ void print_cmd_buff(void) {
     for (int i = 0; i < CMD_BUFF_SIZE; i++) {
         char tmpChar = ' ';
         itoa(i, &tmpChar, 10);
-        const char *tmpCnstCharStr = &tmpChar;  // because sned_string wont take a normal char *
+        const char *tmpCnstCharStr = &tmpChar; // because sned_string wont take a normal char *
         send_string(tmpCnstCharStr);
         SEND_STRING(". ");
         send_string(cmd_buffer[i]);
@@ -185,7 +186,7 @@ void terminal_help(void) {
 }
 
 void command_not_found(void) {
-    wait_ms(50);  // sometimes buffer isnt grabbed quick enough
+    wait_ms(50); // sometimes buffer isnt grabbed quick enough
     SEND_STRING("command \"");
     send_string(buffer);
     SEND_STRING("\" not found\n");
@@ -217,15 +218,16 @@ void process_terminal_command(void) {
 
     if (terminal_enabled) {
         strcpy(buffer, "");
-        for (int i = 0; i < 6; i++) strcpy(arguments[i], "");
+        for (int i = 0; i < 6; i++)
+            strcpy(arguments[i], "");
         SEND_STRING(SS_TAP(X_HOME));
         send_string(terminal_prompt);
     }
 }
 void check_pos(void) {
-    if (current_cmd_buffer_pos >= CMD_BUFF_SIZE) {  // if over the top, move it back down to the top of the buffer so you can climb back down...
+    if (current_cmd_buffer_pos >= CMD_BUFF_SIZE) { // if over the top, move it back down to the top of the buffer so you can climb back down...
         current_cmd_buffer_pos = CMD_BUFF_SIZE - 1;
-    } else if (current_cmd_buffer_pos < 0) {  //...and if you fall under the bottom of the buffer, reset back to 0 so you can climb back up
+    } else if (current_cmd_buffer_pos < 0) { //...and if you fall under the bottom of the buffer, reset back to 0 so you can climb back up
         current_cmd_buffer_pos = 0;
     }
 }
@@ -278,33 +280,33 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
                 case KC_RIGHT:
                     return false;
                     break;
-                case KC_UP:                                             // 0 = recent
-                    check_pos();                                        // check our current buffer position is valid
-                    if (current_cmd_buffer_pos <= CMD_BUFF_SIZE - 1) {  // once we get to the top, dont do anything
+                case KC_UP:                                            // 0 = recent
+                    check_pos();                                       // check our current buffer position is valid
+                    if (current_cmd_buffer_pos <= CMD_BUFF_SIZE - 1) { // once we get to the top, dont do anything
                         str_len = strlen(buffer);
                         for (int i = 0; i < str_len; ++i) {
-                            send_string(SS_TAP(X_BSPACE));  // clear w/e is on the line already
+                            send_string(SS_TAP(X_BSPACE)); // clear w/e is on the line already
                             // process_terminal(KC_BACKSPACE,record);
                         }
                         strncpy(buffer, cmd_buffer[current_cmd_buffer_pos], 80);
 
                         send_string(buffer);
-                        ++current_cmd_buffer_pos;  // get ready to access the above cmd if up/down is pressed again
+                        ++current_cmd_buffer_pos; // get ready to access the above cmd if up/down is pressed again
                     }
                     return false;
                     break;
                 case KC_DOWN:
                     check_pos();
-                    if (current_cmd_buffer_pos >= 0) {  // once we get to the bottom, dont do anything
+                    if (current_cmd_buffer_pos >= 0) { // once we get to the bottom, dont do anything
                         str_len = strlen(buffer);
                         for (int i = 0; i < str_len; ++i) {
-                            send_string(SS_TAP(X_BSPACE));  // clear w/e is on the line already
+                            send_string(SS_TAP(X_BSPACE)); // clear w/e is on the line already
                             // process_terminal(KC_BACKSPACE,record);
                         }
                         strncpy(buffer, cmd_buffer[current_cmd_buffer_pos], 79);
 
                         send_string(buffer);
-                        --current_cmd_buffer_pos;  // get ready to access the above cmd if down/up is pressed again
+                        --current_cmd_buffer_pos; // get ready to access the above cmd if down/up is pressed again
                     }
                     return false;
                     break;
diff --git a/quantum/process_keycode/process_ucis.c b/quantum/process_keycode/process_ucis.c
index d084d2b66c..6a8d8f0ff6 100644
--- a/quantum/process_keycode/process_ucis.c
+++ b/quantum/process_keycode/process_ucis.c
@@ -27,7 +27,7 @@ void qk_ucis_start(void) {
 
 __attribute__((weak)) void qk_ucis_start_user(void) {
     unicode_input_start();
-    register_hex(0x2328);  // ⌨
+    register_hex(0x2328); // ⌨
     unicode_input_finish();
 }
 
diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
index 7685bb1c99..46b77e14ba 100644
--- a/quantum/process_keycode/process_unicode_common.c
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -54,7 +54,9 @@ void unicode_input_mode_init(void) {
     dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
 }
 
-uint8_t get_unicode_input_mode(void) { return unicode_config.input_mode; }
+uint8_t get_unicode_input_mode(void) {
+    return unicode_config.input_mode;
+}
 
 void set_unicode_input_mode(uint8_t mode) {
     unicode_config.input_mode = mode;
@@ -76,7 +78,9 @@ void cycle_unicode_input_mode(int8_t offset) {
 #endif
 }
 
-void persist_unicode_input_mode(void) { eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode); }
+void persist_unicode_input_mode(void) {
+    eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode);
+}
 
 __attribute__((weak)) void unicode_input_start(void) {
     unicode_saved_caps_lock = host_keyboard_led_state().caps_lock;
@@ -90,8 +94,8 @@ __attribute__((weak)) void unicode_input_start(void) {
         tap_code(KC_CAPS_LOCK);
     }
 
-    unicode_saved_mods = get_mods();  // Save current mods
-    clear_mods();                     // Unregister mods to start from a clean state
+    unicode_saved_mods = get_mods(); // Save current mods
+    clear_mods();                    // Unregister mods to start from a clean state
 
     switch (unicode_config.input_mode) {
         case UC_MAC:
@@ -140,7 +144,7 @@ __attribute__((weak)) void unicode_input_finish(void) {
             break;
     }
 
-    set_mods(unicode_saved_mods);  // Reregister previously set mods
+    set_mods(unicode_saved_mods); // Reregister previously set mods
 }
 
 __attribute__((weak)) void unicode_input_cancel(void) {
@@ -165,7 +169,7 @@ __attribute__((weak)) void unicode_input_cancel(void) {
             break;
     }
 
-    set_mods(unicode_saved_mods);  // Reregister previously set mods
+    set_mods(unicode_saved_mods); // Reregister previously set mods
 }
 
 // clang-format off
@@ -262,16 +266,16 @@ void send_unicode_hex_string(const char *str) {
 static const char *decode_utf8(const char *str, int32_t *code_point) {
     const char *next;
 
-    if (str[0] < 0x80) {  // U+0000-007F
+    if (str[0] < 0x80) { // U+0000-007F
         *code_point = str[0];
         next        = str + 1;
-    } else if ((str[0] & 0xE0) == 0xC0) {  // U+0080-07FF
+    } else if ((str[0] & 0xE0) == 0xC0) { // U+0080-07FF
         *code_point = ((int32_t)(str[0] & 0x1F) << 6) | ((int32_t)(str[1] & 0x3F) << 0);
         next        = str + 2;
-    } else if ((str[0] & 0xF0) == 0xE0) {  // U+0800-FFFF
+    } else if ((str[0] & 0xF0) == 0xE0) { // U+0800-FFFF
         *code_point = ((int32_t)(str[0] & 0x0F) << 12) | ((int32_t)(str[1] & 0x3F) << 6) | ((int32_t)(str[2] & 0x3F) << 0);
         next        = str + 3;
-    } else if ((str[0] & 0xF8) == 0xF0 && (str[0] <= 0xF4)) {  // U+10000-10FFFF
+    } else if ((str[0] & 0xF8) == 0xF0 && (str[0] <= 0xF4)) { // U+10000-10FFFF
         *code_point = ((int32_t)(str[0] & 0x07) << 18) | ((int32_t)(str[1] & 0x3F) << 12) | ((int32_t)(str[2] & 0x3F) << 6) | ((int32_t)(str[3] & 0x3F) << 0);
         next        = str + 4;
     } else {
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
index 72defb445e..1a6607c757 100644
--- a/quantum/process_keycode/process_unicode_common.h
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -59,12 +59,12 @@
 #define UC_OSX UC_MAC
 
 enum unicode_input_modes {
-    UC_MAC,    // macOS using Unicode Hex Input
-    UC_LNX,    // Linux using IBus
-    UC_WIN,    // Windows using EnableHexNumpad
-    UC_BSD,    // BSD (not implemented)
-    UC_WINC,   // Windows using WinCompose (https://github.com/samhocevar/wincompose)
-    UC__COUNT  // Number of available input modes (always leave at the end)
+    UC_MAC,   // macOS using Unicode Hex Input
+    UC_LNX,   // Linux using IBus
+    UC_WIN,   // Windows using EnableHexNumpad
+    UC_BSD,   // BSD (not implemented)
+    UC_WINC,  // Windows using WinCompose (https://github.com/samhocevar/wincompose)
+    UC__COUNT // Number of available input modes (always leave at the end)
 };
 
 typedef union {