@@ -0,0 +1 @@
+Process events with less CPU on the backend: iterating, sorting and reading list and dataclass state values costs 25–75% less, and the redis state manager writes the changed states of a session in one round trip.
@@ -0,0 +1 @@
+Lower the CPU cost of every backend event: cached computed var reads, field reads and writes, event dispatch and the JSON encoding of state deltas are faster. A computed var returning a value of the wrong type is now logged once per computed value instead of on every read, and `EventHandler.is_background` and `EventHandler.supersedes` are read once per handler, so mark the function before the handler is first used.
@@ -0,0 +1 @@
+Building Vars (operations, comparisons, `rx.cond`, `rx.foreach`) is up to twice as fast, so pages that derive many Vars compile faster; the generated code is unchanged.
@@ -9,7 +9,7 @@
 import warnings
 from base64 import b64encode
 from collections.abc import Callable, Mapping, Sequence
-from functools import lru_cache, partial
+from functools import cached_property, lru_cache, partial
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -611,16 +611,27 @@ def __class_getitem__(cls, args_spec: str) -> Annotated:
         """
         return Annotated[cls, args_spec]
 
-    @property
+    @cached_property
     def is_background(self) -> bool:
         """Whether the event handler is a background task.
 
+        Read on the first access, so the function has to be marked before then.
+
         Returns:
             True if the event handler is marked as a background task.
         """
         return getattr(self.fn, BACKGROUND_TASK_MARKER, False)
 
-    @property
+    @cached_property
+    def _is_coroutine_function(self) -> bool:
+        """Whether the handler function is a coroutine function.
+
+        Returns:
+            True if calling the handler function returns a coroutine.
+        """
+        return inspect.iscoroutinefunction(self.fn)
+
+    @cached_property
     def supersedes(self) -> bool:
         """Whether a newer invocation supersedes an older one.
 
@@ -636,6 +647,7 @@ def supersedes(self) -> bool:
         Cancellation is cooperative: a handler that never yields to the event
         loop runs to completion, and only its not-yet-started chained events
         are skipped.
+        Read on the first access, so the function has to be marked before then.
 
         Returns:
             True if the event handler is marked as superseding.
 
@@ -4,7 +4,7 @@
 
 import dataclasses
 import functools
-import uuid
+import os
 from collections.abc import Callable, Mapping
 from typing import TYPE_CHECKING, Any, Protocol
 
@@ -31,6 +31,15 @@ def get_name(cls: type | Callable) -> str:
     return to_snake_case(f"{module}___{qualname}")
 
 
+def _new_txid() -> str:
+    """Generate a transaction id.
+
+    Returns:
+        12 random hex digits, the same 48 random bits as ``uuid4().hex[:12]``.
+    """
+    return os.urandom(6).hex()
+
+
 class EnqueueProtocol(Protocol):
     """Protocol for the enqueue function in the event context."""
 
@@ -89,7 +98,7 @@ class EventContext(BaseContext):
 
     # Each event is associated with a top-level transaction id. Empty for a
     # context that belongs to no event, like an event processor's root context.
-    txid: str = dataclasses.field(default_factory=lambda: uuid.uuid4().hex[:12])
+    txid: str = dataclasses.field(default_factory=_new_txid)
     # The txid of another EventContext that enqueued this context's event, or
     # None for a top-level event.
     parent_txid: str | None = None
@@ -110,11 +119,14 @@ class EventContext(BaseContext):
     # event a handler yields resolves against the view that produced it.
     router_data: dict[str, Any] = dataclasses.field(default_factory=dict, repr=False)
 
-    def fork(self, token: str | None = None) -> EventContext:
+    def fork(
+        self, token: str | None = None, router_data: dict[str, Any] | None = None
+    ) -> EventContext:
         """Return a new EventContext with the specified fields replaced.
 
         Args:
             token: The client token for the new context.
+            router_data: The routing data for the new context, inherited from this context if empty.
 
         Returns:
             A new EventContext with the specified fields replaced.
@@ -127,7 +139,7 @@ def fork(self, token: str | None = None) -> EventContext:
             enqueue_impl=self.enqueue_impl,
             emit_delta_impl=self.emit_delta_impl,
             emit_event_impl=self.emit_event_impl,
-            router_data=self.router_data,
+            router_data=router_data or self.router_data,
             otel_context=otel.capture_context(),
         )
 
 
@@ -18,16 +18,17 @@
 from reflex.utils import types
 from reflex_base import otel
 from reflex_base.constants import CompileVars
+from reflex_base.event import Event, EventHandler, EventSpec
 from reflex_base.event.context import EventContext
 from reflex_base.event.processor.event_processor import EventProcessor, EventQueueEntry
 from reflex_base.event.processor.future import EventFuture
 from reflex_base.registry import RegisteredEventHandler
 from reflex_base.utils.format import format_event_handler
+from reflex_base.utils.serializers import deserializers
 
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
-    from reflex.event import Event, EventHandler
     from reflex.state import BaseState
 
 # Resolved once at import: find_spec on a missing package scans sys.path (~90us),
@@ -76,7 +77,6 @@ def _check_valid_yield(events: Any, handler_name: str = "unknown") -> Any:
     Raises:
         TypeError: If any of the events are not valid.
     """
