@micheeeeel/yinyangapp 2.5.0 → 2.6.0

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

@@ -1,26 +1,43 @@
+import type { PropagationScope } from "../../../interfaces/IPropagationGraph";
+/**
+ * Une arrivée de propagation prête pour l'affichage : un saut du graphe
+ * unifié, d'un satellite à un autre, issu d'une résolution précise.
+ *
+ * Identité (PROP-GRAPH-04) : `edgeId` est unique dans tout ensemble de
+ * lignes affichées, même après filtrage, transformation ou fusion de
+ * plusieurs actions de la pile ; `parentEdgeId` désigne l'arrivée qui a
+ * porté le budget de ce saut. Ensemble, ils forment l'arbre des arrivées
+ * (voir propagationTree.ts) : embranchements, convergences et retours
+ * cycliques s'y lisent sans cas particulier. Deux actions qui produisent la
+ * même relation gardent des identités distinctes (`resolutionId`).
+ */
 export type ForceFieldLinkDetail = {
+    /** Résolution d'origine : un bloc de pile, ou le satellite source d'un
+     *  champ de force. Toutes les arêtes d'une résolution le partagent. */
+    resolutionId: string;
+    edgeId: string;
+    /** Absent pour une sortie du point de départ de la résolution. Peut
+     *  désigner une arrivée absente des lignes affichées (sautée dans une autre
+     *  facette) : la ligne est alors une racine pour cet affichage. */
+    parentEdgeId?: string;
+    scope: PropagationScope;
     fromComponentId: string;
     toComponentId: string;
     fromOddId: string;
     toOddId: string;
-    fromCuttingId?: number;
-    toCuttingId?: number;
+    fromCuttingId: number;
+    toCuttingId: number;
     baseDelta: number;
     weight: number;
     strategicWeight: number;
-    layerType: "inter" | "intra" | "bridge";
-    propagationFactor: number;
     absorption: number;
     gap: number;
     fromState: number;
     toState: number;
     deltaTo: number;
     rationale?: string;
-    /** Entry cutting in the target ODD's intra chain (from yasuniInterconnectionGraph edge). */
-    targetedCutting?: number;
-    layersInvolved: string[];
-    localLayerWeights: string | null;
-    bridgeLayerWeights: string | null;
+    /** Chemin causal de l'arrivée (PropagatedActionEdge.path). */
+    path?: readonly string[];
 };
 export type ForceFieldLink = {
     startIndex?: number;
@@ -29,7 +46,8 @@ export type ForceFieldLink = {
     targetComponentId?: string;
     thickness: number;
     potentialGain: number;
-    /** Delay before revealing this link, used for chained intra-ODD propagation. */
+    /** Delay before revealing this link: its depth in the arrival tree times the
+     *  reveal step, whatever its scope. */
     revealDelayMs?: number;
     /** Index orbital du satellite source racine ayant produit ce lien (posé par
      *  ForceFieldComputationService.build, un appel par source). Pour un segment
@@ -56,3 +74,12 @@ export declare function buildSourceOriginKey(componentId: string, oddId: string,
  * sans impacter la logique de propagation.
  */
 export type ForceFieldSegment = Omit<ForceFieldLink, "detail">;
+/**
+ * Clé d'une entrée de liens entrants (contexte "incoming" d'un changement de
+ * facette) : l'identité de l'arrivée elle-même (PROP-GRAPH-04). Deux
+ * arrivées distinctes — autre action, autre satellite de départ, autre
+ * satellite cible, autre chemin — restent deux entrées, sans qu'aucune ne
+ * soit écartée au profit de la plus forte ; une même arrivée vue deux fois
+ * (état courant et recalcul) n'en fait qu'une.
+ */
+export declare function buildIncomingLinkKey(detail: Pick<ForceFieldLinkDetail, "edgeId">): string;

package/dist/types/components/controller/labels/ComponentTitlePresenter.d.ts

@@ -0,0 +1,99 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import { ControllerSession } from "../state/ControllerSession";
+import { ChildScoresDeltaRenderer } from "./ChildScoresDeltaRenderer";
+import { WeightPreviewRingRenderer } from "./WeightPreviewRingRenderer";
+import { ContextLabelsRenderer } from "./ContextLabelsRenderer";
+import { ActionStackManager } from "../action-stack/ActionStackManager";
+import type { CumulativeBlock } from "../types";
+export type ComponentTitlePresenterDeps = {
+    actionStackManager: ActionStackManager;
+    buildChildrenOrbitData: () => ChildrenOrbitEntry[];
+    buildKeyEventBlocksForComponent: (component: {
+        id: string;
+    }) => CumulativeBlock[];
+    childOddMap: Map<string, {
+        oddId: string;
+        score: number;
+        cuttingIndex: number;
+    }>;
+    childScoresDeltaRenderer: ChildScoresDeltaRenderer;
+    contextLabelsRenderer: ContextLabelsRenderer;
+    forceFieldDetailsPanel: ForceFieldDetailsPanel;
+    getActiveChildMeta: () => {
+        oddId: string;
+        cuttingIndex: number;
+        componentId: string;
+    } | null;
+    getAllComponents: () => YinYangInternalModel["components"];
+    getChildRenderedCenter: (childController: IYinYangController) => {
+        x: number;
+        y: number;
+    } | null;
+    getCurrentComponent: () => YinYangInternalModel["components"][number] | null;
+    getInternalModel: () => YinYangInternalModel;
+    navigateToPrereqAction: (actionId: string) => void;
+    session: ControllerSession;
+    showComposanteInfo: () => void;
+    state: YinYangControllerState;
+    view: IYinYangView;
+    weightPreviewRingRenderer: WeightPreviewRingRenderer;
+};
+/** Titre de composante (facette / satellite / action), étiquettes de
+ *  contexte, deltas de score des satellites et anneau d'aperçu de poids. */
+export declare class ComponentTitlePresenter {
+    private deps;
+    constructor(deps: ComponentTitlePresenterDeps);
+    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). */
+    refreshComponentTitle(): void;
+    /** 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. */
+    updateComponentTitleLabelImmediate(componentIndex: number): void;
+    updateContextLabels(orbitData: ChildrenOrbitEntry[]): void;
+    renderChildScoresDeltas(orbitData: ChildrenOrbitEntry[]): void;
+    /** 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. */
+    applyWeightPreview(orbitData: ChildrenOrbitEntry[], globalGroupNode: SVGGElement | null): void;
+}

package/dist/types/components/controller/navigation/DiagramNavigator.d.ts

@@ -0,0 +1,64 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { YinYangComponentNode, YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { type ComboResult } from "../../../data/combo-engine";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import { ComponentTitlePresenter } from "../labels/ComponentTitlePresenter";
+import { ControllerSession } from "../state/ControllerSession";
+import type { ControllerUiCallbacks } from "../state/ControllerUiCallbacks";
+import { ForceFieldComputationService } from "../force-field/ForceFieldComputationService";
+export type DiagramNavigatorDeps = {
+    computeComboResultsForAction: (actionId: string) => ComboResult[] | undefined;
+    animateChildrenHide: () => void;
+    buildChildrenOrbitData: () => ChildrenOrbitEntry[];
+    getChildControllers: () => IYinYangController[];
+    childOddMap: Map<string, {
+        oddId: string;
+        score: number;
+        cuttingIndex: number;
+    }>;
+    forceFieldComputationService: ForceFieldComputationService;
+    forceFieldDetailsPanel: ForceFieldDetailsPanel;
+    getAllComponents: () => YinYangInternalModel["components"];
+    getCurrentComponent: () => YinYangInternalModel["components"][number] | null;
+    getCurrentComponentOrUndefined: () => YinYangInternalModel["components"][number] | undefined;
+    renderCumulativeDetailsForCutting: (oddId: string, cuttingId: number | undefined) => boolean;
+    renderForceFieldDetails: (linkIndex: number) => void;
+    renderSourceActionDetailsForCurrentSource: (opts?: {
+        deltaOverride?: number;
+        comboResults?: ComboResult[];
+    }) => void;
+    session: ControllerSession;
+    state: YinYangControllerState;
+    titlePresenter: ComponentTitlePresenter;
+    ui: ControllerUiCallbacks;
+    view: IYinYangView;
+};
+/** Navigation dans le diagramme depuis les panneaux (source d'une action,
+ *  prérequis, découpe ciblée, clic sur une étiquette de découpe) et fantôme
+ *  HTML affiché pendant un glisser d'action. */
+export declare class DiagramNavigator {
+    private deps;
+    constructor(deps: DiagramNavigatorDeps);
+    private htmlDragGhost;
+    navigateToSource(fromOddId: string, fromCuttingId: number | undefined, fromComponentId: string | undefined): void;
+    navigateToPrereqAction(actionId: string): void;
+    navigateToCutting(toOddId: string, toCuttingId: number | undefined, toComponentId: string | undefined): void;
+    /** Index (position dans l'ODD) d'un cutting à partir de son id — inverse
+     *  de resolveOddCuttingId ; undefined si l'ODD ou l'id est inconnu. */
+    resolveCuttingIndex(component: YinYangInternalModel["components"][number], oddId: string, cuttingId: number): number | undefined;
+    notifyCuttingNavigated(oddId: string, cuttingId: number | undefined): void;
+    clientPointToGlobalGroup(clientX: number, clientY: number): {
+        x: number;
+        y: number;
+    } | null;
+    renderDragGhost(clientX: number, clientY: number, iconUrl: string): void;
+    removeDragGhost(): void;
+    onCuttingLabelClick(oddId: string, cuttingId: number | undefined): void;
+    resolveActionSource(component: YinYangComponentNode | undefined): {
+        oddId: string;
+        cuttingId: number | undefined;
+    } | undefined;
+}

package/dist/types/components/controller/odd/OddViewManager.d.ts

@@ -4,7 +4,7 @@ import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel"
 import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
 import { ActionStackController } from "../action-stack/ActionStackController";
 import { OddHighlightIntensity, ChildHighlightState } from "./childHighlightStyles";
-import type { CumulativeBlock } from "../YinYangController";
+import type { CumulativeBlock } from "../types";
 type ChildOddMeta = {
     oddId: string;
     score: number;

package/dist/types/components/controller/search/SearchPanelSynchronizer.d.ts

@@ -83,6 +83,15 @@ type SearchPanelSynchronizerDeps = {
         x: number;
         y: number;
     } | null;
+    /** Glisser guidé d'un prérequis : réaffiche dans le panneau STACK les
+     *  blocs de l'item de pile portant le combo. */
+    showStackItemBlocksForDrag: (stackItemId: string) => void;
+    /** Glisser guidé : aperçu en direct des cartes combo selon l'emplacement
+     *  survolé (restaure le contenu d'origine hors glisser guidé). */
+    refreshGuidedComboPreview: () => void;
+    /** Sélectionne le satellite d'un item de pile et centre son bloc — même
+     *  chemin qu'un clic sur le libellé de l'item dans la pile. */
+    focusStackItemSatellite: (stackItemId: string) => void;
 };
 /**
  * Coordonne le panneau RECHERCHE avec le diagramme — et héberge aussi le

package/dist/types/components/controller/state/ControllerSession.d.ts

@@ -0,0 +1,107 @@
+import type { ForceFieldLink, ForceFieldLinkDetail } from "../force-field/types";
+/** Contexte "incoming" préparé avant un changement de facette (voir
+ *  ComponentSwitchContext). */
+export type IncomingLinksByOddId = Map<string, {
+    toOddId: string;
+    thickness: number;
+    potentialGain: number;
+    detail: ForceFieldLinkDetail;
+    sourceOriginKey?: string;
+}>;
+/**
+ * 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
+ */
+export type ComponentSwitchContext = undefined | null | {
+    type: "incoming";
+    sourceComponentId: string;
+    /** Keyed by the arrival's own identity (edgeId) — voir
+     *  buildIncomingLinkKey — so that every arrival is preserved as a
+     *  separate entry. `toOddId` is also stored in the value since the key
+     *  is not the plain ODD id. */
+    linksByOddId: IncomingLinksByOddId;
+} | {
+    type: "reactivate";
+} | {
+    type: "searchCutting";
+    oddId: string;
+    cuttingIndex: number;
+    forceOpen?: boolean;
+} | {
+    type: "searchOdd";
+    oddId: string;
+} | {
+    type: "searchOddHighlight";
+    oddId: string;
+} | {
+    type: "searchAction";
+    oddId: string;
+    cuttingIndex: number;
+    actionId: string;
+} | {
+    type: "restoreAction";
+    oddId: string;
+    cuttingIndex: number;
+    actionId: string;
+};
+export type PersistentActionContext = {
+    sourceComponentId: string;
+    sourceOddId: string;
+    sourceCuttingIndex: number;
+    actionId: string;
+    actionLabel?: string;
+    links: ForceFieldLink[];
+};
+export type SourceFocus = {
+    oddId: string;
+    cuttingId: number | undefined;
+};
+/**
+ * État de navigation mutable partagé entre YinYangController et ses
+ * collaborateurs (bascule de facette, navigation, panneau de détails,
+ * Événements Clés). Regroupé ici pour que chacun lise et écrive la même
+ * instance plutôt que de passer par des getters/setters du contrôleur.
+ */
+export declare class ControllerSession {
+    /**
+     * Persists the active action across component switches.
+     * Cleared only when the user explicitly deselects the action.
+     */
+    persistentActionContext: PersistentActionContext | null;
+    pendingComponentSwitchContext: ComponentSwitchContext;
+    selectedSourceFocus: SourceFocus | null;
+    /** Focus saved just before switching away from the source component, so returning
+     * to the source component restores the same highlighted cutting (multi-action). */
+    focusBeforeComponentSwitch: SourceFocus | null;
+    /** 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. */
+    savedSourceComponentLinks: ForceFieldLink[];
+    /** 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. */
+    pendingCuttingFocusAfterSwitch: SourceFocus | null;
+    pendingOddHighlightAfterSwitch: string | null;
+    /** 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. */
+    pendingCuttingNavigationAfterSwitch: {
+        oddId: string;
+        cuttingIndex: number;
+        forceOpen: boolean;
+    } | null;
+    /** Menu cœur à déployer à l'arrivée sur la facette (voir searchSetKeyEventMenuOpen). */
+    pendingKeyEventMenuAfterSwitch: boolean;
+    isCoreEventMenuOpen: boolean;
+    /** Id de l'Événement Clé actuellement en aperçu (carte affichée), ou null. */
+    activeKeyEventId: string | null;
+    /** Quand vrai, le prochain appel à onShowDirectActionBlock est routé vers le panneau B. */
+    routeNextDirectActionBlockToPanelB: boolean;
+    /** Quand vrai, renderSourceActionDetailsForCurrentSource ne re-rend pas le bloc Panel A.
+     * Utilisé pendant reactivatePersistentAction pour préserver l'état des <details> ouverts. */
+    suppressDirectActionBlockRender: boolean;
+}

package/dist/types/components/controller/state/ControllerUiCallbacks.d.ts

@@ -0,0 +1,60 @@
+import type { DiagramNavEvent } from "../types";
+type DirectActionBlockCallback = (compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void;
+/**
+ * Callbacks UI branchés depuis l'extérieur (main.ts, PanelManager,
+ * DiagramPanelBridge…) via les setOn* de YinYangController. Partagé tel quel
+ * avec les collaborateurs qui doivent notifier les panneaux.
+ */
+export type ControllerUiCallbacks = {
+    /** Callback to open the search tab and set a query — wired from main.ts. */
+    openSearchWithQuery?: (query: string) => void;
+    /** Injecte le bloc d'impact d'action directe dans l'onglet Recherche. */
+    onShowDirectActionBlock?: DirectActionBlockCallback;
+    /** Affiche le bloc d'action directe d'un prérequis dans le panneau B. */
+    onShowDirectActionBlockPanelB?: DirectActionBlockCallback;
+    /** Efface le bloc d'impact d'action directe de l'onglet Recherche. */
+    onClearDirectActionBlock?: () => void;
+    /** Injecte la carte descriptive d'un Événement Clé dans l'onglet Recherche. */
+    onShowKeyEventBlock?: (compId: string, keyEventId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void;
+    /** Efface la carte d'Événement Clé de l'onglet Recherche. */
+    onClearKeyEventBlock?: () => void;
+    /** 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. */
+    onKeyEventMenuStateChange?: (componentIndex: number, open: boolean) => void;
+    /** Injecte le bloc d'action propagée dans l'onglet Recherche. */
+    onShowPropagationBlock?: (compId: string, oddId: string, cutIdx: number, html: string, attachHandlers: (container: HTMLElement) => void, sourceDesc: {
+        breadcrumb: string;
+        title: string;
+        description: string;
+    }, rationale?: string) => void;
+    /** Efface le bloc d'action propagée de l'onglet Recherche. */
+    onClearPropagationBlock?: () => void;
+    onDiagramActionDragIntent?: () => void;
+    onActiveChildChange?: () => void;
+    onOuterSparkAutoToggle?: (enabled: boolean) => 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. */
+    onCuttingNavigated?: (compId: string, oddId: string, cuttingIndex: number) => void;
+    onDiagramOddChange?: (componentIndex: number, oddId: string, mode: "highlight") => void;
+    onDiagramNavChange?: (event: DiagramNavEvent) => 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. */
+    onDiagramSatelliteDeselect?: (componentIndex: number) => void;
+    /** Fired when the user clicks the current composante's border arc to hide its satellites. */
+    onDiagramComposanteDeselect?: () => void;
+    /** Vers le panneau Recherche quand la souris entre/sort d'un satellite dans le diagramme. */
+    onDiagramChildHover?: ((componentIndex: number | null, oddId: string | null, cuttingIndex?: number) => void) | null;
+    /** Vers le panneau Recherche quand la souris entre/sort d'un arc de bordure (composante). */
+    onDiagramComposanteHover?: ((componentIndex: number | null) => void) | null;
+    /** Vers le panneau Recherche quand la souris entre/sort d'un cercle d'action dans le menu radial. */
+    onDiagramActionHover?: ((componentIndex: number | null, oddId: string | null, cuttingIndex: number | null, actionId: string | null) => void) | null;
+    /** Panneau RECHERCHE : la souris entre/sort d'un arc ODD dans le diagramme. */
+    onDiagramOddArcHover?: ((oddId: string | null) => void) | null;
+};
+export {};

package/dist/types/components/controller/state/YinYangControllerState.d.ts

@@ -47,7 +47,6 @@ export declare class YinYangControllerState {
         coreEventIconFontScale: number;
     };
     action: {
-        propagationFactor: number;
         delta: number;
     };
     visibility: {
@@ -59,14 +58,14 @@ export declare class YinYangControllerState {
      *  chaque plafond levé. Bornés (false) par défaut : comportement actuel. */
     combos: {
         /** Lève le plafond à 1 sur le ratio de performance des prérequis
-         *  DÉCLENCHEURS (combos non dangereux), ce qui autorise une cascade de
+         *  DÉCLENCHEURS (exploitations éligibles), ce qui autorise une cascade de
          *  combos à dépasser ×2. N'affecte pas les prérequis PROTECTEURS d'un
-         *  combo dangereux (voir dangerousComboCanBecomeBonus). */
+         *  sécurisation (voir dangerousComboCanBecomeBonus). */
         uncappedChainedPerformance: boolean;
         /** Lève le plafond à 1 sur le ratio de performance des prérequis
-         *  PROTECTEURS d'un combo dangereux, ce qui permet à m = avgRatio de
+         *  PROTECTEURS d'une sécurisation, ce qui permet à m = avgRatio de
          *  dépasser ×1 (le risque devient un bonus net). N'affecte pas les
-         *  combos non dangereux (voir uncappedChainedPerformance). */
+         *  exploitations éligibles (voir uncappedChainedPerformance). */
         dangerousComboCanBecomeBonus: boolean;
     };
     labels: {

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

@@ -0,0 +1,103 @@
+import type { ForceFieldLinkDetail } from "./force-field/types";
+import type { ComboResult } from "../../data/combo-engine";
+import type { AmplifierResult, AmplifierTargetBreakdown } from "../../data/amplifier-engine";
+import type { AbsorptionBreakdown, ActiveShield } from "./force-field/shieldViewModel";
+/**
+ * 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.
+ */
+export type ActionCumulativeBlock = {
+    type: "source" | "propagation";
+    actionId?: string;
+    actionName: string;
+    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;
+    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[];
+    /** Arrivées de la seule résolution de ce bloc : pool séquentiel quand il
+     *  existe, sinon les lignes de la résolution de cet item. Lues par les
+     *  listes Source / Bilan et la comète (PROP-VIZ-01). */
+    resolutionPool?: 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;
+    /** Bouclier de stabilité déjà actif sur le satellite en focus quand ce
+     *  bloc s'est résolu (bloc "source" uniquement). */
+    activeShield?: ActiveShield;
+    /** Bouclier créé par cette action (slots de stabilisation déclenchés). */
+    createdShield?: number;
+    /** Réduction appliquée par le bouclier du satellite en focus à la
+     *  contribution négative de ce bloc — journal de résolution. */
+    shieldAbsorption?: AbsorptionBreakdown;
+};
+/**
+ * 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.
+ */
+export 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;
+/** Navigation diagramme → panneau RECHERCHE (voir setOnDiagramNavChange). */
+export 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;
+};

package/dist/types/components/controller/utils/actionCatalog.d.ts

@@ -0,0 +1,15 @@
+import type { ActionDefinition } from "../../../data/yasuni_actions";
+import type { KeyEventDefinition } from "../../../data/yasuni_key_events";
+/** Catalogue indexé par ID — instancié une seule fois au chargement du module. */
+export declare const actionMap: Map<string, ActionDefinition>;
+/**
+ * Cibles d'un Événement Clé prêtes pour buildKeyEventCardHtml : id + nom,
+ * la carte affichant pour chacune le seul bonus ajouté par l'effet (pas de
+ * deltas du catalogue à charrier jusque-là). Les deux points d'appel (clic
+ * sur le cercle central, cartes cumulées du panneau) passent par ici — une
+ * seule définition de la forme attendue.
+ */
+export declare function buildKeyEventTargets(keyEvent: KeyEventDefinition): Array<{
+    id: string;
+    name: string;
+}>;

package/dist/types/components/controller/utils/forceFieldPresentation.d.ts

@@ -1,9 +1,15 @@
-export type ForceFieldLayerType = "inter" | "intra" | "bridge";
-export type ForceFieldDeltaDetail = {
-    layerType: ForceFieldLayerType;
+import type { PropagationScope } from "../../../interfaces/IPropagationGraph";
+/** Libellé de la portée réelle d'une arête du graphe unifié (PROP-GRAPH-04) :
+ *  la même mécanique, seule la destination change. */
+export declare function getScopeDisplayName(scope: PropagationScope): string;
+/** Classe CSS d'une ligne selon sa portée (voir details-panel.css). */
+export declare function getScopeCssClass(scope: PropagationScope): string;
+/**
+ * Delta affiché sur un lien du champ de force qui regroupe plusieurs
+ * arrivées le long du même trajet (même satellite de départ, même cible) :
+ * leur somme, c'est-à-dire tout ce que ce trajet apporte réellement à la
+ * cible dans la résolution.
+ */
+export declare function calculateDisplayedDelta(details: readonly {
     deltaTo: number;
-};
-export declare function getForceFieldWeightLabel(layerType: ForceFieldLayerType): string;
-export declare function getLayerDisplayName(layerType: ForceFieldLayerType): string;
-export declare function getPropagationCardTitle(layerType: ForceFieldLayerType): string;
-export declare function calculateDisplayedDelta(details: ForceFieldDeltaDetail[]): number;
+}[]): number;