@micheeeeel/yinyangapp 1.0.6 → 2.0.1

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

@@ -0,0 +1,17 @@
+/**
+ * Tracks how many "blocking" animations (rotation, facette/ODD switch, and any
+ * future one) are currently running for a single YinYangController instance.
+ * Animation subsystems register themselves via begin()/end() instead of the
+ * gate having to know about each animation source individually — a new
+ * animation only has to call begin()/end() around its own loop to be covered.
+ */
+export declare class BlockingAnimationTracker {
+    private active;
+    private onChangeCb;
+    /** Called whenever the tracker transitions between "nothing active" and
+     *  "something active" (in either direction). */
+    onChange(cb: () => void): void;
+    begin(label: string): symbol;
+    end(token: symbol): void;
+    get isAnyActive(): boolean;
+}

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

@@ -0,0 +1,176 @@
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ForceFieldLink, ForceFieldLinkDetail } from "../force-field/types";
+import { EventFieldTarget } from "../utils/eventFieldTargets";
+import { ProjectedCuttingState } from "../actions/ActionProjectionService";
+import { BlockingAnimationTracker } from "./BlockingAnimationTracker";
+type GhostState = {
+    projectedGhostTensionByOddId: Map<string, number> | null;
+    projectedGhostStateByOddId: Map<string, number> | null;
+    projectedGhostComponentTension: number | null;
+    projectedGhostCuttingStatesByOddId: Map<string, ProjectedCuttingState[]> | null;
+};
+export declare class YinYangControllerState {
+    children: {
+        enabled: boolean;
+        pendingRefresh: boolean;
+        activeChildKey: string | null;
+        orbitFrameId: number | undefined;
+        orbitEnabled: boolean;
+        orbitAngle: number;
+        orbitSpeed: number;
+        orbitRadiusScale: number;
+    };
+    menu: {
+        hasActiveChildAction: boolean;
+        activeChildKey: string | null;
+        /** Key of the cutting that owns the currently active action (may differ from
+         *  activeChildKey when the user browses another cutting's buttons while an
+         *  action is active). */
+        actionSourceChildKey: string | null;
+        activeActionId: string | null;
+        activeActionLabel: string | null;
+        itemDistance: number;
+        itemScale: number;
+        iconFontScale: number;
+        /** Ajustement fin (px) de la distance des boutons d'Événement Clé,
+         *  de part et d'autre de la longueur auto-calculée (voir
+         *  CoreEventMenuController — offsetDistance dérivé de l'orbite des
+         *  satellites, pas de contrôle dédié à cette base). */
+        coreEventMenuDistanceOffset: number;
+        /** Taille des boutons du menu radial des Événements Clés — contrôle dédié
+         *  ("Taille boutons", groupe "Événements clés"), séparé de itemScale qui
+         *  ne pilote que les boutons d'action des satellites. */
+        coreEventMenuItemScale: number;
+        /** Taille des icônes dans les bulles du menu radial des Événements Clés —
+         *  contrôle dédié ("Taille icônes", groupe "Événements clés"), séparé de
+         *  iconFontScale qui ne pilote que les icônes d'action des satellites. */
+        coreEventIconFontScale: number;
+    };
+    action: {
+        propagationFactor: number;
+        delta: number;
+    };
+    visibility: {
+        actionDeltaLabels: boolean;
+        childrenContextLabels: boolean;
+        allLabelsVisible: boolean;
+    };
+    /** Réglages "Combos" — voir combo-engine.ts pour la sémantique exacte de
+     *  chaque plafond levé. Bornés (false) par défaut : comportement actuel. */
+    combos: {
+        /** Lève le plafond à 1 sur le ratio de performance des prérequis
+         *  DÉCLENCHEURS (combos non dangereux), ce qui autorise une cascade de
+         *  combos à dépasser ×2. N'affecte pas les prérequis PROTECTEURS d'un
+         *  combo dangereux (voir dangerousComboCanBecomeBonus). */
+        uncappedChainedPerformance: boolean;
+        /** Lève le plafond à 1 sur le ratio de performance des prérequis
+         *  PROTECTEURS d'un combo dangereux, ce qui permet à m = avgRatio de
+         *  dépasser ×1 (le risque devient un bonus net). N'affecte pas les
+         *  combos non dangereux (voir uncappedChainedPerformance). */
+        dangerousComboCanBecomeBonus: boolean;
+    };
+    labels: {
+        fontScale: number;
+        componentFontScale: number;
+        oddFontScale: number;
+        facetteFontScale: number;
+        facetteSuffixVisible: boolean;
+        childStateDeltaFontScale: number;
+        childStateDeltaOffset: number;
+        childStateDeltaBoxScale: number;
+        componentLegendFontScale: number;
+        legendLabelsBgEnabled: boolean;
+        textShadowEnabled: boolean;
+        childMaxLines: number;
+        oddMaxLines: number;
+        labelShortMaxChars: number;
+        childPlacement: "top" | "bottom";
+        displayEllipsisForShortLabels: boolean;
+    };
+    forceField: {
+        randomCount: number;
+        sourceChildIndex: number;
+        sourceChildIndices: number[];
+        links: ForceFieldLink[];
+        allLinkDetails: ForceFieldLinkDetail[];
+        incomingMode: boolean;
+        frameId: number | undefined;
+        phase: number;
+        lastTimestamp: number | undefined;
+        orbitData: ChildrenOrbitEntry[] | null;
+        revealStartedAt: number | undefined;
+        selectedLinkIndex: number | null;
+    };
+    eventField: {
+        targets: EventFieldTarget[];
+        frameId: number | undefined;
+        phase: number;
+        lastTimestamp: number | undefined;
+        revealStartedAt: number | undefined;
+    };
+    ghost: GhostState;
+    /** Registers rotation / facette-switch / any future animation that should
+     *  block ghost display while active. See YinYangController.beginBlockingAnimation. */
+    blockingAnimations: BlockingAnimationTracker;
+    setActiveChildKey(childKey: string | null): void;
+    setChildrenEnabled(isEnabled: boolean): void;
+    setChildrenPendingRefresh(isPending: boolean): void;
+    setOrbitEnabled(isEnabled: boolean): void;
+    setOrbitSpeed(speed: number): void;
+    setOrbitRadiusScale(scale: number): void;
+    setOrbitFrameId(frameId: number | undefined): void;
+    resetOrbitAngle(): void;
+    clearMenuActiveSelection(): void;
+    setMenuActiveChild(childKey: string | null): void;
+    setActionSourceChildKey(childKey: string | null): void;
+    setMenuActiveAction(actionId: string | null): void;
+    setHasActiveChildAction(isActive: boolean): void;
+    setForceFieldSourceChildIndex(index: number): void;
+    setForceFieldSourceChildIndices(indices: number[]): void;
+    setIncomingForceFieldLinks(links: ForceFieldLink[], allDetails: ForceFieldLinkDetail[]): void;
+    setForceFieldRandomCount(count: number): void;
+    setActionDeltaLabelsVisible(isVisible: boolean): void;
+    setComboUncappedChainedPerformance(isEnabled: boolean): void;
+    setComboDangerousCanBecomeBonus(isEnabled: boolean): void;
+    setChildrenContextLabelsVisible(isVisible: boolean): void;
+    getAllLabelsVisible(): boolean;
+    setAllLabelsVisible(isVisible: boolean): void;
+    setLabelsFontScale(scale: number): void;
+    setLabelsTextShadowEnabled(isEnabled: boolean): void;
+    setChildLabelPlacement(position: "top" | "bottom"): void;
+    setComponentLabelFontScale(scale: number): void;
+    setChildStateDeltaFontScale(scale: number): void;
+    setChildStateDeltaOffset(offset: number): void;
+    setChildStateDeltaBoxScale(scale: number): void;
+    setOddLabelFontScale(scale: number): void;
+    setFacetteLabelFontScale(scale: number): void;
+    setFacetteLabelSuffixVisible(isVisible: boolean): void;
+    setComponentLegendLabelFontScale(scale: number): void;
+    setLegendLabelsBgEnabled(enabled: boolean): void;
+    setMenuItemDistance(distance: number): void;
+    setMenuItemScale(scale: number): void;
+    setMenuIconFontScale(scale: number): void;
+    setCoreEventMenuDistanceOffset(offset: number): void;
+    setCoreEventMenuItemScale(scale: number): void;
+    setCoreEventIconFontScale(scale: number): void;
+    setChildLabelMaxLines(lines: number): void;
+    setOddLabelMaxLines(lines: number): void;
+    setLabelShortMaxChars(chars: number): void;
+    setDisplayEllipsisForShortLabels(enabled: boolean): void;
+    setForceFieldOrbitData(orbitData: ChildrenOrbitEntry[] | null): void;
+    setForceFieldFrameId(frameId: number | undefined): void;
+    setForceFieldLastTimestamp(timestamp: number | undefined): void;
+    setForceFieldSelectedLinkIndex(index: number | null): void;
+    setForceFieldRevealStartedAt(timestamp: number | undefined): void;
+    setForceFieldLinksAndDetails(links: ForceFieldLink[], allLinkDetails: ForceFieldLinkDetail[]): void;
+    setEventFieldTargets(targets: EventFieldTarget[]): void;
+    setEventFieldFrameId(frameId: number | undefined): void;
+    setEventFieldLastTimestamp(timestamp: number | undefined): void;
+    setEventFieldPhase(phase: number): void;
+    setEventFieldRevealStartedAt(timestamp: number | undefined): void;
+    toggleForceFieldSelection(index: number): boolean;
+    applyGhostProjection(ghost: GhostState): void;
+    clearForceFieldComputation(): void;
+    resetGhostProjection(): void;
+}
+export {};

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

