@micheeeeel/yinyangapp 3.0.1 → 3.1.0

package/dist/types/adapters/yasuniCauseAdapter.d.ts

@@ -7,7 +7,7 @@ import { type ContactProfileData } from "../data/contacts";
  * Les scores initiaux sont neutres (0.5 = 50 % de tension), les poids valent 1
  * par satellite tant qu'aucune valeur n'est renseignée dans les données.
  * Poids d'une facette (taille de son arc) : C_f, moyenne des poids de TOUS
- * ses satellites, catégories confondues, zéros inclus (`meanWeight`) — même
+ * ses satellites, catégories confondues, zéros inclus (`facetWeight`) — même
  * règle pour une cause et pour un contact (POC-05A4).
  */
 export declare function composantesToCause(composantes: Composante[], id?: string, name?: string): Cause;

package/dist/types/adapters/yinYangAdapter.d.ts

@@ -1,6 +1,13 @@
 import { YinYangComponentNode, YinYangInternalModel, YinYangOddNode } from "../interfaces/IYinYangInternalModel";
 import { Cause } from "../interfaces/ICauseModel";
 export declare function mapCauseToInternalModel(cause: Cause): YinYangInternalModel;
+/**
+ * Builds the internal model of a facette satellite (Idle « facettes »
+ * sub-state): the whole facette — every ODD and cutting — as the single
+ * component of its own model. The satellite thus derives its yin/yang from
+ * facetTensionFromOdds exactly as the main circle does for that facette.
+ */
+export declare function buildChildFacetteInternalModel(component: YinYangComponentNode): YinYangInternalModel;
 /**
  * Builds a single-component, single-odd, single-cutting internal model for a
  * satellite child, preserving the parent odd's orientation/labels so the

package/dist/types/animations/AnimationsMngr.d.ts

@@ -1,8 +1,22 @@
 import { IYinYangController } from "../interfaces/IYinYangController";
+/**
+ * Rotation Yin/Yang du composant central et de ses satellites, composée par
+ * le navigateur : chaque mouvement (rampe, croisière, freinage) est décrit
+ * analytiquement (rotationMotion.ts) et joué par des Web Animations sur
+ * `transform`. Le contenu des lobes (arcs masqués, dégradés, images) n'est
+ * alors plus redessiné à chaque image : seule leur position change, sur le
+ * GPU, et le thread principal n'a plus rien à faire à chaque image. Les
+ * animations ne sont refaites que sur signal (ViewInitializer.
+ * onRotationTargetsChanged : géométrie des lobes, libellés redessinés), et
+ * la fin d'un freinage est programmée par une minuterie.
+ */
 export declare class AnimationsMngr {
     private subscriberMap;
     subscribe(component: IYinYangController, clockWise?: boolean, time?: number): void;
     startAll(): void;
+    /** Change la durée d'un tour. Une rotation en cours (hors freinage) y
+     *  converge au rythme de sa rampe — progressivement plutôt que d'un coup
+     *  si `rampMs > 0`. */
     setRotationDuration(durationMs: number): void;
     revertRotation(component: IYinYangController): void;
     /**
@@ -15,13 +29,13 @@ export declare class AnimationsMngr {
      */
     stopRotation(component: IYinYangController, rampMs?: number): void;
     /**
-     * Désabonne un composant en fin de vie : coupe sa boucle rAF et libère son
-     * verrou d'animation, SANS toucher au DOM. À utiliser (et non stopRotation)
-     * quand les éléments vont être détruits : finalizeStop remettrait les
-     * transforms des lobes yin/yang à la position de base (resetRotationFrame)
-     * or ces groupes vivent dans globalGroup, pas dans le yinYangGroup que
-     * clearChildren retire — le reset ressusciterait donc à l'écran des
-     * satellites pourtant retirés.
+     * Désabonne un composant en fin de vie : annule ses animations et libère
+     * son verrou d'animation, SANS écrire dans le DOM. À utiliser (et non
+     * stopRotation) quand les éléments vont être détruits : finalizeStop
+     * remettrait les transforms des lobes yin/yang à la position de base
+     * (resetRotationFrame) or ces groupes vivent dans globalGroup, pas dans le
+     * yinYangGroup que clearChildren retire — le reset ressusciterait donc à
+     * l'écran des satellites pourtant retirés.
      */
     unsubscribe(component: IYinYangController): void;
     /**
@@ -54,18 +68,58 @@ export declare class AnimationsMngr {
      * choisie par l'utilisateur — voir `computeFastStopProfile`.
      */
     private beginFastHomingStop;
+    private beginBrake;
     private finalizeStop;
+    /** Fin de rotation sans toucher au DOM : animations annulées, veilles
+     *  débranchées, verrou d'animation rendu. */
+    private release;
     private resetRotationFrame;
     /**
      * Démarre (ou modifie en vol) la rotation. Avec `rampMs > 0`, la vitesse
-     * angulaire part de sa valeur courante (0 si à l'arrêt) et chasse
-     * progressivement la vitesse cible déduite de `time`/`clockWise` — un appel
-     * pendant qu'un arrêt progressif est en cours ré-accélère en douceur depuis
-     * la vitesse déjà atteinte, sans à-coup. `rampMs` omis (0) → vitesse cible
-     * appliquée instantanément, comportement historique.
+     * angulaire part de sa valeur courante (0 si à l'arrêt) et rejoint la
+     * vitesse cible déduite de `time`/`clockWise` à accélération constante — un
+     * appel pendant qu'un arrêt progressif est en cours ré-accélère en douceur
+     * depuis la vitesse déjà atteinte, sans à-coup. `rampMs` omis (0) → vitesse
+     * cible appliquée instantanément, comportement historique.
      */
     animate(component: IYinYangController, clockWise: boolean, time?: number, rampMs?: number): void;
-    private startRotationLoop;
-    private applyRotationFrame;
-    private applyRotationToYinYangGroup;
+    /** Mouvement vers la vitesse cible depuis l'état courant (angle et
+     *  vitesse à cet instant, qu'il y ait rotation, freinage ou arrêt). */
+    private startMotion;
+    private play;
+    /** Géométrie des lobes changée, ghost rempli ou libellés redessinés
+     *  pendant la rotation : seules les pistes concernées sont refaites. */
+    private resync;
+    /**
+     * Cœur et lobes (base et ghost). Le cœur tourne de θ autour du centre du
+     * symbole ; chaque lobe orbite de θ autour de ce même centre puis tourne
+     * de ∓2θ sur lui-même — même cinématique que le film (api-film.ts). Les
+     * lobes ne sont pas dans le yinYangGroup : chacun porte l'orbite et sa
+     * rotation propre dans une seule liste de transformations, interpolée
+     * fonction par fonction (angles linéaires en θ).
+     */
+    private syncLobes;
+    /** Libellés contre-tournés : orientation opposée à celle de leur lobe. */
+    private syncLabels;
+    /**
+     * (Re)pose les animations des cibles dont la piste est absente ou
+     * périmée ; oublie celles des nœuds sortis du document. Une cible qui ne
+     * peint rien (ghost vide, libellé masqué) n'est pas animée : le navigateur
+     * refuse de composer une animation sans effet visible et la joue alors
+     * sur le thread principal, qui repeindrait tout à chaque image.
+     */
+    private syncTargets;
+    private dropTrack;
+    /**
+     * Une animation par tronçon, calée sur `document.timeline` : les tronçons
+     * s'enchaînent d'eux-mêmes, sans attendre le JS. Un tronçon fini garde sa
+     * pose finale (fill forwards) sous le suivant, créé après lui donc
+     * prioritaire dès qu'il démarre : pas d'image vide à la jonction. La
+     * croisière boucle sur un tour (θ → θ ± 360°), pose identique aux bornes
+     * pour chaque cible (multiples entiers de θ).
+     */
+    private animateTarget;
+    private cancelTracks;
+    /** Horloge des animations (temps de l'image courante). */
+    private now;
 }

