fix: prevent parent-child minified name collision in substate resolution

When a parent and child state have the same minified name, substate
resolution can fail because the leading segment is stripped incorrectly. This
change adds a flag to skip stripping only on the initial recursive call, ensuring
correct resolution even in name collision scenarios.

Author: benedikt-bartscher

reflex/state.py

@@ -1068,11 +1068,17 @@ def get_full_name(cls) -> str:
 
     @classmethod
     @functools.lru_cache
-    def get_class_substate(cls, path: Sequence[str] | str) -> type[BaseState]:
+    def get_class_substate(
+        cls, path: Sequence[str] | str, _skip_self: bool = True
+    ) -> type[BaseState]:
         """Get the class substate.
 
         Args:
             path: The path to the substate.
+            _skip_self: If True, strip the leading segment when it matches this
+                state's name. Only the initial (root) call should use True;
+                recursive calls pass False so that a child whose minified name
+                collides with its parent is resolved correctly.
 
         Returns:
             The class substate.
@@ -1085,13 +1091,13 @@ def get_class_substate(cls, path: Sequence[str] | str) -> type[BaseState]:
 
         if len(path) == 0:
             return cls
-        if path[0] == cls.get_name():
+        if _skip_self and path[0] == cls.get_name():
             if len(path) == 1:
                 return cls
             path = path[1:]
         for substate in cls.get_substates():
             if path[0] == substate.get_name():
-                return substate.get_class_substate(path[1:])
+                return substate.get_class_substate(path[1:], _skip_self=False)
         msg = f"Invalid path: {path}"
         raise ValueError(msg)
 
@@ -1605,11 +1611,15 @@ def _reset_client_storage(self):
         for substate in self.substates.values():
             substate._reset_client_storage()
 
-    def get_substate(self, path: Sequence[str]) -> BaseState:
+    def get_substate(self, path: Sequence[str], _skip_self: bool = True) -> BaseState:
         """Get the substate.
 
         Args:
             path: The path to the substate.
+            _skip_self: If True, strip the leading segment when it matches this
+                state's name. Only the initial (root) call should use True;
+                recursive calls pass False so that a child whose minified name
+                collides with its parent is resolved correctly.
 
         Returns:
             The substate.
@@ -1619,14 +1629,14 @@ def get_substate(self, path: Sequence[str]) -> BaseState:
         """
         if len(path) == 0:
             return self
-        if path[0] == self.get_name():
+        if _skip_self and path[0] == self.get_name():
             if len(path) == 1:
                 return self
             path = path[1:]
         if path[0] not in self.substates:
             msg = f"Invalid path: {path}"
             raise ValueError(msg)
-        return self.substates[path[0]].get_substate(path[1:])
+        return self.substates[path[0]].get_substate(path[1:], _skip_self=False)
 
     @classmethod
     def _get_potentially_dirty_states(cls) -> set[type[BaseState]]:

tests/units/test_minification.py

@@ -731,3 +731,104 @@ def test_is_minify_enabled_false_when_both_disabled(self, temp_minify_json):
         clear_config_cache()
 
         assert is_minify_enabled() is False
+
+
+class TestMinifiedNameCollision:
+    """Tests for parent-child minified name collision in substate resolution."""
+
+    def test_get_class_substate_with_parent_child_name_collision(
+        self, temp_minify_json, monkeypatch
+    ):
+        """Test that get_class_substate resolves correctly when parent and child
+        share the same minified name (IDs are only sibling-unique).
+        """
+        monkeypatch.setenv("REFLEX_MINIFY_STATE", "enabled")
+
+        # Build a hierarchy: State -> ParentState -> ChildState
+        # where ParentState and ChildState both get minified name "b"
+
+        class ParentState(State):
+            pass
+
+        class ChildState(ParentState):
+            pass
+
+        parent_path = get_state_full_path(ParentState)
+        child_path = get_state_full_path(ChildState)
+
+        config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                "reflex.state.State": "a",
+                parent_path: "b",
+                child_path: "b",  # Same minified name as parent
+            },
+            "events": {},
+        }
+        save_minify_config(config)
+        clear_config_cache()
+        State.get_name.cache_clear()
+        State.get_full_name.cache_clear()
+        State.get_class_substate.cache_clear()
+        ParentState.get_name.cache_clear()
+        ParentState.get_full_name.cache_clear()
+        ChildState.get_name.cache_clear()
+        ChildState.get_full_name.cache_clear()
+
+        # Verify both get the same minified name
+        assert ParentState.get_name() == "b"
+        assert ChildState.get_name() == "b"
+
+        # Full path should be a.b.b
+        assert ChildState.get_full_name() == "a.b.b"
+
+        # get_class_substate should resolve a.b.b to ChildState, not ParentState
+        resolved = State.get_class_substate("a.b.b")
+        assert resolved is ChildState
+
+    def test_get_substate_with_parent_child_name_collision(
+        self, temp_minify_json, monkeypatch
+    ):
+        """Test that get_substate (instance method) resolves correctly when parent
+        and child share the same minified name.
+        """
+        import reflex as rx
+
+        monkeypatch.setenv("REFLEX_MINIFY_STATE", "enabled")
+
+        class ParentState2(State):
+            pass
+
+        class ChildState2(ParentState2):
+            @rx.event
+            def my_handler(self):
+                pass
+
+        parent_path = get_state_full_path(ParentState2)
+        child_path = get_state_full_path(ChildState2)
+
+        config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                "reflex.state.State": "a",
+                parent_path: "b",
+                child_path: "b",  # Same minified name as parent
+            },
+            "events": {},
+        }
+        save_minify_config(config)
+        clear_config_cache()
+        State.get_name.cache_clear()
+        State.get_full_name.cache_clear()
+        State.get_class_substate.cache_clear()
+        ParentState2.get_name.cache_clear()
+        ParentState2.get_full_name.cache_clear()
+        ChildState2.get_name.cache_clear()
+        ChildState2.get_full_name.cache_clear()
+
+        # Create a state instance tree
+        root = State(_reflex_internal_init=True)  # type: ignore[call-arg]
+
+        # Instance get_substate should resolve a.b.b to ChildState2
+        resolved = root.get_substate(["a", "b", "b"])
+        assert type(resolved) is ChildState2