@micheeeeel/yinyangapp 1.0.6 → 2.0.0

package/dist/types/data/adverse-action-planner.d.ts

@@ -0,0 +1,51 @@
+import type { ComboSlot } from "./yasuni_actions";
+/**
+ * Candidat à l'insertion — la projection commune d'une action adverse
+ * (combos, jamais d'entrave différée) et d'un Événement adverse (entrave
+ * différée, jamais de combos). Une ActionDefinition est assignable telle
+ * quelle ; une KeyEventDefinition se projette en
+ * `{ id, delayedEffect: keyEvent }` (elle porte directement
+ * targetedActionIds/withinNextN).
+ */
+export interface AdverseCandidate {
+    id: string;
+    combos?: ComboSlot[];
+    delayedEffect?: {
+        targetedActionIds: string[];
+        withinNextN?: number;
+    };
+}
+export interface PlannerStackItem {
+    actionId: string;
+    slotIndex: number;
+}
+export interface AdversePlacement {
+    actionId: string;
+    /** Slot d'insertion au moment où cette insertion est appliquée (les
+     *  précédentes du plan étant déjà faites) — pas un slot final. */
+    slotIndex: number;
+}
+export interface PlanAdverseInsertionsParams {
+    /** Items adverses disponibles (pas encore dans la pile). */
+    candidates: AdverseCandidate[];
+    /** Pile courante, tous types d'items confondus. */
+    stack: PlannerStackItem[];
+    count: number;
+    /** Générateur dans [0, 1) — injectable pour des tests déterministes. */
+    rng?: () => number;
+}
+/** Tire une graine au hasard puis absorbe sa chaîne (prérequis d'abord,
+ *  dépendantes ensuite) avant de retirer une nouvelle graine — une "graine"
+ *  sans aucun lien combo forme à elle seule un groupe d'un seul élément.
+ *  Les groupes sont ce qui distingue, au placement (§3), un bloc d'actions
+ *  liées d'un trou entre deux groupes sans rapport. */
+export declare function selectAdverseChainGroups(candidates: AdverseCandidate[], count: number, rng: () => number): AdverseCandidate[][];
+/** Version à plat de {@link selectAdverseChainGroups}, dans l'ordre des
+ *  `candidates` d'origine — sans information de groupe. */
+export declare function selectAdverseChain(candidates: AdverseCandidate[], count: number, rng: () => number): AdverseCandidate[];
+/** Profondeur = longueur du plus long chemin de prérequis adverses menant
+ *  à l'action (0 sans prérequis). Un cycle, jamais attendu au catalogue,
+ *  est coupé à la profondeur courante plutôt que de boucler. */
+export declare function adverseDepth(action: AdverseCandidate, pool: Map<string, AdverseCandidate>, visiting?: Set<string>): number;
+export declare function orderAdverseActions(picked: AdverseCandidate[], rng: () => number): AdverseCandidate[];
+export declare function planAdverseInsertions(params: PlanAdverseInsertionsParams): AdversePlacement[];

package/dist/types/data/adverse-action-planner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/data/amplifier-engine.d.ts

