@norbert_bodziony/bloub 0.2.0

package/dist/package/types/bot/math.d.ts

@@ -0,0 +1,21 @@
+export declare const TAU: number;
+export declare const clamp: (v: number, lo?: number, hi?: number) => number;
+export declare const lerp: (a: number, b: number, t: number) => number;
+export type Easing = (t: number) => number;
+/**
+ * Mesure sur la video : les transitions sont des ease-out exponentiels, sans
+ * depassement du corps. Les seuls effets de ressort sont locaux (le pop de la
+ * pastille de notification, l'ouverture des yeux) et sont ecrits directement
+ * dans l'etat concerne.
+ */
+export declare const easings: {
+    easeOutCubic: (t: number) => number;
+    easeInOutCubic: (t: number) => number;
+    easeOutQuint: (t: number) => number;
+};
+/** Bruit 1D periodique : boucle sans couture sur `period`, utile pour la derive du regard. */
+export declare function loopNoise(t: number, period: number, seed?: number): number;
+/** PRNG deterministe (mulberry32) : meme sequence a chaque lecture. */
+export declare function createRng(seed: number): () => number;
+/** Arrondi court : divise par ~2 le poids des chaines de path generees a 60 fps. */
+export declare const r2: (v: number) => number;

package/dist/package/types/bot/profiles.d.ts

@@ -0,0 +1,7 @@
+export declare const PROFILE_SAMPLES = 64;
+export declare const PROFILES: {
+    readonly egg: readonly [0.8369, 0.8424, 0.8497, 0.8585, 0.8674, 0.8775, 0.8878, 0.8983, 0.9089, 0.9185, 0.9288, 0.9374, 0.9445, 0.9504, 0.9543, 0.9559, 0.9555, 0.9519, 0.9466, 0.9389, 0.9302, 0.9193, 0.9085, 0.8969, 0.8852, 0.8734, 0.8625, 0.8513, 0.8411, 0.8325, 0.8243, 0.8179, 0.8137, 0.8112, 0.8102, 0.8128, 0.8178, 0.8262, 0.8374, 0.8518, 0.8702, 0.8922, 0.9169, 0.9446, 0.9741, 1.0023, 1.0267, 1.0433, 1.0481, 1.0393, 1.0216, 0.997, 0.9697, 0.9418, 0.9169, 0.8949, 0.876, 0.8604, 0.849, 0.8394, 0.8337, 0.8314, 0.8305, 0.8326];
+    readonly hexagon: readonly [0.921, 0.9282, 0.9441, 0.9706, 0.9984, 1.0059, 0.9896, 0.9562, 0.929, 0.9124, 0.9047, 0.9058, 0.9157, 0.9349, 0.9642, 0.9873, 0.9882, 0.9665, 0.9336, 0.9105, 0.8968, 0.8918, 0.8955, 0.908, 0.9293, 0.9611, 0.982, 0.9812, 0.959, 0.9282, 0.9089, 0.8978, 0.8964, 0.9026, 0.9189, 0.9439, 0.9778, 0.999, 0.9964, 0.9713, 0.9439, 0.9274, 0.9196, 0.9206, 0.9308, 0.9502, 0.9799, 1.0121, 1.0226, 1.0071, 0.9752, 0.951, 0.9366, 0.9316, 0.9351, 0.9485, 0.9711, 1.0026, 1.0213, 1.0155, 0.9863, 0.9547, 0.9347, 0.9232];
+    readonly triangle: readonly [0.7819, 0.8211, 0.8747, 0.944, 1.0223, 1.096, 1.1401, 1.134, 1.0808, 1.0047, 0.9265, 0.8603, 0.8104, 0.773, 0.745, 0.7273, 0.7151, 0.7118, 0.7148, 0.7245, 0.7427, 0.768, 0.8037, 0.8518, 0.9148, 0.9876, 1.0583, 1.1073, 1.1109, 1.0667, 0.994, 0.9164, 0.8482, 0.7948, 0.7555, 0.7261, 0.7056, 0.6925, 0.6859, 0.6869, 0.6938, 0.7084, 0.7305, 0.7615, 0.804, 0.8595, 0.9311, 1.0092, 1.0791, 1.1171, 1.1054, 1.0501, 0.9779, 0.905, 0.845, 0.799, 0.7656, 0.7413, 0.7258, 0.716, 0.7146, 0.7204, 0.733, 0.7528];
+};
+export type ProfileName = keyof typeof PROFILES;

