fix: use actual parent class for sibling grouping in minify sync/validate

sync_minify_config and validate_minify_config grouped siblings by
string-splitting state paths, which fails when children of the same
parent class are defined in different Python modules. This caused
colliding minified IDs (e.g. both getting 'a').

Now uses get_parent_state() class objects for grouping, consistent
with generate_minify_config which was already correct.

Also resolves merge conflicts in _get_event_handler to keep the
minified event name reverse lookup.

Author: benedikt-bartscher

reflex/minify.py

@@ -400,25 +400,24 @@ def validate_minify_config(
 
     all_states = collect_all_states(root_state)
 
-    # Check for duplicate state IDs among siblings
-    # Group states by parent path and check for duplicate minified names
-    parent_to_state_ids: dict[str | None, dict[str, list[str]]] = {}
+    # Check for duplicate state IDs among siblings.
+    # Group by actual parent class (not string-split path) since children of
+    # the same parent can be defined in different modules.
+    path_to_cls = {get_state_full_path(s): s for s in all_states}
+    parent_cls_to_state_ids: dict[type[BaseState] | None, dict[str, list[str]]] = {}
     for state_path, minified_name in config["states"].items():
-        # Get parent path
-        parts = state_path.rsplit(".", 1)
-        parent_path = parts[0] if len(parts) > 1 else None
+        state_cls = path_to_cls.get(state_path)
+        parent_cls = state_cls.get_parent_state() if state_cls else None
+        parent_cls_to_state_ids.setdefault(parent_cls, {}).setdefault(
+            minified_name, []
+        ).append(state_path)
 
-        if parent_path not in parent_to_state_ids:
-            parent_to_state_ids[parent_path] = {}
-        if minified_name not in parent_to_state_ids[parent_path]:
-            parent_to_state_ids[parent_path][minified_name] = []
-        parent_to_state_ids[parent_path][minified_name].append(state_path)
-
-    for parent_path, id_to_states in parent_to_state_ids.items():
+    for parent_cls, id_to_states in parent_cls_to_state_ids.items():
         for minified_name, state_paths in id_to_states.items():
             if len(state_paths) > 1:
+                parent_name = parent_cls.__name__ if parent_cls else "root"
                 errors.append(
-                    f"Duplicate state_id='{minified_name}' under '{parent_path or 'root'}': "
+                    f"Duplicate state_id='{minified_name}' under '{parent_name}': "
                     f"{state_paths}"
                 )
 
@@ -525,31 +524,30 @@ def sync_minify_config(
         # Remove empty event dicts
         new_events = {k: v for k, v in new_events.items() if v}
 
-    # Find states that need IDs assigned
-    # Group by parent for sibling-unique assignment
-    parent_to_children: dict[str | None, list[str]] = {}
+    # Build a map from actual parent class to existing sibling minified IDs.
+    # Using the live state classes avoids the string-split bug where children
+    # of the same parent class defined in different modules get different
+    # string-based parent paths and are assigned colliding IDs.
+    parent_cls_to_existing_ids: dict[type[BaseState] | None, set[int]] = {}
+    for state_cls in all_states:
+        state_path = get_state_full_path(state_cls)
+        if state_path in new_states:
+            parent = state_cls.get_parent_state()
+            parent_cls_to_existing_ids.setdefault(parent, set()).add(
+                minified_name_to_int(new_states[state_path])
+            )
+
+    # Find states that need IDs assigned, grouped by actual parent class.
+    parent_cls_to_new_children: dict[type[BaseState] | None, list[str]] = {}
     for state_cls in all_states:
         state_path = get_state_full_path(state_cls)
         if state_path not in new_states:
             parent = state_cls.get_parent_state()
-            parent_path = get_state_full_path(parent) if parent else None
-            if parent_path not in parent_to_children:
-                parent_to_children[parent_path] = []
-            parent_to_children[parent_path].append(state_path)
-
-    # Assign new state IDs
-    for parent_path, children in parent_to_children.items():
-        # Get existing IDs for this parent's children (convert to ints for finding max)
-        existing_ids: set[int] = set()
-        for state_path, minified_name in new_states.items():
-            parts = state_path.rsplit(".", 1)
-            sp_parent = parts[0] if len(parts) > 1 else None
-            # Compare parent paths correctly
-            if parent_path is None:
-                if sp_parent is None or "." not in state_path:
-                    existing_ids.add(minified_name_to_int(minified_name))
-            elif sp_parent == parent_path:
-                existing_ids.add(minified_name_to_int(minified_name))
+            parent_cls_to_new_children.setdefault(parent, []).append(state_path)
+
+    # Assign new state IDs (unique among siblings of the same parent class)
+    for parent_cls, children in parent_cls_to_new_children.items():
+        existing_ids = parent_cls_to_existing_ids.get(parent_cls, set()).copy()
 
         # Assign IDs starting from max + 1 (or 0 if reassign_deleted and gaps exist)
         next_id = 0 if reassign_deleted else (max(existing_ids, default=-1) + 1)

reflex/state.py

@@ -1780,7 +1780,6 @@ async def get_var_value(self, var: Var[VAR_TYPE]) -> VAR_TYPE:
         )
         return getattr(other_state, var_data.field_name)
 
-<<<<<<< .merge_file_rqeWiK
     @classmethod
     def _get_original_event_name(cls, minified_name: str) -> str | None:
         """Look up the original event handler name from a minified name.
@@ -1797,8 +1796,6 @@ def _get_original_event_name(cls, minified_name: str) -> str | None:
         # Direct lookup: _event_id_to_name maps minified_name -> original_name
         return cls._event_id_to_name.get(minified_name)
 
-=======
->>>>>>> .merge_file_20JAsy
     def _get_event_handler(self, event: Event | str) -> tuple[BaseState, EventHandler]:
         """Get the event handler for the given event.
 
@@ -1821,7 +1818,6 @@ def _get_event_handler(self, event: Event | str) -> tuple[BaseState, EventHandle
             msg = "The value of state cannot be None when processing an event."
             raise ValueError(msg)
 
-<<<<<<< .merge_file_rqeWiK
         # Try to look up the handler directly first
         handler = substate.event_handlers.get(name)
         if handler is None:
@@ -1833,8 +1829,6 @@ def _get_event_handler(self, event: Event | str) -> tuple[BaseState, EventHandle
                 msg = f"Event handler '{name}' not found in state '{type(substate).__name__}'"
                 raise KeyError(msg)
 
-=======
->>>>>>> .merge_file_20JAsy
         return substate, handler
 
     async def _process(self, event: Event) -> AsyncIterator[StateUpdate]:

tests/units/istate/test_proxy.py

@@ -2,7 +2,6 @@
 
 import dataclasses
 import pickle
-<<<<<<< .merge_file_7wIbhS
 from asyncio import CancelledError
 from contextlib import asynccontextmanager
 from unittest.mock import patch
@@ -11,11 +10,6 @@
 
 import reflex as rx
 from reflex.istate.proxy import MutableProxy, StateProxy
-=======
-
-import reflex as rx
-from reflex.istate.proxy import MutableProxy
->>>>>>> .merge_file_giC46q
 
 
 @dataclasses.dataclass
@@ -46,7 +40,6 @@ def test_mutable_proxy_pickle_preserves_object_identity():
     assert unpickled["direct"][0].id == 1
     assert unpickled["proxied"][0].id == 1
     assert unpickled["direct"][0] is unpickled["proxied"][0]
-<<<<<<< .merge_file_7wIbhS
 
 
 @pytest.mark.usefixtures("mock_app")
@@ -73,5 +66,3 @@ async def mock_modify_state_context(*args, **kwargs):  # noqa: RUF029
     # After the exception, we should be able to enter the context again without issues
     async with state_proxy:
         pass
-=======
->>>>>>> .merge_file_giC46q

tests/units/test_minification.py

@@ -318,6 +318,81 @@ def handler_b(self):
             new_config["events"][state_path]["handler_b"] == "l"
         )  # 10 + 1 = 11 -> 'l'
 
+    def test_sync_no_sibling_collision_across_modules(self):
+        """Test that sync assigns unique IDs to siblings of the same parent.
+
+        When children of the same parent state class are defined in different
+        Python modules, their get_state_full_path() produces different string
+        prefixes. The sync function must group siblings by the actual parent
+        class object, not by string-splitting the path, to avoid ID collisions.
+        """
+
+        class ParentState(BaseState):
+            pass
+
+        class ChildA(ParentState):
+            pass
+
+        class ChildB(ParentState):
+            pass
+
+        parent_path = get_state_full_path(ParentState)
+        child_a_path = get_state_full_path(ChildA)
+
+        # Config already has ParentState and ChildA assigned
+        existing_config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                parent_path: "a",
+                child_a_path: "a",
+            },
+            "events": {},
+        }
+
+        # Sync should assign ChildB a DIFFERENT ID than ChildA
+        new_config = sync_minify_config(existing_config, ParentState)
+
+        child_b_path = get_state_full_path(ChildB)
+        assert child_b_path in new_config["states"]
+        assert (
+            new_config["states"][child_a_path] != new_config["states"][child_b_path]
+        ), (
+            f"Sibling collision: ChildA and ChildB both got "
+            f"'{new_config['states'][child_a_path]}'"
+        )
+
+    def test_validate_detects_sibling_collision(self):
+        """Test that validate catches duplicate IDs among siblings of same parent."""
+
+        class ParentState(BaseState):
+            pass
+
+        class ChildA(ParentState):
+            pass
+
+        class ChildB(ParentState):
+            pass
+
+        parent_path = get_state_full_path(ParentState)
+        child_a_path = get_state_full_path(ChildA)
+        child_b_path = get_state_full_path(ChildB)
+
+        # Manually create a config with colliding sibling IDs
+        bad_config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                parent_path: "a",
+                child_a_path: "a",
+                child_b_path: "a",  # collision!
+            },
+            "events": {},
+        }
+
+        errors, _warnings, _missing = validate_minify_config(bad_config, ParentState)
+        assert any("Duplicate" in e and "'a'" in e for e in errors), (
+            f"Expected duplicate ID error, got: {errors}"
+        )
+
 
 class TestStateMinification:
     """Tests for state name minification with minify.json."""