@micheeeeel/yinyangapp 3.0.0 → 3.1.0

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,7 @@ export declare class WeightPreviewRingRenderer {
     private basePulseEnabled;
     private pulseDurationMs;
     private pulseMorphRatio;
+    private getChildRenderedCenter;
     render(params: {
         orbitData: ChildrenOrbitEntry[];
         globalGroupNode: SVGGElement | null;
@@ -40,6 +41,9 @@ export declare class WeightPreviewRingRenderer {
         pulseDurationMs: number;
         pulseMorphRatio: number;
     }): 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 +53,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

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

@@ -6,50 +6,83 @@ type ChildrenOrbitManagerDeps = {
     view: IYinYangView;
     getChildControllers: () => IYinYangController[];
     state: YinYangControllerState;
+    /** Rendu complet (menu, labels, panneaux, champ de force) : seulement
+     *  quand l'état de l'orbite change (démarrage, arrêt, repos). */
     renderOppositeChildrenForceField: (orbitData: ChildrenOrbitEntry[]) => void;
+    /** Rendu par frame pendant que l'orbite tourne : uniquement ce qui suit
+     *  la position des satellites (bulles, libellés, liens du champ de force). */
+    updateOrbitFrame: (orbitData: ChildrenOrbitEntry[]) => void;
 };
+/**
+ * Orbite des satellites, jouée par le navigateur (PERF-18). Le mouvement est
+ * décrit en tronçons à accélération constante (`rotationMotion.ts`, ici en
+ * radians et rad/ms) ; chaque satellite reçoit une animation Web Animations
+ * par tronçon sur l'enveloppe d'orbite (`viewInitializer.orbitGroup`), calée
+ * sur `document.timeline` : le contenu du satellite n'est plus re-rasterisé.
+ *
+ * Ce qui suit les satellites (bulles, libellés, champ de force) reste en JS :
+ * une boucle par image recalcule l'angle sur la même horloge et le même
+ * modèle (`evaluateMotion`), d'où la même position que celle affichée.
+ * Les positions lues ailleurs passent par `getChildTranslation`, l'attribut
+ * `transform` n'étant plus à jour pendant le mouvement.
+ */
 export declare class ChildrenOrbitManager {
     private deps;
     private readonly orbitService;
     private cachedOrbitData;
-    /** Temps de rampe (ms) courant pour l'accélération/décélération de la
-     *  boucle active — mémorisé pour que setSpeed() (vitesse changée en vol)
-     *  et la boucle elle-même s'y réfèrent sans avoir à le repasser partout. */
+    /** Temps de rampe (ms) courant pour l'accélération/décélération —
+     *  mémorisé pour que setSpeed() (vitesse changée en vol) s'y réfère sans
+     *  avoir à le repasser partout. */
     private rampMs;
-    /** Vitesse angulaire instantanée (rad/ms, signée) — chasse la vitesse
-     *  cible (state.children.orbitSpeed, en rad/s) au rythme imposé par
-     *  rampMs. */
-    private currentOmega;
-    private lastTimestamp;
-    /** Présent tant qu'un arrêt "retour à la position de base" est en cours :
-     *  l'orbite continue sa course pour s'arrêter exactement sur un multiple
-     *  de 2π (donc visuellement sur la position de base), plutôt que de couper
-     *  la vitesse puis sauter à angle 0. Même principe que AnimationsMngr :
-     *  `beginHomingStop` (mode "normal") décélère à taux constant, avec un tour
-     *  de plus si besoin de confort ; `beginFastHomingStop` (mode "Accéléré")
-     *  rejoint TOUJOURS le prochain passage par la position de base dans une
-     *  durée fixe choisie par l'utilisateur — voir `fastHomingStop.ts`. */
-    private homeBrake?;
+    /** Mouvement en cours (vide à l'arrêt). Angles absolus, ajoutés à l'angle
+     *  de base de chaque satellite. */
+    private motion;
+    /** Mouvement en cours = arrêt "retour à la position de base" : l'orbite
+     *  continue sa course pour s'arrêter exactement sur un multiple de 2π,
+     *  plutôt que de couper la vitesse puis sauter à angle 0. Même principe
+     *  que AnimationsMngr : `beginHomingStop` (mode "normal") décélère à taux
+     *  constant, avec un tour de plus si besoin de confort ;
+     *  `beginFastHomingStop` (mode "Accéléré") rejoint TOUJOURS le prochain
+     *  passage par la position de base dans une durée fixe choisie par
+     *  l'utilisateur — voir `fastHomingStop.ts`. */
+    private homing;
+    /** Satellites et géométrie de la dernière pose (statique ou animée). */
+    private appliedOrbitData;
+    /** Angle de la dernière pose statique. */
+    private appliedAngle;
+    /** Animations posées, par enveloppe d'orbite. */
+    private tracks;
+    /** Satellites recréés pendant le mouvement : animations à reposer. */
+    private tracksStale;
     constructor(deps: ChildrenOrbitManagerDeps);
     invalidateCache(): void;
     buildOrbitData(): ChildrenOrbitEntry[];
+    /** Pose statique (orbite à l'arrêt ou au repos) et rendu complet. */
     applyTransforms(angleOffset: number, orbitData?: ChildrenOrbitEntry[]): void;
+    /** Translation affichée du satellite (repère du parent), y compris en
+     *  plein mouvement : calculée à l'instant de l'image courante. */
+    getChildTranslation(controller: IYinYangController): {
+        x: number;
+        y: number;
+    };
+    private writeTranslations;
     setEnabled(isEnabled: boolean, rampMs?: number): void;
-    /** Change la vitesse cible. Si une boucle est déjà active, elle relit
-     *  orbitSpeed à chaque frame et y converge au rythme de sa rampe en cours
-     *  (pas besoin de la redémarrer) — un changement de vitesse en vol est
-     *  donc lui aussi progressif plutôt que d'un coup. */
+    /** Change la vitesse cible : en vol, le mouvement repart de l'état
+     *  courant et y converge au rythme de la rampe en cours — un changement
+     *  de vitesse est donc lui aussi progressif plutôt que d'un coup. */
     setSpeed(speed: number): void;
     setRadiusScale(scale: number): void;
     /**
      * Démarre (ou modifie en vol) l'orbite. Avec `rampMs > 0`, la vitesse
-     * angulaire part de sa valeur courante (0 si à l'arrêt) et chasse
-     * progressivement `state.children.orbitSpeed` (relu à chaque frame — un
-     * arrêt en cours de freinage repris ici ré-accélère en douceur depuis la
-     * vitesse déjà atteinte). `rampMs` omis (0) → vitesse cible appliquée
+     * angulaire part de sa valeur courante (0 si à l'arrêt) et rejoint
+     * `state.children.orbitSpeed` à accélération constante — un arrêt en
+     * cours de freinage repris ici ré-accélère en douceur depuis la vitesse
+     * déjà atteinte. `rampMs` omis (0) → vitesse cible appliquée
      * instantanément, comportement historique.
      */
     start(_targetSpeed: number, rampMs?: number): void;
+    /** Fin de vie : coupe l'orbite sans rien écrire dans le DOM. */
+    destroy(): void;
     /**
      * Arrête l'orbite. Avec `rampMs > 0` et une orbite en cours, les satellites
      * continuent leur course et décélèrent à taux constant pour s'arrêter
@@ -68,6 +101,24 @@ export declare class ChildrenOrbitManager {
     private computeRemainingToZero;
     private beginHomingStop;
     private beginFastHomingStop;
+    /** Angle et vitesse à l'instant `now`, mouvement en cours ou non. */
+    private currentMotionState;
+    private play;
+    /**
+     * Image d'orbite en vol : les satellites sont déplacés par le navigateur ;
+     * ici, seulement ce qui les suit. Le temps de l'image (rAF) est celui de
+     * `document.timeline` : même angle que celui affiché.
+     */
+    private readonly onFrame;
+    /** (Re)pose une animation par tronçon sur l'enveloppe de chaque satellite. */
+    private syncTracks;
+    private cancelTracks;
+    private cancelFrameLoop;
+    /** Repos à `angle` : pose statique écrite AVANT de retirer les
+     *  animations (même tâche, aucune image entre les deux). */
+    private settle;
     private finalizeStop;
+    /** Horloge des animations (temps de l'image courante). */
+    private now;
 }
 export {};

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

@@ -63,6 +63,8 @@ export declare class OddHighlightEffects {
      * rejouerait l'onde à chaque retour sur la sélection.
      */
     clear(keepOddMemory?: boolean): void;
+    /** Fin de vie : coupe la boucle et retire les couches. */
+    destroy(): void;
     private ensureLayer;
     private ensureLoop;
     private stopLoop;

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

@@ -47,8 +47,10 @@ export declare class OddViewManager {
     /** Satellite sélectionné (menu d'action ouvert) — il porte la même mise en
      *  valeur que celle d'un ODD, mais resserrée sur lui seul. */
     private selectedChildKey;
-    /** Aperçu transitoire au survol d'un item de la pile — prioritaire tant
-     *  qu'il dure, et sans effets de sélection. */
+    /** Satellite source d'un item de la pile — prioritaire tant qu'il dure.
+     *  "soft" : aperçu au survol, sans effets de sélection. "full" : action en
+     *  focus en STACK, même mise en lumière qu'un satellite sélectionné en
+     *  RECHERCHE. */
     private stackPreviewKeys;
     /** Laquelle des deux sélections délibérées — un ODD, ou un satellite — est
      *  la plus récente. Elles peuvent coexister (le menu d'un satellite reste
@@ -96,11 +98,13 @@ export declare class OddViewManager {
      *  de visée + pings + onde de scan, et spikes énergisés avec leurs
      *  comètes. */
     private syncFullHighlightEffects;
+    /** Fin de vie : coupe la boucle des effets de mise en valeur. */
+    destroy(): void;
     /** Relu à chaque frame par OddHighlightEffects : les satellites orbitent
      *  sous les anneaux, et peuvent disparaître (satellites masqués, facette
      *  changée) sans que la mise en valeur soit repassée. */
     private buildHighlightTargets;
-    highlightOddByStackItemId(stackItemId: string | null): void;
+    highlightOddByStackItemId(stackItemId: string | null, intensity?: OddHighlightIntensity): void;
     cancelOddHighlight(): void;
     showOddInfo(oddId: string): void;
     showComposanteInfo(): void;

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

@@ -44,10 +44,24 @@ export declare const HALO_RING: Record<OddHighlightIntensity, {
     glowOpacity: number;
 }>;
 /** Satellite dont le menu d'action est ouvert : blanc pur et plus large, pour
- *  ne pas se confondre avec un membre de l'ODD mis en valeur. */
-export declare const ACTIVE_CHILD_FILTER = "drop-shadow(0 0 12px rgba(255, 255, 255, 0.9)) brightness(1.1)";
+ *  ne pas se confondre avec un membre de l'ODD mis en valeur. La lueur est
+ *  l'anneau ACTIVE_CHILD_GLOW (voir setChildGlowRing), pas un drop-shadow :
+ *  le satellite est en orbite, le flou serait recalculé à chaque image. */
+export declare const ACTIVE_CHILD_FILTER = "brightness(1.1)";
 /** Survol direct d'un satellite — aperçu par-dessus tout le reste. */
-export declare const HOVERED_CHILD_FILTER = "brightness(1.3) drop-shadow(0 0 7px rgba(255,255,255,0.4))";
+export declare const HOVERED_CHILD_FILTER = "brightness(1.3)";
+/** Survol d'un satellite depuis l'arbre Recherche. */
+export declare const SEARCH_HOVERED_CHILD_FILTER = "brightness(1.5)";
+/** Lueur d'un satellite, équivalent de `drop-shadow(0 0 ${blur}px color)`
+ *  (alpha compris dans `alpha`). */
+export type ChildGlow = {
+    color: string;
+    blur: number;
+    alpha: number;
+};
+export declare const ACTIVE_CHILD_GLOW: readonly ChildGlow[];
+export declare const HOVERED_CHILD_GLOW: readonly ChildGlow[];
+export declare const SEARCH_HOVERED_CHILD_GLOW: readonly ChildGlow[];
 /** Aucun ODD mis en valeur et satellite ni actif ni survolé. */
 export declare const IDLE_CHILD_FILTER = "brightness(0.85)";
 /** Sans transition, l'extinction des non-membres se lit comme un
@@ -77,3 +91,31 @@ export declare function resolveChildFilter(params: {
     isPropagationTarget: boolean;
     highlight: ChildHighlightState;
 }): string;
+/** Lueur d'état du satellite (actif), dans le même ordre de priorité que
+ *  resolveChildFilter : seul le satellite actif hors mise en valeur d'ODD en
+ *  a une — les membres ont leur anneau coloré (HALO_RING). */
+export declare function resolveChildGlow(params: {
+    isMember: boolean;
+    isActiveChild: boolean;
+    highlight: ChildHighlightState;
+}): readonly ChildGlow[] | null;
+/**
+ * Pose (ou retire, `glows` null) l'anneau de lueur d'un satellite : des
+ * cercles concentriques translucides juste au-delà de son bord (voir
+ * glowHalo.glowStrokeLayers), dans son globalGroup — ils suivent donc son
+ * orbite sans aucun travail par image, là où un drop-shadow sur le groupe
+ * était recalculé à chaque déplacement.
+ */
+export declare function setChildGlowRing(childController: {
+    view: {
+        viewInitializer: {
+            globalGroup: {
+                node: () => unknown;
+            };
+            positionX: number;
+            positionY: number;
+            borderOuterRadius: number;
+            borderInnerRadius: number;
+        };
+    };
+}, glows: readonly ChildGlow[] | null): void;

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

@@ -83,9 +83,12 @@ 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;
+    /** Affiche le combo source, ou l'action ciblée si le guide vient d'un événement. */
+    showStackItemBlocksForDrag: (stackItemId: string, action: {
+        actionId: string;
+        oddId: string;
+        cuttingIndex: number;
+    }) => void;
     /** Glisser guidé : aperçu en direct des cartes combo selon l'emplacement
      *  survolé (restaure le contenu d'origine hors glisser guidé). */
     refreshGuidedComboPreview: () => void;
@@ -128,8 +131,8 @@ export declare class SearchPanelSynchronizer {
      * Cœur partagé du glisser-déposer vers la pile — entièrement générique
      * (ne connaît ni action ni Événement Clé), utilisé par startSearchActionDrag
      * (hiérarchie RECHERCHE), par ChildActionMenuController (bulle satellite du
-     * diagramme) et par CoreEventMenuController (bulle Événement Clé du cercle
-     * central) : chaque appelant fournit l'icône du fantôme de glisser et un
+     * diagramme) et par KeyEventMenuController (bulle Événement Clé d'un
+     * satellite-facette) : chaque appelant fournit l'icône du fantôme de glisser et un
      * `onDrop` qui sait construire l'item de pile approprié. Retourne `cleanup`
      * comme poignée d'annulation, pour permettre à un appelant de stopper
      * proprement un glisser en cours (ex. fermeture du menu radial en plein

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

@@ -8,7 +8,7 @@ type ControllerSettingsApplierDeps = {
     getOrbitData: () => ChildrenOrbitEntry[];
     updateContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
     updateChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
-    updateCoreEventMenu: () => void;
+    updateKeyEventMenu: () => void;
     applyChildrenFitScale: () => void;
     clearForceFieldComputationState: () => void;
     renderOppositeChildrenForceField: () => void;
@@ -35,10 +35,10 @@ export declare class ControllerSettingsApplier {
     setOddLabelsCompact(compact: boolean): void;
     setChildActionMenuItemDistance(distance: number): void;
     setChildActionMenuItemScale(scale: number): void;
-    setCoreEventMenuDistanceOffset(offset: number): void;
-    setCoreEventMenuItemScale(scale: number): void;
+    setKeyEventMenuDistanceOffset(offset: number): void;
+    setKeyEventMenuItemScale(scale: number): void;
     setChildActionIconFontScale(scale: number): void;
-    setCoreEventIconFontScale(scale: number): void;
+    setKeyEventIconFontScale(scale: number): void;
     setChildLabelMaxLines(lines: number): void;
     setOddLabelMaxLines(lines: number): void;
     setFacetteLabelFontScale(scale: number): void;

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

@@ -94,9 +94,9 @@ export declare class ControllerSession {
         cuttingIndex: number;
         forceOpen: boolean;
     } | null;
-    /** Menu cœur à déployer à l'arrivée sur la facette (voir searchSetKeyEventMenuOpen). */
-    pendingKeyEventMenuAfterSwitch: boolean;
-    isCoreEventMenuOpen: boolean;
+    /** Facette dont le satellite-facette (Idle « facettes ») a ses bulles
+     *  d'Événements Clés déployées, ou null. */
+    keyEventMenuFacetteId: string | null;
     /** 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. */

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

@@ -46,6 +46,16 @@ export type ControllerUiCallbacks = {
      *  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;
+    /** Vrai si au moins un panneau RECHERCHE est verrouillé (multi-blocs) : seul
+     *  ce cas garde l'action active quand on sélectionne un autre satellite, pour
+     *  en consulter la propagation dans le panneau suivant. */
+    isAnyRecherchePanelLocked?: () => boolean;
+    /** Vrai si un panneau RECHERCHE est verrouillé sur une action : elle reste
+     *  l'action source du multi-blocs, aucune autre ne se sélectionne. */
+    isActionSelectionLocked?: () => boolean;
+    /** Clic sur une action alors que la sélection est verrouillée : `retry`
+     *  rejoue ce clic une fois le panneau déverrouillé. */
+    onActionSelectionBlocked?: (retry: () => void) => 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. */