package/dist/types/animations/FrameScheduler.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Horloge d'animation commune : UNE seule requestAnimationFrame native par
+ * frame, quel que soit le nombre de boucles actives (rotation, orbite,
+ * transition de facette, ghost, champ de force, étincelles…).
+ *
+ * L'API reprend celle de requestAnimationFrame / cancelAnimationFrame pour
+ * que les boucles existantes migrent sans changer de forme : un rappel
+ * demandé pendant une frame s'exécute à la frame suivante, avec l'horodatage
+ * de la frame ; il ne tourne qu'une fois, la boucle se ré-abonne si elle veut
+ * continuer. Quand plus aucun rappel n'est en attente, plus aucune rAF native
+ * n'est demandée : l'arrêt est automatique.
+ *
+ * En plus de rAF :
+ * - phases : tous les rappels `read` (mesures DOM : getBBox,
+ *   getBoundingClientRect…) passent avant tous les rappels `write` de la même
+ *   frame, ce qui évite d'alterner lecture et écriture (layout forcé) ;
+ * - `fps` : cadence maximale d'un effet décoratif. Le rappel est simplement
+ *   reporté aux frames suivantes tant que l'intervalle n'est pas écoulé ; la
+ *   boucle étant pilotée par l'horodatage, l'animation garde sa vitesse, elle
+ *   est seulement échantillonnée moins souvent ;
+ * - `pauseWhenHidden` : rappel suspendu tant que le diagramme est hors écran
+ *   (voir observeVisibility). L'onglet caché, lui, est déjà géré par le
+ *   navigateur, qui n'appelle plus rAF ;
+ * - activité (`isActive`, `onActivityChange`) : vrai tant qu'une boucle tourne
+ *   à chaque frame depuis un moment, c.-à-d. que le diagramme est de toute
+ *   façon repeint sur le thread principal. Un effet peut alors préférer
+ *   s'y joindre plutôt que d'ajouter des calques composés (voir
+ *   borderColorCycle). Les rappels `passive` n'en comptent pas.
+ */
+export type FramePhase = "read" | "write";
+export interface FrameRequestOptions {
+    /** Défaut "write". */
+    phase?: FramePhase;
+    /** Cadence maximale (images/s) — pour les effets décoratifs. */
+    fps?: number;
+    /** Suspendu tant que le diagramme est hors écran. */
+    pauseWhenHidden?: boolean;
+    /** Ne compte pas comme activité (voir isActive) : un effet qui ne tourne
+     *  que parce que le diagramme est actif ne doit pas l'entretenir. */
+    passive?: boolean;
+}
+/** Ce que les appelants utilisent de d3.Timer. */
+export interface FrameTimer {
+    stop(): void;
+}
+export declare class FrameScheduler {
+    private nextId;
+    private queue;
+    /** Frame en cours d'exécution : un cancel() doit aussi pouvoir y retirer
+     *  un rappel pas encore exécuté, comme cancelAnimationFrame. */
+    private running;
+    private nativeFrameId;
+    /** Dernière exécution de chaque boucle bridée, indexée par son rappel :
+     *  une boucle se ré-abonne avec la même fonction à chaque frame. */
+    private lastRunByCallback;
+    private observer;
+    private visibility;
+    private active;
+    /** Début de la suite de frames actives en cours, null hors d'une suite. */
+    private activeStreakStart;
+    private lastActiveAt;
+    private activityListeners;
+    request(callback: FrameRequestCallback, options?: FrameRequestOptions): number;
+    cancel(id: number | null | undefined): void;
+    /** Équivalent de d3.timer : `callback(elapsedMs)` à chaque frame jusqu'à
+     *  stop(). */
+    timer(callback: (elapsedMs: number) => void, options?: FrameRequestOptions): FrameTimer;
+    /**
+     * Déclare un élément racine du diagramme : tant qu'aucun des éléments
+     * déclarés n'est à l'écran, les rappels `pauseWhenHidden` sont suspendus.
+     */
+    observeVisibility(element: Element): void;
+    /** Inverse d'observeVisibility : le diagramme est démonté. */
+    unobserveVisibility(element: Element): void;
+    isDiagramVisible(): boolean;
+    /** Vrai quand une boucle non passive tourne depuis ACTIVITY_ENTER_MS : le
+     *  diagramme est alors repeint à chaque frame sur le thread principal. */
+    get isActive(): boolean;
+    /** Prévient à chaque bascule actif/repos ; renvoie le désabonnement. Le
+     *  retour au repos n'est constaté que par une frame : un écouteur qui veut
+     *  le voir garde une boucle `passive` tant qu'il est actif. */
+    onActivityChange(listener: (active: boolean) => void): () => void;
+    /** Nombre de rappels en attente (diagnostic, tests). */
+    get pendingCount(): number;
+    /** Tests : oublie tout, y compris la rAF native en attente (les tests
+     *  remplacent requestAnimationFrame entre deux cas). */
+    reset(): void;
+    private ensureNativeFrame;
+    private hasRunnableEntry;
+    private flush;
+    private trackActivity;
+}
+export declare const frameScheduler: FrameScheduler;
+/** Effets permanents sans valeur hors écran (étincelle du pourtour,
+ *  surbrillance d'ODD) : suspendus quand le diagramme n'est pas visible. */
+export declare const AMBIENT_FRAME: FrameRequestOptions;
+/** Effets décoratifs en boucle (vagues et pulsation du ghost) : bridés à
+ *  animationConfig.decorativeFps et suspendus hors écran. */
+export declare const DECORATIVE_FRAME: FrameRequestOptions;