@@ -0,0 +1,107 @@
+import type { KeyEventDefinition, KeyEventEffect } from "./yasuni_key_events";
+import type { ActionStackItem } from "../components/controller/action-stack/ActionStackState";
+/** Ce qu'une source d'effet différé doit fournir — la partie "effet" d'une
+ *  KeyEventDefinition (Événement Clé ou adverse, seule espèce de source). */
+export interface AmplifierSourceDefinition {
+    targetedActionIds: string[];
+    withinNextN?: number;
+    effect: KeyEventEffect;
+}
+export interface AmplifierResult {
+    /** KeyEventDefinition.id — résoluble dans yasuniKeyEventMap (fusion des
+     *  catalogues positif et adverse) pour distinguer les deux au rendu. */
+    sourceId: string;
+    name: string;
+    /** Bonus de score EFFECTIF déjà réduit selon la position (voir
+     *  positionalBonus) — jamais le nominal du catalogue tel quel.
+     *  Fractionnaire en général : le score est une échelle continue. */
+    scoreBonus: number;
+    /** Bonus de poids EFFECTIF, arrondi PAR SOURCE (pas sur le total) :
+     *  le poids est une échelle entière, et arrondir ici garantit que la
+     *  valeur affichée sur la carte est exactement celle qui s'applique —
+     *  y compris un 0 honnête en bord de fenêtre. */
+    weightBonus: number;
+}
+/** Détail de l'amplification d'une action ciblée par une source —
+ *  miroir de PrereqBreakdown côté combos, pour l'affichage carte. */
+export interface AmplifierTargetBreakdown {
+    id: string;
+    /** Slot où l'action a été jouée après la source — absent si jamais
+     *  jouée dans la fenêtre withinNextN. */
+    slotIndex?: number;
+    /** Efficacité positionnelle Beta(t) ∈ [0, 1], 0 si non jouée dans la fenêtre. */
+    positional: number;
+    /** true si l'action a été jouée après la source ET dans sa fenêtre
+     *  withinNextN — false confond volontairement "jamais jouée" et "jouée
+     *  mais hors fenêtre" : dans les deux cas elle ne rapporte rien aujourd'hui. */
+    played: boolean;
+    /** Mêmes conventions qu'AmplifierResult (0 quand played=false). */
+    effectiveScoreBonus: number;
+    effectiveWeightBonus: number;
+}
+/**
+ * Retourne toutes les sources qui touchent `targetItem` : Événements
+ * (kind="keyEvent", Clés comme adverses),
+ * actifs (cochés), positionnés AVANT lui dans la pile (slotIndex strictement
+ * inférieur — recalculé dynamiquement à chaque appel, donc toujours à jour
+ * après un glisser-déposer), et dont la liste `targetedActionIds` contient
+ * l'actionId de `targetItem` — à condition que `targetItem` reste dans la
+ * fenêtre `withinNextN` de la source (si définie), pendant inverse du
+ * `withinLastN` des combos. Le bonus retourné est déjà réduit selon la
+ * position de `targetItem` dans cette fenêtre (voir positionalBonus) : le
+ * catalogue ne donne que le plafond, atteint au pic de la courbe.
+ *
+ * `targetItem` lui-même n'a pas besoin d'être actif : l'appelant décide déjà
+ * s'il calcule un delta pour un item actif ou non (mêmes conventions que
+ * evaluateCombo/composeEffectiveDelta).
+ */
+export declare function evaluateAmplifiers(targetItem: ActionStackItem, allItems: ActionStackItem[], activeItemIds: Set<string>, keyEventMap: Map<string, KeyEventDefinition>): AmplifierResult[];
+/**
+ * true si `keyEventItem` (un Événement Clé joué, kind="keyEvent") amplifie
+ * ACTUELLEMENT au moins une de ses actions ciblées — mêmes conditions que
+ * isAmplifying mais lues depuis l'événement plutôt que depuis l'action : sert
+ * à distinguer visuellement un bloc Événement Clé "actif" (au moins une
+ * action ciblée jouée après lui, active, dans sa fenêtre withinNextN) d'un
+ * bloc simplement présent (joué mais rien ne l'active encore) — le bloc
+ * lui-même reste affiché dans les deux cas, voir buildKeyEventBlocksForComponent.
+ */
+export declare function isKeyEventCurrentlyActive(keyEventItem: ActionStackItem, allItems: ActionStackItem[], activeItemIds: Set<string>, keyEventMap: Map<string, KeyEventDefinition>): boolean;
+/**
+ * Répartition par action ciblée d'une source RÉELLEMENT placée dans la pile
+ * (`sourceItem`) — une entrée par `targetedActionIds`, y compris les actions
+ * jamais jouées ou hors fenêtre (played=false). Miroir des `prereqBreakdowns`
+ * de ComboResult, pour l'affichage carte (position %, icône "barres de gain
+ * par slot"). `allItems` doit inclure TOUS les items de la pile, actifs ou
+ * non (même convention que playedHistory côté combos — "joué" ne dépend pas
+ * de la case à cocher) ; si plusieurs occurrences d'une même action existent
+ * après la source, seule la plus proche (première jouée après elle) compte,
+ * symétrique du lastIndexOf des combos.
+ */
+export declare function getAmplifierTargetBreakdown(source: AmplifierSourceDefinition, sourceItem: ActionStackItem, allItems: ActionStackItem[]): AmplifierTargetBreakdown[];
+/**
+ * Compose le delta de score effectif avec les sources déclenchées — somme de
+ * tous les scoreBonus, déjà réduits selon la position (commutatif par
+ * construction), appliquée dans la direction du delta (voir
+ * applyDirectionalBonus). Appliqué APRÈS composeEffectiveDelta (combos) —
+ * jamais sur le baseDelta brut.
+ */
+export declare function composeAmplifiedDelta(effectiveDelta: number, results: AmplifierResult[]): number;
+/**
+ * Compose un weightDelta brut avec les sources déclenchées — somme des
+ * weightBonus (déjà entiers, arrondis par source à l'évaluation), appliquée
+ * dans la direction du weightDelta de l'action : une action qui allège le
+ * poids est renforcée (ou entravée) vers l'allègement, une action qui
+ * l'alourdit vers l'alourdissement, et une action sans effet de poids n'en
+ * gagne pas. Entier par construction : plus d'arrondi final susceptible
+ * d'absorber silencieusement l'effet d'une source.
+ */
+export declare function composeAmplifiedWeightDelta(weightDelta: number, results: AmplifierResult[]): number;
+/**
+ * L'unique item actif de kind="action", s'il y en a exactement un — jamais un
+ * Événement Clé, qui n'a pas de "satellite source" au sens propre. Utilisé
+ * partout où le code déduit "l'action actuellement active" à partir de la
+ * pile : sans ce filtre, un Événement Clé actif se fait passer pour l'action
+ * active dès qu'il est seul dans la pile (son nom/son id se substituent alors
+ * à ceux de l'action qu'il est censé amplifier).
+ */
+export declare function findSoleActiveAction(items: ActionStackItem[]): ActionStackItem | undefined;

