@micheeeeel/yinyangapp 3.0.1 → 3.1.1

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

@@ -6,50 +6,83 @@ type ChildrenOrbitManagerDeps = {
     view: IYinYangView;
     getChildControllers: () => IYinYangController[];
     state: YinYangControllerState;
+    /** Rendu complet (menu, labels, panneaux, champ de force) : seulement
+     *  quand l'état de l'orbite change (démarrage, arrêt, repos). */
     renderOppositeChildrenForceField: (orbitData: ChildrenOrbitEntry[]) => void;
+    /** Rendu par frame pendant que l'orbite tourne : uniquement ce qui suit
+     *  la position des satellites (bulles, libellés, liens du champ de force). */
+    updateOrbitFrame: (orbitData: ChildrenOrbitEntry[]) => void;
 };
+/**
+ * Orbite des satellites, jouée par le navigateur (PERF-18). Le mouvement est
+ * décrit en tronçons à accélération constante (`rotationMotion.ts`, ici en
+ * radians et rad/ms) ; chaque satellite reçoit une animation Web Animations
+ * par tronçon sur l'enveloppe d'orbite (`viewInitializer.orbitGroup`), calée
+ * sur `document.timeline` : le contenu du satellite n'est plus re-rasterisé.
+ *
+ * Ce qui suit les satellites (bulles, libellés, champ de force) reste en JS :
+ * une boucle par image recalcule l'angle sur la même horloge et le même
+ * modèle (`evaluateMotion`), d'où la même position que celle affichée.
+ * Les positions lues ailleurs passent par `getChildTranslation`, l'attribut
+ * `transform` n'étant plus à jour pendant le mouvement.
+ */
 export declare class ChildrenOrbitManager {
     private deps;
     private readonly orbitService;
     private cachedOrbitData;
-    /** Temps de rampe (ms) courant pour l'accélération/décélération de la
-     *  boucle active — mémorisé pour que setSpeed() (vitesse changée en vol)
-     *  et la boucle elle-même s'y réfèrent sans avoir à le repasser partout. */
+    /** Temps de rampe (ms) courant pour l'accélération/décélération —
+     *  mémorisé pour que setSpeed() (vitesse changée en vol) s'y réfère sans
+     *  avoir à le repasser partout. */
     private rampMs;
-    /** Vitesse angulaire instantanée (rad/ms, signée) — chasse la vitesse
-     *  cible (state.children.orbitSpeed, en rad/s) au rythme imposé par
-     *  rampMs. */
-    private currentOmega;
-    private lastTimestamp;
-    /** Présent tant qu'un arrêt "retour à la position de base" est en cours :
-     *  l'orbite continue sa course pour s'arrêter exactement sur un multiple
-     *  de 2π (donc visuellement sur la position de base), plutôt que de couper
-     *  la vitesse puis sauter à angle 0. Même principe que AnimationsMngr :
-     *  `beginHomingStop` (mode "normal") décélère à taux constant, avec un tour
-     *  de plus si besoin de confort ; `beginFastHomingStop` (mode "Accéléré")
-     *  rejoint TOUJOURS le prochain passage par la position de base dans une
-     *  durée fixe choisie par l'utilisateur — voir `fastHomingStop.ts`. */
-    private homeBrake?;
+    /** Mouvement en cours (vide à l'arrêt). Angles absolus, ajoutés à l'angle
+     *  de base de chaque satellite. */
+    private motion;
+    /** Mouvement en cours = arrêt "retour à la position de base" : l'orbite
+     *  continue sa course pour s'arrêter exactement sur un multiple de 2π,
+     *  plutôt que de couper la vitesse puis sauter à angle 0. Même principe
+     *  que AnimationsMngr : `beginHomingStop` (mode "normal") décélère à taux
+     *  constant, avec un tour de plus si besoin de confort ;
+     *  `beginFastHomingStop` (mode "Accéléré") rejoint TOUJOURS le prochain
+     *  passage par la position de base dans une durée fixe choisie par
+     *  l'utilisateur — voir `fastHomingStop.ts`. */
+    private homing;
+    /** Satellites et géométrie de la dernière pose (statique ou animée). */
+    private appliedOrbitData;
+    /** Angle de la dernière pose statique. */
+    private appliedAngle;
+    /** Animations posées, par enveloppe d'orbite. */
+    private tracks;
+    /** Satellites recréés pendant le mouvement : animations à reposer. */
+    private tracksStale;
     constructor(deps: ChildrenOrbitManagerDeps);
     invalidateCache(): void;
     buildOrbitData(): ChildrenOrbitEntry[];
+    /** Pose statique (orbite à l'arrêt ou au repos) et rendu complet. */
     applyTransforms(angleOffset: number, orbitData?: ChildrenOrbitEntry[]): void;
+    /** Translation affichée du satellite (repère du parent), y compris en
+     *  plein mouvement : calculée à l'instant de l'image courante. */
+    getChildTranslation(controller: IYinYangController): {
+        x: number;
+        y: number;
+    };
+    private writeTranslations;
     setEnabled(isEnabled: boolean, rampMs?: number): void;
-    /** Change la vitesse cible. Si une boucle est déjà active, elle relit
-     *  orbitSpeed à chaque frame et y converge au rythme de sa rampe en cours
-     *  (pas besoin de la redémarrer) — un changement de vitesse en vol est
-     *  donc lui aussi progressif plutôt que d'un coup. */
+    /** Change la vitesse cible : en vol, le mouvement repart de l'état
+     *  courant et y converge au rythme de la rampe en cours — un changement
+     *  de vitesse est donc lui aussi progressif plutôt que d'un coup. */
     setSpeed(speed: number): void;
     setRadiusScale(scale: number): void;
     /**
      * Démarre (ou modifie en vol) l'orbite. Avec `rampMs > 0`, la vitesse
-     * angulaire part de sa valeur courante (0 si à l'arrêt) et chasse
-     * progressivement `state.children.orbitSpeed` (relu à chaque frame — un
-     * arrêt en cours de freinage repris ici ré-accélère en douceur depuis la
-     * vitesse déjà atteinte). `rampMs` omis (0) → vitesse cible appliquée
+     * angulaire part de sa valeur courante (0 si à l'arrêt) et rejoint
+     * `state.children.orbitSpeed` à accélération constante — un arrêt en
+     * cours de freinage repris ici ré-accélère en douceur depuis la vitesse
+     * déjà atteinte. `rampMs` omis (0) → vitesse cible appliquée
      * instantanément, comportement historique.
      */
     start(_targetSpeed: number, rampMs?: number): void;
+    /** Fin de vie : coupe l'orbite sans rien écrire dans le DOM. */
+    destroy(): void;
     /**
      * Arrête l'orbite. Avec `rampMs > 0` et une orbite en cours, les satellites
      * continuent leur course et décélèrent à taux constant pour s'arrêter
@@ -68,6 +101,24 @@ export declare class ChildrenOrbitManager {
     private computeRemainingToZero;
     private beginHomingStop;
     private beginFastHomingStop;
+    /** Angle et vitesse à l'instant `now`, mouvement en cours ou non. */
+    private currentMotionState;
+    private play;
+    /**
+     * Image d'orbite en vol : les satellites sont déplacés par le navigateur ;
+     * ici, seulement ce qui les suit. Le temps de l'image (rAF) est celui de
+     * `document.timeline` : même angle que celui affiché.
+     */
+    private readonly onFrame;
+    /** (Re)pose une animation par tronçon sur l'enveloppe de chaque satellite. */
+    private syncTracks;
+    private cancelTracks;
+    private cancelFrameLoop;
+    /** Repos à `angle` : pose statique écrite AVANT de retirer les
+     *  animations (même tâche, aucune image entre les deux). */
+    private settle;
     private finalizeStop;
+    /** Horloge des animations (temps de l'image courante). */
+    private now;
 }
 export {};

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

