diff --git a/VERSIONS_HOTLINE/170600 b/VERSIONS_HOTLINE/170600
new file mode 100644
index 0000000000000000000000000000000000000000..738469942ee076c3d1f328d644cd8faaa5320f04
--- /dev/null
+++ b/VERSIONS_HOTLINE/170600
@@ -0,0 +1 @@
+ - correctif #170600 : Cosmogramme : correction de l'affichage des règles de paramétrage des facettes dynamiques
\ No newline at end of file
diff --git a/library/Class/CodifThesaurus/ListRules.php b/library/Class/CodifThesaurus/ListRules.php
index 488f85d54eefebf96b531a69d83da718a2c8f91e..6c0091497668eb9f9ea08dc1e0f9851c7432ab8f 100644
--- a/library/Class/CodifThesaurus/ListRules.php
+++ b/library/Class/CodifThesaurus/ListRules.php
@@ -22,21 +22,18 @@
 
 class Class_CodifThesaurus_ListRules {
 
-  protected $_list_rules;
+  protected Storm_Collection $_list_rules;
 
   public function __construct() {
     $this->_list_rules = new Storm_Collection();
   }
 
 
-  public function initialize($datas) {
-    if (!$rules = json_decode($datas, true))
+  public function initialize(?string $datas) : self {
+    if ( ! $rules = json_decode($datas, true))
       return $this;
 
-    if (!is_array($rules))
-      $rules = [ $rules ];
-
-    foreach ($rules as $rule) {
+    foreach ($this->_forLegacyDo($rules) as $rule) {
       $new_rule = new Class_CodifThesaurus_Rules();
       $new_rule->initializeFields($rule);
       $this->_list_rules->add($new_rule);
@@ -46,18 +43,23 @@ class Class_CodifThesaurus_ListRules {
   }
 
 
-  public function clean() {
+  protected function _forLegacyDo(array $rules) : array {
+    return is_array(reset($rules))
+      ? $rules
+      : [$rules];
+  }
+
+
+  public function clean() : self {
     $this->_list_rules = $this->_withNotEmpty();
+
     return $this;
   }
 
 
-  public function format() {
+  public function format() : ?string {
     $list_format = $this->_withNotEmpty()
-      ->collect(function ($rules)
-                {
-                  return $rules->asArray();
-                })
+      ->collect(fn($rules) => $rules->asArray())
       ->getArrayCopy();
 
     return $list_format
@@ -66,43 +68,35 @@ class Class_CodifThesaurus_ListRules {
   }
 
 
-  public function withLabelAndIdListRulesDo($closure) {
-    return $this->_injectIntoDo(function ($result, $rules) use ($closure)
-                                {
-                                  return array_merge($result, $rules->withLabelAndIdDo($closure));
-                                });
+  public function withLabelAndIdListRulesDo(Closure $closure) : array {
+    return $this
+      ->_injectIntoDo(fn($result, $rules) => array_merge($result,
+                                                         $rules->withLabelAndIdDo($closure)));
   }
 
 
-  public function withRulesDo($closure) {
-    return $this->_injectIntoDo(function ($result, $rules) use ($closure)
-                                {
-                                  return array_merge($result, $closure($rules));
-                                });
+  public function withRulesDo(Closure $closure) : array {
+    return $this->_injectIntoDo(fn($result, $rules) => array_merge($result, $closure($rules)));
   }
 
 
-  public function isIdFieldsEmpty() {
+  public function isIdFieldsEmpty() : bool {
     return 0 == count(array_filter($this->getListIdField()));
   }
 
 
-  public function existsByZoneLabel($zone, $label) {
-    return 0 < $this->_list_rules->select(function ($rules) use ($zone, $label)
-                                          {
-                                            return $zone === $rules->getZone()
-                                              && $label === $rules->getLabelField();
-                                          })
-                                 ->count();
+  public function existsByZoneLabel(string $zone, string $label) : bool {
+    return 0 < $this->_list_rules
+      ->select(fn($rules) => $zone === $rules->getZone()
+                             && $label === $rules->getLabelField())
+      ->count();
   }
 
 
-  public function validate($codif_thesaurus) {
+  public function validate(Class_CodifThesaurus $codif_thesaurus) : self {
     $this->_withNotEmpty()
-         ->eachDo(function ($rules) use ($codif_thesaurus)
-                  {
-                    $codif_thesaurus->check($rules->isValid(), $rules->getErrorMessage());
-                  });
+         ->eachDo(fn($rules) => $codif_thesaurus->check($rules->isValid(),
+                                                        $rules->getErrorMessage()));
     return $this;
   }
 
@@ -110,7 +104,9 @@ class Class_CodifThesaurus_ListRules {
   public function getLabelFromZoneIdField() : string {
     return implode('', $this->_list_rules
                    ->select(fn($rules) => $rules->getIdField())
-                   ->collect(fn($rules) => sprintf(' (%s$%s)', $rules->getZone(), $rules->getIdField()))
+                   ->collect(fn($rules) => sprintf(' (%s$%s)',
+                                                   $rules->getZone(),
+                                                   $rules->getIdField()))
                    ->getArrayCopy());
   }
 
@@ -155,88 +151,84 @@ class Class_CodifThesaurus_ListRules {
   }
 
 
-  public function setListZone($values) {
+  public function setListZone(array $values) : self {
     return $this->_setFromList('Zone', $values);
   }
 
 
-  public function setListLabelField($values) {
+  public function setListLabelField(array $values) : self {
     return $this->_setFromList('LabelField', $values);
   }
 
 
-  public function setListIdField($values) {
+  public function setListIdField(array $values) : self {
     return $this->_setFromList('IdField', $values);
   }
 
 
-  public function setListLabelStartPos($values) {
+  public function setListLabelStartPos(array $values) : self {
     return $this->_setFromList('LabelStartPos', $values);
   }
 
 
-  public function setListLabelLength($values) {
+  public function setListLabelLength(array $values) : self {
     return $this->_setFromList('LabelLength', $values);
   }
 
 
-  public function setListFilterField($values) {
+  public function setListFilterField(array $values) : self {
     return $this->_setFromList('FilterField', $values);
   }
 
 
-  public function setListFilterValue($values) {
+  public function setListFilterValue(array $values) : self {
     return $this->_setFromList('FilterValue', $values);
   }
 
 
-  public function setListDomainId($values) {
+  public function setListDomainId(array $values) : self {
     return $this->_setFromList('DomainId', $values);
   }
 
 
-  protected function _getFromList($field) {
-    return $this->_list_rules->collect(function($rules) use($field)
-                                       {
-                                         return call_user_func([$rules, 'get' . $field]);
-                                       })
+  protected function _getFromList(string $field) : array {
+    return $this->_list_rules->collect(fn($rules) => call_user_func([$rules, 'get' . $field]))
                              ->getArrayCopy();
   }
 
 
-  protected function _setFromList($name, $fields) {
+  protected function _setFromList(string $name, array $fields) : self {
     if ($this->_list_rules->count() > count($fields))
       $this->_list_rules = new Storm_Collection();
 
     $name = 'set' . $name;
     foreach ($fields as $pos => $value)
       $this->_getOrCreateRules($pos)->$name($value);
+
     return $this;
   }
 
 
-  protected function _withNotEmpty() {
+  protected function _withNotEmpty() : Storm_Collection {
     return $this->_list_rules
-      ->reject(function ($rules)
-               {
-                 return $rules->isEmpty();
-               });
+      ->reject(fn($rules) => $rules->isEmpty());
   }
 
 
-  protected function _injectIntoDo($closure) {
+  protected function _injectIntoDo(Closure $closure) : array {
     return $this->_withNotEmpty()
                 ->injectInto([], $closure);
   }
 
 
-  protected function _getOrCreateRules($position) {
+  protected function _getOrCreateRules(int $position) : Class_CodifThesaurus_Rules {
     if ($this->_list_rules->count() > $position
         && $rules = $this->_list_rules->offsetGet($position))
       return $rules;
 
     $rules = new Class_CodifThesaurus_Rules();
     $this->_list_rules->add($rules);
+
     return $rules;
   }
 }
diff --git a/tests/scenarios/Catalog/CustomCatalogTest.php b/tests/scenarios/Catalog/CustomCatalogTest.php
index fd3c31a4dc633b7c7a64742e44e5a49739579ba9..f42b80273e1d059395fe79a56b5ed9941e87e957 100644
--- a/tests/scenarios/Catalog/CustomCatalogTest.php
+++ b/tests/scenarios/Catalog/CustomCatalogTest.php
@@ -880,6 +880,13 @@ class CustomCatalogControllerPostWithCustomThesaurusElementTest
     $this->assertEquals(' Where (MATCH(facettes) AGAINST(\'+F329 +HDEWE0010 +HTHME0052 +HGEN00089\' IN BOOLEAN MODE)) and type=1',
                         Class_Catalogue::getQueryConditionsForDomain(Class_Catalogue::find(7)));
   }
+
+
+  /** @test */
+  public function codifThesaurusListRulesInitializeShouldCroteRules() {
+    $this->assertEquals('[{"LabelStartPos":1,"LabelLength":0,"Zone":"910","LabelField":"b"}]',
+                        (Class_CodifThesaurus::find(7897)->getRules()));
+  }
 }
 
 
@@ -960,4 +967,4 @@ class CustomCatalogControllerWithThesaurusPostTest
 
     $this->fail('Unknown column catalogue.parc');
   }
-}
\ No newline at end of file
+}