@micheeeeel/yinyangapp 3.0.1 → 3.1.1

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

@@ -1,9 +1,11 @@
+import type { KeyEventActionEffects } from "../../../data/key-event-effects";
+import { type EventTargetBreakdown } from "./keyEventPresentation";
 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 ComboResult } from "../../../data/combo-engine";
 import { type AbsorptionBreakdown, type ActiveShield } from "./shieldViewModel";
-import type { AmplifierResult, AmplifierTargetBreakdown } from "../../../data/amplifier-engine";
+import type { AmplifierResult } 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
@@ -45,6 +47,7 @@ type ActionCumulativeBlockViewModel = {
     detailRows: ForceFieldLinkDetail[];
     comboResults?: ComboResult[];
     amplifierResults?: AmplifierResult[];
+    eventEffects?: KeyEventActionEffects;
     stackItemId?: string;
     color?: string;
     sequentialDetailPool?: ForceFieldLinkDetail[];
@@ -65,6 +68,10 @@ type ActionCumulativeBlockViewModel = {
      *  contribution négative de ce bloc — direct, propagé, agrégé, absorbé,
      *  appliqué (journal de résolution). */
     shieldAbsorption?: AbsorptionBreakdown;
+    directionalAbsorptions?: Array<{
+        active?: ActiveShield;
+        breakdown: AbsorptionBreakdown;
+    }>;
 };
 /** Bloc "keyEvent" : un Événement Clé joué, toujours affiché dès que sa
  *  Facette d'origine correspond à celle affichée (voir YinYangController.
@@ -82,7 +89,7 @@ type KeyEventCumulativeBlockViewModel = {
         id: string;
         name: string;
     }>;
-    breakdowns?: AmplifierTargetBreakdown[];
+    breakdowns?: EventTargetBreakdown[];
 };
 type CumulativeBlockViewModel = ActionCumulativeBlockViewModel | KeyEventCumulativeBlockViewModel;
 export declare class ForceFieldDetailsPanel {
@@ -134,6 +141,10 @@ export declare class ForceFieldDetailsPanel {
     /** Timer set during a user card interaction — prevents ResizeObserver from
      *  running _applyAutoFitToGrids while a card is animating. */
     private _userInteractingTimer;
+    /** Observers posés sur les conteneurs de rails, et rappel de la montée des
+     *  badges en cours : coupés par destroy(). */
+    private readonly _resizeObservers;
+    private _countUpFrameId;
     /** 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). */
@@ -150,8 +161,6 @@ export declare class ForceFieldDetailsPanel {
     private _onDiagramElementHover?;
     /** Called when hovering a cumulative block — notifies the stack to highlight the matching item. */
     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. */
@@ -202,6 +211,9 @@ export declare class ForceFieldDetailsPanel {
      *  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;
+    /** Repère d'une ligne Source : le satellite où l'action est jouée porte
+     *  la petite icône de l'action (son nom en infobulle). */
+    private _actionSourceMarkHtml;
     /** 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. */
@@ -258,7 +270,7 @@ export declare class ForceFieldDetailsPanel {
     /**
      * 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
+     * (1er clic sur une bulle du menu radial du satellite-facette), 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
@@ -289,13 +301,12 @@ export declare class ForceFieldDetailsPanel {
             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
+         *  effectif déjà réduit) — bloc STACK seulement : absente en aperçu
+         *  (RECHERCHE), où aucune position n'existe hors de la pile. En STACK,
+         *  réduite aux actions cochées et amplifiées, comme targetedActions
+         *  (voir buildKeyEventBlocksForComponent). */
+        breakdowns?: EventTargetBreakdown[];
+        /** Id de l'item "keyEvent" actif dans la pile (absent en aperçu) — 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;
@@ -304,49 +315,6 @@ export declare class ForceFieldDetailsPanel {
         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.
-     *  Seule une action propagée porte une note dans l'en-tête (le satellite
-     *  dont elle provient) : pour une action directe — adverse comprise — on
-     *  est déjà sur le satellite porteur, l'information serait redondante.
-     *  L'acteur d'origine d'une action adverse est rendu à part (`origin`),
-     *  dans le corps du bloc, pour ne pas concurrencer le nom. */
     private _pickActionBlockBadge;
     /** Ligne « Acteur : … » placée en tête du corps d'un bloc adverse (action
      *  ou Événement) — remplace l'ancienne note d'en-tête. */
@@ -486,6 +454,9 @@ export declare class ForceFieldDetailsPanel {
      * re-runs the auto-fit measurement whenever the container changes size.
      */
     private _ensureResizeObserver;
+    /** Fin de vie : observers déconnectés, minuteries et montée des badges
+     *  coupées. Le DOM du panneau appartient à l'hôte : non touché. */
+    destroy(): void;
     private _initCardRailState;
     private _handleCardRailClick;
     private _triggerHighlightFromCard;
@@ -531,7 +502,6 @@ export declare class ForceFieldDetailsPanel {
     /** Vrai si le panneau affiche actuellement le bloc « Effets cumulés » de cet
      *  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). */
@@ -692,6 +662,7 @@ export declare class ForceFieldDetailsPanel {
         allComponents?: YinYangComponentNode[];
         comboResults?: ComboResult[];
         amplifierResults?: AmplifierResult[];
+        eventEffects?: KeyEventActionEffects;
         stackItemId?: string;
         /** 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

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

@@ -20,7 +20,7 @@ export type ForceFieldDetailsPresenterDeps = {
     actionStackManager: ActionStackManager;
     applyOddStateForCutting: (oddId: string) => void;
     buildChildrenOrbitData: () => ChildrenOrbitEntry[];
-    buildProjectionActionsFromStackItems: (items: ActionStackItem[]) => SequentialActionProjectionInput[];
+    buildProjectionActionsFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => SequentialActionProjectionInput[];
     getChildControllers: () => IYinYangController[];
     childOddMap: Map<string, {
         oddId: string;
@@ -47,6 +47,9 @@ export type ForceFieldDetailsPresenterDeps = {
 export declare class ForceFieldDetailsPresenter {
     private deps;
     constructor(deps: ForceFieldDetailsPresenterDeps);
+    /** Action ciblée par un événement pendant son insertion depuis RECHERCHE.
+     * Les positions projetées servent au même moteur d'effets que le dépôt. */
+    renderGuidedActionPreview(preview: ActionStackItem, projected: ActionStackItem[] | null): void;
     /**
      * Construit le bloc d'action directe pour un emplacement connu (compId/oddId/cutIdx/actionId)
      * sans naviguer le diagramme, et fire le callback avec (compId, oddId, cutIdx, actionId, html, attachHandlers).

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

@@ -18,6 +18,12 @@ type ForceFieldLifecycleControllerDeps = {
     getAllComponents: () => YinYangInternalModel["components"] | undefined;
     updateChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
     updateContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
+    /** Frame d'orbite : bulles du menu radial et bulles détachées recalées
+     *  sur leur satellite, sans data join ni transitions. */
+    followOrbitChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
+    /** Frame d'orbite : libellés, deltas et anneau de poids recalés, sans
+     *  réécrire le titre, la légende ni les panneaux. */
+    followOrbitContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
     clearForceFieldDetails: () => void;
     renderForceFieldDetails: (linkIndex: number) => void;
     renderActionPropagationTable: () => void;
@@ -62,7 +68,16 @@ export declare class ForceFieldLifecycleController {
     invalidatePropagationCache(): void;
     private _buildPropCacheKey;
     renderOppositeChildrenForceField(orbitData?: ChildrenOrbitEntry[]): void;
-    removeOppositeChildrenForceField(): void;
+    /**
+     * Frame d'orbite en vol (ChildrenOrbitManager) : les satellites viennent
+     * de bouger, rien d'autre n'a changé. Seule la géométrie qui dépend de
+     * leur position est recalée ; le champ de force est dessiné ici une seule
+     * fois, sa propre boucle se contentant alors d'avancer la phase.
+     */
+    updateOrbitFrame(orbitData: ChildrenOrbitEntry[]): void;
+    /** Fin de vie : coupe la boucle du champ de force. */
+    destroy(): void;
+    removeOppositeChildrenForceField(orbitData?: ChildrenOrbitEntry[]): void;
     private ensureForceFieldLinks;
     private updateForceFieldVisual;
     private startForceFieldAnimation;

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

@@ -6,13 +6,12 @@ type Point = {
     y: number;
 };
 export declare class ForceFieldRenderer {
-    private forceFieldGroup;
-    private forceFieldDefs;
+    /** Surface du champ de force ; null = aucun champ affiché. */
+    private painter;
     private forceFieldLayers;
-    private readonly gradientPrefix;
     /** setTimeout id du fondu de sortie en cours, ou null — voir hide(). */
     private _hideTimeoutId;
-    /** requestAnimationFrame id de la rétraction géométrique en cours — voir retractGeometry(). */
+    /** Id frameScheduler de la rétraction géométrique en cours — voir retractGeometry(). */
     private _retractFrameId;
     /** Horodatage du dernier updateVisual — updateVisual ne reçoit pas de Δt,
      *  on le dérive ici pour le lissage de l'emphase. */
@@ -53,32 +52,25 @@ export declare class ForceFieldRenderer {
         getComponentBorderTargetPoint: (componentId: string) => Point | null;
     }): void;
     /**
-     * Fondu de sortie : au lieu de retirer le groupe instantanément (clear()),
-     * ramène son opacité à 0 sur fieldFadeOutDurationMs puis le retire
+     * Fondu de sortie : au lieu de retirer la surface instantanément (clear()),
+     * ramène son opacité à 0 sur fieldFadeOutDurationMs puis la retire
      * réellement — même grammaire de disparition que EventFieldRenderer.hide().
      * Idempotent : un appel alors qu'un fondu est déjà en cours ne fait rien de
      * plus (le clear() en attente suffit).
      */
     hide(): void;
     /**
-     * Rétraction géométrique : anime chaque beam vers son point de départ,
+     * Rétraction géométrique : ramène chaque faisceau vers son point de départ,
      * inverse exact de la croissance animatedEnd de updateVisual (même
      * fonction d'accélération, lue à l'envers : d3.easeCubicOut(1 - t) au lieu
-     * de d3.easeCubicOut(t)). Repart de _prevEndpoint — la géométrie du
-     * dernier frame réellement rendu — donc ne dépend d'aucun state externe :
-     * elle continue même si les liens qui l'ont produite sont nettoyés entre
+     * de d3.easeCubicOut(t)). Repart du dernier faisceau réellement peint, figé
+     * (respiration et comètes arrêtées), donc ne dépend d'aucun state externe :
+     * elle continue même si les liens qui l'ont produit sont nettoyés entre
      * temps (cas typique : clic sur l'arc de facette, qui déclenche hide()
      * puis, dans la foulée, la destruction des satellites source). Se déroule
-     * en parallèle du fondu d'opacité du groupe (même durée, posé par hide()).
+     * en parallèle du fondu d'opacité (même durée, posé par hide()).
      */
     private retractGeometry;
     clear(): void;
-    /**
-     * Met à jour les coordonnées d'un gradient et, si stopData est fourni (cache miss),
-     * les couleurs et opacités des stops.
-     * Fix 1 : les offsets ne sont jamais réécrits (initialisés une seule fois dans createStops).
-     * Fix 2 : stopData === null signifie que le cache couleur est valide — on n'écrit pas les stops.
-     */
-    private updateGradient;
 }
 export {};

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

@@ -8,10 +8,10 @@ import { ComponentTitlePresenter } from "../labels/ComponentTitlePresenter";
 import { ControllerSession } from "../state/ControllerSession";
 import { ForceFieldComputationService } from "./ForceFieldComputationService";
 export type IncomingForceFieldServiceDeps = {
-    applyProjectedGhostFromStackItems: (items: ActionStackItem[]) => void;
+    applyProjectedGhostFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => void;
     buildChildrenOrbitData: () => ChildrenOrbitEntry[];
     buildForceFieldSourceIndicesFromStackItems: (items: ActionStackItem[]) => number[];
-    buildProjectionActionsFromStackItems: (items: ActionStackItem[]) => SequentialActionProjectionInput[];
+    buildProjectionActionsFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => SequentialActionProjectionInput[];
     childOddMap: Map<string, {
         oddId: string;
         score: number;

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

@@ -44,6 +44,8 @@ export declare class PropagationAnimator {
      *  le réglage se sente tout de suite. */
     setFocusPropagationLoopGapMs(ms: number): void;
     restartFocusPropagationLoop(): void;
+    /** Fin de vie : coupe la boucle de l'action en focus et la comète. */
+    destroy(): void;
     private stopFocusPropagationLoop;
     private _runFocusPropagationLoopPass;
     /** Joue une passe pour l'item ; retourne sa durée (0 si rien à jouer). */

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

@@ -0,0 +1,47 @@
+import type { KeyEventDefinition } from "../../../data/key-event-types";
+import type { KeyEventActionEffects } from "../../../data/key-event-effects";
+import type { ForceFieldLinkDetail } from "./types";
+export declare const escapeEventHtml: (text: string) => string;
+export type EventTargetBreakdown = {
+    id: string;
+    positional: number;
+    played: boolean;
+    effectText: string;
+    slotIndex?: number;
+};
+export declare const eventSignatureName: (event: KeyEventDefinition) => string;
+/** Catalogue potential, or the parameter at the exact shared eligibility strength.
+ * These are labelled parameters, never fabricated additive deltas. */
+export declare function eventSignatureDescription(event: KeyEventDefinition, strength?: number): string;
+export declare function eventSignatureChipHtml(event: KeyEventDefinition): string;
+export declare function eventEffectRows(effects: KeyEventActionEffects | undefined): {
+    event: KeyEventDefinition;
+    text: string;
+    strength: number;
+}[];
+export type EventEffectCardContext = {
+    baseDelta?: number;
+    comboDelta?: number;
+    stackItemId?: string;
+    detailRows?: ForceFieldLinkDetail[];
+    activeShield?: number;
+    activeShieldProtectedSign?: 1 | -1;
+};
+/** Cartes de modification dans le rail de l'action : même grammaire que
+ * les combos, avec les unités propres à chaque signature. Les badges de
+ * propagation/bouclier ne prétendent jamais être des deltas additionnables. */
+export declare function eventEffectsCardsHtml(effects: KeyEventActionEffects | undefined, context?: EventEffectCardContext): string;
+export declare function eventPropagationLabel(row: ForceFieldLinkDetail): string;
+export declare function eventTargetsCardHtml(params: {
+    keyEvent: KeyEventDefinition;
+    targetedActions: Array<{
+        id: string;
+        name: string;
+    }>;
+    breakdowns?: EventTargetBreakdown[];
+    requiresAttr: string;
+    withinNextNAttr: string;
+    nameAttr: string;
+    itemIdAttr: string;
+    adverse: boolean;
+}): string;

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

@@ -37,6 +37,10 @@ export type CometPlayOptions = {
 export declare class PropagationCometPlayer {
     private deps;
     private run;
+    /** Rappel de frame en attente et couche de la lecture en cours : `stop()`
+     *  les retire tout de suite au lieu d'attendre la frame suivante. */
+    private pendingFrameId;
+    private pendingLayer;
     constructor(deps: PropagationCometPlayerDeps);
     private get cfg();
     /** Joue un ou plusieurs arbres (rafale). Retourne la durée de la lecture

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

@@ -38,8 +38,10 @@ export declare class PropagationVizLists {
         pool: readonly ForceFieldLinkDetail[];
         satellite: VizSatellite;
         blockColor?: string;
-        /** Libellé d'une provenance (ex. nom de l'action pour son satellite). */
-        labelOf?: (satellite: VizSatellite) => string | undefined;
+        /** Repère HTML ajouté après le nom d'un satellite (ex. icône de l'action
+         *  sur le satellite où elle est jouée) — le nom, lui, reste celui du
+         *  satellite : une ligne de liste désigne toujours un satellite. */
+        markOf?: (satellite: VizSatellite) => string | undefined;
     }): {
         html: string;
         count: number;

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

@@ -15,6 +15,7 @@ export type VizListEntry = {
     delta: number;
     edgeIds: string[];
     rationales: string[];
+    provenance: string[];
 };
 /** Arbre de trajet d'une comète : le satellite de départ, puis chaque
  *  satellite atteint, embranchements compris. */

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

@@ -5,6 +5,7 @@ export interface ShieldGrant {
     oddId: string;
     cuttingIndex: number;
     shield: number;
+    protectedSign?: 1 | -1;
     /** Nom de l'action qui l'a créé — l'origine affichée au joueur. */
     label?: string;
     /** Item de pile qui l'a créé — cible du lien de la carte Bouclier. */
@@ -12,6 +13,7 @@ export interface ShieldGrant {
 }
 export interface ActiveShield {
     value: number;
+    protectedSign?: 1 | -1;
     originLabel?: string;
     originStackItemId?: string;
 }
@@ -25,7 +27,7 @@ export interface ShieldTargetRef {
  * un seul par satellite, le plus fort ; à valeur égale, le premier posé
  * reste l'origine (un bouclier plus faible ou égal ne remplace jamais).
  */
-export declare function resolveActiveShield(grants: ShieldGrant[], target: ShieldTargetRef): ActiveShield | undefined;
+export declare function resolveActiveShield(grants: ShieldGrant[], target: ShieldTargetRef, protectedSign?: 1 | -1): ActiveShield | undefined;
 export type ShieldVerdict = "creates" | "replaces" | "ignored" | "unchanged";
 /**
  * Ce que ferait un bouclier `created` face au bouclier `active` déjà en
@@ -52,13 +54,14 @@ export interface AbsorptionBreakdown {
     applied: number;
     /** true si le bouclier a tout absorbé : le delta appliqué est 0, pas un gain. */
     boundedToZero: boolean;
+    protectedSign?: 1 | -1;
 }
 /**
  * @param absorption  réduction rapportée par la projection pour ce satellite
  * @param directDelta delta effectif de l'action si elle vise ce satellite,
  *                    0 sinon — permet de séparer direct et propagé.
  */
-export declare function buildAbsorptionBreakdown(absorption: Pick<ShieldAbsorption, "shield" | "aggregated" | "applied">, directDelta: number): AbsorptionBreakdown;
+export declare function buildAbsorptionBreakdown(absorption: Pick<ShieldAbsorption, "shield" | "aggregated" | "applied" | "protectedSign">, directDelta: number): AbsorptionBreakdown;
 /** Lignes courtes du journal de résolution, dans l'ordre du pipeline. */
 export declare function absorptionSentences(b: AbsorptionBreakdown): string[];
 /** Carte « Bouclier » d'un bloc de l'ANALYSE : maillon additif entre les
@@ -73,6 +76,7 @@ export interface ShieldCardViewModel {
     /** Lignes de calcul, dans l'ordre du pipeline. */
     lines: string[];
     boundedToZero: boolean;
+    protectedSign?: 1 | -1;
 }
 /** undefined quand le bouclier n'a rien réduit dans ce bloc (contribution
  *  positive, ou pas de bouclier) : pas de carte, la note du Bilan suffit. */

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

@@ -1,4 +1,4 @@
-import type { PropagationScope } from "../../../interfaces/IPropagationGraph";
+import type { EventPropagationMetadata, 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.
@@ -20,6 +20,7 @@ export type ForceFieldLinkDetail = {
      *  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;
+    eventPropagation?: EventPropagationMetadata;
     scope: PropagationScope;
     fromComponentId: string;
     toComponentId: string;

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

@@ -3,6 +3,13 @@ import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel"
 import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
 import { ProjectedCuttingState } from "../actions/ActionProjectionService";
 export declare class ChildScoresDeltaRenderer {
+    private lastParams;
+    /**
+     * Frame d'orbite : chaque bloc de deltas déjà rendu glisse vers son
+     * nouvel ancrage par un simple `transform` sur son groupe (décalage par
+     * rapport à l'ancrage du dernier render), sans recréer textes ni voile.
+     */
+    followOrbit(): void;
     render(params: {
         orbitData: ChildrenOrbitEntry[];
         globalGroupNode: SVGGElement | null;

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

@@ -49,6 +49,15 @@ export declare class ComponentTitlePresenter {
     private deps;
     constructor(deps: ComponentTitlePresenterDeps);
     private getCurrentComponentTitle;
+    /** L'Événement Clé actif, s'il est issu de `component` — partagé par le
+     *  titre en Facette et au repos. */
+    private getActiveKeyEventOf;
+    /** Au repos (Idle « facettes » / « tab ») : la hiérarchie du titre remonte
+     *  d'un cran — l'objet racine en tête, le satellite-facette sélectionné
+     *  (celui dont les bulles sont déployées) sur la ligne enfant, son
+     *  Événement Clé actif au niveau suivant. Même rendu qu'une Facette
+     *  ouverte (facette › satellite › action). */
+    private getIdleFacetteTitle;
     /** 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é
@@ -80,6 +89,10 @@ export declare class ComponentTitlePresenter {
      *  satellite line is cleared here rather than read from state mid-switch. */
     updateComponentTitleLabelImmediate(componentIndex: number): void;
     updateContextLabels(orbitData: ChildrenOrbitEntry[]): void;
+    /** Frame d'orbite (ForceFieldLifecycleController.updateOrbitFrame) :
+     *  libellés, deltas et anneau de poids suivent les satellites. Le titre,
+     *  la légende et les ghosts de bordure ne dépendent pas de l'angle. */
+    followOrbit(orbitData: ChildrenOrbitEntry[]): void;
     renderChildScoresDeltas(orbitData: ChildrenOrbitEntry[]): void;
     /** Re-syncs the weightDelta ghost/wave/pulse against the current
      *  ViewInitializer settings (basePulseEnabled, ghostPulseDurationSec,

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

@@ -67,6 +67,12 @@ export declare class ContextLabelsRenderer {
     private componentLegendGroup;
     private lastParams;
     private _childLabelCache;
+    /** Rects écran du SVG et du titre pour updateTitleObstruction, relus au
+     *  plus toutes les OBSTRUCTION_RECTS_TTL_MS pendant l'orbite : les lire à
+     *  chaque frame, juste après les transforms des satellites, forçait un
+     *  layout complet. */
+    private _obstructionRects;
+    private static readonly OBSTRUCTION_RECTS_TTL_MS;
     /** Crossfades du texte du titre (facette / satellite), indépendants pour
      *  que le changement de l'un ne fasse pas clignoter l'autre. */
     private _titleCrossfadeTimers;
@@ -92,6 +98,16 @@ export declare class ContextLabelsRenderer {
     private static readonly SATELLITE_ROW_SPEC;
     private static readonly ACTION_ROW_SPEC;
     render(params: RenderContextLabelsParams): void;
+    /** Place le libellé court d'un satellite au meilleur endroit autour de
+     *  son centre ; ne réécrit rien si rien n'a bougé depuis `cache`. */
+    private layoutChildLabel;
+    /**
+     * Frame d'orbite : les satellites ont bougé, rien d'autre. Recale chaque
+     * libellé déjà rendu (groupe + position du texte) et l'occultation du
+     * titre, sans data join ni réécriture du titre HTML, de la légende ou du
+     * contenu des libellés — tout cela ne change que par render().
+     */
+    followOrbit(orbitData: ChildrenOrbitEntry[]): void;
     clear(): void;
     setVisibilityOpacity(opacity: number): void;
     /**

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

@@ -18,6 +18,12 @@ export declare class WeightPreviewRingRenderer {
     private basePulseEnabled;
     private pulseDurationMs;
     private pulseMorphRatio;
+    /** Fantôme en contour seul (signature, voir renderFixed) plutôt qu'en
+     *  lavis quand il est plus grand que le satellite. */
+    private outlineOnly;
+    /** Vague entre le satellite et son fantôme (coupée en mouvement réduit). */
+    private wavesEnabled;
+    private getChildRenderedCenter;
     render(params: {
         orbitData: ChildrenOrbitEntry[];
         globalGroupNode: SVGGElement | null;
@@ -40,6 +46,31 @@ export declare class WeightPreviewRingRenderer {
         pulseDurationMs: number;
         pulseMorphRatio: number;
     }): void;
+    /**
+     * Fantôme de SIGNATURE (OBS-UI-01, satellites-facettes d'une signature
+     * d'obstacle modulée par un contact) : le même cercle d'or et la même
+     * vague que l'aperçu de poids, mais sur des rayons fournis par l'appelant
+     * — le satellite a déjà sa taille modulée (`baseRadius`), le fantôme garde
+     * celle de la signature (`targetRadius`). Contour seul (une trace de
+     * l'exigence, pas un gain), sans pulsation du satellite : sa taille est
+     * celle de la modulation, l'animer la rendrait fausse. `waves: false`
+     * (mouvement réduit) laisse le fantôme immobile, même information.
+     */
+    renderFixed(params: {
+        groupNode: SVGGElement | null;
+        entries: Array<{
+            id: string;
+            controller: IYinYangController;
+            centerX: number;
+            centerY: number;
+            baseRadius: number;
+            targetRadius: number;
+        }>;
+        waves: boolean;
+    }): void;
+    /** Frame d'orbite : recentre fantômes et vagues sur leur satellite (les
+     *  entrées sont les données liées aux cercles), sans data join. */
+    followOrbit(): void;
     /** Starts/stops per-satellite pulse state to match the current entry set
      *  and basePulseEnabled flag, resetting any satellite's own scale back to
      *  identity the moment it stops being targeted or pulsing is turned off —
@@ -49,6 +80,8 @@ export declare class WeightPreviewRingRenderer {
     private resetEntryTransform;
     private drawGhostCircles;
     private ensureLoop;
+    /** Fin de vie : coupe la boucle de pulsation. */
+    destroy(): void;
     private stopLoop;
     /** Breathes each pulsing satellite's own size out to its weightDelta
      *  target and back, on a loop with a pause — same morph/reset/pause cycle