@micheeeeel/yinyangapp 1.0.6 → 2.0.1

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

@@ -1,31 +1,197 @@
 import { IYinYangModel } from "../../interfaces/IYinYangModel";
 import { IYinYangView } from "../../interfaces/IYinYangView";
 import { IYinYangController } from "../../interfaces/IYinYangController";
-import { ICategory } from "../../interfaces/ICategory";
 import { IYinYangAppFactory } from "../../interfaces/IYinYangAppFactory";
-import { IOddItem } from "../../interfaces/IOddItem";
 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;
+};
 export declare class YinYangController implements IYinYangController {
     model: IYinYangModel;
     view: IYinYangView;
     factory: IYinYangAppFactory;
     animator: IAnimator;
+    private childControllers;
+    private childrenOrbitManager;
+    private childOddMap;
     /**
-     * Constructor to initialize the controller with its model, view, and factory.
+     * Persists the active action across component switches.
+     * Cleared only when the user explicitly deselects the action.
      */
-    constructor(model: IYinYangModel, view: IYinYangView, factory: IYinYangAppFactory);
+    private persistentActionContext;
     /**
-     * Retrieves the number of borders for the YinYang view.
+     * 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
      */
-    getBorderNb(): number;
+    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
+     *  Clé actuellement actif (voir eventFieldLifecycleController). */
+    private eventFieldRenderer;
+    private eventFieldLifecycleController;
+    private childScoresDeltaRenderer;
+    private weightPreviewRingRenderer;
+    private contextLabelsRenderer;
+    private forceFieldComputationService;
+    private childInteractionController;
+    private forceFieldLifecycleController;
+    private settingsApplier;
+    private oddViewManager;
+    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?;
     /**
-     * Retrieves the sorted data for the model.
+     * Constructor to initialize the controller with its model, view, and factory.
      */
-    getSortedData(): IOddItem[];
+    constructor(model: IYinYangModel, view: IYinYangView, factory: IYinYangAppFactory);
     /**
-     * Retrieves the categories from the model.
+     * Retrieves the number of borders for the YinYang view.
      */
-    getCategories(): ICategory[];
+    getBorderNb(): number;
+    getInternalModel(): YinYangInternalModel;
+    private getAllComponents;
     /**
      * Retrieves the unique key for this instance of the model.
      */
@@ -34,14 +200,7 @@ export declare class YinYangController implements IYinYangController {
      * Retrieves the parent key for this instance, if it exists.
      */
     getParentKey(): string | null;
-    /**
-     * Determines whether the current model represents an enemy.
-     */
-    getIsEnemy(): boolean;
-    /**
-     * Calculates the average score based on the model's data.
-     */
-    calculateAverageScore(): number;
+    getForceFieldAllLinkDetails(): ForceFieldLinkDetail[];
     /**
      * Generates a unique child key for sub-instances.
      */
@@ -51,9 +210,778 @@ export declare class YinYangController implements IYinYangController {
      * 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;
+    applyChildrenFitScale(): void;
+    /** Creates the facette image ring, sized from the room actually left between
+     *  the border and the container edge. Call after applyChildrenFitScale() so
+     *  the pattern's final scale is already known. */
+    createFacetteImageRing(): void;
+    /** Re-applies the "Images facette" dev-control parameters (margin, fade
+     *  start/opacity) by rebuilding the ring. */
+    rebuildFacetteImageRing(): void;
+    /** Re-applies the border-arc shape dev controls (corner radius, bevel
+     *  intensity) by rebuilding the segments — they are built once at init, so
+     *  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.
+     * Called at the moment of component selection to start hide animation early.
+     */
+    animateChildrenHide(): void;
+    beginBlockingAnimation(label: string): symbol;
+    endBlockingAnimation(token: symbol): void;
+    hasActiveBlockingAnimation(): boolean;
+    /**
+     * Re-syncs the ghost visual state (tension + display) with the current
+     * mode/animation gate. Safe to call unconditionally — internally a no-op
+     * when ghost display isn't currently allowed (see ViewInitializer.isGhostDisplayAllowed).
+     * Called on STACK/RECHERCHE tab switches and whenever a blocking animation
+     * (rotation, facette/ODD switch, ...) starts or stops.
+     */
+    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;
+    /**
+     * @param forceOpen Skips the toggle-to-close branch below. Used by "navigate to"
+     *   callers (search/history replay) where the intent is always to land on this
+     *   satellite in its open state, never to close it — unlike a real diagram click,
+     *   which should toggle. Without this, replaying a history entry for a satellite
+     *   whose menu is still flagged active (e.g. after browsing away from it via a
+     *   card-link in cumulative mode, which doesn't change activeChildKey) closes it
+     *   instead of restoring it.
+     */
+    private openActionMenuFromChild;
+    /**
+     * Focus a cutting's child spike by oddId + cuttingIndex (0-based).
+     * Equivalent to clicking the corresponding spike on the diagram.
+     * Called both directly (same component) and after a component switch
+     * (via pendingComponentSwitchContext.type === "searchFocus").
+     */
+    private focusChildByOddCutting;
+    private focusChildByOddCuttingAndAction;
+    /** Mirrors the ODD state update performed by a diagram cutting click. */
+    private applyOddStateForCutting;
+    /** Shared deselect: clears the active action while keeping the action menu open,
+     *  then highlights the parent ODD and syncs the Recherche tree to ODD level. */
+    private _deactivateActionKeepMenu;
+    private applyOddHighlight;
+    private applyEnterOddView;
+    searchHandleComposanteClick(componentIndex: number): void;
+    searchNavigateToComponent(componentIndex: number): void;
+    searchNavigateToOdd(componentIndex: number, oddId: string): void;
+    /** Mirrors a RECHERCHE legend chip's open/closed state onto its arc in the
+     *  diagram — no-op if that chip's facette isn't the one currently shown. */
+    searchActivateOdd(componentIndex: number, oddId: string, isOpen: boolean): void;
+    searchHandleOddArcClick(componentIndex: number, oddId: string): void;
+    searchHighlightOdd(componentIndex: number, oddId: string): void;
+    searchPreviewHover(target: {
+        type: string;
+        componentIndex: number;
+        oddId?: string;
+        cuttingIndex?: number;
+        actionId?: string;
+    } | null): void;
+    /** Référence au nœud SVG du satellite mis en évidence depuis le hover du panneau force field. */
+    private _ffHoverChildNode;
+    searchHandleCuttingClick(componentIndex: number, oddId: string, cuttingIndex: number): void;
+    searchNavigateToCutting(componentIndex: number, oddId: string, cuttingIndex: number, forceOpen?: boolean): void;
+    searchNavigateToAction(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string): void;
+    restoreActionDiagramState(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string): void;
+    activateForceFieldMultiSource(sources: Array<{
+        oddId: string;
+        cuttingIndex: number;
+    }>): void;
+    startSearchActionDrag(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string, label: string, startEvent: PointerEvent, sourceEl: Element, onDragIntentDetected?: () => 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;
+    private onStackItemVisibilityToggle;
+    private activateActionFromChild;
+    private syncGhostTensionFromAction;
+    private attachChildHoverHandler;
+    /**
+     * Enters ODD view for the given ODD id.
+     * Called when the user clicks on an already-highlighted arc.
+     */
+    enterOddView(oddId: string): void;
+    /**
+     * Cancels any ODD highlight without changing view mode.
+     * Called when the user clicks outside arcs/children.
+     */
+    cancelOddHighlight(): void;
+    isChildrenEnabled(): boolean;
+    isActionActive(): boolean;
+    /**
+     * Attaches a click handler on the SVG container to cancel ODD highlight
+     * when clicking outside arcs and children.
+     */
+    private attachBackgroundClickHandler;
+    /**
+     * Exits ODD view and returns to component view.
+     */
+    exitOddView(): void;
+    showOddInfo(oddId: string): void;
+    showComposanteInfo(): void;
+    private setActiveChild;
+    private clearActiveChild;
+    private animateChildren;
+    private clearChildren;
+    setChildrenOrbitEnabled(isEnabled: boolean): void;
+    setChildrenOrbitDuration(_durationMs: number): void;
+    setChildrenOrbitSpeed(speed: number): void;
+    setChildrenOrbitRadiusScale(scale: number): void;
+    setRandomForceFieldCount(count: number): void;
+    setActionDeltaLabelsVisible(isVisible: boolean): void;
+    setChildrenContextLabelsVisible(isVisible: boolean): void;
+    setComboUncappedChainedPerformance(isEnabled: boolean): void;
+    setComboDangerousCanBecomeBonus(isEnabled: boolean): void;
+    /**
+     * Réévalue les combos affectés par un changement de réglage "Combos"
+     * (voir state.combos) et rafraîchit les aperçus qui en dépendent : les
+     * items déjà validés dans la pile (via onStackItemVisibilityToggle, qui
+     * réécrit item.comboResults/effectiveDelta puis re-render la carte
+     * focalisée) et, à défaut, l'action en simple aperçu (pas encore ajoutée
+     * à la pile — computeComboResultsForAction n'a pas de cache à invalider
+     * dans ce cas).
+     */
+    private recomputeActiveComboDisplays;
+    setLabelsFontScale(scale: number): void;
+    setLabelsTextShadowEnabled(isEnabled: boolean): void;
+    setChildLabelPlacement(position: "top" | "bottom"): void;
+    setActionStackLabelFontScale(scale: number): void;
+    setActionStackHistoryButtonScale(scale: number): void;
+    setComponentLabelFontScale(scale: number): void;
+    setChildStateDeltaFontScale(scale: number): void;
+    setChildStateDeltaOffset(offset: number): void;
+    setChildStateDeltaBoxScale(scale: number): void;
+    setOddLabelFontScale(scale: number): void;
+    setFacetteLabelFontScale(scale: number): void;
+    setFacetteLabelSuffixVisible(isVisible: boolean): void;
+    setComponentLegendLabelFontScale(scale: number): void;
+    setLegendLabelsBgEnabled(enabled: boolean): void;
+    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;
+    /** Turns the perimeter spark off. Called on every real Idle/Facette state
+     *  transition (app boot, a facette getting activated, or one being
+     *  deselected) — the spark is never turned on automatically any more.
+     *  Deselecting a facette returns to Idle exactly like a fresh load, not to
+     *  some separate "spark sweeping" status: nothing about deselecting
+     *  logically implies "start sweeping." The only ways to turn the spark on
+     *  are the manual "Étincelle périmètre" checkbox and the dev "Étincelle"
+     *  button (see triggerOuterSparkDev). */
+    private disableOuterSpark;
+    /** Called once at startup to apply the true Idle state: no facette active
+     *  (already the case — border segments are created with no active index)
+     *  and no spark sweeping either — nothing has happened yet. */
+    initIdleDefault(): void;
+    /** Immediately cancels the perimeter spark. Called at the very start of
+     *  any *real* facette activation (never the spark's own pseudo-activation
+     *  as it sweeps across a border arc — see ViewInitializer.animateToComponent's
+     *  notifyChildren flag). Must run synchronously before the switch animation
+     *  starts, not only once it finalizes: otherwise a spark sweep still running
+     *  during those ~800ms can cross another arc, overwrite the shared
+     *  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
+     *  diagramme (selectedSourceFocus / lien force-field sélectionné, voir
+     *  renderChildScoresDeltas). Sert notamment à resynchroniser le chip
+     *  d'en-tête STACK sur le satellite courant, y compris quand celui-ci a été
+     *  choisi via l'arbre RECHERCHE plutôt qu'en ouvrant son menu d'action. */
+    getActiveChildMeta(): {
+        oddId: string;
+        cuttingIndex: number;
+        componentId: string;
+    } | null;
+    private getSelectedCuttingMeta;
+    /**
+     * Called when the hierarchy (RECHERCHE tree or STACK overlay) collapses/deselects a cutting.
+     * Closes the satellite's radial action menu in the diagram without firing onDiagramNavChangeCb
+     * (to avoid a recursive sync loop).
+     */
+    deactivateChildMenuFromHierarchy(): void;
+    /**
+     * Fermeture du menu radial d'un satellite et de l'action qu'il projetait
+     * (champ de force, ghosts, bloc d'action du panneau) — chemin unique partagé
+     * par la hiérarchie (deactivateChildMenuFromHierarchy) et par l'exclusivité
+     * action/événement (toggleCoreEventMenu, previewKeyEvent). No-op si aucun
+     * satellite n'est actif.
+     */
+    private closeChildActionMenu;
+    deactivateComposanteFromHierarchy(): void;
+    /**
+     * Fermeture de la facette courante — chemin unique partagé par l'arc de
+     * bordure du diagramme (toggleComposanteChildrenFromDiagram) et par les
+     * hiérarchies RECHERCHE / STACK (deactivateComposanteFromHierarchy).
+     * Referme le menu radial, purge l'état d'action projetée (champ de force,
+     * ghosts, bloc d'action du panneau) puis masque les satellites : on retombe
+     * en mode Sphère, quel que soit le point d'entrée.
+     */
+    private closeCurrentComposante;
+    /**
+     * Called when switching FROM STACK → RECHERCHE tab.
+     * Stops the STACK force field animation and clears mode-specific state so
+     * STACK's multi-source force fields don't bleed into RECHERCHE mode.
+     */
+    clearForceFieldForModeSwitch(): void;
+    /**
+     * Called when switching FROM RECHERCHE → STACK tab.
+     * Clears any RECHERCHE-preview force field still active in state/diagram,
+     * then re-renders the combined force fields of STACK's own active items
+     * (no-op visually if the stack is empty).
+     */
+    syncForceFieldToStackMode(): void;
+    /**
+     * Recalcule le Champ d'événement pour le mode courant — à appeler APRÈS que
+     * l'onglet a réellement basculé (les gardes RECHERCHE/STACK, elles, tournent
+     * en phase de capture, avant le toggle de `ff-tab-active`, et liraient donc
+     * encore l'ancien mode via isStackModeActive).
+     *
+     * RECHERCHE → STACK : fait apparaître le souffle des Événements Clés cochés
+     * de la pile. STACK → RECHERCHE : le fait disparaître, faute d'aperçu actif.
+     */
+    syncEventFieldToCurrentMode(): void;
+    /**
+     * Deselecting a satellite (diagram toggle-close or hierarchy collapse) tears
+     * down clearProjectedActionState's shared hasActiveChildAction flag, which
+     * doubles as "STACK's checked items have a force field to show". In STACK
+     * mode with items still checked, that field must survive the deselect — so
+     * rebuild it from the stack, mirroring the RECHERCHE→STACK tab-switch sync
+     * in syncForceFieldToStackMode. No-op in RECHERCHE mode or an empty stack.
+     */
+    private reassertStackForceFieldAfterDeselect;
+    setOnLocateStackItemInSearch(cb: (componentId: string, oddId: string, cuttingIndex: number, actionId: string, kind: "action" | "keyEvent") => void): void;
+    /**
+     * Clic sur le libellé d'un item de la pile : sélectionne automatiquement
+     * son satellite porteur (action) ou sa Facette d'origine (Événement Clé)
+     * dans le diagramme, en restant en mode STACK (pendant "sans changement
+     * d'onglet" de setOnLocateStackItemInSearch).
+     */
+    setOnSelectStackItemSatellite(cb: (componentId: string, oddId: string, cuttingIndex: number, stackItemId: string) => void): void;
+    /** 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. */
+    requestScrollToStackItemBlock(stackItemId: string): void;
+    /**
+     * Wire from main.ts — injecte le bloc d'impact d'action directe dans l'onglet Recherche
+     * plutôt que dans l'onglet Analyse.
+     */
+    setOnDirectActionBlock(show: (compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void, clear: () => void): void;
+    /** Wire from main.ts — injecte la carte descriptive d'un Événement Clé dans l'onglet Recherche. */
+    setOnShowKeyEventBlock(show: (compId: string, keyEventId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void, clear: () => void): void;
+    /** Enregistre le miroir "menu cœur déployé ?" vers la hiérarchie RECHERCHE. */
+    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;
+    /**
+     * Wire from main.ts — injecte le bloc d'action propagée dans l'onglet Recherche
+     * lorsque l'utilisateur clique sur un cutting cible dans l'arbre ou le diagramme.
+     */
+    setOnPropagationBlock(show: (compId: string, oddId: string, cutIdx: number, html: string, attachHandlers: (container: HTMLElement) => void, sourceDesc: {
+        breadcrumb: string;
+        title: string;
+        description: string;
+    }, rationale?: string) => void, clear: () => void): void;
+    /** Wire from main.ts — notifie le chip STACK du badge + nom affiché par les
+     *  cartes d'info minimales Sphère/ODD (voir ForceFieldDetailsPanel.setOnHeaderUpdate). */
+    setOnHeaderUpdate(cb: (badge: {
+        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;
+    /** Toggle satellite (cutting circle) visibility for the current composante from the diagram. */
+    toggleComposanteChildrenFromDiagram(componentIndex: number): void;
+    /**
+     * A satellite drill-down and facette-level ODD browsing are mutually
+     * exclusive: deselect any active satellite before an ODD arc interaction
+     * proceeds, so the panel falls back to a view that actually contains the
+     * clicked ODD's legend chip (renderCuttingInfo/an active action only show
+     * a single ODD, or none — toggleOddLegendChipById would otherwise silently
+     * no-op). Mirrors the toggle-close branch of openActionMenuFromChild, plus
+     * an explicit renderComposanteInfo (clearProjectedActionState alone falls
+     * back to the Sphère card, not the Facette one).
+     */
+    private deselectActiveChildForOddInteraction;
+    /**
+     * Called by YinYangDrawer when the user clicks an ODD arc. Mirrors a click
+     * on that ODD's legend chip in the panel: toggles its description open/
+     * closed under whatever is already displayed (sphère/facette/satellite),
+     * mirrors the resulting open/closed state onto the global circle's own arc
+     * (never a satellite's own arc style, which stays owned entirely by
+     * satellite-click interactions — see the isChild guard in YinYangDrawer),
+     * and highlights (as a whole, not via their own arc) the satellites that
+     * belong to this ODD. Also deselects any satellite whose action menu was
+     * open, since browsing the facette-level ODD legend and drilling into a
+     * satellite are mutually exclusive.
+     */
+    onDiagramOddArcClicked(oddId: string): void;
+    setOddContextLabelsVisible(isVisible: boolean): void;
+    setAllLabelsVisible(isVisible: boolean): void;
+    setOddLabelsCompact(compact: boolean): void;
+    setChildActionMenuItemDistance(distance: number): void;
+    setChildActionMenuItemScale(scale: number): void;
+    setChildActionIconFontScale(scale: number): void;
+    setCoreEventMenuDistanceOffset(offset: number): void;
+    setCoreEventMenuItemScale(scale: number): void;
+    setCoreEventIconFontScale(scale: number): void;
+    setChildLabelMaxLines(lines: number): void;
+    setLabelShortMaxChars(chars: number): void;
+    setOddLabelMaxLines(lines: number): void;
+    private startChildrenOrbit;
+    private stopChildrenOrbit;
+    private buildChildrenOrbitData;
+    private applyChildrenOrbitTransforms;
+    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;
+    /** Anime un point rouge vif traversant `waypoints` en séquence segment par
+     *  segment. `onWaypointArrival` est appelé à chaque arrivée (sauf la source).
+     *  `onSegmentStart` est appelé au début de chaque segment (utile pour pulser
+     *  le lien force-field correspondant). */
+    private _animatePropagationArc;
+    private getCurrentComponent;
+    private getCurrentComponentOrUndefined;
+    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;
+    /**
+     * 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;
+    private removeOppositeChildrenForceField;
     /**
      * Initializes animations for this instance and sets up event listeners for clicks.
      * Rotations are reverted on click events.
      */
     InitializeAnimations(): void;
+    highlightOddInChildren(oddId: string | null): void;
+    highlightOddByStackItemId(stackItemId: string | null): void;
+    /**
+     * Retourne les actions applicables au cutting associé à `childKey`,
+     * en consultant `yasuniCause` 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.
+     *
+     * 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).
+     */
+    debugInsertAdverseActions(count: number): void;
 }
+export {};