package/dist/package/types/bot/repere.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Le repere de tout ce que le moteur rend.
+ *
+ * `engine.sample()` sort des coordonnees en unites de viewBox, et ces deux nombres en sont
+ * la definition : sans eux, une sortie du moteur ne veut rien dire. Ils vivaient dans
+ * `BloubBot.vue`, donc hors d'atteinte — un `<script setup>` n'exporte rien — et
+ * `export.ts` en redisait un a la main avec le commentaire qui nommait le probleme.
+ *
+ * Ils sont ici parce que `src/bot/` est ce qui se lit et se consomme du dehors : le
+ * composant Vue est UN client du moteur, pas sa definition.
+ */
+/**
+ * Rayon de la boule au repos, en unites de viewBox. C'est le `scale` que le composant
+ * passe a `BotEngine`.
+ *
+ * Choisi et non mesure : c'est l'unite de travail. Tout le reste du dossier s'exprime en
+ * fractions de ce rayon, ce qui rend les mesures relevees sur la video independantes de la
+ * taille d'affichage.
+ */
+export declare const RAYON = 100;
+/**
+ * Demi-cote du viewBox affiche. La marge au-dela du rayon loge les anneaux.
+ *
+ * Ce n'est pas une valeur libre : les anneaux de l'orbite et le swoosh de la comete montent
+ * a 1,4 fois le rayon, soit 140. Rien ne les borne au runtime — c'est le reglage a la main
+ * des tableaux `RINGS` et `SWOOSH` (`decor.ts`) qui les tient sous 158, et un test le
+ * verrouille.
+ */
+export declare const DEMI_VIEWBOX = 158;

package/dist/package/types/bot/shape.d.ts