@@ -0,0 +1,13 @@
+export type StackLayoutMetrics = {
+    firstSlotCenterY: number;
+    slotSpacing: number;
+    compactLength: number;
+};
+export type ClientRectLike = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare function getStackInsertionIndexFromGlobalY(globalY: number, metrics: StackLayoutMetrics | null): number;
+export declare function isPointInsideClientRect(clientX: number, clientY: number, rect: ClientRectLike | null): boolean;

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

@@ -0,0 +1,7 @@
+export declare function reorderStackItemsByVisibleIndex<T extends {
+    id: string;
+}>(params: {
+    items: T[];
+    itemId: string;
+    targetVisibleIndex: number;
+}): T[];

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

@@ -0,0 +1,18 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+export type ChildrenOrbitEntry = {
+    controller: IYinYangController;
+    dx: number;
+    dy: number;
+    radius: number;
+    baseAngle: number;
+};
+export declare function buildChildrenOrbitData(params: {
+    parentX: number;
+    parentY: number;
+    childControllers: IYinYangController[];
+    radiusScale: number;
+}): ChildrenOrbitEntry[];
+export declare function computeOrbitTranslation(orbitEntry: ChildrenOrbitEntry, angleOffset: number): {
+    x: number;
+    y: number;
+};

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

@@ -0,0 +1,9 @@
+import { YinYangComponentNode } from "../../../interfaces/IYinYangInternalModel";
+export declare function getComponentTitle(component: YinYangComponentNode | null | undefined): string;
+export declare function getCuttingLabel(component: YinYangComponentNode | null | undefined, oddId: string, cuttingIndex: number): string;
+export declare function getCuttingShortLabel(params: {
+    component: YinYangComponentNode | null | undefined;
+    oddId: string;
+    cuttingIndex: number;
+    maxChars: number;
+}): string;

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

