@micheeeeel/yinyangapp 3.0.1 → 3.1.0

package/dist/types/components/controller/actions/KeyEventController.d.ts

@@ -1,8 +1,7 @@
 import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
-import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
-import { CoreEventMenuController } from "./CoreEventMenuController";
+import { KeyEventMenuController } from "./KeyEventMenuController";
 import { ActionStackController } from "../action-stack/ActionStackController";
 import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
 import { EventFieldRenderer } from "../force-field/EventFieldRenderer";
@@ -15,10 +14,8 @@ import { ActionStackManager } from "../action-stack/ActionStackManager";
 export type KeyEventControllerDeps = {
     actionStackController: ActionStackController;
     actionStackManager: ActionStackManager;
-    animateChildrenHide: () => void;
-    buildChildrenOrbitData: () => ChildrenOrbitEntry[];
     closeChildActionMenu: () => void;
-    coreEventMenuController: CoreEventMenuController;
+    keyEventMenuController: KeyEventMenuController;
     eventFieldLifecycleController: EventFieldLifecycleController;
     eventFieldRenderer: EventFieldRenderer;
     forceFieldDetailsPanel: ForceFieldDetailsPanel;
@@ -27,52 +24,93 @@ export type KeyEventControllerDeps = {
         y: number;
     } | null;
     getCurrentComponentOrUndefined: () => YinYangInternalModel["components"][number] | undefined;
+    /** Satellite-facette d'une facette en sous-état Idle « facettes » : centre
+     *  rendu et rayon, ou null s'il n'est pas (encore) affiché. */
+    getFacetteSatelliteAnchor: (componentId: string) => {
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    } | null;
+    /** Vrai quand le sous-état Idle « facettes » est affiché. */
+    isIdleFacettesActive: () => boolean;
+    /** Amène le diagramme en Idle « facettes » (referme la Facette ouverte,
+     *  bascule le sous-état) ; résolu une fois les satellites-facettes sortis. */
+    showIdleFacettes: () => Promise<void>;
     navigateToPrereqAction: (actionId: string) => void;
-    prepareForComponentSwitch: (targetComponentId: string) => void;
     session: ControllerSession;
     state: YinYangControllerState;
     titlePresenter: ComponentTitlePresenter;
     ui: ControllerUiCallbacks;
     view: IYinYangView;
 };
