@micheeeeel/yinyangapp 3.0.1 → 3.1.1

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

@@ -9,6 +9,8 @@ import { StackFocusController } from "../action-stack/StackFocusController";
 import { ComponentTitlePresenter } from "../labels/ComponentTitlePresenter";
 import type { ControllerUiCallbacks } from "../state/ControllerUiCallbacks";
 import { ChildrenOrbitManager } from "../odd/ChildrenOrbitManager";
+/** Écart (px, repère du motif) entre deux satellites voisins d'un anneau. */
+export declare const SATELLITE_RING_GAP_PX = 6;
 export type ChildrenBuilderDeps = {
     animateChildren: (show: boolean) => Promise<void>;
     applyChildrenOrbitTransforms: (angleOffset: number, orbitData?: ChildrenOrbitEntry[]) => void;
@@ -29,6 +31,8 @@ export type ChildrenBuilderDeps = {
     getCurrentComponentOrUndefined: () => YinYangInternalModel["components"][number] | undefined;
     getKey: () => string;
     renderOppositeChildrenForceField: (orbitData?: ChildrenOrbitEntry[], angleOffset?: number) => void;
+    /** Exécute `run` sans rendu du champ de force (les appels sont ignorés). */
+    suppressForceFieldRender: (run: () => void) => void;
     getRotationState: () => {
         clockWise: boolean;
         durationMs: number;
@@ -56,28 +60,21 @@ export declare class ChildrenBuilder {
      *  baseline radius, independent of any satellite's own weight-scaled
      *  radius — mirrors ChildActionMenuController's action cluster geometry. */
     private getChildActionClusterReach;
-    /** Décalage constant appliqué au poids ET à sa moyenne avant de calculer le
-     *  ratio de taille d'un satellite (voir weightToSizeRatio) : resserre la
-     *  fourchette de tailles (poids min moins minuscule, poids max un peu
-     *  moins dominant) sans changer la taille d'un satellite au poids moyen
-     *  exact (ratio toujours 1 dans ce cas), et sans dépendre du poids moyen
-     *  de la fratrie pour l'ampleur du resserrement. */
-    private static readonly WEIGHT_SIZE_FLOOR_OFFSET;
-    /** Ratio de taille d'un satellite (rayon relatif à la baseline uniforme de
-     *  sa facette) à partir de son poids et du poids moyen de sa fratrie —
-     *  voir WEIGHT_SIZE_FLOOR_OFFSET pour le resserrement. */
-    private static weightToSizeRatio;
-    /** Ratio of a component's heaviest satellite radius to its own uniform
-     *  baseline radius. Mirrors the per-cutting weight-based scaling applied
-     *  in createYinYangChildren(). */
-    private getMaxWeightRatio;
-    /** The container-fit shrink ratio only depends on borderOuterRadius/
-     *  smallCircleRadius/distanceFromChild, which are fixed for the whole
-     *  session once this top-level view is first initialized (they don't get
-     *  recomputed on facette switch) — so this is computed once (on the worst
-     *  case weight ratio across every facette) and cached. That's what keeps
-     *  the whole diagram's size from visibly changing every time the user
-     *  switches facette. */
+    /** Ratio de taille d'un satellite (rayon relatif à la taille de base,
+     *  ViewInitializer.smallCircleRadius) : sur son poids ABSOLU, le même pour
+     *  la cause et pour la sphère d'un personnage — un satellite de poids 7 a
+     *  la même taille dans tous les diagrammes, quels que soient ses voisins.
+     *  `(poids + 1) / (référence + 1)` : 1 au poids de référence (5), 1/6 au
+     *  poids nul (un satellite vide reste visible), 11/6 au poids maximal. */
+    static weightToSizeRatio(weight: number): number;
+    /** Ratio de taille du satellite le plus lourd possible (poids maximal). */
+    static readonly MAX_SIZE_RATIO: number;
+    /** Réduction d'ensemble qui fait tenir l'anneau de satellites dans le
+     *  conteneur. Elle ne dépend que de la géométrie du motif (rayon, taille
+     *  de base, orbite), pas des données : elle réserve la place du satellite
+     *  le plus lourd possible, si bien que le cercle central occupe la même
+     *  part du conteneur dans tous les diagrammes, et qu'aucune évolution des
+     *  poids en cours de partie ne fait déborder l'anneau. Calculée une fois. */
     private cachedGlobalFitShrinkRatio?;
     private computeGlobalFitShrinkRatio;
     applyChildrenFitScale(): void;

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

@@ -32,10 +32,12 @@ export type ComponentSwitchCoordinatorDeps = {
         cuttingIndex: number;
     }>;
     clearActiveChild: () => void;
-    clearChildren: () => void;
     createYinYangChildren: () => void;
     detailsPresenter: ForceFieldDetailsPresenter;
     disableOuterSpark: () => void;
+    /** Réaligne le sous-état Idle (arcs / facettes) : ce chemin quitte Idle
+     *  sans passer par setChildrenEnabled(). */
+    syncIdleView: () => void;
     eventFieldLifecycleController: EventFieldLifecycleController;
     eventFieldRenderer: EventFieldRenderer;
     focusChildByOddCutting: (oddId: string, cuttingIndex: number, forceOpen?: boolean) => void;

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

@@ -0,0 +1,205 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { IYinYangAppFactory } from "../../../interfaces/IYinYangAppFactory";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { IdleView, YinYangControllerState } from "../state/YinYangControllerState";
+import { FacetModulation, FacetModulationOptions } from "./facetModulation";
+/** Crochets de l'hôte autour du sous-état « tab » — voir
+ *  `IYinYangController.setIdleTabHooks`. */
+export type IdleTabHooks = {
+    /** Avant le calcul de la grille (l'hôte peut agrandir le conteneur du
+     *  diagramme) ; la grille attend sa résolution. */
+    beforeEnter?: () => Promise<void> | void;
+    /** Une fois les satellites revenus à leur place radiale. */
+    afterLeave?: () => Promise<void> | void;
+};
+export type IdleFacettesControllerDeps = {
+    view: IYinYangView;
+    state: YinYangControllerState;
+    factory: IYinYangAppFactory;
+    getKey: () => string;
+    getInternalModel: () => YinYangInternalModel;
+    setChildrenHiddenState: (children: IYinYangController[], hidden: boolean) => void;
+    animateChildren: (children: IYinYangController[], show: boolean) => Promise<void>;
+    applyChildrenFitScale: () => void;
+    /** Double-clic sur un satellite-facette : ouvre cette Facette, comme son arc. */
+    openFacette: (componentIndex: number, componentId: string) => void;
+    /** Clic sur un satellite-facette : déploie/replie ses Événements Clés. */
+    onSatelliteClick: (componentId: string) => void;
+    /** En Idle « tab » : sélectionne la facette pour le titre (sans déployer les bulles). */
+    selectKeyEventFacetteForTab: (componentId: string) => void;
+    /** Double-clic, juste avant d'ouvrir la Facette : annule l'effet de bord
+     *  du premier clic sur l'aperçu en cours. */
+    onSatelliteDoubleClick: () => void;
+    /** Satellites-facettes sortis (fin d'animation) : les bulles et le souffle
+     *  peuvent s'y accrocher. */
+    onSatellitesShown: () => void;
+    /** Satellites-facettes rentrés : leurs bulles rentrent avec eux. */
+    onSatellitesHidden: () => void;
+    onIdleViewChange?: (view: IdleView) => void;
+};
+/**
+ * Sous-états Idle « facettes » et « tab » : les arcs de bordure rentrent
+ * sous l'illustration, et chaque facette en ressort sous la forme d'un
+ * satellite montrant son propre yin/yang, dimensionné selon son poids.
+ * - « facettes » : à l'angle du milieu de son arc ;
+ * - « tab » : dans une grille régulière (voir idleTabLayout), l'illustration
+ *   réduite au centre, l'image de la facette en fond de sa case et les
+ *   facettes d'une même notion parente regroupées (IdleTabGridDrawer).
+ *
+ * Les satellites sortent toujours à leur place radiale ; « tab » les y
+ * reprend pour les faire glisser jusqu'à leur case (idleTabMorph), et
+ * inversement — la grille n'est qu'une transformation posée sur eux.
+ *
+ * Les satellites-facettes vivent à part des satellites de cutting d'une
+ * Facette (childControllers) : ni champ de force, ni menu d'action, ni
+ * orbite ne les concernent. Les transitions sont sérialisées — chaque étape
+ * relit l'état voulu au moment de s'exécuter, de sorte que des bascules
+ * rapprochées convergent vers le dernier état demandé sans se chevaucher.
+ */
+export declare class IdleFacettesController {
+    private deps;
+    private satellites;
+    private satelliteByComponentId;
+    /** Disposition des satellites-facettes actuellement sortis (null : aucun). */
+    private shownLayout;
+    /** Grille en place (sous-état « tab ») et échelle du motif à rétablir en
+     *  revenant à la disposition radiale. */
+    private tab;
+    /** Groupe enveloppe de chaque satellite-facette (porte la grille). */
+    private wrappers;
+    /** Position et facteur d'échelle posés par la grille, par satellite. */
+    private tabPlacement;
+    private readonly tabGrid;
+    private tabHooks;
+    /** Vrai une fois les satellites-facettes arrivés à leur place (fin de
+     *  l'animation de sortie) : les bulles n'ont de point d'ancrage qu'alors. */
+    private settled;
+    private queue;
+    private escapeListener;
+    /** Modulation de la signature par un contact (OBS-UI-01), voir
+     *  setModulation ; null : chaque satellite montre son propre modèle. */
+    private modulation;
+    private modulationOptions;
+    /** Géométrie radiale de l'anneau, calculée à la sortie sur les poids du
+     *  MODÈLE (O_f d'une signature) : la modulation change les tailles,
+     *  jamais les places ni l'échelle. */
+    private ring;
+    /** Par satellite : clé de son affichage, son diamètre au poids du modèle
+     *  et son diamètre réel (modulé). */
+    private displays;
+    /** Fantôme de signature de chaque satellite modulé (dans son enveloppe). */
+    private ghosts;
+    /** Détruit : les transitions encore en file n'ont plus rien à faire (sans
+     *  quoi un diagramme démonté puis remonté dans le même conteneur — double
+     *  montage d'un hôte React en développement — y recevait les satellites
+     *  du premier, sortis après coup). */
+    private destroyed;
+    constructor(deps: IdleFacettesControllerDeps);
+    setTabHooks(hooks: IdleTabHooks | null): void;
+    getView(): IdleView;
+    /** Vrai dès qu'un sous-état à satellites-facettes (« facettes » ou
+     *  « tab ») est l'état visé en Idle (arcs repliés ou en train de l'être). */
+    isActive(): boolean;
+    setView(requested: IdleView): Promise<void>;
+    /** Centre et rayon du satellite-facette d'une facette, une fois sorti. */
+    getSatelliteAnchor(componentId: string): {
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    } | null;
+    toggleView(): Promise<void>;
+    /** Aligne l'affichage sur l'état voulu (Idle + sous-état). À appeler à
+     *  chaque entrée/sortie d'Idle. */
+    sync(): Promise<void>;
+    private isIdle;
+    /** Vrai pour une Cause sans score (signature d'obstacle). */
+    private isScorelessModel;
+    /**
+     * Superpose à la signature la lecture d'un contact (OBS-UI-01) — ou la
+     * retire (`null`). Chaque satellite-facette concerné prend le diamètre de
+     * W_f et la chance Q_f, à partir de sa taille courante (animation de
+     * `durationMs`) ; un fantôme garde le diamètre du poids du modèle (O_f).
+     * Les places et l'échelle restent celles du modèle : revenir à la
+     * signature puis réappliquer le même contact redonne exactement le même
+     * dessin. Appliquée en file avec les bascules de sous-état ; hors
+     * « facettes »/« tab », elle est mémorisée pour la prochaine sortie.
+     */
+    setModulation(modulation: FacetModulation | null, options?: FacetModulationOptions): Promise<void>;
+    private applyModulation;
+    private displayOf;
+    private wantedLayout;
+    private applyDesiredState;
+    /** Arcs repliés sous l'illustration, puis satellites jaillissant du centre
+     *  jusqu'à leur place radiale. */
+    private show;
+    /** Satellites rentrant au centre, puis arcs ressortant jusqu'au bord. */
+    private hide;
+    /** Les satellites glissent de leur place radiale à leur case ; dans le même
+     *  mouvement, l'illustration rapetisse, l'anneau d'images s'efface (chaque
+     *  case porte la sienne) et la grille apparaît. */
+    private morphToTab;
+    /** Mouvement inverse : chaque satellite regagne sa place radiale. */
+    private morphToRadial;
+    private morph;
+    private patternCenter;
+    /** Place radiale d'un satellite, dans le repère du motif. */
+    private radialPlace;
+    /** Satellites à leur place : les bulles peuvent s'y accrocher. */
+    private settle;
+    /** Satellites en mouvement : leurs bulles rentrent. */
+    private unsettle;
+    /** Mise en page de la grille, dans le repère du SVG : sur toute la place
+     *  que le conteneur du diagramme offre autour de l'illustration (le SVG
+     *  déborde visiblement), au moins sur le carré du SVG. */
+    private computeTabLayout;
+    /** Plus grand rectangle centré sur l'illustration qui tienne dans le
+     *  conteneur du SVG, padding exclu, en unités du SVG (le conteneur peut
+     *  être mis à l'échelle par l'hôte : on ramène ses dimensions à celles du
+     *  SVG). */
+    private tabArea;
+    private fadeImageRing;
+    /** Ratio de taille de chaque satellite-facette : sur le poids de sa
+     *  facette (C_f), ramené à l'échelle d'un satellite [0, WEIGHT_MAX] — tel
+     *  quel en règle `mean`, divisé par le nombre de satellites en règle `sum`
+     *  — pour la même règle de taille que les satellites d'une Facette. */
+    private computeSizeRatios;
+    private createSatellites;
+    /** Angles et resserrement de l'anneau, sur les poids du modèle. */
+    private computeRing;
+    /** Crée le satellite-facette d'une composante, à sa place dans l'anneau,
+     *  selon son affichage (ordinaire, signature, modulé). */
+    private createSatellite;
+    /**
+     * Remplace un satellite-facette par celui de son nouvel affichage, SUR
+     * PLACE : même enveloppe de grille, même centre. Le nouveau part de la
+     * taille de l'ancien et gagne la sienne (O_f → W_f, ou retour) pendant
+     * que l'ancien s'efface ; sans durée, d'un coup.
+     */
+    private replaceSatellite;
+    /** Fantôme de signature d'un satellite modulé plus petit que son poids
+     *  de modèle : contour au diamètre de O_f, dans son enveloppe (il suit la
+     *  grille). Retiré sinon. */
+    private refreshGhost;
+    /** Glisse un groupe enveloppe entre le satellite et le groupe des enfants
+     *  du motif : il porte la transformation de la grille, sans interférer
+     *  avec celles que d'autres posent sur le satellite lui-même. */
+    private wrap;
+    private attachClickHandler;
+    /** Double-clic. Le sous-état « facettes » reste mémorisé : refermer la
+     *  Facette y ramène.
+     *  On replie d'abord les satellites-facettes et on redéploie les arcs (la
+     *  Facette met en valeur l'arc actif), puis on ouvre la Facette. */
+    private openFacette;
+    /** Détache les satellites-facettes courants (pour les faire rentrer puis
+     *  les détruire) et prévient que leurs bulles doivent rentrer avec eux. */
+    private takeSatellites;
+    /** Fin de vie : satellites-facettes détruits sur place (sans animation de
+     *  rentrée), grille retirée, écouteur Échap détaché. */
+    destroy(): void;
+    private destroySatellites;
+    private attachEscapeListener;
+    private detachEscapeListener;
+}

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

@@ -0,0 +1,49 @@
+import { YinYangComponentNode } from "../../../interfaces/IYinYangInternalModel";
+/**
+ * MODULATION d'une signature par un contact (OBS-UI-01) : pour chaque
+ * facette (id de composante), le poids W_f que la signature prend face à ce
+ * contact (0–10) et la qualité Q_f du contact (0–100), sa chance de
+ * réussir cette facette. L'hôte fournit les valeurs : la lib ne fait que
+ * les montrer (diamètre sur W_f, pourcentage Q_f, fantôme sur le poids du
+ * modèle, O_f).
+ */
+export type FacetModulation = {
+    weights: Record<string, number>;
+    scores: Record<string, number>;
+};
+export type FacetModulationOptions = {
+    /** Durée de l'animation des diamètres (ms) ; 0 : immédiat (défaut). */
+    durationMs?: number;
+    /** Vague entre satellite et fantôme ; à couper en mouvement réduit.
+     *  Défaut : false. */
+    ghostWaves?: boolean;
+};
+/** Ce qu'un satellite-facette montre. */
+export type FacetDisplay = 
+/** Ses propres score et poids (diagramme ordinaire). */
+{
+    kind: "ordinary";
+}
+/** Poids seul, sans score (signature d'obstacle). */
+ | {
+    kind: "signature";
+}
+/** Poids modulé W_f et qualité Q_f d'un contact. */
+ | {
+    kind: "modulated";
+    weight: number;
+    quality: number;
+};
+/** Poids d'une facette du modèle (O_f pour une signature, C_f sinon). */
+export declare function componentWeight(component: YinYangComponentNode): number;
+/**
+ * Affichage d'une facette. Une facette sans exigence (poids nul) d'une
+ * signature reste sans score même modulée : W_f y est nul, elle n'entre
+ * dans aucun tirage — lui montrer une chance serait faux.
+ */
+export declare function resolveFacetDisplay(component: YinYangComponentNode, scoreless: boolean, modulation: FacetModulation | null): FacetDisplay;
+/** Clé d'égalité d'un affichage (un satellite inchangé n'est pas refait). */
+export declare function facetDisplayKey(display: FacetDisplay): string;
+/** La facette portant la qualité Q_f d'un contact : tous ses satellites
+ *  à la même tension, si bien que sa qualité (moyenne pondérée) vaut Q_f. */
+export declare function withQuality(component: YinYangComponentNode, quality: number): YinYangComponentNode;

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

@@ -0,0 +1,95 @@
+export type IdleTabFacet = {
+    id: string;
+    label: string;
+    orientation: "yin" | "yang";
+    notion?: {
+        id: string;
+        name: string;
+    };
+    /** Ratio de taille du satellite (même calcul qu'en Idle « facettes »). */
+    sizeRatio: number;
+};
+export type IdleTabRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type IdleTabCell = IdleTabRect & {
+    facetId: string;
+    label: string;
+    orientation: "yin" | "yang";
+    /** Centre du satellite. */
+    satelliteCenter: {
+        x: number;
+        y: number;
+    };
+    /** Diamètre du satellite (minEdge, en pixels). */
+    satelliteDiameter: number;
+    /** Ligne de base du libellé de la facette. */
+    labelAnchor: {
+        x: number;
+        y: number;
+    };
+    /** La pastille de notion du groupe se pose sur le bord bas (sinon haut) :
+     *  le libellé de la facette s'écarte alors vers l'intérieur. */
+    legendBottom: boolean;
+    /** La case borde-t-elle son groupe en haut / en bas (coins arrondis,
+     *  libellé de la notion posé sur ce bord) ? */
+    groupEdges: {
+        top: boolean;
+        bottom: boolean;
+    };
+    /** Notion parente du groupe de la case, si elle en a une. */
+    notion?: {
+        id: string;
+        name: string;
+    };
+};
+export type IdleTabGroup = IdleTabRect & {
+    facetIds: string[];
+    /** Notion parente : son libellé se pose sur la bordure du groupe. */
+    notion?: {
+        id: string;
+        name: string;
+    };
+    /** Bordure qui porte le libellé de la notion (côté extérieur). */
+    legendSide: "top" | "bottom";
+};
+export type IdleTabLayout = {
+    columns: number;
+    rows: number;
+    cells: IdleTabCell[];
+    groups: IdleTabGroup[];
+    center: {
+        x: number;
+        y: number;
+    };
+    /** Rayon de l'illustration centrale réduite. */
+    centerRadius: number;
+    /** Taille de police des libellés de facette (px). */
+    labelFontSize: number;
+};
+export type IdleTabLayoutOptions = {
+    /** Coin haut-gauche de l'espace disponible (défaut : 0, 0). */
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    /** Marge autour de la grille. */
+    padding?: number;
+    /** Écart entre deux groupes voisins. */
+    gutter?: number;
+};
+type Unit = {
+    facets: IdleTabFacet[];
+    notion?: {
+        id: string;
+        name: string;
+    };
+};
+/** Facettes d'une même notion regroupées (ordre de première apparition),
+ *  yin avant yang au sein d'un groupe. */
+export declare function buildIdleTabUnits(facets: readonly IdleTabFacet[]): Unit[];
+export declare function computeIdleTabLayout(facets: readonly IdleTabFacet[], options: IdleTabLayoutOptions): IdleTabLayout;
+export {};

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

@@ -0,0 +1,45 @@
+/** Centre et diamètre d'un satellite. */
+export type MorphPoint = {
+    x: number;
+    y: number;
+    d: number;
+};
+export type MorphItem = {
+    /** Groupe enveloppe du satellite, qui porte la transformation. */
+    wrapper: SVGGElement;
+    /** Place radiale du satellite dans le repère du motif (avant réduction). */
+    base: MorphPoint;
+    /** Départ et arrivée, en pixels du SVG. */
+    from: MorphPoint;
+    to: MorphPoint;
+};
+type Center = {
+    x: number;
+    y: number;
+};
+/** Place à l'écran (pixels du SVG) d'un point du motif réduit à `scale`. */
+export declare function toScreen(point: MorphPoint, scale: number, center: Center): MorphPoint;
+/** Transformation de l'enveloppe qui amène le satellite de sa place
+ *  radiale `base` à `screen`, le motif étant réduit à `scale`. */
+export declare function wrapperTransform(base: MorphPoint, screen: MorphPoint, scale: number, center: Center): {
+    x: number;
+    y: number;
+    k: number;
+    transform: string;
+};
+/** Point entre `from` (t = 0) et `to` (t = 1), sur une trajectoire polaire
+ *  autour de `center`. */
+export declare function polarLerp(from: MorphPoint, to: MorphPoint, t: number, center: Center): MorphPoint;
+/** Joue la bascule : échelle du motif de `fromScale` à `toScale` (posée par
+ *  `applyScale`), chaque satellite de `from` à `to`. */
+export declare function morphSatellites(options: {
+    /** Nœud qui porte la transition (le globalGroup du motif). */
+    node: SVGGElement;
+    center: Center;
+    fromScale: number;
+    toScale: number;
+    items: readonly MorphItem[];
+    durationMs: number;
+    applyScale: (scale: number) => void;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,10 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+/**
+ * Apparence d'un satellite-facette SANS SCORE (signature d'obstacle,
+ * OBS-UI-01) : un disque neutre, liseré de la couleur de sa catégorie, et
+ * sa pastille de poids — ni lobes yin/yang ni pourcentage, puisqu'un
+ * obstacle n'a pas de qualité. Le marquage `data-scoreless` tait le reste
+ * (styles/signature.css) ; le disque est posé dans le cœur, qui porte
+ * aussi l'animation de sortie du satellite.
+ */
+export declare function applyScorelessLook(satellite: IYinYangController): void;

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

@@ -28,6 +28,18 @@ type EventFieldLifecycleControllerDeps = {
         center: Point | null;
         radius: number;
     };
+    /** Vrai en Idle « facettes » : le souffle relie alors le satellite-facette
+     *  d'origine aux autres satellites-facettes atteints — pas de satellite de
+     *  cutting à viser, et getComponentBorderTargetPoint résout chaque facette
+     *  vers son satellite-facette. */
+    isIdleFacettesField: () => boolean;
+    /** Vrai pendant l'animation de changement de facette (clic sur un arc,
+     *  navigation RECHERCHE ou pile) — voir refreshTargets. */
+    isComponentSwitching: () => boolean;
+    /** Vrai quand le champ est piloté par les événements cochés de la pile
+     *  (mode STACK, aucun aperçu) : seuls les satellites réellement amplifiés
+     *  sont alors visés (voir buildEventFieldTargets, stackEffects). */
+    isStackDrivenField: () => boolean;
 };
 /**
  * Cycle de vie du "Champ d'événement" (souffle cœur → satellites de
@@ -99,6 +111,8 @@ export declare class EventFieldLifecycleController {
      *  frame par startEventFieldAnimation (orbite + pulsation). */
     private updateEventFieldVisual;
     private startEventFieldAnimation;
+    /** Fin de vie : coupe la boucle du champ d'événement. */
+    destroy(): void;
     private stopEventFieldAnimation;
 }
 export {};

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

@@ -7,8 +7,8 @@ export type Point = {
  *  ce renderer ne fait que dessiner. */
 export type EventFieldRenderSegment = {
     end: Point;
-    /** Bonus de score de l'Événement Clé — pilote l'épaisseur du souffle. */
-    scoreBonus: number;
+    /** Intensité positionnelle commune aux cinq signatures — épaisseur du souffle. */
+    intensity: number;
 };
 /**
  * Chorégraphie du "Champ d'événement" : un souffle annulaire. Le cœur du
@@ -34,7 +34,7 @@ export declare class EventFieldRenderer {
     private coreHalo;
     /** setTimeout id du fondu de sortie en cours, ou null — voir hide(). */
     private _hideTimeoutId;
-    /** requestAnimationFrame id de la rétraction géométrique en cours — voir retractGeometry(). */
+    /** Id frameScheduler de la rétraction géométrique en cours — voir retractGeometry(). */
     private _retractFrameId;
     hasActiveGroup(): boolean;
     ensureElements(params: {

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

@@ -0,0 +1,99 @@
+type Point = {
+    x: number;
+    y: number;
+};
+export type StopData = Array<{
+    color: string;
+    opacity: number;
+}>;
+/** Un faisceau, tel que peint sur une image (repère du globalGroup). */
+export type ForceFieldStroke = {
+    start: Point;
+    end: Point;
+    /** Extrémités des dégradés (énergie, comète, cœur). */
+    tail: Point;
+    head: Point;
+    /** Atténuation du faisceau (emphase de l'action en focus), 0..1. */
+    emphasis: number;
+    glow: {
+        color: string;
+        alpha: number;
+        baseWidth: number;
+    };
+    /** Cône d'aura : trapèze sur l'axe start → end, demi-largeurs aux deux bouts. */
+    cone: {
+        sourceHalf: number;
+        targetHalf: number;
+        fill: string;
+        opacity: number;
+    };
+    energy: {
+        stops: StopData;
+        width: number;
+        opacity: number;
+        dashOffset: number;
+    };
+    flow: {
+        width: number;
+        opacity: number;
+        dashOffset: number;
+    };
+    core: {
+        stops: StopData;
+        width: number;
+        opacity: number;
+    };
+    port: {
+        r: number;
+        width: number;
+        color: string;
+        opacity: number;
+    };
+    headAura: {
+        r: number;
+        fill: string;
+        opacity: number;
+    };
+    headCore: {
+        r: number;
+        opacity: number;
+    };
+};
+export declare const COMET_PERIOD: number;
+export declare class ForceFieldCanvasPainter {
+    readonly globalGroup: SVGGElement;
+    private readonly host;
+    private readonly canvas;
+    private readonly ctx;
+    private readonly resizeObserver;
+    /** Coin haut-gauche de la zone peinte, en unités du globalGroup. */
+    private originX;
+    private originY;
+    /** Pixels du canvas par unité du globalGroup. */
+    private pxPerUnit;
+    /** Repère pour lequel la zone a été calée ; null = à recaler. */
+    private laidOutKey;
+    private readonly glowLayersByAlpha;
+    constructor(globalGroup: SVGGElement);
+    /** Repasse au-dessus des autres enfants du globalGroup. */
+    raise(): void;
+    /** Opacité de toute la couche, avec une transition CSS éventuelle. */
+    setOpacity(value: string, transition?: string): void;
+    remove(): void;
+    paint(strokes: readonly ForceFieldStroke[]): void;
+    private paintStroke;
+    /**
+     * Empreinte du repère de la zone peinte : transforms du globalGroup et de
+     * ses ancêtres jusqu'au <svg>, viewBox, densité d'écran. Quelques
+     * getAttribute par image, sans layout forcé ; la taille du <svg> est
+     * suivie à part (ResizeObserver).
+     */
+    private layoutKey;
+    private ensureLayout;
+    /** Cale la zone peinte sur le <svg> visible. Faux si pas encore mesurable. */
+    private layout;
+    private glowLayers;
+    private line;
+    private gradient;
+}
+export {};

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

@@ -1,8 +1,13 @@
+import type { ActionStackItem } from "../action-stack/ActionStackState";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import type { CompiledPropagationGraph } from "../../../interfaces/IPropagationGraph";
 import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
 import { ForceFieldLink, ForceFieldLinkDetail } from "./types";
 export declare class ForceFieldComputationService {
+    private readonly getEventContextItems;
+    constructor(getEventContextItems?: () => ActionStackItem[]);
+    eventContextCacheKey(): string;
+    private resolveDetails;
     build(params: {
         orbitData: ChildrenOrbitEntry[];
         sourceChildIndex: number;
@@ -15,6 +20,8 @@ export declare class ForceFieldComputationService {
         allComponents: YinYangInternalModel["components"] | undefined;
         actionDelta: number;
         propagationGraph: CompiledPropagationGraph;
+        eventContextItems?: ActionStackItem[];
+        actionItem?: ActionStackItem;
     }): {
         links: ForceFieldLink[];
         allLinkDetails: ForceFieldLinkDetail[];
@@ -31,6 +38,8 @@ export declare class ForceFieldComputationService {
         allComponents: YinYangInternalModel["components"] | undefined;
         actionDelta: number;
         propagationGraph: CompiledPropagationGraph;
+        eventContextItems?: ActionStackItem[];
+        actionItem?: ActionStackItem;
     }): {
         links: ForceFieldLink[];
         allLinkDetails: ForceFieldLinkDetail[];