@@ -0,0 +1,79 @@
+import { type ProfileName } from './profiles.js';
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Une silhouette = un profil radial r(theta) plus une pose.
+ *
+ * Tout passe par des profils echantillonnes au MEME nombre d'angles : deux
+ * formes quelconques ont donc des points qui se correspondent un a un, et le
+ * morphing se reduit a une interpolation lineaire des rayons. C'est ce qui
+ * rend les transitions propres sans librairie de morphing de path.
+ */
+export interface Silhouette {
+    radii: number[];
+    /** rotation du profil, en radians */
+    rot: number;
+    /** decalage du centre, en unites de rayon de boule */
+    cx: number;
+    cy: number;
+    /** squash & stretch, applique en repere ecran (apres rotation) */
+    sx: number;
+    sy: number;
+}
+export declare function silhouette(name: ProfileName, pose?: Partial<Silhouette>): Silhouette;
+/** Cercle parfait : sert de base neutre (point, bulle, cible de fondu). */
+export declare function circle(radius: number, pose?: Partial<Silhouette>): Silhouette;
+/** Interpolation de deux silhouettes. `out` est reutilise pour eviter d'allouer a 60 fps. */
+export declare function blend(a: Silhouette, b: Silhouette, t: number, out?: Silhouette): Silhouette;
+/** Projette la silhouette en points ecran. `scale` = rayon de la boule en unites de viewBox. */
+export declare function toPoints(s: Silhouette, scale: number, out?: Point[]): Point[];
+/**
+ * Polyligne fermee -> cubiques Catmull-Rom.
+ *
+ * Avec 64 points les tangentes centrees suffisent largement : le contour est
+ * lisse au pixel pres meme affiche en 600 px, et la chaine reste courte.
+ */
+export declare function closedPath(pts: Point[], tension?: number): string;
+/**
+ * Polygone quelconque -> profil radial, par lancer de rayon depuis `center`.
+ *
+ * Sert a fabriquer les formes qui ne s'expriment pas naturellement en r(theta)
+ * (la barre tronconique du "!"). Calcule une seule fois au chargement, jamais
+ * dans la boucle de rendu.
+ */
+export declare function profileFromPolygon(poly: Point[], cx: number, cy: number): number[];
+/** Enveloppe convexe de deux cercles : la barre tronconique du "!" vertical. */
+export declare function hullOfCircles(x1: number, y1: number, r1: number, x2: number, y2: number, r2v: number, steps?: number): Point[];
+/**
+ * Rayon du profil dans une direction quelconque, par interpolation entre les
+ * deux echantillons voisins.
+ *
+ * Sert a recaler ce qui est pose "sur" le corps (les yeux, la pastille de
+ * notification) quand la silhouette n'est plus un cercle : sans ca, un oeil
+ * place a 0.62 rayon sort d'une forme dont le bord est a 0.55 dans cette
+ * direction, et le masque le rogne.
+ */
+export declare function radiusAtAngle(radii: number[], angle: number): number;
+/**
+ * Superellipse : |x/sx|^n + |y/sy|^n = 1.
+ * n = 2 donne une ellipse, n ~ 4 le squircle du personnalisateur.
+ */
+export declare function superellipseProfile(n: number, sx?: number, sy?: number): number[];
+/**
+ * Profil radial de l'UNION de disques : r(theta) = la plus lointaine des
+ * intersections rayon/cercle. Exact tant que l'origine est dans l'union — c'est
+ * ce qui donne les bosses du nuage sans booleen de path.
+ */
+export declare function unionOfCirclesProfile(circles: Array<{
+    x: number;
+    y: number;
+    r: number;
+}>): number[];
+/** Polygone regulier a coins arrondis, inscrit dans `radius`. */
+export declare function regularPolygonProfile(sides: number, radius: number, rc: number, rotationDeg?: number): number[];
+/** Polyligne fermee exacte : garde les segments droits (contrairement a closedPath). */
+export declare function polyPath(pts: Point[], scale?: number): string;
+/** Capsule (stade) centree sur l'origine : la forme exacte des yeux du bot. */
+export declare function capsulePath(w: number, h: number): string;

package/dist/package/types/bot/skins.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Formes et couleurs proposees par le personnalisateur du bot.
+ *
+ * A la difference des silhouettes d'animation (`profiles.ts`), celles-ci ne sont
+ * PAS relevees sur la video : elles sont construites analytiquement d'apres la
+ * grille du personnalisateur d'origine. Deux sources distinctes, donc, et c'est
+ * volontaire — les etats animes doivent rester fideles a la video, les formes de
+ * base sont un choix d'utilisateur.
+ */
+/**
+ * Les identifiants sont enumeres plutot que deduits du tableau : c'est ce qui
+ * permet a la couche i18n de verifier A LA COMPILATION que chaque forme a bien
+ * sa traduction dans les trois langues (`t(\`shapes.${id}\`)` ne compile que si
+ * la cle existe). Un `as const` sur le tableau aurait le meme effet mais
+ * rendrait `radii` en lecture seule, alors que le moteur le passe tel quel.
+ */
+export type ShapeId = 'cercle' | 'galet' | 'squircle' | 'capsule' | 'triangle' | 'hexagone' | 'nuage' | 'goutte';
+export interface BotShape {
+    id: ShapeId;
+    radii: number[];
+}
+export declare const SHAPES: BotShape[];
+export declare const SHAPE_BY_ID: Map<string, BotShape>;
+export declare const DEFAULT_SHAPE = "cercle";
+export type ColorId = 'encre' | 'creme' | 'brun' | 'rouge' | 'orange' | 'ambre' | 'vert' | 'turquoise' | 'bleu' | 'violet' | 'rose' | 'gris';
+export interface BotColor {
+    id: ColorId;
+    hex: string;
+}
+/** Palette du personnalisateur d'origine. */
+export declare const COLORS: BotColor[];
+export declare const COLOR_BY_ID: Map<string, BotColor>;
+export declare const DEFAULT_COLOR = "encre";
+/** Melange deux couleurs hex. Sert a la brume de profondeur des particules. */
+export declare function mixHex(from: string, to: string, t: number): string;

