@micheeeeel/yinyangapp 3.0.1 → 3.1.0

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/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[];

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

@@ -1,9 +1,11 @@
+import type { KeyEventActionEffects } from "../../../data/key-event-effects";
+import { type EventTargetBreakdown } from "./keyEventPresentation";
 import { type CometPlayFn } from "./propagation-viz/propagationVizLists";
 import { YinYangComponentNode, YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { ForceFieldLink, ForceFieldLinkDetail } from "./types";
-import type { ComboResult } from "../../../data/combo-engine";
+import { type ComboResult } from "../../../data/combo-engine";
 import { type AbsorptionBreakdown, type ActiveShield } from "./shieldViewModel";
-import type { AmplifierResult, AmplifierTargetBreakdown } from "../../../data/amplifier-engine";
+import type { AmplifierResult } from "../../../data/amplifier-engine";
 import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
 import type { Composante, ODD } from "../../../data/yasuni_cause";
 /** Contexte combo (backward) ou amplificateur (forward) transmis au clic
@@ -45,6 +47,7 @@ type ActionCumulativeBlockViewModel = {
     detailRows: ForceFieldLinkDetail[];
     comboResults?: ComboResult[];
     amplifierResults?: AmplifierResult[];
+    eventEffects?: KeyEventActionEffects;
     stackItemId?: string;
     color?: string;
     sequentialDetailPool?: ForceFieldLinkDetail[];
@@ -65,6 +68,10 @@ type ActionCumulativeBlockViewModel = {
      *  contribution négative de ce bloc — direct, propagé, agrégé, absorbé,
      *  appliqué (journal de résolution). */
     shieldAbsorption?: AbsorptionBreakdown;
+    directionalAbsorptions?: Array<{
+        active?: ActiveShield;
+        breakdown: AbsorptionBreakdown;
+    }>;
 };
 /** Bloc "keyEvent" : un Événement Clé joué, toujours affiché dès que sa
  *  Facette d'origine correspond à celle affichée (voir YinYangController.
@@ -82,7 +89,7 @@ type KeyEventCumulativeBlockViewModel = {
         id: string;
         name: string;
     }>;
-    breakdowns?: AmplifierTargetBreakdown[];
+    breakdowns?: EventTargetBreakdown[];
 };
 type CumulativeBlockViewModel = ActionCumulativeBlockViewModel | KeyEventCumulativeBlockViewModel;
 export declare class ForceFieldDetailsPanel {
@@ -134,6 +141,10 @@ export declare class ForceFieldDetailsPanel {
     /** Timer set during a user card interaction — prevents ResizeObserver from
      *  running _applyAutoFitToGrids while a card is animating. */
     private _userInteractingTimer;
+    /** Observers posés sur les conteneurs de rails, et rappel de la montée des
+     *  badges en cours : coupés par destroy(). */
+    private readonly _resizeObservers;
+    private _countUpFrameId;
     /** Set during a live-update _initCardRailState call. _applyAutoFitToGrids skips
      *  this container until the timer fires (covering both the initial DOM-insertion
      *  resize and the gs-block-open animation resize that follows). */
