@micheeeeel/yinyangapp 3.0.1 → 3.1.1

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

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

@@ -11,6 +11,12 @@ export declare class ViewInitializer {
     graphicContainer: IGraphicElement;
     graphicStrategy: IGraphicsStrategy;
     globalGroup: IGraphicElement;
+    /** Enveloppe du globalGroup d'un satellite, sous le children-group du
+     *  parent : porte la seule translation d'orbite, jouée par le navigateur
+     *  (ChildrenOrbitManager), sans toucher aux transforms que d'autres posent
+     *  sur le globalGroup (respiration du poids). C'est le nœud à retirer pour
+     *  supprimer le satellite. Pour le parent : son globalGroup. */
+    orbitGroup: IGraphicElement;
     yinOrYangGroup: {
         yin: IYinOrYangPattern;
         yang: IYinOrYangPattern;
@@ -20,6 +26,11 @@ export declare class ViewInitializer {
         yang: IYinOrYangPattern;
     };
     yinYangGroup: IGraphicElement;
+    /** Rappelé, une fois par tâche, quand ce qui suit la rotation Yin/Yang
+     *  change : géométrie des lobes, libellés contre-tournés redessinés.
+     *  AnimationsMngr y refait ses animations pendant une rotation. */
+    onRotationTargetsChanged: (() => void) | null;
+    private rotationTargetsChangePending;
     childrenGroup: IGraphicElement;
     facetteImageBackgroundGroup: IGraphicElement;
     borderArcsGroup: IGraphicElement;
@@ -220,6 +231,8 @@ export declare class ViewInitializer {
     private currentComponentIndex;
     private animationSequence;
     private isAnimationRunning;
+    private transitionFrameId;
+    private observedRoot;
     private isDisplayingOddMode;
     /**
      * Returns whether the view is currently in ODD display mode.
@@ -285,6 +298,18 @@ export declare class ViewInitializer {
      * Keeps yinYangGroup intact while refreshing symbol groups and spikes.
      */
     private redrawYinYangGeometry;
+    /**
+     * Frame d'une transition de facette ou d'ODD : quand les nœuds du dernier
+     * rendu complet couvrent déjà les catégories de la frame, seuls leurs
+     * attributs sont réécrits (YinYangDrawer.updateSwitchFrame,
+     * SpikeDrawer.updateSpikePositions) ; sinon — typiquement la première
+     * frame, où les catégories entrantes rejoignent les sortantes — rendu
+     * complet. Bordures, poids de la facette et illustration idle ne dépendent
+     * pas de l'interpolation : ils attendent la dernière frame, toujours rendue
+     * en entier pour que l'état final soit exactement celui d'un rendu complet.
+     */
+    private renderTransitionFrame;
+    private updateGeometryInPlace;
     /**
      * Redraws the ghost Yin/Yang geometry without touching borders or spikes.
      */
@@ -306,11 +331,10 @@ export declare class ViewInitializer {
     getAverageTension(): number;
     getAverageState(): number;
     /** Poids C_f de la facette courante : moyenne des poids de tous ses
-     *  satellites (`meanWeight`, même règle que `perimeterWeight`, qui fixe la
+     *  satellites (`facetWeight`, même règle que `perimeterWeight`, qui fixe la
      *  taille de son arc de bordure). */
     getFacetteWeight(): number;
-    /** Plafond du poids C_f : WEIGHT_MAX, quel que soit le nombre de
-     *  satellites. */
+    /** Plafond du poids de la facette courante (`facetWeightMax`). */
     getFacetteWeightMax(): number;
     /** getFacetteWeight pour une facette quelconque (poids de chaque arc de
      *  bordure quand "Afficher libellés" est actif). */
@@ -321,9 +345,9 @@ export declare class ViewInitializer {
     /**
      * Centre courant (écran, repère de `globalGroup`) du sous-cercle yin ou
      * yang, en tenant compte d'une éventuelle rotation Yin/Yang en cours
-     * (AnimationsMngr écrit un `transform` orbite+spin directement sur
-     * `yinOrYangGroup[orientation].graphElementGroup` à chaque frame, sans
-     * jamais toucher `geometry`). Résolu via le CTM plutôt qu'en rejouant la
+     * (AnimationsMngr anime, par Web Animations, un `transform` orbite+spin
+     * sur `yinOrYangGroup[orientation].graphElementGroup`, sans jamais
+     * toucher `geometry` ; le CTM reflète la valeur animée courante). Résolu via le CTM plutôt qu'en rejouant la
      * formule d'orbite d'AnimationsMngr : le point transformé est le centre
      * CANONIQUE du lobe, qui est aussi le pivot de sa rotation locale — une
      * rotation autour de son propre point fixe n'a par construction aucun
@@ -406,6 +430,10 @@ export declare class ViewInitializer {
      */
     private interpolateCategoriesRGB;
     private startCategoryAnimation;
+    private requestTransitionFrame;
+    /** Fin de vie : coupe la transition de facette en cours, le suivi de
+     *  visibilité du diagramme et le rappel de rotation. */
+    destroy(): void;
     private startComponentAnimationLoop;
     private getAnimationCurrentState;
     private getComponentAnimationState;
@@ -442,7 +470,14 @@ export declare class ViewInitializer {
     private buildGhostOddSpikes;
     private buildGhostComponentSpikes;
     private areCategoriesEqual;
-    private clearGroupChildren;
+    /**
+     * Vide un lobe avant son rendu complet, sauf ses libellés (calque des
+     * libellés d'arc ODD, score de la facette) : leurs rendus les mettent à
+     * jour par jointure, ce qui les garde visibles d'un rendu à l'autre. Les
+     * recréer à chaque rendu les faisait repartir d'une opacité nulle — et les
+     * laissait invisibles pendant toute une transition de facette.
+     */
+    private clearLobeGroup;
     /**
      * Converts hex color to RGB object.
      * @param hex Hex color (e.g., "#FF0000")
@@ -473,6 +508,9 @@ export declare class ViewInitializer {
      */
     private createYinOrYangGroups;
     private updateYinOrYangGroup;
+    /** Signale (en fin de tâche, après le rendu en cours) que les cibles de
+     *  la rotation ont changé — voir onRotationTargetsChanged. */
+    notifyRotationTargetsChanged(): void;
     private applyGhostOverlapRules;
     private buildGeometry;
     private buildSpikes;