@micheeeeel/yinyangapp 2.5.1 → 2.6.0

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

@@ -0,0 +1,80 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ActionStackItem } from "../action-stack/ActionStackController";
+import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
+import { ForceFieldRenderer } from "../force-field/ForceFieldRenderer";
+import { EventFieldRenderer } from "../force-field/EventFieldRenderer";
+import { ForceFieldLinkDetail } from "../force-field/types";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import { IncomingForceFieldService } from "../force-field/IncomingForceFieldService";
+import { ForceFieldDetailsPresenter } from "../force-field/ForceFieldDetailsPresenter";
+import { DiagramNavigator } from "../navigation/DiagramNavigator";
+import { KeyEventController } from "../actions/KeyEventController";
+import { ComponentTitlePresenter } from "../labels/ComponentTitlePresenter";
+import { PropagationAnimator } from "../force-field/PropagationAnimator";
+import { ControllerSession } from "../state/ControllerSession";
+import { EventFieldLifecycleController } from "../force-field/EventFieldLifecycleController";
+import { ActionStackManager } from "../action-stack/ActionStackManager";
+export type ComponentSwitchCoordinatorDeps = {
+    actionStackManager: ActionStackManager;
+    activateActionFromChild: (childController: IYinYangController, actionId?: string, label?: string, clearStack?: boolean) => void;
+    applyEmptyGhostProjectionState: () => void;
+    applyEnterOddView: (oddId: string) => void;
+    applyOddHighlight: (oddId: string) => void;
+    applyProjectedGhostFromStackItems: (items: ActionStackItem[]) => void;
+    buildChildrenOrbitData: () => ChildrenOrbitEntry[];
+    getChildControllers: () => IYinYangController[];
+    childOddMap: Map<string, {
+        oddId: string;
+        score: number;
+        cuttingIndex: number;
+    }>;
+    clearActiveChild: () => void;
+    clearChildren: () => void;
+    createYinYangChildren: () => void;
+    detailsPresenter: ForceFieldDetailsPresenter;
+    disableOuterSpark: () => void;
+    eventFieldLifecycleController: EventFieldLifecycleController;
+    eventFieldRenderer: EventFieldRenderer;
+    focusChildByOddCutting: (oddId: string, cuttingIndex: number, forceOpen?: boolean) => void;
+    focusChildByOddCuttingAndAction: (oddId: string, cuttingIndex: number, actionId: string) => void;
+    forceFieldDetailsPanel: ForceFieldDetailsPanel;
+    forceFieldRenderer: ForceFieldRenderer;
+    getAllComponents: () => YinYangInternalModel["components"];
+    getCurrentComponent: () => YinYangInternalModel["components"][number] | null;
+    getCurrentComponentOrUndefined: () => YinYangInternalModel["components"][number] | undefined;
+    incomingForceField: IncomingForceFieldService;
+    keyEvents: KeyEventController;
+    navigator: DiagramNavigator;
+    propagationAnimator: PropagationAnimator;
+    renderOppositeChildrenForceField: (orbitData?: ChildrenOrbitEntry[], angleOffset?: number) => void;
+    session: ControllerSession;
+    state: YinYangControllerState;
+    syncGhostTensionFromAction: () => void;
+    titlePresenter: ComponentTitlePresenter;
+    view: IYinYangView;
+};
+/** Changement de facette : prépare le contexte (action à réactiver, champ
+ *  entrant, navigation en attente) avant de masquer les satellites, puis le
+ *  rejoue à l'arrivée une fois les nouveaux satellites créés. */
+export declare class ComponentSwitchCoordinator {
+    private deps;
+    constructor(deps: ComponentSwitchCoordinatorDeps);
+    prepareForComponentSwitch(targetComponentId: string): void;
+    handleComponentSwitchChildren(): void;
+    refreshChildrenForComponentSwitch(): Promise<void>;
+    restoreIncomingForceFieldContext(context: {
+        type: "incoming";
+        sourceComponentId: string;
+        linksByOddId: Map<string, {
+            toOddId: string;
+            thickness: number;
+            potentialGain: number;
+            detail: ForceFieldLinkDetail;
+            sourceOriginKey?: string;
+        }>;
+    }): void;
+    private reactivatePersistentAction;
+}

