@micheeeeel/yinyangapp 3.0.1 → 3.1.1

package/dist/types/adapters/yasuniCauseAdapter.d.ts

@@ -1,13 +1,13 @@
 import type { Composante } from "../data/yasuni_cause";
 import type { Cause } from "../interfaces/ICauseModel";
-import { type ContactProfileData } from "../data/contacts";
+import { type ContactProfileData, type ObstacleSignatureData } from "../data/contacts";
 /**
  * Adapte le catalogue Composante[] (format yasuni_cause.ts) vers le format
  * Cause attendu par mapCauseToInternalModel.
  * Les scores initiaux sont neutres (0.5 = 50 % de tension), les poids valent 1
  * par satellite tant qu'aucune valeur n'est renseignée dans les données.
  * Poids d'une facette (taille de son arc) : C_f, moyenne des poids de TOUS
- * ses satellites, catégories confondues, zéros inclus (`meanWeight`) — même
+ * ses satellites, catégories confondues, zéros inclus (`facetWeight`) — même
  * règle pour une cause et pour un contact (POC-05A4).
  */
 export declare function composantesToCause(composantes: Composante[], id?: string, name?: string): Cause;
@@ -28,3 +28,14 @@ export declare function getYasuniCause(id?: string): Cause;
  * bornes (`validateContactProfile`).
  */
 export declare function contactProfileToCause(profile: ContactProfileData, id?: string): Cause;
+/**
+ * La `Cause` d'une SIGNATURE D'OBSTACLE (OBS-UI-01) : les huit facettes
+ * universelles d'un contact, chacune pesant son exigence O_f, SANS SCORE
+ * (`scoreless`) — un obstacle n'a pas de qualité. Montée avec
+ * `presentation: true`, elle s'affiche en Idle « facettes » ou « tab »
+ * (satellites-facettes à la taille de O_f) ; `setFacetModulation` y
+ * superpose ensuite la lecture d'un contact. Fraîchement construite à
+ * chaque appel ; lève une erreur explicite pour une signature invalide
+ * (`validateObstacleSignature`).
+ */
+export declare function obstacleSignatureToCause(signature: ObstacleSignatureData, id?: string): Cause;

package/dist/types/adapters/yinYangAdapter.d.ts

@@ -1,6 +1,13 @@
 import { YinYangComponentNode, YinYangInternalModel, YinYangOddNode } from "../interfaces/IYinYangInternalModel";
 import { Cause } from "../interfaces/ICauseModel";
 export declare function mapCauseToInternalModel(cause: Cause): YinYangInternalModel;
