@micheeeeel/yinyangapp 1.0.5 → 2.0.0

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

@@ -0,0 +1,639 @@
+import { YinYangComponentNode, YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ForceFieldLink, ForceFieldLinkDetail } from "./types";
+import type { ComboResult } from "../../../data/combo-engine";
+import type { AmplifierResult, AmplifierTargetBreakdown } from "../../../data/amplifier-engine";
+import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
+import type { Composante, ODD } from "../../../data/yasuni_cause";
+/** Contexte combo (backward) ou amplificateur (forward) transmis au clic
+ *  d'un tag d'action, d'une ligne de prérequis, ou de la carte/du bloc. */
+type ActionTagComboContext = {
+    requires: string[];
+    withinLastN?: number;
+    type: string;
+    comboName?: string;
+    sourceItemId?: string;
+    deltaMultiplier?: number;
+    maxDeltaMultiplier?: number;
+    direction?: "forward" | "backward";
+};
+type ActionCumulativeBlockViewModel = {
+    type: "source" | "propagation";
+    actionId?: string;
+    actionName: string;
+    actionDescription: string;
+    sourceComponentName?: string;
+    sourceOddName?: string;
+    sourceOddId: string;
+    sourceCuttingId: number | undefined;
+    totalDelta: number;
+    rawDelta?: number;
+    baseDelta?: number;
+    /** Variation de poids du satellite ciblé, amplificateurs inclus — uniquement
+     *  peuplé pour type "source" (le poids ne se propage jamais), depuis
+     *  ActionDefinition.weightDelta. Affiché sur la carte bilan. */
+    weightDelta?: number;
+    /** Même variation de poids, mais avant application des amplificateurs —
+     *  affichée sur le chip de la carte source, en écho au badge de delta de
+     *  score qui montre lui aussi la valeur de base (le montant amplifié
+     *  n'apparaît que dans la carte bilan, cf. weightDelta ci-dessus). */
+    weightDeltaBase?: number;
+    detailRows: ForceFieldLinkDetail[];
+    comboResults?: ComboResult[];
+    amplifierResults?: AmplifierResult[];
+    stackItemId?: string;
+    color?: string;
+    sequentialDetailPool?: ForceFieldLinkDetail[];
+    /** Position dans la pile (ActionStackItem.slotIndex) — permet de fusionner
+     *  et trier les blocs "keyEvent" (voir ci-dessous) avec les blocs action
+     *  dans leur ordre naturel de pile. */
+    slotIndex?: number;
+};
+/** Bloc "keyEvent" : un Événement Clé joué, toujours affiché dès que sa
+ *  Facette d'origine correspond à celle affichée (voir YinYangController.
+ *  buildKeyEventBlocksForComponent) — `active` ne conditionne que le style
+ *  (voir _buildKeyEventBlockHtml), jamais l'existence du bloc. */
+type KeyEventCumulativeBlockViewModel = {
+    type: "keyEvent";
+    keyEventId: string;
+    active: boolean;
+    totalDelta: number;
+    slotIndex?: number;
+    stackItemId?: string;
+    color?: string;
+    targetedActions: Array<{
+        id: string;
+        name: string;
+    }>;
+    breakdowns?: AmplifierTargetBreakdown[];
+};
+type CumulativeBlockViewModel = ActionCumulativeBlockViewModel | KeyEventCumulativeBlockViewModel;
+export declare class ForceFieldDetailsPanel {
+    private onComboHighlight?;
+    private onComboClear?;
+    /** Key of the currently active (clicked) combo card — persists across re-renders. */
+    private activeComboCardKey;
+    /** Resolves an action ID to its display name for combo rules. Defaults to identity. */
+    private resolveActionName;
+    /** Called when the user clicks an action rule tag.
+     * Second argument is the combo context of the card containing the tag (if any). */
+    private onActionTagClick?;
+    /** Cached propagation index, invalidated when force-field data changes. */
+    private _cachedPropagationIndex;
+    /** When non-null, clearForceFieldDetails is a no-op (panel frozen during component switch). */
+    private _frozenHtml;
+    /**
+     * Persistent set of expanded card keys, for cards whose DOM position isn't
+     * stable across re-renders — combo cards (can disappear temporarily during
+     * drag preview when the slot reorder invalidates the combo condition) and
+     * Événement Clé / action adverse cards (.ff-chain-keyevent-detail,
+     * .ff-chain-keyevent-targets — their grid can shift position when a new
+     * block is inserted elsewhere in the cumulative view, see
+     * _hasStableCardKey). Keyed via _getCardKey, which already derives a
+     * content-based key for both families rather than relying on the
+     * positional pos:${gi}:${ci} key used for everything else.
+     */
+    private _expandedComboKeys;
+    /**
+     * Every _getCardKey a stable-keyed card (combo or Événement Clé/action
+     * adverse) has ever been processed under, regardless of expanded state.
+     * Distinguishes "first appearance" (key absent here) from "already seen,
+     * deliberately left collapsed" (key present but not in _expandedComboKeys)
+     * — both look identical to _expandedComboKeys alone, but only the former
+     * should default to expanded when a live-update render (a card inserted
+     * while other, already-restored cards are on screen — see
+     * _initCardRailState) has no snapshot entry for it yet.
+     */
+    private _seenCardKeys;
+    /** Timer set during a user card interaction — prevents ResizeObserver from
+     *  running _applyAutoFitToGrids while a card is animating. */
+    private _userInteractingTimer;
+    /** Set during a live-update _initCardRailState call. _applyAutoFitToGrids skips
+     *  this container until the timer fires (covering both the initial DOM-insertion
+     *  resize and the gs-block-open animation resize that follows). */
+    private _suppressAutoFitContainer;
+    private _suppressAutoFitTimer;
+    /** Top-level sphere name & description shown in the empty (nothing-selected) state. */
+    private _sphereName;
+    /** Per-render registry mapping navKey → onNavigateToSource callback for source card steps. */
+    private readonly _sourceNavCallbacks;
+    /** Monotonic counter to generate unique nav keys per render. */
+    private _sourceNavCounter;
+    private _sphereDescription;
+    /** Called on hover enter/leave over a navigable step — used to highlight the corresponding diagram element. */
+    private _onDiagramElementHover?;
+    /** Called when hovering a cumulative block — notifies the stack to highlight the matching item. */
+    private _onStackItemHighlightCb?;
+    /** Id d'un bloc "Effets cumulés" à centrer (scroll animé) dès qu'il apparaît
+     *  dans le panneau — voir requestScrollToStackItemBlock. Le rendu déclencheur
+     *  (renderComposanteInfo / renderCumulativeActionDetails) peut survenir de
+     *  façon asynchrone après la demande (ouverture animée du satellite). */
+    private _pendingBlockScrollStackItemId;
+    private _pendingBlockScrollTimeout;
+    /** Notifie le header (chip STACK) du badge + nom de l'élément affiché par les
+     *  cartes d'info minimales (Sphère, ODD) — ces cartes ne répètent plus ce
+     *  titre dans leur corps. Facette et Satellite restent gérés par leurs
+     *  mécanismes dédiés existants (voir renderComposanteInfo/renderCuttingInfo). */
+    private _onHeaderUpdate?;
+    setOnHeaderUpdate(cb: (badge: {
+        label: string;
+        cssClass: string;
+    } | undefined, name: string | undefined) => void): void;
+    setSphereInfo(name: string, description: string): void;
+    setActionNameResolver(resolver: (id: string) => string): void;
+    setActionTagClickCallback(cb: (actionId: string, comboContext?: ActionTagComboContext) => void): void;
+    /**
+     * Enregistre les callbacks de surlignage combo.
+     * Doit être appelé une seule fois depuis YinYangController après instanciation.
+     */
+    setOnDiagramElementHover(cb: ((target: {
+        oddId: string;
+        cuttingId: number | undefined;
+        componentId?: string;
+    } | null) => void) | undefined): void;
+    setComboHighlightCallbacks(onHighlight: (params: ActionTagComboContext) => void, onClear: () => void): void;
+    /** Clé stable identifiant la carte/le bloc pour le suivi "actif" — combo,
+     *  ou Événement Clé (carte événement ET carte actions ciblées partagent la
+     *  même clé via data-keyevent-item-id : deux éléments DOM, un seul bloc
+     *  logique). */
+    private _getCardKey;
+    /** True pour une carte dont l'état déplié/replié doit être suivi via
+     *  _getCardKey (contenu) plutôt que via sa position dans la grid — combo,
+     *  ou Événement Clé/action adverse (.ff-chain-keyevent-detail,
+     *  .ff-chain-keyevent-targets). Sans ça, une carte ainsi insérée au milieu
+     *  d'une vue cumulative déjà rendue (ex. : valider un Événement Clé pendant
+     *  que d'autres blocs sont affichés) déciderait son repli/dépli sur une clé
+     *  positionnelle pos:${gi}:${ci} décalée par l'insertion — potentiellement
+     *  celle d'une tout autre carte, ou une position absente du snapshot
+     *  précédent, ce qui la replierait par défaut au lieu de suivre l'auto-fit. */
+    private _hasStableCardKey;
+    /** Un clic "replier" (par opposition à un clic qui ouvre/surligne) — sur le
+     *  badge delta habituel, ou sur le header pour une carte qui n'en a plus :
+     *  la carte source Événement Clé n'a aucun delta à elle (celui de l'effet
+     *  vit désormais uniquement sur la carte "Actions amplifiées" sœur), donc
+     *  aucun badge à cliquer — le header sert de poignée de repli à sa place. */
+    private _isCardCollapseTrigger;
+    private _attachComboHighlightHandlers;
+    /** Contexte combo (backward) ou amplificateur (forward) déduit de
+     *  l'ancêtre le plus proche de `el` — même forme pour un clic sur un tag
+     *  de règle, une ligne de prérequis, ou la carte/le bloc entier.
+     *  `undefined` si `el` ne vit dans aucune carte combo/Événement Clé (ex.
+     *  tag de règle dans une description hors contexte). */
+    private _extractTagComboContext;
+    private _buildComboSectionHtml;
+    /**
+     * Média d'une carte Événement Clé : l'illustration si l'événement est
+     * débloqué, sinon un cartouche verrouillé. Voir isKeyEventUnlocked —
+     * le verrou simule la progression de l'aventure, absente du POC, et évite
+     * surtout d'afficher une image cassée pour les événements pas encore
+     * illustrés. Le cartouche ne porte ni data-full-src ni .ff-zoom-thumb :
+     * pas de modale HD à ouvrir sur une image qui n'existe pas.
+     */
+    private _buildKeyEventMediaHtml;
+    /**
+     * Construit la (les) carte(s) "amplificateur" — un Événement Clé actif qui
+     * renforce le delta effectif de cette action (bonus additif en points, voir
+     * amplifier-engine.ts). Contrairement à une carte combo, elle affiche
+     * l'illustration de l'ÉVÉNEMENT (pas de l'action) et se relie au reste du
+     * rail par un connecteur "⚡" plutôt que "⊕", pour signaler un renfort
+     * événementiel plutôt qu'une synergie entre actions.
+     *
+     * Description et coefficients sont EN SURIMPRESSION sur l'illustration
+     * (.ff-card-steps-overlay), comme sur une carte action illustrée : posés à
+     * côté, ils amputaient le cadre de l'image, qui ne pouvait alors plus la
+     * montrer entière (voir --ff-card-image-ratio).
+     */
+    private _buildAmplifierSectionHtml;
+    /**
+     * Carte descriptive autonome d'un Événement Clé — affichée dans le
+     * panneau Recherche quand l'utilisateur prévisualise l'événement lui-même
+     * (1er clic sur une bulle du menu radial du cercle central), pas quand il
+     * amplifie une action (voir _buildAmplifierSectionHtml pour cette carte-là).
+     * Reprend délibérément le langage visuel de la carte action "source" (voir
+     * _renderChainCardHtml/isSourceCard) — illustration plein cadre — mais SANS
+     * badge de score ni chip de poids : ce sont des deltas d'effet différé, ils
+     * ne vivent que sur la carte "Actions amplifiées" sœur
+     * (_buildDelayedTargetsCardHtml), pas ici, pour ne pas dupliquer la même
+     * valeur sur deux cartes. N'ayant plus aucune valeur à porter, cette carte
+     * n'a pas de badge du tout (pas de bouton vide) — le header sert de
+     * poignée de repli à sa place (voir _isCardCollapseTrigger). Jamais de
+     * section combo ni de carte Bilan, l'événement n'a pas de delta propre.
+     * Repliable comme n'importe quelle carte de la famille — priorité
+     * d'expansion maximale dans l'auto-fit du rail (première carte non-combo,
+     * voir _applyAutoFitToGrids), donc repliée seulement si l'espace manque
+     * vraiment.
+     *
+     * La liste des Actions amplifiées vit dans une SECONDE carte du même rail
+     * (.ff-chain-keyevent-targets, voir _buildDelayedTargetsCardHtml), séparée
+     * par un .ff-chain-separator — même traitement qu'un bloc combo/amplificateur
+     * vis-à-vis de sa carte source, pour que ce bloc-ci ne fasse pas exception.
+     * Même gabarit standard que le reste de la famille de cartes — les noms
+     * d'action y passent à la ligne plutôt que d'exiger une largeur
+     * dérogatoire.
+     */
+    buildKeyEventCardHtml(params: {
+        keyEvent: KeyEventDefinition;
+        targetedActions: Array<{
+            id: string;
+            name: string;
+        }>;
+        /** Répartition par action ciblée (position dans la fenêtre, bonus
+         *  effectif déjà réduit) — absente en aperçu avant validation, où
+         *  l'événement n'a pas encore de slot depuis lequel compter une position.
+         *  Une entrée par targetedActions quand présente (voir
+         *  getAmplifierTargetBreakdown). */
+        breakdowns?: AmplifierTargetBreakdown[];
+        /** Id de l'item "keyEvent" actif dans la pile (absent en aperçu avant
+         *  validation) — active le clic "barres de gain par slot" sur la carte
+         *  et sa section d'actions ciblées (voir _attachComboHighlightHandlers),
+         *  même mécanisme que le clic sur une carte combo. */
+        sourceItemId?: string;
+        onNavigateToAction?: (actionId: string) => void;
+    }): {
+        html: string;
+        attachHandlers: (container: HTMLElement) => void;
+    };
+    /**
+     * Carte "actions ciblées" d'une source d'effet différé — la liste des
+     * actions qu'un Événement Clé amplifie ("Actions amplifiées") ou qu'une
+     * action adverse entrave ("Actions entravées"), avec pour chacune le seul
+     * delta AJOUTÉ (ou retiré) par l'effet — pas le résultat final combiné au
+     * delta de base de l'action, qui deviendrait faux dès qu'un combo entre
+     * en jeu ailleurs sur la même action. Même grammaire que la chip de bonus
+     * de la carte Événement Clé sœur (buildKeyEventChipsHtml) : rester simple
+     * et lisible plutôt que reconstituer un calcul complet ici.
+     *
+     * Le bonus du catalogue est le PLAFOND — atteint seulement quand l'action
+     * est jouée au pic de la fenêtre. Une fois la source placée (breakdowns
+     * disponibles), chaque ligne affiche le bonus EFFECTIF (réduit selon la
+     * position) plutôt que ce plafond nominal — sinon la chip mentirait sur ce
+     * que l'action rapporte réellement. Sans breakdowns, le plafond reste la
+     * meilleure estimation disponible.
+     *
+     * Porte le même jeu d'attributs data-keyevent-* que la carte source
+     * (Événement Clé ou action adverse) pour que _attachComboHighlightHandlers
+     * et _extractTagComboContext y lisent la fenêtre "en avant" : un clic
+     * affiche les barres de gain par slot pour toute la fenêtre withinNextN.
+     *
+     * Badge et tableau repris à l'identique du gabarit carte combo (voir
+     * _buildComboSectionHtml/_buildPrereqBreakdownHtml) plutôt qu'un format ad
+     * hoc : le badge affiche le bonus/malus plafond du catalogue, accompagné
+     * d'un chip de poids (même paire badge+chip que portait la carte source
+     * avant que ces deltas n'emménagent ici, voir buildKeyEventCardHtml —
+     * absent si l'effet ne touche pas le poids), et le tableau réutilise les
+     * colonnes ff-pt-name/ff-pt-val de
+     * .ff-combo-prereq-table (les noms passent à la ligne plutôt que d'exiger
+     * une largeur de carte dérogatoire). Repliable comme n'importe quelle autre
+     * carte de la famille (le garde-fou qui la forçait dépliée a été retiré de
+     * _handleCardRailClick/_applyAutoFitToGrids) et précédée d'un séparateur
+     * .ff-chain-separator — même traitement que la carte source vis-à-vis d'un
+     * bloc combo/amplificateur, pour que ce bloc-ci ne fasse pas exception.
+     */
+    private _buildDelayedTargetsCardHtml;
+    /** Badge et note de provenance d'un bloc action de la vue cumulative :
+     *  propagée (depuis son satellite source), adverse (son acteur d'origine)
+     *  ou directe. */
+    private _pickActionBlockBadge;
+    /**
+     * En-tête générique et repliable d'un .ff-cumulative-block — icône, badge
+     * de type, nom, note de provenance optionnelle ("rationale"), et une
+     * valeur phare à droite (delta, coefficient…). Un seul gabarit pour tous
+     * les types de bloc (action directe/propagée, Événement Clé…) : le clic
+     * replie/déplie via le délégué déjà installé une seule fois sur le
+     * conteneur (voir getForceFieldDetailsContainer, qui toggle
+     * .ff-action-expanded sur le .ff-cumulative-block ancêtre au clic sur
+     * .ff-block-header) — aucun câblage supplémentaire à ajouter pour qu'un
+     * nouveau type de bloc devienne repliable, tant qu'il réutilise cette
+     * structure.
+     */
+    private _buildBlockHeaderHtml;
+    /**
+     * Bloc "keyEvent" de la vue cumulative (mode STACK) et de renderComposanteInfo
+     * — même structure que les blocs action (_buildBlockHeaderHtml + description
+     * courte + rail de cartes dans .ff-action-body), pour que ce bloc s'apparente
+     * visuellement au reste de la famille plutôt que de n'être qu'une carte brute.
+     * Un Événement Clé joué (kind="keyEvent" dans la pile) reste toujours visible,
+     * qu'une de ses actions ciblées soit effectivement amplifiée ou non ; seules
+     * la classe modificatrice --keyevent-active/--keyevent-inactive et la couleur
+     * du coefficient dans l'en-tête changent (voir isKeyEventCurrentlyActive côté
+     * YinYangController). attachHandlers n'est délibérément pas invoqué ici,
+     * comme pour l'aperçu (voir commentaire de buildKeyEventCardHtml) : les
+     * gestionnaires délégués au conteneur (_attachPrereqNavHandlers/
+     * _attachComboHighlightHandlers) couvrent déjà les attributs data-keyevent-*.
+     */
+    private _buildKeyEventBlockHtml;
+    /**
+     * Construit le bloc de détail d'un combo : valeur héro (multiplicateur
+     * effectif), tableau de répartition par prérequis/protecteur (avec
+     * mini-barre de remplissage sur Score), et conseil conditionnel listant
+     * les prérequis jamais joués. Structure alignée sur les cartes Absorption
+     * et Écart (state-row héro + détail + tip).
+     *
+     * Chaque ligne du tableau montre :
+     *   - Nom du prérequis (tronqué si besoin)
+     *   - Perf. : ratio effectif/base (100% = nominal)
+     *   - Pos.  : efficacité positionnelle Beta(t) (100% = position optimale)
+     *   - Score : contribution combinée Perf × Pos (avec mini-barre)
+     * Les lignes "jamais joué" (played=false) affichent "—" plutôt que des
+     * pourcentages sans signification réelle.
+     */
+    private _buildPrereqBreakdownHtml;
+    /** Ratio de performance du Bilan (% du delta nominal obtenu), généralisé aux
+     *  blocs source (combos vs baseDelta) ET propagation (Abs/Gap vs rawDelta) —
+     *  même sémantique des deux côtés, juste un nominal différent. */
+    private _computeBlockOptimizationRatio;
+    private _buildTotalCardHtml;
+    /** Delta "brut" d'une ligne de propagation, avant application d'Absorption
+     *  et Gap — sert à la fois à décomposer leur contribution (cartes Abs/Gap)
+     *  et à calculer le ratio de performance du Bilan (% du nominal obtenu). */
+    private _rawDeltaForRow;
+    /** Barre de zones générique (piste B) partagée entre Absorption et Écart :
+     *  une piste de zones colorées (largeurs fixées en CSS) + un marqueur
+     *  positionné à markerPct. Seules les classes de zones et l'échelle du
+     *  marqueur diffèrent selon la carte appelante. */
+    private _buildZoneBarHtml;
+    private _buildPropagationModifiersSectionHtml;
+    private _buildWeightInfluenceHint;
+    /**
+     * Anime tous les badges numériques d'un container après un innerHTML update.
+     * Une seule boucle rAF partagée remplace N boucles indépendantes (une par badge),
+     * ce qui évite N appels requestAnimationFrame simultanés à 60fps pendant 600ms.
+     */
+    private _animateContainerCounters;
+    private _wrapChainGrid;
+    /** Renders the same crosshair/reticle "navigate to" icon used by the action-stack
+     *  items (ActionStackController.ts, ring + 4 orthogonal ticks), as a clickable span
+     *  carrying the given nav data attributes. This is the sole navigation trigger for a
+     *  listed element — clicking the label itself now animates instead of navigating. */
+    private _buildNavTargetIconHtml;
+    /** Steps HTML for the propagation source card: one line per sortedDirect row,
+     *  each clickable to navigate back to the source satellite. */
+    private _buildPropSourceStepsHtml;
+    /** Flat list of cascade targets (satellites X sends to) for the bilan card. */
+    /** Reconstructs the forward path origin → ... → (toOddId, toCuttingId) by walking
+     *  cascadeRows backward via fromCuttingId (picking one contributing row per hop when
+     *  several exist, same simplification as _getBranchLabel's "first cascade" pick).
+     *  Used to give each cascade-list entry its own isolated flash sequence. */
+    private _buildCascadeFlashPath;
+    private _buildCascadeListHtml;
+    /** Simple chain-steps HTML from TargetChainData — used in the collapsible section
+     *  when no flash-target context is available (cumulative panel). */
+    private _buildPropChainStepsHtml;
+    private _buildDetailDisclosureHtml;
+    private _snapshotCardExpansion;
+    /**
+     * Expand all cards in a grid and measure if they fit.
+     * If they fit → keep all expanded. Otherwise → collapse all.
+     * Called on fresh mount and on ResizeObserver triggers.
+     */
+    private _applyAutoFitToGrids;
+    /**
+     * Installs a ResizeObserver on the container the first time this is called
+     * for a given container element (guard via data attribute). The observer
+     * re-runs the auto-fit measurement whenever the container changes size.
+     */
+    private _ensureResizeObserver;
+    private _initCardRailState;
+    private _handleCardRailClick;
+    private _triggerHighlightFromCard;
+    /** Maps every row within a target chain's chainCards (trigger + steps) to that card's
+     *  own flash sequence — the diagram nodes lit up when isolating just that one
+     *  propagation path (a bridge hop, an inter-ODD hop, or a pure-intra chain). Shared by
+     *  every panel that offers a "flash all paths combined" header plus a per-path,
+     *  badge-isolated flash (buildPropagatedActionHtml and renderCumulativeActionDetails). */
+    private _computeChainCardFlashes;
+    /** Builds a chain-card's final flash sequence: `source` first, then `cardFlash` in its
+     *  own (causally correct) order, deduped by node so the same satellite never flashes
+     *  twice. `target` (the currently focused satellite) is only force-inserted right after
+     *  `source` when `cardFlash` wouldn't otherwise reach it at all — e.g. an inter trigger
+     *  whose own BFS didn't resolve to this exact cutting. When `cardFlash` DOES naturally
+     *  include `target` (the common case), it's left at its true causal position instead of
+     *  being jumped to the front: for a chainCard like "Maladies de peau → Populations
+     *  exposées", forcing the focused satellite (Populations exposées) to position 2 would
+     *  make it flash *before* the intermediate ancestor that actually causes it. Shared by
+     *  every panel presenting a propagation-path flash (buildPropagatedActionHtml,
+     *  renderCumulativeActionDetails) so their animations never diverge. */
+    private _finalizeFlashSequence;
+    private _buildBranchFlashSequence;
+    private _getBranchLabel;
+    private _handleCardRailClickPrelude;
+    private _resolveDetailPool;
+    private _ensurePropagationIndex;
+    invalidatePropagationIndex(): void;
+    private static _buildTargetChainKey;
+    private static _buildSourceChainKey;
+    /** Whether this chain's own satellite is the direct target of a bridge (cross-component)
+     *  edge — an intrinsic property of the chain, independent of which upstream source is
+     *  asking. Chains only reached *indirectly* through an intermediate node that itself
+     *  received a bridge (e.g. one more intra hop downstream) don't qualify: the bridge
+     *  badge should mark the satellite the bridge actually lands on, not everything
+     *  downstream of it. */
+    private static _chainHasDirectBridgeEdge;
+    private _buildTargetChainData;
+    /** Builds one TargetChainData per distinct cutting reached within a
+     *  self-contained, single-source pool (e.g. one stack item's own
+     *  sequential-step edges) — the per-item equivalent of
+     *  propagationIndex.sourceToTargetChains, without needing the shared
+     *  cross-item index since the pool already belongs to exactly one action. */
+    private _buildBranchesFromPool;
+    private _buildDetailRowKey;
+    private _buildTargetGroupKey;
+    private _renderChainCardHtml;
+    private _selectPropagationTableViewModel;
+    private _selectCumulativeViewModel;
+    private _selectTargetChainCards;
+    renderCumulativeActionDetails(params: {
+        focusOddId: string;
+        focusCuttingId: number | undefined;
+        currentComponent?: YinYangComponentNode;
+        /** All components in the model, used to resolve cutting labels for cross-component targets. */
+        allComponents?: YinYangComponentNode[];
+        forceFieldLinks: ForceFieldLink[];
+        allForceFieldLinkDetails: ForceFieldLinkDetail[];
+        onCardElementFlash?: (targets: Array<{
+            oddId: string;
+            cuttingId: number | undefined;
+            componentId?: string;
+        }>) => void;
+        onNavigateToCutting?: (toOddId: string, toCuttingId: number | undefined, toComponentId: string | undefined) => void;
+        onNavigateToAction?: (actionId: string) => void;
+        blocks: CumulativeBlockViewModel[];
+        onNavigateToSatellite?: (oddId: string, cuttingId: number | undefined, componentId?: string) => void;
+    }): void;
+    private _attachBlockLinkedHoverHandlers;
+    setStackItemHighlightCallback(cb: (id: string | null) => void): void;
+    highlightBlockByStackItemId(id: string | null): void;
+    /**
+     * Demande de centrer (scroll animé) le bloc "Effets cumulés" de cet item de
+     * pile dès qu'il apparaît dans le panneau — déclenché par le clic sur le
+     * libellé d'un item de la pile (sélection auto du satellite/facette porteur,
+     * cf. DiagramPanelBridge.setOnSelectStackItemSatellite). Le rendu qui produit
+     * le bloc correspondant peut arriver de façon asynchrone (ouverture animée du
+     * satellite) : on retente immédiatement puis on laisse chaque prochain rendu
+     * de blocs (renderComposanteInfo / renderCumulativeActionDetails) consommer
+     * la demande via _consumePendingBlockScroll. Abandonnée après 1s si aucun
+     * bloc correspondant n'apparaît (item hors de tout bloc affiché).
+     */
+    requestScrollToStackItemBlock(stackItemId: string): void;
+    private _consumePendingBlockScroll;
+    private getTargetName;
+    private getGhostDetailsContainer;
+    private getForceFieldDetailsContainer;
+    /** Ouvre/ferme la description de cet ODD sous le descriptif actuellement
+     *  affiché (sphère/facette/satellite), comme un clic direct sur son chip
+     *  de légende. Retourne `null` si aucun chip pour cet ODD n'est visible
+     *  dans le contexte courant (no-op), sinon le nouvel état (ouvert/fermé). */
+    toggleOddLegendChipById(oddId: string): boolean | null;
+    clearGhostDetails(): void;
+    /** Freeze the panel during a component switch so clearForceFieldDetails is a no-op. */
+    freezeForSwitch(html: string): void;
+    /** Unfreeze and optionally restore the preserved HTML. */
+    unfreezeForSwitch(): void;
+    clearForceFieldDetails(): void;
+    /** Shows the sphere intro card in the empty (nothing-selected) state.
+     *  Falls back to clearing the container if no sphere info is set.
+     *  Badge + nom ne sont plus répétés ici : ils remontent au header du panneau
+     *  (chip STACK / titre de panneau RECHERCHE) via _onHeaderUpdate, à l'identique
+     *  du fonctionnement déjà en place côté RECHERCHE (setOnTitleUpdate).
+     */
+    private _renderSphereIntroOrClear;
+    /** Callback vers le diagramme quand la souris entre/sort d'un chip de la
+     *  légende ODD (lien visuel bidirectionnel — voir aussi highlightOddLegendChip
+     *  pour le sens inverse, arc du diagramme → chip). */
+    private _onOddLegendHoverCb;
+    setOddLegendHoverCallback(cb: (oddId: string | null) => void): void;
+    /** Callback vers le diagramme quand un chip de la légende ODD est
+     *  déplié/replié par un clic direct dans le panneau (sens panneau →
+     *  diagramme — voir onDiagramOddArcClicked pour le sens inverse). */
+    private _onOddLegendActiveChangeCb;
+    setOddLegendActiveChangeCallback(cb: (oddId: string, isOpen: boolean) => void): void;
+    /** Surligne (ou éteint si `oddId` est `null`) le chip de la légende ODD
+     *  correspondant à l'arc actuellement survolé dans le diagramme. */
+    highlightOddLegendChip(oddId: string | null): void;
+    /**
+     * Displays a minimal ODD info card with its parent Facette (collapsed).
+     * Called when the user clicks an ODD arc in the diagram. Badge + nom
+     * remontent au header via _onHeaderUpdate (voir _renderSphereIntroOrClear).
+     */
+    renderOddInfo(oddName: string, description?: string): void;
+    /**
+     * Displays a minimal Composante info card.
+     * Called when the user clicks the component title or a legend label — y compris
+     * une seconde fois après le rebuild post-animation d'un switch de composante, qui
+     * repasse d'abord par un clearForceFieldDetails() transitoire (état Sphère). C'est
+     * pourquoi _onHeaderUpdate est notifié ici plutôt que laissé au seul mécanisme
+     * diagramme-vers-chip : cet appel est fiablement le dernier de la séquence.
+     */
+    renderComposanteInfo(composante: Composante, keyEventBlocks?: CumulativeBlockViewModel[], onNavigateToAction?: (actionId: string) => void): void;
+    /**
+     * Displays a simple satellite info card.
+     * Used when the clicked cutting has no direct or indirect impact from the current action(s).
+     * Badge + nom ne sont pas répétés ici : notifyCuttingNavigated (déclenché par
+     * le même appelant, onCuttingLabelClick) tient déjà le chip STACK à jour.
+     */
+    renderCuttingInfo(cuttingName: string, description?: string, odd?: ODD, composanteId?: string): void;
+    /**
+     * empty placeholder), null otherwise. Used to preserve the panel across a
+     * component switch (save before children are rebuilt, restore after).
+     */
+    snapshotPanelHtml(): string | null;
+    /**
+     * Restores previously snapshotted panel HTML. The old click listener
+     * (captured in its closure) is still attached to the container from the
+     * previous render, so interactivity is fully preserved.
+     */
+    private restorePanelHtml;
+    renderGhostDetailsForActiveAction(params: {
+        isInOddMode: boolean;
+        displayingOddId?: string;
+        currentComponent?: YinYangInternalModel["components"][number];
+        projectedGhostTensionByOddId: Map<string, number> | null;
+        projectedGhostComponentTension: number | null;
+        projectedGhostCuttingStatesByOddId: Map<string, Array<{
+            cuttingId: number;
+            originalTension: number;
+            projectedTension: number;
+            originalState: number;
+            projectedState: number;
+        }>> | null;
+    }): void;
+    renderActionPropagationTable(params: {
+        forceFieldLinks: ForceFieldLink[];
+        allForceFieldLinkDetails: ForceFieldLinkDetail[];
+    }): void;
+    /**
+     * Builds only the chain-rail HTML (cards row) for a direct action on a source cutting.
+     * Used by the Recherche tab to inject the impact block inline below the cutting element.
+     * No interactive flash handlers or nav buttons are attached.
+     */
+    buildDirectActionCardsHtml(params: {
+        oddId: string;
+        cuttingId: number | undefined;
+        actionDelta: number;
+        actionBaseDelta?: number;
+        projectionDelta?: number;
+        actionId?: string;
+        actionName?: string;
+        /** Variation de poids du satellite ciblé, amplificateurs inclus — affichée
+         *  sur la carte bilan (ActionDefinition.weightDelta). */
+        weightDelta?: number;
+        /** Même variation, avant amplificateurs — affichée sur le chip de la
+         *  carte source (voir ActionCumulativeBlockViewModel.weightDeltaBase). */
+        weightDeltaBase?: number;
+        forceFieldLinks: ForceFieldLink[];
+        allForceFieldLinkDetails: ForceFieldLinkDetail[];
+        currentComponent?: YinYangComponentNode;
+        allComponents?: YinYangComponentNode[];
+        comboResults?: ComboResult[];
+        amplifierResults?: AmplifierResult[];
+        stackItemId?: string;
+        onCardElementFlash?: (targets: Array<{
+            oddId: string;
+            cuttingId: number | undefined;
+            componentId?: string;
+        }>) => void;
+        onNavigateToCutting?: (toOddId: string, toCuttingId: number | undefined, toComponentId: string | undefined) => void;
+        onNavigateToAction?: (actionId: string) => void;
+    }): {
+        html: string;
+        attachHandlers: (container: HTMLElement) => void;
+    };
+    /**
+     * Builds the full propagated-action analysis block HTML for a target cutting.
+     * Returns `{ html, attachHandlers }` so the caller (Recherche tab) can inject
+     * and wire it inline under the cutting row — identical rendering to the Analyse tab panel.
+     * Returns `null` when the link or chain data is unavailable.
+     */
+    buildPropagatedActionHtml(params: {
+        linkIndex: number;
+        forceFieldLinks: ForceFieldLink[];
+        allForceFieldLinkDetails: ForceFieldLinkDetail[];
+        onCardElementFlash?: (targets: Array<{
+            oddId: string;
+            cuttingId: number | undefined;
+            componentId?: string;
+        }>) => void;
+        onNavigateToCutting?: (toOddId: string, toCuttingId: number | undefined, toComponentId: string | undefined) => void;
+        actionSource?: {
+            oddId: string;
+            cuttingId: number | undefined;
+        };
+        incomingMode?: boolean;
+        incomingSourceName?: string;
+        currentComponent?: YinYangComponentNode;
+        actionId?: string;
+        actionName?: string;
+        actionDescription?: string;
+        sourceOddName?: string;
+        onNavigateToSatellite?: (oddId: string, cuttingId: number | undefined, componentId?: string) => void;
+    }): {
+        html: string;
+        attachHandlers: (container: HTMLElement) => void;
+    } | null;
+    /** Attaches the standard card↔table click handler used by detail panels with a disclosure table. */
+    private _attachDetailPanelClickHandler;
+    private _installClickHandler;
+    private _buildMultiFlashClickHandler;
+    private _attachNavBtnHandlers;
+    private _attachPrereqNavHandlers;
+}
+export {};