@lemoncat7/dsh-theme-xiaohei 0.3.0-alpha.22 → 0.3.1

package/lib/vendor/bloub/expressions.d.ts

@@ -0,0 +1,35 @@
+import { type HeadGaze } from './face.js';
+import type { EyeCfg } from './states.js';
+/**
+ * Expression de repos du bot.
+ *
+ * Le visage ne tient qu'à deux gélules, donc tout se joue sur quatre leviers :
+ * l'orientation de la tête, l'écart des yeux, leurs proportions, et
+ * l'inclinaison propre de chaque œil. C'est ce dernier qui permet la colère et
+ * la tristesse : elles demandent des inclinaisons EN MIROIR (les hauts qui
+ * convergent ou divergent), impossible avec le seul roulis de tête qui incline
+ * les deux yeux du même côté.
+ *
+ * Seul l'état de repos porte cette expression. Les états expressifs de la vidéo
+ * (clin d'œil, yeux écarquillés, notification) gardent la leur : c'est elle
+ * qu'on est venu reproduire.
+ *
+ * Les amplitudes s'appuient sur bible-strong-avatar-lab, qui expose le même
+ * modèle (tête X/Y/Z, largeur et hauteur par œil, écart, angle par œil) : chez
+ * eux la largeur va de 0,8 à 2,7 fois le neutre, la hauteur de 0,3 à 1,5, et
+ * les angles jusqu'à ±80°. On reste dans cette enveloppe.
+ */
+/** Enumeres pour que la couche i18n verifie leurs traductions a la compilation. */
+export type ExpressionId = 'neutre' | 'attentif' | 'surpris' | 'excite' | 'heureux' | 'hilare' | 'colere' | 'triste' | 'effraye' | 'mefiant' | 'confus' | 'curieux' | 'fier' | 'timide' | 'blase' | 'somnolent';
+export interface BotExpression {
+    id: ExpressionId;
+    gaze: HeadGaze;
+    split: number;
+    eyes: [EyeCfg, EyeCfg];
+}
+export declare const EXPRESSIONS: BotExpression[];
+export declare const EXPRESSION_BY_ID: Map<string, BotExpression>;
+export declare const DEFAULT_EXPRESSION = "neutre";
+/** Interpolation de deux expressions : le changement se fait en glissant. */
+export declare function blendExpression(a: BotExpression, b: BotExpression, t: number): BotExpression;
+//# sourceMappingURL=expressions.d.ts.map

package/lib/vendor/bloub/expressions.js