package/dist/package/types/bot/states.d.ts

@@ -0,0 +1,86 @@
+import { type ArcSpec, type DotRender } from './decor.js';
+import { type HeadGaze } from './face.js';
+import { type Silhouette } from './shape.js';
+export interface EyeCfg {
+    /** largeur locale (axe court de la gelule), en unites de rayon de boule */
+    w: number;
+    /** hauteur locale (axe long) */
+    h: number;
+    /** 1 = ouvert, 0 = ferme */
+    open: number;
+    /**
+     * Inclinaison propre de la gelule, en degres, positif = le haut part a
+     * droite. Appliquee APRES le repere tangent de la sphere. Sans elle, les deux
+     * yeux penchent forcement du meme cote (le roulis de tete) et la colere comme
+     * la tristesse, qui demandent des inclinaisons en miroir, sont hors de portee.
+     */
+    tilt?: number;
+}
+export interface Pose {
+    /** silhouette du corps, en unites de rayon de boule */
+    sil: Silhouette;
+    /** decalage global du corps ET des yeux */
+    offX: number;
+    offY: number;
+    gaze: HeadGaze;
+    /** demi-ecart des yeux sur la sphere, en degres */
+    split: number;
+    /** [oeil interieur, oeil exterieur] */
+    eyes: [EyeCfg, EyeCfg];
+    /** opacite des yeux : sert aux etats sans visage */
+    eyeAlpha: number;
+    bodyAlpha: number;
+    dots: DotRender[];
+    arcs: ArcSpec[];
+    notif: {
+        x: number;
+        y: number;
+        r: number;
+        notch: number;
+    } | null;
+    /** true = le decor passe derriere le corps (particules de l'eclatement) */
+    dotsBehind: boolean;
+}
+export type StateId = 'idle' | 'thinking' | 'wink' | 'wide' | 'alert' | 'notify' | 'exclaim' | 'sleep' | 'egg' | 'hexagon' | 'play' | 'orbit' | 'burst' | 'comet'
+/** transition d'interface, pas une animation du catalogue : hors `SEQUENCE` */
+ | 'swirl';
+export interface StateDef {
+    id: StateId;
+    /** duree de maintien quand la sequence complete est jouee */
+    duration: number;
+    /**
+     * duree en dessous de laquelle l'animation est coupee avant d'aboutir : le
+     * "!" ne revient pas, le corps reste eclate. Elle se lit dans les constantes
+     * de `pose` ci-dessous, elle ne se choisit pas. Absente = l'etat ignore le
+     * temps ou boucle, n'importe quelle duree lui va (voir `MIN_BLOCK`).
+     */
+    minDuration?: number;
+    /** duree du morph d'entree */
+    morph: number;
+    /** true = l'entree est masquee par un clignement, comme dans la video */
+    blinkIn: boolean;
+    /**
+     * true = le corps est la silhouette "au repos", donc remplacable par la forme
+     * choisie dans le personnalisateur. Les etats qui dessinent leur propre forme
+     * (le "!", les points, l'oeuf, le triangle...) valent false : c'est cette forme
+     * la qui EST l'animation.
+     */
+    baseBody: boolean;
+    /**
+     * true = l'etat porte le visage "au repos", donc remplacable par l'expression
+     * choisie. Seul `idle` : les autres etats a visage ont une expression relevee
+     * sur la video, c'est precisement ce qu'on reproduit.
+     */
+    baseFace: boolean;
+    pose(local: number): Pose;
+}
+export declare const STATES: StateDef[];
+export declare const STATE_BY_ID: Map<StateId, StateDef>;
+/** Ordre de lecture de la sequence complete, calque sur la video de reference. */
+/**
+ * Date, en temps local, ou chaque etat est le plus lisible : c'est la pose que
+ * montrent les vignettes et la planche. Rendu deterministe, donc comparable
+ * d'une execution a l'autre. Le type force a couvrir tout nouvel etat.
+ */
+export declare const POSES: Record<StateId, number>;
+export declare const SEQUENCE: StateId[];