+/**
+ * Builds the internal model of a facette satellite (Idle « facettes »
+ * sub-state): the whole facette — every ODD and cutting — as the single
+ * component of its own model. The satellite thus derives its yin/yang from
+ * facetTensionFromOdds exactly as the main circle does for that facette.
+ */
+export declare function buildChildFacetteInternalModel(component: YinYangComponentNode): YinYangInternalModel;
 /**
  * Builds a single-component, single-odd, single-cutting internal model for a
  * satellite child, preserving the parent odd's orientation/labels so the

package/dist/types/animations/AnimationsMngr.d.ts

@@ -1,8 +1,22 @@
 import { IYinYangController } from "../interfaces/IYinYangController";
+/**
+ * Rotation Yin/Yang du composant central et de ses satellites, composée par
+ * le navigateur : chaque mouvement (rampe, croisière, freinage) est décrit
+ * analytiquement (rotationMotion.ts) et joué par des Web Animations sur
+ * `transform`. Le contenu des lobes (arcs masqués, dégradés, images) n'est
+ * alors plus redessiné à chaque image : seule leur position change, sur le
+ * GPU, et le thread principal n'a plus rien à faire à chaque image. Les
+ * animations ne sont refaites que sur signal (ViewInitializer.
+ * onRotationTargetsChanged : géométrie des lobes, libellés redessinés), et
+ * la fin d'un freinage est programmée par une minuterie.
+ */
 export declare class AnimationsMngr {
     private subscriberMap;
     subscribe(component: IYinYangController, clockWise?: boolean, time?: number): void;
     startAll(): void;
+    /** Change la durée d'un tour. Une rotation en cours (hors freinage) y
+     *  converge au rythme de sa rampe — progressivement plutôt que d'un coup
+     *  si `rampMs > 0`. */
     setRotationDuration(durationMs: number): void;
     revertRotation(component: IYinYangController): void;
     /**
@@ -15,13 +29,13 @@ export declare class AnimationsMngr {
      */
     stopRotation(component: IYinYangController, rampMs?: number): void;
     /**
-     * Désabonne un composant en fin de vie : coupe sa boucle rAF et libère son
-     * verrou d'animation, SANS toucher au DOM. À utiliser (et non stopRotation)
-     * quand les éléments vont être détruits : finalizeStop remettrait les
-     * transforms des lobes yin/yang à la position de base (resetRotationFrame)
-     * or ces groupes vivent dans globalGroup, pas dans le yinYangGroup que
-     * clearChildren retire — le reset ressusciterait donc à l'écran des
-     * satellites pourtant retirés.
+     * Désabonne un composant en fin de vie : annule ses animations et libère
+     * son verrou d'animation, SANS écrire dans le DOM. À utiliser (et non
+     * stopRotation) quand les éléments vont être détruits : finalizeStop
+     * remettrait les transforms des lobes yin/yang à la position de base
+     * (resetRotationFrame) or ces groupes vivent dans globalGroup, pas dans le
+     * yinYangGroup que clearChildren retire — le reset ressusciterait donc à
+     * l'écran des satellites pourtant retirés.
      */
     unsubscribe(component: IYinYangController): void;
     /**
@@ -54,18 +68,58 @@ export declare class AnimationsMngr {
      * choisie par l'utilisateur — voir `computeFastStopProfile`.
      */
     private beginFastHomingStop;
+    private beginBrake;
     private finalizeStop;
+    /** Fin de rotation sans toucher au DOM : animations annulées, veilles
+     *  débranchées, verrou d'animation rendu. */
+    private release;
     private resetRotationFrame;
     /**
      * Démarre (ou modifie en vol) la rotation. Avec `rampMs > 0`, la vitesse
-     * angulaire part de sa valeur courante (0 si à l'arrêt) et chasse
-     * progressivement la vitesse cible déduite de `time`/`clockWise` — un appel
-     * pendant qu'un arrêt progressif est en cours ré-accélère en douceur depuis
-     * la vitesse déjà atteinte, sans à-coup. `rampMs` omis (0) → vitesse cible
-     * appliquée instantanément, comportement historique.
+     * angulaire part de sa valeur courante (0 si à l'arrêt) et rejoint la
+     * vitesse cible déduite de `time`/`clockWise` à accélération constante — un
+     * appel pendant qu'un arrêt progressif est en cours ré-accélère en douceur
+     * depuis la vitesse déjà atteinte, sans à-coup. `rampMs` omis (0) → vitesse
+     * cible appliquée instantanément, comportement historique.
      */
     animate(component: IYinYangController, clockWise: boolean, time?: number, rampMs?: number): void;
-    private startRotationLoop;
-    private applyRotationFrame;
-    private applyRotationToYinYangGroup;
+    /** Mouvement vers la vitesse cible depuis l'état courant (angle et
+     *  vitesse à cet instant, qu'il y ait rotation, freinage ou arrêt). */
+    private startMotion;
+    private play;
+    /** Géométrie des lobes changée, ghost rempli ou libellés redessinés
+     *  pendant la rotation : seules les pistes concernées sont refaites. */
+    private resync;
+    /**
+     * Cœur et lobes (base et ghost). Le cœur tourne de θ autour du centre du
+     * symbole ; chaque lobe orbite de θ autour de ce même centre puis tourne
+     * de ∓2θ sur lui-même — même cinématique que le film (api-film.ts). Les
+     * lobes ne sont pas dans le yinYangGroup : chacun porte l'orbite et sa
+     * rotation propre dans une seule liste de transformations, interpolée
+     * fonction par fonction (angles linéaires en θ).
+     */
+    private syncLobes;
+    /** Libellés contre-tournés : orientation opposée à celle de leur lobe. */
+    private syncLabels;
+    /**
+     * (Re)pose les animations des cibles dont la piste est absente ou
+     * périmée ; oublie celles des nœuds sortis du document. Une cible qui ne
+     * peint rien (ghost vide, libellé masqué) n'est pas animée : le navigateur
+     * refuse de composer une animation sans effet visible et la joue alors
+     * sur le thread principal, qui repeindrait tout à chaque image.
+     */
+    private syncTargets;
+    private dropTrack;
+    /**
+     * Une animation par tronçon, calée sur `document.timeline` : les tronçons
+     * s'enchaînent d'eux-mêmes, sans attendre le JS. Un tronçon fini garde sa
+     * pose finale (fill forwards) sous le suivant, créé après lui donc
+     * prioritaire dès qu'il démarre : pas d'image vide à la jonction. La
+     * croisière boucle sur un tour (θ → θ ± 360°), pose identique aux bornes
+     * pour chaque cible (multiples entiers de θ).
+     */
+    private animateTarget;
+    private cancelTracks;
+    /** Horloge des animations (temps de l'image courante). */
+    private now;
 }