@@ -0,0 +1,143 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+import { EYE_H, EYE_SPLIT, EYE_W, REST_GAZE } from './face.js';
+import { lerp } from './math.js';
+/** `tilt` en degrés, positif = le haut de la gélule part vers la droite. */
+const eye = (w, h, tilt = 0, open = 1) => ({ w, h, tilt, open });
+/** Les deux yeux identiques, inclinaisons en miroir si `tilt` est fourni. */
+const pair = (w, h, tilt = 0, open = 1) => [
+    eye(w, h, tilt, open),
+    eye(w, h, -tilt, open)
+];
+export const EXPRESSIONS = [
+    {
+        // la pose relevée image par image sur la vidéo de référence
+        id: 'neutre',
+        gaze: { ...REST_GAZE },
+        split: EYE_SPLIT,
+        eyes: [eye(EYE_W, EYE_H), eye(EYE_W, EYE_H)]
+    },
+    {
+        id: 'attentif',
+        gaze: { yaw: 4, pitch: 5, roll: -4 },
+        split: 16,
+        eyes: pair(0.21, 0.44)
+    },
+    {
+        id: 'surpris',
+        gaze: { yaw: 3, pitch: -3, roll: 0 },
+        split: 19,
+        eyes: pair(0.45, 0.47)
+    },
+    {
+        id: 'excite',
+        gaze: { yaw: 6, pitch: -14, roll: 0 },
+        split: 19.5,
+        eyes: pair(0.4, 0.56, -10)
+    },
+    {
+        // yeux plissés en arc : les hauts convergent légèrement
+        id: 'heureux',
+        gaze: { yaw: 5, pitch: 9, roll: 0 },
+        split: 17,
+        eyes: pair(0.27, 0.17, 14)
+    },
+    {
+        id: 'hilare',
+        gaze: { yaw: 4, pitch: 14, roll: 0 },
+        split: 18,
+        eyes: pair(0.34, 0.13, 20)
+    },
+    {
+        // hauts des yeux qui convergent fort vers le centre + yeux étrécis
+        id: 'colere',
+        gaze: { yaw: 3, pitch: 7, roll: 0 },
+        split: 17,
+        eyes: pair(0.34, 0.15, 30)
+    },
+    {
+        // l'inverse : les hauts divergent, et le regard tombe
+        id: 'triste',
+        gaze: { yaw: 3, pitch: -13, roll: 0 },
+        split: 16,
+        eyes: pair(0.22, 0.4, -28)
+    },
+    {
+        id: 'effraye',
+        gaze: { yaw: 2, pitch: -20, roll: 0 },
+        split: 20.5,
+        eyes: pair(0.4, 0.6)
+    },
+    {
+        // un œil franchement plus fermé que l'autre
+        id: 'mefiant',
+        gaze: { yaw: 12, pitch: 6, roll: -6 },
+        split: 16,
+        eyes: [eye(0.21, 0.4), eye(0.22, 0.15)]
+    },
+    {
+        // asymétrique sur les deux axes : tailles ET inclinaisons dépareillées.
+        // L'œil plissé est volontairement plat (rapport 1,6) : à un rapport proche
+        // de 1 il serait rond, et son inclinaison ne se verrait pas.
+        id: 'confus',
+        gaze: { yaw: -14, pitch: 3, roll: 8 },
+        split: 16.5,
+        eyes: [eye(0.2, 0.44, -18), eye(0.28, 0.17, 14)]
+    },
+    {
+        // la tête penche : c'est le roulis qui porte la curiosité
+        id: 'curieux',
+        gaze: { yaw: 16, pitch: -9, roll: -15 },
+        split: 16.5,
+        eyes: [eye(0.24, 0.46, -8), eye(0.2, 0.38, -8)]
+    },
+    {
+        id: 'fier',
+        gaze: { yaw: 5, pitch: 17, roll: 0 },
+        split: 17,
+        eyes: pair(0.3, 0.15, 18)
+    },
+    {
+        id: 'timide',
+        gaze: { yaw: -19, pitch: -14, roll: -7 },
+        split: 14,
+        eyes: pair(0.17, 0.3)
+    },
+    {
+        // fentes horizontales et regard qui part sur le côté
+        id: 'blase',
+        gaze: { yaw: -22, pitch: 2, roll: 0 },
+        split: 16,
+        eyes: pair(0.3, 0.12)
+    },
+    {
+        // paupières à moitié tombées : on passe par `open`, donc l'écrasement
+        // vertical à l'écran, le même mécanisme que le clignement
+        id: 'somnolent',
+        gaze: { yaw: 6, pitch: -9, roll: -3 },
+        split: 16,
+        eyes: pair(0.2, 0.42, 0, 0.42)
+    }
+];
+export const EXPRESSION_BY_ID = new Map(EXPRESSIONS.map((e) => [e.id, e]));
+export const DEFAULT_EXPRESSION = 'neutre';
+const lerpEyeCfg = (a, b, t) => ({
+    w: lerp(a.w, b.w, t),
+    h: lerp(a.h, b.h, t),
+    tilt: lerp(a.tilt ?? 0, b.tilt ?? 0, t),
+    open: lerp(a.open, b.open, t)
+});
+/** Interpolation de deux expressions : le changement se fait en glissant. */
+export function blendExpression(a, b, t) {
+    return {
+        id: b.id,
+        gaze: {
+            yaw: lerp(a.gaze.yaw, b.gaze.yaw, t),
+            pitch: lerp(a.gaze.pitch, b.gaze.pitch, t),
+            roll: lerp(a.gaze.roll, b.gaze.roll, t)
+        },
+        split: lerp(a.split, b.split, t),
+        eyes: [lerpEyeCfg(a.eyes[0], b.eyes[0], t), lerpEyeCfg(a.eyes[1], b.eyes[1], t)]
+    };
+}
+//# sourceMappingURL=expressions.js.map