package/dist/types/animations/rotationMotion.d.ts

@@ -0,0 +1,43 @@
+import { FastStopProfile } from "./fastHomingStop";
+/**
+ * Mouvement angulaire décrit analytiquement, tronçon par tronçon, pour être
+ * joué par le navigateur (Web Animations) plutôt qu'écrit image par image :
+ * chaque tronçon est à accélération constante, donc sa position est un
+ * polynôme du second degré en temps, qu'une courbe `cubic-bezier` reproduit
+ * exactement (voir `segmentEasing`).
+ *
+ * Les temps sont ceux de `document.timeline` (ms), les angles en degrés, les
+ * vitesses en °/ms et les accélérations en °/ms², tous signés (+ = horaire).
+ * Les calculs ne dépendent pas de l'unité d'angle : l'orbite des satellites
+ * (ChildrenOrbitManager) les fait en radians.
+ */
+export interface MotionSegment {
+    startTime: number;
+    /** Infinity = croisière à vitesse constante, sans fin. */
+    duration: number;
+    angle0: number;
+    omega0: number;
+    accel: number;
+}
+export declare function angleAfter(segment: MotionSegment, elapsedMs: number): number;
+export declare function motionEndTime(segments: MotionSegment[]): number;
+/** Angle et vitesse du mouvement à l'instant `time` (0 sans mouvement). */
+export declare function evaluateMotion(segments: MotionSegment[], time: number): {
+    angle: number;
+    omega: number;
+};
+/**
+ * Démarrage ou changement de vitesse : rampe à accélération constante
+ * (`accelMag`, °/ms²) de `omega` vers `targetOmega`, puis croisière.
+ * `accelMag` ≤ 0 → vitesse cible appliquée d'emblée.
+ */
+export declare function rampSegments(startTime: number, angle: number, omega: number, targetOmega: number, accelMag: number): MotionSegment[];
+/** Freinage vers la position de base selon un profil de `fastHomingStop`. */
+export declare function brakeSegments(startTime: number, angle: number, direction: number, profile: FastStopProfile): MotionSegment[];
+/**
+ * Courbe d'accélération d'un tronçon fini. Avec x1 = 1/3 et x2 = 2/3, le
+ * temps est linéaire dans le paramètre de la courbe ; la progression est
+ * alors le polynôme cubique de mêmes pentes aux bornes que la position, qui
+ * est du second degré : c'est donc elle, exactement.
+ */
+export declare function segmentEasing(segment: MotionSegment): string;