package/dist/types/data/amplifier-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/data/combo-engine.d.ts

@@ -0,0 +1,94 @@
+import type { ActionDefinition } from "./yasuni_actions";
+/**
+ * Intervalles du multiplicateur combo.
+ *
+ * Le multiplicateur est une interpolation linéaire entre un plancher et un
+ * plafond, pilotée par prereqAvgRatio ∈ [0, 1] :
+ *
+ *     m = plancher + (plafond − plancher) × prereqAvgRatio
+ *
+ * Les deux types partagent la même largeur d'intervalle (1) et se touchent en
+ * ×1, le point neutre "rien de spécial ne se passe" :
+ *
+ *   - bonus     [1, 2] → m = 1 + avgRatio
+ *       Les requires sont des DÉCLENCHEURS. Aucun joué → ×1 (neutre, pas de
+ *       malus) ; tous parfaits et bien placés → ×2.
+ *   - dangereux [0, 1] → m = avgRatio
+ *       Les requires sont des PROTECTEURS et le risque est permanent
+ *       (triggered = true en continu). Protection parfaite → ×1 (risque
+ *       annulé) ; aucune protection → ×0 (l'action ne rapporte plus rien).
+ *
+ * Largeurs égales de part et d'autre : un bonus et un risque de qualité égale
+ * s'annulent exactement dans composeEffectiveDelta, ce qui rend l'arbitrage
+ * lisible sans avoir à connaître un barème. Le multiplicateur affiché EST
+ * l'avgRatio (au décalage de plancher près) — aucune traduction mentale.
+ */
+/** Détail de la contribution d'un prérequis au multiplicateur combo. */
+export interface PrereqBreakdown {
+    id: string;
+    label?: string;
+    ratio: number;
+    positional: number;
+    factor: number;
+    /** true si le prérequis/protecteur a déjà été joué au moins une fois (s >= 0),
+     *  indépendamment de sa performance. Permet à l'UI de distinguer "jamais joué"
+     *  (ratio/positional = 0 par convention, sans signification réelle) d'un
+     *  prérequis réellement joué mais sous-performant. */
+    played: boolean;
+}
+/** Réglages "Combos" du panneau de contrôle — voir YinYangControllerState.combos.
+ *  Bornés (false) par défaut : comportement actuel. */
+export interface ComboEngineSettings {
+    /** Lève le plafond à 1 sur le ratio des prérequis DÉCLENCHEURS (non
+     *  dangereux), autorisant une cascade de combos à dépasser ×2. */
+    uncappedChainedPerformance?: boolean;
+    /** Lève le plafond à 1 sur le ratio des prérequis PROTECTEURS d'un combo
+     *  dangereux, permettant à m = avgRatio de dépasser ×1. */
+    dangerousComboCanBecomeBonus?: boolean;
+}
+export interface ComboResult {
+    triggered: boolean;
+    name?: string;
+    comboId?: string;
+    description?: string;
+    type?: string;
+    effectiveDelta: number;
+    baseDelta: number;
+    deltaMultiplier: number;
+    maxDeltaMultiplier: number;
+    prereqAvgRatio?: number;
+    prereqBreakdowns?: PrereqBreakdown[];
+    requires?: string[];
+    withinLastN?: number;
+}
+/**
+ * Évalue tous les slots combo d'une action et retourne ceux qui sont déclenchés.
+ * Tous les slots satisfaits sont retournés (pas d'arrêt au premier).
+ *
+ * @param action          L'action que le joueur est sur le point de jouer
+ * @param playedHistory   Les IDs des actions jouées avant celle-ci (ordre chronologique)
+ * @param prereqRatioMap  (optionnel) actionId → ratio de performance (actualDelta / baseDelta,
+ *                        clampé dans [0, 1]). Si fourni, le multiplicateur est pondéré par la
+ *                        performance réelle des prérequis :
+ *                          effectiveDm = (dangereux ? 0 : 1) + avg(ratio × Beta(t))
+ *                        où t est la position normalisée du prérequis dans la fenêtre.
+ * @returns               Tableau de ComboResult pour chaque slot (vide si aucun combo défini)
+ */
+export declare function evaluateCombo(action: ActionDefinition, playedHistory: string[], prereqRatioMap?: Map<string, number>, settings?: ComboEngineSettings): ComboResult[];
+/**
+ * Compose le delta effectif à partir de plusieurs résultats combo (formule additive centrée).
+ * Chaque multiplicateur exprime un écart par rapport à 1 (neutre).
+ *
+ * Formule : baseDelta × (Σ multiplicateurs − (n − 1))
+ *
+ * Exemples :
+ *   - 1 combo ×1.4            → baseDelta × 1.4
+ *   - 2 combos ×1.4 + ×-0.5  → baseDelta × (1.4 + (−0.5)) = baseDelta × 0.9
+ *   - aucun combo              → baseDelta × 1 = baseDelta
+ */
+export declare function composeEffectiveDelta(baseDelta: number, results: ComboResult[]): number;
+/**
+ * Retourne true si l'action donnée est requise par au moins
+ * une autre action dans le catalogue.
+ */
+export declare function isPrerequisiteOf(actionId: string, allActions: ActionDefinition[]): boolean;