package/dist/types/animations/FrameScheduler.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Horloge d'animation commune : UNE seule requestAnimationFrame native par
+ * frame, quel que soit le nombre de boucles actives (rotation, orbite,
+ * transition de facette, ghost, champ de force, étincelles…).
+ *
+ * L'API reprend celle de requestAnimationFrame / cancelAnimationFrame pour
+ * que les boucles existantes migrent sans changer de forme : un rappel
+ * demandé pendant une frame s'exécute à la frame suivante, avec l'horodatage
+ * de la frame ; il ne tourne qu'une fois, la boucle se ré-abonne si elle veut
+ * continuer. Quand plus aucun rappel n'est en attente, plus aucune rAF native
+ * n'est demandée : l'arrêt est automatique.
+ *
+ * En plus de rAF :
+ * - phases : tous les rappels `read` (mesures DOM : getBBox,
+ *   getBoundingClientRect…) passent avant tous les rappels `write` de la même
+ *   frame, ce qui évite d'alterner lecture et écriture (layout forcé) ;
+ * - `fps` : cadence maximale d'un effet décoratif. Le rappel est simplement
+ *   reporté aux frames suivantes tant que l'intervalle n'est pas écoulé ; la
+ *   boucle étant pilotée par l'horodatage, l'animation garde sa vitesse, elle
+ *   est seulement échantillonnée moins souvent ;
+ * - `pauseWhenHidden` : rappel suspendu tant que le diagramme est hors écran
+ *   (voir observeVisibility). L'onglet caché, lui, est déjà géré par le
+ *   navigateur, qui n'appelle plus rAF ;
+ * - activité (`isActive`, `onActivityChange`) : vrai tant qu'une boucle tourne
+ *   à chaque frame depuis un moment, c.-à-d. que le diagramme est de toute
+ *   façon repeint sur le thread principal. Un effet peut alors préférer
+ *   s'y joindre plutôt que d'ajouter des calques composés (voir
+ *   borderColorCycle). Les rappels `passive` n'en comptent pas.
+ */
+export type FramePhase = "read" | "write";
+export interface FrameRequestOptions {
+    /** Défaut "write". */
+    phase?: FramePhase;
+    /** Cadence maximale (images/s) — pour les effets décoratifs. */
+    fps?: number;
+    /** Suspendu tant que le diagramme est hors écran. */
+    pauseWhenHidden?: boolean;
+    /** Ne compte pas comme activité (voir isActive) : un effet qui ne tourne
+     *  que parce que le diagramme est actif ne doit pas l'entretenir. */
+    passive?: boolean;
+}
+/** Ce que les appelants utilisent de d3.Timer. */
+export interface FrameTimer {
+    stop(): void;
+}
+export declare class FrameScheduler {
+    private nextId;
+    private queue;
+    /** Frame en cours d'exécution : un cancel() doit aussi pouvoir y retirer
+     *  un rappel pas encore exécuté, comme cancelAnimationFrame. */
+    private running;
+    private nativeFrameId;
+    /** Dernière exécution de chaque boucle bridée, indexée par son rappel :
+     *  une boucle se ré-abonne avec la même fonction à chaque frame. */
+    private lastRunByCallback;
+    private observer;
+    private visibility;
+    private active;
+    /** Début de la suite de frames actives en cours, null hors d'une suite. */
+    private activeStreakStart;
+    private lastActiveAt;
+    private activityListeners;
+    request(callback: FrameRequestCallback, options?: FrameRequestOptions): number;
+    cancel(id: number | null | undefined): void;
+    /** Équivalent de d3.timer : `callback(elapsedMs)` à chaque frame jusqu'à
+     *  stop(). */
+    timer(callback: (elapsedMs: number) => void, options?: FrameRequestOptions): FrameTimer;
+    /**
+     * Déclare un élément racine du diagramme : tant qu'aucun des éléments
+     * déclarés n'est à l'écran, les rappels `pauseWhenHidden` sont suspendus.
+     */
+    observeVisibility(element: Element): void;
+    /** Inverse d'observeVisibility : le diagramme est démonté. */
+    unobserveVisibility(element: Element): void;
+    isDiagramVisible(): boolean;
+    /** Vrai quand une boucle non passive tourne depuis ACTIVITY_ENTER_MS : le
+     *  diagramme est alors repeint à chaque frame sur le thread principal. */
+    get isActive(): boolean;
+    /** Prévient à chaque bascule actif/repos ; renvoie le désabonnement. Le
+     *  retour au repos n'est constaté que par une frame : un écouteur qui veut
+     *  le voir garde une boucle `passive` tant qu'il est actif. */
+    onActivityChange(listener: (active: boolean) => void): () => void;
+    /** Nombre de rappels en attente (diagnostic, tests). */
+    get pendingCount(): number;
+    /** Tests : oublie tout, y compris la rAF native en attente (les tests
+     *  remplacent requestAnimationFrame entre deux cas). */
+    reset(): void;
+    private ensureNativeFrame;
+    private hasRunnableEntry;
+    private flush;
+    private trackActivity;
+}
+export declare const frameScheduler: FrameScheduler;
+/** Effets permanents sans valeur hors écran (étincelle du pourtour,
+ *  surbrillance d'ODD) : suspendus quand le diagramme n'est pas visible. */
+export declare const AMBIENT_FRAME: FrameRequestOptions;
+/** Effets décoratifs en boucle (vagues et pulsation du ghost) : bridés à
+ *  animationConfig.decorativeFps et suspendus hors écran. */
+export declare const DECORATIVE_FRAME: FrameRequestOptions;