package/lib/vendor/bloub/eyefit.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Ou poser le visage sur une forme du personnalisateur.
+ *
+ * Les yeux vivent sur une sphere, et `radiusAtAngle` les recolle au contour reel au
+ * prorata du rayon local. Ce prorata place bien leur CENTRE, mais l'oeil a une taille :
+ * la marge qui lui reste devant le bord est multipliee par le meme facteur, donc une
+ * silhouette etroite dans sa direction le pousse contre le bord jusqu'a ce que le
+ * masque l'ouvre vers l'exterieur. La gelule apparaissait comme une encoche dans le
+ * corps sur `capsule`, `triangle`, `nuage` et `goutte`.
+ *
+ * Ce module resout le probleme UNE FOIS, au chargement, et rend une table de decalages.
+ * Ce choix est l'essentiel du correctif, bien plus que la geometrie qui suit :
+ *
+ * Resolue dans la boucle de rendu, la correction reagit a tout ce qui bouge a soixante
+ * images par seconde — la derive du regard, le pointeur, l'expression en cours de
+ * morph, le bord le plus proche qui change, l'oeil le plus contraint qui change. Sept
+ * variantes ont ete ecrites ainsi et toutes produisaient un artefact de mouvement
+ * visible : tremblement permanent, saut de direction de 26 unites quand le bord de
+ * reference basculait, grossissement brusque quand la taille entrait dans le calcul.
+ * Le defaut n'etait dans aucune de leurs geometries, il etait dans le fait de resoudre
+ * par image.
+ *
+ * Le reste du moteur ne travaille pas comme ca : les poses sont DECLAREES et il ne fait
+ * que les interpoler avec des courbes connues. Un decalage tabule rentre dans ce moule.
+ * Il ne bouge pas quand le regard derive ni quand le pointeur bouge, et sur un changement
+ * de forme ou d'expression il ne fait qu'aller d'une entree de table a l'autre, sur la
+ * courbe de ce morph. Le tremblement devient impossible par construction, au lieu d'etre
+ * repousse : interpoler entre deux constantes est monotone, alors que re-resoudre le
+ * probleme sur un regard en cours d'interpolation ne l'est pas.
+ *
+ * Corollaire agreable : le solveur n'a plus aucune contrainte de continuite, puisqu'il ne
+ * tourne pas pendant l'animation. Il peut donc sonder tout un faisceau de directions et
+ * couvrir le pire cas de la derive du regard, ce qu'une version par image ne pouvait pas
+ * se permettre.
+ *
+ * La table est une constante de module, batie a l'import a partir de donnees pures :
+ * meme nature que le calendrier de clignements de `face.ts`, deterministe et sans etat,
+ * donc sans effet sur la purete de `engine.sample(t)`.
+ */
+import { type StateId } from './states.js';
+/**
+ * Table des decalages, batie a l'import : une entree par (forme, etat a corps de base,
+ * expression). Seuls `idle` et `swirl` portent le visage de repos, donc seuls eux se
+ * declinent par expression — les trois autres etats a corps de base ont un visage releve
+ * sur la video et une seule entree.
+ *
+ * Clef par REFERENCE du tableau de rayons, ce qui est deja la convention du moteur : ses
+ * gardes `radii === this.shape` et `expression === this.expr` reposent sur la meme
+ * stabilite. Un profil inconnu, ou `null`, ne corrige rien — l'API accepte n'importe quel
+ * tableau et le moteur n'a pas a dependre de la prudence de ses appelants.
+ */
+declare function batir(): Map<number[], Map<string, {
+    x: number;
+    y: number;
+}>>;
+/**
+ * Decalage a appliquer aux deux yeux pour cette forme sur cet etat, en unites de rayon
+ * de boule — le moteur le remet a son echelle.
+ *
+ * Vaut zero des que la forme n'est pas au catalogue, ce qui couvre `null` et le cercle :
+ * sur le cercle les deux profils sont le meme, donc la marge est deja celle exigee et la
+ * descente sort au premier tour. La forme relevee sur la video ne bouge donc pas, sans
+ * cas particulier.
+ */
+export declare function decalageDesYeux(radii: number[] | null, state: StateId, expr: string | null): {
+    x: number;
+    y: number;
+};
+/** Pour les tests : de quoi verifier la table sans refaire la geometrie. */
+/** Pour les tests : de quoi chronometrer la construction de la table. */
+export declare const POUR_TESTS: {
+    batir: typeof batir;
+};
+export {};
+//# sourceMappingURL=eyefit.d.ts.map