package/dist/package/types/components/BloubBot.d.ts

@@ -0,0 +1,33 @@
+import { type JSX } from 'solid-js';
+import { type GazeScript } from '../ui/gaze.js';
+import { type Block } from '../bot/cycles.js';
+import { type StateId } from '../bot/states.js';
+export interface BloubBotRef {
+    readonly svg: SVGSVGElement;
+    seek(index: number, offset?: number): void;
+    renderAt(seconds: number): void;
+}
+export interface BloubBotProps {
+    size?: number;
+    shape?: string;
+    color?: string;
+    expression?: string;
+    paper?: string;
+    ariaLabel?: string;
+    frozenAt?: number;
+    cycle?: Block[];
+    follow?: boolean;
+    gaze?: GazeScript | null;
+    block?: number;
+    state?: StateId;
+    playing?: boolean;
+    elapsed?: number;
+    onBlockChange?: (value: number) => void;
+    onStateChange?: (value: StateId) => void;
+    onPlayingChange?: (value: boolean) => void;
+    onElapsedChange?: (value: number) => void;
+    ref?: (value: BloubBotRef) => void;
+    class?: string;
+    style?: JSX.CSSProperties | string;
+}
+export default function BloubBot(rawProps: BloubBotProps): JSX.Element;

package/dist/package/types/index.d.ts

@@ -0,0 +1,10 @@
+export { default as BloubBot } from './components/BloubBot.js';
+export type { BloubBotProps, BloubBotRef } from './components/BloubBot.js';
+export * from './bot/engine.js';
+export * from './bot/cycles.js';
+export * from './bot/states.js';
+export * from './bot/skins.js';
+export * from './bot/expressions.js';
+export { RAYON, DEMI_VIEWBOX } from './bot/repere.js';
+export type { GazeScript, Aim } from './ui/gaze.js';
+export { lookTarget, tourLook, TOUR_TIME, TURN_TIME } from './ui/gaze.js';

package/dist/package/types/ui/gaze.d.ts

