hotkey and typing on after keyup solution

[happyf-weallareeuropean]

when you using letter key as modifier, it need to act both quiet and write letter, which after_keyup or if_along.
but that introduce typing problem. eg say you set mud_a after keyup to a, you try to type 'akhetonics' but with that manipulation make you actually type kahetonics or khaetonics.
so we need to add new functionality that when during hold, delay rest letter key fire on keydown to until the specify key after keyup.

secound, after you put the action in the mud_a then k key to arrow up. the hotkey also should fire on strict oder of e need to be the first to keyup. if didnot have this, then even akhetonics type as akhetonics, ak might mostly bring you to the hotkey action cuz most our typing is not keyup a then keydown k sequentially wait, rather keyup a before k keyup etc.

[happyf-weallareeuropean]

let's have some Examples, we assume this is a defualt keyboard, mutify from start.

a: a dual-role with symbol buffering until a keyup, then flush

{
"description": "a mod",
"manipulators": [
{
"type": "basic",
"from": { "key_code": "a" },

  "to": [{ "set_variable": { "name": "a_held", "value": 1 } }],

  "to_after_key_up": [
    { "set_variable": { "name": "a_held", "value": 0 } },
    { "key_code": "a" }
  ],
  "start_buf_symbol_on_from_down_until_from_up_flush": true
}

]
}

Abstract timeline:
• start: on from keydown (a down)
• buffer: only symbol keys
• end: on from keyup (a up)
• flush: emit buffered keys at that boundary

Timeline example:
Input: a down, f down, a up, f up, t down ...
• a down -> a_held=1, buffering starts
• f down -> f goes into buffer (nothing emitted yet)
• a up -> flush buffer -> to_after_key_up emits a, then emit f
• output becomes fa, if without start_buf_symbol_on_from_down_until_from_up_flush
• output becomes f, if you without adding keycode 'a' at after keyup

important role is flush are after to_after_key_up
and "start_buf_symbol_on_from_down_until_from_up_flush": true was locally per manipulators

⸻
b: base on earlier a mod setup, adding s is a chord key, strict keyup order decides

{
"type": "basic",
"conditions": [{ "name": "a_held", "type": "variable_if", "value": 1 }],
"from": { "key_code": "s", "modifiers": { "optional": ["any"] } },

"from_strict_key_up_order": ["s", "a_held"],

"to": [{ "key_code": "left_arrow" }],

"cancel_buf_and_flush_on_to_triggered": true,
"cancel_after_key_up_symbol_key": true
}

example timeline:

Case 1 (you want arrow, and you want to kill buffered typing):
• a down -> a_held=1 (buffering active from the other rule)
• s down, s goes into buffer
• s up happens while a_held==1
• strict order ["s","a_held"] is satisfied at the moment of s up
• to fires -> left_arrow
• cancel_buf_and_flush_on_to_triggered:true runs right now
• buffer is dropped (so no delayed letters leak out later)
• later a up -> does not flush any buffered symbol keys (because buffer was cancelled)
• the a key doesnot send. thx to cancel_after_key_up_symbol_key.

So a sequence like: a down, s down, a up, s up
does NOT trigger because when s up happens, a_held is already 0, so the strict condition fails.

Case 2 (typing, no arrow):
• a down -> a_held=1
• s down
• a up -> a_held=0
• s up -> strict order fails -> no to -> buffer (if any) flushes normally at a up

That matches your intent: arrow only when s keyup occurs before a keyup (or equivalently: s up while a_held==1).
all those
⸻

•	start_buf_symbol_on_from_down_until_from_up_flush (start buffering when this manipulator triggers)
•	from_strict_key_up_order
•	cancel_after_key_up_symbol_key 
•	cancel_buf_and_flush_on_to_triggered

[tekezo]

I believe this request is addressed exactly by this configuration, so please give it a try.
https://karabiner-elements.pqrs.org/docs/json/expert-complex-modifications-examples/letter-key-release-order-modifier/