package/lib/vendor/bloub/eyefit.js

@@ -0,0 +1,393 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+/**
+ * Ou poser le visage sur une forme du personnalisateur.
+ *
+ * Les yeux vivent sur une sphere, et `radiusAtAngle` les recolle au contour reel au
+ * prorata du rayon local. Ce prorata place bien leur CENTRE, mais l'oeil a une taille :
+ * la marge qui lui reste devant le bord est multipliee par le meme facteur, donc une
+ * silhouette etroite dans sa direction le pousse contre le bord jusqu'a ce que le
+ * masque l'ouvre vers l'exterieur. La gelule apparaissait comme une encoche dans le
+ * corps sur `capsule`, `triangle`, `nuage` et `goutte`.
+ *
+ * Ce module resout le probleme UNE FOIS, au chargement, et rend une table de decalages.
+ * Ce choix est l'essentiel du correctif, bien plus que la geometrie qui suit :
+ *
+ * Resolue dans la boucle de rendu, la correction reagit a tout ce qui bouge a soixante
+ * images par seconde — la derive du regard, le pointeur, l'expression en cours de
+ * morph, le bord le plus proche qui change, l'oeil le plus contraint qui change. Sept
+ * variantes ont ete ecrites ainsi et toutes produisaient un artefact de mouvement
+ * visible : tremblement permanent, saut de direction de 26 unites quand le bord de
+ * reference basculait, grossissement brusque quand la taille entrait dans le calcul.
+ * Le defaut n'etait dans aucune de leurs geometries, il etait dans le fait de resoudre
+ * par image.
+ *
+ * Le reste du moteur ne travaille pas comme ca : les poses sont DECLAREES et il ne fait
+ * que les interpoler avec des courbes connues. Un decalage tabule rentre dans ce moule.
+ * Il ne bouge pas quand le regard derive ni quand le pointeur bouge, et sur un changement
+ * de forme ou d'expression il ne fait qu'aller d'une entree de table a l'autre, sur la
+ * courbe de ce morph. Le tremblement devient impossible par construction, au lieu d'etre
+ * repousse : interpoler entre deux constantes est monotone, alors que re-resoudre le
+ * probleme sur un regard en cours d'interpolation ne l'est pas.
+ *
+ * Corollaire agreable : le solveur n'a plus aucune contrainte de continuite, puisqu'il ne
+ * tourne pas pendant l'animation. Il peut donc sonder tout un faisceau de directions et
+ * couvrir le pire cas de la derive du regard, ce qu'une version par image ne pouvait pas
+ * se permettre.
+ *
+ * La table est une constante de module, batie a l'import a partir de donnees pures :
+ * meme nature que le calendrier de clignements de `face.ts`, deterministe et sans etat,
+ * donc sans effet sur la purete de `engine.sample(t)`.
+ */
+import { EXPRESSIONS } from './expressions.js';
+import { eyePoses } from './face.js';
+import { radiusAtAngle, toPoints } from './shape.js';
+import { SHAPES } from './skins.js';
+import { STATES } from './states.js';
+/** Rayon de reference du solveur. Le decalage rendu est en unites de ce rayon. */
+const R = 100;
+/**
+ * Amplitudes maximales de la vie au repos, lues sur `liveliness` : `loopNoise` est
+ * borne a 1 en valeur absolue, donc ces sommes sont des bornes exactes et non des
+ * estimations.
+ *
+ * Il faut les couvrir, sinon la correction est juste sur la pose nominale et fausse une
+ * seconde plus tard : 7 degres de lacet deplacent l'oeil d'une douzaine d'unites sur une
+ * boule de rayon 100. C'est precisement ce qui faisait deborder `capsule` + `effraye`
+ * alors qu'une mesure a un seul instant le declarait bon.
+ */
+const DERIVE_YAW = 5.5 + 1.6;
+const DERIVE_PITCH = 4.2 + 1.3;
+/** Flottement du centre, en unites de rayon de boule. */
+const DERIVE_X = 0.006;
+const DERIVE_Y = 0.007;
+/**
+ * Empreintes des deux yeux d'un visage, posees sur un profil.
+ *
+ * Une gelule est exactement un segment epaissi d'un disque de rayon `r`. Son image par
+ * la matrice tangente est donc un segment epaissi d'une ELLIPSE, et un disque du rayon
+ * de son grand axe la couvre : d'ou la plus grande valeur singuliere. La mesure reste
+ * ainsi conservatrice au sens strict, une marge positive garantissant que la gelule est
+ * dedans.
+ *
+ * Le clignement n'y est pas : un oeil ferme n'a pas besoin qu'on lui fasse de la place.
+ */
+function empreintes(visage, sil, radii) {
+    const out = [];
+    const poses = eyePoses(visage.gaze, R, visage.split);
+    for (let i = 0; i < 2; i++) {
+        const e = poses[i];
+        if (e.depth <= 0.02)
+            continue;
+        const cfg = visage.eyes[i];
+        const phi = ((cfg.tilt ?? 0) * Math.PI) / 180;
+        const cp = Math.cos(phi);
+        const sp = Math.sin(phi);
+        const ax = e.a * cp + e.c * sp;
+        const ay = e.b * cp + e.d * sp;
+        const cx = -e.a * sp + e.c * cp;
+        const cy = -e.b * sp + e.d * cp;
+        const hw = Math.max(cfg.w * R, 0.01) / 2;
+        const hh = Math.max(cfg.h * R, 0.01) / 2;
+        const r = Math.min(hw, hh);
+        // l'axe est celui de la plus grande dimension
+        const long = hh > hw;
+        const demi = long ? hh - r : hw - r;
+        // le prorata du rayon local, exactement comme le fait le moteur
+        const fit = radiusAtAngle(radii, Math.atan2(e.y, e.x) - sil.rot);
+        out.push({
+            x: e.x * fit,
+            y: e.y * fit,
+            ax: (long ? cx : ax) * demi,
+            ay: (long ? cy : ay) * demi,
+            r,
+            m: [ax, ay, cx, cy]
+        });
+    }
+    return out;
+}
+/**
+ * Approche la plus courte entre un contour et un segment : la distance, et le vecteur
+ * qui va du contour vers le segment — le sens qui degage.
+ *
+ * Les deux sortent de la MEME passe. Les calculer separement doublait le seul vrai cout
+ * de ce module, qui est ce balayage.
+ */
+function approche(pts, x0, y0, x1, y1) {
+    const sx = x1 - x0;
+    const sy = y1 - y0;
+    const len2 = sx * sx + sy * sy;
+    let best = Infinity;
+    let vx = 0;
+    let vy = 0;
+    for (let i = 0; i < pts.length; i++) {
+        const p = pts[i];
+        let t = len2 > 0 ? ((p.x - x0) * sx + (p.y - y0) * sy) / len2 : 0;
+        t = t < 0 ? 0 : t > 1 ? 1 : t;
+        const ex = x0 + t * sx - p.x;
+        const ey = y0 + t * sy - p.y;
+        const d2 = ex * ex + ey * ey;
+        if (d2 < best) {
+            best = d2;
+            vx = ex;
+            vy = ey;
+        }
+    }
+    const d = Math.sqrt(best);
+    return { d, ux: d > 1e-9 ? vx / d : 0, uy: d > 1e-9 ? vy / d : 0 };
+}
+/**
+ * Flottement du centre au repos, en unites de viewBox. Il est ajoute au rayon de la
+ * gelule : moins d'une unite, donc l'absorber ainsi coute moins cher que de multiplier les
+ * epreuves par ses quatre coins.
+ */
+const FLOTTEMENT = Math.hypot(DERIVE_X, DERIVE_Y) * R;
+/** Marge de la gelule la plus serree, et le sens qui la degage. */
+function pire(pts, emps, tx, ty) {
+    let marge = Infinity;
+    let ux = 0;
+    let uy = 0;
+    for (const e of emps) {
+        const x = e.x + tx;
+        const y = e.y + ty;
+        const a = approche(pts, x - e.ax, y - e.ay, x + e.ax, y + e.ay);
+        // fonction d'appui de l'ellipse dans la direction de l'approche
+        const [m0, m1, m2, m3] = e.m;
+        const rayon = e.r * Math.hypot(m0 * a.ux + m1 * a.uy, m2 * a.ux + m3 * a.uy) + FLOTTEMENT;
+        if (a.d - rayon < marge) {
+            marge = a.d - rayon;
+            ux = a.ux;
+            uy = a.uy;
+        }
+    }
+    return { marge, ux, uy };
+}
+/**
+ * Directions sondees et pas de la dichotomie. Le produit des deux est le cout de
+ * construction de la table, seul chiffre a surveiller ici.
+ */
+const DIRECTIONS = 12;
+const DICHOTOMIE = 8;
+/**
+ * Le decalage a poser sur les deux yeux pour cette forme, cet etat et cette expression.
+ *
+ * Une TRANSLATION commune aux deux yeux, donc une isometrie : ecart entre les yeux,
+ * tailles et inclinaisons sont conserves au pixel. Le visage est seulement pose un peu
+ * plus bas sur un corps qui n'a pas de place en haut, ce qui est le geste qu'on ferait a
+ * la main. Les variantes qui bornaient chaque oeil separement ecartaient la paire, et
+ * celles qui mettaient le visage a l'echelle rapetissaient les yeux — visiblement.
+ *
+ * La marge visee est celle du profil D'ORIGINE, pas un degagement strict : sur le cercle
+ * l'oeil exterieur frole deja le bord, 17,3 unites pour une boule de rayon 100, et c'est
+ * voulu, c'est ce qui donne le volume. Elle est plafonnee par ce que la forme offre en son
+ * centre, sinon la demande est intenable sur un corps plat.
+ *
+ * RECHERCHE DIRECTIONNELLE et non descente. On cherche la translation de plus petite
+ * norme qui tient, donc on sonde une couronne de directions et on dichotomie la distance
+ * le long de chacune. Une descente de gradient a ete ecrite d'abord et elle ne converge
+ * pas : degager la paire d'un bord la rapproche de l'autre, si bien qu'elle tatonne et ne
+ * fait que garder son meilleur essai — passer ses tours de 40 a 18 suffisait a faire
+ * reapparaitre 34 debordements. Ici le resultat ne depend pas d'une convergence : chaque
+ * direction est resolue exactement, au pas de dichotomie pres.
+ */
+function resous(epreuves) {
+    if (!epreuves.length)
+        return { x: 0, y: 0 };
+    /** La marge la plus serree sur toutes les epreuves, pour une translation donnee. */
+    const marge = (tx, ty) => {
+        let m = Infinity;
+        for (const ep of epreuves)
+            m = Math.min(m, pire(ep.contour, ep.empreintes, tx, ty).marge);
+        return m;
+    };
+    // Marge exigee : la plus serree que le profil d'origine tolere, sur toutes les
+    // epreuves. Puis plafonnee par le plus degage que la forme puisse offrir a la paire,
+    // son centre.
+    let requis = Infinity;
+    for (const ep of epreuves) {
+        requis = Math.min(requis, pire(ep.calContour, ep.reference, 0, 0).marge);
+    }
+    /*
+     * La course doit pouvoir atteindre le centre du corps : `wide` a des gelules de 87
+     * unites de long, et sur un triangle elles ne tiennent que vers le milieu, a une
+     * cinquantaine d'unites de leur place nominale. Une course fixe les laissait dehors.
+     */
+    let mx = 0;
+    let my = 0;
+    const emps = epreuves[0].empreintes;
+    for (const e of emps) {
+        mx -= e.x / emps.length;
+        my -= e.y / emps.length;
+    }
+    const course = Math.max(0.35 * R, Math.hypot(mx, my) * 1.25);
+    // Plafond de la demande : ce que la forme offre en son centre, toujours atteignable.
+    requis = Math.min(requis, marge(mx, my));
+    /*
+     * Deja bon : le cas du cercle, et de toute forme assez large. La gelule doit RENTRER
+     * en plus de n'etre pas plus serree que sur le profil d'origine — sans cette seconde
+     * condition, une forme ou rien ne rentre satisfait la premiere de facon degeneree et
+     * on abandonnait. `wide` a des gelules de 87 unites de long, `notify` de 50 de
+     * diametre : sur un triangle ou une goutte elles debordent quoi qu'on fasse, et il
+     * faut alors viser le moins pire, pas renoncer.
+     */
+    const depart = marge(0, 0);
+    if (depart >= requis && depart >= 0)
+        return { x: 0, y: 0 };
+    const cible = Math.max(requis, 0);
+    let meilleurX = 0;
+    let meilleurY = 0;
+    let meilleureNorme = Infinity;
+    // repli quand rien ne rentre : la translation qui degage le plus, sondee au passage
+    let secoursX = 0;
+    let secoursY = 0;
+    let secours = depart;
+    for (let d = 0; d < DIRECTIONS; d++) {
+        const a = (d / DIRECTIONS) * Math.PI * 2;
+        const ux = Math.cos(a);
+        const uy = Math.sin(a);
+        if (marge(ux * course, uy * course) < cible) {
+            // cette direction ne mene nulle part ; on garde quand meme le meilleur degagement
+            // pas de solution par la, mais peut-etre un meilleur degagement
+            for (const k of [0.3, 0.6, 1]) {
+                const m = marge(ux * course * k, uy * course * k);
+                if (m > secours) {
+                    secours = m;
+                    secoursX = ux * course * k;
+                    secoursY = uy * course * k;
+                }
+            }
+            continue;
+        }
+        // la plus courte distance qui tient, le long de cette direction
+        let bas = 0;
+        let haut = course;
+        for (let i = 0; i < DICHOTOMIE; i++) {
+            const mid = (bas + haut) / 2;
+            if (marge(ux * mid, uy * mid) >= cible)
+                haut = mid;
+            else
+                bas = mid;
+        }
+        if (haut < meilleureNorme) {
+            meilleureNorme = haut;
+            meilleurX = ux * haut;
+            meilleurY = uy * haut;
+        }
+    }
+    const x = meilleureNorme === Infinity ? secoursX : meilleurX;
+    const y = meilleureNorme === Infinity ? secoursY : meilleurY;
+    // rendu en unites de RAYON DE BOULE : le moteur le remet a son echelle
+    return { x: +(x / R).toFixed(6), y: +(y / R).toFixed(6) };
+}
+/**
+ * Le visage a couvrir : celui de l'expression si l'etat l'accepte, le sien sinon.
+ *
+ * UNE entree de table par expression, et non un pire cas commun a toutes. Un pire cas
+ * paraissait plus sur — un decalage constant ne peut pas bouger quand l'expression change
+ * — mais il est intenable : sur une capsule, `neutre` a les yeux hauts et demande a
+ * descendre quand `effraye` les a bas et demande a monter. Aucune translation unique ne
+ * satisfait les deux, et la mesure le confirme (4 debordements de 4,8 unites).
+ *
+ * Une entree par expression n'est pas moins fluide pour autant : le moteur interpole
+ * entre DEUX CONSTANTES, ce qui est monotone par construction. Ce qui tremblait, c'etait
+ * de re-resoudre le probleme sur un regard en cours d'interpolation.
+ */
+function visageDe(def, pose, expr) {
+    if (def.baseFace && expr)
+        return { gaze: expr.gaze, split: expr.split, eyes: expr.eyes };
+    return { gaze: pose.gaze, split: pose.split, eyes: pose.eyes };
+}
+/** Les dates a echantillonner dans un etat : une seule si sa pose ne bouge pas. */
+function dates(def) {
+    /** Tout ce dont le solveur se sert : si rien ne bouge, une date suffit. */
+    const signature = (p) => JSON.stringify([p.gaze, p.split, p.eyes, p.sil.rot, p.sil.cx, p.sil.cy, p.sil.sx, p.sil.sy]);
+    if (signature(def.pose(0)) === signature(def.pose(def.duration)))
+        return [0];
+    const n = 3;
+    return Array.from({ length: n }, (_, i) => (i / (n - 1)) * def.duration);
+}
+/** Le decalage d'une forme sur un etat et une expression, derive comprise. */
+function decalagePour(def, radii, expr) {
+    const epreuves = [];
+    for (const t of dates(def)) {
+        const pose = def.pose(t);
+        const contour = toPoints({ ...pose.sil, radii }, R);
+        const calContour = toPoints(pose.sil, R);
+        const v = visageDe(def, pose, expr);
+        // Les quatre coins de la derive bornent la pose nominale, qui est leur centre : la
+        // tester en plus ne changerait aucune marge et coute une epreuve sur cinq.
+        const coins = [];
+        for (const dy of [-DERIVE_YAW, DERIVE_YAW]) {
+            for (const dp of [-DERIVE_PITCH, DERIVE_PITCH]) {
+                coins.push({
+                    ...v,
+                    gaze: { yaw: v.gaze.yaw + dy, pitch: v.gaze.pitch + dp, roll: v.gaze.roll }
+                });
+            }
+        }
+        for (const c of coins) {
+            epreuves.push({
+                empreintes: empreintes(c, pose.sil, radii),
+                reference: empreintes(c, pose.sil, pose.sil.radii),
+                contour,
+                calContour
+            });
+        }
+    }
+    return resous(epreuves);
+}
+/** Zero, la valeur commune a tout ce qui n'a rien a corriger. */
+const NUL = { x: 0, y: 0 };
+/** Clef d'une entree : l'etat, et l'expression quand l'etat l'accepte. */
+const clef = (state, expr) => `${state}|${expr ?? ''}`;
+/**
+ * Table des decalages, batie a l'import : une entree par (forme, etat a corps de base,
+ * expression). Seuls `idle` et `swirl` portent le visage de repos, donc seuls eux se
+ * declinent par expression — les trois autres etats a corps de base ont un visage releve
+ * sur la video et une seule entree.
+ *
+ * Clef par REFERENCE du tableau de rayons, ce qui est deja la convention du moteur : ses
+ * gardes `radii === this.shape` et `expression === this.expr` reposent sur la meme
+ * stabilite. Un profil inconnu, ou `null`, ne corrige rien — l'API accepte n'importe quel
+ * tableau et le moteur n'a pas a dependre de la prudence de ses appelants.
+ */
+function batir() {
+    return new Map(SHAPES.map((forme) => {
+        const par = new Map();
+        for (const def of STATES) {
+            if (!def.baseBody)
+                continue;
+            const expressions = def.baseFace ? [null, ...EXPRESSIONS] : [null];
+            for (const expr of expressions) {
+                par.set(clef(def.id, expr?.id ?? null), decalagePour(def, forme.radii, expr));
+            }
+        }
+        return [forme.radii, par];
+    }));
+}
+// The theme uses the authored body, not the customiser. Avoid building its
+// fitting catalogue at startup; preserve the solver for a future custom shape.
+let DECALAGES;
+const CATALOG_PROFILES = new Set(SHAPES.map(shape => shape.radii));
+/**
+ * Decalage a appliquer aux deux yeux pour cette forme sur cet etat, en unites de rayon
+ * de boule — le moteur le remet a son echelle.
+ *
+ * Vaut zero des que la forme n'est pas au catalogue, ce qui couvre `null` et le cercle :
+ * sur le cercle les deux profils sont le meme, donc la marge est deja celle exigee et la
+ * descente sort au premier tour. La forme relevee sur la video ne bouge donc pas, sans
+ * cas particulier.
+ */
+export function decalageDesYeux(radii, state, expr) {
+    if (!radii || !CATALOG_PROFILES.has(radii))
+        return NUL;
+    const par = (DECALAGES ??= batir()).get(radii);
+    if (!par)
+        return NUL;
+    // un etat sans visage de repos n'a qu'une entree, quelle que soit l'expression
+    return par.get(clef(state, expr)) ?? par.get(clef(state, null)) ?? NUL;
+}
+/** Pour les tests : de quoi verifier la table sans refaire la geometrie. */
+/** Pour les tests : de quoi chronometrer la construction de la table. */
+export const POUR_TESTS = { batir };
+//# sourceMappingURL=eyefit.js.map