Event type changes when handler is shared

[pokutuna]

Describe the bug

When same handler is used for both a shortcut and button click, pressing Ctrl+Enter unexpectedly triggers a ClickEvent instead of TextareaShortcutEvent.

This is confusing because the handler's expected event type (TextareaShortcutEvent) is overwritten by ClickEvent from later registration.

To Reproduce
Steps to reproduce the behavior:

1. Run this code:

import mesop as me


@me.stateclass
class State:
    event_type: str = ""


def submit(e: me.TextareaShortcutEvent):
    state = me.state(State)
    state.event_type = str(type(e))
    # Cannot access e.value with ClickEvent


@me.page(path="/page1")
def page1():
    state = me.state(State)
    me.textarea(
        placeholder="Ctrl+Enter to submit",
        shortcuts={
            me.Shortcut(ctrl=True, key="Enter"): submit,
        },
    )
    me.text(state.event_type)
    # => <class 'mesop.components.input.input.TextareaShortcutEvent'>


@me.page(path="/page2")
def page2():
    state = me.state(State)
    me.textarea(
        placeholder="Ctrl+Enter to submit",
        shortcuts={
            me.Shortcut(ctrl=True, key="Enter"): submit,
        },
    )
    me.button("submit", on_click=submit)
    me.text(state.event_type)
    # => <class 'mesop.events.events.ClickEvent'>

2. Access /page1 and focus on the textarea and press Ctrl+Enter (works fine)
3. Access /page2 and focus on the textarea and press Ctrl+Enter (unexpectedly triggers ClickEvent)

Expected behavior

• When pressing Ctrl+Enter: Handler should receive TextareaShortcutEvent
• When clicking button: Handler should receive ClickEvent
• Each input should trigger its appropriate event type.

Screenshots

When focusing on the textarea and press Ctrl+Enter:

Desktop System Info

• OS: macOS
• Browser: Chrome 130.0.6723.70（Official Build）（arm64）
• Version: mesop v0.12.8

Additional context

I understand that defining separate handlers for keyboard and mouse events is the correct solution, since event types should naturally correspond to their components.

This is confusing because event types should be determined by the component (button → ClickEvent, shortcut → TextareaShortcutEvent), but instead they are determined by handler registration order.

Having event types determined by registration order or handler assignment makes the behavior unpredictable and breaks the natural component-event relationship.

---

This happens because register_event_handler function overwrites event type mappings.

mesop/mesop/component_helpers/helper.py

Lines 374 to 382 in 69148c9

	def register_event_handler(
	handler_fn: Callable[..., Any], event: Type[E]
	) -> str:
	fn_id = compute_fn_id(handler_fn)
	runtime().context().register_event_handler(
	fn_id, wrap_handler_with_event(handler_fn, event)
	)
	return fn_id

• When registering same function, compute_fn_id generates same ID
• Later registration (button's click event) overwrites earlier one (shortcut event)
• Makes code behavior unexpected and breaks event type

If it's difficult to fix this issue directly in the implementation, I would like to propose the following:

• Add this to Troubleshooting section in documentation.
  https://google.github.io/mesop/guides/event-handlers/#troubleshooting
• Add warnings when this situation.

[wwwillchen]

I think this is pretty difficult to fix implementation-wise and something fairly rare, please feel free to send a PR to improve the docs / add warnings. Thanks.