@micheeeeel/yinyangapp 2.2.2 → 2.3.0

package/dist/types/api.d.ts

@@ -44,6 +44,13 @@ export declare function mountYinYang(config: YinYangMountConfig): YinYangMountHa
 export declare function createYinYangSvg(config: YinYangSvgConfig): SVGSVGElement | null;
 /** Variante en lot : une seule zone hors écran pour tous les rendus. */
 export declare function createYinYangSvgs(configs: YinYangSvgConfig[]): (SVGSVGElement | null)[];
+/** Durée d'un tour de rotation yin/yang du diagramme (ms), telle qu'elle est
+ *  configurée côté Sphères (`animationConfig.rotationDurationMs`). Un hôte qui
+ *  rejoue la même cinématique ailleurs — un film de marker cuit avec
+ *  `yinYangRotationMs`, ou la variable CSS `--yy-yinyang-rotation` — doit LIRE
+ *  cette valeur plutôt que la recopier : une vitesse changée ici doit se voir
+ *  partout, sans resynchronisation manuelle. */
+export declare const YINYANG_ROTATION_DURATION_MS: number;
 export { createYinYangFilmSvg, createYinYangFilmSvgAsync } from "./api-film";
 export type { YinYangFilmConfig, YinYangFilmAsyncOptions } from "./api-film";
 export { createRandomCause } from "./api-random";

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