@@ -0,0 +1,130 @@
+import type { Look } from '../bot/engine.js';
+import type { ExpressionId } from '../bot/expressions.js';
+/**
+ * Ou le bot regarde quand il suit le curseur. Pur, comme `src/ui/timeline.ts` :
+ * la position du pointeur entre en coordonnees deja normalisees, donc la regle
+ * se teste sans DOM — et elle a besoin de l'etre, parce que deux signes s'y
+ * trompent facilement.
+ */
+/**
+ * Angles en degres d'orientation de tete. CHOISIS, pas releves : la video de
+ * reference ne montre aucun suivi de curseur. Assez amples pour se distinguer de
+ * la derive au repos (±7deg de lacet, ±5,5 de tangage), assez retenus pour
+ * qu'aucun oeil ne parte derriere le limbe de la sphere.
+ */
+export declare const YAW_MAX = 16;
+export declare const PITCH_MAX = 13;
+/**
+ * Hauteur a laquelle le regard se tient, curseur au centre. CHOISIE : legerement
+ * au-dessus de l'equateur, ce qui donne un bot attentif plutot qu'absent.
+ *
+ * C'est une valeur ABSOLUE, et c'est tout le point : en relatif, la hauteur des
+ * yeux suivait celle de chaque expression, et comme « neutre » regarde a
+ * +28,6deg quand les humeurs sont entre -9 et +9, les yeux tombaient d'un coup
+ * au premier changement d'humeur.
+ */
+export declare const PITCH = 10;
+/**
+ * Direction ou la tete se pose dans la vue des reglages : le bot cesse de regarder en haut a
+ * droite (sa pose de repos) pour regarder a GAUCHE, du cote du panneau.
+ *
+ * Ce n'est pas un miroir de l'image : les yeux font vraiment le tour de la
+ * sphere, donc ils gardent leur inclinaison en `\\` et leur compression de
+ * profondeur. Retourner l'image les aurait couches en `//`.
+ */
+export declare const TURN = 26;
+/**
+ * Tour complet parcouru EN CHEMIN : les yeux ne glissent pas en travers du
+ * visage, ils font le tour de la boule avant d'arriver.
+ *
+ * C'est gratuit parce que les yeux vivent sur une sphere : passe 90deg de lacet
+ * ils franchissent le limbe, le moteur les retire de l'image, puis ils
+ * reapparaissent de l'autre cote. Le tourbillon n'est donc pas un effet pose
+ * par-dessus, c'est la meme projection orthographique poussee d'un tour.
+ *
+ * Et surtout : il ATTERRIT JUSTE par construction, `-360deg` etant le meme angle
+ * que `0`. C'est ce qui le distingue d'une pose de regard ecrite dans un etat,
+ * qui laisse les yeux la ou sa courbe se termine.
+ */
+export declare const SPIN = 360;
+/**
+ * Duree du tour. Un peu plus courte que le bloc d'entree (`swirl`) : les yeux
+ * doivent etre poses a gauche avant que les anneaux ne s'effacent.
+ */
+export declare const TURN_TIME = 1.1;
+/**
+ * Humeurs que le bot traverse pendant qu'il suit le curseur.
+ *
+ * Toutes ont un ROULIS NUL, et c'est le critere de selection. Le lacet et le
+ * tangage sont neutralises par le suivi (ils sont absolus), mais pas le roulis —
+ * il fait pencher la tete, donc il deplace les yeux verticalement, et une humeur
+ * a -15deg suivie d'une a +8 les fait sauter. Ce qui reste pour distinguer les
+ * humeurs, c'est la FORME des yeux : ronds, plisses, ecarquilles, aplatis. C'est
+ * largement suffisant, et c'est ce qui se lit.
+ *
+ * Ce n'est donc pas une liste de gouts : y ajouter « curieux » (roulis -15deg)
+ * ramenerait le saut.
+ */
+export declare const HUMEURS: readonly ExpressionId[];
+/**
+ * Un regard SCRIPTE : evalue a chaque image avec le temps ecoule depuis le debut
+ * de l'arrivee, en secondes. Le script porte donc sa propre horloge et peut
+ * enchainer plusieurs mouvements — le composant ne fait que l'evaluer et n'a
+ * aucune duree a connaitre.
+ *
+ * REGLE, et c'est elle qui rend un script sans entretien : il doit FINIR a
+ * `mix: 0`, ou la pose de l'etat commande seule. Il n'y a alors jamais rien a
+ * relacher, et ce relachement — qui se verrait sous la forme d'un dernier
+ * glissement des yeux, juste quand tout devrait etre pose — n'existe pas.
+ *
+ * Le type reste general alors qu'il n'y a qu'un script aujourd'hui : quatre ont
+ * ete ecrits et compares cote a cote avant d'en garder un, et c'est cette forme
+ * qui a permis de les essayer sans toucher au moteur.
+ */
+export type GazeScript = (t: number) => Look;
+/**
+ * « Le tour » : la boule a l'air de tourner sur elle-meme.
+ *
+ * `mix` reste a ZERO du debut a la fin : aucune direction n'est imposee, seul
+ * `spin` fond, ce qui fait passer les yeux DERRIERE la boule avant de les
+ * ramener exactement la ou l'expression choisie les met.
+ *
+ * Ease-in-OUT et non l'ease-out exponentiel du reste du projet : ce n'est pas une
+ * valeur qui se pose, c'est un objet qui tourne. En ease-out, les deux tiers du
+ * tour etaient avales en 0,3 s — un a-coup, pas une rotation.
+ *
+ * Il est VIF au passage du limbe — 20 px entre deux images sur une boule de 100
+ * de rayon — et ce n'est pas un defaut de reglage : pres du bord, un petit angle
+ * devient un grand deplacement a l'ecran, et l'oeil disparait puis reparait de
+ * l'autre cote. Ralentir n'y change rien, c'est la trajectoire qui veut ca, et
+ * c'est justement ce qui fait l'effet. Ne pas chercher a l'adoucir.
+ *
+ * Corollaire indispensable : ce tour ne se joue que sur un CERCLE. Les yeux sont
+ * recolles au contour reel (`radiusAtAngle`), donc sur une forme non circulaire
+ * ils suivent le profil en tournant et sautillent. Voir `forme` dans `App.vue`.
+ */
+export declare const TOUR_TIME = 1.5;
+export declare const tourLook: GazeScript;
+export interface Aim {
+    /** ecart horizontal du pointeur au centre du bot, -1 a 1 (droite positive) */
+    nx: number;
+    /** ecart vertical, -1 a 1, dans le sens de l'ecran (bas positif) */
+    ny: number;
+    /** avancement de l'arrivee, 0 a 1 */
+    tour: number;
+    /** false = aucun pointeur connu : la tete reste tournee, mais elle revit */
+    pointer: boolean;
+}
+/**
+ * Cible de regard.
+ *
+ * `tour` mene tout : il fait monter l'emprise sur la pose (`mix`) et fondre le
+ * tour parcouru (`spin`) en meme temps. A 0 la pose de l'etat commande seule ; a
+ * 1 la tete est posee a gauche et suit le curseur.
+ *
+ * Rien ici ne compense l'expression affichee : c'est le moteur qui melange,
+ * parce que lui seul connait la pose a l'instant t. Le faire ici obligerait a
+ * lire le lacet d'ARRIVEE de l'expression pendant que le moteur, lui, morphe
+ * encore — et les yeux sautaient a chaque changement d'humeur.
+ */
+export declare function lookTarget({ nx, ny, tour, pointer }: Aim): Look;

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@norbert_bodziony/bloub",
+  "private": false,
+  "version": "0.2.0",
+  "type": "module",
+  "description": "SVG recreation of the x.ai bot avatar. One shape morphing through 14 states, measured off the reference video frame by frame.",
+  "license": "MIT",
+  "author": "Jérémy Perret",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NorbertBodziony/bloub.git"
+  },
+  "homepage": "https://bloub-app.pages.dev",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "svg",
+    "animation",
+    "avatar",
+    "solid-js",
+    "morphing"
+  ],
+  "packageManager": "bun@1.4.0",
+  "files": [
+    "dist/package/index.js",
+    "dist/package/server.js",
+    "dist/package/types"
+  ],
+  "types": "./dist/package/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/package/types/index.d.ts",
+      "browser": "./dist/package/index.js",
+      "import": "./dist/package/server.js",
+      "default": "./dist/package/server.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "dev": "vite",
+    "typecheck": "tsc --noEmit",
+    "build": "bun run typecheck && bun run build:app && bun run build:package",
+    "build:app": "vite build",
+    "build:package": "vite build --config vite.lib.config.ts && vite build --config vite.lib.ssr.config.ts && tsc -p tsconfig.lib.json",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:package": "bun run build:package && tsc -p tsconfig.package-test.json && bun tests/package-runtime.ts",
+    "test:tarball": "bun tools/test-package-tarball.mjs",
+    "pack:check": "bun run test:package && bun run test:tarball",
+    "prepublishOnly": "bun run test && bun run typecheck && bun run pack:check"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.9.15"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^26.0.0",
+    "happy-dom": "^20.11.2",
+    "mediabunny": "^1.54.0",
+    "solid-js": "^1.9.15",
+    "tailwindcss": "^4.3.3",
+    "typescript": "^5.9.3",
+    "vite": "^8.2.1",
+    "vite-plugin-solid": "^2.11.14",
+    "vitest": "^4.1.10"
+  }
+}