package/dist/types/components/controller/debug/ControllerDebugTools.d.ts

@@ -0,0 +1,81 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { type ActionDefinition } from "../../../data/yasuni_actions";
+import { ActionStackController } from "../action-stack/ActionStackController";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import type { ControllerUiCallbacks } from "../state/ControllerUiCallbacks";
+export type ControllerDebugToolsDeps = {
+    actionStackController: ActionStackController;
+    getChildControllers: () => IYinYangController[];
+    disableOuterSpark: () => void;
+    getActionsForChild: (childKey: string, filter?: "mode" | "playable" | "adverse" | "all") => ActionDefinition[];
+    setChildrenEnabled: (isEnabled: boolean) => void;
+    state: YinYangControllerState;
+    ui: ControllerUiCallbacks;
+    validateActionSelection: (childController: IYinYangController, actionId: string, label: string, insertAtVisibleIndex?: number | null, entryOrigin?: {
+        x: number;
+        y: number;
+    }) => void;
+    view: IYinYangView;
+};
+/** Outils de développement (boutons dev du panneau de contrôle) : remplissage
+ *  aléatoire de la pile, insertion d'actions adverses, étincelles. */
+export declare class ControllerDebugTools {
+    private deps;
+    constructor(deps: ControllerDebugToolsDeps);
+    /**
+     * 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;
+    /** 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;
+    /**
+     * 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;
+}

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

@@ -1,15 +1,7 @@
-import { type PropagatedActionEdge } from "../../../utils/actionPropagation";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
-import { CauseGraph } from "../../../interfaces/ICauseGraph";
-import { PropagationLayersConfig } from "../../../interfaces/IPropagationLayers";
+import type { CompiledPropagationGraph } from "../../../interfaces/IPropagationGraph";
 import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
 import { ForceFieldLink, ForceFieldLinkDetail } from "./types";
-/** Single source of truth for turning a raw propagation edge into the
- *  enriched ForceFieldLinkDetail the UI consumes (rationale, layer
- *  summaries…) — shared by build(), buildFromSource(), and any other caller
- *  that needs to map edges from computeActionPropagationDetails/
- *  propagateForceFieldActionInComponent without re-deriving this metadata. */
-export declare function mapPropagatedEdgeToDetail(edge: PropagatedActionEdge, componentId: string): ForceFieldLinkDetail;
 export declare class ForceFieldComputationService {
     build(params: {
         orbitData: ChildrenOrbitEntry[];
@@ -22,9 +14,7 @@ export declare class ForceFieldComputationService {
         component: YinYangInternalModel["components"][number] | null;
         allComponents: YinYangInternalModel["components"] | undefined;
         actionDelta: number;
-        actionPropagationFactor: number;
-        interconnectionGraph: CauseGraph;
-        propagationLayers: PropagationLayersConfig;
+        propagationGraph: CompiledPropagationGraph;
     }): {
         links: ForceFieldLink[];
         allLinkDetails: ForceFieldLinkDetail[];
@@ -40,9 +30,7 @@ export declare class ForceFieldComputationService {
         component: YinYangInternalModel["components"][number];
         allComponents: YinYangInternalModel["components"] | undefined;
         actionDelta: number;
-        actionPropagationFactor: number;
-        interconnectionGraph: CauseGraph;
-        propagationLayers: PropagationLayersConfig;
+        propagationGraph: CompiledPropagationGraph;
     }): {
         links: ForceFieldLink[];
         allLinkDetails: ForceFieldLinkDetail[];

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

@@ -1,6 +1,8 @@
+import { type CometPlayFn } from "./propagation-viz/propagationVizLists";
 import { YinYangComponentNode, YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { ForceFieldLink, ForceFieldLinkDetail } from "./types";
 import type { ComboResult } from "../../../data/combo-engine";
+import { type AbsorptionBreakdown, type ActiveShield } from "./shieldViewModel";
 import type { AmplifierResult, AmplifierTargetBreakdown } from "../../../data/amplifier-engine";
 import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
 import type { Composante, ODD } from "../../../data/yasuni_cause";
@@ -23,6 +25,9 @@ type ActionCumulativeBlockViewModel = {
     actionDescription: string;
     sourceComponentName?: string;
     sourceOddName?: string;
+    /** Facette du satellite qui porte l'action (peut différer de la facette
+     *  affichée pour un bloc de propagation). */
+    sourceComponentId?: string;
     sourceOddId: string;
     sourceCuttingId: number | undefined;
     totalDelta: number;
@@ -43,10 +48,23 @@ type ActionCumulativeBlockViewModel = {
     stackItemId?: string;
     color?: string;
     sequentialDetailPool?: ForceFieldLinkDetail[];
+    /** Arrivées de la seule résolution de ce bloc (PROP-VIZ-01). */
+    resolutionPool?: 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;
+    /** Bouclier de stabilité déjà actif sur le satellite en focus au moment
+     *  où ce bloc s'est résolu (type "source" uniquement — l'action vise ce
+     *  satellite). Voir shieldViewModel.ts. */
+    activeShield?: ActiveShield;
+    /** Bouclier que cette action crée elle-même (slots de stabilisation
+     *  déclenchés), à confronter à activeShield. */
+    createdShield?: number;
+    /** Réduction appliquée par le bouclier du satellite en focus à la
+     *  contribution négative de ce bloc — direct, propagé, agrégé, absorbé,
+     *  appliqué (journal de résolution). */
+    shieldAbsorption?: AbsorptionBreakdown;
 };
 /** Bloc "keyEvent" : un Événement Clé joué, toujours affiché dès que sa
  *  Facette d'origine correspond à celle affichée (voir YinYangController.
@@ -68,15 +86,24 @@ type KeyEventCumulativeBlockViewModel = {
 };
 type CumulativeBlockViewModel = ActionCumulativeBlockViewModel | KeyEventCumulativeBlockViewModel;
 export declare class ForceFieldDetailsPanel {
+    /** Même seuil que le glisser vers la pile (YinYangController). */
+    private static readonly TAG_DRAG_THRESHOLD_PX;
     private onComboHighlight?;
     private onComboClear?;
     /** Key of the currently active (clicked) combo card — persists across re-renders. */
     private activeComboCardKey;
+    /** Item de pile passé en focus alors que les barres d'une carte combo
+     *  étaient affichées : son bloc reprend les barres dès que sa carte
+     *  équivalente est rendue (voir _reanchorActiveComboCard). */
+    private _pendingComboReanchorItemId;
     /** 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?;
+    /** Called on pointerdown on an action rule tag / prereq name: lets the
+     *  controller start a drag of that action toward the stack. */
+    private onActionTagDragStart?;
     /** Cached propagation index, invalidated when force-field data changes. */
     private _cachedPropagationIndex;
     /** When non-null, clearForceFieldDetails is a no-op (panel frozen during component switch). */
@@ -125,6 +152,7 @@ export declare class ForceFieldDetailsPanel {
     private _onStackItemHighlightCb?;
     /** Clic sur l'en-tête d'un bloc → action en focus (YinYangController). */
     private _onStackItemFocusCb?;
+    private _onShieldOriginClickCb?;
     /** Miroir de state.forceField.focusedStackItemId — sert uniquement à
      *  ré-appliquer .ff-block--focused après chaque innerHTML. */
     private _focusedStackItemId;
@@ -154,6 +182,7 @@ export declare class ForceFieldDetailsPanel {
     setSphereInfo(name: string, description: string): void;
     setActionNameResolver(resolver: (id: string) => string): void;
     setActionTagClickCallback(cb: (actionId: string, comboContext?: ActionTagComboContext) => void): void;
+    setActionTagDragStartCallback(cb: (actionId: string, comboContext: ActionTagComboContext | undefined, event: PointerEvent, el: HTMLElement) => void): void;
     /**
      * Enregistre les callbacks de surlignage combo.
      * Doit être appelé une seule fois depuis YinYangController après instanciation.
@@ -169,6 +198,14 @@ export declare class ForceFieldDetailsPanel {
      *  même clé via data-keyevent-item-id : deux éléments DOM, un seul bloc
      *  logique). */
     private _getCardKey;
+    /** Clé de la carte dont les barres sont affichées : _getCardKey plus
+     *  l'item de pile porteur, car la même action présente deux fois dans la
+     *  pile a deux cartes combo de même contenu mais d'ancres différentes. */
+    private _getHighlightCardKey;
+    /** Titre de carte, gabarit commun à toutes les cartes du rail : étiquette
+     *  de type facultative (couleur --card-accent de la carte) puis nom
+     *  lisible — l'information principale à lire. */
+    private _cardTitleHtml;
     /** 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,
@@ -342,6 +379,47 @@ export declare class ForceFieldDetailsPanel {
      * _attachComboHighlightHandlers) couvrent déjà les attributs data-keyevent-*.
      */
     private _buildKeyEventBlockHtml;
+    /** Contenu d'origine des cartes combo mises en aperçu par
+     *  previewComboCardsForItem — restauré tel quel (nœuds et gestionnaires
+     *  compris) quand l'aperçu s'arrête. */
+    private _comboPreviewOriginals;
+    /**
+     * Aperçu en direct, pendant le glisser guidé d'un prérequis, des cartes
+     * combo de l'item `stackItemId` : `comboResults` est le résultat que
+     * donnerait le dépôt à l'emplacement survolé. Seul le contenu sous la
+     * description (héro, note bouclier, tableau, conseil) est remplacé ; null
+     * restaure le contenu d'origine (hors zone de dépôt, fin du glisser).
+     */
+    previewComboCardsForItem(stackItemId: string, comboResults: ComboResult[] | null): void;
+    /**
+     * Carte combo d'une action qui n'est pas encore dans la pile (mode
+     * Recherche) : l'activation dépend de la position de l'action et de l'ordre
+     * de ses prérequis, inconnus tant qu'elle n'est pas placée. On n'affiche
+     * donc pas de résultat (bouclier créé, bonus effectif) — seulement le
+     * potentiel du combo, le tableau des prérequis (présents ou non dans la
+     * pile, Perf./Pos./Score projetés pour un dépôt en haut de pile) et un
+     * renvoi vers le mode Stack.
+     *
+     * Une sécurisation y est évaluée protecteurs supposés joués (×1, voir
+     * ActionStackManager.computeComboResultsForAction) pour laisser voir la
+     * propagation : la carte le dit, et prévient que la pile, elle, ne le
+     * supposera pas.
+     */
+    private _buildComboOutsideStackHtml;
+    /** Sécurisation hors pile, protecteurs supposés joués : risque neutralisé
+     *  (±0 %) et tableau des protecteurs marqués « supposé joué ».
+     *  L'avertissement vit sous le bloc (_buildAssumedProtectionNoteHtml). */
+    private _buildAssumedProtectionHtml;
+    /** Avertissement placé sous le bloc de l'action (après le rail de cartes)
+     *  quand une sécurisation y est évaluée protecteurs supposés joués : la
+     *  pile, elle, ne le supposera pas. Vide sinon. */
+    private _buildAssumedProtectionNoteHtml;
+    /**
+     * Tableau de répartition par prérequis/protecteur (Perf., Pos., Score avec
+     * mini-barre) — partagé par la carte combo en pile et hors pile (RECHERCHE,
+     * où les valeurs projettent un dépôt de l'action en haut de la pile).
+     */
+    private _buildPrereqTableHtml;
     /**
      * Construit le bloc de détail d'un combo : valeur héro (multiplicateur
      * effectif), tableau de répartition par prérequis/protecteur (avec
@@ -362,6 +440,14 @@ export declare class ForceFieldDetailsPanel {
      *  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;
+    /** Note « bouclier » de la carte bilan : bouclier actif sur le satellite
+     *  et, dans le journal de résolution, la réduction réellement appliquée
+     *  (direct, propagé, agrégé, absorbé, appliqué). Vide sans bouclier. */
+    private _buildShieldNoteHtml;
+    /** Carte « Bouclier » : maillon additif entre les modificateurs et le
+     *  Bilan — badge = points absorbés, donc delta avant bouclier + badge =
+     *  Bilan. Vide quand le bouclier n'a rien réduit dans ce bloc. */
+    private _buildShieldCardHtml;
     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)
@@ -386,19 +472,6 @@ export declare class ForceFieldDetailsPanel {
      *  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;
     /**
@@ -416,52 +489,30 @@ export declare class ForceFieldDetailsPanel {
     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;
+    /** Nom d'un satellite résolu dans sa facette (`componentId`), à défaut
+     *  dans la facette affichée. */
+    /** Lecteur de la comète des listes Source / Bilan (PROP-VIZ-01). */
+    private _cometPlay;
+    /** Arrivées de la résolution de chaque item de pile dont un bloc est
+     *  affiché (celles que lisent ses listes Source / Bilan) : la boucle de
+     *  l'action en focus y lit ses trajets, pour suivre exactement les mêmes. */
+    private _stackItemResolutionPools;
+    getStackItemResolutionPool(stackItemId: string): readonly ForceFieldLinkDetail[] | undefined;
+    setPropagationCometPlayer(play: CometPlayFn): void;
+    /** Constructeur des listes Source / Bilan d'un rendu : noms des
+     *  satellites, réticules de navigation et lecteur de comète. */
+    private _createVizLists;
+    private _satelliteName;
     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;
@@ -470,11 +521,6 @@ export declare class ForceFieldDetailsPanel {
         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[];
@@ -486,8 +532,18 @@ export declare class ForceFieldDetailsPanel {
      *  item de pile (le satellite/la facette porteuse est sélectionné). */
     hasBlockForStackItem(stackItemId: string): boolean;
     setStackItemFocusCallback(cb: (id: string | null) => void): void;
+    /** Clic sur le nom de l'action d'origine dans une carte Bouclier. */
+    setShieldOriginClickCallback(cb: (stackItemId: string) => void): void;
     /** Miroir du focus (source de vérité : YinYangController / state). */
     setFocusedStackItemId(id: string | null): void;
+    /**
+     * Si les barres affichées sont celles d'une carte combo d'un autre item,
+     * active à sa place la carte de même combo portée par `stackItemId` (même
+     * _getCardKey, ancre différente) et rejoue les barres. Retourne true si la
+     * demande est réglée (carte basculée, ou rien à faire), false si la carte
+     * équivalente n'est pas (encore) dans le DOM.
+     */
+    private _reanchorActiveComboCard;
     /**
      * Ré-applique .ff-block--focused sur le bloc en focus — à appeler après
      * chaque rendu de blocs (innerHTML), comme _consumePendingBlockScroll.
@@ -637,11 +693,10 @@ export declare class ForceFieldDetailsPanel {
         comboResults?: ComboResult[];
         amplifierResults?: AmplifierResult[];
         stackItemId?: string;
-        onCardElementFlash?: (targets: Array<{
-            oddId: string;
-            cuttingId: number | undefined;
-            componentId?: string;
-        }>) => void;
+        /** Bouclier de stabilité déjà actif sur le satellite ciblé (posé par
+         *  une action antérieure de la pile) — affiché sur la carte bilan et
+         *  confronté au bouclier qu'une stabilisation prévisualisée créerait. */
+        activeShield?: ActiveShield;
         onNavigateToCutting?: (toOddId: string, toCuttingId: number | undefined, toComponentId: string | undefined) => void;
         onNavigateToAction?: (actionId: string) => void;
     }): {
@@ -658,11 +713,6 @@ export declare class ForceFieldDetailsPanel {
         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;
@@ -671,6 +721,9 @@ export declare class ForceFieldDetailsPanel {
         incomingMode?: boolean;
         incomingSourceName?: string;
         currentComponent?: YinYangComponentNode;
+        /** Toutes les composantes : nomme les satellites atteints dans une autre
+         *  facette que celle affichée. */
+        allComponents?: YinYangComponentNode[];
         actionId?: string;
         actionName?: string;
         actionDescription?: string;
@@ -680,10 +733,11 @@ export declare class ForceFieldDetailsPanel {
         html: string;
         attachHandlers: (container: HTMLElement) => void;
     } | null;
-    /** Attaches the standard card↔table click handler used by detail panels with a disclosure table. */
+    /** Clics des panneaux à tableau de détail : repli des cartes, lien
+     *  « pourquoi » vers le tableau et mise en évidence d'une ligne du tableau.
+     *  La comète des listes est câblée à part (PropagationVizLists.attach). */
     private _attachDetailPanelClickHandler;
     private _installClickHandler;
-    private _buildMultiFlashClickHandler;
     private _attachNavBtnHandlers;
     private _attachPrereqNavHandlers;
 }