@micheeeeel/yinyangapp 2.5.1 → 2.6.0

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

@@ -4,92 +4,8 @@ import { IYinYangController } from "../../interfaces/IYinYangController";
 import { IYinYangAppFactory } from "../../interfaces/IYinYangAppFactory";
 import { IAnimator } from "../../interfaces/IAnimator";
 import { YinYangInternalModel } from "../../interfaces/IYinYangInternalModel";
-import { type ComboResult } from "../../data/combo-engine";
-import { type AmplifierResult, type AmplifierTargetBreakdown } from "../../data/amplifier-engine";
 import { ForceFieldLinkDetail } from "./force-field/types";
-/**
- * Bloc "action" de la vue cumulative (mode STACK) : "source" = action jouée
- * sur le satellite ciblé, "propagation" = effet indirect qui l'atteint depuis
- * un autre satellite.
- */
-type ActionCumulativeBlock = {
-    type: "source" | "propagation";
-    actionId?: string;
-    actionName: string;
-    actionDescription: string;
-    sourceComponentName?: string;
-    sourceOddName?: string;
-    sourceOddId: string;
-    sourceCuttingId: number | undefined;
-    totalDelta: number;
-    rawDelta?: number;
-    baseDelta?: number;
-    weightDelta?: number;
-    weightDeltaBase?: number;
-    detailRows: ForceFieldLinkDetail[];
-    comboResults?: ComboResult[];
-    amplifierResults?: AmplifierResult[];
-    stackItemId?: string;
-    color?: string;
-    /** This item's own propagation edges from the real sequential
-     *  simulation (see computeSequentialStackContributionsAtFocus) — lets
-     *  the panel build this block's descriptive breakdown (cascade,
-     *  absorption/gap badges, "satellites touchés" list) from data that
-     *  exactly matches totalDelta, instead of the shared isolated pool. */
-    sequentialDetailPool?: ForceFieldLinkDetail[];
-    /** Position dans la pile (ActionStackItem.slotIndex) — permet de fusionner
-     *  et trier les blocs "keyEvent" avec les blocs action dans leur ordre
-     *  naturel de pile (voir renderCumulativeDetailsForCutting). */
-    slotIndex?: number;
-};
-/**
- * Bloc "keyEvent" de la vue cumulative : un Événement Clé joué (kind="keyEvent"
- * dans la pile), toujours affiché dès que sa Facette d'origine correspond à
- * celle affichée — voir buildKeyEventBlocksForComponent. `active` distingue
- * visuellement "amplifie actuellement une action ciblée" de "présent mais
- * rien ne l'active encore" (voir isKeyEventCurrentlyActive) ; l'existence du
- * bloc, elle, ne dépend jamais de cette condition.
- */
-type KeyEventCumulativeBlock = {
-    type: "keyEvent";
-    keyEventId: string;
-    active: boolean;
-    totalDelta: number;
-    slotIndex?: number;
-    stackItemId?: string;
-    color?: string;
-    targetedActions: Array<{
-        id: string;
-        name: string;
-    }>;
-    breakdowns?: AmplifierTargetBreakdown[];
-};
-/**
- * Un bloc de la vue cumulative (mode STACK). Hissé au niveau module (au lieu
- * d'un type local à renderCumulativeDetailsForCutting) pour être partagé avec
- * buildKeyEventBlocksForComponent, réutilisé aussi par renderComposanteInfo
- * quand aucun satellite n'est sélectionné.
- */
-export type CumulativeBlock = ActionCumulativeBlock | KeyEventCumulativeBlock;
-type DiagramNavEvent = {
-    type: "composante";
-    componentIndex: number;
-} | {
-    type: "cutting";
-    componentIndex: number;
-    oddId: string;
-    cuttingIndex: number;
-} | {
-    type: "action";
-    componentIndex: number;
-    oddId: string;
-    cuttingIndex: number;
-    actionId: string;
-} | {
-    type: "keyEvent";
-    componentIndex: number;
-    keyEventId: string;
-};
+import type { DiagramNavEvent } from "./types";
 export declare class YinYangController implements IYinYangController {
     model: IYinYangModel;
     view: IYinYangView;
@@ -103,48 +19,10 @@ export declare class YinYangController implements IYinYangController {
     private rotationState;
     private childrenOrbitManager;
     private childOddMap;
-    /**
-     * Persists the active action across component switches.
-     * Cleared only when the user explicitly deselects the action.
-     */
-    private persistentActionContext;
-    /**
-     * Prepared by prepareForComponentSwitch() before children are hidden.
-     * undefined = not yet prepared (fallback path)
-     * null      = prepared but no action applies to target component
-     * { type: 'incoming', ... } = show incoming force fields on arrival
-     * { type: 'reactivate' }   = re-activate the source action on arrival
-     */
-    private pendingComponentSwitchContext;
-    private readonly CHILD_LABEL_SHORT_MAX_CHARS;
     private readonly ACTION_DRAG_THRESHOLD_PX;
-    private htmlDragGhost;
-    private selectedSourceFocus;
-    /** Focus saved just before switching away from the source component, so returning
-     * to the source component restores the same highlighted cutting (multi-action). */
-    private focusBeforeComponentSwitch;
-    /** Cross-component force-field links from the source component, saved when
-     *  switching away to a target component.  Used to recompute the incoming view
-     *  when a checkbox toggle fires while already on the target component. */
-    private savedSourceComponentLinks;
-    /** Set by navigateToCutting for cross-component nav: after the switch the
-     *  incoming force field context is established, then onCuttingLabelClick is
-     *  called for this cutting to show its propagated card. */
-    private _pendingCuttingFocusAfterSwitch;
-    private _pendingOddHighlightAfterSwitch;
-    /** Set by SearchPanelSynchronizer.searchNavigateToCutting when a stack-item
-     *  click switches facette while an action is active: prepareForComponentSwitch
-     *  owns pendingComponentSwitchContext for the incoming force field, so this
-     *  navigation is applied separately once the switch completes. */
-    private _pendingCuttingNavigationAfterSwitch;
-    /** Menu cœur à déployer à l'arrivée sur la facette (voir searchSetKeyEventMenuOpen). */
-    private _pendingKeyEventMenuAfterSwitch;
     private actionStackController;
     private childActionMenuController;
     private coreEventMenuController;
-    private isCoreEventMenuOpen;
-    /** Id de l'Événement Clé actuellement en aperçu (carte affichée), ou null. */
-    private activeKeyEventId;
     private forceFieldDetailsPanel;
     private forceFieldRenderer;
     /** Champ d'événement — liens cœur → satellites amplifiés par l'Événement
@@ -162,31 +40,18 @@ export declare class YinYangController implements IYinYangController {
     private searchPanelSynchronizer;
     private actionStackManager;
     private state;
-    /** Callback to open the search tab and set a query — wired from main.ts. */
-    private openSearchWithQuery?;
-    /** Callback: injecte le bloc d'impact d'action directe dans l'onglet Recherche. */
-    private _onShowDirectActionBlock?;
-    /** Callback: affiche le bloc d'action directe d'un prérequis dans le panneau B. */
-    private _onShowDirectActionBlockPanelB?;
-    /** Quand vrai, le prochain appel à _onShowDirectActionBlock est routé vers le panneau B. */
-    private _routeNextDirectActionBlockToPanelB;
-    /** Quand vrai, renderSourceActionDetailsForCurrentSource ne re-rend pas le bloc Panel A.
-     * Utilisé pendant reactivatePersistentAction pour préserver l'état des <details> ouverts. */
-    private _suppressDirectActionBlockRender;
-    /** Callback: efface le bloc d'impact d'action directe de l'onglet Recherche. */
-    private _onClearDirectActionBlock?;
-    /** Callback: injecte la carte descriptive d'un Événement Clé dans l'onglet Recherche. */
-    private _onShowKeyEventBlock?;
-    /** Callback: efface la carte d'Événement Clé de l'onglet Recherche. */
-    private _onClearKeyEventBlock?;
-    /** Notifie la hiérarchie RECHERCHE de l'état du menu radial des Événements
-     *  Clés (diagramme → arbre), pour que le groupe "Événements Clés" reste le
-     *  reflet exact des bulles réellement déployées. */
-    private _onKeyEventMenuStateChange?;
-    /** Callback: injecte le bloc d'action propagée dans l'onglet Recherche. */
-    private _onShowPropagationBlock?;
-    /** Callback: efface le bloc d'action propagée de l'onglet Recherche. */
-    private _onClearPropagationBlock?;
+    private childrenBuilder;
+    private componentSwitch;
+    private incomingForceField;
+    private detailsPresenter;
+    private navigator;
+    private keyEvents;
+    private stackFocus;
+    private titlePresenter;
+    private propagationAnimator;
+    private debugTools;
+    private session;
+    private ui;
     /**
      * Constructor to initialize the controller with its model, view, and factory.
      */
@@ -210,39 +75,10 @@ export declare class YinYangController implements IYinYangController {
      * Generates a unique child key for sub-instances.
      */
     generateChildKey(): string;
-    /**
-     * Creates child instances of the YinYang pattern using the model's data.
-     * Each child is generated based on the small circle data.
-     */
     createYinYangChildren(): void;
-    /** Both distance and size are fixed relative to the facette's uniform
-     *  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. */
-    private cachedGlobalFitShrinkRatio?;
-    private computeGlobalFitShrinkRatio;
+    /** Nom de l'objet racine : celui de la Cause montée quand elle en porte un
+     *  (sphère de contact), sinon la sphère active de la page. */
+    private rootName;
     /** Mode PRÉSENTATION (voir `IViewData.presentation`) : le diagramme se lit,
      *  il ne se manœuvre pas. Lu sur la vue, donc hérité par les satellites —
      *  chacun porte la même `viewData.presentation`. */
@@ -260,13 +96,6 @@ export declare class YinYangController implements IYinYangController {
      *  a plain redraw would not pick the new values up. */
     rebuildBorderSegments(): void;
     setChildrenEnabled(isEnabled: boolean): void;
-    /**
-     * Dev-only helper: vide la pile d'actions et la remplit avec des actions
-     * choisies au hasard parmi les enfants visibles, en réutilisant le pipeline
-     * normal de validation (`validateActionSelection`) afin d'exercer le même
-     * calcul de projection ghost que dans l'usage réel. Sert à tester
-     * rapidement l'affichage des yin-yang ghost sans clics manuels répétés.
-     */
     debugFillActionStackWithRandomActions(count?: number): void;
     /**
      * Immediately starts hiding children animation without waiting.
@@ -286,18 +115,6 @@ export declare class YinYangController implements IYinYangController {
     refreshGhostVisualState(): void;
     prepareForComponentSwitch(targetComponentId: string): void;
     handleComponentSwitchChildren(): void;
-    private refreshChildrenForComponentSwitch;
-    private restoreIncomingForceFieldContext;
-    /**
-     * Recomputes the incoming force-field view for `currentComponentId` based on
-     * the subset of source actions provided by `items`, using the source links saved
-     * when the user originally switched away from the source component.
-     * Returns true if matching cross-component links were found and the view was
-     * updated; returns false if no links target the current component (caller should
-     * fall back to switching to the source component instead).
-     */
-    private recomputeIncomingForceFieldForItems;
-    private reactivatePersistentAction;
     private setChildrenHiddenState;
     private attachChildToggleHandler;
     /**
@@ -351,10 +168,16 @@ export declare class YinYangController implements IYinYangController {
         cuttingIndex: number;
     }>): void;
     startSearchActionDrag(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string, label: string, startEvent: PointerEvent, sourceEl: Element, onDragIntentDetected?: () => void): void;
+    /**
+     * Glisser d'un libellé d'action (prérequis d'une carte combo, tag de règle)
+     * vers la pile. Le libellé ne porte que l'id de l'action : on résout ici
+     * son emplacement (ODD/découpage de la composante courante) puis on passe
+     * la main à `onDragStart` — le même gestionnaire que le glisser depuis
+     * l'arbre RECHERCHE (cf. PanelManager.wireSearchDrag), donc même
+     * comportement, bascule automatique vers STACK comprise.
+     */
+    setOnActionTagDragStart(onDragStart: (componentIndex: number, oddId: string, cuttingIndex: number, actionId: string, label: string, event: PointerEvent, el: Element) => void): void;
     startSearchKeyEventDrag(componentIndex: number, keyEventId: string, label: string, startEvent: PointerEvent, sourceEl: Element, onDragIntentDetected?: () => void): void;
-    private navigateToSource;
-    private navigateToPrereqAction;
-    private navigateToCutting;
     private buildProjectionActionsFromStackItems;
     private buildForceFieldSourceIndicesFromStackItems;
     private applyProjectedGhostFromStackItems;
@@ -429,15 +252,12 @@ export declare class YinYangController implements IYinYangController {
     setDisplayEllipsisForShortLabels(enabled: boolean): void;
     /** Wire from main.ts so rule-tag clicks with absent actions open the search tab. */
     setOpenSearchWithQuery(cb: (query: string) => void): void;
-    private _onDiagramActionDragIntentCb?;
     /** Déclenché une fois, au franchissement du seuil de glisser d'une bulle
      *  d'action satellite (voir la dépendance startActionDrag câblée au
      *  constructeur de ChildActionMenuController) — DiagramPanelBridge s'en
      *  sert pour basculer sur l'onglet STACK, comme pour le glisser RECHERCHE. */
     setOnDiagramActionDragIntent(cb: () => void): void;
-    private _onActiveChildChange?;
     setOnActiveChildChange(cb: () => void): void;
-    private _onOuterSparkAutoToggle?;
     /** Notified whenever the Sphère/Facette status auto-toggles the perimeter
      *  spark, so the "Étincelle périmètre" checkbox can mirror it. */
     setOnOuterSparkAutoToggle(cb: (enabled: boolean) => void): void;
@@ -463,27 +283,7 @@ export declare class YinYangController implements IYinYangController {
      *  currentAnimation slot with its own pseudo-switch, and silently swallow
      *  the real switch's finalization (which is what used to turn the spark off). */
     cancelOuterSparkForActivation(): void;
-    /** Dev-only: toggles the perimeter spark sweep from the "Étincelle"
-     *  button — a second click restores whatever it was before the first
-     *  (off, in every normal case, since the spark otherwise never turns on
-     *  by itself). The spark stays purely opt-in — this button and the
-     *  "Étincelle périmètre" checkbox are the only ways to start it. */
     triggerOuterSparkDev(): void;
-    /** Dev-only: (re)lance l'étincelle d'équilibre sur la facette active.
-     *  L'orientation passée est celle de la facette, c'est-à-dire son lobe
-     *  dominant (getRadiiForScore le dessine à 0.5 + score/2, donc toujours
-     *  le plus grand des deux) : c'est la seule qui satisfasse le contrat de
-     *  triggerBalanceSpark, qui calibre la croissance de queue et le taux de
-     *  combustion partagé sur l'étincelle primaire. Elle était codée en dur
-     *  sur "yang", ce qui inversait les rôles sur une facette yin-dominante
-     *  — la survivante se faisait alors tuer par la limite de durée de vie à
-     *  l'instant même où sa jumelle s'éteignait, sans pondre un seul têtard.
-     *  Contrairement à l'étincelle du périmètre, c'est une animation
-     *  ponctuelle (elle s'arrête d'elle-même une fois le sous-cercle
-     *  parcouru à moitié) : chaque clic la relance depuis le début plutôt
-     *  que de la toggle. `onComplete`, transmis tel quel à triggerBalanceSpark,
-     *  permet à l'appelant (le bouton dev, une fois basculé en mode actif) de
-     *  la relancer en boucle sans dupliquer sa logique de durée. */
     triggerBalanceSparkDev(onComplete?: () => void): void;
     /** Satellite dont le menu d'action est ouvert, sinon (repli) le satellite
      *  "sélectionné en lecture seule" — même surbrillance que la bordure du
@@ -564,6 +364,33 @@ 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. */
+    /**
+     * 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,
+     * 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)
+     * et centre son bloc — même effet qu'un clic sur le libellé de l'item
+     * (voir setOnSelectStackItemSatellite dans DiagramPanelBridge).
+     */
+    private focusStackItemSatellite;
+    /** Item dont les cartes combo sont actuellement en aperçu de dépôt. */
+    private _guidedComboPreviewItemId;
+    /**
+     * Pendant le glisser guidé d'un prérequis, met à jour en direct les cartes
+     * combo de l'action qui le requiert, comme si le prérequis était déposé à
+     * l'emplacement survolé — le pendant, pour un glisser venu de RECHERCHE, de
+     * la projection que fait déjà le glisser d'un item interne à la pile
+     * (ActionStackDragHandler.emitDragPreviewChange). Hors zone de dépôt ou
+     * glisser terminé : contenu d'origine restauré.
+     */
+    private refreshGuidedComboPreview;
     requestScrollToStackItemBlock(stackItemId: string): void;
     /**
      * Wire from main.ts — injecte le bloc d'impact d'action directe dans l'onglet Recherche
@@ -576,17 +403,6 @@ export declare class YinYangController implements IYinYangController {
     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;
-    /**
-     * 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).
-     * Utilisé par les panneaux contextuels pour afficher le bloc d'une action cliquée dans leur arbre.
-     */
-    /**
-     * Déclenche l'affichage du bloc de propagation dans un panneau contextuel lorsque
-     * l'utilisateur clique sur un cutting dans l'arbre de ce panneau.
-     * Retourne true si le cutting est effectivement impacté par l'action active (bloc affiché),
-     * false sinon (aucun changement).
-     */
     showPropagationForContextCutting(componentId: string, oddId: string, cuttingIndex: number): boolean;
     buildDirectActionBlockForContext(compId: string, oddId: string, cutIdx: number, actionId: string, onReady: (compId: string, oddId: string, cutIdx: number, actionId: string, html: string, attachHandlers: (container: HTMLElement) => void) => void): void;
     /**
@@ -604,40 +420,16 @@ export declare class YinYangController implements IYinYangController {
         label: string;
         cssClass: string;
     } | undefined, name: string | undefined) => void): void;
-    /** Fired unconditionally at the end of onCuttingLabelClick (both the cumulative and
-     *  the normal branch), regardless of which internal path handled the click, so that
-     *  DiagramPanelBridge can keep the STACK hierarchy (chip + history) in sync even when
-     *  the cumulative view intercepts the click before renderForceFieldDetails /
-     *  _onShowPropagationBlock is reached. Signature mirrors setOnPropagationBlock's
-     *  (compId, oddId, cuttingIndex) shape so the same STACK-sync handler can be reused. */
-    private _onCuttingNavigated?;
     setOnCuttingNavigated(cb: (compId: string, oddId: string, cuttingIndex: number) => void): void;
-    private notifyCuttingNavigated;
-    private onDiagramOddChangeCb?;
     /** Wire from main.ts to sync the search panel when the user clicks an ODD arc. */
     setOnDiagramOddChange(cb: (componentIndex: number, oddId: string, mode: "highlight") => void): void;
-    private onDiagramNavChangeCb?;
     /** Wire from main.ts to sync the search panel on composante / cutting / action clicks. */
     setOnDiagramNavChange(cb: (event: DiagramNavEvent) => void): void;
-    /** Fired when the user re-clicks the active satellite in the diagram (toggle-to-close),
-     *  or when an ODD-level interaction deselects it — componentIndex lets the listener
-     *  restore its detail panel to the facette view rather than clearing it entirely. */
-    private _onDiagramSatelliteDeselect?;
     setOnDiagramSatelliteDeselect(cb: (componentIndex: number) => void): void;
-    /** Fired when the user clicks the current composante's border arc to hide its satellites. */
-    private _onDiagramComposanteDeselect?;
     setOnDiagramComposanteDeselect(cb: () => void): void;
-    /** Callback vers le panneau Recherche quand la souris entre/sort d'un satellite dans le diagramme. */
-    private _onDiagramChildHoverCb;
     setOnDiagramChildHover(cb: (componentIndex: number | null, oddId: string | null, cuttingIndex?: number) => void): void;
-    /** Callback vers le panneau Recherche quand la souris entre/sort d'un arc de bordure (composante). */
-    private _onDiagramComposanteHoverCb;
     setOnDiagramComposanteHover(cb: (componentIndex: number | null) => void): void;
-    /** Callback vers le panneau Recherche quand la souris entre/sort d'un cercle d'action dans le menu radial. */
-    private _onDiagramActionHoverCb;
     setOnDiagramActionHover(cb: (componentIndex: number | null, oddId: string | null, cuttingIndex: number | null, actionId: string | null) => void): void;
-    /** Callback externe (panneau RECHERCHE) quand la souris entre/sort d'un arc ODD dans le diagramme. */
-    private _onDiagramOddArcHoverCb;
     setOnDiagramOddArcHover(cb: (oddId: string | null) => void): void;
     /** Called by BorderDrawer when the user clicks a composante border arc. */
     onDiagramComposanteClicked(componentIndex: number): void;
@@ -687,312 +479,25 @@ export declare class YinYangController implements IYinYangController {
     private clearForceFieldVisualState;
     private clearForceFieldVisualOnly;
     private renderOppositeChildrenForceField;
-    private clearGhostDetails;
-    private renderGhostDetailsForActiveAction;
     clearForceFieldDetails(): void;
-    private renderActionPropagationTable;
-    /**
-     * Calcule les ComboResult pour une action donnée.
-     * Priorité : résultats pré-calculés du stack item → évaluation à la volée.
-     * Utilisé par le panneau principal et tous les panneaux contextuels.
-     */
-    private _computeComboResultsForAction;
-    private renderSourceActionDetailsForCurrentSource;
-    private _mergeAllComponentLinkDetails;
-    /**
-     * For each cross-component inter row in the source's allLinkDetails, compute the
-     * cascade intra rows that would appear in the target component's ODD.
-     * These rows live in the target controller's state (only populated after the user
-     * switches to that component), so we recompute them eagerly here, mirroring the
-     * logic of restoreIncomingForceFieldContext exactly.
-     *
-     * Three sub-cases, matching restoreIncomingForceFieldContext:
-     *   A) intraEdges.length === 0  → distributeToAllChildren (equal split)
-     *   B) targetedCutting undefined → global mode: each flat intra edge gets the full budget
-     *   C) targetedCutting set       → targeted DFS with cascading budget from entry node
-     *      C') entry node not found  → distributeToAllChildren fallback (non-bridge only)
-     */
-    private _computeCrossComponentCascadeRows;
-    private renderForceFieldDetails;
-    private flashChildCuttings;
-    /** Waypoint d'un satellite de la facette courante (par index orbital). Le
-     *  contrôleur peut être passé quand l'appelant l'a déjà sous la main. */
-    private _resolveOrbitWaypoint;
-    /** Waypoint sur l'arc de bordure d'une autre facette (cible inter-facettes). */
-    private _resolveBorderWaypoint;
-    /** `color` avec l'opacité `alpha` (chaîne CSS). */
-    private static _withAlpha;
-    /**
-     * Couleur de la comète : celle de l'action portant l'emphase (aperçu ??
-     * focus) quand le réglage le demande et qu'elle est identifiable, sinon la
-     * couleur fixe du réglage.
-     */
-    private _resolvePropagationColor;
-    /** Anneau doux (couleur de la comète) autour d'un satellite atteint :
-     *  un cercle qui s'élargit en s'éteignant, plus une brève lueur pleine.
-     *  Intensité réglable (ringOpacity, 0 = rien). */
-    private _drawFlashRings;
-    /**
-     * Joue une passe de propagation sur des waypoints déjà résolus : lueur sur
-     * la source, comète parcourant tout le chemin d'un seul mouvement (en
-     * pulsant chaque lien de champ de force à son entrée), anneau à chaque
-     * arrivée. Partagée par le clic sur une ligne du panneau
-     * (flashChildCuttings) et par la boucle de l'action en focus
-     * (flashSourcePropagationTree). Retourne la durée totale de la passe en ms
-     * (comète éteinte et dernier anneau fondu), pour cadencer la boucle.
-     */
-    private _animateResolvedPropagation;
-    /**
-     * Comète parcourant `waypoints` (polyligne) d'un seul mouvement : vitesse
-     * de croisière réglable, départ et arrivée adoucis (easeSinInOut sur tout
-     * le trajet), fondu d'apparition/extinction, halo flouté, et queue fondue
-     * reconstituée à partir des positions récentes (elle épouse donc les
-     * virages aux étapes au lieu de se couper à chaque segment). Tout est
-     * déterministe en fonction du temps écoulé : la queue se calcule sans
-     * historique, en rééchantillonnant la position à t − Δ.
-     * `onWaypointArrival(wp)` à chaque étape atteinte (sauf la source),
-     * `onSegmentStart(i)` à l'entrée dans chaque segment. `isCancelled` lu à
-     * chaque frame : vrai → la comète disparaît net. Retourne la durée du
-     * trajet (ms), fondu de sortie non compris.
-     */
-    private _animateComet;
     private getCurrentComponent;
     private getCurrentComponentOrUndefined;
-    /** Nom de l'objet racine : celui de la Cause montée quand elle en porte un
-     *  (sphère de contact), sinon la sphère active de la page. */
-    private rootName;
-    private getCurrentComponentTitle;
-    /** Second (et, le cas échéant, troisième) niveau du titre : libellé + couleur
-     *  ODD du satellite actif sous la facette courante (menu ouvert, ou
-     *  sélection en lecture seule — voir getActiveChildMeta), avec le libellé
-     *  de son action active le cas échéant. Un Événement Clé actif (frère du
-     *  Satellite, jamais les deux à la fois côté menu — voir activeKeyEventId)
-     *  prend la priorité et occupe cette même ligne, sans action associée
-     *  (targetedActionIds sont des renvois, pas une Action propre). Null hors
-     *  facette / sans satellite ni Événement Clé actif. */
-    private getCurrentSatelliteTitle;
-    /** Troisième niveau du titre : libellé de l'action actuellement active,
-     *  seulement si elle appartient bien au satellite affiché (oddId,
-     *  cuttingIndex) — actionSourceChildKey peut différer du satellite affiché
-     *  quand l'utilisateur navigue vers un autre satellite en lecture seule
-     *  (recherche/STACK) pendant qu'une action reste techniquement active sur
-     *  le précédent (voir le commentaire sur actionSourceChildKey). Sans ce
-     *  contrôle, le titre affichait le libellé de l'ancienne action sous le
-     *  nouveau satellite. */
-    private getCurrentActionTitle;
-    /** Refreshes just the top-left title's satellite line against the current
-     *  state — cheap, idempotent DOM diffing — from every code path that can
-     *  change which satellite is active (menu open/close, force-field link
-     *  click, hierarchy/search navigation, cumulative view). */
-    private refreshComponentTitle;
-    /** Cross-fades the top-left component-title label to `componentIndex`'s
-     *  name immediately, without waiting for the full updateContextLabels()
-     *  pass (orbit data, legend, etc.) that only runs once the diagram's
-     *  component-switch animation completes. A facette switch always starts
-     *  with no active satellite (createYinYangChildren() resets it), so the
-     *  satellite line is cleared here rather than read from state mid-switch. */
-    private updateComponentTitleLabelImmediate;
-    private updateContextLabels;
-    private renderChildScoresDeltas;
-    /** Re-syncs the weightDelta ghost/wave/pulse against the current
-     *  ViewInitializer settings (basePulseEnabled, ghostPulseDurationSec,
-     *  pulseMorphRatio) without waiting for the next natural preview change.
-     *  Needed because toggling "Pulsation rayons activée" only calls
-     *  redrawBothGhosts() (VizControlsPanel), which refreshes the facette's own
-     *  score ghost but has no reason to know about the weightDelta preview. */
     refreshWeightPreviewPulse(): void;
-    /** Draws the weightDelta ghost + traveling wave for every satellite
-     *  targeted by a currently-previewed action — see
-     *  ActionStackManager.getWeightDeltaByChildKey. The satellite's own circle
-     *  never resizes, same as the facette ghost never resizes the real
-     *  yin-yang circle; WeightPreviewRingRenderer resyncs every child each
-     *  call (no delta = no ghost/wave), same "recompute the full desired
-     *  state" pattern as highlightOddInChildren. */
-    private applyWeightPreview;
     private clearChildActionMenu;
     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;
     /** Sélectionne (ouvre) le satellite `childKey` de la facette courante,
      *  comme un clic dessus — sans toggle-close s'il est déjà actif. */
     private selectSatelliteByKey;
-    /**
-     * Appelé par YinYangDrawer quand le petit cercle "œil" du lobe dominant
-     * (yin ou yang, selon Composante.orientation) est cliqué — jamais l'autre
-     * lobe, jamais un satellite (garde déjà appliquée côté YinYangDrawer, même
-     * principe que onDiagramOddArcClicked pour les arcs ODD). Ouvre/ferme le
-     * menu radial des Événements Clés de la facette active.
-     */
     onCoreEventNucleusClicked(): void;
-    private notifyKeyEventMenuState;
-    private toggleCoreEventMenu;
-    /**
-     * Fermeture du Champ d'événement : l'Événement Clé en aperçu et les bulles
-     * du menu cœur — chemin unique partagé par la fermeture de facette
-     * (closeCurrentComposante) et par l'exclusivité action/événement
-     * (openActionMenuFromChild). No-op si rien n'est ouvert.
-     *
-     * hide() d'abord pour la rétraction immédiate du souffle (le geste
-     * d'ouverture joué à l'envers — cf. prepareForComponentSwitch),
-     * updateCoreEventMenu() ensuite pour replier les bulles et laisser
-     * refreshTargets constater qu'il n'y a plus rien à dessiner. La carte du
-     * panneau RECHERCHE part avec : elle décrit l'Événement Clé qu'on vient de
-     * retirer du diagramme, et rien ne garantit qu'un autre bloc prenne sa
-     * place (ouvrir un satellite n'affiche qu'un descriptif, pas un bloc).
-     */
-    private closeKeyEventField;
-    private updateCoreEventMenu;
-    /**
-     * Événements Clés qui pilotent le Champ d'événement en ce moment — source
-     * unique de vérité pour EventFieldLifecycleController (cibles) comme pour
-     * getEventFieldSource (point d'émission).
-     *
-     * Deux régimes, mêmes règles de priorité que le champ de force d'action :
-     * un APERÇU (clic sur une bulle du menu cœur ou sur l'entrée de l'arbre
-     * RECHERCHE) prend toujours la main — c'est le geste que l'utilisateur
-     * vient de faire, quel que soit l'onglet ; sinon, en mode STACK, ce sont
-     * les Événements Clés COCHÉS de la pile qui décident, exactement comme les
-     * actions cochées y décident des champs de force. En mode RECHERCHE sans
-     * aperçu, rien : la pile n'a pas voix au chapitre.
-     *
-     * Le renderer n'a qu'une source (le souffle part d'UN point, voir
-     * EventFieldRenderer), donc on ne renvoie jamais qu'un jeu d'événements
-     * partageant la même : ceux nés de la facette courante partent tous de son
-     * cœur et se cumulent ; à défaut, on retombe sur le plus récent des
-     * événements distants qui atteignent cette facette (mode entrant, source =
-     * l'arc de sa facette d'origine).
-     */
-    private getEventFieldKeyEvents;
-    /**
-     * Point d'émission du Champ d'événement : le CŒUR du yin/yang, c'est-à-dire
-     * le disque central du lobe correspondant à l'orientation de la facette
-     * courante — le cœur noir du yang sur une facette Yang, le cœur blanc du
-     * yin sur une facette Yin. Ce n'est PAS le centre géométrique du symbole :
-     * les deux lobes ont des rayons qui varient avec le score, donc le cœur se
-     * déplace le long de l'axe vertical au fil de la partie, d'où la
-     * relecture de la géométrie à chaque frame. Injecté dans
-     * EventFieldLifecycleController (getEventFieldSource), rappelé à chaque
-     * frame de son animation.
-     *
-     * `geometry.yin/yang.centerY` est la position CANONIQUE (pré-rotation) :
-     * pendant une rotation Yin/Yang (AnimationsMngr), le cœur visible se
-     * déplace via un `transform` écrit à même `graphElementGroup` à chaque
-     * frame, sans jamais toucher `geometry`. On lit donc la position réelle
-     * via getLiveLobeCoreCenter plutôt que la géométrie statique, pour que les
-     * anneaux du champ d'événement suivent le cœur qui tourne au lieu de
-     * naître à une origine figée.
-     */
-    private getEventFieldSource;
-    /**
-     * Résout un point porté par `lobeGroup` (coordonnées locales, ici le
-     * centre canonique du cœur) dans le repère de globalGroup — celui où
-     * EventFieldRenderer dessine (voir EventFieldLifecycleController,
-     * getGlobalGroupNode). Passe par les CTM SVG plutôt que de reparser
-     * l'attribut `transform` (comme getChildRenderedCenter le fait pour une
-     * simple translation) : le transform posé sur graphElementGroup pendant
-     * une rotation combine rotate ET translate, et cette composition suit
-     * fidèlement AnimationsMngr sans dépendre de sa formule exacte — un
-     * changement futur de celle-ci n'a pas besoin d'être répercuté ici.
-     */
-    private getLiveLobeCoreCenter;
-    /**
-     * Rejoue l'aperçu d'un Événement Clé depuis une navigation Recherche
-     * (historique précédent/suivant) — pendant minimal de searchNavigateToAction,
-     * sans mise au point du diagramme (pas de satellite/facette à recentrer,
-     * l'entrée d'arbre dédiée est hors scope pour l'instant).
-     */
     searchNavigateToKeyEvent(keyEventId: string): void;
-    /**
-     * Rétablit le Champ d'événement d'un Événement Clé DÉJÀ affiché à droite —
-     * pendant de restoreActionDiagramState pour les événements, utilisé au
-     * retour en mode RECHERCHE (voir PanelManager.resyncDiagramToMasterPanel).
-     *
-     * Volontairement plus étroit que previewKeyEvent : ni carte redessinée, ni
-     * notification de navigation (donc pas d'entrée d'historique en double) —
-     * le panneau montre déjà cet événement, c'est le diagramme qui le rattrape.
-     * On garde en revanche l'exclusivité action/événement : les deux champs ne
-     * cohabitent jamais.
-     *
-     * Si la facette courante n'est plus celle de l'événement (l'utilisateur a
-     * navigué ailleurs pendant le mode STACK), on revient d'abord sur sa facette
-     * d'origine — mêmes gestes que searchSetKeyEventMenuOpen : l'aperçu survit
-     * au switch (prepareForComponentSwitch le garde vivant, destination =
-     * origine) et le menu cœur se redéploie à l'arrivée avec sa bulle active.
-     */
     restoreKeyEventDiagramState(keyEventId: string): void;
-    /**
-     * Dépli/repli du groupe "Événements Clés" depuis la hiérarchie RECHERCHE —
-     * pendant exact du clic sur le cœur du yin/yang (onCoreEventNucleusClicked),
-     * pour que l'arbre et le diagramme montrent le même menu déployé : ouvrir le
-     * groupe déploie les bulles de la facette, le refermer les rétracte (même
-     * règle que le dépli d'un Satellite, qui déploie ses boutons d'Action).
-     *
-     * Le repli passe par closeKeyEventField plutôt que par le toggle : il doit
-     * aussi emporter l'Événement Clé en aperçu (et sa carte), sinon une bulle
-     * validée resterait allumée sous un groupe replié.
-     */
     searchSetKeyEventMenuOpen(componentIndex: number, open: boolean): void;
-    /** Ouverture idempotente du menu cœur — no-op s'il est déjà déployé (le
-     *  toggle le refermerait). */
-    private openCoreEventMenu;
-    /** Seul point de mutation de activeKeyEventId — resynchronise la ligne
-     *  Événement Clé du titre (voir getCurrentSatelliteTitle) à chaque
-     *  changement, exactement comme setActiveChildKey le fait pour le
-     *  satellite. */
-    private setActiveKeyEventId;
-    /** Aperçu — 1er clic sur un Événement Clé : affiche sa carte descriptive
-     *  dans le panneau Recherche, ne joue rien (même principe que
-     *  activateActionFromChild côté satellite). */
-    private previewKeyEvent;
-    /** Validation — 2e clic sur l'Événement Clé déjà en aperçu, ou glisser une
-     *  bulle jusqu'à une position précise de la pile (voir startKeyEventDrag,
-     *  même mécanisme que validateActionSelection côté satellite). Sans
-     *  insertAtVisibleIndex, l'item est ajouté au sommet — le menu radial
-     *  reste ouvert dans les deux cas, pour enchaîner d'autres choix. */
-    private validateKeyEventSelection;
     private validateActionSelection;
-    private clientPointToGlobalGroup;
-    private renderDragGhost;
-    private removeDragGhost;
-    private onCuttingLabelClick;
-    private resolveActionSource;
-    private getActiveActionMeta;
-    /**
-     * Per active stack item sourced from the CURRENT component: its marginal
-     * contribution (state units, 0..100) to (oddId, cuttingId), and its own
-     * detailed propagation edges — both produced by the real sequential
-     * simulation (projectGhostStateForActionSequence), the same one that
-     * drives the diagram's displayed Δ.
-     *
-     * - marginalDeltaAtFocus: summing this across items equals the diagram's Δ
-     *   exactly, by construction (telescoping sum over the fractional
-     *   accumulator). Used as the authoritative block total.
-     * - detailPool: this item's OWN propagation edges (absorption/gap/cascade),
-     *   from the exact same single-pass computation (computeActionPropagationDetails,
-     *   via onStep) that produced marginalDeltaAtFocus — not a second, separately
-     *   re-run propagation — against the exact rolled-forward state this item
-     *   saw at its point in the stack, not the pristine base state. Used so the
-     *   panel's descriptive breakdown badges match the authoritative total
-     *   instead of an isolated estimate.
-     *
-     * Items sourced from a DIFFERENT component are absent from the map: they
-     * don't participate in this component's rolling simulation (their effect
-     * is merged separately via the cross-component bridge/incoming-links path).
-     * Callers must fall back to the isolated per-source estimate for those.
-     */
-    private computeSequentialStackContributionsAtFocus;
-    /**
-     * Blocs "keyEvent" pour la vue cumulative : un Événement Clé actif (coché
-     * dans la pile) dont la Facette d'origine (originComposanteId) correspond à
-     * `component` — indépendamment du satellite précis sélectionné, et même si
-     * aucune de ses actions ciblées n'est jouée (voir isKeyEventCurrentlyActive
-     * pour le seul état visuel actif/inactif). Réutilisé par
-     * renderCumulativeDetailsForCutting (satellite sélectionné) et par les
-     * appelants de renderComposanteInfo (Facette sélectionnée, aucun satellite).
-     */
-    private buildKeyEventBlocksForComponent;
-    private renderCumulativeDetailsForCutting;
-    private collectDetailRowsForSourceTarget;
     private getChildRenderedCenter;
     private getComponentBorderTargetPoint;
     private clearForceFieldComputationState;
@@ -1042,139 +547,18 @@ export declare class YinYangController implements IYinYangController {
      * que YinYangDrawer applique déjà à l'arc lui-même.
      */
     previewOddHighlight(oddId: string | null): void;
-    /** Focus persistant — null pour l'effacer. */
-    private setFocusedStackItem;
-    /**
-     * Clic sur le libellé d'un item déjà en focus, alors que son bloc est
-     * visible dans le panneau (satellite porteur sélectionné) : désactive le
-     * focus et retourne true — l'appelant n'a alors ni navigation ni scroll à
-     * faire. Si le bloc n'est pas visible (l'utilisateur a navigué ailleurs
-     * entre-temps), le clic redevient une sélection normale : false.
-     */
     toggleStackItemFocusFromStack(stackItemId: string): boolean;
-    /** Aperçu par survol — null à la sortie, qui retombe sur le focus. */
-    private setStackItemEmphasisPreview;
-    /**
-     * Point d'accroche unique de la mise en valeur du satellite source de
-     * l'action portant l'emphase (aperçu ?? focus). Réutilise pour l'instant
-     * le glow de highlightOddByStackItemId (ou le segment de bordure si la
-     * source est dans une autre facette) — l'anneau animé viendra ici.
-     * `clearIfNone` : sans emphase, efface la mise en valeur (sorties de
-     * survol, défocus) ; false pour les simples re-applications (satellites
-     * recréés, fin d'un survol de satellite) afin de ne pas écraser d'autres
-     * highlights en cours.
-     */
-    private applyFocusedSourceHighlight;
-    /** Memo à une entrée de resolveEmphasisSourceChildIndex (lu chaque frame). */
-    private _emphasisSourceMemo;
-    /**
-     * Index orbital du satellite source de l'action portant l'emphase, ou null
-     * si rien ne doit être atténué : hors mode STACK (un aperçu RECHERCHE ne
-     * doit pas hériter d'un focus STACK résiduel), item absent, Événement Clé
-     * (pas de champ de force), ou source dans une autre facette (tout reste
-     * plein, la bordure source est surlignée par highlightOddByStackItemId).
-     * Résolution par oddId + cuttingIndex (buildForceFieldSourceIndicesFromStackItems),
-     * robuste au rebuild de childOddMap ; la clé du memo suit la convention de
-     * ForceFieldLifecycleController._buildPropCacheKey.
-     */
-    private resolveEmphasisSourceChildIndex;
-    /** Identité stable (sourceOriginKey) du satellite source d'un item de la
-     *  pile — null pour un Événement Clé ou une facette introuvable. */
-    private _stackItemSourceOriginKey;
-    private _emphasisKeyMemo;
-    /** Clé de la source de l'action portant l'emphase (aperçu ?? focus), quelle
-     *  que soit sa facette ; null hors STACK ou sans emphase. Lue à chaque frame. */
-    private resolveEmphasisSourceOriginKey;
-    /** Memo à une entrée de resolveFocusedActionSource (lu à chaque update du menu). */
-    private _focusSourceMemo;
-    /**
-     * Action en focus (focus persistant seulement, pas l'aperçu par survol —
-     * une bulle qui apparaît/disparaît au survol serait du bruit), résolue en
-     * (actionId, clé et index orbital du satellite source) dans la facette
-     * courante. null hors mode STACK, sans focus, pour un Événement Clé, ou si
-     * la source vit dans une autre facette.
-     */
-    private resolveFocusedActionSource;
-    /**
-     * Point de départ « bulle » du champ de force de l'action en focus : la
-     * bulle de son action dans le menu radial si le satellite source est celui
-     * sélectionné, sinon la bulle détachée posée sur la source. null si
-     * aucune bulle n'est visible (le champ démarre alors au satellite).
-     */
-    private resolveFocusBubbleStub;
-    private _focusLoopTimer;
-    /** Jeton d'annulation : incrémenté à chaque (re)départ/arrêt, les passes en
-     *  vol comparent leur jeton à chaque frame et s'effacent si dépassées. */
-    private _focusLoopRun;
-    /** Pause entre deux passes (propagationCometConfig.loopGapMs, panneau
-     *  Debug). Un timer en attente est reposé avec la nouvelle valeur pour que
-     *  le réglage se sente tout de suite. */
     setFocusPropagationLoopGapMs(ms: number): void;
-    private restartFocusPropagationLoop;
-    private stopFocusPropagationLoop;
-    private _runFocusPropagationLoopPass;
-    /** Liens sortants par index orbital de départ (segments chaînés inclus),
-     *  restreints à ceux qui mènent quelque part (satellite ou autre facette). */
-    private _buildOutgoingLinkMap;
-    /** Tous les chemins `prefix` + descente depuis `node` jusqu'aux feuilles
-     *  (satellite sans lien sortant, ou arc d'une autre facette), sans cycle. */
-    private _walkPropagationPaths;
-    /** Anime simultanément chaque chemin (waypoints `head` puis la cible de
-     *  chaque lien) ; retourne la durée de la passe la plus longue. */
-    private _animatePropagationPaths;
-    /**
-     * Joue une passe de propagation sur l'arbre complet des champs de force
-     * d'une source de la facette courante : chaque chemin racine → feuille est
-     * animé simultanément, comme le clic sur l'en-tête d'un bloc source.
-     * L'arbre est lu dans state.forceField.links via le tag sourceChildIndex
-     * (segments chaînés inclus : startIndex = cible précédente). La comète part
-     * de la bulle d'action quand elle est visible. Retourne la durée de la
-     * passe (0 si rien à animer).
-     */
-    private flashSourcePropagationTree;
-    /**
-     * Même passe pour une action dont la source vit dans une autre facette :
-     * ses liens entrants ici (tagués sourceOriginKey, recopié par
-     * restoreIncomingForceFieldContext) partent de l'arc de la facette source ;
-     * chaque entrée est prolongée par sa cascade intra-facette. Retourne la
-     * durée de la passe (0 si cette action n'a aucun lien entrant ici).
-     */
-    private flashIncomingPropagationTree;
     highlightOddByStackItemId(stackItemId: string | null): void;
+    debugInsertAdverseActions(count: number): void;
     /**
-     * Retourne les actions applicables au cutting associé à `childKey`,
-     * en consultant `activeComposantes` via `actionMap` (lookup O(1)).
-     *
-     * Les actions adverses vivent sous le même satellite (l'invariant "une
-     * action vit sous un satellite" tient) mais ne sont jamais proposées au
-     * joueur ici : le système se chargera de les placer lui-même dans la
-     * pile, pas un clic sur le satellite.
-     */
-    private getActionsForChild;
-    /**
-     * Dev-only : le système place lui-même `count` items adverses — actions
-     * ET Événements adverses (yasuni_adverse_key_events.ts) — dans la pile
-     * active, piochés dans tout le catalogue (toutes les facettes, pas
-     * seulement celle affichée à l'écran), aux slots choisis par
-     * adverse-action-planner.ts (chaînes de combos complètes, ordre narratif,
-     * fenêtres d'effet respectées — un combo d'action adverse peut avoir un
-     * Événement adverse pour prérequis). Les adverses déjà présents dans la
-     * pile ne sont pas rejoués.
+     * 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
+     * reconstruit seul à la bascule. La pile n'est jamais filtrée.
      *
-     * Une action d'une facette non affichée n'a pas de childController vivant
-     * (childControllers/childOddMap ne connaissent que la facette courante,
-     * voir createYinYangChildren) : l'item de pile est donc construit à la
-     * main plutôt que via ActionStackManager.insertActionAtSlot, qui exige un
-     * childController réel. sourceChildKey reste au sentinel "" — le reste du
-     * code résout toujours l'origine d'un item via sourceComponentId /
-     * sourceOddId / sourceCuttingIndex, jamais via sourceChildKey une fois en
-     * pile (childOddMap est reconstruit avec de nouvelles clés à chaque
-     * changement de facette). Un Événement adverse porte les sentinelles d'un
-     * item keyEvent (sourceOddId "" / sourceCuttingIndex −1, voir
-     * validateKeyEventSelection) et sa Facette d'origine en sourceComponentId
-     * — indispensable au scoping Facette de son bloc dans l'ANALYSE (voir
-     * buildKeyEventBlocksForComponent).
+     * Hors STACK, l'action ou l'Événement en aperçu de l'autre bord perdrait
+     * sa bulle : on le referme plutôt que de laisser un champ sans émetteur.
      */
-    debugInsertAdverseActions(count: number): void;
+    setAdverseMode(isEnabled: boolean): void;
 }
-export {};