package/dist/types/animations/rotationMotion.d.ts

@@ -0,0 +1,43 @@
+import { FastStopProfile } from "./fastHomingStop";
+/**
+ * Mouvement angulaire décrit analytiquement, tronçon par tronçon, pour être
+ * joué par le navigateur (Web Animations) plutôt qu'écrit image par image :
+ * chaque tronçon est à accélération constante, donc sa position est un
+ * polynôme du second degré en temps, qu'une courbe `cubic-bezier` reproduit
+ * exactement (voir `segmentEasing`).
+ *
+ * Les temps sont ceux de `document.timeline` (ms), les angles en degrés, les
+ * vitesses en °/ms et les accélérations en °/ms², tous signés (+ = horaire).
+ * Les calculs ne dépendent pas de l'unité d'angle : l'orbite des satellites
+ * (ChildrenOrbitManager) les fait en radians.
+ */
+export interface MotionSegment {
+    startTime: number;
+    /** Infinity = croisière à vitesse constante, sans fin. */
+    duration: number;
+    angle0: number;
+    omega0: number;
+    accel: number;
+}
+export declare function angleAfter(segment: MotionSegment, elapsedMs: number): number;
+export declare function motionEndTime(segments: MotionSegment[]): number;
+/** Angle et vitesse du mouvement à l'instant `time` (0 sans mouvement). */
+export declare function evaluateMotion(segments: MotionSegment[], time: number): {
+    angle: number;
+    omega: number;
+};
+/**
+ * Démarrage ou changement de vitesse : rampe à accélération constante
+ * (`accelMag`, °/ms²) de `omega` vers `targetOmega`, puis croisière.
+ * `accelMag` ≤ 0 → vitesse cible appliquée d'emblée.
+ */
+export declare function rampSegments(startTime: number, angle: number, omega: number, targetOmega: number, accelMag: number): MotionSegment[];
+/** Freinage vers la position de base selon un profil de `fastHomingStop`. */
+export declare function brakeSegments(startTime: number, angle: number, direction: number, profile: FastStopProfile): MotionSegment[];
+/**
+ * Courbe d'accélération d'un tronçon fini. Avec x1 = 1/3 et x2 = 2/3, le
+ * temps est linéaire dans le paramètre de la courbe ; la progression est
+ * alors le polynôme cubique de mêmes pentes aux bornes que la position, qui
+ * est du second degré : c'est donc elle, exactement.
+ */
+export declare function segmentEasing(segment: MotionSegment): string;