package/dist/types/data/combo-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/data/odd_generic_descriptions.d.ts

@@ -0,0 +1,4 @@
+export interface OddGenericEntry {
+    description: string;
+}
+export declare const oddGenericDescriptionsFr: Record<string, OddGenericEntry>;

package/dist/types/data/odd_labels.d.ts

@@ -0,0 +1,5 @@
+export type OddLabelEntry = {
+    label: string;
+    shortLabel: string;
+};
+export declare const oddLabelsFr: Record<string, OddLabelEntry>;

package/dist/types/data/yasuni_actions.d.ts

@@ -0,0 +1,47 @@
+export interface ComboCondition {
+    requires?: string[];
+    withinLastN?: number;
+}
+export interface ComboEffect {
+    /**
+     * Seul `type` décide de l'amplitude : "dangereux" parcourt [0, 1] (les
+     * requires sont des protecteurs), les autres [1, 2] (les requires sont des
+     * déclencheurs). Le curseur dans l'intervalle est la performance réelle des
+     * prérequis — voir combo-engine.ts. Pas de palier à choisir au cas par cas.
+     */
+    type: "preparation" | "exploitation" | "stabilisation" | "dangereux";
+    name: string;
+    comboId: string;
+    description: string;
+}
+export interface ComboSlot {
+    condition: ComboCondition;
+    effect: ComboEffect;
+}
+export interface ActionDefinition {
+    id: string;
+    name: string;
+    shortDescription: string;
+    description: string;
+    baseDelta: number;
+    targeting: "unique" | "shared";
+    combos?: ComboSlot[];
+    /**
+     * Variation d'importance (poids) appliquée uniquement au satellite ciblé
+     * au moment du jeu — jamais aux autres satellites référençant la même
+     * action, jamais par propagation. Volontairement plafonné à ±1 : les
+     * ajustements de poids plus importants sont réservés aux futures actions
+     * "cercle global" (portée multi-satellites, tier super-pouvoir).
+     */
+    weightDelta?: number;
+    /** Acteur à l'origine d'une action adverse (pouvoir politique, industrie…),
+     *  affiché en note de provenance sur sa carte. */
+    origin?: string;
+}
+/**
+ * Une action adverse dégrade directement son satellite : c'est le signe de
+ * son baseDelta, pas un drapeau à part, qui la distingue — une seule source
+ * de vérité pour le moteur (propagation, combos) comme pour l'affichage.
+ */
+export declare function isAdverseAction(action: ActionDefinition): boolean;
+export declare const yasuniActions: ActionDefinition[];

