@micheeeeel/yinyangapp 3.0.1 → 3.1.1

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

@@ -5,6 +5,9 @@ import { IYinYangAppFactory } from "../../interfaces/IYinYangAppFactory";
 import { IAnimator } from "../../interfaces/IAnimator";
 import { YinYangInternalModel } from "../../interfaces/IYinYangInternalModel";
 import { ForceFieldLinkDetail } from "./force-field/types";
+import { type IdleTabHooks } from "./children/IdleFacettesController";
+import type { FacetModulation, FacetModulationOptions } from "./children/facetModulation";
+import type { IdleView } from "./state/YinYangControllerState";
 import type { DiagramNavEvent } from "./types";
 export declare class YinYangController implements IYinYangController {
     model: IYinYangModel;
@@ -12,6 +15,9 @@ export declare class YinYangController implements IYinYangController {
     factory: IYinYangAppFactory;
     animator: IAnimator;
     private childControllers;
+    /** Vrai pendant la création des satellites (ChildrenBuilder) : les rendus
+     *  intermédiaires du champ de force y sont ignorés, un seul suit. */
+    private forceFieldRenderSuppressed;
     /** État de la rotation spin (voir startRotation/stopRotationAll) — non nul
      *  tant que la rotation est active, pour que les enfants recréés en cours
      *  de route (createYinYangChildren) démarrent immédiatement avec les mêmes
@@ -22,7 +28,7 @@ export declare class YinYangController implements IYinYangController {
     private readonly ACTION_DRAG_THRESHOLD_PX;
     private actionStackController;
     private childActionMenuController;
-    private coreEventMenuController;
+    private keyEventMenuController;
     private forceFieldDetailsPanel;
     private forceFieldRenderer;
     /** Champ d'événement — liens cœur → satellites amplifiés par l'Événement
@@ -41,6 +47,8 @@ export declare class YinYangController implements IYinYangController {
     private actionStackManager;
     private state;
     private childrenBuilder;
+    private idleFacettes;
+    private onIdleViewChange;
     private componentSwitch;
     private incomingForceField;
     private detailsPresenter;
@@ -56,6 +64,39 @@ export declare class YinYangController implements IYinYangController {
      * Constructor to initialize the controller with its model, view, and factory.
      */
     constructor(model: IYinYangModel, view: IYinYangView, factory: IYinYangAppFactory);
+    /** Sous-état d'Idle affiché quand aucune Facette n'est ouverte : arcs
+     *  pondérés (« arcs ») ou un satellite yin/yang par facette (« facettes »). */
+    getIdleView(): IdleView;
+    /** Crochets de l'hôte autour du sous-état Idle « tab » : `beforeEnter`
+     *  (attendu avant le calcul de la grille — ex. replier des panneaux pour
+     *  agrandir le conteneur du diagramme) et `afterLeave` (satellites revenus
+     *  à leur place radiale — ex. rétablir ces panneaux). */
+    setIdleTabHooks(hooks: IdleTabHooks | null): void;
+    /** Rappel de l'hôte à chaque changement de sous-état Idle (ex. refléter
+     *  l'état d'un bouton « Arcs »). */
+    setOnIdleViewChange(callback: ((view: IdleView) => void) | null): void;
+    /** Bascule vers un sous-état d'Idle. Hors Idle (Facette ouverte), le choix
+     *  est seulement mémorisé : il s'appliquera à la fermeture de la Facette. */
+    setIdleView(view: IdleView): Promise<void>;
+    private isEventFieldInIdleFacettes;
+    /** Amène le diagramme en Idle « facettes » — en refermant la Facette
+     *  ouverte s'il le faut. Résolu une fois les satellites-facettes sortis. */
+    private showIdleFacettes;
+    /** Clic sur le cœur du lobe dominant en Facette : referme la Facette et
+     *  revient à la cause en Idle « facettes », quel que soit le sous-état
+     *  Idle mémorisé. */
+    onFacetteCoreClicked(): void;
+    /** Clic sur l'illustration centrale : facettes ↔ tab (sans effet hors Idle
+     *  et en « arcs »). */
+    toggleIdleView(): Promise<void>;
+    /** Superpose (ou retire, `null`) la lecture d'un contact à une
+     *  signature d'obstacle (OBS-UI-01) — voir
+     *  IdleFacettesController.setModulation. */
+    setFacetModulation(modulation: FacetModulation | null, options?: FacetModulationOptions): Promise<void>;
+    /** Vrai quand le sous-état Idle « facettes » est visé (arcs repliés). */
+    isIdleFacettesActive(): boolean;
+    /** Réaligne le sous-état Idle après une entrée/sortie d'Idle. */
+    syncIdleView(): void;
     /**
      * Retrieves the number of borders for the YinYang view.
      */
@@ -211,6 +252,8 @@ export declare class YinYangController implements IYinYangController {
     private setActiveChild;
     private clearActiveChild;
     private animateChildren;
+    private destroyed;
+    destroy(): void;
     private clearChildren;
     setChildrenOrbitEnabled(isEnabled: boolean, rampMs?: number): void;
     /** Arrête l'orbite des satellites en rejoignant leur position de base dans
@@ -307,10 +350,37 @@ export declare class YinYangController implements IYinYangController {
      * Fermeture du menu radial d'un satellite et de l'action qu'il projetait
      * (champ de force, ghosts, bloc d'action du panneau) — chemin unique partagé
      * par la hiérarchie (deactivateChildMenuFromHierarchy) et par l'exclusivité
-     * action/événement (toggleCoreEventMenu, previewKeyEvent). No-op si aucun
+     * action/événement (toggleKeyEventMenu, previewKeyEvent). No-op si aucun
      * satellite n'est actif.
      */
     private closeChildActionMenu;
+    /**
+     * Sélection courante du diagramme — satellite, sinon ODD mis en valeur,
+     * sinon facette ; null en vue Sphère (aucune facette ouverte). Sert à
+     * mémoriser la sélection propre à un mode au moment de le quitter (voir
+     * PanelManager.rememberStackSelection).
+     */
+    getDiagramSelection(): {
+        type: "composante";
+        componentIndex: number;
+    } | {
+        type: "odd";
+        componentIndex: number;
+        oddId: string;
+    } | {
+        type: "cutting";
+        componentIndex: number;
+        oddId: string;
+        cuttingIndex: number;
+    } | null;
+    /**
+     * Remet le diagramme à blanc sous la facette courante — satellite
+     * désélectionné (menu et action projetée compris), ODD éteint — avant d'y
+     * rejouer la sélection mémorisée d'un mode. La facette elle-même reste
+     * ouverte (vue ODD quittée) : c'est la sélection rejouée qui décide de la
+     * garder, d'en changer ou de la fermer.
+     */
+    clearDiagramSelection(): void;
     deactivateComposanteFromHierarchy(): void;
     /**
      * Fermeture de la facette courante — chemin unique partagé par l'arc de
@@ -335,7 +405,7 @@ export declare class YinYangController implements IYinYangController {
      */
     syncForceFieldToStackMode(): void;
     /**
-     * Recalcule le Champ d'événement pour le mode courant — à appeler APRÈS que
+     * Recalcule les bulles et le Champ d'événement pour le mode courant — APRÈS que
      * l'onglet a réellement basculé (les gardes RECHERCHE/STACK, elles, tournent
      * en phase de capture, avant le toggle de `ff-tab-active`, et liraient donc
      * encore l'ancien mode via isStackModeActive).
@@ -364,18 +434,20 @@ export declare class YinYangController implements IYinYangController {
     /** Centre automatiquement (scroll animé) le bloc "Effets cumulés" correspondant
      *  à cet item de pile, dès qu'il apparaît dans le panneau — voir
      *  ForceFieldDetailsPanel.requestScrollToStackItemBlock. */
+    private _guidedEventPreviewItem;
     /**
      * Glisser guidé d'un prérequis depuis RECHERCHE : la bascule vers STACK
      * faite par le glisser (switchToTab direct, sans le clic d'onglet qui
      * appelle syncForceFieldToStackMode) laissait le panneau sur le satellite
      * de l'action glissée — encore absente de la pile, donc sans aucun bloc.
      * On resynchronise les champs de la pile comme un vrai passage en STACK,
-     * puis on affiche les blocs du satellite de l'action portant le combo,
+     * puis on affiche les blocs du satellite de l'action portant le combo
+     * ou l'aperçu de l'action ciblée par l'événement,
      * sans déplacer la sélection du diagramme (le dépôt s'en charge).
      */
     private showStackItemBlocksForDrag;
     /**
-     * Sélectionne le satellite porteur d'un item de pile (diagramme + panneau)
+     * Sélectionne le satellite porteur ou la Facette d'origine d'un item de pile (diagramme + panneau)
      * et centre son bloc — même effet qu'un clic sur le libellé de l'item
      * (voir setOnSelectStackItemSatellite dans DiagramPanelBridge).
      */
@@ -399,7 +471,8 @@ export declare class YinYangController implements IYinYangController {
     setOnDirectActionBlock(show: (compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void, clear: () => void): void;
     /** Wire from main.ts — injecte la carte descriptive d'un Événement Clé dans l'onglet Recherche. */
     setOnShowKeyEventBlock(show: (compId: string, keyEventId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void, clear: () => void): void;
-    /** Enregistre le miroir "menu cœur déployé ?" vers la hiérarchie RECHERCHE. */
+    /** Enregistre le miroir "bulles d'Événements Clés déployées sur quel
+     *  satellite-facette ?" vers la hiérarchie RECHERCHE. */
     setOnKeyEventMenuStateChange(cb: (componentIndex: number, open: boolean) => void): void;
     /** Wire from main.ts — affiche le bloc d'action directe d'un prérequis dans le panneau B. */
     setOnDirectActionBlockPanelB(show: (compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void) => void): void;
@@ -425,6 +498,19 @@ export declare class YinYangController implements IYinYangController {
     setOnDiagramOddChange(cb: (componentIndex: number, oddId: string, mode: "highlight") => void): void;
     /** Wire from main.ts to sync the search panel on composante / cutting / action clicks. */
     setOnDiagramNavChange(cb: (event: DiagramNavEvent) => void): void;
+    /** Consulter un autre satellite garde l'action active (et son champ de
+     *  force) : toujours en STACK, en RECHERCHE seulement avec un panneau
+     *  verrouillé — voir openActionMenuFromChild. */
+    private keepsActiveActionOnSatelliteSwitch;
+    setIsAnyRecherchePanelLocked(cb: () => boolean): void;
+    /** Multi-blocs : un panneau RECHERCHE verrouillé sur une action la fige
+     *  comme action source — les boutons d'action s'estompent et un clic
+     *  dessus est refusé (voir onActionSelectionBlocked). */
+    setActionSelectionLock(isLocked: () => boolean, onBlocked: (retry: () => void) => void): void;
+    private isActionSelectionLocked;
+    /** Redessine le menu d'actions du satellite sélectionné — après un
+     *  (dé)verrouillage de panneau, qui change l'estompage des boutons. */
+    refreshChildActionMenu(): void;
     setOnDiagramSatelliteDeselect(cb: (componentIndex: number) => void): void;
     setOnDiagramComposanteDeselect(cb: () => void): void;
     setOnDiagramChildHover(cb: (componentIndex: number | null, oddId: string | null, cuttingIndex?: number) => void): void;
@@ -466,9 +552,9 @@ export declare class YinYangController implements IYinYangController {
     setChildActionMenuItemDistance(distance: number): void;
     setChildActionMenuItemScale(scale: number): void;
     setChildActionIconFontScale(scale: number): void;
-    setCoreEventMenuDistanceOffset(offset: number): void;
-    setCoreEventMenuItemScale(scale: number): void;
-    setCoreEventIconFontScale(scale: number): void;
+    setKeyEventMenuDistanceOffset(offset: number): void;
+    setKeyEventMenuItemScale(scale: number): void;
+    setKeyEventIconFontScale(scale: number): void;
     setChildLabelMaxLines(lines: number): void;
     setLabelShortMaxChars(chars: number): void;
     setOddLabelMaxLines(lines: number): void;
@@ -487,13 +573,22 @@ export declare class YinYangController implements IYinYangController {
     private clearProjectedActionState;
     private applyEmptyGhostProjectionState;
     private updateChildActionMenu;
-    /** Clic sur le libellé de l'item en focus dans la pile, rejoué depuis une
-     *  bulle du diagramme — null hors STACK ou sans focus. */
-    private focusedStackItemLabelClick;
+    /**
+     * STACK : une bulle par action activée de la pile dont la source est sur
+     * la facette affichée, sur son satellite source. Comme les champs de
+     * force : l'action en focus ressort, les autres s'estompent, et toutes
+     * sont pleines quand aucune n'est en focus.
+     */
+    private buildStackDetachedBubbles;
+    /**
+     * RECHERCHE multi-blocs (panneau verrouillé) : l'action active garde ses
+     * champs de force pendant qu'on consulte un autre satellite — sa bulle
+     * reste donc visible sur la source, que le menu radial ne montre plus.
+     */
+    private buildRechercheDetachedBubbles;
     /** Sélectionne (ouvre) le satellite `childKey` de la facette courante,
      *  comme un clic dessus — sans toggle-close s'il est déjà actif. */
     private selectSatelliteByKey;
-    onCoreEventNucleusClicked(): void;
     searchNavigateToKeyEvent(keyEventId: string): void;
     restoreKeyEventDiagramState(keyEventId: string): void;
     searchSetKeyEventMenuOpen(componentIndex: number, open: boolean): void;
@@ -554,7 +649,7 @@ export declare class YinYangController implements IYinYangController {
     /**
      * Mode adverse (outil de debug, voir adverseMode.ts) : les actions et
      * Événements adverses remplacent les ordinaires sur le diagramme (bulles
-     * des satellites, menu cœur) et dans l'arbre RECHERCHE — qui se
+     * des satellites et des satellites-facettes) et dans l'arbre RECHERCHE — qui se
      * reconstruit seul à la bascule. La pile n'est jamais filtrée.
      *
      * Hors STACK, l'action ou l'Événement en aperçu de l'autre bord perdrait

package/dist/types/components/controller/action-stack/ActionStackController.d.ts

@@ -75,6 +75,8 @@ export declare class ActionStackController {
      * ActionStackState.addItem, sans muter la pile. null hors zone de dépôt.
      */
     getPriorIdsIfInsertedAtPreview(anchorItemId: string, insertedActionId: string): string[] | null;
+    /** Projection d'une insertion externe, sans mutation de la pile ni de l'historique. */
+    getItemsIfInsertedAtPreview(inserted: ActionStackItem): ActionStackItem[] | null;
     /** Fin du glisser (dépôt ou abandon). Les barres restent affichées ; un
      *  dépôt consomme le guide, un abandon le garde pour un nouvel essai. */
     endPrereqDragGuide(dropped: boolean): void;
@@ -100,6 +102,15 @@ export declare class ActionStackController {
      */
     private _hitboxEmphasisStyle;
     private _applyHitboxEmphasisStyles;
+    /** Couleur du libellé d'un item — éclairci pour l'item en focus. */
+    private _stackLabelFill;
+    /**
+     * Marques propres à l'item en focus, indépendantes du cadre : liseré plein
+     * à sa couleur sur le bord gauche (pendant du border-left du bloc
+     * .ff-block--focused dans le panneau) et libellé éclairci en gras. Elles
+     * restent visibles quand le survol lié prend la main sur le cadre.
+     */
+    private _applyFocusMarks;
     /**
      * Affiche temporairement le highlight combo (cercles de fenêtre) pendant ~1.8 s.
      * Sans effet si un highlight permanent est déjà actif.
@@ -142,7 +153,7 @@ export declare class ActionStackController {
      *  ActionStackState.addItemAtSlot. Même remise à zéro de l'aperçu de
      *  glisser qu'addItem, pour la même raison (rendu synchrone dans
      *  state.addItemAtSlot). */
-    addItemAtSlot(item: Omit<ActionStackItem, "id" | "validatedAt" | "slotIndex">, slotIndex: number): ActionStackItem;
+    addItemAtSlot(item: Omit<ActionStackItem, "id" | "validatedAt" | "slotIndex">, slotIndex: number): ActionStackItem | null;
     syncActiveAction(sourceChildKey: string | null, actionId: string | null): void;
     setExternalDragActive(active: boolean): void;
     clearDropPreview(): void;
@@ -195,5 +206,9 @@ export declare class ActionStackController {
     copyRangeToClipboard(): void;
     /** Pastes the clipboard at the top of the currently active stack. */
     pasteClipboard(): void;
+    /** Fin de vie : observer déconnecté, minuterie du flash et écouteur
+     *  clavier retirés. */
+    destroy(): void;
+    private keydownHandler;
     private ensureKeyboardListeners;
 }

package/dist/types/components/controller/action-stack/ActionStackDragHandler.d.ts

@@ -83,6 +83,10 @@ export declare class ActionStackDragHandler {
         compactLength: number;
     }): void;
     clearDropPreview(): void;
+    /** Zone de dépôt relue à l'instant : un glisser venu du diagramme ou de
+     *  RECHERCHE bascule en mode STACK, dont le panneau entre alors en glissant
+     *  depuis la gauche — la géométrie du dernier rendu serait périmée. */
+    private liveDropZone;
     updateDropPreview(clientX: number, clientY: number, _localY: number): boolean;
     isDropZoneHit(clientX: number, clientY: number): boolean;
     getInsertionPreviewIndex(): number | null;

package/dist/types/components/controller/action-stack/ActionStackManager.d.ts

@@ -41,7 +41,7 @@ type ActionStackManagerDeps = {
     prepareForComponentSwitch: (targetComponentId: string) => void;
     animateChildrenHide: () => void;
     recomputeIncomingForceFieldForItems: (items: ActionStackItem[], sourceComponentId: string, currentComponentId: string) => boolean;
-    buildProjectionActionsFromStackItems: (items: ActionStackItem[]) => SequentialActionProjectionInput[];
+    buildProjectionActionsFromStackItems: (items: ActionStackItem[], eventContextItems?: ActionStackItem[]) => SequentialActionProjectionInput[];
     buildForceFieldSourceIndicesFromStackItems: (items: ActionStackItem[]) => number[];
     clearProjectedActionState: (options?: {
         deselect?: boolean;
@@ -119,7 +119,18 @@ export declare class ActionStackManager {
      *  ODD, métadonnées de son cutting. Null si le satellite est inconnu. */
     private buildActionStackItem;
     activateActionFromChild(childController: IYinYangController, actionId?: string, label?: string, clearStack?: boolean): void;
-    applyProjectedGhostFromStackItems(items: ActionStackItem[]): void;
+    private panelsRefreshFrameId;
+    /** Rend, à la frame suivante, les panneaux dépendants de l'action active :
+     *  détails du ghost, deltas des satellites, puis le menu radial en dernier
+     *  (il rebranche ses closures de clic sur l'activeActionId posé par
+     *  l'activation, voir refreshChildActionMenu). Plusieurs activations dans la
+     *  même frame se fondent en un seul rendu. Si l'action n'est plus active à
+     *  l'échéance (désactivée, ou remplacée), le flux qui l'a remplacée a rendu
+     *  son propre état : rien à faire. */
+    /** Fin de vie : annule le rendu différé des panneaux. */
+    destroy(): void;
+    private schedulePanelsRefresh;
+    applyProjectedGhostFromStackItems(items: ActionStackItem[], eventContextItems?: ActionStackItem[]): void;
     onStackItemVisibilityToggle(activeItems: ActionStackItem[]): void;
     private updateProjectedGhostTensions;
     private applyEmptyGhostProjectionState;

package/dist/types/components/controller/action-stack/ActionStackState.d.ts

@@ -2,8 +2,7 @@ export type ActionStackItem = {
     id: string;
     /**
      * Nature de l'item — "action" (par défaut) pour une action satellite
-     * classique, "keyEvent" pour un Événement Clé joué depuis le cercle
-     * central d'une facette. Un keyEvent n'a pas de satellite cible (les
+     * classique, "keyEvent" pour un Événement Clé joué depuis le satellite-facette. Un keyEvent n'a pas de satellite cible (les
      * champs source* ci-dessous sont des sentinels dans ce cas) ni de delta
      * propre (effectiveDelta reste 0) — son seul effet est d'amplifier les
      * actions listées dans sa définition, si elles sont jouées après lui
@@ -31,6 +30,7 @@ export type ActionStackItem = {
     comboResults?: import("../../../data/combo-engine").ComboResult[];
     /** Index du slot occupé dans la pile (0 = en bas, croissant vers le haut). */
     slotIndex: number;
+    unrecognized?: boolean;
 };
 /** Champs persistants d'un item copié — sans id/validatedAt/slotIndex, qui sont
  *  réattribués à l'insertion (dans la même pile ou une autre, via un bookmark). */
@@ -61,6 +61,7 @@ export type ActionStackSnapshot = StackState & {
 export declare class ActionStackState {
     private readonly onActiveItemsChange;
     private readonly onClear?;
+    private readonly isKnownItem?;
     readonly ACTION_STACK_MAX_ITEMS = 30;
     readonly HISTORY_LIMIT = 120;
     readonly CONFIG_BOOKMARKS_MAX = 4;
@@ -76,7 +77,7 @@ export declare class ActionStackState {
     stackClipboard: StackClipboardEntry[] | null;
     configBookmarks: ConfigBookmark[];
     activeBookmarkIndex: number;
-    constructor(onActiveItemsChange: (activeItems: ActionStackItem[]) => void, onClear?: (() => void) | undefined);
+    constructor(onActiveItemsChange: (activeItems: ActionStackItem[]) => void, onClear?: (() => void) | undefined, isKnownItem?: ((item: ActionStackItem) => boolean) | undefined);
     canUndo(): boolean;
     canRedo(): boolean;
     getItemById(id: string): ActionStackItem | undefined;
@@ -106,7 +107,7 @@ export declare class ActionStackState {
      * @param compactLength  Current number of visible slots (from render context).
      *                       Null when called without a specific insertion index.
      */
-    addItem(item: Omit<ActionStackItem, "id" | "validatedAt" | "slotIndex">, insertAtVisibleIndex: number | null, compactLength: number | null): ActionStackItem;
+    addItem(item: Omit<ActionStackItem, "id" | "validatedAt" | "slotIndex">, insertAtVisibleIndex: number | null, compactLength: number | null): ActionStackItem | null;
     /**
      * Insère à un slot ABSOLU (0 = bas de pile), en décalant d'un cran tout
      * item situé à ce slot ou au-dessus — inconditionnellement, même si le
@@ -115,8 +116,10 @@ export declare class ActionStackState {
      * insertion. addItem, lui, n'a pas cette garantie (il ne décale qu'en
      * présence d'un occupant, et raisonne en index visible).
      */
-    addItemAtSlot(item: Omit<ActionStackItem, "id" | "validatedAt" | "slotIndex">, slotIndex: number): ActionStackItem;
+    addItemAtSlot(item: Omit<ActionStackItem, "id" | "validatedAt" | "slotIndex">, slotIndex: number): ActionStackItem | null;
     private pushItemAtSlot;
+    /** Unicité par carte sur toute la STAC, y compris les items décochés. */
+    private hasKeyEvent;
     removeItem(itemId: string): void;
     clearAll(): void;
     deselectAllItems(): void;

package/dist/types/components/controller/action-stack/StackFocusController.d.ts

@@ -45,9 +45,11 @@ export declare class StackFocusController {
     setStackItemEmphasisPreview(stackItemId: string | null): void;
     /**
      * Point d'accroche unique de la mise en valeur du satellite source de
-     * l'action portant l'emphase (aperçu ?? focus). Réutilise pour l'instant
-     * le glow de highlightOddByStackItemId (ou le segment de bordure si la
-     * source est dans une autre facette) — l'anneau animé viendra ici.
+     * l'action portant l'emphase (aperçu ?? focus) : pour l'action en focus,
+     * la même mise en lumière que le satellite sélectionné en RECHERCHE
+     * (anneaux de visée, pings, onde de scan) ; pour un simple aperçu au
+     * survol, le glow doux. Segment de bordure si la source est dans une
+     * autre facette.
      * `clearIfNone` : sans emphase, efface la mise en valeur (sorties de
      * survol, défocus) ; false pour les simples re-applications (satellites
      * recréés, fin d'un survol de satellite) afin de ne pas écraser d'autres
@@ -89,10 +91,9 @@ export declare class StackFocusController {
         sourceIndex: number;
     } | null;
     /**
-     * Point de départ « bulle » du champ de force de l'action en focus : la
-     * bulle de son action dans le menu radial si le satellite source est celui
-     * sélectionné, sinon la bulle détachée posée sur la source. null si
-     * aucune bulle n'est visible (le champ démarre alors au satellite).
+     * Point de départ « bulle » du champ de force de l'action en focus : sa
+     * bulle détachée, posée sur le satellite source. null si aucune bulle
+     * n'est visible (le champ démarre alors au satellite).
      */
     resolveFocusBubbleStub(): {
         sourceChildIndex: number;

package/dist/types/components/controller/action-stack/stackChromePalette.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Habillage ambre de la pile (mode STACK) — pendant SVG des variables
+ * --stack-* de layout.css. Ne couvre que le décor (bordures, en-tête,
+ * boutons, frise temporelle) : les couleurs porteuses d'état (configurations
+ * A/B/C/D, placeholder de dépôt, phases, items actifs) restent les leurs.
+ */
+export declare const STACK_CHROME: {
+    readonly line: "#3a2f1e";
+    readonly headerText: "#e8c07a";
+    readonly buttonStroke: "#6a5028";
+    readonly buttonIcon: "#e8c07a";
+    readonly ghostSlotDots: "rgba(130, 98, 48, 0.55)";
+    readonly ghostSlotNumber: "rgba(120, 90, 45, 0.50)";
+    readonly timelineBandFill: "rgba(232, 168, 64, 0.06)";
+    readonly timelineBandStroke: "rgba(232, 168, 64, 0.18)";
+    readonly timelineAxis: "rgba(232, 168, 64, 0.50)";
+    readonly timelineArrow: "rgba(232, 168, 64, 0.65)";
+    readonly timelineTickOccupied: "rgba(240, 195, 110, 0.75)";
+    readonly timelineTick: "rgba(232, 168, 64, 0.40)";
+};

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

@@ -1,5 +1,7 @@
+import type { KeyEventPropagationContext } from "../../../data/key-event-propagation";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { type PropagatedActionEdge, type PropagationTruncation } from "../../../utils/actionPropagation";
+import { type StabilityProtection, type ProtectedSign, type DirectionalShield } from "../../../data/stability-shield";
 import { ForceFieldLink } from "../force-field/types";
 export type ProjectedCuttingState = {
     cuttingId: number;
@@ -15,6 +17,7 @@ export type GhostProjectionResult = {
     projectedGhostCuttingStatesByOddId: Map<string, ProjectedCuttingState[]>;
 };
 export type SequentialActionProjectionInput = {
+    eventPropagation?: KeyEventPropagationContext;
     sourceOddId: string;
     sourceCuttingIndex: number;
     /** Bouclier de stabilité (points d'état) que cette action crée sur son
@@ -23,6 +26,7 @@ export type SequentialActionProjectionInput = {
      *  résolutions suivantes de la séquence, jamais consommé ; le plus fort
      *  remplace le précédent sur un même satellite. */
     shield?: number;
+    protectedSign?: ProtectedSign;
 };
 export type EmptyGhostProjectionState = {
     projectedGhostTensionByOddId: null;
@@ -45,6 +49,7 @@ export type ShieldAbsorption = {
     shield: number;
     aggregated: number;
     applied: number;
+    protectedSign?: ProtectedSign;
 };
 /**
  * Bouclier de stabilité sur UNE résolution : pour chaque satellite protégé,
@@ -53,11 +58,16 @@ export type ShieldAbsorption = {
  * total une seule fois — jamais chaque contribution séparément, jamais
  * au-delà de 0. Mute `projectedStates` et rend les réductions appliquées.
  */
-export declare function applyStabilityShieldsToResolution(startStates: Record<string, Record<number, number>>, projectedStates: Record<string, Record<number, number>>, activeShields: Map<string, Map<number, number>>): ShieldAbsorption[];
+export type SignedResolutionContributions = Record<string, Record<number, {
+    positive: number;
+    negative: number;
+}>>;
+export declare function applyStabilityShieldsToResolution(startStates: Record<string, Record<number, number>>, projectedStates: Record<string, Record<number, number>>, activeShields: Map<string, Map<number, StabilityProtection>>, contributions?: SignedResolutionContributions): ShieldAbsorption[];
 export type ActionSequenceStepInfo = {
     actionIndex: number;
     action: SequentialActionProjectionInput;
     effectiveDelta: number;
+    createdProtection?: DirectionalShield;
     /** Boucliers ayant réduit une contribution négative de cette étape — vide
      *  si aucun satellite protégé n'a été touché négativement. */
     shieldAbsorptions: ShieldAbsorption[];
@@ -97,6 +107,7 @@ export declare function projectGhostStateForComponent(params: {
     sourceOddId: string | undefined;
     sourceCuttingIndex: number;
     actionDelta: number;
+    eventPropagation?: KeyEventPropagationContext;
 }): GhostProjectionResult | null;
 /** Tension projetée de la facette : même règle que sa tension courante
  *  (`facetTensionFromOdds`, moyenne pondérée sur tous ses satellites), sur