package/dist/types/api.d.ts

@@ -4,9 +4,14 @@ import type { YinYangInternalModel } from "./interfaces/IYinYangInternalModel";
 import type { Cause } from "./interfaces/ICauseModel";
 export type { IViewData } from "./interfaces/IViewData";
 export type { IYinYangController } from "./interfaces/IYinYangController";
-export type { Cause, CauseComponent, CauseOdd, CauseOddCutting, } from "./interfaces/ICauseModel";
+export type { Cause, CauseComponent, CauseOdd, CauseOddCutting, FacetNotion, } from "./interfaces/ICauseModel";
 export type { YinYangInternalModel, YinYangComponentNode, YinYangOddNode, YinYangCuttingNode, YinYangCategorySlice, YinYangOrientation, } from "./interfaces/IYinYangInternalModel";
 export { mapCauseToInternalModel } from "./adapters/yinYangAdapter";
+/** Sous-état Idle du diagramme (aucune facette ouverte) — voir
+ *  `YinYangMountConfig.idleView`. */
+export type YinYangIdleView = "arcs" | "facettes" | "tab";
+export type { FacetModulation, FacetModulationOptions, } from "./components/controller/children/facetModulation";
+import type { FacetModulation, FacetModulationOptions } from "./components/controller/children/facetModulation";
 /** Données acceptées : soit une `Cause` (format métier), soit le modèle interne déjà adapté. */
 export type YinYangData = Cause | YinYangInternalModel;
 export interface YinYangSvgConfig {
@@ -29,10 +34,31 @@ export interface YinYangMountConfig {
     /** Mode PRÉSENTATION : le diagramme se lit, il ne se manœuvre pas — voir
      *  `IViewData.presentation`. Défaut : false (l'atelier complet). */
     presentation?: boolean;
+    /** Sous-état Idle affiché au montage : `"arcs"` (arcs pondérés des
+     *  facettes autour de l'illustration) ou `"facettes"` (un satellite
+     *  yin/yang par facette, à l'angle de son arc) ou `"tab"` (ces mêmes
+     *  satellites rangés dans une grille régulière autour d'une illustration
+     *  réduite — les facettes d'une même notion parente, `CauseComponent.notion`,
+     *  y sont regroupées). L'utilisateur passe ensuite d'un sous-état au
+     *  suivant en cliquant l'illustration centrale. Défaut : `"arcs"`. */
+    idleView?: YinYangIdleView;
 }
 export interface YinYangMountHandle {
     controller: IYinYangController;
-    /** Vide le conteneur. */
+    /** Bascule (animée) du sous-état Idle — voir `YinYangMountConfig.idleView`.
+     *  Facette ouverte : le choix s'applique à sa fermeture. */
+    setIdleView(view: YinYangIdleView): Promise<void>;
+    /** Signature d'obstacle (`obstacleSignatureToCause`) : y superpose la
+     *  lecture d'un contact, ou la retire (`null`). Pour chaque facette (id) :
+     *  `weights` le poids modulé W_f (0–10, diamètre du satellite), `scores`
+     *  la qualité Q_f du contact (0–100, sa chance affichée). Le diamètre
+     *  d'origine (O_f) reste visible en fantôme ; places et échelle ne
+     *  bougent pas. `durationMs` anime le passage (0 : immédiat),
+     *  `ghostWaves` fait courir la vague du fantôme (à couper en mouvement
+     *  réduit). Une facette de poids nul reste sans score. */
+    setFacetModulation(modulation: FacetModulation | null, options?: FacetModulationOptions): Promise<void>;
+    /** Arrête toutes les boucles d'animation du diagramme (champ de force,
+     *  orbite, rotation, ghost, étincelles…) puis vide le conteneur. */
     destroy(): void;
 }
 /**
@@ -58,10 +84,12 @@ export { createYinYangFilmSvg, createYinYangFilmSvgAsync } from "./api-film";
 export type { YinYangFilmConfig, YinYangFilmAsyncOptions } from "./api-film";
 export { createRandomCause } from "./api-random";
 export type { RandomCauseOptions, RandomRange } from "./api-random";
-export { getYasuniCause, contactProfileToCause } from "./adapters/yasuniCauseAdapter";
+export { getYasuniCause, contactProfileToCause, obstacleSignatureToCause, } from "./adapters/yasuniCauseAdapter";
 export { validateContactProfile } from "./data/contacts/buildContactSphere";
 export type { ContactProfileData, ContactSatelliteValue, } from "./data/contacts/buildContactSphere";
 export { UNIVERSAL_FACETS, CONTACT_CATEGORIES } from "./data/contacts/universalFacets";
+export { contactFacetReadings, obstacleFacetWeight, obstacleModulation, validateObstacleSignature, } from "./data/contacts/obstacleSignature";
+export type { ContactFacetReading, ObstacleSignatureData, } from "./data/contacts/obstacleSignature";
 export type { SatelliteKey, ContactFacetId, ContactCategoryId, UniversalFacet, UniversalSatellite, ContactCategory, } from "./data/contacts/universalFacets";
 export { mountYinYangWorkspace } from "./api-workspace";
 export type { YinYangWorkspaceConfig, YinYangWorkspaceHandle, } from "./api-workspace";

package/dist/types/benchmark/runner.d.ts

@@ -1,5 +1,25 @@
 declare global {
     var runBenchmark: () => Promise<void>;
     var runBenchmarkAvg: (n: number) => Promise<void>;
+    var runBenchmarkReport: (only?: string[]) => Promise<BenchmarkReport>;
+}
+import { type DomCounts } from "./scenarios";
+interface ScenarioResult {
+    name: string;
+    description: string;
+    duration: number;
+    setupMs?: number;
+    avgFrameMs: number;
+    p95FrameMs: number;
+    longTasksCount: number;
+    domCounts?: DomCounts;
+}
+interface BenchmarkReport {
+    commit: string;
+    timestamp: string;
+    runsCount?: number;
+    longTaskObserverOk?: boolean;
+    scenarios: ScenarioResult[];
+    analysis?: Record<string, unknown>;
 }
 export {};

package/dist/types/benchmark/scenarios.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Compteurs DOM d'un scénario (détection de fuites : nœuds SVG, `<animate>` SMIL,
+ * enfants de `<defs>`). Relevés par le scénario juste avant de retirer son
+ * conteneur, puis lus une seule fois par le runner via takeDomCounts().
+ */
+export interface DomCounts {
+    svgNodes: number;
+    animateNodes: number;
+    defsChildren: number;
+}
+export declare function takeDomCounts(): DomCounts | undefined;
 /**
  * Scenario 1 — Large dataset initialization.
  *
@@ -35,10 +46,9 @@ export declare function runComponentSwitchScenario(hooks?: ComponentSwitchHooks)
 /**
  * Scenario 3 — Rotation animation.
  *
- * Starts the continuous rotation animation (AnimationsMngr RAF loop) on a
- * full Yasuni instance including orbit children, and lets it run for
- * TRANSITION_DURATION_MS. Measures per-frame cost: Yin/Yang orbital math,
- * SVG transform updates for parent + all children.
+ * Starts the continuous rotation animation (AnimationsMngr, Web Animations
+ * composed by the browser) on a full Yasuni instance including orbit
+ * children, and lets it run for TRANSITION_DURATION_MS.
  *
  * Performance measure name: "bm-transition"
  */
@@ -50,8 +60,8 @@ export interface BaselineHooks {
 /**
  * Scenario — Baseline (pivot).
  *
- * Controller + satellites en état idle : aucune action activée, aucune rotation,
- * aucun champ de force. Seuls les RAF loops systèmes tournent en arrière-plan
+ * Facette 0 ouverte (donc satellites présents), sans action, rotation ni champ de force :
+ * seuls les RAF loops systèmes tournent en arrière-plan
  * (ghost pulse, outer spark, cycle couleurs de bordure).
  *
  * Sert de référence directe pour quantifier le surcoût de chaque autre scénario :
@@ -116,3 +126,42 @@ export declare function runForceFieldDirectScenario(hooks?: ForceFieldHooks): Pr
  * Performance measure names: "bm-forcefield-merged-setup", "bm-forcefield-merged"
  */
 export declare function runForceFieldMergedScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 8 — ghostProjection : action projetée en mode Pile, 3 s.
+ *
+ * Mode Pile forcé + activation d'une action (ODD_15 / cut0) : le ghost (badge
+ * de deltas, vagues, arc / bordure / spikes ghost) tourne en boucle sans fin.
+ * Mesure le régime établi pendant 3 s, une fois la projection affichée.
+ *
+ * Performance measure names: "bm-ghost-setup", "bm-ghost"
+ */
+export declare function runGhostProjectionScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 9 — orbit : orbite des satellites SANS action active (3 s).
+ *
+ * setChildrenOrbitEnabled(true) : chaque frame, ChildrenOrbitManager.applyTransforms
+ * déclenche renderOppositeChildrenForceField (labels de contexte, panneau de
+ * détails…). Cible : la cascade applicative à 60 fps hors champ de force.
+ *
+ * Performance measure name: "bm-orbit"
+ */
+export declare function runOrbitScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 10 — orbitAction : orbite des satellites AVEC une action active (3 s).
+ *
+ * Même chose qu'orbit, mais après searchNavigateToAction : le champ de force
+ * est alors dessiné par l'orbite ET par sa propre boucle.
+ *
+ * Performance measure names: "bm-orbit-action-setup", "bm-orbit-action"
+ */
+export declare function runOrbitActionScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 11 — idleTabMorph : Idle « facettes » → « tab » → « facettes ».
+ *
+ * La fenêtre de mesure couvre les deux morphs et un maintien de 1 s sur la
+ * grille « tab » (transform sur le globalGroup racine à chaque tick, fondus
+ * d'images clip-pathées).
+ *
+ * Performance measure name: "bm-idle-tab"
+ */
+export declare function runIdleTabMorphScenario(hooks?: ForceFieldHooks): Promise<void>;