package/dist/types/data/yasuni_adverse_actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "./yasuni_actions";
+export declare const yasuniAdverseActions: ActionDefinition[];

package/dist/types/data/yasuni_adverse_key_events.d.ts

@@ -0,0 +1,2 @@
+import type { KeyEventDefinition } from "./yasuni_key_events";
+export declare const yasuniAdverseKeyEvents: KeyEventDefinition[];

package/dist/types/data/yasuni_cause.d.ts

@@ -0,0 +1,33 @@
+export interface Cutting {
+    id: number;
+    name: string;
+    score?: number;
+    /** Importance du satellite dans sa facette ; chaque satellite vaut 1 par défaut. */
+    weight?: number;
+    /** Présentation succincte du problème ou enjeu représenté par ce cutting. */
+    description?: string;
+    actionIds: string[];
+}
+export interface ODD {
+    id: string;
+    name: string;
+    /** Présentation contextuelle du rôle de cet ODD dans la composante parente. */
+    description?: string;
+    cuttings: Cutting[];
+}
+export interface Composante {
+    id: string;
+    name: string;
+    orientation?: "yin" | "yang";
+    /** Vue d'ensemble des enjeux et des dynamiques propres à cette composante. */
+    description?: string;
+    odds: ODD[];
+}
+export interface Sphere {
+    name: string;
+    description: string;
+    composantes: Composante[];
+}
+export declare const yasuniSphere: Sphere;
+/** Backward-compatible alias — all existing callers continue to work unchanged. */
+export declare const yasuniCause: Composante[];

package/dist/types/data/yasuni_graph.d.ts