@@ -0,0 +1,13 @@
+export type EventFieldColors = {
+    /** Cordon au repos entre deux souffles — presque éteint. */
+    cord: string;
+    /** Segment de cordon allumé par le passage d'un anneau. */
+    capsule: string;
+    /** Anneaux émis par le cœur, et halo général. */
+    ring: string;
+    glow: string;
+    /** Blanc chaud du point d'impact. */
+    core: string;
+};
+export declare function getEventFieldColors(): EventFieldColors;
+export declare function getEventFieldCapsuleWidth(scoreBonus: number): number;

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

@@ -0,0 +1,47 @@
+import type { ActionStackItem } from "../action-stack/ActionStackController";
+import type { KeyEventDefinition } from "../../../data/yasuni_key_events";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+export type EventFieldTarget = {
+    /** Index dans childControllers de la facette active — cible dans la même
+     *  facette que le cœur émetteur. */
+    childIndex?: number;
+    /** Id de la facette cible, quand le satellite amplifié vit dans une autre
+     *  facette — résolu par l'appelant vers le point de bordure de son arc
+     *  (même mécanisme que ForceFieldRenderer pour les champs de force
+     *  cross-composante). */
+    targetComponentId?: string;
+    /** Bonus de score de l'événement pour un satellite réellement amplifié,
+     *  0 pour un satellite simplement à portée — pilote l'épaisseur du
+     *  souffle (voir getEventFieldCapsuleWidth). */
+    scoreBonus: number;
+};
+/**
+ * Whether `keyEvent`'s static scope (collectReachedSatellites) includes at
+ * least one satellite living in `componentId`. Used when the user switches
+ * facette to decide whether the active Champ d'événement should keep
+ * driving the field in the destination facette (incoming continuation) or
+ * be cleared like it is for any unrelated facette — see
+ * YinYangController.prepareForComponentSwitch.
+ */
+export declare function keyEventReachesComponent(keyEvent: KeyEventDefinition, componentId: string): boolean;
+/**
+ * Résout les cibles du "Champ d'événement" pour l'Événement Clé actuellement
+ * actif (aperçu ou validé) : sa portée statique, résolue en index de satellite
+ * dans la facette courante ou en id de facette distante.
+ *
+ * L'épaisseur du souffle distingue les satellites RÉELLEMENT amplifiés ici et
+ * maintenant — ceux dont une action ciblée est cochée dans la pile — de ceux
+ * qui ne sont qu'à portée : les premiers reçoivent le bonus de score de
+ * l'événement, les seconds 0 (souffle minimal).
+ */
+export declare function buildEventFieldTargets(params: {
+    keyEvent: KeyEventDefinition;
+    activeItems: ActionStackItem[];
+    currentComponentId: string | undefined;
+    childControllers: IYinYangController[];
+    childOddMap: Map<string, {
+        oddId: string;
+        score: number;
+        cuttingIndex: number;
+    }>;
+}): EventFieldTarget[];

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

