@micheeeeel/yinyangapp 1.0.6 → 2.0.0

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

@@ -0,0 +1,53 @@
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ForceFieldComputationService } from "./ForceFieldComputationService";
+import { ForceFieldRenderer } from "./ForceFieldRenderer";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+type ChildOddMeta = {
+    oddId: string;
+    score: number;
+    cuttingIndex: number;
+};
+type ForceFieldLifecycleControllerDeps = {
+    state: YinYangControllerState;
+    childOddMap: Map<string, ChildOddMeta>;
+    forceFieldComputationService: ForceFieldComputationService;
+    forceFieldRenderer: ForceFieldRenderer;
+    getCurrentComponent: () => YinYangInternalModel["components"][number] | null;
+    getAllComponents: () => YinYangInternalModel["components"] | undefined;
+    updateChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
+    updateContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
+    clearForceFieldDetails: () => void;
+    renderForceFieldDetails: (linkIndex: number) => void;
+    renderActionPropagationTable: () => void;
+    renderSourceActionDetailsForCurrentSource: () => void;
+    clearGhostDetails: () => void;
+    clearForceFieldComputationState: () => void;
+    buildChildrenOrbitData: () => ChildrenOrbitEntry[];
+    setContextLabelsVisibilityOpacity: (opacity: number) => void;
+    getGlobalGroupNode: () => SVGGElement | null;
+    getChildRenderedCenter: (childController: IYinYangController) => {
+        x: number;
+        y: number;
+    } | null;
+    getComponentBorderTargetPoint: (componentId: string) => {
+        x: number;
+        y: number;
+    } | null;
+};
+export declare class ForceFieldLifecycleController {
+    private deps;
+    private _propCacheKey;
+    private _propCacheResult;
+    constructor(deps: ForceFieldLifecycleControllerDeps);
+    /** Invalide le cache (à appeler après un switch de composante ou clear). */
+    invalidatePropagationCache(): void;
+    private _buildPropCacheKey;
+    renderOppositeChildrenForceField(orbitData?: ChildrenOrbitEntry[]): void;
+    removeOppositeChildrenForceField(): void;
+    private ensureForceFieldLinks;
+    private updateForceFieldVisual;
+    private startForceFieldAnimation;
+}
+export {};

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