@@ -150,8 +161,6 @@ export declare class ForceFieldDetailsPanel {
     private _onDiagramElementHover?;
     /** Called when hovering a cumulative block — notifies the stack to highlight the matching item. */
     private _onStackItemHighlightCb?;
-    /** Clic sur l'en-tête d'un bloc → action en focus (YinYangController). */
-    private _onStackItemFocusCb?;
     private _onShieldOriginClickCb?;
     /** Miroir de state.forceField.focusedStackItemId — sert uniquement à
      *  ré-appliquer .ff-block--focused après chaque innerHTML. */
@@ -202,6 +211,9 @@ export declare class ForceFieldDetailsPanel {
      *  l'item de pile porteur, car la même action présente deux fois dans la
      *  pile a deux cartes combo de même contenu mais d'ancres différentes. */
     private _getHighlightCardKey;
+    /** Repère d'une ligne Source : le satellite où l'action est jouée porte
+     *  la petite icône de l'action (son nom en infobulle). */
+    private _actionSourceMarkHtml;
     /** Titre de carte, gabarit commun à toutes les cartes du rail : étiquette
      *  de type facultative (couleur --card-accent de la carte) puis nom
      *  lisible — l'information principale à lire. */
@@ -258,7 +270,7 @@ export declare class ForceFieldDetailsPanel {
     /**
      * Carte descriptive autonome d'un Événement Clé — affichée dans le
      * panneau Recherche quand l'utilisateur prévisualise l'événement lui-même
-     * (1er clic sur une bulle du menu radial du cercle central), pas quand il
+     * (1er clic sur une bulle du menu radial du satellite-facette), pas quand il
      * amplifie une action (voir _buildAmplifierSectionHtml pour cette carte-là).
      * Reprend délibérément le langage visuel de la carte action "source" (voir
      * _renderChainCardHtml/isSourceCard) — illustration plein cadre — mais SANS
@@ -289,13 +301,12 @@ export declare class ForceFieldDetailsPanel {
             name: string;
         }>;
         /** Répartition par action ciblée (position dans la fenêtre, bonus
-         *  effectif déjà réduit) — absente en aperçu avant validation, où
-         *  l'événement n'a pas encore de slot depuis lequel compter une position.
-         *  Une entrée par targetedActions quand présente (voir
-         *  getAmplifierTargetBreakdown). */
-        breakdowns?: AmplifierTargetBreakdown[];
-        /** Id de l'item "keyEvent" actif dans la pile (absent en aperçu avant
-         *  validation) — active le clic "barres de gain par slot" sur la carte
+         *  effectif déjà réduit) — bloc STACK seulement : absente en aperçu
+         *  (RECHERCHE), où aucune position n'existe hors de la pile. En STACK,
+         *  réduite aux actions cochées et amplifiées, comme targetedActions
+         *  (voir buildKeyEventBlocksForComponent). */
+        breakdowns?: EventTargetBreakdown[];
+        /** Id de l'item "keyEvent" actif dans la pile (absent en aperçu) — active le clic "barres de gain par slot" sur la carte
          *  et sa section d'actions ciblées (voir _attachComboHighlightHandlers),
          *  même mécanisme que le clic sur une carte combo. */
         sourceItemId?: string;
@@ -304,49 +315,6 @@ export declare class ForceFieldDetailsPanel {
         html: string;
         attachHandlers: (container: HTMLElement) => void;
     };
-    /**
-     * Carte "actions ciblées" d'une source d'effet différé — la liste des
-     * actions qu'un Événement Clé amplifie ("Actions amplifiées") ou qu'une
-     * action adverse entrave ("Actions entravées"), avec pour chacune le seul
-     * delta AJOUTÉ (ou retiré) par l'effet — pas le résultat final combiné au
-     * delta de base de l'action, qui deviendrait faux dès qu'un combo entre
-     * en jeu ailleurs sur la même action. Même grammaire que la chip de bonus
-     * de la carte Événement Clé sœur (buildKeyEventChipsHtml) : rester simple
-     * et lisible plutôt que reconstituer un calcul complet ici.
-     *
-     * Le bonus du catalogue est le PLAFOND — atteint seulement quand l'action
-     * est jouée au pic de la fenêtre. Une fois la source placée (breakdowns
-     * disponibles), chaque ligne affiche le bonus EFFECTIF (réduit selon la
-     * position) plutôt que ce plafond nominal — sinon la chip mentirait sur ce
-     * que l'action rapporte réellement. Sans breakdowns, le plafond reste la
-     * meilleure estimation disponible.
-     *
-     * Porte le même jeu d'attributs data-keyevent-* que la carte source
-     * (Événement Clé ou action adverse) pour que _attachComboHighlightHandlers
-     * et _extractTagComboContext y lisent la fenêtre "en avant" : un clic
-     * affiche les barres de gain par slot pour toute la fenêtre withinNextN.
-     *
-     * Badge et tableau repris à l'identique du gabarit carte combo (voir
-     * _buildComboSectionHtml/_buildPrereqBreakdownHtml) plutôt qu'un format ad
-     * hoc : le badge affiche le bonus/malus plafond du catalogue, accompagné
-     * d'un chip de poids (même paire badge+chip que portait la carte source
-     * avant que ces deltas n'emménagent ici, voir buildKeyEventCardHtml —
-     * absent si l'effet ne touche pas le poids), et le tableau réutilise les
-     * colonnes ff-pt-name/ff-pt-val de
-     * .ff-combo-prereq-table (les noms passent à la ligne plutôt que d'exiger
-     * une largeur de carte dérogatoire). Repliable comme n'importe quelle autre
-     * carte de la famille (le garde-fou qui la forçait dépliée a été retiré de
-     * _handleCardRailClick/_applyAutoFitToGrids) et précédée d'un séparateur
-     * .ff-chain-separator — même traitement que la carte source vis-à-vis d'un
-     * bloc combo/amplificateur, pour que ce bloc-ci ne fasse pas exception.
-     */
-    private _buildDelayedTargetsCardHtml;
-    /** Badge et note de provenance d'un bloc action de la vue cumulative.
-     *  Seule une action propagée porte une note dans l'en-tête (le satellite
-     *  dont elle provient) : pour une action directe — adverse comprise — on
-     *  est déjà sur le satellite porteur, l'information serait redondante.
-     *  L'acteur d'origine d'une action adverse est rendu à part (`origin`),
-     *  dans le corps du bloc, pour ne pas concurrencer le nom. */
     private _pickActionBlockBadge;
     /** Ligne « Acteur : … » placée en tête du corps d'un bloc adverse (action
      *  ou Événement) — remplace l'ancienne note d'en-tête. */
@@ -486,6 +454,9 @@ export declare class ForceFieldDetailsPanel {
      * re-runs the auto-fit measurement whenever the container changes size.
      */
     private _ensureResizeObserver;
+    /** Fin de vie : observers déconnectés, minuteries et montée des badges
+     *  coupées. Le DOM du panneau appartient à l'hôte : non touché. */
+    destroy(): void;
     private _initCardRailState;
     private _handleCardRailClick;
     private _triggerHighlightFromCard;
@@ -531,7 +502,6 @@ export declare class ForceFieldDetailsPanel {
     /** Vrai si le panneau affiche actuellement le bloc « Effets cumulés » de cet
      *  item de pile (le satellite/la facette porteuse est sélectionné). */
     hasBlockForStackItem(stackItemId: string): boolean;
-    setStackItemFocusCallback(cb: (id: string | null) => void): void;
     /** Clic sur le nom de l'action d'origine dans une carte Bouclier. */
     setShieldOriginClickCallback(cb: (stackItemId: string) => void): void;
     /** Miroir du focus (source de vérité : YinYangController / state). */
@@ -692,6 +662,7 @@ export declare class ForceFieldDetailsPanel {
         allComponents?: YinYangComponentNode[];
         comboResults?: ComboResult[];
         amplifierResults?: AmplifierResult[];
+        eventEffects?: KeyEventActionEffects;
         stackItemId?: string;
         /** Bouclier de stabilité déjà actif sur le satellite ciblé (posé par
          *  une action antérieure de la pile) — affiché sur la carte bilan et

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

@@ -20,7 +20,7 @@ export type ForceFieldDetailsPresenterDeps = {
     actionStackManager: ActionStackManager;
     applyOddStateForCutting: (oddId: string) => void;
     buildChildrenOrbitData: () => ChildrenOrbitEntry[];
-    buildProjectionActionsFromStackItems: (items: ActionStackItem[]) => SequentialActionProjectionInput[];
+    buildProjectionActionsFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => SequentialActionProjectionInput[];
     getChildControllers: () => IYinYangController[];
     childOddMap: Map<string, {
         oddId: string;
@@ -47,6 +47,9 @@ export type ForceFieldDetailsPresenterDeps = {
 export declare class ForceFieldDetailsPresenter {
     private deps;
     constructor(deps: ForceFieldDetailsPresenterDeps);
+    /** Action ciblée par un événement pendant son insertion depuis RECHERCHE.
+     * Les positions projetées servent au même moteur d'effets que le dépôt. */
+    renderGuidedActionPreview(preview: ActionStackItem, projected: ActionStackItem[] | null): void;
     /**
      * Construit le bloc d'action directe pour un emplacement connu (compId/oddId/cutIdx/actionId)
      * sans naviguer le diagramme, et fire le callback avec (compId, oddId, cutIdx, actionId, html, attachHandlers).

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

@@ -18,6 +18,12 @@ type ForceFieldLifecycleControllerDeps = {
     getAllComponents: () => YinYangInternalModel["components"] | undefined;
     updateChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
     updateContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
+    /** Frame d'orbite : bulles du menu radial et bulles détachées recalées
+     *  sur leur satellite, sans data join ni transitions. */
+    followOrbitChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
+    /** Frame d'orbite : libellés, deltas et anneau de poids recalés, sans
+     *  réécrire le titre, la légende ni les panneaux. */
+    followOrbitContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
     clearForceFieldDetails: () => void;
     renderForceFieldDetails: (linkIndex: number) => void;
     renderActionPropagationTable: () => void;
@@ -62,7 +68,16 @@ export declare class ForceFieldLifecycleController {
     invalidatePropagationCache(): void;
     private _buildPropCacheKey;
     renderOppositeChildrenForceField(orbitData?: ChildrenOrbitEntry[]): void;
-    removeOppositeChildrenForceField(): void;
+    /**
+     * Frame d'orbite en vol (ChildrenOrbitManager) : les satellites viennent
+     * de bouger, rien d'autre n'a changé. Seule la géométrie qui dépend de
+     * leur position est recalée ; le champ de force est dessiné ici une seule
+     * fois, sa propre boucle se contentant alors d'avancer la phase.
+     */
+    updateOrbitFrame(orbitData: ChildrenOrbitEntry[]): void;
+    /** Fin de vie : coupe la boucle du champ de force. */
+    destroy(): void;
+    removeOppositeChildrenForceField(orbitData?: ChildrenOrbitEntry[]): void;
     private ensureForceFieldLinks;
     private updateForceFieldVisual;
     private startForceFieldAnimation;

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

@@ -6,13 +6,12 @@ type Point = {
     y: number;
 };
 export declare class ForceFieldRenderer {
-    private forceFieldGroup;
-    private forceFieldDefs;
+    /** Surface du champ de force ; null = aucun champ affiché. */
+    private painter;
     private forceFieldLayers;
-    private readonly gradientPrefix;
     /** 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;
     /** Horodatage du dernier updateVisual — updateVisual ne reçoit pas de Δt,
      *  on le dérive ici pour le lissage de l'emphase. */
@@ -53,32 +52,25 @@ export declare class ForceFieldRenderer {
         getComponentBorderTargetPoint: (componentId: string) => Point | null;
     }): void;
     /**
-     * Fondu de sortie : au lieu de retirer le groupe instantanément (clear()),
-     * ramène son opacité à 0 sur fieldFadeOutDurationMs puis le retire
+     * Fondu de sortie : au lieu de retirer la surface instantanément (clear()),
+     * ramène son opacité à 0 sur fieldFadeOutDurationMs puis la retire
      * réellement — même grammaire de disparition que EventFieldRenderer.hide().
      * Idempotent : un appel alors qu'un fondu est déjà en cours ne fait rien de
      * plus (le clear() en attente suffit).
      */
     hide(): void;
     /**
-     * Rétraction géométrique : anime chaque beam vers son point de départ,
+     * Rétraction géométrique : ramène chaque faisceau vers son point de départ,
      * inverse exact de la croissance animatedEnd de updateVisual (même
      * fonction d'accélération, lue à l'envers : d3.easeCubicOut(1 - t) au lieu
-     * de d3.easeCubicOut(t)). Repart de _prevEndpoint — la géométrie du
-     * dernier frame réellement rendu — donc ne dépend d'aucun state externe :
-     * elle continue même si les liens qui l'ont produite sont nettoyés entre
+     * de d3.easeCubicOut(t)). Repart du dernier faisceau réellement peint, figé
+     * (respiration et comètes arrêtées), donc ne dépend d'aucun state externe :
+     * elle continue même si les liens qui l'ont produit sont nettoyés entre
      * temps (cas typique : clic sur l'arc de facette, qui déclenche hide()
      * puis, dans la foulée, la destruction des satellites source). Se déroule
-     * en parallèle du fondu d'opacité du groupe (même durée, posé par hide()).
+     * en parallèle du fondu d'opacité (même durée, posé par hide()).
      */
     private retractGeometry;
     clear(): void;
-    /**
-     * Met à jour les coordonnées d'un gradient et, si stopData est fourni (cache miss),
-     * les couleurs et opacités des stops.
-     * Fix 1 : les offsets ne sont jamais réécrits (initialisés une seule fois dans createStops).
-     * Fix 2 : stopData === null signifie que le cache couleur est valide — on n'écrit pas les stops.
-     */
-    private updateGradient;
 }
 export {};

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

@@ -8,10 +8,10 @@ import { ComponentTitlePresenter } from "../labels/ComponentTitlePresenter";
 import { ControllerSession } from "../state/ControllerSession";
 import { ForceFieldComputationService } from "./ForceFieldComputationService";
 export type IncomingForceFieldServiceDeps = {
-    applyProjectedGhostFromStackItems: (items: ActionStackItem[]) => void;
+    applyProjectedGhostFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => void;
     buildChildrenOrbitData: () => ChildrenOrbitEntry[];
     buildForceFieldSourceIndicesFromStackItems: (items: ActionStackItem[]) => number[];
-    buildProjectionActionsFromStackItems: (items: ActionStackItem[]) => SequentialActionProjectionInput[];
+    buildProjectionActionsFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => SequentialActionProjectionInput[];
     childOddMap: Map<string, {
         oddId: string;
         score: number;

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

@@ -44,6 +44,8 @@ export declare class PropagationAnimator {
      *  le réglage se sente tout de suite. */
     setFocusPropagationLoopGapMs(ms: number): void;
     restartFocusPropagationLoop(): void;
+    /** Fin de vie : coupe la boucle de l'action en focus et la comète. */
+    destroy(): void;
     private stopFocusPropagationLoop;
     private _runFocusPropagationLoopPass;
     /** Joue une passe pour l'item ; retourne sa durée (0 si rien à jouer). */