wissive 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,695 @@
+/** Todos los estados, sin repetidos, en orden de grupo */
+export declare const ALL_STATES: InteractionState[];
+
+/**
+ * Todo estado que un emoji podría "visitar" al deambular — es decir, todos
+ * menos los de Interacción (idle/near/hover/click no se "visitan", los
+ * decide la interacción real del usuario). A diferencia de AUTONOMOUS_STATES,
+ * esto SÍ incluye Ciclo de producto/Morfos de agente: sirve como el universo
+ * de opciones cuando alguien elige el banco a mano (p.ej. el picker del
+ * emoji personalizado) — ahí ya no es la librería "mintiendo" por su cuenta,
+ * es una elección explícita del usuario para su propio emoji.
+ */
+export declare const ALL_WANDERABLE_STATES: InteractionState[];
+
+declare class AnimationLoop {
+    private callbacks;
+    private handle;
+    private lastTime;
+    add(cb: FrameCallback): void;
+    remove(cb: FrameCallback): void;
+    get size(): number;
+    private tick;
+}
+
+/**
+ * Aplica la animación idle correspondiente al perfil de movimiento.
+ * `intensity` reduce la amplitud sin apagarla — los estados near/hover/click
+ * siguen respirando en vez de quedarse congelados.
+ */
+export declare function applyIdleMotion(motionType: MotionType, p: FaceParameters, t: number, speed: number, amp: number, intensity?: number): void;
+
+/**
+ * Aplica el movimiento propio de un estado.
+ * Devuelve `false` si el estado no tiene firma propia — en ese caso el llamador
+ * debe recurrir a la animación de personalidad del emoji.
+ */
+export declare function applyStateMotion(state: string, p: FaceParameters, t: number, speed: number, amp: number): boolean;
+
+export declare function attachEventListeners(element: HTMLElement, callbacks: EventCallbacks, nearRadius?: number): () => void;
+
+/**
+ * Estados que el emoji puede visitar por su cuenta en reposo (deambular
+ * autónomo) — solo "Reacciones": son expresión pura, sin significado de
+ * aplicación. Deliberadamente NO incluye "Ciclo de producto" ni "Morfos de
+ * agente" (uploading, thinking, orbit…): esos los debe fijar la app anfitriona
+ * porque comunican un estado real, y mostrarlos al azar sería mentir.
+ */
+export declare const AUTONOMOUS_STATES: InteractionState[];
+
+/**
+ * Interpola suavemente entre dos colores HEX
+ */
+export declare function blendColors(colorA: string, colorB: string, factor: number): string;
+
+/**
+ * Construye una definición de emoji personalizado: base neutra (Cota),
+ * silueta a elección (circle por default), con ojos/boca/animación tomados
+ * opcionalmente de cualquier otro emoji del catálogo.
+ */
+export declare function buildCustomEmoji(name: string, options?: CustomEmojiOptions): EmojiDefinition;
+
+export declare function buildFace(silhouette: SilhouetteType, baseColor: string, params: FaceParameters, size: number, renderOptions?: RenderOptions, time?: number): string;
+
+/**
+ * Verifica si el ratio de contraste cumple con los criterios mínimos de WCAG (3:1 para componentes gráficos).
+ */
+export declare function checkContrast(bgColor: string, fgColor: string, minRatio?: number): {
+    ratio: number;
+    passes: boolean;
+};
+
+export declare type CoreInteractionState = 'idle' | 'near' | 'hover' | 'click';
+
+/**
+ * Construye (o reconstruye) un emoji personalizado, lo persiste en localStorage
+ * y lo registra en LIB para poder usarlo directamente con createEmoji(name, ...).
+ */
+export declare function createCustomEmoji(name: string, options?: CustomEmojiOptions): EmojiDefinition;
+
+export declare function createEmoji(name: string, options: WissiveOptions): WissiveInstance;
+
+export declare function createEmojiGroup(instances?: WissiveInstance[], options?: EmojiGroupOptions): EmojiGroup;
+
+export declare function createMultiSpring<T extends Record<string, number>>(initialValues: T, config?: Partial<SpringConfig>): MultiSpring<T>;
+
+/**
+ * Encadena expresiones en una línea de tiempo.
+ *
+ * No toca resortes ni DOM: recibe `resolveStep` (paso → parámetros) y
+ * `applyStep` (parámetros → destino), de modo que la interpolación entre pasos
+ * la sigue haciendo el motor de resortes que ya existe.
+ */
+export declare function createSequencePlayer(hooks: {
+    resolveStep: (step: SequenceStep) => Partial<FaceParameters>;
+    applyStep: (params: Partial<FaceParameters>) => void;
+}): SequencePlayer;
+
+export declare type CueSoundType = 'chime' | 'sparkle' | 'droplet' | 'bloom' | 'whisper' | 'tick' | 'press' | 'release' | 'toggle' | 'success' | 'error' | 'page' | 'loading' | 'ready' | 'pulse' | 'scan' | 'arrival';
+
+export declare interface CustomEmojiOptions {
+    /** Color base, ej. '#F2A9B8' */
+    baseColor?: string;
+    /** Silueta base — cualquiera de las 22 que soporta getSilhouettePath() en
+     *  render/svg.ts (las 14 de los personajes del catálogo + 8 sin usar
+     *  todavía por ninguno). Default 'circle'. */
+    silhouette?: SilhouetteType;
+    /** Nombre de un emoji del catálogo (LIB) del que tomar el tipo/tamaño de ojos */
+    eyesFrom?: string;
+    /** Nombre de un emoji del catálogo del que tomar el tipo/curva/ancho de boca */
+    mouthFrom?: string;
+    /**
+     * Tipo de ojo crudo (ver el switch(eyeType) en render/svg.ts, 0-23) — para
+     * los tipos nuevos que ningún personaje del catálogo usa todavía (estrella,
+     * reojo, guiño). Gana sobre `eyesFrom` si se especifican los dos.
+     */
+    eyeTypeOverride?: number;
+    /** Tipo de boca crudo (0-16), mismo caso que eyeTypeOverride. Gana sobre `mouthFrom`. */
+    mouthTypeOverride?: number;
+    /** Nombre de un emoji del catálogo del que tomar la animación idle (motion) */
+    motionFrom?: string;
+    /** Nombre de un emoji del catálogo del que tomar el estilo de partículas (burst) */
+    particlesFrom?: string;
+    /** Nombre de un emoji del catálogo del que tomar el set de sonidos */
+    soundFrom?: string;
+    /**
+     * Banco de estados que este emoji puede realizar por su cuenta en reposo
+     * (deambular autónomo) — cualquier subconjunto de ALL_WANDERABLE_STATES
+     * (todos menos idle/near/hover/click). Elegido a mano por quien arma el
+     * emoji, así que aquí sí se permiten los de "Ciclo de producto"/"Morfos
+     * de agente" — es una decisión explícita, no la librería inventando.
+     * Sin especificar, usa el banco genérico (AUTONOMOUS_STATES, 16 "Reacciones").
+     */
+    stateBank?: InteractionState[];
+}
+
+export declare const DEFAULT_STEP_MS = 600;
+
+export declare class DragPhysics {
+    private posX;
+    private posY;
+    private velX;
+    private velY;
+    private dragging;
+    private startPointerX;
+    private startPointerY;
+    private lastPointerX;
+    private lastPointerY;
+    private lastPointerTime;
+    private velocitySamples;
+    private readonly MAX_SAMPLES;
+    private readonly springK;
+    private readonly springD;
+    private readonly tossDecay;
+    private readonly maxStretch;
+    private animating;
+    private rafId;
+    private onUpdate;
+    private onDragStart?;
+    private onDragEnd?;
+    private el;
+    constructor(element: HTMLElement, onUpdate: (state: DragPhysicsState) => void, options?: {
+        onDragStart?: () => void;
+        onDragEnd?: () => void;
+    });
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handleTouchDown;
+    private handleTouchMove;
+    private handleTouchUp;
+    private startDrag;
+    private moveDrag;
+    private endDrag;
+    private startPhysicsLoop;
+    private physicsTick;
+    private emitState;
+    destroy(): void;
+}
+
+/**
+ * Drag & Toss physics with elastic Squash & Stretch deformation.
+ *
+ * The user can grab an emoji and drag it around. While dragging, the body
+ * stretches in the direction of movement. When released, it flies away with
+ * the accumulated velocity and bounces back to its origin like jelly.
+ */
+export declare interface DragPhysicsState {
+    /** Current visual offset from origin (px) */
+    offsetX: number;
+    offsetY: number;
+    /** Squash & Stretch deformation for CSS transform */
+    scaleX: number;
+    scaleY: number;
+    /** Rotation from drag inertia (rad) */
+    rotation: number;
+    /** true while the user is actively dragging */
+    isDragging: boolean;
+}
+
+export declare const EMOJI_BRIX: EmojiDefinition;
+
+export declare const EMOJI_COTA: EmojiDefinition;
+
+export declare const EMOJI_DOZY: EmojiDefinition;
+
+export declare const EMOJI_FIDGE: EmojiDefinition;
+
+export declare const EMOJI_KNOT: EmojiDefinition;
+
+export declare const EMOJI_LUMO: EmojiDefinition;
+
+export declare const EMOJI_MOCHI: EmojiDefinition;
+
+export declare const EMOJI_NIMA: EmojiDefinition;
+
+export declare const EMOJI_PIP: EmojiDefinition;
+
+export declare const EMOJI_SNUG: EmojiDefinition;
+
+export declare const EMOJI_SURI: EmojiDefinition;
+
+export declare const EMOJI_VOID: EmojiDefinition;
+
+export declare const EMOJI_WILT: EmojiDefinition;
+
+export declare const EMOJI_ZUMI: EmojiDefinition;
+
+export declare interface EmojiDefinition {
+    name: string;
+    emotion: string;
+    baseColor: string;
+    silhouette: SilhouetteType;
+    motion: MotionProfile;
+    expressions: EmojiExpressionPool;
+    /** Emoción cuyo set de partículas usar en bursts (por defecto: `emotion`) */
+    particleEmotion?: string;
+    /** Emoción cuyo set de sonidos usar (por defecto: `emotion`) */
+    soundEmotion?: string;
+    /**
+     * Banco de estados que este emoji puede visitar por su cuenta en reposo
+     * (deambular autónomo). Por defecto: `AUTONOMOUS_STATES` (todo el grupo
+     * "Reacciones"). Lo usan sobre todo los emojis personalizados, para elegir
+     * su propio repertorio en vez del genérico.
+     */
+    autonomousStatePool?: InteractionState[];
+}
+
+export declare type EmojiExpressionPool = Record<string, FaceParameters[]>;
+
+export declare class EmojiGroup {
+    private instances;
+    private options;
+    private connectedPairs;
+    private isRunning;
+    constructor(instances?: WissiveInstance[], options?: EmojiGroupOptions);
+    add(instance: WissiveInstance): void;
+    remove(instance: WissiveInstance): void;
+    start(): void;
+    stop(): void;
+    private getPairKey;
+    private update;
+    /**
+     * Reacción de sinergia entre dos emojis según sus emociones
+     */
+    private triggerSynergy;
+    destroy(): void;
+}
+
+export declare interface EmojiGroupOptions {
+    proximityThreshold?: number;
+    enableGazeSync?: boolean;
+    enableSynergies?: boolean;
+}
+
+export declare interface EmojiTheme {
+    baseColor: string;
+    strokeColor?: string;
+    glowColor?: string;
+}
+
+export declare interface EventCallbacks {
+    onHoverStart: () => void;
+    onHoverEnd: () => void;
+    onClickStart: () => void;
+    onClickEnd: () => void;
+    onNearChange: (isNear: boolean) => void;
+    onGazeMove?: (gazeX: number, gazeY: number) => void;
+}
+
+export declare interface FaceParameters {
+    [key: string]: number;
+    /** Eye scale/openness [0..1] */
+    eyeOpen: number;
+    /** Overall eye size multiplier [0.5..2.0] */
+    eyeScale: number;
+    /**
+     * Eye type selector, 0-31 — ver el switch(eyeType) en render/svg.ts, es
+     * la fuente de verdad real (este comentario se desactualizó una vez, no
+     * confiar en él a ciegas si volvés a tocar el switch).
+     * [0: dot, 1: happy-arc ^, 2: wedge-squint >, 3/4: diagonal-wink-mirrored,
+     * 5: pupil-in-white, 6: heart, 7: X, 8: double-line squint, 9: eyebrows-only,
+     * 10/11: asymmetric-wink-oval, 12: cat-pupil, 13: big-pupil, 14: closed-serene-arc,
+     * 15: droopy-lid, 16: vertical-line (crying), 17: angry-diagonal-brow,
+     * 18: spiral (Knot), 19: sleepy-ring, 20: hollow-ring, 21: star,
+     * 22: side-eye, 23: single-wink, 24: anime-highlight, 25: sleepy-lash,
+     * 26: googly, 27: waterfall-cry ⊓⊓, 28: blank-stare, 29: worried-brow,
+     * 30: angry-zigzag-brow, 31: content-ring]
+     */
+    eyeType: number;
+    /** Horizontal distance between both eyes (default 32) */
+    eyeGap: number;
+    /** Vertical position of the eye line (default 45) */
+    eyeY: number;
+    /** Vertical position of the mouth (default 63) */
+    mouthY: number;
+    /** Mouth curvature [-1..1] where 1 is happy curve, -1 is sad curve */
+    mouthCurve: number;
+    /** Mouth width relative [0.5..1.5] */
+    mouthWidth: number;
+    /** Mouth opening vertical factor [0..1] for open mouth/surprised */
+    mouthOpen: number;
+    /**
+     * Mouth type selector, 0-24 — ver el switch(mouthType) en render/svg.ts.
+     * [0: curve/line (sigue mouthCurve), 1: open-oval, 2: zigzag, 3: flat-line,
+     * 4: teeth-clench, 5: teeth-grin, 6: wide-happy-open, 7: X, 8: mask-cover,
+     * 9: wavy-w, 10: dot, 11: diagonal-line, 12: frown-curve, 13: hollow-circle,
+     * 14: none, 15: tongue-out, 16: smirk, 17: triangle-kitten, 18: cat-three (>3<),
+     * 19: box-open, 20: pursed, 21: teeth-row, 22: side-tongue, 23: mega-tongue,
+     * 24: cat-cup-smirk]
+     */
+    mouthType: number;
+    /** Eyebrow Y offset */
+    browY: number;
+    /** Eyebrow tilt angle in degrees (+ is angry \ /, - is sad / \) */
+    browTilt: number;
+    /** Cheek opacity [0..1] */
+    cheek: number;
+    /** Vertical head bob offset in pixels */
+    bob: number;
+    /** Horizontal shift in pixels */
+    shiftX: number;
+    /** Teardrop opacity/scale [0..1] (Lumo) */
+    tears: number;
+    /** Horizontal gaze shift [-13.2..13.2] */
+    gazeX: number;
+    /** Vertical gaze shift [-8.4..8.4] */
+    gazeY: number;
+    /** 3D Head rotation angle in radians [-PI..PI] */
+    turnAngle: number;
+    /** Opacidad/intensidad del accesorio "Zzz" flotante [0..1] */
+    zzz: number;
+    /** Opacidad/intensidad de la gota de sudor [0..1] */
+    sweat: number;
+    /** Nubes de tormenta encima de la cabeza (enfado) [0..1] */
+    storm: number;
+    /** Garabato/espiral de confusión encima de la cabeza [0..1] */
+    scribble: number;
+    /** Nubecita de resoplido saliendo de la boca (agotamiento) [0..1] */
+    puff: number;
+}
+
+export declare type FrameCallback = (dt: number) => void;
+
+/**
+ * Calcula el ratio de contraste entre dos colores (e.g. 3:1, 4.5:1).
+ */
+export declare function getContrastRatio(color1: string, color2: string): number;
+
+export declare function getEmojiDefinition(nameOrEmotion: string): EmojiDefinition;
+
+/**
+ * Obtiene el volumen global actual (0.0 a 1.0).
+ */
+export declare function getGlobalVolume(): number;
+
+/**
+ * Calcula la luminancia relativa de un color según la norma WCAG 2.1.
+ */
+export declare function getLuminance(color: string): number;
+
+export declare function getSilhouettePath(silhouette: SilhouetteType): string;
+
+/**
+ * Obtiene el tema sugerido para un estado dado, con fallback a la paleta predeterminada del emoji.
+ */
+export declare function getThemeForState(_state: InteractionState, defaultBaseColor: string): EmojiTheme;
+
+export declare const IDLE_MOTIONS: Record<MotionType, IdleMotionFn>;
+
+/**
+ * Animación idle por personalidad.
+ *
+ * Cada emoji tiene una firma de movimiento propia. La clave para que se sienta
+ * "vivo" no es el desplazamiento principal (bob/shiftX) sino el movimiento
+ * secundario: inclinación de cabeza desfasada, respiración leída en eyeScale,
+ * micro-expresión (cejas/boca/mejillas) y acentos irregulares que rompen el
+ * bucle senoidal perfecto.
+ *
+ * Todas las funciones son ADITIVAS sobre los valores del resorte.
+ */
+export declare type IdleMotionFn = (p: FaceParameters, t: number, speed: number, amp: number) => void;
+
+export declare type InteractionState = CoreInteractionState | LifecycleState | ReactionState | MorphState | ProductCycleState | (string & {});
+
+/**
+ * Consulta si el sonido está habilitado globalmente.
+ */
+export declare function isGlobalSoundEnabled(): boolean;
+
+/**
+ * Utilidades de accesibilidad (A11y) para Wissive:
+ * - Detección y subscripción a prefers-reduced-motion
+ * - Cálculo de luminancia relativa y ratio de contraste WCAG 2.1
+ */
+/**
+ * Detecta si el usuario prefiere movimiento reducido en su sistema operativo.
+ */
+export declare function isReducedMotionPreferred(): boolean;
+
+/**
+ * Detecta si el entorno es primariamente táctil (pantallas táctiles sin hover).
+ */
+export declare function isTouchDevice(): boolean;
+
+export declare const LIB: Record<string, EmojiDefinition>;
+
+export declare type LifecycleState = 'sleeping' | 'waking' | 'idle' | 'listening' | 'thinking' | 'searching' | 'working';
+
+export declare function loadCustomEmoji(name: string): EmojiDefinition | null;
+
+/**
+ * Motor de resorte amortiguado (damped spring physics).
+ * Utiliza integrador numérico sub-stepped para máxima estabilidad.
+ */
+export declare function makeSpring(initialValue: number, config?: Partial<SpringConfig>): SpringInstance;
+
+export declare type MorphState = 'orbit' | 'radar' | 'progress';
+
+export declare interface MotionProfile {
+    stiffness: number;
+    damping: number;
+    idleSpeed: number;
+    idleAmplitude: number;
+    idleIntervalMin: number;
+    idleIntervalMax: number;
+    motionType: MotionType;
+}
+
+/** Firma de movimiento idle — una por personalidad, ver `core/motion.ts` */
+export declare type MotionType = 'bouncy' | 'flutter' | 'serene' | 'float' | 'calm' | 'droop' | 'sob' | 'jitter' | 'fiery' | 'wilt' | 'dizzy' | 'snooze' | 'pop' | 'drift';
+
+export declare interface MultiSpring<T extends Record<string, number>> {
+    getValues: () => T;
+    setTargets: (targets: Partial<T>) => void;
+    setValues: (values: Partial<T>) => void;
+    update: (dt: number) => boolean;
+}
+
+export declare class ParticleEmitter {
+    private particles;
+    private canvas;
+    private ctx;
+    private animating;
+    private rafId;
+    private size;
+    private dpr;
+    constructor(container: HTMLElement, size: number);
+    private setupCanvas;
+    resize(newSize: number): void;
+    burst(emotion: string, count?: number, originX?: number, originY?: number): void;
+    private createParticle;
+    private tick;
+    private drawParticle;
+    destroy(): void;
+}
+
+export declare type ParticleShape = 'heart' | 'star' | 'sparkle' | 'drop' | 'diamond' | 'zigzag' | 'circle' | 'ring' | 'zzz' | 'petal' | 'spiral' | 'bubble' | 'ember' | 'shard' | 'burst' | 'dot' | 'glitch';
+
+/** Estados cuya animación la pone la personalidad del emoji, no el estado */
+export declare const PERSONALITY_DRIVEN_STATES: InteractionState[];
+
+/** Elige uno al azar de `pool`, evitando repetir `previous` cuando hay más de una opción */
+export declare function pickWithoutRepeat<T>(pool: T[], previous: T | null): T;
+
+export declare type ProductCycleState = 'spawning' | 'humming' | 'loading' | 'dictating' | 'writing' | 'sending' | 'receiving' | 'uploading' | 'notifying' | 'alerting' | 'dragging' | 'bouncing' | 'powering-down';
+
+export declare type ReactionState = 'excited' | 'surprised' | 'suspicious' | 'angry' | 'drowsy' | 'happy' | 'curious' | 'confused' | 'bored' | 'proud' | 'shy' | 'sad' | 'laughing' | 'scared' | 'playful' | 'celebrate';
+
+export declare interface RenderOptions {
+    flipX?: boolean;
+    emphasis?: boolean;
+}
+
+export declare function renderSvgElement(silhouette: SilhouetteType, baseColor: string, params: FaceParameters, size: number, renderOptions?: RenderOptions): string;
+
+/**
+ * Resuelve qué banco de estados usar para deambular, en orden de prioridad:
+ * opción explícita del llamador > banco propio del emoji (p.ej. un custom
+ * con `stateBank`) > banco genérico. Función pura para poder testear la
+ * prioridad sin tener que instanciar un emoji real (createEmoji necesita DOM).
+ */
+export declare function resolveAutonomousStatePool(explicitPool: InteractionState[] | undefined, definitionPool: InteractionState[] | undefined): InteractionState[];
+
+export declare function resolveSize(size?: WissiveSize): number;
+
+export declare function saveCustomEmoji(name: string, def: EmojiDefinition): void;
+
+export declare type SequenceMode = 'loop' | 'once' | 'ping-pong';
+
+export declare interface SequenceOptions {
+    mode?: SequenceMode;
+    onComplete?: () => void;
+}
+
+export declare interface SequencePlayer {
+    play: (steps: SequenceStep[], options?: SequenceOptions) => void;
+    stop: () => void;
+    isPlaying: () => boolean;
+}
+
+export declare interface SequenceStep {
+    /** Nombre de un estado del emoji (usa su pool de expresiones) */
+    state?: string;
+    /** Parámetros crudos — se aplican encima si además hay `state` */
+    params?: Partial<FaceParameters>;
+    /** ms que dura este paso antes de pasar al siguiente */
+    duration?: number;
+}
+
+/**
+ * Control global del sonido para todas las instancias de Wissive en la página.
+ */
+export declare function setGlobalSound(enabled: boolean): void;
+
+/**
+ * Ajusta el nivel de volumen global (0.0 a 1.0) para todos los sonidos de Wissive.
+ */
+export declare function setGlobalVolume(volume: number): void;
+
+export declare const sharedLoop: AnimationLoop;
+
+export declare type SilhouetteType = 'circle' | 'capsule' | 'rounded-squircle' | 'pear-blob' | 'egg-oval' | 'starburst-puff' | 'pill-vertical' | 'heart' | 'round-blob' | 'ghost-blob' | 'oval' | 'elongated-oval' | 'teardrop-blob' | 'flame-blob' | 'droopy-blob' | 'bear-blob' | 'spiky-blob' | 'cloud-blob' | 'wide-oval' | 'soft-round' | 'octopus-blob' | 'wave-blob';
+
+export declare const SIZE_PRESETS: Record<WissivePresetSize, number>;
+
+export declare class SoundEngine {
+    private enabled;
+    private volume;
+    constructor();
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    setVolumeLevel(vol: number): void;
+    getVolumeLevel(): number;
+    playCue(cueName: CueSoundType, options?: {
+        volume?: number;
+    }): void;
+    playSound(emotion: string, action: 'hover' | 'click' | 'bounce'): void;
+}
+
+export declare const soundEngine: SoundEngine;
+
+export declare interface SpringConfig {
+    stiffness: number;
+    damping: number;
+    mass: number;
+}
+
+export declare interface SpringInstance {
+    state: SpringState;
+    setTarget: (target: number) => void;
+    setCurrent: (value: number) => void;
+    update: (dt: number) => boolean;
+}
+
+export declare interface SpringState {
+    current: number;
+    target: number;
+    velocity: number;
+}
+
+export declare const STATE_GROUPS: StateGroup[];
+
+export declare const STATE_MOTIONS: Record<string, IdleMotionFn>;
+
+/**
+ * Mapeo de paleta de colores por estado de emoción/actividad
+ */
+export declare const STATE_THEME_MAP: Partial<Record<InteractionState, EmojiTheme>>;
+
+/**
+ * Registro de estados en runtime — fuente única de verdad.
+ *
+ * Los tipos de `types.ts` solo existen en compilación, así que la UI se
+ * inventaba su propia lista y quedó desincronizada: `idle` duplicado,
+ * etiquetas en francés y un recuento de 39 que no cuadraba con la realidad.
+ */
+export declare interface StateGroup {
+    label: string;
+    states: InteractionState[];
+}
+
+export declare class StateManager {
+    private currentState;
+    private lastIndices;
+    getState(): InteractionState;
+    setState(newState: InteractionState): boolean;
+    resolvePool(expressions: Record<string, FaceParameters[]>, state?: InteractionState): FaceParameters[];
+    pickVariant(pool: FaceParameters[], state?: InteractionState): FaceParameters;
+}
+
+/**
+ * Se suscribe a los cambios de la preferencia prefers-reduced-motion del sistema.
+ */
+export declare function subscribeToReducedMotion(onChange: (reduced: boolean) => void): () => void;
+
+/**
+ * Detecta si el dispositivo actual soporta hover real (puntero fino como mouse o trackpad).
+ * Devuelve false en dispositivos táctiles primarios (smartphones, tablets sin mouse).
+ */
+export declare function supportsHover(): boolean;
+
+export declare type ThemeOption = 'auto' | EmojiTheme;
+
+declare const Wissive: {
+    create: typeof createEmoji;
+    createGroup: typeof createEmojiGroup;
+    setGlobalSound: typeof setGlobalSound;
+    isGlobalSoundEnabled: typeof isGlobalSoundEnabled;
+    setGlobalVolume: typeof setGlobalVolume;
+    getGlobalVolume: typeof getGlobalVolume;
+    supportsHover: typeof supportsHover;
+    isTouchDevice: typeof isTouchDevice;
+};
+export { Wissive }
+export default Wissive;
+
+export declare interface WissiveInstance {
+    id: string;
+    name: string;
+    emotionCategory: string;
+    getElement: () => HTMLElement;
+    getPosition: () => {
+        x: number;
+        y: number;
+    };
+    getCurrentState: () => InteractionState;
+    setEmotion: (state: InteractionState) => void;
+    spin: (turns?: number) => void;
+    bounce: () => void;
+    setGaze: (gaze: {
+        x: number;
+        y: number;
+    }) => void;
+    setGazeTracking: (enabled: boolean) => void;
+    setSound: (enabled: boolean) => void;
+    setDraggable: (enabled: boolean) => void;
+    setFlipX: (flip: boolean) => void;
+    setEmphasis: (emphasis: boolean) => void;
+    setAmbientParticles: (enabled: boolean) => void;
+    setAutonomousStates: (enabled: boolean) => void;
+    setAutonomousStatePool: (pool: InteractionState[]) => void;
+    setReducedMotion: (setting: 'auto' | boolean) => void;
+    setTheme: (theme: ThemeOption) => void;
+    setSize: (size: WissiveSize) => void;
+    triggerParticles: (count?: number) => void;
+    playSequence: (steps: SequenceStep[], options?: SequenceOptions) => void;
+    stopSequence: () => void;
+    isSequencePlaying: () => boolean;
+    destroy: () => void;
+}
+
+export declare interface WissiveOptions {
+    target: HTMLElement;
+    size?: WissiveSize;
+    sound?: boolean;
+    interactive?: boolean;
+    draggable?: boolean;
+    nearRadius?: number;
+    flipX?: boolean;
+    emphasis?: boolean;
+    gazeTracking?: boolean;
+    ambientParticles?: boolean;
+    /** Visita reacciones al azar cuando está en reposo, para que se sienta vivo (default: true) */
+    autonomousStates?: boolean;
+    /** Qué estados puede visitar al deambular (default: `definition.autonomousStatePool` o AUTONOMOUS_STATES) */
+    autonomousStatePool?: InteractionState[];
+    reducedMotion?: 'auto' | boolean;
+    theme?: ThemeOption;
+}
+
+export declare type WissivePresetSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl';
+
+export declare type WissiveSize = WissivePresetSize | number;
+
+export { }

package/dist/react.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("react/jsx-runtime"),t=require("react"),i=require("./wissive.cjs");function o({name:n,...s}){const e=t.useRef(null),r=t.useRef(null);return t.useEffect(()=>{if(e.current)return r.current=i.createEmoji(n,{target:e.current,...s}),()=>{var u;(u=r.current)==null||u.destroy(),r.current=null}},[n]),c.jsx("div",{ref:e})}exports.Wissive=o;
+//# sourceMappingURL=react.cjs.map