package/dist/types/api.d.ts

@@ -4,9 +4,12 @@ import type { YinYangInternalModel } from "./interfaces/IYinYangInternalModel";
 import type { Cause } from "./interfaces/ICauseModel";
 export type { IViewData } from "./interfaces/IViewData";
 export type { IYinYangController } from "./interfaces/IYinYangController";
-export type { Cause, CauseComponent, CauseOdd, CauseOddCutting, } from "./interfaces/ICauseModel";
+export type { Cause, CauseComponent, CauseOdd, CauseOddCutting, FacetNotion, } from "./interfaces/ICauseModel";
 export type { YinYangInternalModel, YinYangComponentNode, YinYangOddNode, YinYangCuttingNode, YinYangCategorySlice, YinYangOrientation, } from "./interfaces/IYinYangInternalModel";
 export { mapCauseToInternalModel } from "./adapters/yinYangAdapter";
+/** Sous-état Idle du diagramme (aucune facette ouverte) — voir
+ *  `YinYangMountConfig.idleView`. */
+export type YinYangIdleView = "arcs" | "facettes" | "tab";
 /** Données acceptées : soit une `Cause` (format métier), soit le modèle interne déjà adapté. */
 export type YinYangData = Cause | YinYangInternalModel;
 export interface YinYangSvgConfig {
@@ -29,10 +32,22 @@ export interface YinYangMountConfig {
     /** Mode PRÉSENTATION : le diagramme se lit, il ne se manœuvre pas — voir
      *  `IViewData.presentation`. Défaut : false (l'atelier complet). */
     presentation?: boolean;
+    /** Sous-état Idle affiché au montage : `"arcs"` (arcs pondérés des
+     *  facettes autour de l'illustration) ou `"facettes"` (un satellite
+     *  yin/yang par facette, à l'angle de son arc) ou `"tab"` (ces mêmes
+     *  satellites rangés dans une grille régulière autour d'une illustration
+     *  réduite — les facettes d'une même notion parente, `CauseComponent.notion`,
+     *  y sont regroupées). L'utilisateur passe ensuite d'un sous-état au
+     *  suivant en cliquant l'illustration centrale. Défaut : `"arcs"`. */
+    idleView?: YinYangIdleView;
 }
 export interface YinYangMountHandle {
     controller: IYinYangController;
-    /** Vide le conteneur. */
+    /** Bascule (animée) du sous-état Idle — voir `YinYangMountConfig.idleView`.
+     *  Facette ouverte : le choix s'applique à sa fermeture. */
+    setIdleView(view: YinYangIdleView): Promise<void>;
+    /** Arrête toutes les boucles d'animation du diagramme (champ de force,
+     *  orbite, rotation, ghost, étincelles…) puis vide le conteneur. */
     destroy(): void;
 }
 /**

package/dist/types/benchmark/runner.d.ts

@@ -1,5 +1,25 @@
 declare global {
     var runBenchmark: () => Promise<void>;
     var runBenchmarkAvg: (n: number) => Promise<void>;
+    var runBenchmarkReport: (only?: string[]) => Promise<BenchmarkReport>;
+}
+import { type DomCounts } from "./scenarios";
+interface ScenarioResult {
+    name: string;
+    description: string;
+    duration: number;
+    setupMs?: number;
+    avgFrameMs: number;
+    p95FrameMs: number;
+    longTasksCount: number;
+    domCounts?: DomCounts;
+}
+interface BenchmarkReport {
+    commit: string;
+    timestamp: string;
+    runsCount?: number;
+    longTaskObserverOk?: boolean;
+    scenarios: ScenarioResult[];
+    analysis?: Record<string, unknown>;
 }
 export {};

package/dist/types/benchmark/scenarios.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Compteurs DOM d'un scénario (détection de fuites : nœuds SVG, `<animate>` SMIL,
+ * enfants de `<defs>`). Relevés par le scénario juste avant de retirer son
+ * conteneur, puis lus une seule fois par le runner via takeDomCounts().
+ */
+export interface DomCounts {
+    svgNodes: number;
+    animateNodes: number;
+    defsChildren: number;
+}
+export declare function takeDomCounts(): DomCounts | undefined;
 /**
  * Scenario 1 — Large dataset initialization.
  *
@@ -35,10 +46,9 @@ export declare function runComponentSwitchScenario(hooks?: ComponentSwitchHooks)
 /**
  * Scenario 3 — Rotation animation.
  *
- * Starts the continuous rotation animation (AnimationsMngr RAF loop) on a
- * full Yasuni instance including orbit children, and lets it run for
- * TRANSITION_DURATION_MS. Measures per-frame cost: Yin/Yang orbital math,
- * SVG transform updates for parent + all children.
+ * Starts the continuous rotation animation (AnimationsMngr, Web Animations
+ * composed by the browser) on a full Yasuni instance including orbit
+ * children, and lets it run for TRANSITION_DURATION_MS.
  *
  * Performance measure name: "bm-transition"
  */
@@ -50,8 +60,8 @@ export interface BaselineHooks {
 /**
  * Scenario — Baseline (pivot).
  *
- * Controller + satellites en état idle : aucune action activée, aucune rotation,
- * aucun champ de force. Seuls les RAF loops systèmes tournent en arrière-plan
+ * Facette 0 ouverte (donc satellites présents), sans action, rotation ni champ de force :
+ * seuls les RAF loops systèmes tournent en arrière-plan
  * (ghost pulse, outer spark, cycle couleurs de bordure).
  *
  * Sert de référence directe pour quantifier le surcoût de chaque autre scénario :
@@ -116,3 +126,42 @@ export declare function runForceFieldDirectScenario(hooks?: ForceFieldHooks): Pr
  * Performance measure names: "bm-forcefield-merged-setup", "bm-forcefield-merged"
  */
 export declare function runForceFieldMergedScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 8 — ghostProjection : action projetée en mode Pile, 3 s.
+ *
+ * Mode Pile forcé + activation d'une action (ODD_15 / cut0) : le ghost (badge
+ * de deltas, vagues, arc / bordure / spikes ghost) tourne en boucle sans fin.
+ * Mesure le régime établi pendant 3 s, une fois la projection affichée.
+ *
+ * Performance measure names: "bm-ghost-setup", "bm-ghost"
+ */
+export declare function runGhostProjectionScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 9 — orbit : orbite des satellites SANS action active (3 s).
+ *
+ * setChildrenOrbitEnabled(true) : chaque frame, ChildrenOrbitManager.applyTransforms
+ * déclenche renderOppositeChildrenForceField (labels de contexte, panneau de
+ * détails…). Cible : la cascade applicative à 60 fps hors champ de force.
+ *
+ * Performance measure name: "bm-orbit"
+ */
+export declare function runOrbitScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 10 — orbitAction : orbite des satellites AVEC une action active (3 s).
+ *
+ * Même chose qu'orbit, mais après searchNavigateToAction : le champ de force
+ * est alors dessiné par l'orbite ET par sa propre boucle.
+ *
+ * Performance measure names: "bm-orbit-action-setup", "bm-orbit-action"
+ */
+export declare function runOrbitActionScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 11 — idleTabMorph : Idle « facettes » → « tab » → « facettes ».
+ *
+ * La fenêtre de mesure couvre les deux morphs et un maintien de 1 s sur la
+ * grille « tab » (transform sur le globalGroup racine à chaque tick, fondus
+ * d'images clip-pathées).
+ *
+ * Performance measure name: "bm-idle-tab"
+ */
+export declare function runIdleTabMorphScenario(hooks?: ForceFieldHooks): Promise<void>;

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

@@ -5,6 +5,8 @@ import { IYinYangAppFactory } from "../../interfaces/IYinYangAppFactory";
 import { IAnimator } from "../../interfaces/IAnimator";
 import { YinYangInternalModel } from "../../interfaces/IYinYangInternalModel";
 import { ForceFieldLinkDetail } from "./force-field/types";
+import { type IdleTabHooks } from "./children/IdleFacettesController";
+import type { IdleView } from "./state/YinYangControllerState";
 import type { DiagramNavEvent } from "./types";
 export declare class YinYangController implements IYinYangController {
     model: IYinYangModel;
@@ -12,6 +14,9 @@ export declare class YinYangController implements IYinYangController {
     factory: IYinYangAppFactory;
     animator: IAnimator;
     private childControllers;
+    /** Vrai pendant la création des satellites (ChildrenBuilder) : les rendus
+     *  intermédiaires du champ de force y sont ignorés, un seul suit. */
+    private forceFieldRenderSuppressed;
     /** État de la rotation spin (voir startRotation/stopRotationAll) — non nul
      *  tant que la rotation est active, pour que les enfants recréés en cours
      *  de route (createYinYangChildren) démarrent immédiatement avec les mêmes
@@ -22,7 +27,7 @@ export declare class YinYangController implements IYinYangController {
     private readonly ACTION_DRAG_THRESHOLD_PX;
     private actionStackController;
     private childActionMenuController;
-    private coreEventMenuController;
+    private keyEventMenuController;
     private forceFieldDetailsPanel;
     private forceFieldRenderer;
     /** Champ d'événement — liens cœur → satellites amplifiés par l'Événement
@@ -41,6 +46,8 @@ export declare class YinYangController implements IYinYangController {
     private actionStackManager;
     private state;
     private childrenBuilder;
+    private idleFacettes;
+    private onIdleViewChange;
     private componentSwitch;
     private incomingForceField;
     private detailsPresenter;
@@ -56,6 +63,35 @@ export declare class YinYangController implements IYinYangController {
      * Constructor to initialize the controller with its model, view, and factory.
      */
     constructor(model: IYinYangModel, view: IYinYangView, factory: IYinYangAppFactory);
+    /** Sous-état d'Idle affiché quand aucune Facette n'est ouverte : arcs
+     *  pondérés (« arcs ») ou un satellite yin/yang par facette (« facettes »). */
+    getIdleView(): IdleView;
+    /** Crochets de l'hôte autour du sous-état Idle « tab » : `beforeEnter`
+     *  (attendu avant le calcul de la grille — ex. replier des panneaux pour
+     *  agrandir le conteneur du diagramme) et `afterLeave` (satellites revenus
+     *  à leur place radiale — ex. rétablir ces panneaux). */
+    setIdleTabHooks(hooks: IdleTabHooks | null): void;
+    /** Rappel de l'hôte à chaque changement de sous-état Idle (ex. refléter
+     *  l'état d'un bouton « Arcs »). */
+    setOnIdleViewChange(callback: ((view: IdleView) => void) | null): void;
+    /** Bascule vers un sous-état d'Idle. Hors Idle (Facette ouverte), le choix
+     *  est seulement mémorisé : il s'appliquera à la fermeture de la Facette. */
+    setIdleView(view: IdleView): Promise<void>;
+    private isEventFieldInIdleFacettes;
+    /** Amène le diagramme en Idle « facettes » — en refermant la Facette
+     *  ouverte s'il le faut. Résolu une fois les satellites-facettes sortis. */
+    private showIdleFacettes;
+    /** Clic sur le cœur du lobe dominant en Facette : referme la Facette et
+     *  revient à la cause en Idle « facettes », quel que soit le sous-état
+     *  Idle mémorisé. */
+    onFacetteCoreClicked(): void;
+    /** Clic sur l'illustration centrale : facettes ↔ tab (sans effet hors Idle
+     *  et en « arcs »). */
+    toggleIdleView(): Promise<void>;
+    /** Vrai quand le sous-état Idle « facettes » est visé (arcs repliés). */
+    isIdleFacettesActive(): boolean;
+    /** Réaligne le sous-état Idle après une entrée/sortie d'Idle. */
+    syncIdleView(): void;
     /**
      * Retrieves the number of borders for the YinYang view.
      */
@@ -211,6 +247,8 @@ export declare class YinYangController implements IYinYangController {
     private setActiveChild;
     private clearActiveChild;
     private animateChildren;
+    private destroyed;
+    destroy(): void;
     private clearChildren;
     setChildrenOrbitEnabled(isEnabled: boolean, rampMs?: number): void;
     /** Arrête l'orbite des satellites en rejoignant leur position de base dans
@@ -307,10 +345,37 @@ export declare class YinYangController implements IYinYangController {
      * Fermeture du menu radial d'un satellite et de l'action qu'il projetait
      * (champ de force, ghosts, bloc d'action du panneau) — chemin unique partagé
      * par la hiérarchie (deactivateChildMenuFromHierarchy) et par l'exclusivité
-     * action/événement (toggleCoreEventMenu, previewKeyEvent). No-op si aucun
+     * action/événement (toggleKeyEventMenu, previewKeyEvent). No-op si aucun
      * satellite n'est actif.
      */
     private closeChildActionMenu;
+    /**
+     * Sélection courante du diagramme — satellite, sinon ODD mis en valeur,
+     * sinon facette ; null en vue Sphère (aucune facette ouverte). Sert à
+     * mémoriser la sélection propre à un mode au moment de le quitter (voir
+     * PanelManager.rememberStackSelection).
+     */
+    getDiagramSelection(): {
+        type: "composante";
+        componentIndex: number;
+    } | {
+        type: "odd";
+        componentIndex: number;
+        oddId: string;
+    } | {
+        type: "cutting";
+        componentIndex: number;
+        oddId: string;
+        cuttingIndex: number;
+    } | null;
+    /**
+     * Remet le diagramme à blanc sous la facette courante — satellite
+     * désélectionné (menu et action projetée compris), ODD éteint — avant d'y
+     * rejouer la sélection mémorisée d'un mode. La facette elle-même reste
+     * ouverte (vue ODD quittée) : c'est la sélection rejouée qui décide de la
+     * garder, d'en changer ou de la fermer.
+     */
+    clearDiagramSelection(): void;
     deactivateComposanteFromHierarchy(): void;
     /**
      * Fermeture de la facette courante — chemin unique partagé par l'arc de
@@ -335,7 +400,7 @@ export declare class YinYangController implements IYinYangController {
      */
     syncForceFieldToStackMode(): void;
     /**
-     * Recalcule le Champ d'événement pour le mode courant — à appeler APRÈS que
+     * Recalcule les bulles et le Champ d'événement pour le mode courant — APRÈS que
      * l'onglet a réellement basculé (les gardes RECHERCHE/STACK, elles, tournent
      * en phase de capture, avant le toggle de `ff-tab-active`, et liraient donc
      * encore l'ancien mode via isStackModeActive).
@@ -364,18 +429,20 @@ export declare class YinYangController implements IYinYangController {
     /** Centre automatiquement (scroll animé) le bloc "Effets cumulés" correspondant
      *  à cet item de pile, dès qu'il apparaît dans le panneau — voir
      *  ForceFieldDetailsPanel.requestScrollToStackItemBlock. */
+    private _guidedEventPreviewItem;
     /**
      * Glisser guidé d'un prérequis depuis RECHERCHE : la bascule vers STACK
      * faite par le glisser (switchToTab direct, sans le clic d'onglet qui
      * appelle syncForceFieldToStackMode) laissait le panneau sur le satellite
      * de l'action glissée — encore absente de la pile, donc sans aucun bloc.
      * On resynchronise les champs de la pile comme un vrai passage en STACK,
-     * puis on affiche les blocs du satellite de l'action portant le combo,
+     * puis on affiche les blocs du satellite de l'action portant le combo
+     * ou l'aperçu de l'action ciblée par l'événement,
      * sans déplacer la sélection du diagramme (le dépôt s'en charge).
      */
     private showStackItemBlocksForDrag;
     /**
-     * Sélectionne le satellite porteur d'un item de pile (diagramme + panneau)
+     * Sélectionne le satellite porteur ou la Facette d'origine d'un item de pile (diagramme + panneau)
      * et centre son bloc — même effet qu'un clic sur le libellé de l'item
      * (voir setOnSelectStackItemSatellite dans DiagramPanelBridge).
      */
@@ -399,7 +466,8 @@ export declare class YinYangController implements IYinYangController {
     setOnDirectActionBlock(show: (compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void, clear: () => void): void;
     /** Wire from main.ts — injecte la carte descriptive d'un Événement Clé dans l'onglet Recherche. */
     setOnShowKeyEventBlock(show: (compId: string, keyEventId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void, clear: () => void): void;
-    /** Enregistre le miroir "menu cœur déployé ?" vers la hiérarchie RECHERCHE. */
+    /** Enregistre le miroir "bulles d'Événements Clés déployées sur quel
+     *  satellite-facette ?" vers la hiérarchie RECHERCHE. */
     setOnKeyEventMenuStateChange(cb: (componentIndex: number, open: boolean) => void): void;
     /** Wire from main.ts — affiche le bloc d'action directe d'un prérequis dans le panneau B. */
     setOnDirectActionBlockPanelB(show: (compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void): void;
@@ -425,6 +493,19 @@ export declare class YinYangController implements IYinYangController {
     setOnDiagramOddChange(cb: (componentIndex: number, oddId: string, mode: "highlight") => void): void;
     /** Wire from main.ts to sync the search panel on composante / cutting / action clicks. */
     setOnDiagramNavChange(cb: (event: DiagramNavEvent) => void): void;
+    /** Consulter un autre satellite garde l'action active (et son champ de
+     *  force) : toujours en STACK, en RECHERCHE seulement avec un panneau
+     *  verrouillé — voir openActionMenuFromChild. */
+    private keepsActiveActionOnSatelliteSwitch;
+    setIsAnyRecherchePanelLocked(cb: () => boolean): void;
+    /** Multi-blocs : un panneau RECHERCHE verrouillé sur une action la fige
+     *  comme action source — les boutons d'action s'estompent et un clic
+     *  dessus est refusé (voir onActionSelectionBlocked). */
+    setActionSelectionLock(isLocked: () => boolean, onBlocked: (retry: () => void) => void): void;
+    private isActionSelectionLocked;
+    /** Redessine le menu d'actions du satellite sélectionné — après un
+     *  (dé)verrouillage de panneau, qui change l'estompage des boutons. */
+    refreshChildActionMenu(): void;
     setOnDiagramSatelliteDeselect(cb: (componentIndex: number) => void): void;
     setOnDiagramComposanteDeselect(cb: () => void): void;
     setOnDiagramChildHover(cb: (componentIndex: number | null, oddId: string | null, cuttingIndex?: number) => void): void;
@@ -466,9 +547,9 @@ export declare class YinYangController implements IYinYangController {
     setChildActionMenuItemDistance(distance: number): void;
     setChildActionMenuItemScale(scale: number): void;
     setChildActionIconFontScale(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;
     setLabelShortMaxChars(chars: number): void;
     setOddLabelMaxLines(lines: number): void;
@@ -487,13 +568,22 @@ export declare class YinYangController implements IYinYangController {
     private clearProjectedActionState;
     private applyEmptyGhostProjectionState;
     private updateChildActionMenu;
-    /** Clic sur le libellé de l'item en focus dans la pile, rejoué depuis une
-     *  bulle du diagramme — null hors STACK ou sans focus. */
-    private focusedStackItemLabelClick;
+    /**
+     * STACK : une bulle par action activée de la pile dont la source est sur
+     * la facette affichée, sur son satellite source. Comme les champs de
+     * force : l'action en focus ressort, les autres s'estompent, et toutes
+     * sont pleines quand aucune n'est en focus.
+     */
+    private buildStackDetachedBubbles;
+    /**
+     * RECHERCHE multi-blocs (panneau verrouillé) : l'action active garde ses
+     * champs de force pendant qu'on consulte un autre satellite — sa bulle
+     * reste donc visible sur la source, que le menu radial ne montre plus.
+     */
+    private buildRechercheDetachedBubbles;
     /** 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;
-    onCoreEventNucleusClicked(): void;
     searchNavigateToKeyEvent(keyEventId: string): void;
     restoreKeyEventDiagramState(keyEventId: string): void;
     searchSetKeyEventMenuOpen(componentIndex: number, open: boolean): void;
@@ -554,7 +644,7 @@ export declare class YinYangController implements IYinYangController {
     /**
      * Mode adverse (outil de debug, voir adverseMode.ts) : les actions et
      * Événements adverses remplacent les ordinaires sur le diagramme (bulles
-     * des satellites, menu cœur) et dans l'arbre RECHERCHE — qui se
+     * des satellites et des satellites-facettes) et dans l'arbre RECHERCHE — qui se
      * reconstruit seul à la bascule. La pile n'est jamais filtrée.
      *
      * Hors STACK, l'action ou l'Événement en aperçu de l'autre bord perdrait