@@ -0,0 +1,22 @@
+import { CauseGraph } from "../interfaces/ICauseGraph";
+/**
+ * Yasuní sparse interconnection matrix W (adjacency list form) — SIGNED.
+ *
+ * Node format: componentId::oddId (contextualized SDG node).
+ * w in [-1..+1], expert-driven bands (absolute value):
+ * - 0.2 weak
+ * - 0.4 moderate
+ * - 0.6 strong
+ * - 0.8 structuring
+ *
+ * Sign convention:
+ * - w > 0 : A↑ causes B↑ (same direction)
+ * - w < 0 : A↑ causes B↓ (opposite direction)
+ *
+ * NOTE: This file intentionally includes a few additional contextualized nodes (e.g.,
+ * biodiversity_habitat_fragmentation::ODD_2, indigenous_rights::ODD_3/4/11) to show that
+ * the node count is not constrained to 17. If your engine builds node state strictly from
+ * yasuni_cause.ts, add these nodes there (or have the engine lazily init missing nodes).
+ */
+export declare const yasuniInterconnectionGraph: CauseGraph;
+export default yasuniInterconnectionGraph;

package/dist/types/data/yasuni_key_events.d.ts

@@ -0,0 +1,61 @@
+export interface KeyEventEffect {
+    /**
+     * Bonus ADDITIF de score (en points), au pic de la fenêtre positionnelle —
+     * réduit vers 0 aux bords, voir positionalBonus (amplifier-engine.ts).
+     * Appliqué dans la direction du delta effectif de l'action (après combos),
+     * jamais sur une action au delta nul. Additif et non multiplicatif : un
+     * ratio réduit par la position devenait fractionnaire et se faisait
+     * absorber par l'arrondi du poids ; un montant en points permet aussi à
+     * un futur malus (bonus négatif) de s'annuler exactement avec lui.
+     */
+    scoreBonus: number;
+    /**
+     * Bonus ADDITIF de poids (en points entiers), au pic de la fenêtre.
+     * Renforce le weightDelta de l'action ciblée dans sa propre direction
+     * (alléger ou alourdir) — sans effet sur une action sans weightDelta.
+     * L'arrondi à l'entier se fait par événement à l'évaluation, jamais sur
+     * un total fractionnaire : ce que la carte affiche est ce qui s'applique.
+     */
+    weightBonus: number;
+}
+export interface KeyEventDefinition {
+    id: string;
+    name: string;
+    shortDescription: string;
+    description: string;
+    /** Facette (Composante.id) depuis laquelle l'événement se déclenche. */
+    originComposanteId: string;
+    /**
+     * Actions amplifiées (par id), même logique que ComboCondition.requires.
+     * Cohérence thématique obligatoire avec la facette d'origine.
+     */
+    targetedActionIds: string[];
+    /**
+     * Fenêtre temporelle AVANT laquelle l'amplification s'arrête — pendant
+     * inverse de ComboCondition.withinLastN : une action ciblée jouée plus de
+     * withinNextN slots après l'événement n'est plus amplifiée. Oblige le
+     * joueur à réserver des emplacements libres après l'événement plutôt que
+     * de le placer systématiquement tout en bas de la pile.
+     */
+    withinNextN?: number;
+    effect: KeyEventEffect;
+    /** Acteur à l'origine d'un Événement adverse (pouvoir politique,
+     *  industrie…), affiché en note de provenance sur son bloc — les
+     *  Événements Clés positifs n'en ont pas (ils émanent de la cause). */
+    origin?: string;
+}
+/**
+ * Un Événement adverse est une KeyEventDefinition ordinaire dont l'effet est
+ * un MALUS (bonus négatifs) — même critère de signe qu'isAdverseAction, pas
+ * un drapeau. Catalogue séparé (yasuni_adverse_key_events.ts), jamais listé
+ * dans yasuniKeyEvents : le menu radial du cercle central et l'arbre
+ * RECHERCHE, qui itèrent ce tableau, l'ignorent donc structurellement — seul
+ * yasuniKeyEventMap (moteur, rendu de la pile) fusionne les deux catalogues.
+ */
+export declare function isAdverseKeyEvent(keyEvent: KeyEventDefinition): boolean;
+export declare const yasuniKeyEvents: KeyEventDefinition[];
+/** Lookup O(1) par id, même convention que les autres catalogues — fusionne
+ *  Événements Clés ET Événements adverses : le moteur et le rendu de la pile
+ *  résolvent les deux ici, tandis que les surfaces utilisateur (menu radial,
+ *  arbre RECHERCHE) itèrent yasuniKeyEvents, sans les adverses. */
+export declare const yasuniKeyEventMap: Map<string, KeyEventDefinition>;