@@ -710,11 +710,47 @@ export declare class YinYangController implements IYinYangController {
     private _computeCrossComponentCascadeRows;
     private renderForceFieldDetails;
     private flashChildCuttings;
-    /** Anime un point rouge vif traversant `waypoints` en séquence segment par
-     *  segment. `onWaypointArrival` est appelé à chaque arrivée (sauf la source).
-     *  `onSegmentStart` est appelé au début de chaque segment (utile pour pulser
-     *  le lien force-field correspondant). */
-    private _animatePropagationArc;
+    /** Waypoint d'un satellite de la facette courante (par index orbital). Le
+     *  contrôleur peut être passé quand l'appelant l'a déjà sous la main. */
+    private _resolveOrbitWaypoint;
+    /** Waypoint sur l'arc de bordure d'une autre facette (cible inter-facettes). */
+    private _resolveBorderWaypoint;
+    /** `color` avec l'opacité `alpha` (chaîne CSS). */
+    private static _withAlpha;
+    /**
+     * Couleur de la comète : celle de l'action portant l'emphase (aperçu ??
+     * focus) quand le réglage le demande et qu'elle est identifiable, sinon la
+     * couleur fixe du réglage.
+     */
+    private _resolvePropagationColor;
+    /** Anneau doux (couleur de la comète) autour d'un satellite atteint :
+     *  un cercle qui s'élargit en s'éteignant, plus une brève lueur pleine.
+     *  Intensité réglable (ringOpacity, 0 = rien). */
+    private _drawFlashRings;
+    /**
+     * Joue une passe de propagation sur des waypoints déjà résolus : lueur sur
+     * la source, comète parcourant tout le chemin d'un seul mouvement (en
+     * pulsant chaque lien de champ de force à son entrée), anneau à chaque
+     * arrivée. Partagée par le clic sur une ligne du panneau
+     * (flashChildCuttings) et par la boucle de l'action en focus
+     * (flashSourcePropagationTree). Retourne la durée totale de la passe en ms
+     * (comète éteinte et dernier anneau fondu), pour cadencer la boucle.
+     */
+    private _animateResolvedPropagation;
+    /**
+     * Comète parcourant `waypoints` (polyligne) d'un seul mouvement : vitesse
+     * de croisière réglable, départ et arrivée adoucis (easeSinInOut sur tout
+     * le trajet), fondu d'apparition/extinction, halo flouté, et queue fondue
+     * reconstituée à partir des positions récentes (elle épouse donc les
+     * virages aux étapes au lieu de se couper à chaque segment). Tout est
+     * déterministe en fonction du temps écoulé : la queue se calcule sans
+     * historique, en rééchantillonnant la position à t − Δ.
+     * `onWaypointArrival(wp)` à chaque étape atteinte (sauf la source),
+     * `onSegmentStart(i)` à l'entrée dans chaque segment. `isCancelled` lu à
+     * chaque frame : vrai → la comète disparaît net. Retourne la durée du
+     * trajet (ms), fondu de sortie non compris.
+     */
+    private _animateComet;
     private getCurrentComponent;
     private getCurrentComponentOrUndefined;
     private getCurrentComponentTitle;
@@ -769,6 +805,9 @@ export declare class YinYangController implements IYinYangController {
     private clearProjectedActionState;
     private applyEmptyGhostProjectionState;
     private updateChildActionMenu;
+    /** Sélectionne (ouvre) le satellite `childKey` de la facette courante,
+     *  comme un clic dessus — sans toggle-close s'il est déjà actif. */
+    private selectSatelliteByKey;
     /**
      * Appelé par YinYangDrawer quand le petit cercle "œil" du lobe dominant
      * (yin ou yang, selon Composante.orientation) est cliqué — jamais l'autre
@@ -969,7 +1008,130 @@ export declare class YinYangController implements IYinYangController {
      *  rejoignant leur position de base dans une durée fixe `durationMs`
      *  (troisième mode d'arrêt — voir AnimationsMngr.stopRotationFast). */
     stopRotationAllFast(durationMs: number): void;
+    /**
+     * Satellites atteints par la propagation de l'action en cours (source
+     * racine comprise), résolus depuis les liens du champ de force via leur
+     * index orbital — la même correspondance index → satellite qu'utilise
+     * ForceFieldRenderer pour tracer les segments. Ils gardent leur apparence
+     * normale quand une mise en valeur éteint le reste de la constellation.
+     */
+    private getPropagationTargetChildKeys;
+    /**
+     * Rejoue tout ce qui dépend de l'onglet actif (RECHERCHE vs STACK) : la
+     * mise en valeur des ODD et du satellite sélectionné, réservée à
+     * RECHERCHE, l'anneau orange du satellite sélectionné, réservé à STACK, et
+     * les boutons d'action, qui ne se déploient plus en STACK. Appelé par
+     * switchToTab — le mode se lit dans le DOM (isStackModeActive), il n'y a
+     * donc rien à observer, seulement à resynchroniser au basculement.
+     */
+    refreshModeDependentVisuals(): void;
     highlightOddInChildren(oddId: string | null): void;
+    /**
+     * Aperçu de mise en valeur d'un ODD, quelle qu'en soit l'origine : arc du
+     * diagramme, chip de la légende du panneau RECHERCHE ou du panneau STACK.
+     * Une sortie de survol (`null`) retombe sur l'ODD actif plutôt que
+     * d'effacer la sélection en cours — même priorité actif/survol que celle
+     * que YinYangDrawer applique déjà à l'arc lui-même.
+     */
+    previewOddHighlight(oddId: string | null): void;
+    /** Focus persistant — null pour l'effacer. */
+    private setFocusedStackItem;
+    /**
+     * Clic sur le libellé d'un item déjà en focus, alors que son bloc est
+     * visible dans le panneau (satellite porteur sélectionné) : désactive le
+     * focus et retourne true — l'appelant n'a alors ni navigation ni scroll à
+     * faire. Si le bloc n'est pas visible (l'utilisateur a navigué ailleurs
+     * entre-temps), le clic redevient une sélection normale : false.
+     */
+    toggleStackItemFocusFromStack(stackItemId: string): boolean;
+    /** Aperçu par survol — null à la sortie, qui retombe sur le focus. */
+    private setStackItemEmphasisPreview;
+    /**
+     * Point d'accroche unique de la mise en valeur du satellite source de
+     * l'action portant l'emphase (aperçu ?? focus). Réutilise pour l'instant
+     * le glow de highlightOddByStackItemId (ou le segment de bordure si la
+     * source est dans une autre facette) — l'anneau animé viendra ici.
+     * `clearIfNone` : sans emphase, efface la mise en valeur (sorties de
+     * survol, défocus) ; false pour les simples re-applications (satellites
+     * recréés, fin d'un survol de satellite) afin de ne pas écraser d'autres
+     * highlights en cours.
+     */
+    private applyFocusedSourceHighlight;
+    /** Memo à une entrée de resolveEmphasisSourceChildIndex (lu chaque frame). */
+    private _emphasisSourceMemo;
+    /**
+     * Index orbital du satellite source de l'action portant l'emphase, ou null
+     * si rien ne doit être atténué : hors mode STACK (un aperçu RECHERCHE ne
+     * doit pas hériter d'un focus STACK résiduel), item absent, Événement Clé
+     * (pas de champ de force), ou source dans une autre facette (tout reste
+     * plein, la bordure source est surlignée par highlightOddByStackItemId).
+     * Résolution par oddId + cuttingIndex (buildForceFieldSourceIndicesFromStackItems),
+     * robuste au rebuild de childOddMap ; la clé du memo suit la convention de
+     * ForceFieldLifecycleController._buildPropCacheKey.
+     */
+    private resolveEmphasisSourceChildIndex;
+    /** Identité stable (sourceOriginKey) du satellite source d'un item de la
+     *  pile — null pour un Événement Clé ou une facette introuvable. */
+    private _stackItemSourceOriginKey;
+    private _emphasisKeyMemo;
+    /** Clé de la source de l'action portant l'emphase (aperçu ?? focus), quelle
+     *  que soit sa facette ; null hors STACK ou sans emphase. Lue à chaque frame. */
+    private resolveEmphasisSourceOriginKey;
+    /** Memo à une entrée de resolveFocusedActionSource (lu à chaque update du menu). */
+    private _focusSourceMemo;
+    /**
+     * Action en focus (focus persistant seulement, pas l'aperçu par survol —
+     * une bulle qui apparaît/disparaît au survol serait du bruit), résolue en
+     * (actionId, clé et index orbital du satellite source) dans la facette
+     * courante. null hors mode STACK, sans focus, pour un Événement Clé, ou si
+     * la source vit dans une autre facette.
+     */
+    private resolveFocusedActionSource;
+    /**
+     * Point de départ « bulle » du champ de force de l'action en focus : la
+     * bulle de son action dans le menu radial si le satellite source est celui
+     * sélectionné, sinon la bulle détachée posée sur la source. null si
+     * aucune bulle n'est visible (le champ démarre alors au satellite).
+     */
+    private resolveFocusBubbleStub;
+    private _focusLoopTimer;
+    /** Jeton d'annulation : incrémenté à chaque (re)départ/arrêt, les passes en
+     *  vol comparent leur jeton à chaque frame et s'effacent si dépassées. */
+    private _focusLoopRun;
+    /** Pause entre deux passes (propagationCometConfig.loopGapMs, panneau
+     *  Debug). Un timer en attente est reposé avec la nouvelle valeur pour que
+     *  le réglage se sente tout de suite. */
+    setFocusPropagationLoopGapMs(ms: number): void;
+    private restartFocusPropagationLoop;
+    private stopFocusPropagationLoop;
+    private _runFocusPropagationLoopPass;
+    /** Liens sortants par index orbital de départ (segments chaînés inclus),
+     *  restreints à ceux qui mènent quelque part (satellite ou autre facette). */
+    private _buildOutgoingLinkMap;
+    /** Tous les chemins `prefix` + descente depuis `node` jusqu'aux feuilles
+     *  (satellite sans lien sortant, ou arc d'une autre facette), sans cycle. */
+    private _walkPropagationPaths;
+    /** Anime simultanément chaque chemin (waypoints `head` puis la cible de
+     *  chaque lien) ; retourne la durée de la passe la plus longue. */
+    private _animatePropagationPaths;
+    /**
+     * Joue une passe de propagation sur l'arbre complet des champs de force
+     * d'une source de la facette courante : chaque chemin racine → feuille est
+     * animé simultanément, comme le clic sur l'en-tête d'un bloc source.
+     * L'arbre est lu dans state.forceField.links via le tag sourceChildIndex
+     * (segments chaînés inclus : startIndex = cible précédente). La comète part
+     * de la bulle d'action quand elle est visible. Retourne la durée de la
+     * passe (0 si rien à animer).
+     */
+    private flashSourcePropagationTree;
+    /**
+     * Même passe pour une action dont la source vit dans une autre facette :
+     * ses liens entrants ici (tagués sourceOriginKey, recopié par
+     * restoreIncomingForceFieldContext) partent de l'arc de la facette source ;
+     * chaque entrée est prolongée par sa cascade intra-facette. Retourne la
+     * durée de la passe (0 si cette action n'a aucun lien entrant ici).
+     */
+    private flashIncomingPropagationTree;
     highlightOddByStackItemId(stackItemId: string | null): void;
     /**
      * Retourne les actions applicables au cutting associé à `childKey`,

package/dist/types/components/controller/action-stack/ActionStackController.d.ts

@@ -14,6 +14,9 @@ export declare class ActionStackController {
     private fallingStackItemIds;
     private keyboardListenersBound;
     private _linkedHoverId;
+    /** Item en focus (action en focus côté panneau) : style persistant,
+     *  synchronisé par YinYangController.setFocusedStackItem. */
+    private _focusedItemId;
     private _onBlockHighlightCb?;
     private _onSatelliteHighlightCb?;
     private activeComboHighlight;
@@ -50,6 +53,18 @@ export declare class ActionStackController {
     setSatelliteHighlightCallback(cb: (id: string | null) => void): void;
     getItemById(id: string): ActionStackItem | undefined;
     highlightByStackItemId(id: string | null): void;
+    /** Focus persistant (miroir du bloc en focus dans le panneau) — survit aux
+     *  re-rendus, updateVisual relisant _focusedItemId. */
+    setFocusedItemId(id: string | null): void;
+    /**
+     * Style du cadre d'un item selon son emphase, par priorité décroissante :
+     * survol lié (aperçu) > focus (persistant, teinte pleine + halo) > coché
+     * (halo discret) > repos. Source unique pour updateVisual,
+     * highlightByStackItemId et setFocusedItemId, afin qu'un re-rendu ne
+     * fasse jamais retomber le focus.
+     */
+    private _hitboxEmphasisStyle;
+    private _applyHitboxEmphasisStyles;
     /**
      * Affiche temporairement le highlight combo (cercles de fenêtre) pendant ~1.8 s.
      * Sans effet si un highlight permanent est déjà actif.

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

@@ -3,6 +3,17 @@ import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { type ActionDefinition } from "../../../data/yasuni_actions";
 import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
 import { type Point } from "./radialItemMenu";
+type DetachedBubbleContext = {
+    orbitData: ChildrenOrbitEntry[];
+    /** Satellite source porteur de la bulle — null = aucune bulle détachée. */
+    sourceChildKey: string | null;
+    action: ActionDefinition | null;
+    childActionMenuItemDistance: number;
+    childActionMenuItemScale: number;
+    childActionIconFontScale: number;
+    /** Clic sur la bulle : typiquement, sélectionner le satellite source. */
+    onClick: (sourceChildKey: string, actionId: string) => void;
+};
 type ChildActionMenuContext = {
     orbitData: ChildrenOrbitEntry[];
     activeActionMenuChildKey: string | null;
@@ -44,6 +55,18 @@ export declare class ChildActionMenuController {
      *  le contexte courant) et rejoué au survol : rallumer une impulsion ne
      *  doit pas relancer la chorégraphie d'ouverture. */
     private linkStyleGetter;
+    /** Positions du dernier update() — exposées au champ de force (le segment
+     *  « bulle → source » démarre au centre de la bulle de l'action en focus). */
+    private lastPositions;
+    private detachedGroup;
+    private detachedLineLayer;
+    private lastDetachedCenter;
+    private lastDetachedPosition;
+    /** Centre (coordonnées du globalGroup) de la bulle `actionId` du menu radial
+     *  ouvert, ou null si elle n'y est pas. */
+    getItemCenter(actionId: string): Point | null;
+    /** Centre de la bulle détachée si elle porte `actionId`, sinon null. */
+    getDetachedCenter(actionId: string): Point | null;
     constructor(view: IYinYangView, getChildRenderedCenter: (childController: IYinYangController) => Point | null, refreshActionStackVisual: () => void, 
     /** Aperçu — 1er clic sur une action : affiche sa carte, ne joue rien. */
     activateActionFromChild: (childController: IYinYangController, actionId: string, label?: string) => void, 
@@ -69,6 +92,9 @@ export declare class ChildActionMenuController {
     private setHoveredAction;
     retractAndDispose(): void;
     clearImmediately(): void;
+    /** Retire la bulle détachée et son faisceau, tout de suite (0) ou après un
+     *  délai (fin d'une transition de facette). */
+    private disposeDetached;
     /**
      * Starts the fold-out animation on the visible action buttons, then removes
      * the group once every item has finished animating.  Nulls the group
@@ -76,6 +102,20 @@ export declare class ChildActionMenuController {
      * that follows is a no-op and won't cancel the in-flight transition.
      */
     animateClose(): void;
+    /** Replie la bulle détachée (chorégraphie de fermeture), groupes conservés. */
+    private closeDetached;
+    /**
+     * Bulle détachée de l'action en focus : quand un bloc de propagation est
+     * en focus, le satellite sélectionné n'est pas la source et son menu ne
+     * montre donc pas la bulle de l'action. On pose alors, sur le satellite
+     * source, la seule bulle de cette action (pas ses sœurs), en style
+     * « regardée », avec son faisceau — le champ de force peut ainsi toujours
+     * démarrer à la bulle. Un clic sélectionne le satellite source (le menu
+     * complet prend alors le relais et la bulle détachée se replie).
+     * Cluster indépendant du menu radial : update() n'en sait rien.
+     */
+    updateDetached(context: DetachedBubbleContext): void;
+    private ensureDetachedGroups;
     update(context: ChildActionMenuContext): void;
     private ensureChildActionMenuGroup;
     private ensureLineLayer;

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

@@ -1,6 +1,7 @@
 import { IYinYangController } from "../../../interfaces/IYinYangController";
 import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ChildHighlightState } from "../odd/childHighlightStyles";
 type ChildOddMeta = {
     oddId: string;
     score: number;
@@ -19,6 +20,11 @@ type ChildInteractionControllerDeps = {
     onUserCuttingClicked?: (childController: IYinYangController) => void;
     /** Appelé quand la souris entre/sort d'un satellite (null = sortie). */
     onChildHover?: (oddId: string | null, cuttingIndex?: number) => void;
+    /** ODD actuellement mis en valeur (OddViewManager) — le style "satellite
+     *  actif" et le survol doivent le respecter au lieu de l'écraser. */
+    getOddHighlight: () => ChildHighlightState;
+    /** Satellites atteints par la propagation de l'action en cours. */
+    getPropagationTargetKeys: () => Set<string>;
 };
 export declare class ChildInteractionController {
     private deps;
@@ -33,6 +39,9 @@ export declare class ChildInteractionController {
     clearActiveChild(childControllers: IYinYangController[]): void;
     animateChildren(childControllers: IYinYangController[], show: boolean, onBeforeShow?: () => void, onBeforeHide?: () => void): Promise<void>;
     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 resolveFilterFor;
     private getChildOffset;
 }
 export {};

package/dist/types/components/controller/force-field/ForceFieldDetailsPanel.d.ts

@@ -123,12 +123,25 @@ export declare class ForceFieldDetailsPanel {
     private _onDiagramElementHover?;
     /** Called when hovering a cumulative block — notifies the stack to highlight the matching item. */
     private _onStackItemHighlightCb?;
+    /** Clic sur l'en-tête d'un bloc → action en focus (YinYangController). */
+    private _onStackItemFocusCb?;
+    /** Miroir de state.forceField.focusedStackItemId — sert uniquement à
+     *  ré-appliquer .ff-block--focused après chaque innerHTML. */
+    private _focusedStackItemId;
+    /** Bloc actuellement survolé — pour détecter un survol orphelin quand le
+     *  bloc est détruit par un re-rendu sans que mouseleave n'ait été émis. */
+    private _hoveredBlockStackItemId;
     /** Id d'un bloc "Effets cumulés" à centrer (scroll animé) dès qu'il apparaît
      *  dans le panneau — voir requestScrollToStackItemBlock. Le rendu déclencheur
      *  (renderComposanteInfo / renderCumulativeActionDetails) peut survenir de
      *  façon asynchrone après la demande (ouverture animée du satellite). */
     private _pendingBlockScrollStackItemId;
     private _pendingBlockScrollTimeout;
+    /** Dernier bloc ciblé par un clic-libellé de la pile — encadré persistant
+     *  (.ff-block--selected) pour savoir à tout instant quel bloc est sélectionné,
+     *  là où le focus-flash s'éteint en fin d'animation. Remplacé au prochain
+     *  clic-libellé ; ré-appliqué après chaque innerHTML comme le focus. */
+    private _selectedStackItemId;
     /** Notifie le header (chip STACK) du badge + nom de l'élément affiché par les
      *  cartes d'info minimales (Sphère, ODD) — ces cartes ne répètent plus ce
      *  titre dans leur corps. Facette et Satellite restent gérés par leurs
@@ -166,11 +179,13 @@ export declare class ForceFieldDetailsPanel {
      *  celle d'une tout autre carte, ou une position absente du snapshot
      *  précédent, ce qui la replierait par défaut au lieu de suivre l'auto-fit. */
     private _hasStableCardKey;
-    /** Un clic "replier" (par opposition à un clic qui ouvre/surligne) — sur le
-     *  badge delta habituel, ou sur le header pour une carte qui n'en a plus :
-     *  la carte source Événement Clé n'a aucun delta à elle (celui de l'effet
-     *  vit désormais uniquement sur la carte "Actions amplifiées" sœur), donc
-     *  aucun badge à cliquer — le header sert de poignée de repli à sa place. */
+    /** Un clic "poignée" (ouvrir/replier la carte, rien d'autre — pas de flash
+     *  de propagation, pas de surlignage combo) : le badge delta en haut à
+     *  droite, le chip de poids, et l'en-tête de la carte — même rôle pour tous
+     *  les types de cartes. L'en-tête portait autrefois le flash de propagation
+     *  des cartes source ; ce flash tourne désormais en boucle sur l'action en
+     *  focus (YinYangController.flashSourcePropagationTree) et reste accessible
+     *  ligne par ligne dans le corps de la carte. */
     private _isCardCollapseTrigger;
     private _attachComboHighlightHandlers;
     /** Contexte combo (backward) ou amplificateur (forward) déduit de
@@ -289,10 +304,16 @@ export declare class ForceFieldDetailsPanel {
      * bloc combo/amplificateur, pour que ce bloc-ci ne fasse pas exception.
      */
     private _buildDelayedTargetsCardHtml;
-    /** Badge et note de provenance d'un bloc action de la vue cumulative :
-     *  propagée (depuis son satellite source), adverse (son acteur d'origine)
-     *  ou directe. */
+    /** Badge et note de provenance d'un bloc action de la vue cumulative.
+     *  Seule une action propagée porte une note dans l'en-tête (le satellite
+     *  dont elle provient) : pour une action directe — adverse comprise — on
+     *  est déjà sur le satellite porteur, l'information serait redondante.
+     *  L'acteur d'origine d'une action adverse est rendu à part (`origin`),
+     *  dans le corps du bloc, pour ne pas concurrencer le nom. */
     private _pickActionBlockBadge;
+    /** Ligne « Acteur : … » placée en tête du corps d'un bloc adverse (action
+     *  ou Événement) — remplace l'ancienne note d'en-tête. */
+    private _buildBlockOriginHtml;
     /**
      * En-tête générique et repliable d'un .ff-cumulative-block — icône, badge
      * de type, nom, note de provenance optionnelle ("rationale"), et une
@@ -461,6 +482,20 @@ export declare class ForceFieldDetailsPanel {
     }): void;
     private _attachBlockLinkedHoverHandlers;
     setStackItemHighlightCallback(cb: (id: string | null) => void): void;
+    /** Vrai si le panneau affiche actuellement le bloc « Effets cumulés » de cet
+     *  item de pile (le satellite/la facette porteuse est sélectionné). */
+    hasBlockForStackItem(stackItemId: string): boolean;
+    setStackItemFocusCallback(cb: (id: string | null) => void): void;
+    /** Miroir du focus (source de vérité : YinYangController / state). */
+    setFocusedStackItemId(id: string | null): void;
+    /**
+     * Ré-applique .ff-block--focused sur le bloc en focus — à appeler après
+     * chaque rendu de blocs (innerHTML), comme _consumePendingBlockScroll.
+     * Profite du passage pour clore un survol orphelin : un bloc survolé puis
+     * détruit par le re-rendu n'émet jamais mouseleave, et son aperçu
+     * primerait indéfiniment sur le focus.
+     */
+    private _applyFocusedBlockClass;
     highlightBlockByStackItemId(id: string | null): void;
     /**
      * Demande de centrer (scroll animé) le bloc "Effets cumulés" de cet item de
@@ -475,6 +510,22 @@ export declare class ForceFieldDetailsPanel {
      */
     requestScrollToStackItemBlock(stackItemId: string): void;
     private _consumePendingBlockScroll;
+    /**
+     * Déplie la carte source du premier rail d'un bloc — même désignation que
+     * _applyAutoFitToGrids (carte marquée source, sinon premier non-combo), qui
+     * ne la replie jamais quelle que soit la phase : l'ouvrir ici ne sera donc
+     * pas défait par l'auto-fit déclenché ensuite (rAF / ResizeObserver). Si le
+     * rail déborde, il scrolle — comme après un clic utilisateur sur la carte.
+     */
+    private _expandSourceCard;
+    /**
+     * Mise en valeur appuyée (halo pulsé aux couleurs de l'item, cf.
+     * .ff-block--focus-flash) du bloc que le clic-libellé vient de centrer, pour
+     * qu'il se distingue nettement de ses voisins une fois le scroll terminé.
+     * La classe est retirée en fin d'animation ; un nouveau focus sur le même
+     * bloc relance l'animation depuis le début (retrait + reflow + ré-ajout).
+     */
+    private _flashFocusedBlock;
     private getTargetName;
     private getGhostDetailsContainer;
     private getForceFieldDetailsContainer;

package/dist/types/components/controller/force-field/ForceFieldLifecycleController.d.ts

@@ -35,6 +35,23 @@ type ForceFieldLifecycleControllerDeps = {
         x: number;
         y: number;
     } | null;
+    /** Index orbital du satellite source de l'action en focus/aperçu (voir
+     *  YinYangController.resolveEmphasisSourceChildIndex), null sans emphase.
+     *  Lu à chaque frame : le renderer lisse lui-même la transition. */
+    getEmphasisSourceChildIndex: () => number | null;
+    /** Identité (sourceOriginKey) du satellite source de l'action en
+     *  focus/aperçu, même quand il vit dans une autre facette — c'est elle qui
+     *  atténue les liens entrants des autres actions. null sans emphase. */
+    getEmphasisSourceOriginKey: () => string | null;
+    /** Bulle d'action de l'action en focus (menu radial du satellite source,
+     *  ou bulle détachée) — le champ de cette source démarre à la bulle. */
+    getFocusBubbleStub: () => {
+        sourceChildIndex: number;
+        center: {
+            x: number;
+            y: number;
+        };
+    } | null;
 };
 export declare class ForceFieldLifecycleController {
     private deps;

package/dist/types/components/controller/force-field/ForceFieldRenderer.d.ts

@@ -22,16 +22,41 @@ export declare class ForceFieldRenderer {
      * Called by YinYangController while the propagation arc travels the matching segment.
      */
     pulseLink(linkIndex: number, durationMs: number): void;
+    /** Horodatage du dernier updateVisual — updateVisual ne reçoit pas de Δt,
+     *  on le dérive ici pour le lissage de l'emphase. */
+    private _lastVisualNow;
+    /** Identité du segment « bulle → source » courant et origine de sa
+     *  révélation (voir updateVisual / bubbleStub). */
+    private _stubKey;
+    private _stubRevealAt;
     hasActiveGroup(): boolean;
     ensureElements(params: {
         globalGroupNode: SVGGElement;
         requiredCount: number;
     }): void;
+    /** Ajuste le nombre de layers au nombre de segments à dessiner (liens +
+     *  éventuel segment « bulle → source », voir updateVisual). */
+    private _ensureLayerCount;
     updateVisual(params: {
         forceFieldOrbitData: ChildrenOrbitEntry[] | null;
         forceFieldLinks: ForceFieldSegment[];
         forceFieldRevealStartedAt?: number;
         forceFieldPhase: number;
+        /** Index orbital du satellite source de l'action en focus (ou en aperçu
+         *  par survol) ; null = pas d'emphase, tous les liens restent pleins. */
+        emphasisSourceChildIndex: number | null;
+        /** Identité stable (sourceOriginKey) de la source de l'action en
+         *  focus/aperçu — prime sur l'index quand le lien la porte, et seule
+         *  façon d'atténuer les liens entrants (source dans une autre facette). */
+        emphasisSourceOriginKey: string | null;
+        /** Bulle d'action de l'action en focus : quand elle est connue, le champ
+         *  de cette source « démarre » à la bulle — un segment supplémentaire
+         *  bulle → satellite source est dessiné avec la grammaire des liens
+         *  (port d'émission à la bulle, éclat au satellite). null = aucun. */
+        bubbleStub: {
+            sourceChildIndex: number;
+            center: Point;
+        } | null;
         getChildRenderedCenter: (childController: IYinYangController) => Point | null;
         getComponentBorderTargetPoint: (componentId: string) => Point | null;
     }): void;

package/dist/types/components/controller/force-field/types.d.ts

@@ -31,8 +31,24 @@ export type ForceFieldLink = {
     potentialGain: number;
     /** Delay before revealing this link, used for chained intra-ODD propagation. */
     revealDelayMs?: number;
+    /** Index orbital du satellite source racine ayant produit ce lien (posé par
+     *  ForceFieldComputationService.build, un appel par source). Pour un segment
+     *  chaîné, startIndex est la cible précédente : seul ce champ dit à quelle
+     *  action le lien appartient — c'est la clé de l'emphase par action en focus
+     *  (ForceFieldRenderer). Absent pour les liens injectés en incomingMode
+     *  (buildFromSource) → jamais atténués. */
+    sourceChildIndex?: number;
+    /** Identité stable du satellite source racine de l'action (voir
+     *  buildSourceOriginKey). Contrairement à sourceChildIndex (index orbital,
+     *  local à une facette), elle survit au changement de facette : recopiée
+     *  sur les liens entrants (restoreIncomingForceFieldContext), elle permet à
+     *  l'emphase et à la comète de l'action en focus de suivre sa propagation
+     *  inter-facettes depuis l'arc de la facette source. */
+    sourceOriginKey?: string;
     detail: ForceFieldLinkDetail;
 };
+/** Clé d'identité d'un satellite source racine : `composante|odd|cutting`. */
+export declare function buildSourceOriginKey(componentId: string, oddId: string, cuttingId: number | undefined): string;
 /**
  * Représentation pure-rendu d'un segment de champ de force.
  * Identique à ForceFieldLink mais sans le champ `detail` (domaine métier).

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

@@ -0,0 +1,78 @@
+/** Un satellite membre de l'ODD mis en valeur, dans le repère du globalGroup
+ *  de la facette parente (mêmes coordonnées que
+ *  WeightPreviewRingRenderer : centre orbital courant + rayon du satellite). */
+export type OddHighlightTarget = {
+    id: string;
+    x: number;
+    y: number;
+    radius: number;
+};
+/**
+ * Effets "sélection d'ODD" posés sur les satellites membres, dans le
+ * globalGroup de la facette parente — donc dans le même repère que les
+ * satellites eux-mêmes, qui continuent d'orbiter dessous (les positions sont
+ * relues à chaque frame via `getTargets`, jamais figées à la construction).
+ *
+ * Trois couches, toutes peintes dans la couleur de l'ODD :
+ *  - un anneau de visée pointillé dont les tirets dérivent lentement,
+ *    doublé de quatre crochets d'angle qui tournent en sens inverse ;
+ *  - un "ping" sonar qui s'échappe de chaque satellite en boucle, décalé
+ *    d'un satellite à l'autre ;
+ *  - une onde de scan unique partant de la couronne de la facette, tirée une
+ *    seule fois quand un nouvel ODD passe en sélection (voir `oddKey`).
+ *
+ * Réservé à l'intensité "full" (clic) : le survol n'allume que le halo
+ * coloré des satellites, sans rien de tout ceci — voir OddViewManager.
+ *
+ * Aucun filtre CSS ici, à dessein : un `drop-shadow` sur un élément dont
+ * un attribut change à chaque frame (rotation des crochets, dérive des
+ * tirets, rayon du ping) force une passe de flou par frame et par élément —
+ * mesuré à 65 ms/frame avec cinq satellites en orbite. La lueur est rendue
+ * par un second trait, plus large et translucide, dessiné sous le trait
+ * net : même lecture, coût nul. De même, les styles constants ne sont posés
+ * qu'à la création (enter), seule la géométrie est écrite par frame.
+ */
+export declare class OddHighlightEffects {
+    private layerNode;
+    private getTargets;
+    private color;
+    private frameId;
+    private scan;
+    /** ODD actuellement mis en valeur — sert à ne retirer l'onde de scan
+     *  qu'une seule fois par sélection, et non à chaque re-render. */
+    private currentOddKey;
+    render(params: {
+        globalGroupNode: SVGGElement | null;
+        getTargets: () => OddHighlightTarget[];
+        color: string;
+        oddKey: string;
+        parentCenterX: number;
+        /** Rayon de départ de l'onde de scan : le bord externe de la couronne,
+         *  et non le centre — la moitié intérieure de la course serait cachée
+         *  sous le disque de la facette, et l'onde doit se lire comme partant de
+         *  l'arc de l'ODD vers ses satellites. */
+        parentCenterY: number;
+        scanStartRadius: number;
+        scanRadius: number;
+    }): void;
+    /**
+     * Retire toutes les couches. `keepOddMemory` conserve l'ODD mémorisé pour
+     * la déduplication de l'onde de scan : on l'utilise quand la mise en
+     * valeur n'est que *rétrogradée* en "soft" (survol d'un arc voisin alors
+     * qu'un ODD est sélectionné) — sinon le simple fait de repasser la souris
+     * rejouerait l'onde à chaque retour sur la sélection.
+     */
+    clear(keepOddMemory?: boolean): void;
+    private ensureLayer;
+    private ensureLoop;
+    private stopLoop;
+    /** Jointure d'un couple lueur + trait net pour une forme donnée : la lueur
+     *  est le même élément, dessiné d'abord, plus large et translucide. */
+    private joinPair;
+    private drawReticles;
+    /** Quatre arcs courts aux diagonales — le "target lock" qui encadre
+     *  l'anneau de visée sans le fermer. */
+    private buildBracketPath;
+    private drawPings;
+    private drawScan;
+}