@@ -63,6 +63,8 @@ export declare class OddHighlightEffects {
      * rejouerait l'onde à chaque retour sur la sélection.
      */
     clear(keepOddMemory?: boolean): void;
+    /** Fin de vie : coupe la boucle et retire les couches. */
+    destroy(): void;
     private ensureLayer;
     private ensureLoop;
     private stopLoop;

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

@@ -47,8 +47,10 @@ export declare class OddViewManager {
     /** Satellite sélectionné (menu d'action ouvert) — il porte la même mise en
      *  valeur que celle d'un ODD, mais resserrée sur lui seul. */
     private selectedChildKey;
-    /** Aperçu transitoire au survol d'un item de la pile — prioritaire tant
-     *  qu'il dure, et sans effets de sélection. */
+    /** Satellite source d'un item de la pile — prioritaire tant qu'il dure.
+     *  "soft" : aperçu au survol, sans effets de sélection. "full" : action en
+     *  focus en STACK, même mise en lumière qu'un satellite sélectionné en
+     *  RECHERCHE. */
     private stackPreviewKeys;
     /** Laquelle des deux sélections délibérées — un ODD, ou un satellite — est
      *  la plus récente. Elles peuvent coexister (le menu d'un satellite reste
@@ -96,11 +98,13 @@ export declare class OddViewManager {
      *  de visée + pings + onde de scan, et spikes énergisés avec leurs
      *  comètes. */
     private syncFullHighlightEffects;
+    /** Fin de vie : coupe la boucle des effets de mise en valeur. */
+    destroy(): void;
     /** Relu à chaque frame par OddHighlightEffects : les satellites orbitent
      *  sous les anneaux, et peuvent disparaître (satellites masqués, facette
      *  changée) sans que la mise en valeur soit repassée. */
     private buildHighlightTargets;
-    highlightOddByStackItemId(stackItemId: string | null): void;
+    highlightOddByStackItemId(stackItemId: string | null, intensity?: OddHighlightIntensity): void;
     cancelOddHighlight(): void;
     showOddInfo(oddId: string): void;
     showComposanteInfo(): void;

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

@@ -44,10 +44,24 @@ export declare const HALO_RING: Record<OddHighlightIntensity, {
     glowOpacity: number;
 }>;
 /** Satellite dont le menu d'action est ouvert : blanc pur et plus large, pour
- *  ne pas se confondre avec un membre de l'ODD mis en valeur. */
-export declare const ACTIVE_CHILD_FILTER = "drop-shadow(0 0 12px rgba(255, 255, 255, 0.9)) brightness(1.1)";
+ *  ne pas se confondre avec un membre de l'ODD mis en valeur. La lueur est
+ *  l'anneau ACTIVE_CHILD_GLOW (voir setChildGlowRing), pas un drop-shadow :
+ *  le satellite est en orbite, le flou serait recalculé à chaque image. */
+export declare const ACTIVE_CHILD_FILTER = "brightness(1.1)";
 /** Survol direct d'un satellite — aperçu par-dessus tout le reste. */
-export declare const HOVERED_CHILD_FILTER = "brightness(1.3) drop-shadow(0 0 7px rgba(255,255,255,0.4))";
+export declare const HOVERED_CHILD_FILTER = "brightness(1.3)";
+/** Survol d'un satellite depuis l'arbre Recherche. */
+export declare const SEARCH_HOVERED_CHILD_FILTER = "brightness(1.5)";
+/** Lueur d'un satellite, équivalent de `drop-shadow(0 0 ${blur}px color)`
+ *  (alpha compris dans `alpha`). */
+export type ChildGlow = {
+    color: string;
+    blur: number;
+    alpha: number;
+};
+export declare const ACTIVE_CHILD_GLOW: readonly ChildGlow[];
+export declare const HOVERED_CHILD_GLOW: readonly ChildGlow[];
+export declare const SEARCH_HOVERED_CHILD_GLOW: readonly ChildGlow[];
 /** Aucun ODD mis en valeur et satellite ni actif ni survolé. */
 export declare const IDLE_CHILD_FILTER = "brightness(0.85)";
 /** Sans transition, l'extinction des non-membres se lit comme un
@@ -77,3 +91,31 @@ export declare function resolveChildFilter(params: {
     isPropagationTarget: boolean;
     highlight: ChildHighlightState;
 }): string;
+/** Lueur d'état du satellite (actif), dans le même ordre de priorité que
+ *  resolveChildFilter : seul le satellite actif hors mise en valeur d'ODD en
+ *  a une — les membres ont leur anneau coloré (HALO_RING). */
+export declare function resolveChildGlow(params: {
+    isMember: boolean;
+    isActiveChild: boolean;
+    highlight: ChildHighlightState;
+}): readonly ChildGlow[] | null;
+/**
+ * Pose (ou retire, `glows` null) l'anneau de lueur d'un satellite : des
+ * cercles concentriques translucides juste au-delà de son bord (voir
+ * glowHalo.glowStrokeLayers), dans son globalGroup — ils suivent donc son
+ * orbite sans aucun travail par image, là où un drop-shadow sur le groupe
+ * était recalculé à chaque déplacement.
+ */
+export declare function setChildGlowRing(childController: {
+    view: {
+        viewInitializer: {
+            globalGroup: {
+                node: () => unknown;
+            };
+            positionX: number;
+            positionY: number;
+            borderOuterRadius: number;
+            borderInnerRadius: number;
+        };
+    };
+}, glows: readonly ChildGlow[] | null): void;

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

@@ -83,9 +83,12 @@ type SearchPanelSynchronizerDeps = {
         x: number;
         y: number;
     } | null;
-    /** Glisser guidé d'un prérequis : réaffiche dans le panneau STACK les
-     *  blocs de l'item de pile portant le combo. */
-    showStackItemBlocksForDrag: (stackItemId: string) => void;
+    /** Affiche le combo source, ou l'action ciblée si le guide vient d'un événement. */
+    showStackItemBlocksForDrag: (stackItemId: string, action: {
+        actionId: string;
+        oddId: string;
+        cuttingIndex: number;
+    }) => void;
     /** Glisser guidé : aperçu en direct des cartes combo selon l'emplacement
      *  survolé (restaure le contenu d'origine hors glisser guidé). */
     refreshGuidedComboPreview: () => void;
@@ -128,8 +131,8 @@ export declare class SearchPanelSynchronizer {
      * Cœur partagé du glisser-déposer vers la pile — entièrement générique
      * (ne connaît ni action ni Événement Clé), utilisé par startSearchActionDrag
      * (hiérarchie RECHERCHE), par ChildActionMenuController (bulle satellite du
-     * diagramme) et par CoreEventMenuController (bulle Événement Clé du cercle
-     * central) : chaque appelant fournit l'icône du fantôme de glisser et un
+     * diagramme) et par KeyEventMenuController (bulle Événement Clé d'un
+     * satellite-facette) : chaque appelant fournit l'icône du fantôme de glisser et un
      * `onDrop` qui sait construire l'item de pile approprié. Retourne `cleanup`
      * comme poignée d'annulation, pour permettre à un appelant de stopper
      * proprement un glisser en cours (ex. fermeture du menu radial en plein

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

@@ -8,7 +8,7 @@ type ControllerSettingsApplierDeps = {
     getOrbitData: () => ChildrenOrbitEntry[];
     updateContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
     updateChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
-    updateCoreEventMenu: () => void;
+    updateKeyEventMenu: () => void;
     applyChildrenFitScale: () => void;
     clearForceFieldComputationState: () => void;
     renderOppositeChildrenForceField: () => void;
@@ -35,10 +35,10 @@ export declare class ControllerSettingsApplier {
     setOddLabelsCompact(compact: boolean): void;
     setChildActionMenuItemDistance(distance: number): void;
     setChildActionMenuItemScale(scale: number): void;
-    setCoreEventMenuDistanceOffset(offset: number): void;
-    setCoreEventMenuItemScale(scale: number): void;
+    setKeyEventMenuDistanceOffset(offset: number): void;
+    setKeyEventMenuItemScale(scale: number): void;
     setChildActionIconFontScale(scale: number): void;
-    setCoreEventIconFontScale(scale: number): void;
+    setKeyEventIconFontScale(scale: number): void;
     setChildLabelMaxLines(lines: number): void;
     setOddLabelMaxLines(lines: number): void;
     setFacetteLabelFontScale(scale: number): void;

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

@@ -94,9 +94,9 @@ export declare class ControllerSession {
         cuttingIndex: number;
         forceOpen: boolean;
     } | null;
-    /** Menu cœur à déployer à l'arrivée sur la facette (voir searchSetKeyEventMenuOpen). */
-    pendingKeyEventMenuAfterSwitch: boolean;
-    isCoreEventMenuOpen: boolean;
+    /** Facette dont le satellite-facette (Idle « facettes ») a ses bulles
+     *  d'Événements Clés déployées, ou null. */
+    keyEventMenuFacetteId: string | null;
     /** Id de l'Événement Clé actuellement en aperçu (carte affichée), ou null. */
     activeKeyEventId: string | null;
     /** Quand vrai, le prochain appel à onShowDirectActionBlock est routé vers le panneau B. */

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

@@ -46,6 +46,16 @@ export type ControllerUiCallbacks = {
      *  or when an ODD-level interaction deselects it — componentIndex lets the listener
      *  restore its detail panel to the facette view rather than clearing it entirely. */
     onDiagramSatelliteDeselect?: (componentIndex: number) => void;
+    /** Vrai si au moins un panneau RECHERCHE est verrouillé (multi-blocs) : seul
+     *  ce cas garde l'action active quand on sélectionne un autre satellite, pour
+     *  en consulter la propagation dans le panneau suivant. */
+    isAnyRecherchePanelLocked?: () => boolean;
+    /** Vrai si un panneau RECHERCHE est verrouillé sur une action : elle reste
+     *  l'action source du multi-blocs, aucune autre ne se sélectionne. */
+    isActionSelectionLocked?: () => boolean;
+    /** Clic sur une action alors que la sélection est verrouillée : `retry`
+     *  rejoue ce clic une fois le panneau déverrouillé. */
+    onActionSelectionBlocked?: (retry: () => void) => void;
     /** Fired when the user clicks the current composante's border arc to hide its satellites. */
     onDiagramComposanteDeselect?: () => void;
     /** Vers le panneau Recherche quand la souris entre/sort d'un satellite dans le diagramme. */

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/ObstacleDemoControl.d.ts

@@ -0,0 +1,3 @@
+import type { YinYangController } from "../controller/YinYangController";
+/** Câble le groupe #debug-obstacle-group (affiché pour l'obstacle seul). */
+export declare function mountObstacleDemoControl(controller: YinYangController): void;

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;