@@ -0,0 +1,67 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ForceFieldSegment } from "./types";
+type Point = {
+    x: number;
+    y: number;
+};
+export declare class ForceFieldRenderer {
+    private forceFieldGroup;
+    private forceFieldDefs;
+    private forceFieldLayers;
+    private readonly gradientPrefix;
+    /** Active pulse overrides: linkIndex → { startMs, durationMs }. Cleared on arc end. */
+    private readonly _pulsedLinks;
+    /** 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(). */
+    private _retractFrameId;
+    /**
+     * Temporarily boost the visual intensity of a force-field link.
+     * Opacity and aura stroke-width are amplified with a sin envelope over `durationMs`.
+     * Called by YinYangController while the propagation arc travels the matching segment.
+     */
+    pulseLink(linkIndex: number, durationMs: number): void;
+    hasActiveGroup(): boolean;
+    ensureElements(params: {
+        globalGroupNode: SVGGElement;
+        requiredCount: number;
+    }): void;
+    updateVisual(params: {
+        forceFieldOrbitData: ChildrenOrbitEntry[] | null;
+        forceFieldLinks: ForceFieldSegment[];
+        forceFieldRevealStartedAt?: number;
+        forceFieldPhase: number;
+        getChildRenderedCenter: (childController: IYinYangController) => Point | null;
+        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
+     * 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,
+     * 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
+     * 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()).
+     */
+    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/types.d.ts

@@ -0,0 +1,42 @@
+export type ForceFieldLinkDetail = {
+    fromComponentId: string;
+    toComponentId: string;
+    fromOddId: string;
+    toOddId: string;
+    fromCuttingId?: number;
+    toCuttingId?: number;
+    baseDelta: number;
+    weight: number;
+    strategicWeight: number;
+    layerType: "inter" | "intra" | "bridge";
+    propagationFactor: number;
+    absorption: number;
+    gap: number;
+    fromState: number;
+    toState: number;
+    deltaTo: number;
+    rationale?: string;
+    /** Entry cutting in the target ODD's intra chain (from yasuniInterconnectionGraph edge). */
+    targetedCutting?: number;
+    layersInvolved: string[];
+    localLayerWeights: string | null;
+    bridgeLayerWeights: string | null;
+};
+export type ForceFieldLink = {
+    startIndex?: number;
+    sourceComponentId?: string;
+    endIndex?: number;
+    targetComponentId?: string;
+    thickness: number;
+    potentialGain: number;
+    /** Delay before revealing this link, used for chained intra-ODD propagation. */
+    revealDelayMs?: number;
+    detail: ForceFieldLinkDetail;
+};
+/**
+ * Représentation pure-rendu d'un segment de champ de force.
+ * Identique à ForceFieldLink mais sans le champ `detail` (domaine métier).
+ * Permet de fusionner des segments qui se superposent visuellement
+ * sans impacter la logique de propagation.
+ */
+export type ForceFieldSegment = Omit<ForceFieldLink, "detail">;

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

@@ -0,0 +1,33 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ProjectedCuttingState } from "../actions/ActionProjectionService";
+export declare class ChildScoresDeltaRenderer {
+    render(params: {
+        orbitData: ChildrenOrbitEntry[];
+        globalGroupNode: SVGGElement | null;
+        parentCenterX: number;
+        parentCenterY: number;
+        component: YinYangInternalModel["components"][number] | null;
+        childOddMap: Map<string, {
+            oddId: string;
+            score: number;
+            cuttingIndex: number;
+        }>;
+        getChildRenderedCenter: (childController: IYinYangController) => {
+            x: number;
+            y: number;
+        } | null;
+        getChildRadius: (childController: IYinYangController) => number;
+        projectedGhostCuttingStatesByOddId: Map<string, ProjectedCuttingState[]> | null;
+        projectedGhostStateByOddId: Map<string, number> | null;
+        weightDeltaByChildKey?: Map<string, number>;
+        actionDeltaLabelsVisible: boolean;
+        labelsTextShadowEnabled: boolean;
+        childStateDeltaFontScale: number;
+        childStateDeltaOffset?: number;
+        childStateDeltaBoxScale?: number;
+        selectedCuttingId?: number;
+        selectedOddId?: string;
+    }): void;
+}

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

@@ -0,0 +1,155 @@
+import { YinYangCategoryArcGeometry } from "../../../interfaces/IYinYangGeometry";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { ProjectedCuttingState } from "../actions/ActionProjectionService";
+type ChildOddMeta = {
+    oddId: string;
+    score: number;
+    cuttingIndex: number;
+};
+/** Satellite (ODD cutting) actuellement actif sous la facette affichée, à
+ *  afficher comme second niveau du titre — avec, le cas échéant, l'action
+ *  de ce satellite en troisième niveau. Null en repli sur le seul libellé
+ *  de facette. */
+export type ComponentTitleSatelliteInfo = {
+    label: string;
+    oddColor: string;
+    actionLabel: string | null;
+} | null;
+type RenderContextLabelsParams = {
+    globalGroupNode: SVGGElement | null;
+    orbitData: ChildrenOrbitEntry[];
+    allComponents: YinYangInternalModel["components"];
+    borderSegments: YinYangCategoryArcGeometry[];
+    containerTopY: number;
+    componentTitleContainer?: HTMLDivElement | null;
+    onComponentLegendVisibilityChange?: (isVisible: boolean) => void;
+    onComponentLegendSelect?: (componentId: string) => void;
+    onComponentTitleClick?: () => void;
+    component: YinYangInternalModel["components"][number] | null;
+    componentTitle: string;
+    satelliteTitle: ComponentTitleSatelliteInfo;
+    parentCenterX: number;
+    parentCenterY: number;
+    childOddMap: Map<string, ChildOddMeta>;
+    getChildRenderedCenter: (controller: ChildrenOrbitEntry["controller"]) => {
+        x: number;
+        y: number;
+    } | null;
+    getChildRadius: (controller: ChildrenOrbitEntry["controller"]) => number;
+    /** Center + radius of a facette's image thumbnail (pre-scale coordinate
+     *  space), so the component legend can anchor onto the image instead of
+     *  floating radially around the sphere. Null if the ring isn't built yet. */
+    getComponentImagePosition: (componentId: string) => {
+        x: number;
+        y: number;
+        radius: number;
+    } | null;
+    childrenContextLabelsVisible: boolean;
+    labelsFontScale: number;
+    componentLabelFontScale: number;
+    componentLegendLabelFontScale: number;
+    legendLabelsBgEnabled: boolean;
+    labelsTextShadowEnabled: boolean;
+    childLabelMaxLines: number;
+    childLabelShortMaxChars: number;
+    actionDeltaLabelsVisible: boolean;
+    projectedGhostCuttingStatesByOddId: Map<string, ProjectedCuttingState[]> | null;
+    projectedGhostStateByOddId: Map<string, number> | null;
+    allLabelsVisible: boolean;
+    displayEllipsisForShortLabels: boolean;
+    /** True only when no facette is active (Sphère status) — the component
+     *  legend must only ever show in that state. */
+    isSphereStatus: boolean;
+};
+export declare class ContextLabelsRenderer {
+    private contextLabelGroup;
+    private componentLegendGroup;
+    private lastParams;
+    private _childLabelCache;
+    /** Crossfades du texte du titre (facette / satellite), indépendants pour
+     *  que le changement de l'un ne fasse pas clignoter l'autre. */
+    private _titleCrossfadeTimers;
+    /** Timers de révélation "machine à écrire" lettre par lettre, par clé
+     *  (facette / satellite / action) — annulés et relancés à chaque nouveau
+     *  texte pour qu'un changement rapide n'empile pas plusieurs cascades. */
+    private _typewriterTimers;
+    /** Halo sombre multi-direction (au lieu d'un fond plein) qui garde le
+     *  libellé lisible sur n'importe quel arrière-plan (vignettes, arcs de
+     *  couleur, etc.) maintenant qu'il n'a plus de cadre. */
+    private static readonly TITLE_GLOW;
+    /** Ombre sombre pure (sans le halo cyan de TITLE_GLOW) pour les lignes
+     *  satellite/action : à leur petit corps, le halo lumineux rendait le
+     *  texte flou — une ombre nette suffit à la lisibilité sur fond mixte. */
+    private static readonly SUB_ROW_SHADOW;
+    /** Délai entre deux lettres de la révélation "machine à écrire" du titre. */
+    private static readonly TITLE_TYPEWRITER_STEP_MS;
+    /** Les deux niveaux enfants du titre partagent leur mise en forme entre
+     *  création et mise à jour via ces specs, seule source de vérité : rampe
+     *  typographique régulière (15 → 12.5 → 11), indentation en escalier
+     *  (l'équerre de l'action s'aligne sous le début du texte satellite) et
+     *  connecteur de l'action légèrement atténué pour reculer d'un plan. */
+    private static readonly SATELLITE_ROW_SPEC;
+    private static readonly ACTION_ROW_SPEC;
+    render(params: RenderContextLabelsParams): void;
+    clear(): void;
+    setVisibilityOpacity(opacity: number): void;
+    /**
+     * Updates just the top-left component-title DOM element, independently of
+     * the full render() pass (which needs orbit/legend data and is only ever
+     * called once the diagram's component-switch animation completes). Lets
+     * callers reflect the new active facette in the label the instant the user
+     * clicks, instead of waiting ~800ms for the diagram animation.
+     */
+    updateComponentTitleOnly(container: HTMLDivElement | null | undefined, title: string, satelliteTitle: ComponentTitleSatelliteInfo, fontScale: number, textShadowEnabled: boolean, onTitleClick?: () => void): void;
+    private renderComponentTitleInDOM;
+    /** Fades the top-left title out whenever a rendered orbit bubble (the
+     *  tension/force-field badges that fly out around an active facette)
+     *  physically overlaps its on-screen footprint — the title's fixed corner
+     *  position means some facettes' badges end up right underneath it.
+     *  Compares real getBoundingClientRect()s (not the diagram's internal
+     *  coordinate space) so it stays correct regardless of zoom/resize. */
+    private updateTitleObstruction;
+    private createTitleElement;
+    /** Un niveau (satellite ou action) du titre : un connecteur en ⌐ inversé
+     *  (SVG, coin arrondi, caps ronds) qui part du bord gauche de la ligne
+     *  parente et vient pointer sur le libellé, teinté de la couleur ODD du
+     *  satellite (même convention que le chip STACK du panneau de détails).
+     *  `indentPx` enfonce l'action un cran de plus que le satellite pour lire
+     *  la hiérarchie facette → satellite → action d'un coup d'œil. Replié à
+     *  hauteur nulle plutôt que retiré du DOM quand invisible, pour pouvoir
+     *  s'animer en douceur à l'apparition/disparition. */
+    private createTreeRow;
+    /** Toute la mise en forme d'une ligne de l'arbre (géométrie du connecteur
+     *  comprise), partagée entre le chemin création et le chemin mise à jour
+     *  pour que les deux restent rigoureusement identiques. Le connecteur est
+     *  redessiné à chaque passage : son tracé dépend de la hauteur de ligne
+     *  (fontScale) et de la couleur ODD, tous deux susceptibles de changer. */
+    private applyTreeRowStyle;
+    /** Révèle `text` dans `el` lettre par lettre, en cascade rapide (effet
+     *  "machine à écrire" façon interface sci-fi) : chaque caractère est posé
+     *  dans son propre span, invisible, puis fondu en place avec un léger
+     *  décalage sur le suivant. `key` isole les cascades concurrentes (facette
+     *  vs. satellite vs. action) et annule celle déjà en cours pour cette clé
+     *  afin qu'un changement rapide ne fasse pas se chevaucher deux révélations. */
+    private typewriterReveal;
+    /** Fades one title line's old text out, then reveals the new text lettre
+     *  par lettre (typewriterReveal) instead of an abrupt swap, using its own
+     *  short duration (componentTitleCrossfadeMs) independent of the slower
+     *  orbit/legend reveal, so the label always reads as a quick, deliberate,
+     *  sci-fi-flavored change. `key` isolates concurrent crossfades (facette
+     *  vs. satellite vs. action line) and cancels any one already in flight
+     *  for that key so rapid re-clicks converge on the latest text instead of
+     *  racing. */
+    private scheduleTextCrossfade;
+    private updateTitleElement;
+    /** Updates one existing tree row (satellite or action line) in place —
+     *  the counterpart to createTreeRow for the update path (element already
+     *  in the DOM). Re-applies the shared style pass (applyTreeRowStyle), then
+     *  cross-fades the text if it changed. */
+    private updateTreeRow;
+    private renderComponentLegend;
+    private hideComponentLegend;
+    private ensureContextLabelGroup;
+}
+export {};

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

@@ -0,0 +1,61 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+/**
+ * The satellite equivalent of the facette's score ghost
+ * (YinYangDrawer.drawGhostCircle + updateGhostWaveAnimation): the satellite's
+ * own circle never changes size — a dashed gold "ghost" circle is drawn at
+ * the projected weightDelta radius, and a single wave circle continuously
+ * travels between the satellite's real radius and that ghost radius
+ * (d3.easeSinInOut, same waveTravelDurationSec-length lap, sin envelope
+ * fading it in/out at each end so it loops without a visible pop).
+ */
+export declare class WeightPreviewRingRenderer {
+    private entries;
+    private frameId;
+    private groupNode;
+    private pulseStates;
+    private basePulseEnabled;
+    private pulseDurationMs;
+    private pulseMorphRatio;
+    render(params: {
+        orbitData: ChildrenOrbitEntry[];
+        globalGroupNode: SVGGElement | null;
+        component: YinYangInternalModel["components"][number] | null;
+        childOddMap: Map<string, {
+            oddId: string;
+            score: number;
+            cuttingIndex: number;
+        }>;
+        weightDeltaByChildKey: Map<string, number>;
+        getChildRenderedCenter: (childController: IYinYangController) => {
+            x: number;
+            y: number;
+        } | null;
+        getChildRadius: (childController: IYinYangController) => number;
+        /** Mirrors ViewInitializer.basePulseEnabled/ghostPulseDurationSec/
+         *  pulseMorphRatio ("Pulsation rayons activée") from the parent facette,
+         *  so toggling that one control affects both ghosts identically. */
+        basePulseEnabled: boolean;
+        pulseDurationMs: number;
+        pulseMorphRatio: number;
+    }): 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 —
+     *  mirrors YinYangDrawer.updateBasePulseAnimationForType's reset path. */
+    private syncPulseStates;
+    private resetPulseTransforms;
+    private resetEntryTransform;
+    private drawGhostCircles;
+    private ensureLoop;
+    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
+     *  as YinYangDrawer.applyPulseFrame, scaling the satellite's globalGroup
+     *  around its own center instead of morphing a single circle's radius, so
+     *  the whole satellite (arcs, masks, border) breathes together. */
+    private updateBasePulse;
+    private updateWaves;
+    private clear;
+}

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

@@ -0,0 +1,25 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+type ChildrenOrbitManagerDeps = {
+    view: IYinYangView;
+    getChildControllers: () => IYinYangController[];
+    state: YinYangControllerState;
+    renderOppositeChildrenForceField: (orbitData: ChildrenOrbitEntry[]) => void;
+};
+export declare class ChildrenOrbitManager {
+    private deps;
+    private readonly orbitService;
+    private cachedOrbitData;
+    constructor(deps: ChildrenOrbitManagerDeps);
+    invalidateCache(): void;
+    buildOrbitData(): ChildrenOrbitEntry[];
+    applyTransforms(angleOffset: number, orbitData?: ChildrenOrbitEntry[]): void;
+    setEnabled(isEnabled: boolean): void;
+    setSpeed(speed: number): void;
+    setRadiusScale(scale: number): void;
+    start(_durationMs: number): void;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,44 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
+import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
+import { ActionStackController } from "../action-stack/ActionStackController";
+import type { CumulativeBlock } from "../YinYangController";
+type ChildOddMeta = {
+    oddId: string;
+    score: number;
+    cuttingIndex: number;
+};
+type OddViewManagerDeps = {
+    view: IYinYangView;
+    getChildControllers: () => IYinYangController[];
+    getChildOddMap: () => Map<string, ChildOddMeta>;
+    getActiveChildKey: () => string | null;
+    enterOddView: (oddId: string) => void;
+    exitOddView: () => void;
+    getCurrentComponent: () => YinYangInternalModel["components"][number] | null;
+    getAllComponents: () => YinYangInternalModel["components"] | undefined;
+    forceFieldDetailsPanel: ForceFieldDetailsPanel;
+    actionStackController: ActionStackController;
+    hasActiveAction: () => boolean;
+    /** Blocs "keyEvent" de la Facette (voir YinYangController.buildKeyEventBlocksForComponent)
+     *  — affichés par renderComposanteInfo même sans satellite sélectionné. */
+    buildKeyEventBlocksForComponent: (component: {
+        id: string;
+    }) => CumulativeBlock[];
+    onNavigateToAction: (actionId: string) => void;
+};
+export declare class OddViewManager {
+    private deps;
+    constructor(deps: OddViewManagerDeps);
+    highlightOddInChildren(oddId: string | null): void;
+    highlightOddByStackItemId(stackItemId: string | null): void;
+    cancelOddHighlight(): void;
+    showOddInfo(oddId: string): void;
+    showComposanteInfo(): void;
+    applyOddHighlight(oddId: string): void;
+    applyEnterOddView(oddId: string): void;
+    applyOddStateForCutting(oddId: string): void;
+    private applyChildOddHighlight;
+}
+export {};

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

@@ -0,0 +1,125 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import { ActionStackController } from "../action-stack/ActionStackController";
+import { ChildActionMenuController } from "../actions/ChildActionMenuController";
+import type { KeyEventDefinition } from "../../../data/yasuni_key_events";
+import type { Point } from "../actions/radialItemMenu";
+type ChildOddMeta = {
+    oddId: string;
+    score: number;
+    cuttingIndex: number;
+};
+type DiagramCuttingNavEvent = {
+    type: "cutting";
+    componentIndex: number;
+    oddId: string;
+    cuttingIndex: number;
+};
+/** Subset of PendingComponentSwitchContext values set by search interactions. */
+type SearchPendingContext = null | {
+    type: "searchCutting";
+    oddId: string;
+    cuttingIndex: number;
+    forceOpen?: boolean;
+} | {
+    type: "searchOdd";
+    oddId: string;
+} | {
+    type: "searchOddHighlight";
+    oddId: string;
+} | {
+    type: "searchAction";
+    oddId: string;
+    cuttingIndex: number;
+    actionId: string;
+} | {
+    type: "restoreAction";
+    oddId: string;
+    cuttingIndex: number;
+    actionId: string;
+};
+type SearchPanelSynchronizerDeps = {
+    view: IYinYangView;
+    getChildControllers: () => IYinYangController[];
+    getChildOddMap: () => Map<string, ChildOddMeta>;
+    state: YinYangControllerState;
+    ACTION_DRAG_THRESHOLD_PX: number;
+    setPendingContext: (ctx: SearchPendingContext) => void;
+    setPendingOddHighlightAfterSwitch: (oddId: string) => void;
+    setPendingCuttingNavigationAfterSwitch: (oddId: string, cuttingIndex: number, forceOpen: boolean) => void;
+    setRouteNextDirectActionBlockToPanelB: (val: boolean) => void;
+    setSuppressDirectActionBlockRender: (val: boolean) => void;
+    prepareForComponentSwitch: (targetComponentId: string) => void;
+    animateChildrenHide: () => void;
+    setChildrenEnabled: (enabled: boolean) => void;
+    onDiagramComposanteClicked: (componentIndex: number) => void;
+    onDiagramOddArcClicked: (oddId: string) => void;
+    onDiagramNavChange?: (event: DiagramCuttingNavEvent) => void;
+    applyEnterOddView: (oddId: string) => void;
+    applyOddHighlight: (oddId: string) => void;
+    focusChildByOddCutting: (oddId: string, cuttingIndex: number, forceOpen?: boolean) => void;
+    focusChildByOddCuttingAndAction: (oddId: string, cuttingIndex: number, actionId: string) => void;
+    validateActionSelection: (childController: IYinYangController, actionId: string, label: string, insertAtVisibleIndex?: number | null, entryOrigin?: {
+        x: number;
+        y: number;
+    }) => void;
+    validateKeyEventSelection: (keyEvent: KeyEventDefinition, insertAtVisibleIndex?: number | null, entryOrigin?: {
+        x: number;
+        y: number;
+    }) => void;
+    restoreKeyEventDiagramState: (keyEventId: string) => void;
+    actionStackController: ActionStackController;
+    childActionMenuController: ChildActionMenuController;
+    renderDragGhost: (clientX: number, clientY: number, iconUrl: string) => void;
+    removeDragGhost: () => void;
+    clientPointToGlobalGroup: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
+    } | null;
+};
+/**
+ * Coordonne le panneau RECHERCHE avec le diagramme — et héberge aussi le
+ * cœur partagé du glisser-déposer vers la pile (startActionDrag), réutilisé
+ * par ChildActionMenuController pour le glisser depuis une bulle satellite
+ * du diagramme, qui n'a rien de "RECHERCHE" en soi (voir startActionDrag).
+ */
+export declare class SearchPanelSynchronizer {
+    private deps;
+    private searchHoverChildNode;
+    constructor(deps: SearchPanelSynchronizerDeps);
+    searchHandleComposanteClick(componentIndex: number): void;
+    searchNavigateToComponent(componentIndex: number): void;
+    searchNavigateToOdd(componentIndex: number, oddId: string): void;
+    searchHandleOddArcClick(componentIndex: number, oddId: string): void;
+    searchHighlightOdd(componentIndex: number, oddId: string): void;
+    searchPreviewHover(target: {
+        type: string;
+        componentIndex: number;
+        oddId?: string;
+        cuttingIndex?: number;
+        actionId?: string;
+    } | null): void;
+    searchHandleCuttingClick(componentIndex: number, oddId: string, cuttingIndex: number): void;
+    searchNavigateToCutting(componentIndex: number, oddId: string, cuttingIndex: number, forceOpen?: boolean): void;
+    searchNavigateToAction(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string): void;
+    restoreActionDiagramState(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string): void;
+    startSearchActionDrag(componentIndex: number, oddId: string, cuttingIndex: number, actionId: string, label: string, startEvent: PointerEvent, sourceEl: Element, onDragIntentDetected?: () => void): void;
+    startSearchKeyEventDrag(componentIndex: number, keyEventId: string, label: string, startEvent: PointerEvent, sourceEl: Element, onDragIntentDetected?: () => void): void;
+    /**
+     * 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
+     * `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
+     * glisser — les écouteurs pointermove/pointerup vivent sur `window`, pas
+     * sur l'élément source, donc le retirer du DOM ne suffit pas à arrêter
+     * le glisser).
+     */
+    startActionDrag(iconUrl: string, startEvent: PointerEvent, sourceEl: Element, onDrop: (insertAtVisibleIndex: number | null, entryOrigin: Point) => void, onDragIntentDetected?: () => void): () => void;
+    private clearSearchHoverChild;
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { IYinYangView } from "../../../interfaces/IYinYangView";
+import { YinYangControllerState } from "../state/YinYangControllerState";
+import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
+type ControllerSettingsApplierDeps = {
+    state: YinYangControllerState;
+    view: IYinYangView;
+    hasChildrenControllers: () => boolean;
+    getOrbitData: () => ChildrenOrbitEntry[];
+    updateContextLabels: (orbitData: ChildrenOrbitEntry[]) => void;
+    updateChildActionMenu: (orbitData: ChildrenOrbitEntry[]) => void;
+    updateCoreEventMenu: () => void;
+    applyChildrenFitScale: () => void;
+    clearForceFieldComputationState: () => void;
+    renderOppositeChildrenForceField: () => void;
+};
+export declare class ControllerSettingsApplier {
+    private deps;
+    constructor(deps: ControllerSettingsApplierDeps);
+    setRandomForceFieldCount(count: number): void;
+    setActionDeltaLabelsVisible(isVisible: boolean): void;
+    setChildrenContextLabelsVisible(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;
+    setComponentLegendLabelFontScale(scale: number): void;
+    setLegendLabelsBgEnabled(enabled: boolean): void;
+    setDisplayEllipsisForShortLabels(enabled: boolean): void;
+    setOddContextLabelsVisible(isVisible: boolean): void;
+    setAllLabelsVisible(isVisible: boolean): void;
+    setOddLabelsCompact(compact: boolean): void;
+    setChildActionMenuItemDistance(distance: number): void;
+    setChildActionMenuItemScale(scale: number): void;
+    setCoreEventMenuDistanceOffset(offset: number): void;
+    setCoreEventMenuItemScale(scale: number): void;
+    setChildActionIconFontScale(scale: number): void;
+    setCoreEventIconFontScale(scale: number): void;
+    setChildLabelMaxLines(lines: number): void;
+    setOddLabelMaxLines(lines: number): void;
+    setFacetteLabelFontScale(scale: number): void;
+    setFacetteLabelSuffixVisible(isVisible: boolean): void;
+    setLabelShortMaxChars(chars: number): void;
+    private clamp;
+    private clampInt;
+}
+export {};