-    from reflex.event import Event, EventHandler, EventSpec
 
     def _is_valid_type(events: Any) -> bool:
         return isinstance(events, (Event, EventHandler, EventSpec))
@@ -121,9 +121,6 @@ def _transform_event_arg(value: Any, hinted_args: Any) -> Any:
     Raises:
         ValueError: If a string value is received for an int or float type and cannot be converted.
     """
-    from reflex.model import Model
-    from reflex.utils.serializers import deserializers
-
     if hinted_args is Any:
         return value
     if types.is_union(hinted_args):
@@ -135,6 +132,8 @@ def _transform_event_arg(value: Any, hinted_args: Any) -> Any:
         and isinstance(hinted_args, type)
         and not types.is_generic_alias(hinted_args)  # py3.10
     ):
+        from reflex.model import Model
+
         if issubclass(hinted_args, Model):
             # Remove non-fields from the payload
             return hinted_args(**{
@@ -181,7 +180,7 @@ def _transform_event_payload(
         The transformed event payload.
     """
     transformed = {}
-    for arg, value in list(payload.items()):
+    for arg, value in payload.items():
         hinted_args = type_hints.get(arg, Any)
         try:
             transformed[arg] = _transform_event_arg(value, hinted_args)
@@ -231,8 +230,6 @@ async def chain_updates(
         handler_name: The name of the handler that yielded the events, used for error messages.
         root_state: The root state of the app, no delta emitted if omitted.
     """
-    from reflex.event import Event
-
     ctx = EventContext.get()
 
     if root_state is not None:
@@ -250,8 +247,10 @@ async def chain_updates(
             root_state._clean()
 
     # Convert valid EventHandler and EventSpec into Event
-    if fixed_events := Event.from_event_type(
-        _check_valid_yield(events, handler_name=handler_name),
+    if events is not None and (
+        fixed_events := Event.from_event_type(
+            _check_valid_yield(events, handler_name=handler_name),
+        )
     ):
         await _route_events(ctx, fixed_events)
 
@@ -305,13 +304,16 @@ async def process_event(
     Raises:
         ValueError: If a string value is received for an int or float type and cannot be converted.
     """
-    handler_name = handler.fn.__qualname__
-
-    # Get the function to process the event.
-    fn = functools.partial(handler.fn, state)
+    fn = handler.fn
+    handler_name = fn.__qualname__
 
     try:
-        type_hints = types.get_type_hints(handler.fn)
+        # Resolved hints are cached on the handler, empty for an unannotated one;
+        # fall back for ones that were not resolvable at registration (None),
+        # raising again if still unresolved.
+        type_hints = handler._type_hints
+        if type_hints is None:
+            type_hints = types.get_type_hints(fn)
         payload = _transform_event_payload(payload, type_hints)
     except Exception as ex:
         # No transformation was possible, continue with the original payload
@@ -320,12 +322,12 @@ async def process_event(
         )
 
     # Handle async functions.
-    if inspect.iscoroutinefunction(fn.func):
-        events = await fn(**payload)
+    if handler._is_coroutine_function:
+        events = await fn(state, **payload)
 
     # Handle regular functions.
     else:
-        events = fn(**payload)
+        events = fn(state, **payload)
     # Handle async generators.
     if inspect.isasyncgen(events):
         async for event in events:
@@ -468,16 +470,14 @@ async def _execute_event(
         ) as state:
             if otel.enabled:
                 otel.record_state_acquired(acquire_start, event)
+            previous_router_data = state.router_data
             # Compatibility hack rehydrate the state before processing this event.
             needs_to_rehydrate = bool(
-                not state.router_data and event.name not in _hydrate_event_names()
+                not previous_router_data and event.name not in _hydrate_event_names()
             )
 
             # re-assign only when the value is set and different
-            if (
-                router_data
-                and (previous_router_data := state.router_data) != router_data
-            ):
+            if router_data and previous_router_data != router_data:
                 # only the router vars whose backing keys changed are rebuilt
                 # and re-sent; session/headers stay put across navigations.
                 merged_router_data = state._update_router_vars(
@@ -503,7 +503,7 @@ async def _execute_event(
                 return
 
             # Get the event's substate.
-            substate = await state.get_state(event.state_cls)
+            substate = await state.get_state(registered_handler.states[0])
             root_state = state._get_root_state()
 
             if needs_to_rehydrate:
 
@@ -402,18 +402,22 @@ async def enqueue(
             already enqueued it, the returned future is already cancelled and
             the event is dropped.
         """
+        # The event's router_data is bound before the entry exists, so entry.ctx
+        # is what the handler, the task metadata, and every event it yields all read.
         if ev_ctx is None:
             try:
-                ev_ctx = EventContext.get().fork(token=token)
+                ev_ctx = EventContext.get().fork(
+                    token=token, router_data=event.router_data
+                )
             except LookupError as le:
                 if self._root_context is not None:
-                    ev_ctx = self._root_context.fork(token=token)
+                    ev_ctx = self._root_context.fork(
+                        token=token, router_data=event.router_data
+                    )
                 else:
                     msg = "Event processor is not running, call .start(...) first."
                     raise RuntimeError(msg) from le
-        if event.router_data:
-            # Bound before the entry exists, so entry.ctx is what the handler,
-            # the task metadata, and every event it yields all read.
+        elif event.router_data:
             ev_ctx = dataclasses.replace(ev_ctx, router_data=event.router_data)
         queue = self._ensure_queue_task()
         txid = ev_ctx.txid
@@ -579,7 +583,7 @@ def _try_clean_future(self, future: EventFuture) -> None:  # type: ignore[overri
                 # reusing the txid can chain recovery events normally.
                 return
             # Not checking future.all_done() to avoid waiting for grandchildren here.
-            if not all(c.done() for c in future.children):
+            if (children := future.children) and not all(c.done() for c in children):
                 return
             parent = future.parent
             self._futures.pop(future.txid, None)
@@ -761,7 +765,7 @@ def _create_event_task(
         coro = self._process_event_queue_entry(
             entry=entry, registered_handler=registered_handler
         )
-        name = f"reflex_event|{entry.event.name}|{entry.ctx.token}|{time.time()}"
+        name = f"reflex_event|{entry.event.name}|{entry.ctx.token}|{entry.ctx.txid}"
         loop = asyncio.get_running_loop()
         if (
             sys.version_info >= (3, 12)
@@ -934,14 +938,14 @@ def _resolve_future(
             True if a backend exception handler task was spawned and now owns
             the future's lifecycle, False otherwise.
         """
-        from reflex.utils import telemetry
-
         try:
             result = task.result()
         except asyncio.CancelledError:
             if future is not None and not future.done():
                 future.cancel()
         except Exception as ex:
+            from reflex.utils import telemetry
+
             if future is not None and not future.done():
                 future.set_exception(ex)
                 with contextlib.suppress(BaseException):
 
@@ -718,20 +718,43 @@ def _get_serialize() -> Callable[[Any], Any]:
     return _serialize
 
 
-def json_dumps(obj: Any, **kwargs) -> str:
+@lru_cache
+def _get_json_encoder(separators: tuple[str, str] | None) -> json.JSONEncoder:
+    """Get the JSON encoder that serializes values with the Reflex serializers.
+
+    ``json.dumps`` builds a new encoder on every call when given any option, which
+    dominates the cost of small payloads. Encoders keep no state between calls, so
+    one is shared per set of separators.
+
+    Args:
+        separators: The item and key separators, or None for the default ones.
+
+    Returns:
+        The shared encoder.
+    """
+    return json.JSONEncoder(
+        ensure_ascii=False, default=_get_serialize(), separators=separators
+    )
+
+
+def json_dumps(obj: Any, separators: tuple[str, str] | None = None, **kwargs) -> str:
     """Takes an object and returns a jsonified string.
 
     Args:
         obj: The object to be serialized.
+        separators: The item and key separators, as for json.dumps.
         kwargs: Additional keyword arguments to pass to json.dumps.
 
     Returns:
         A string
     """
+    if not kwargs and (separators is None or isinstance(separators, tuple)):
+        return _get_json_encoder(separators).encode(obj)
+
     kwargs.setdefault("ensure_ascii", False)
     kwargs.setdefault("default", _get_serialize())
 
-    return json.dumps(obj, **kwargs)
+    return json.dumps(obj, separators=separators, **kwargs)
 
 
 def collect_form_dict_names(form_dict: dict[str, Any]) -> dict[str, Any]:
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+Process events with less CPU on the backend: iterating, sorting and reading list and dataclass state values costs 25–75% less, and the redis state manager writes the changed states of a session in one round trip.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+Lower the CPU cost of every backend event: cached computed var reads, field reads and writes, event dispatch and the JSON encoding of state deltas are faster. A computed var returning a value of the wrong type is now logged once per computed value instead of on every read, and `EventHandler.is_background` and `EventHandler.supersedes` are read once per handler, so mark the function before the handler is first used.
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+Building Vars (operations, comparisons, `rx.cond`, `rx.foreach`) is up to twice as fast, so pages that derive many Vars compile faster; the generated code is unchanged.