-/** Événements Clés : menu radial du cœur, aperçu de carte, champ
- *  d'événement et ajout à la pile. */
+/** Événements Clés : menu radial des satellites-facettes, aperçu de carte,
+ *  champ d'événement et ajout à la pile. */
 export declare class KeyEventController {
     private deps;
+    /** Aperçu effacé par le dernier clic sur un satellite-facette, avec
+     *  l'instant de l'effacement — voir restorePreviewClearedByDoubleClick. */
+    private previewClearedBySwitch;
     constructor(deps: KeyEventControllerDeps);
+    /** Facette dont les bulles d'Événements Clés sont déployées, ou null. */
+    getKeyEventMenuFacetteId(): string | null;
+    private notifyKeyEventMenuState;
+    /**
+     * Clic sur un satellite-facette (Idle « facettes ») : déploie ses bulles
+     * d'Événements Clés, ou les replie si elles l'étaient déjà — même règle
+     * que le clic sur un satellite de cutting pour ses boutons d'action. Un
+     * seul menu à la fois : ouvrir celui d'une facette replie celui d'une
+     * autre.
+     */
+    toggleKeyEventMenu(componentId: string): void;
     /**
-     * Appelé par YinYangDrawer quand le petit cercle "œil" du lobe dominant
-     * (yin ou yang, selon Composante.orientation) est cliqué — jamais l'autre
-     * lobe, jamais un satellite (garde déjà appliquée côté YinYangDrawer, même
-     * principe que onDiagramOddArcClicked pour les arcs ODD). Ouvre/ferme le
-     * menu radial des Événements Clés de la facette active.
+     * Double-clic sur un satellite-facette (entrée dans sa Facette) : son
+     * premier clic a déjà basculé (ou replié) les bulles, effaçant au passage
+     * l'aperçu en cours — celui-là même dont le souffle doit se poursuivre
+     * dans la Facette. On le rétablit s'il vient d'être effacé.
      */
-    onCoreEventNucleusClicked(): void;
-    notifyKeyEventMenuState(open: boolean): void;
-    private toggleCoreEventMenu;
+    restorePreviewClearedByDoubleClick(): void;
+    /** Replie les bulles du satellite-facette ouvert — et l'aperçu qu'elles
+     *  portaient. No-op si aucun menu n'est déployé. */
+    closeKeyEventMenu(): void;
+    /** Les satellites-facettes sont sortis : un Événement Clé encore en aperçu
+     *  (revenu d'une Facette) retrouve ses bulles sur le satellite-facette
+     *  d'origine, sa bulle allumée, et son souffle en part. */
+    onIdleFacettesShown(): void;
+    /** Les satellites-facettes rentrent (bascule vers les arcs ou ouverture
+     *  d'une Facette) : leurs bulles rentrent avec eux. L'aperçu, lui, reste
+     *  en place jusqu'au choix d'une autre action ou d'un autre événement —
+     *  invisible en Idle « arcs », il retrouve son souffle dans une Facette
+     *  concernée ou au retour des satellites-facettes. */
+    onIdleFacettesHidden(): void;
     /**
      * Fermeture du Champ d'événement : l'Événement Clé en aperçu et les bulles
-     * du menu cœur — chemin unique partagé par la fermeture de facette
+     * du satellite-facette — chemin unique partagé par la fermeture de facette
      * (closeCurrentComposante) et par l'exclusivité action/événement
      * (openActionMenuFromChild). No-op si rien n'est ouvert.
      *
      * hide() d'abord pour la rétraction immédiate du souffle (le geste
      * d'ouverture joué à l'envers — cf. prepareForComponentSwitch),
-     * updateCoreEventMenu() ensuite pour replier les bulles et laisser
+     * updateKeyEventMenu() ensuite pour replier les bulles et laisser
      * refreshTargets constater qu'il n'y a plus rien à dessiner. La carte du
      * panneau RECHERCHE part avec : elle décrit l'Événement Clé qu'on vient de
      * retirer du diagramme, et rien ne garantit qu'un autre bloc prenne sa
      * place (ouvrir un satellite n'affiche qu'un descriptif, pas un bloc).
      */
     closeKeyEventField(): void;
-    updateCoreEventMenu(): void;
+    updateKeyEventMenu(): void;
     /**
      * Événements Clés qui pilotent le Champ d'événement en ce moment — source
      * unique de vérité pour EventFieldLifecycleController (cibles) comme pour
      * getEventFieldSource (point d'émission).
      *
+     * Rien en Idle « arcs ». En Idle « facettes », le souffle relie le
+     * satellite-facette d'origine aux AUTRES satellites-facettes atteints ; en
+     * Facette, il part du cœur vers les satellites de cutting.
+     *
      * Deux régimes, mêmes règles de priorité que le champ de force d'action :
-     * un APERÇU (clic sur une bulle du menu cœur ou sur l'entrée de l'arbre
+     * un APERÇU (clic sur une bulle d'un satellite-facette ou sur l'entrée de l'arbre
      * RECHERCHE) prend toujours la main — c'est le geste que l'utilisateur
      * vient de faire, quel que soit l'onglet ; sinon, en mode STACK, ce sont
      * les Événements Clés COCHÉS de la pile qui décident, exactement comme les
@@ -87,25 +125,10 @@ export declare class KeyEventController {
      * l'arc de sa facette d'origine).
      */
     getEventFieldKeyEvents(): KeyEventDefinition[];
-    /**
-     * Point d'émission du Champ d'événement : le CŒUR du yin/yang, c'est-à-dire
-     * le disque central du lobe correspondant à l'orientation de la facette
-     * courante — le cœur noir du yang sur une facette Yang, le cœur blanc du
-     * yin sur une facette Yin. Ce n'est PAS le centre géométrique du symbole :
-     * les deux lobes ont des rayons qui varient avec le score, donc le cœur se
-     * déplace le long de l'axe vertical au fil de la partie, d'où la
-     * relecture de la géométrie à chaque frame. Injecté dans
-     * EventFieldLifecycleController (getEventFieldSource), rappelé à chaque
-     * frame de son animation.
-     *
-     * `geometry.yin/yang.centerY` est la position CANONIQUE (pré-rotation) :
-     * pendant une rotation Yin/Yang (AnimationsMngr), le cœur visible se
-     * déplace via un `transform` écrit à même `graphElementGroup` à chaque
-     * frame, sans jamais toucher `geometry`. On lit donc la position réelle
-     * via getLiveLobeCoreCenter plutôt que la géométrie statique, pour que les
-     * anneaux du champ d'événement suivent le cœur qui tourne au lieu de
-     * naître à une origine figée.
-     */
+    /** Événements Clés cochés de la pile, dans l'ordre de la pile, réduits à
+     *  ceux qui ont une bulle dans le mode courant. */
+    private getCheckedStackKeyEvents;
+    /** Origin satellite while visible; its facet arc carries the field after navigation. */
     getEventFieldSource(): {
         center: {
             x: number;
@@ -113,18 +136,6 @@ export declare class KeyEventController {
         } | null;
         radius: number;
     };
-    /**
-     * Résout un point porté par `lobeGroup` (coordonnées locales, ici le
-     * centre canonique du cœur) dans le repère de globalGroup — celui où
-     * EventFieldRenderer dessine (voir EventFieldLifecycleController,
-     * getGlobalGroupNode). Passe par les CTM SVG plutôt que de reparser
-     * l'attribut `transform` (comme getChildRenderedCenter le fait pour une
-     * simple translation) : le transform posé sur graphElementGroup pendant
-     * une rotation combine rotate ET translate, et cette composition suit
-     * fidèlement AnimationsMngr sans dépendre de sa formule exacte — un
-     * changement futur de celle-ci n'a pas besoin d'être répercuté ici.
-     */
-    private getLiveLobeCoreCenter;
     /**
      * Rejoue l'aperçu d'un Événement Clé depuis une navigation Recherche
      * (historique précédent/suivant) — pendant minimal de searchNavigateToAction,
@@ -139,41 +150,35 @@ export declare class KeyEventController {
      *
      * Volontairement plus étroit que previewKeyEvent : ni carte redessinée, ni
      * notification de navigation (donc pas d'entrée d'historique en double) —
-     * le panneau montre déjà cet événement, c'est le diagramme qui le rattrape.
-     * On garde en revanche l'exclusivité action/événement : les deux champs ne
-     * cohabitent jamais.
-     *
-     * Si la facette courante n'est plus celle de l'événement (l'utilisateur a
-     * navigué ailleurs pendant le mode STACK), on revient d'abord sur sa facette
-     * d'origine — mêmes gestes que searchSetKeyEventMenuOpen : l'aperçu survit
-     * au switch (prepareForComponentSwitch le garde vivant, destination =
-     * origine) et le menu cœur se redéploie à l'arrivée avec sa bulle active.
+     * le panneau montre déjà cet événement, c'est le diagramme qui le rattrape :
+     * bascule en Idle « facettes » (une Facette ouverte se referme), bulles du
+     * satellite-facette d'origine déployées, celle de l'événement allumée.
      */
     restoreKeyEventDiagramState(keyEventId: string): void;
     /**
      * Dépli/repli du groupe "Événements Clés" depuis la hiérarchie RECHERCHE —
-     * pendant exact du clic sur le cœur du yin/yang (onCoreEventNucleusClicked),
-     * pour que l'arbre et le diagramme montrent le même menu déployé : ouvrir le
-     * groupe déploie les bulles de la facette, le refermer les rétracte (même
-     * règle que le dépli d'un Satellite, qui déploie ses boutons d'Action).
+     * pendant exact du clic sur un satellite-facette, pour que l'arbre et le
+     * diagramme montrent le même menu déployé : ouvrir le groupe bascule en
+     * Idle « facettes » (une Facette ouverte se referme) et déploie les bulles
+     * de ce satellite-facette, le refermer les rétracte.
      *
      * Le repli passe par closeKeyEventField plutôt que par le toggle : il doit
      * aussi emporter l'Événement Clé en aperçu (et sa carte), sinon une bulle
      * validée resterait allumée sous un groupe replié.
      */
     searchSetKeyEventMenuOpen(componentIndex: number, open: boolean): void;
-    /** Ouverture idempotente du menu cœur — no-op s'il est déjà déployé (le
-     *  toggle le refermerait). */
-    openCoreEventMenu(): void;
+    /** Ouverture idempotente des bulles d'un satellite-facette — no-op si
+     *  elles sont déjà déployées (le toggle les refermerait). */
+    openKeyEventMenu(componentId: string): void;
     /** Seul point de mutation de activeKeyEventId — resynchronise la ligne
      *  Événement Clé du titre (voir getCurrentSatelliteTitle) à chaque
      *  changement, exactement comme setActiveChildKey le fait pour le
      *  satellite. */
     setActiveKeyEventId(keyEventId: string | null): void;
     /**
-     * Clic sur une bulle du menu cœur. En STACK : clic sur le libellé de son
-     * item de pile — celui en focus s'il s'agit de cet événement, sinon le
-     * plus récent ; rien s'il n'est pas dans la pile. Ailleurs : aperçu.
+     * Clic sur une bulle d'un satellite-facette. En STACK : clic sur le libellé de son
+     * item coché de pile — celui en focus s'il s'agit de cet événement, sinon le
+     * plus récent ; rien s'il n'est pas coché dans la pile. Ailleurs : aperçu.
      */
     onKeyEventBubbleClick(keyEvent: KeyEventDefinition): void;
     /** Aperçu — 1er clic sur un Événement Clé : affiche sa carte descriptive
@@ -189,4 +194,7 @@ export declare class KeyEventController {
         x: number;
         y: number;
     }): void;
+    /** En Idle « tab » : sélectionne une facette pour le titre dynamique, sans
+     *  ouvrir/fermer les bulles d'événements. Rafraîchit le titre. */
+    selectKeyEventFacetteForTab(componentId: string): void;
 }

package/dist/types/components/controller/actions/{CoreEventMenuController.d.ts → KeyEventMenuController.d.ts}

@@ -1,41 +1,36 @@
 import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
 import { type Point } from "./radialItemMenu";
-type CoreEventMenuContext = {
-    /** null/false ferme le menu (même logique que activeActionMenuChildKey côté satellite). */
-    isOpen: boolean;
-    keyEventsForActiveFacette: KeyEventDefinition[];
+type KeyEventMenuContext = {
+    /** Satellite-facette (Idle « facettes ») qui porte le menu, ou null pour
+     *  le refermer : centre rendu et rayon du satellite. */
+    anchor: {
+        center: Point;
+        radius: number;
+    } | null;
+    /** Centre du cercle global : l'éventail s'ouvre vers l'extérieur, sur
+     *  l'axe centre → satellite, comme les boutons d'action d'un satellite. */
+    parentCenter: Point;
+    keyEvents: KeyEventDefinition[];
     /** Id de l'événement actuellement en aperçu (carte affichée), ou null. */
     activeKeyEventId: string | null;
-    /** Même valeur que le contrôle "Distance boutons" du groupe "Grappe Actions"
-     *  (state.menu.itemDistance) — pas de contrôle dédié : voir le calcul de
-     *  offsetDistance plus bas, qui la réutilise telle quelle. */
-    childActionMenuItemDistance: number;
-    /** Distance centre du cercle central → satellites de la facette active
-     *  (moyenne des rayons d'orbite réels, cf. buildChildrenOrbitData) — le
-     *  "connu" dont dérive offsetDistance plus bas. */
-    childrenOrbitRadius: number;
-    /** Taille des bulles — contrôle dédié "Taille boutons" du groupe
-     *  "Événements clés" (state.menu.coreEventMenuItemScale) : les Événements
-     *  Clés se dimensionnent indépendamment des boutons d'action des
-     *  satellites. */
-    coreEventMenuItemScale: number;
-    coreEventIconFontScale: number;
-    /** Ajustement fin (px) de la distance des boutons, de part et d'autre de
-     *  la longueur auto-calculée — contrôle "Distance boutons" du groupe
-     *  "Événements clés", voir state.menu.coreEventMenuDistanceOffset. */
-    coreEventMenuDistanceOffset: number;
+    /** Distance satellite → bulles : même base que les boutons d'action
+     *  (smallCircleRadius × state.menu.itemDistance, voir
+     *  ChildActionMenuController), ajustée par keyEventMenuDistanceOffset. */
+    offsetDistance: number;
+    /** Rayon des bulles — contrôle dédié "Taille boutons" du groupe
+     *  "Événements clés" (state.menu.keyEventMenuItemScale). */
+    itemRadius: number;
+    keyEventIconFontScale: number;
 };
 /**
- * Menu radial des Événements Clés, déclenché par un clic sur le cercle
- * central (yin-yang) de la facette active — même langage visuel et même
- * sémantique de clic que ChildActionMenuController (bulles + icône,
- * chorégraphie D3 en éventail factorisée dans radialItemMenu.ts ; clic =
- * aperçu, glisser vers la pile = validation), mais ancré sur
- * le centre fixe de la facette plutôt que sur un satellite, et déployé à
- * angle égal sur 360° plutôt que sur un axe source.
+ * Menu radial des Événements Clés d'une facette, déployé autour de son
+ * satellite-facette (sous-état Idle « facettes ») — même langage visuel et
+ * même sémantique que ChildActionMenuController autour d'un satellite de
+ * cutting (bulles + icône, chorégraphie D3 en éventail factorisée dans
+ * radialItemMenu.ts ; clic = aperçu, glisser vers la pile = validation).
  */
-export declare class CoreEventMenuController {
+export declare class KeyEventMenuController {
     private readonly view;
     /** Clic sur une bulle — aperçu, ou focus de son item de pile en STACK
      *  (voir KeyEventController.onKeyEventBubbleClick). */
@@ -48,11 +43,11 @@ export declare class CoreEventMenuController {
      *  SearchPanelSynchronizer.startActionDrag, entièrement générique).
      *  Retourne une poignée d'annulation, conservée dans activeDragCancel. */
     private readonly startKeyEventDrag;
-    private coreEventMenuGroup;
+    private keyEventMenuGroup;
     /** Groupe séparé pour les traits centre → bulle, abaissé au fond du
      *  z-order (voir ensureLineLayer) pour qu'ils s'affichent derrière le
      *  disque central et les satellites plutôt que par-dessus. */
-    private coreEventLineLayer;
+    private keyEventLineLayer;
     /** Poignée d'annulation du glisser-déposer en cours (voir startKeyEventDrag),
      *  ou null si aucun glisser n'est en cours — même rôle que
      *  ChildActionMenuController.activeDragCancel. */
@@ -80,7 +75,7 @@ export declare class CoreEventMenuController {
     private _onHoverCb?;
     setOnHover(cb: (keyEventId: string | null) => void): void;
     clearImmediately(): void;
-    update(context: CoreEventMenuContext): void;
+    update(context: KeyEventMenuContext): void;
     /** Restyle les seuls liens (impulsion allumée/éteinte) sans toucher à leur
      *  géométrie : le survol ne doit rien réanimer. */
     private setHoveredKeyEvent;

package/dist/types/components/controller/actions/radialItemMenu.d.ts

@@ -20,6 +20,19 @@ export type RadialMenuItemPosition<T> = {
  *   cercle central — pas d'axe source à respecter, maximise l'écart
  *   angulaire entre bulles).
  */
+/** Lueur d'une bulle : équivalent de `drop-shadow(0 0 ${blur}px ${color})`. */
+export type RadialItemGlow = {
+    color: string;
+    blur: number;
+} | null;
+/**
+ * Habille le halo pré-rendu d'une bulle (cercle `${dataRole}-halo`, créé
+ * sous la plaque) : un disque à dégradé radial au lieu d'un drop-shadow sur
+ * la plaque. `null` l'éteint.
+ */
+export declare function styleRadialItemHalo(group: d3.Selection<SVGGElement, unknown, null, undefined>, dataRole: string, radius: number, glow: RadialItemGlow): void;
+/** Allume / éteint le halo de survol d'une bulle, sans perdre sa lueur propre. */
+export declare function setRadialItemHaloHighlight(group: d3.Selection<SVGGElement, unknown, null, undefined>, dataRole: string, highlighted: boolean): void;
 export declare function computeFanPositions<T extends {
     id: string;
 }>(items: T[], opts: {
@@ -31,6 +44,14 @@ export declare function computeFanPositions<T extends {
     itemRadius: number;
     keyPrefix: string;
 }): RadialMenuItemPosition<T>[];
+/**
+ * Recale des bulles DÉJÀ rendues sur de nouvelles positions (frame d'orbite) :
+ * ni data join, ni transition, ni listeners. Une bulle encore en ouverture
+ * n'est pas touchée directement — sa transition relit la cible mise à jour
+ * ici (liveItemTransformTween). Les bulles absentes de `positions` (en
+ * sortie) restent à leur chorégraphie.
+ */
+export declare function followRadialItems<T>(groupNode: SVGGElement, dataRole: string, positions: RadialMenuItemPosition<T>[]): void;
 /**
  * Referme et retire toutes les bulles d'un menu radial (repli en
  * éventail), utilisé à la fois quand update() ne reçoit plus de
@@ -48,8 +69,10 @@ export declare function renderRadialItemsChoreography<T>(params: {
     groupNode: SVGGElement;
     dataRole: string;
     positions: RadialMenuItemPosition<T>[];
-    exitAnimationCenter: Point;
-    enterCenter: Point;
+    /** Un point unique, ou un point par bulle (bulles détachées : chacune naît
+     *  de son propre satellite source et y retourne). */
+    exitAnimationCenter: Point | ((d: RadialMenuItemPosition<T>) => Point);
+    enterCenter: Point | ((d: RadialMenuItemPosition<T>) => Point);
     getIconUrl: (id: string) => string;
     /** Décor optionnel inséré entre la plaque (cercle) et le pictogramme, sur
      *  la seule sélection enter() — c'est par là que le menu des Événements
@@ -86,7 +109,7 @@ export declare function styleRadialItemLinks<T extends {
 }>(groupNode: SVGGElement | null, dataRole: string, getStyle: (d: RadialMenuItemPosition<T>) => RadialItemLinkStyle): void;
 /**
  * Chorégraphie D3 des liens parent → item, rendus dans un groupe SÉPARÉ de
- * celui des bulles (voir CoreEventMenuController : ce groupe est glissé plus
+ * celui des bulles (voir KeyEventMenuController : ce groupe est glissé plus
  * tôt dans le z-order pour passer derrière les satellites et le disque
  * central, alors que les bulles restent devant dans leur propre groupe).
  * Anime directement x2/y2 des lignes : un lien entrant grandit depuis le bord
@@ -101,8 +124,23 @@ export declare function renderRadialItemLinks<T extends {
     groupNode: SVGGElement;
     dataRole: string;
     positions: RadialMenuItemPosition<T>[];
-    center: Point;
+    /** Centre du parent — un seul, ou un par bulle (bulles détachées). */
+    center: Point | ((d: RadialMenuItemPosition<T>) => Point);
     /** Rayon du disque parent : le faisceau démarre à son bord. 0 = au centre. */
-    startRadius?: number;
+    startRadius?: number | ((d: RadialMenuItemPosition<T>) => number);
     getStyle?: (d: RadialMenuItemPosition<T>) => RadialItemLinkStyle;
 }): void;
+/**
+ * Pendant de followRadialItems pour les faisceaux : origine, extrémité et
+ * dégradé recalés sur les nouvelles positions, sans data join ni transition.
+ * Un faisceau encore en ouverture garde sa transition, qui relit la cible.
+ */
+export declare function followRadialItemLinks<T extends {
+    id: string;
+}>(params: {
+    groupNode: SVGGElement;
+    dataRole: string;
+    positions: RadialMenuItemPosition<T>[];
+    center: Point | ((d: RadialMenuItemPosition<T>) => Point);
+    startRadius?: number | ((d: RadialMenuItemPosition<T>) => number);
+}): void;

package/dist/types/components/controller/children/ChildInteractionController.d.ts

@@ -32,6 +32,9 @@ export declare class ChildInteractionController {
     setChildrenHiddenState(childControllers: IYinYangController[], hidden: boolean): void;
     attachChildToggleHandler(childController: IYinYangController, childOddMap: Map<string, ChildOddMeta>): void;
     attachChildHoverHandler(childController: IYinYangController, childOddMap: Map<string, ChildOddMeta>): void;
+    private backgroundClickContainer;
+    /** Un seul écouteur par conteneur : le SVG racine survit aux recréations de
+     *  satellites, et cette méthode est rappelée à chacune. */
     attachBackgroundClickHandler(): void;
     enterOddView(oddId: string): void;
     exitOddView(): void;
@@ -41,6 +44,7 @@ export declare class ChildInteractionController {
     private applyChildActiveStyle;
     /** Filtre courant d'un satellite : la mise en valeur d'un ODD prime sur le
      *  style "actif", qui prime lui-même sur l'état neutre. */
+    private resolveGlowFor;
     private resolveFilterFor;
     private getChildOffset;
 }

package/dist/types/components/controller/children/ChildrenBuilder.d.ts

@@ -29,6 +29,8 @@ export type ChildrenBuilderDeps = {
     getCurrentComponentOrUndefined: () => YinYangInternalModel["components"][number] | undefined;
     getKey: () => string;
     renderOppositeChildrenForceField: (orbitData?: ChildrenOrbitEntry[], angleOffset?: number) => void;
+    /** Exécute `run` sans rendu du champ de force (les appels sont ignorés). */
+    suppressForceFieldRender: (run: () => void) => void;
     getRotationState: () => {
         clockWise: boolean;
         durationMs: number;
@@ -66,7 +68,7 @@ export declare class ChildrenBuilder {
     /** Ratio de taille d'un satellite (rayon relatif à la baseline uniforme de
      *  sa facette) à partir de son poids et du poids moyen de sa fratrie —
      *  voir WEIGHT_SIZE_FLOOR_OFFSET pour le resserrement. */
-    private static weightToSizeRatio;
+    static weightToSizeRatio(weight: number, averageWeight: number): number;
     /** Ratio of a component's heaviest satellite radius to its own uniform
      *  baseline radius. Mirrors the per-cutting weight-based scaling applied
      *  in createYinYangChildren(). */

package/dist/types/components/controller/children/ComponentSwitchCoordinator.d.ts

@@ -32,10 +32,12 @@ export type ComponentSwitchCoordinatorDeps = {
         cuttingIndex: number;
     }>;
     clearActiveChild: () => void;
-    clearChildren: () => void;
     createYinYangChildren: () => void;
     detailsPresenter: ForceFieldDetailsPresenter;
     disableOuterSpark: () => void;
+    /** Réaligne le sous-état Idle (arcs / facettes) : ce chemin quitte Idle
+     *  sans passer par setChildrenEnabled(). */
+    syncIdleView: () => void;
     eventFieldLifecycleController: EventFieldLifecycleController;
     eventFieldRenderer: EventFieldRenderer;
     focusChildByOddCutting: (oddId: string, cuttingIndex: number, forceOpen?: boolean) => void;

package/dist/types/components/controller/children/IdleFacettesController.d.ts

@@ -0,0 +1,151 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { IYinYangAppFactory } from "../../../interfaces/IYinYangAppFactory";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { IdleView, YinYangControllerState } from "../state/YinYangControllerState";
+/** Crochets de l'hôte autour du sous-état « tab » — voir
+ *  `IYinYangController.setIdleTabHooks`. */
+export type IdleTabHooks = {
+    /** Avant le calcul de la grille (l'hôte peut agrandir le conteneur du
+     *  diagramme) ; la grille attend sa résolution. */
+    beforeEnter?: () => Promise<void> | void;
+    /** Une fois les satellites revenus à leur place radiale. */
+    afterLeave?: () => Promise<void> | void;
+};
+export type IdleFacettesControllerDeps = {
+    view: IYinYangView;
+    state: YinYangControllerState;
+    factory: IYinYangAppFactory;
+    getKey: () => string;
+    getInternalModel: () => YinYangInternalModel;
+    setChildrenHiddenState: (children: IYinYangController[], hidden: boolean) => void;
+    animateChildren: (children: IYinYangController[], show: boolean) => Promise<void>;
+    applyChildrenFitScale: () => void;
+    /** Double-clic sur un satellite-facette : ouvre cette Facette, comme son arc. */
+    openFacette: (componentIndex: number, componentId: string) => void;
+    /** Clic sur un satellite-facette : déploie/replie ses Événements Clés. */
+    onSatelliteClick: (componentId: string) => void;
+    /** En Idle « tab » : sélectionne la facette pour le titre (sans déployer les bulles). */
+    selectKeyEventFacetteForTab: (componentId: string) => void;
+    /** Double-clic, juste avant d'ouvrir la Facette : annule l'effet de bord
+     *  du premier clic sur l'aperçu en cours. */
+    onSatelliteDoubleClick: () => void;
+    /** Satellites-facettes sortis (fin d'animation) : les bulles et le souffle
+     *  peuvent s'y accrocher. */
+    onSatellitesShown: () => void;
+    /** Satellites-facettes rentrés : leurs bulles rentrent avec eux. */
+    onSatellitesHidden: () => void;
+    onIdleViewChange?: (view: IdleView) => void;
+};
+/**
+ * Sous-états Idle « facettes » et « tab » : les arcs de bordure rentrent
+ * sous l'illustration, et chaque facette en ressort sous la forme d'un
+ * satellite montrant son propre yin/yang, dimensionné selon son poids.
+ * - « facettes » : à l'angle du milieu de son arc ;
+ * - « tab » : dans une grille régulière (voir idleTabLayout), l'illustration
+ *   réduite au centre, l'image de la facette en fond de sa case et les
+ *   facettes d'une même notion parente regroupées (IdleTabGridDrawer).
+ *
+ * Les satellites sortent toujours à leur place radiale ; « tab » les y
+ * reprend pour les faire glisser jusqu'à leur case (idleTabMorph), et
+ * inversement — la grille n'est qu'une transformation posée sur eux.
+ *
+ * Les satellites-facettes vivent à part des satellites de cutting d'une
+ * Facette (childControllers) : ni champ de force, ni menu d'action, ni
+ * orbite ne les concernent. Les transitions sont sérialisées — chaque étape
+ * relit l'état voulu au moment de s'exécuter, de sorte que des bascules
+ * rapprochées convergent vers le dernier état demandé sans se chevaucher.
+ */
+export declare class IdleFacettesController {
+    private deps;
+    private satellites;
+    private satelliteByComponentId;
+    /** Disposition des satellites-facettes actuellement sortis (null : aucun). */
+    private shownLayout;
+    /** Grille en place (sous-état « tab ») et échelle du motif à rétablir en
+     *  revenant à la disposition radiale. */
+    private tab;
+    /** Groupe enveloppe de chaque satellite-facette (porte la grille). */
+    private wrappers;
+    /** Position et facteur d'échelle posés par la grille, par satellite. */
+    private tabPlacement;
+    private readonly tabGrid;
+    private tabHooks;
+    /** Vrai une fois les satellites-facettes arrivés à leur place (fin de
+     *  l'animation de sortie) : les bulles n'ont de point d'ancrage qu'alors. */
+    private settled;
+    private queue;
+    private escapeListener;
+    constructor(deps: IdleFacettesControllerDeps);
+    setTabHooks(hooks: IdleTabHooks | null): void;
+    getView(): IdleView;
+    /** Vrai dès qu'un sous-état à satellites-facettes (« facettes » ou
+     *  « tab ») est l'état visé en Idle (arcs repliés ou en train de l'être). */
+    isActive(): boolean;
+    setView(view: IdleView): Promise<void>;
+    /** Centre et rayon du satellite-facette d'une facette, une fois sorti. */
+    getSatelliteAnchor(componentId: string): {
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    } | null;
+    toggleView(): Promise<void>;
+    /** Aligne l'affichage sur l'état voulu (Idle + sous-état). À appeler à
+     *  chaque entrée/sortie d'Idle. */
+    sync(): Promise<void>;
+    private isIdle;
+    private wantedLayout;
+    private applyDesiredState;
+    /** Arcs repliés sous l'illustration, puis satellites jaillissant du centre
+     *  jusqu'à leur place radiale. */
+    private show;
+    /** Satellites rentrant au centre, puis arcs ressortant jusqu'au bord. */
+    private hide;
+    /** Les satellites glissent de leur place radiale à leur case ; dans le même
+     *  mouvement, l'illustration rapetisse, l'anneau d'images s'efface (chaque
+     *  case porte la sienne) et la grille apparaît. */
+    private morphToTab;
+    /** Mouvement inverse : chaque satellite regagne sa place radiale. */
+    private morphToRadial;
+    private morph;
+    private patternCenter;
+    /** Place radiale d'un satellite, dans le repère du motif. */
+    private radialPlace;
+    /** Satellites à leur place : les bulles peuvent s'y accrocher. */
+    private settle;
+    /** Satellites en mouvement : leurs bulles rentrent. */
+    private unsettle;
+    /** Mise en page de la grille, dans le repère du SVG : sur toute la place
+     *  que le conteneur du diagramme offre autour de l'illustration (le SVG
+     *  déborde visiblement), au moins sur le carré du SVG. */
+    private computeTabLayout;
+    /** Plus grand rectangle centré sur l'illustration qui tienne dans le
+     *  conteneur du SVG, padding exclu, en unités du SVG (le conteneur peut
+     *  être mis à l'échelle par l'hôte : on ramène ses dimensions à celles du
+     *  SVG). */
+    private tabArea;
+    private fadeImageRing;
+    private computeSizeRatios;
+    private createSatellites;
+    /** Glisse un groupe enveloppe entre le satellite et le groupe des enfants
+     *  du motif : il porte la transformation de la grille, sans interférer
+     *  avec celles que d'autres posent sur le satellite lui-même. */
+    private wrap;
+    private attachClickHandler;
+    /** Double-clic. Le sous-état « facettes » reste mémorisé : refermer la
+     *  Facette y ramène.
+     *  On replie d'abord les satellites-facettes et on redéploie les arcs (la
+     *  Facette met en valeur l'arc actif), puis on ouvre la Facette. */
+    private openFacette;
+    /** Détache les satellites-facettes courants (pour les faire rentrer puis
+     *  les détruire) et prévient que leurs bulles doivent rentrer avec eux. */
+    private takeSatellites;
+    /** Fin de vie : satellites-facettes détruits sur place (sans animation de
+     *  rentrée), grille retirée, écouteur Échap détaché. */
+    destroy(): void;
+    private destroySatellites;
+    private attachEscapeListener;
+    private detachEscapeListener;
+}