@@ -0,0 +1,4 @@
+export declare function getInterOddRationale(componentId: string, fromOddId: string, toOddId: string): string | null;
+export declare function getLayersInvolved(componentId: string, fromOddId: string, toOddId: string): string[];
+export declare function getLocalLayerWeightSummary(componentId: string, fromOddId: string, toOddId: string): string | null;
+export declare function getBridgeLayerWeightSummary(componentId: string, fromOddId: string, toOddId: string): string | null;

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

@@ -0,0 +1,9 @@
+export type ForceFieldLayerType = "inter" | "intra" | "bridge";
+export type ForceFieldDeltaDetail = {
+    layerType: ForceFieldLayerType;
+    deltaTo: number;
+};
+export declare function getForceFieldWeightLabel(layerType: ForceFieldLayerType): string;
+export declare function getLayerDisplayName(layerType: ForceFieldLayerType): string;
+export declare function getPropagationCardTitle(layerType: ForceFieldLayerType): string;
+export declare function calculateDisplayedDelta(details: ForceFieldDeltaDetail[]): number;

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

@@ -0,0 +1,10 @@
+export type ForceFieldColors = {
+    aura: string;
+    auraGlow: string;
+    energy: string;
+    energyGlow: string;
+    core: string;
+    coreGlow: string;
+};
+export declare function getForceFieldThickness(weight: number): number;
+export declare function getForceFieldColors(potentialGain: number): ForceFieldColors;

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

