@micheeeeel/yinyangapp 3.0.0 → 3.1.0

package/dist/types/components/controller/state/YinYangControllerState.d.ts

@@ -9,6 +9,7 @@ type GhostState = {
     projectedGhostComponentTension: number | null;
     projectedGhostCuttingStatesByOddId: Map<string, ProjectedCuttingState[]> | null;
 };
+export type IdleView = "arcs" | "facettes" | "tab";
 export declare class YinYangControllerState {
     children: {
         enabled: boolean;
@@ -20,6 +21,15 @@ export declare class YinYangControllerState {
         orbitSpeed: number;
         orbitRadiusScale: number;
     };
+    /** Sous-état d'Idle (children.enabled === false) : « arcs » montre les
+     *  arcs pondérés des facettes autour de l'illustration, « facettes »
+     *  remplace ces arcs par un satellite par facette (son yin/yang), « tab »
+     *  range ces mêmes satellites dans une grille régulière autour d'une
+     *  illustration réduite, pour comparer leurs poids. Mémorisé
+     *  quand une Facette s'ouvre : la refermer ramène au même sous-état. */
+    idle: {
+        view: IdleView;
+    };
     menu: {
         hasActiveChildAction: boolean;
         activeChildKey: string | null;
@@ -34,17 +44,17 @@ export declare class YinYangControllerState {
         iconFontScale: number;
         /** Ajustement fin (px) de la distance des boutons d'Événement Clé,
          *  de part et d'autre de la longueur auto-calculée (voir
-         *  CoreEventMenuController — offsetDistance dérivé de l'orbite des
+         *  KeyEventMenuController — offsetDistance dérivé de l'orbite des
          *  satellites, pas de contrôle dédié à cette base). */
-        coreEventMenuDistanceOffset: number;
+        keyEventMenuDistanceOffset: number;
         /** Taille des boutons du menu radial des Événements Clés — contrôle dédié
          *  ("Taille boutons", groupe "Événements clés"), séparé de itemScale qui
          *  ne pilote que les boutons d'action des satellites. */
-        coreEventMenuItemScale: number;
+        keyEventMenuItemScale: number;
         /** Taille des icônes dans les bulles du menu radial des Événements Clés —
          *  contrôle dédié ("Taille icônes", groupe "Événements clés"), séparé de
          *  iconFontScale qui ne pilote que les icônes d'action des satellites. */
-        coreEventIconFontScale: number;
+        keyEventIconFontScale: number;
     };
     action: {
         delta: number;
@@ -99,8 +109,8 @@ export declare class YinYangControllerState {
         orbitData: ChildrenOrbitEntry[] | null;
         revealStartedAt: number | undefined;
         selectedLinkIndex: number | null;
-        /** Item de pile en focus — persistant, posé par le clic sur l'en-tête
-         *  d'un bloc du panneau de description. Survit à la navigation entre
+        /** Item de pile en focus — persistant, posé par le clic sur son libellé
+         *  dans la pile. Survit à la navigation entre
          *  satellites et facettes ; effacé quand l'item quitte la pile active. */
         focusedStackItemId: string | null;
         /** Aperçu temporaire (survol d'un bloc du panneau ou d'un item de la
@@ -120,6 +130,7 @@ export declare class YinYangControllerState {
     blockingAnimations: BlockingAnimationTracker;
     setActiveChildKey(childKey: string | null): void;
     setChildrenEnabled(isEnabled: boolean): void;
+    setIdleView(view: IdleView): void;
     setChildrenPendingRefresh(isPending: boolean): void;
     setOrbitEnabled(isEnabled: boolean): void;
     setOrbitSpeed(speed: number): void;
@@ -167,9 +178,9 @@ export declare class YinYangControllerState {
     setMenuItemDistance(distance: number): void;
     setMenuItemScale(scale: number): void;
     setMenuIconFontScale(scale: number): void;
-    setCoreEventMenuDistanceOffset(offset: number): void;
-    setCoreEventMenuItemScale(scale: number): void;
-    setCoreEventIconFontScale(scale: number): void;
+    setKeyEventMenuDistanceOffset(offset: number): void;
+    setKeyEventMenuItemScale(scale: number): void;
+    setKeyEventIconFontScale(scale: number): void;
     setChildLabelMaxLines(lines: number): void;
     setOddLabelMaxLines(lines: number): void;
     setLabelShortMaxChars(chars: number): void;

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

@@ -1,6 +1,8 @@
+import type { KeyEventActionEffects } from "../../data/key-event-effects";
+import type { EventTargetBreakdown } from "./force-field/keyEventPresentation";
 import type { ForceFieldLinkDetail } from "./force-field/types";
 import type { ComboResult } from "../../data/combo-engine";
-import type { AmplifierResult, AmplifierTargetBreakdown } from "../../data/amplifier-engine";
+import type { AmplifierResult } from "../../data/amplifier-engine";
 import type { AbsorptionBreakdown, ActiveShield } from "./force-field/shieldViewModel";
 /**
  * Bloc "action" de la vue cumulative (mode STACK) : "source" = action jouée
@@ -27,6 +29,7 @@ export type ActionCumulativeBlock = {
     detailRows: ForceFieldLinkDetail[];
     comboResults?: ComboResult[];
     amplifierResults?: AmplifierResult[];
+    eventEffects?: KeyEventActionEffects;
     stackItemId?: string;
     color?: string;
     /** This item's own propagation edges from the real sequential
@@ -51,6 +54,10 @@ export type ActionCumulativeBlock = {
     /** Réduction appliquée par le bouclier du satellite en focus à la
      *  contribution négative de ce bloc — journal de résolution. */
     shieldAbsorption?: AbsorptionBreakdown;
+    directionalAbsorptions?: Array<{
+        active?: ActiveShield;
+        breakdown: AbsorptionBreakdown;
+    }>;
 };
 /**
  * Bloc "keyEvent" de la vue cumulative : un Événement Clé joué (kind="keyEvent"
@@ -72,7 +79,7 @@ export type KeyEventCumulativeBlock = {
         id: string;
         name: string;
     }>;
-    breakdowns?: AmplifierTargetBreakdown[];
+    breakdowns?: EventTargetBreakdown[];
 };
 /**
  * Un bloc de la vue cumulative (mode STACK). Hissé au niveau module (au lieu

package/dist/types/components/controller/utils/actionCatalog.d.ts

@@ -6,7 +6,7 @@ export declare const actionMap: Map<string, ActionDefinition>;
  * Cibles d'un Événement Clé prêtes pour buildKeyEventCardHtml : id + nom,
  * la carte affichant pour chacune le seul bonus ajouté par l'effet (pas de
  * deltas du catalogue à charrier jusque-là). Les deux points d'appel (clic
- * sur le cercle central, cartes cumulées du panneau) passent par ici — une
+ * sur le satellite-facette, cartes cumulées du panneau) passent par ici — une
  * seule définition de la forme attendue.
  */
 export declare function buildKeyEventTargets(keyEvent: KeyEventDefinition): Array<{

package/dist/types/components/controller/utils/eventFieldTargets.d.ts

@@ -10,20 +10,18 @@ export type EventFieldTarget = {
      *  (même mécanisme que ForceFieldRenderer pour les champs de force
      *  cross-composante). */
     targetComponentId?: string;
-    /** Bonus de score de l'événement pour un satellite réellement amplifié,
-     *  0 pour un satellite simplement à portée — pilote l'épaisseur du
-     *  souffle (voir getEventFieldCapsuleWidth). */
-    scoreBonus: number;
+    /** Shared eligibility strength, purely visual; zero for potential targets. */
+    intensity: number;
 };
-/**
- * Whether `keyEvent`'s static scope (collectReachedSatellites) includes at
- * least one satellite living in `componentId`. Used when the user switches
- * facette to decide whether the active Champ d'événement should keep
- * driving the field in the destination facette (incoming continuation) or
- * be cleared like it is for any unrelated facette — see
- * YinYangController.prepareForComponentSwitch.
- */
-export declare function keyEventReachesComponent(keyEvent: KeyEventDefinition, componentId: string): boolean;
+/** Vrai si l'événement amplifie réellement au moins un satellite — une
+ *  action ciblée cochée, jouée après lui et dans sa fenêtre (voir
+ *  collectEligibleStrengths). Sert, en mode STACK, à écarter les événements
+ *  cochés qui n'ont encore aucun effet. */
+export declare function keyEventAffectsAny(keyEvent: KeyEventDefinition, activeItems: ActionStackItem[]): boolean;
+/** Vrai si l'événement amplifie réellement au moins un satellite de
+ *  `componentId` — choisit, en mode STACK, l'événement distant dont le
+ *  souffle entre dans la facette courante. */
+export declare function keyEventAffectsComponent(keyEvent: KeyEventDefinition, componentId: string, activeItems: ActionStackItem[]): boolean;
 /**
  * Résout les cibles du "Champ d'événement" pour l'Événement Clé actuellement
  * actif (aperçu ou validé) : sa portée statique, résolue en index de satellite
@@ -33,6 +31,13 @@ export declare function keyEventReachesComponent(keyEvent: KeyEventDefinition, c
  * maintenant — ceux dont une action ciblée est cochée dans la pile — de ceux
  * qui ne sont qu'à portée : les premiers reçoivent le bonus de score de
  * l'événement, les seconds 0 (souffle minimal).
+ *
+ * `stackEffects` (mode STACK, événements cochés de la pile) : la pile ne
+ * montre que des effets réels, donc seuls les satellites amplifiés reçoivent
+ * un cordon — et une facette distante seulement si elle en abrite un — et
+ * leur épaisseur suit le bonus EFFECTIF, réduit selon la position de
+ * l'action dans la fenêtre. L'aperçu (RECHERCHE ou bulle) garde la portée
+ * complète et le bonus nominal : il montre jusqu'où l'événement PEUT porter.
  */
 export declare function buildEventFieldTargets(params: {
     keyEvent: KeyEventDefinition;
@@ -44,4 +49,5 @@ export declare function buildEventFieldTargets(params: {
         score: number;
         cuttingIndex: number;
     }>;
+    stackEffects?: boolean;
 }): EventFieldTarget[];

package/dist/types/components/controller/utils/keyEventPropagationContext.d.ts

@@ -0,0 +1,4 @@
+import type { ActionStackItem } from "../action-stack/ActionStackState";
+import type { KeyEventPropagationContext } from "../../../data/key-event-propagation";
+/** Same event matches as delta/shield resolution, with actual source applicability. */
+export declare function keyEventPropagationContext(item: ActionStackItem | undefined, items: ActionStackItem[]): KeyEventPropagationContext | undefined;

package/dist/types/components/controller/utils/keyEventTargetBreakdowns.d.ts

@@ -0,0 +1,4 @@
+import type { ActionStackItem } from "../action-stack/ActionStackState";
+import type { KeyEventDefinition } from "../../../data/key-event-types";
+import { type EventTargetBreakdown } from "../force-field/keyEventPresentation";
+export declare function keyEventTargetBreakdowns(event: KeyEventDefinition, items: ActionStackItem[]): EventTargetBreakdown[];

package/dist/types/components/controller/utils/svgTransform.d.ts

@@ -3,3 +3,19 @@ export declare function parseTranslateTransform(transform: string): {
     y: number;
     found: boolean;
 };
+type TransformTarget = {
+    setAttribute: (name: string, value: string) => unknown;
+};
+/** Translation d'orbite, sur l'enveloppe d'orbite du satellite
+ *  (viewInitializer.orbitGroup) — en plein mouvement, une animation du
+ *  navigateur la recouvre (ChildrenOrbitManager). */
+export declare function setSatelliteTranslation(target: TransformTarget, x: number, y: number): void;
+/** Respiration du weightDelta (WeightPreviewRingRenderer), sur le
+ *  globalGroup du satellite : scale autour de son centre. Séparée de
+ *  l'orbite, qui est posée sur l'enveloppe. `scale` 1 (ou null) la retire. */
+export declare function setSatellitePulseScale(target: TransformTarget, pulse: {
+    scale: number;
+    cx: number;
+    cy: number;
+} | null): void;
+export {};

package/dist/types/components/controls/VizControlsPanel.d.ts

@@ -13,4 +13,6 @@ export interface VizControlsDeps {
         orbitRampMs: number;
     };
 }
-export declare function mountVizControls(deps: VizControlsDeps): void;
+/** Retourne la fonction de démontage : désabonne les veilles d'inactivité
+ *  (sinon elles relanceraient la rotation / l'orbite d'un diagramme détruit). */
+export declare function mountVizControls(deps: VizControlsDeps): () => void;

package/dist/types/components/panel/PanelManager.d.ts

@@ -42,6 +42,15 @@ export declare class PanelManager {
     masterCuttingPending: boolean;
     masterCuttingHistoryPushed: boolean;
     diagramNavMasterHistLenAtStart: number;
+    /** Vrai pendant qu'une sélection mémorisée est rejouée sur le diagramme
+     *  (bascule RECHERCHE ↔ STACK) : les rappels du diagramme n'écrivent alors
+     *  pas dans le panneau RECHERCHE — voir isRecherchePanelMuted. */
+    private restoringModeSelection;
+    /** Sélection propre à chaque mode, photographiée au moment de le quitter.
+     *  Les deux modes sont hermétiques : chacun retrouve la sienne au retour,
+     *  et un mode jamais visité démarre sans sélection (vue Sphère). */
+    private rechercheSelection;
+    private stackSelection;
     /** Jeton de génération pour historyBack/historyForward — voir leur commentaire. */
     private navGen;
     oddNavState: {
@@ -65,35 +74,46 @@ export declare class PanelManager {
     private redistributeOpenHeights;
     private setPanelCollapsed;
     private updateLockButton;
-    /** Cible actuellement sélectionnée dans l'arbre du panneau maître, ou null.
-     *  À lire AVANT de quitter RECHERCHE : voir resyncDiagramToMasterPanel. */
+    /** Cible actuellement sélectionnée dans l'arbre du panneau maître, ou null. */
     getMasterSelectedTarget(): SearchNavTarget | null;
     /**
-     * Rejoue sur le diagramme ce que le panneau MAÎTRE montre déjà — appelé au
-     * retour en mode RECHERCHE, où l'onglet réaffiche le dernier élément
-     * sélectionné alors que le diagramme, lui, vient d'être vidé des champs de
-     * la pile (clearForceFieldForModeSwitch). Les deux côtés doivent montrer la
-     * même chose quel que soit le mode ; sans ça, il fallait recliquer sur
-     * l'élément déjà affiché pour retrouver ses champs.
+     * Le panneau RECHERCHE n'écoute pas le diagramme : en mode STACK (les deux
+     * modes sont hermétiques — la navigation STACK ne touche ni l'arbre ni
+     * l'historique RECHERCHE), et pendant qu'une sélection mémorisée est
+     * rejouée (le panneau montre déjà ce qu'il faut).
+     */
+    isRecherchePanelMuted(): boolean;
+    /** À appeler AVANT de quitter RECHERCHE (clic d'onglet ou bascule
+     *  programmatique) : le passage en STACK peut effacer la sélection de
+     *  l'arbre (le rendu des champs cumulés de la pile repasse par les blocs de
+     *  détail du panneau). */
+    rememberRechercheSelection(): void;
+    /** À appeler AVANT de quitter STACK : sa sélection ne vit que dans le
+     *  diagramme, qui va être réécrit par celle de RECHERCHE. */
+    rememberStackSelection(): void;
+    /**
+     * Retour en RECHERCHE : rejoue sur le diagramme la sélection mémorisée en
+     * quittant RECHERCHE. Le panneau maître, lui, n'a pas bougé pendant STACK
+     * (isRecherchePanelMuted) ; il n'est resynchronisé que si sa sélection a
+     * malgré tout été perdue en route.
      *
      * Passe par les chemins de RESTAURATION (restoreActionDiagramState,
      * restoreKeyEventDiagramState, forceOpen) et non par ceux d'un clic : l'état
      * est déjà connu, il ne doit ni basculer en toggle-close ni redessiner la
      * carte du panneau ni pousser une entrée d'historique.
-     *
-     * Ne traite que les niveaux qui portent un champ dans le diagramme (action,
-     * cutting, Événement Clé). Une facette ou un ODD n'en ont pas : les rejouer
-     * ne ferait que risquer un toggle de la vue ODD pour rien.
-     *
-     * @param fallbackTarget cible mémorisée au moment de QUITTER RECHERCHE.
-     *   Le passage en STACK peut effacer la sélection de l'arbre (le rendu des
-     *   champs cumulés de la pile repasse par les blocs de détail du panneau)
-     *   ou la réécrire au niveau facette (navigation d'arc de bordure pendant
-     *   STACK) : dans les deux cas c'est cette photographie qui dit quel
-     *   élément l'utilisateur consultait, et sa restauration inclut le switch
-     *   de facette si le diagramme est parti ailleurs entre temps.
      */
-    resyncDiagramToMasterPanel(fallbackTarget?: SearchNavTarget | null): void;
+    restoreRechercheSelection(): void;
+    /** Retour en STACK : rejoue sur le diagramme la sélection mémorisée en
+     *  quittant STACK (aucune au premier passage). Le chip et l'historique
+     *  STACK suivent par les rappels habituels du diagramme. */
+    restoreStackSelection(): void;
+    /**
+     * Remet le diagramme à blanc puis y rejoue `target` (null : vue Sphère),
+     * panneau RECHERCHE muet jusqu'à la fin d'un éventuel changement de facette
+     * — la navigation reportée après l'animation repasse elle aussi par les
+     * rappels du diagramme.
+     */
+    private replayDiagramSelection;
     /**
      * @param forceOpen À passer à true quand target restaure un état déjà connu
      *   (rejeu d'historique back/forward, panneau qui redevient maître) plutôt
@@ -103,10 +123,58 @@ export declare class PanelManager {
      *   la mise à jour ne se faisait qu'un clic Retour/Suivant sur deux.
      */
     syncDiagramToTarget(target: SearchNavTarget, forceOpen?: boolean): void;
+    /** Le panneau qui devient maître impose au diagramme l'élément qu'il
+     *  mémorise, et lui seul : chaque panneau déverrouillé reste isolé des
+     *  autres. Une action se rétablit sans bascule (re-sélectionner l'action
+     *  déjà active la désactiverait) et sans redessiner le bloc, que le
+     *  panneau affiche déjà. Sous verrou, l'action source reste celle du
+     *  panneau verrouillé : on n'en montre que la propagation sur le
+     *  satellite de ce panneau. */
+    private syncDiagramToMasterTarget;
     private setMaster;
     private setPanelLocked;
+    private noticeEl;
+    private noticeTimer;
+    /** Index d'un panneau verrouillé sur une action, ou -1. Cette action est
+     *  l'action source du multi-blocs : ses champs de force et sa bulle
+     *  restent affichés, en sélectionner une autre les remplacerait. */
+    private findActionLockedSlot;
+    isActionSelectionLocked(): boolean;
+    /** Estompe les actions de l'arbre des panneaux non verrouillés. */
+    private applyActionLockClasses;
+    /** Garde de l'arbre d'un panneau : refuse la sélection d'une action tant
+     *  qu'un panneau est verrouillé sur une autre. */
+    private guardActionNav;
+    /** Panneau verrouillé autre que `exceptIdx`, ou -1. */
+    private findLockedSlot;
+    /** Clic refusé sur une action : bandeau sous l'en-tête du panneau maître,
+     *  qui propose de déverrouiller puis de rejouer ce clic. */
+    showActionLockNotice(retry: () => void): void;
+    /** Verrou refusé : un autre panneau l'est déjà. Bandeau ancré sous le
+     *  bouton verrou — en position fixe, car un panneau replié rognerait un
+     *  bandeau qu'il contiendrait. */
+    private showSecondLockNotice;
+    /** Place un bandeau (posé sur body) sous `anchor`, aligné à sa droite —
+     *  au-dessus s'il déborderait du bas de l'écran. */
+    private anchorNotice;
+    /** Bandeau de refus (un seul à la fois) : texte + bouton « Déverrouiller »
+     *  qui exécute `onUnlock`. Disparaît seul au bout de 6 s. */
+    private showNotice;
+    private hideNotice;
+    /** Déverrouille les panneaux qui figent l'action source. Le panneau
+     *  maître garde la main ; les panneaux libérés mémorisent leur action. */
+    private unlockActionLockedSlots;
     openPanel(slotIdx: number, skipSync?: boolean): void;
-    private closePanel;
+    private compareMode;
+    /** Hors mode Comparer, replie les blocs déverrouillés ouverts autres que
+     *  `keepIdx` (null : aucun n'est gardé). */
+    private enforceSingleOpen;
+    private wireCompareToggle;
+    /** Clic sur l'en-tête : replie/déplie le bloc, rien d'autre. Ni bascule
+     *  de maître (seul un clic dans le bloc la fait, voir wireSlotInteraction)
+     *  ni repli des autres blocs, qu'on peut ainsi comparer ouverts ensemble.
+     *  Un maître replié reste maître : le diagramme ne bouge pas. */
+    private togglePanelFromHeader;
     activateLinkedPanel(slotIdx: number): void;
     resolveTargetSlot(): {
         idx: number;
@@ -140,6 +208,8 @@ export declare class PanelManager {
         title: string;
         description: string;
     } | undefined, rationale: string | undefined, isLinked: boolean): () => void;
+    private lockSlot;
+    private unlockSlot;
     private wireSlotInteraction;
     private initPanel1;
     private initPanel2;

package/dist/types/components/search/GlobalSearchController.d.ts

@@ -49,7 +49,8 @@ export interface GlobalSearchControllerOptions {
     /** Appelé au dépli/repli du groupe "Événements Clés" d'une facette. Le groupe
      *  n'est pas une cible de navigation (pas de data-nav-key, rien à
      *  sélectionner) mais il a bien un pendant dans le diagramme : le menu radial
-     *  des Événements Clés, déployé depuis le cœur du yin/yang. */
+     *  des Événements Clés, déployé autour du satellite-facette (Idle
+     *  « facettes »). */
     onKeyEventGroupToggle?: (componentIndex: number, open: boolean) => void;
 }
 export declare class GlobalSearchController {
@@ -264,7 +265,8 @@ export declare class GlobalSearchController {
     /**
      * Diagramme → arbre : reflète l'état réel du menu radial des Événements Clés.
      * Le diagramme referme ces bulles de lui-même dans plusieurs cas (ouverture
-     * du menu d'un Satellite, fermeture ou changement de facette) ; sans ce
+     * du menu d'un Satellite, bulles d'un autre satellite-facette, sortie du
+     * sous-état Idle « facettes ») ; sans ce
      * miroir, le groupe resterait déplié au-dessus d'un diagramme vide et il
      * aurait fallu deux clics pour le rouvrir (le premier ne faisant que
      * rattraper le décalage). DOM seul — n'émet jamais vers le diagramme.
@@ -295,6 +297,13 @@ export declare class GlobalSearchController {
     private setSelectedNavKey;
     private restoreSelectedRow;
     private _syncImpactBlockVisibility;
+    /** Garde de sélection d'action (multi-blocs, voir setActionNavGuard). */
+    private _actionNavGuard;
+    /** Multi-blocs : tant qu'un panneau est verrouillé sur une action, le garde
+     *  refuse toute sélection d'action (retourne false) ; `retry` rejoue la
+     *  sélection une fois le panneau déverrouillé. */
+    setActionNavGuard(guard: ((target: SearchNavTarget, retry: () => void) => boolean) | null): void;
+    /** Retourne false si la navigation a été refusée. */
     private emitNav;
     /** Lie le panneau de détail à droite de l'arbre de recherche. */
     setDetailPanel(el: HTMLElement): void;
@@ -398,15 +407,13 @@ export declare class GlobalSearchController {
      * placeholder (voir _syncPlaceholder).
      */
     resetToSphereView(): void;
+    /** Verrouille ou déverrouille le panneau : bloque la navigation utilisateur et le bloc d'impact. */
+    setLocked(locked: boolean): void;
     /**
      * Injecte le HTML des cartes d'impact directement sous la ligne action dans l'arbre,
      * comme élément frère suivant le <li class="gs-tree-action"> de l'action sélectionnée.
      * Ré-utilisé après chaque renderTree pour que le bloc survive aux reconstructions DOM.
      */
-    private _markActionBeacon;
-    private _clearActionBeacon;
-    /** Verrouille ou déverrouille le panneau : bloque la navigation utilisateur et le bloc d'impact. */
-    setLocked(locked: boolean): void;
     private _injectImpactBlockIfActive;
     /** Anime la fermeture d'un bloc puis appelle onDone une seule fois. */
     private _animateBlockOut;

package/dist/types/components/view/BorderDrawer.d.ts

@@ -21,10 +21,6 @@ export declare class BorderDrawer {
     private readonly facetteImageElements;
     private readonly facetteImagePositions;
     private revealedFacetteImageIndex;
-    /** Default "voile terne" filter applied to every facette image — lifted
-     *  (see revealFacetteImage) only for the facette the outer spark is
-     *  currently sweeping over. */
-    private readonly facetteImageVeilFilter;
     private _hoverSegmentIndex;
     /** Segment currently under the mouse pointer, tracked separately from
      *  _hoverSegmentIndex (which comes from the Recherche tree) so neither
@@ -43,8 +39,14 @@ export declare class BorderDrawer {
     private readonly sourceBeaconColor;
     private borderGhostGroupNode;
     private borderGhostEntries;
+    /** Arcs d'onde du ghost des bordures et leur générateur, gardés d'une frame
+     *  à l'autre tant que les entrées et la géométrie ne changent pas. */
+    private borderGhostWaveCache;
     private borderGhostFrameId;
+    private facetteRevealFrameId;
     constructor(ViewInitializer: ViewInitializer);
+    /** Fin de vie : arrête la vague du ghost et le fondu d'image en attente. */
+    destroy(): void;
     /**
      * Initializes the properties needed for drawing borders based on the ViewInitializer data.
      * Uses borderArcsGroup for the persistent per-component border arcs.
@@ -143,16 +145,16 @@ export declare class BorderDrawer {
      *  (margin, fade start/opacity — see the "Images facette" dev controls) take
      *  effect immediately. */
     rebuildFacetteImageRing(): void;
-    /** Lifts the "voile terne" on one facette's image, veiling every other one
-     *  — only one can be unveiled at a time. Driven by the outer spark
+    /** Lifts the "voile terne" on one facette's image (fade-in of its color
+     *  version over the pre-rendered veiled one), veiling every other one —
+     *  only one can be unveiled at a time. Driven by the outer spark
      *  sweeping across border arcs. Veils *all* others rather than just the
      *  previously-tracked index, so the single-spotlight invariant holds
      *  whatever state the ring was left in. */
     revealFacetteImage(segmentIndex: number): void;
     /** Thumbnails often overlap: SVG has no z-index, so the unveiled image's
      *  group is moved last in the ring to be painted above its neighbours.
-     *  Style is flushed after the move so the filter transition still plays
-     *  (a re-inserted node would otherwise jump straight to its new filter). */
+     *  Returns whether the group was actually moved. */
     private bringFacetteImageToFront;
     /** Center + radius (pre-scale coordinate space) of a facette's image
      *  thumbnail, so labels can be anchored onto the image instead of
@@ -162,6 +164,9 @@ export declare class BorderDrawer {
         y: number;
         radius: number;
     } | undefined;
+    /** Angle du milieu de l'arc de chaque facette (convention d3.arc : 0 = midi,
+     *  sens horaire), indexé par id de facette. */
+    getSegmentMidAngles(): Map<string, number>;
     private getSegmentMidAngle;
     private getPointOnAngle;
     /**
@@ -194,7 +199,9 @@ export declare class BorderDrawer {
     clearSourceBeacon(): void;
     /**
      * Applique un survol léger sur un segment de bordure (hover depuis l'arbre Recherche).
-     * N'affecte pas l'index actif — simple classe CSS ajoutée/retirée.
+     * N'affecte pas l'index actif : une classe sur le groupe wrapper (marqueur
+     * d'état) et un halo cyan pré-rendu sous l'arc (emplacement "hover",
+     * indépendant de ceux de l'état actif et du beacon).
      */
     setHoverSegment(segmentIndex: number | null): void;
     /** Rebuilds every border segment so the live-tuned shape parameters (corner
@@ -202,6 +209,22 @@ export declare class BorderDrawer {
      *  are otherwise built exactly once, at init. Mirrors
      *  rebuildFacetteImageRing. The active/beacon state is re-applied at the
      *  end so a rebuild is visually invisible apart from the tuned parameter. */
+    /** Échelle des arcs repliés : assez petite pour que l'anneau passe
+     *  entièrement sous l'illustration centrale, qui le
+     *  recouvre — d'où l'effet d'arcs « rentrant » dans le cercle global. */
+    private static readonly RETRACTED_ARCS_SCALE;
+    private segmentsRetracted;
+    areSegmentsRetracted(): boolean;
+    /**
+     * Sous-état Idle « facettes » : replie (ou redéploie) l'anneau des arcs de
+     * bordure vers le centre. Mouvement mécanique
+     * plutôt qu'un fondu : léger recul puis plongée sous l'illustration au
+     * repli (easeBackIn), sortie avec un léger dépassement du bord au
+     * redéploiement (easeBackOut). On anime le groupe conteneur des arcs, qui
+     * persiste à travers leurs reconstructions.
+     * Les arcs ne sont plus cliquables tant qu'ils sont repliés.
+     */
+    setSegmentsRetracted(retracted: boolean, durationMs?: number): Promise<void>;
     rebuildBorderSegments(): void;
     /**
      * Updates the style of border segments based on active index (lightweight, no redraw)
@@ -211,20 +234,23 @@ export declare class BorderDrawer {
     private applySegmentStyle;
     private getTotalBordersGroup;
     /**
-     * Applies color animation to a segment's gradient, making it cycle through category colors
+     * Makes an active segment cycle through its ODD colours (see
+     * borderColorCycle: composed by the browser while the diagram is at rest,
+     * written on the main thread while a frame loop runs). Idempotent — the
+     * same colours and duration keep the running cycle and its phase. No cycle
+     * when the duration is 0 (film bake): the static gradient stays.
      */
     private applySegmentColorAnimation;
-    /**
-     * Removes color animation from a segment's gradient
-     */
+    /** Stops an inactive segment's colour cycle; its own fill is restored by
+     *  the caller (fill-opacity of the inactive style). */
     private removeSegmentColorAnimation;
+    private stopSegmentColorCycles;
     /**
      * Applies an animation that only increases the segment outer radius.
      * The inner radius remains unchanged.
      */
     private applySegmentOuterWidthAnimation;
     private startBeaconPulse;
-    private toRgba;
     /**
      * Builds the ODD gradient painted inside one facette's arc.
      *

package/dist/types/components/view/IdleTabGridDrawer.d.ts

@@ -0,0 +1,15 @@
+import type { IdleTabLayout } from "../controller/children/idleTabLayout";
+export declare class IdleTabGridDrawer {
+    private readonly getSvgRoot;
+    /** Nœud devant lequel le tableau s'insère (le globalGroup du diagramme). */
+    private readonly getBeforeNode;
+    private readonly getIdPrefix;
+    private group;
+    constructor(getSvgRoot: () => SVGSVGElement | null, 
+    /** Nœud devant lequel le tableau s'insère (le globalGroup du diagramme). */
+    getBeforeNode: () => Element | null, getIdPrefix: () => string);
+    show(layout: IdleTabLayout, durationMs: number): Promise<void>;
+    hide(durationMs: number): Promise<void>;
+    removeNow(): void;
+    private draw;
+}

package/dist/types/components/view/SpikeDrawer.d.ts

@@ -6,6 +6,9 @@ export declare class SpikeDrawer {
     private key;
     private graphicStrategy;
     spikesEnabled: boolean;
+    /** Points d'onde des spikes, gardés d'une frame à l'autre tant que les
+     *  entrées et le calque ne changent pas. */
+    private spikeGhostWaveCache;
     private spikeGhostEntries;
     private spikeGhostFrameId;
     /** ODD actuellement sélectionné dans le cercle central (clic sur un arc) :
@@ -15,6 +18,10 @@ export declare class SpikeDrawer {
     private oddSpikeHighlight;
     private oddCometEntries;
     private oddCometFrameId;
+    /** Lignes et dégradés posés par le dernier drawSpikes, dans l'ordre de
+     *  geometry.spikes : une frame de transition de facette n'en réécrit que
+     *  les coordonnées et la couleur (updateSpikePositions). */
+    private spikeNodes;
     constructor(ViewInitializer: ViewInitializer);
     /**
      * Initializes the necessary data for drawing spikes.
@@ -32,6 +39,15 @@ export declare class SpikeDrawer {
     private clearSpikes;
     private drawSpikes;
     private drawSpike;
+    private spikeGradientId;
+    /**
+     * Frame de transition de facette : replace en place les spikes du dernier
+     * drawSpikes (extrémités de la ligne et de son dégradé, couleur de l'ODD),
+     * sans retirer ni recréer ni ligne ni dégradé — la mise en avant d'un ODD
+     * sélectionné et ses comètes restent donc posées dessus. Renvoie false si
+     * les spikes ne sont plus les mêmes (l'appelant refait un rendu complet).
+     */
+    updateSpikePositions(): boolean;
     /**
      * Draws the weightDelta ghost overlay from ViewInitializer.spikesGhost on
      * both yin and yang: a dashed gold line to each targeted spike's projected
@@ -47,6 +63,8 @@ export declare class SpikeDrawer {
     private drawSpikeGhostsForType;
     private drawSpikeGhostLines;
     private ensureSpikeGhostLoop;
+    /** Fin de vie : arrête la vague du ghost et les comètes d'ODD. */
+    destroy(): void;
     private stopSpikeGhostLoop;
     /** Dot that travels between a spike's real tip and its projected tip, on
      *  the same lap duration/easing as the border-segment and ODD-arc ghost