package/dist/types/data/yasuni_propagation_layers.d.ts

@@ -0,0 +1,3 @@
+import { PropagationLayersConfig } from "../interfaces/IPropagationLayers";
+export declare const yasuniPropagationLayers: PropagationLayersConfig;
+export default yasuniPropagationLayers;

package/dist/types/interfaces/IActions.d.ts

@@ -0,0 +1 @@
+export type { ActionDefinition, ComboSlot, ComboCondition, ComboEffect, } from "../data/yasuni_actions";

package/dist/types/interfaces/ICauseGraph.d.ts

@@ -0,0 +1,9 @@
+export type CauseNodeId = `${string}::${string}`;
+export interface CauseEdge {
+    to: CauseNodeId;
+    w: number;
+    rationale?: string;
+    /** Entry-point cutting in the target ODD's intra chain (Phase 6+7 / incoming-mode entry). */
+    targetedCutting?: number;
+}
+export type CauseGraph = Record<CauseNodeId, CauseEdge[]>;

package/dist/types/interfaces/ICauseModel.d.ts

@@ -0,0 +1,33 @@
+import { YinYangOrientation } from "./IYinYangInternalModel";
+export interface CauseOdd {
+    id: string;
+    name?: string;
+    shortName?: string;
+    libelle?: string;
+    libelleCourt?: string;
+    oddCutting: CauseOddCutting[];
+}
+export interface CauseOddCutting {
+    id: number;
+    name?: string;
+    shortName?: string;
+    libelle: string;
+    libelleCourt?: string;
+    score: number;
+    weight: number;
+}
+export interface CauseComponent {
+    id: string;
+    name?: string;
+    shortName?: string;
+    description?: string;
+    orientation: YinYangOrientation;
+    odds: CauseOdd[];
+    /** Somme brute des poids de tous les satellites de la facette. */
+    perimeterWeight: number;
+}
+export interface Cause {
+    id: string;
+    name: string;
+    components: CauseComponent[];
+}

package/dist/types/interfaces/IGraphicsStrategy.d.ts

@@ -6,18 +6,22 @@ export interface IGraphicsStrategy {
     defs: D3Element;
     initialize(svgSelector: string, w: number, svgElement?: IGraphicElement, defElement?: IGraphicElement): IGraphicElement;
     resizeGroup(group: IGraphicElement, scaleFactor: number, centerX: Number, centerY: Number): void;
-    drawArc(parent: IGraphicElement, cx: number, cy: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, fill: string): void;
-    drawArc(parent: IGraphicElement, cx: number, cy: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, fill: string): void;
+    drawArc(parent: IGraphicElement, cx: number, cy: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, fill: string, cornerRadius?: number): IGraphicElement;
     drawCircle(parent: IGraphicElement, cx: number, cy: number, radius: number, fill: string, opacity?: number): IGraphicElement;
     createLinearGradient(id: string, x1: string, y1: string, x2: string, y2: string, stops: {
         offset: string;
         color: string;
         opacity: number;
     }[], gradientUnits: string): IGraphicElement;
-    createYinOrYangArcMask(id: string, cx: number, cy: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, type: "yin" | "yang"): void;
+    createRadialGradient(id: string, cx: string, cy: string, r: string, stops: {
+        offset: string;
+        color: string;
+        opacity: number;
+    }[], gradientUnits: string): IGraphicElement;
+    createYinOrYangArcMask(id: string, cx: number, cy: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, type: "yin" | "yang", blendOpacity?: number): string;
     createBorderMask(id: string, cx: number, cy: number, innerRadius: number, outerRadius: number): void;
     changeBorderColors(gradient: any, duration: number, colors: string[]): void;
     drawLineWithGradient(parent: IGraphicElement, x1: number, y1: number, x2: number, y2: number, gradientId: string): void;
-    createUnderlyingCircleGradient(id: string, color: string): void;
-    createUnderlyingCircleWithArcMask(maskId: string, gradientId: string, parent: IGraphicElement, cx: number, cy: number, radius: number): void;
+    createUnderlyingCircleGradient(id: string, color: string, spread?: number, intensity?: number): string;
+    createUnderlyingCircleWithArcMask(maskId: string | undefined, gradientId: string, parent: IGraphicElement, cx: number, cy: number, radius: number): void;
 }