@@ -0,0 +1,5 @@
+export declare function calculateBestShortLabelPosition(childCenterX: number, childCenterY: number, childRadius: number, parentCenterX: number, parentCenterY: number): {
+    x: number;
+    y: number;
+    angle: number;
+};

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

@@ -0,0 +1,2 @@
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+export declare function resolveOddCuttingId(component: YinYangInternalModel["components"][number], oddId: string, cuttingIndex: number): number | undefined;

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

@@ -0,0 +1,9 @@
+export declare function clientPointToGroupCoordinates(params: {
+    clientX: number;
+    clientY: number;
+    group: SVGGElement | null;
+    svg: SVGSVGElement | null;
+}): {
+    x: number;
+    y: number;
+} | null;

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

@@ -0,0 +1,5 @@
+export declare function parseTranslateTransform(transform: string): {
+    x: number;
+    y: number;
+    found: boolean;
+};

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

@@ -0,0 +1,2 @@
+export declare function wrapText(text: string, maxLines: number): string[];
+export declare function truncateStackLabel(label: string | undefined, maxWidthPx: number, fontSizePx: number): string;

package/dist/types/components/controls/VizControlsPanel.d.ts

@@ -0,0 +1,14 @@
+import { YinYangController } from "../controller/YinYangController";
+import { YinYangAppFactory } from "../factory/YinYangAppFactory";
+export interface VizControlsDeps {
+    controllerCause: YinYangController;
+    factory: YinYangAppFactory;
+    layoutState: {
+        actionStackColumnWidth: number;
+    };
+    renderColumnLayouts: () => void;
+    animationConfig: {
+        rotationDurationMs: number;
+    };
+}
+export declare function mountVizControls(deps: VizControlsDeps): void;

package/dist/types/components/factory/YinYangAppFactory.d.ts

@@ -1,11 +1,11 @@
 import { AnimationsMngr } from "../../animations/AnimationsMngr";
-import { IOddItem } from "../../interfaces/IOddItem";
 import { IYinYangModel } from "../../interfaces/IYinYangModel";
 import { IYinYangView } from "../../interfaces/IYinYangView";
 import { IYinYangController } from "../../interfaces/IYinYangController";
 import { IGraphicsStrategy } from "../../interfaces/IGraphicsStrategy";
 import { IYinYangAppFactory } from "../../interfaces/IYinYangAppFactory";
 import { IViewData } from "../../interfaces/IViewData";