package/dist/types/interfaces/IPropagationLayers.d.ts

@@ -0,0 +1,27 @@
+export interface LocalCuttingEdgeRef {
+    cuttingId: number;
+    rationale?: string;
+}
+export interface LocalCuttingEdge {
+    toCuttingId: number;
+    w: number;
+    rationale?: string;
+    /** Pointers to next cuttings in the causal chain — resolved from the same flat array. */
+    targetedCuttings?: LocalCuttingEdgeRef[];
+}
+export interface BridgeCuttingEdge {
+    fromComponentId?: string;
+    fromOddId: string;
+    fromCuttingId: number;
+    toComponentId?: string;
+    toOddId: string;
+    toCuttingId: number;
+    w: number;
+    rationale?: string;
+}
+export interface PropagationLayersConfig {
+    intraOddByComponent: Record<string, Record<string, LocalCuttingEdge[]>>;
+    bridgeEdgesByComponent: Record<string, BridgeCuttingEdge[]>;
+    localK?: number;
+    bridgeK?: number;
+}

package/dist/types/interfaces/IViewData.d.ts

@@ -2,4 +2,16 @@ export interface IViewData {
     minEdge: number;
     containerId: string;
     borderAnimationDuration: number;
+    /** Poids de ce satellite relatif à la moyenne de sa fratrie (1 = moyenne),
+     *  déjà utilisé pour dériver minEdge dans YinYangController.createYinYangChildren.
+     *  Reporté ici tel quel pour que le satellite compense sa propre taille de
+     *  police (voir YinYangDrawer.renderChildStateLabel) sans redériver le
+     *  calcul. Absent pour les patterns qui ne sont pas des satellites. */
+    weightRatio?: number;
+    /** Poids brut (échelle absolue [WEIGHT_MIN, WEIGHT_MAX], voir causeMetrics.ts),
+     *  distinct de weightRatio qui est relatif à la fratrie : sert à savoir
+     *  combien de graduations remplir dans la jauge de poids du satellite
+     *  (voir YinYangDrawer.renderChildWeightGauge). Absent pour les patterns
+     *  qui ne sont pas des satellites. */
+    weight?: number;
 }

package/dist/types/interfaces/IYinYangAppFactory.d.ts

@@ -2,14 +2,14 @@ import { YinYangModel } from "../components/model/YinYangModel";
 import { IYinYangView } from "./IYinYangView";
 import { IYinYangController } from "./IYinYangController";
 import { AnimationsMngr } from "../animations/AnimationsMngr";
-import { IOddItem } from "../interfaces/IOddItem";
+import { YinYangInternalModel } from "./IYinYangInternalModel";
 import { IGraphicsStrategy } from "./IGraphicsStrategy";
 import { IViewData } from "./IViewData";
 export interface IYinYangAppFactory {
     graphicsStrategy: IGraphicsStrategy;
     animator: AnimationsMngr;
-    create(modelData: IOddItem[], viewData: IViewData, isEnemy: boolean, parentKey?: string | null): IYinYangController;
-    createModel(dataSubset: IOddItem[], isEnemy: boolean, parentKey?: string | null): YinYangModel;
+    create(modelData: YinYangInternalModel, viewData: IViewData, parentKey?: string | null): IYinYangController;
+    createModel(dataSubset: YinYangInternalModel, parentKey?: string | null): YinYangModel;
     createView(): IYinYangView;
     createController(model: YinYangModel, view: IYinYangView): IYinYangController;
     createAnimationsManager(): AnimationsMngr;