+import { YinYangInternalModel } from "../../interfaces/IYinYangInternalModel";
 export declare class YinYangAppFactory implements IYinYangAppFactory {
     instances: Map<string, IYinYangController>;
     private idCounter;
@@ -23,12 +23,11 @@ export declare class YinYangAppFactory implements IYinYangAppFactory {
     /**
      * Creates a new YinYang model.
      *
-     * @param modelData - Data for the model based on IOddItem.
-     * @param isEnemy - Indicates if the model is for an enemy (defaults to true).
+     * @param modelData - Internal model data for the instance.
      * @param parentKey - The key of the parent model if any.
      * @returns A new instance of YinYangModel.
      */
-    createModel(modelData: IOddItem[], isEnemy?: boolean, parentKey?: string | null): IYinYangModel;
+    createModel(modelData: YinYangInternalModel, parentKey?: string | null): IYinYangModel;
     /**
      * Creates a new view for the YinYang diagram.
      *
@@ -54,9 +53,8 @@ export declare class YinYangAppFactory implements IYinYangAppFactory {
      *
      * @param modelData - The data for the model.
      * @param viewData - The data for the view (e.g., dimensions, container ID).
-     * @param isEnemy - Indicates whether the entity is an enemy.
      * @param parentKey - Optional key for a parent instance.
      * @returns The created YinYangController.
      */
-    create(modelData: IOddItem[], viewData: IViewData, isEnemy?: boolean, parentKey?: string | null): IYinYangController;
+    create(modelData: YinYangInternalModel, viewData: IViewData, parentKey?: string | null): IYinYangController;
 }

package/dist/types/components/model/YinYangModel.d.ts

@@ -1,41 +1,15 @@
-import { IOddItem } from "../../interfaces/IOddItem";
+import { YinYangInternalModel } from "../../interfaces/IYinYangInternalModel";
 import { IYinYangModel } from "../../interfaces/IYinYangModel";
-import { ICategory } from "../../interfaces/ICategory";
 export declare class YinYangModel implements IYinYangModel {
-    sortedData: IOddItem[];
-    categories: ICategory[];
+    internalModel: YinYangInternalModel;
     key: string;
     parentKey: string | null;
     childCounter: number;
     borderNb: number;
-    isEnemy: boolean;
-    /**
-     * Constructor for the YinYangModel.
-     * Sorts the input data, initializes the categories, and sets up the properties.
-     */
-    constructor(data: IOddItem[], key: string, parentKey: string | null | undefined, isEnemy: boolean);
+    constructor(internalModel: YinYangInternalModel, key: string, parentKey?: string | null);
     /**
      * Generates a unique key for child instances.
      */
     generateChildKey(): string;
-    /**
-     * Calculates the average score from the data.
-     * @returns The average score rounded to one decimal place.
-     */
-    calculateAverageScore(): number;
-    /**
-     * Retrieves the small circle data, including score and angle for each item.
-     * @returns Array of small circle data with score and angle for each item.
-     */
-    getSmallCircleData(): {
-        score: number;
-        angle: number;
-    }[];
-    /**
-     * Sets up the categories for the YinYang diagram based on the input data.
-     * Calculates the percentage and angles for each category.
-     * @param data - Array of items to categorize.
-     * @returns Array of category objects with their respective data.
-     */
-    setupCategories(data: IOddItem[]): ICategory[];
+    resetChildCounter(): void;
 }

package/dist/types/components/panel/DiagramPanelBridge.d.ts

@@ -0,0 +1,34 @@
+import { YinYangController } from "../controller/YinYangController";
+import { type Composante } from "../../data/yasuni_cause";
+import { PanelManager } from "./PanelManager";
+export interface DiagramPanelBridgeDeps {
+    panelManager: PanelManager;
+    controllerCause: YinYangController;
+    switchToTab: (id: string) => void;
+    yasuniCause: Composante[];
+    actionNameMap: Map<string, string>;
+    causeOddColors: Record<string, string>;
+    /** Called when the user clicks a cutting satellite in the diagram. Used to
+     *  sync the STACK hierarchy in the other direction (diagram → hierarchy). */
+    onDiagramCuttingNav?: (event: {
+        componentIndex: number;
+        oddId: string;
+        cuttingIndex: number;
+    }) => void;
+    /** Called when the user clicks a composante (Facette) — arc de bordure du diagramme
+     *  ou navigation indirecte via searchHandleComposanteClick. Sert à synchroniser le
+     *  chip et l'historique STACK au niveau Facette. */
+    onDiagramComposanteNav?: (componentIndex: number) => void;
+    /** Called when a diagram action drag intent is detected, after the built-in
+     *  tab switch logic. Used to e.g. close the stack hierarchy dropdown. */
+    onDiagramActionDragIntent?: () => void;
+    /** Called when a propagation block fires while in STACK mode, so that card-link
+     *  navigation (clicking a propagation target in the ANALYSE detail cards) is
+     *  recorded in the STACK navigation history. */
+    onStackPropagationNav?: (compId: string, oddId: string, cutIdx: number) => void;
+}
+export declare class DiagramPanelBridge {
+    private readonly deps;
+    constructor(deps: DiagramPanelBridgeDeps);
+    wire(): void;
+}

package/dist/types/components/panel/PanelManager.d.ts

@@ -0,0 +1,150 @@
+import { YinYangController } from "../controller/YinYangController";
+import { GlobalSearchController, SearchNavTarget } from "../search/GlobalSearchController";
+import { type Composante } from "../../data/yasuni_cause";
+export interface PanelSlot {
+    controller: GlobalSearchController;
+    panelEl: HTMLElement;
+    headerEl: HTMLElement;
+    titleEl: HTMLElement;
+    lockEl: HTMLButtonElement;
+    backEl: HTMLButtonElement | null;
+    forwardEl: HTMLButtonElement | null;
+    resizerEl: HTMLElement;
+    collapsed: boolean;
+    locked: boolean;
+    isMaster: boolean;
+    _openHeight: number;
+    _linkedTitle: boolean;
+    _history: Array<() => void>;
+    _histIdx: number;
+    _histNav: boolean;
+}
+export interface PanelManagerDeps {
+    controllerCause: YinYangController;
+    yasuniCause: Composante[];
+    actionNameMap: Map<string, string>;
+    globalSearch: GlobalSearchController;
+    switchToTab: (id: string) => void;
+    attachAxisResizer: (handle: HTMLDivElement | null, axis: "x" | "y", cursor: string, onStart: () => number, onDelta: (nextValue: number) => void) => void;
+    layoutState: {
+        rechercheContextHeight: number;
+    };
+    applyRechercheContextHeight: (h: number) => void;
+    resizerRechercheContext: HTMLElement | null;
+}
+export declare class PanelManager {
+    private readonly deps;
+    readonly panelSlots: (PanelSlot | null)[];
+    masterSlotIdx: number | null;
+    suppressSatelliteSearchUpdate: boolean;
+    pendingNavSourceSlot: number;
+    lastPropagationSlot: number;
+    masterCuttingPending: boolean;
+    masterCuttingHistoryPushed: boolean;
+    diagramNavMasterHistLenAtStart: number;
+    /** Jeton de génération pour historyBack/historyForward — voir leur commentaire. */
+    private navGen;
+    oddNavState: {
+        componentIndex: number;
+        oddId: string;
+        mode: "highlight";
+    } | null;
+    constructor(deps: PanelManagerDeps);
+    /** Appelé après le constructeur une fois le DOM prêt. */
+    init(): void;
+    /** Diagramme → arbre : reflète l'état du menu radial des Événements Clés dans
+     *  le panneau qui pilote le diagramme (le maître, ou le panneau 1 tant qu'il
+     *  n'y en a pas — même règle que setOnKeyEventGroupToggle). */
+    syncKeyEventGroupFromDiagram(componentIndex: number, open: boolean): void;
+    getMasterController(): GlobalSearchController | null;
+    private findNextUnlocked;
+    setPanelTitle(slotIdx: number, prefix: string, name?: string, badge?: {
+        label: string;
+        cssClass: string;
+    }, rationale?: string, oddColor?: string, stateValue?: number, weightValue?: number, iconUrl?: string): void;
+    private redistributeOpenHeights;
+    private setPanelCollapsed;
+    private updateLockButton;
+    /** Cible actuellement sélectionnée dans l'arbre du panneau maître, ou null.
+     *  À lire AVANT de quitter RECHERCHE : voir resyncDiagramToMasterPanel. */
+    getMasterSelectedTarget(): SearchNavTarget | null;
+    /**
+     * Rejoue sur le diagramme ce que le panneau MAÎTRE montre déjà — appelé au
+     * retour en mode RECHERCHE, où l'onglet réaffiche le dernier élément
+     * sélectionné alors que le diagramme, lui, vient d'être vidé des champs de
+     * la pile (clearForceFieldForModeSwitch). Les deux côtés doivent montrer la
+     * même chose quel que soit le mode ; sans ça, il fallait recliquer sur
+     * l'élément déjà affiché pour retrouver ses champs.
+     *
+     * Passe par les chemins de RESTAURATION (restoreActionDiagramState,
+     * restoreKeyEventDiagramState, forceOpen) et non par ceux d'un clic : l'état
+     * est déjà connu, il ne doit ni basculer en toggle-close ni redessiner la
+     * carte du panneau ni pousser une entrée d'historique.
+     *
+     * Ne traite que les niveaux qui portent un champ dans le diagramme (action,
+     * cutting, Événement Clé). Une facette ou un ODD n'en ont pas : les rejouer
+     * ne ferait que risquer un toggle de la vue ODD pour rien.
+     *
+     * @param fallbackTarget cible mémorisée au moment de QUITTER RECHERCHE.
+     *   Le passage en STACK peut effacer la sélection de l'arbre (le rendu des
+     *   champs cumulés de la pile repasse par les blocs de détail du panneau)
+     *   ou la réécrire au niveau facette (navigation d'arc de bordure pendant
+     *   STACK) : dans les deux cas c'est cette photographie qui dit quel
+     *   élément l'utilisateur consultait, et sa restauration inclut le switch
+     *   de facette si le diagramme est parti ailleurs entre temps.
+     */
+    resyncDiagramToMasterPanel(fallbackTarget?: SearchNavTarget | null): void;
+    /**
+     * @param forceOpen À passer à true quand target restaure un état déjà connu
+     *   (rejeu d'historique back/forward, panneau qui redevient maître) plutôt
+     *   qu'un vrai clic utilisateur. searchNavigateToCutting bascule sinon en
+     *   toggle-close si le satellite ciblé est encore celui dont le menu est
+     *   flaggé actif (state.menu.activeChildKey périmé) — symptôme observé :
+     *   la mise à jour ne se faisait qu'un clic Retour/Suivant sur deux.
+     */
+    syncDiagramToTarget(target: SearchNavTarget, forceOpen?: boolean): void;
+    private setMaster;
+    private setPanelLocked;
+    openPanel(slotIdx: number, skipSync?: boolean): void;
+    private closePanel;
+    activateLinkedPanel(slotIdx: number): void;
+    resolveTargetSlot(): {
+        idx: number;
+        isLinked: boolean;
+        src: number;
+    };
+    wrapAttachHandlersForSlot(originalAttach: (c: HTMLElement) => void, slotIdx: number): (c: HTMLElement) => void;
+    private wireSlotNavigation;
+    private buildContextPanelDOM;
+    ensureSlot(slotIdx: number): PanelSlot;
+    pushHistory(slotIdx: number, restore: () => void): void;
+    private updateHistoryBtns;
+    /**
+     * Rejoue l'entrée d'historique courante du slot, en attendant qu'un éventuel
+     * switch de composante en cours (déclenché par un clic Retour/Suivant précédent,
+     * animation ~800ms) se termine avant d'appliquer la restauration. Sans ce garde,
+     * un clic rapide pendant l'animation faisait avancer _histIdx alors que la
+     * closure de restauration s'exécutait quand même sur un diagramme "occupé" —
+     * certains de ses effets (syncDiagramToTarget -> searchHandleComposanteClick)
+     * sont silencieusement ignorés par le guard isComponentSwitching interne,
+     * désynchronisant diagramme/panneau/hiérarchie de la position réelle de
+     * l'historique. gen permet d'abandonner si une navigation plus récente a
+     * entretemps pris le dessus (même slot ou un autre, le diagramme étant partagé).
+     */
+    private replayHistoryEntry;
+    private historyBack;
+    private historyForward;
+    makeActionRestoreFn(idx: number, compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (c: HTMLElement) => void, src: number, actionName: string, titlePrefix?: string, linkedTitle?: boolean): () => void;
+    makePropRestoreFn(idx: number, compId: string, oddId: string, cutIdx: number, html: string, attachHandlers: (c: HTMLElement) => void, src: number, sourceDesc: {
+        breadcrumb: string;
+        title: string;
+        description: string;
+    } | undefined, rationale: string | undefined, isLinked: boolean): () => void;
+    private wireSlotInteraction;
+    private initPanel1;
+    private initPanel2;
+    updateStackBadge(): void;
+    private wireSearchDrag;
+    /** Initialise le master et les hauteurs apres rendu. */
+    initMasterAndHeights(): void;
+}