@nice2dev/ui-graphics 1.0.0

package/dist/types/animation/AnimationEditor.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import type { CharacterConfig } from "./characterTypes";
+export interface AnimationEditorProps {
+    /** Initial character config. Defaults to DEFAULT_CHARACTER. */
+    initialConfig?: CharacterConfig;
+    /** Called whenever config changes. */
+    onChange?: (config: CharacterConfig) => void;
+    /** Persist/restore state to localStorage with this key. Pass false to disable. Default: "nice2dev.animation-editor.character" */
+    storageKey?: string | false;
+    /** Optional notification callback (replaces Toast integration). */
+    onNotify?: (message: string, type?: "success" | "error" | "info") => void;
+    /** Show JSON editor panel (default: true). Set false for compact mode. */
+    showJsonPanel?: boolean;
+    /** Show the preview panel (default: true). Set false to hide the avatar preview. */
+    showPreview?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function AnimationEditor({ initialConfig, onChange, storageKey, onNotify, showJsonPanel, showPreview, className, style, }: AnimationEditorProps): import("react/jsx-runtime").JSX.Element;
+export default AnimationEditor;

package/dist/types/animation/Audience.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+/** Props for the Audience grid component. */
+export type AudienceProps = {
+    /** Number of audience members. */
+    count?: number;
+    /** Columns in CSS grid. */
+    columns?: number;
+};
+/** Grid of animated audience members with wave/cheer actions. */
+declare const Audience: React.FC<AudienceProps>;
+export default Audience;

package/dist/types/animation/BodyRenderer.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { CharacterConfig } from "./characterTypes";
+/** Props for BodyRenderer (pure visual; no animation). */
+export type BodyRendererProps = {
+    /** Character configuration (features + palettes). */
+    character: CharacterConfig;
+    /** Optional pixel size. Defaults to character.size (or 180). */
+    size?: number;
+};
+/** Static character body composed from modular SVG shapes. */
+export declare const BodyRenderer: React.FC<BodyRendererProps>;
+export default BodyRenderer;

package/dist/types/animation/animationHelper.d.ts

@@ -0,0 +1,28 @@
+import { AnimationControls } from "framer-motion";
+export type PersonControls = {
+    root: AnimationControls;
+    body: AnimationControls;
+    head: AnimationControls;
+    eyes: AnimationControls;
+    mouth: AnimationControls;
+    leftArm: AnimationControls;
+    rightArm: AnimationControls;
+    card: AnimationControls;
+    curse: AnimationControls;
+};
+export declare function usePersonControls(): PersonControls;
+/** Dotychczasowe pozy + 10 nowych */
+export type PersonPose = "idle" | "raiseCard" | "happy" | "angry" | "disappointed" | "swearing" | "shouting" | "rock" | "danceA" | "danceB" | "danceC" | "hideDown" | "exitLeft" | "exitRight" | "enterFromLeft" | "enterFromRight" | "waveHand" | "facepalm" | "shrug" | "nodYes" | "shakeNo" | "pointRight" | "leanBack" | "jump" | "spin" | "celebrate";
+export type PoseOptions = {
+    duration?: number;
+    score?: number | string;
+    screenW?: number;
+    screenH?: number;
+};
+export type ChoreoStep = {
+    pose: PersonPose;
+    holdMs?: number;
+    options?: PoseOptions;
+};
+export declare function playPose(fx: PersonControls, pose: PersonPose, opts?: PoseOptions): Promise<void>;
+export declare function runChoreo(fx: PersonControls, steps: ChoreoStep[]): Promise<void>;

package/dist/types/animation/characterTypes.d.ts

@@ -0,0 +1,37 @@
+export type FeatureConfig = {
+    /** nazwa wariantu, np. "short", "dot" itp. */
+    variant: string;
+    /** 1+ colors per variant. Excess trimmed in renderers, missing duplicated. */
+    colors: string[];
+};
+export type CharacterConfig = {
+    face: FeatureConfig;
+    hair: FeatureConfig;
+    eyes: FeatureConfig;
+    nose: FeatureConfig;
+    mouth: FeatureConfig;
+    outfit: FeatureConfig;
+    headwear: FeatureConfig;
+    prop: FeatureConfig;
+    name?: string;
+    size?: number;
+};
+export declare const VARIANTS: {
+    readonly face: readonly ["round", "oval", "square", "heart", "diamond", "long", "chubby", "flatTop", "egg", "triangle", "hex", "pear", "bean", "heroJaw"];
+    readonly hair: readonly ["none", "short", "long", "curly", "wavy", "mohawk", "afro", "bunHigh", "bunLow", "bob", "pixie", "sidePart", "undercut", "spiky", "braids", "dreadlocks", "ponytail", "twinTails", "mullet", "balding", "bangs"];
+    readonly eyes: readonly ["classic", "big", "anime", "sleepy", "angry", "surprised", "winkLeft", "winkRight", "smile", "oval", "upturned", "downturned", "lashes", "sparkle", "heart", "star", "sad", "focused"];
+    readonly nose: readonly ["line", "triangle", "round", "button", "hook", "flat", "wide", "tiny", "pointy", "roman", "none"];
+    readonly mouth: readonly ["smile", "frown", "open", "flat", "o", "grin", "teeth", "smirk", "wow", "tongue", "laugh", "sad", "angry", "kiss", "grimace"];
+    readonly outfit: readonly ["tee", "hoodie", "suit", "dress", "tank", "jacket", "blazer", "vest", "sweatshirt", "kimono", "polo", "stripes", "checker", "jersey", "tux", "robe"];
+    readonly headwear: readonly ["none", "cap", "headphones", "hat", "crown", "beanie", "bandana", "visor", "bow", "tiara", "fedora", "beret", "headband", "helmet", "headsetMic", "hood", "cowboy", "bunnyEars"];
+    readonly prop: readonly ["none", "mic", "clipboard", "star", "flag", "phone", "glass", "trophy", "rose", "glowstick", "megaphone", "tambourine", "lightstick", "scoreCard", "camera", "tablet", "remote", "foamFinger", "whistle", "drumstick"];
+};
+export declare const DEFAULT_COLORS: {
+    skin: string;
+    hair: string;
+    shirt: string;
+    stroke: string;
+};
+export declare const DEFAULT_CHARACTER: CharacterConfig;
+/** Returns color from list; if missing – uses last or fallback */
+export declare function pick(colors: string[], index: number, fallback?: string): string;

package/dist/types/animation/choreoDSL.d.ts

@@ -0,0 +1,88 @@
+import type { ChoreoStep, PersonControls, PersonPose, PoseOptions } from "./animationHelper";
+/** Context passed to choreography runtime (conditions, scoring, etc.). */
+export type RunContext = {
+    score?: number;
+    [k: string]: unknown;
+};
+type InternalStep = {
+    type: "pose";
+    pose: PersonPose;
+    holdMs?: number;
+    options?: PoseOptions;
+} | {
+    type: "wait";
+    ms: number;
+} | {
+    type: "label";
+    name: string;
+} | {
+    type: "goto";
+    name: string;
+    when?: (ctx: RunContext) => boolean;
+};
+/**
+ * Builder-pattern DSL for choreography sequences.
+ *
+ * @example
+ * ```ts
+ * seq()
+ *   .enterFromLeft(0.6)
+ *   .happy(300)
+ *   .waveHand(600)
+ *   .celebrate(500)
+ * ```
+ */
+export declare class ChoreoBuilder {
+    private steps;
+    private labels;
+    private loopCount;
+    pose(pose: PersonPose, holdMs?: number, options?: PoseOptions): this;
+    wait(ms: number): this;
+    tempo(multiplier: number): this;
+    repeat(times: number): this;
+    loop(times: number | typeof Infinity): this;
+    label(name: string): this;
+    goto(name: string): this;
+    gotoIf(name: string, when: (ctx: RunContext) => boolean): this;
+    idle(ms?: number): this;
+    enterFromLeft(duration?: number): this;
+    enterFromRight(duration?: number): this;
+    exitLeft(duration?: number): this;
+    exitRight(duration?: number): this;
+    hideDown(duration?: number): this;
+    happy(ms?: number): this;
+    angry(ms?: number): this;
+    disappointed(ms?: number): this;
+    swearing(ms?: number): this;
+    shouting(ms?: number): this;
+    rock(ms?: number): this;
+    danceA(ms?: number): this;
+    danceB(ms?: number): this;
+    danceC(ms?: number): this;
+    waveHand(ms?: number): this;
+    facepalm(ms?: number): this;
+    shrug(ms?: number): this;
+    nodYes(ms?: number): this;
+    shakeNo(ms?: number): this;
+    pointRight(ms?: number): this;
+    leanBack(ms?: number): this;
+    jump(ms?: number): this;
+    spin(ms?: number): this;
+    celebrate(ms?: number): this;
+    raiseCard(score?: number | string, holdMs?: number, duration?: number): this;
+    build(): InternalStep[];
+    getLoop(): number | typeof Infinity | undefined;
+}
+/** Create a new ChoreoBuilder. */
+export declare const seq: () => ChoreoBuilder;
+/** Compile builder or steps into flat ChoreoStep[] (resolving gotos). */
+export declare function compile(builderOrSteps: ChoreoBuilder | ChoreoStep[] | InternalStep[], ctx?: RunContext): ChoreoStep[];
+/** Run compiled choreography on a single actor (with optional looping). */
+export declare function runSeq(fx: PersonControls, builderOrSteps: ChoreoBuilder | ChoreoStep[] | InternalStep[], ctx?: RunContext): Promise<void>;
+/** Wave pattern: stagger actors left→right. */
+export declare function runWave(actors: PersonControls[], choreo: ChoreoBuilder | ChoreoStep[] | InternalStep[], staggerMs?: number, ctx?: RunContext): Promise<void>;
+/** Cannon pattern: wave left→right, then right→left. */
+export declare function runCannon(actors: PersonControls[], choreo: ChoreoBuilder | ChoreoStep[] | InternalStep[], staggerMs?: number, ctx?: RunContext): Promise<void>;
+/** Assign programs to actors round-robin. */
+export declare function runRounds(actors: PersonControls[], programs: Array<ChoreoBuilder | ChoreoStep[] | InternalStep[]>, staggerMs?: number, ctx?: RunContext): Promise<void>;
+export {};

package/dist/types/animation/choreography.d.ts

@@ -0,0 +1,8 @@
+/** Wave + score reveal choreography. */
+export declare const waveScoreChoreo: (score: number) => import("./choreoDSL").ChoreoBuilder;
+/** Boo / disapproval choreography. */
+export declare const booChoreo: import("./choreoDSL").ChoreoBuilder;
+/** Dance party loop. */
+export declare const danceParty: import("./choreoDSL").ChoreoBuilder;
+/** Showcase all poses. */
+export declare const showcaseAll: import("./choreoDSL").ChoreoBuilder;

package/dist/types/animation/karaokeIntegration.d.ts

@@ -0,0 +1,31 @@
+import type { PersonControls } from "./animationHelper";
+import type { ChoreoBuilder } from "./choreoDSL";
+/** Score event emitted on the score bus. */
+export type ScoreEvent = {
+    score: number;
+    at: number;
+};
+type ScoreHandler = (e: ScoreEvent) => void;
+declare class ScoreBus {
+    private target;
+    push(score: number): void;
+    subscribe(handler: ScoreHandler): () => void;
+}
+/** Shared score event bus. */
+export declare const scoreBus: ScoreBus;
+export type ScoreListenerOptions = {
+    minIntervalMs?: number;
+    dedupeWindowMs?: number;
+    roundTo?: number;
+};
+/** Subscribe to score events with throttling + dedup. */
+export declare function onScore(handler: (score: number) => void, opts?: ScoreListenerOptions): () => void;
+/** Map a score to a reaction choreography. */
+export declare function reactionForScore(score: number, rng?: () => number): ChoreoBuilder;
+/** Play intro choreography for actors. */
+export declare function playIntro(actors: PersonControls[]): Promise<void>;
+/** Emit a score event for testing. */
+export declare const simulateScore: (score: number) => void;
+/** Attach score reactions to actors. */
+export declare function attachScoreReactions(actors: PersonControls[], opts?: ScoreListenerOptions, rng?: () => number): () => void;
+export {};

package/dist/types/animation/lottieExport.d.ts

@@ -0,0 +1,77 @@
+/**
+ * lottieExport.ts — Export animations to Lottie/Bodymovin JSON format.
+ *
+ * Converts rig poses and choreography sequences to Lottie animation format
+ * that can be played back with lottie-web, lottie-ios, lottie-android, etc.
+ */
+import type { RigPose, RigConfig } from "./rig/rigTypes";
+export interface LottieKeyframe {
+    /** Time in ms. */
+    time: number;
+    /** Pose at this keyframe. */
+    pose: RigPose;
+}
+export interface LottieExportOptions {
+    /** Animation name. */
+    name?: string;
+    /** Width in pixels. */
+    width?: number;
+    /** Height in pixels. */
+    height?: number;
+    /** Frames per second. */
+    fps?: number;
+    /** Rig configuration (defaults to DEFAULT_RIG). */
+    rig?: RigConfig;
+    /** Character size for FK solving. */
+    size?: number;
+    /** Author name. */
+    author?: string;
+}
+interface LottieLayer {
+    ddd: number;
+    ind: number;
+    ty: number;
+    nm: string;
+    sr: number;
+    ks: Record<string, unknown>;
+    ao: number;
+    shapes: unknown[];
+    ip: number;
+    op: number;
+    st: number;
+    bm: number;
+}
+interface LottieAnimation {
+    v: string;
+    fr: number;
+    ip: number;
+    op: number;
+    w: number;
+    h: number;
+    nm: string;
+    ddd: number;
+    assets: unknown[];
+    layers: LottieLayer[];
+    meta?: {
+        a: string;
+        g: string;
+    };
+}
+/**
+ * Export a sequence of RigPose keyframes to Lottie JSON format.
+ * Returns a Lottie animation object that can be serialized with JSON.stringify().
+ */
+export declare function exportToLottie(keyframes: LottieKeyframe[], options?: LottieExportOptions): LottieAnimation;
+/** Serialize Lottie animation to a JSON string. */
+export declare function lottieToJSON(animation: LottieAnimation): string;
+/** Create a downloadable Blob for the Lottie animation. */
+export declare function lottieToBlob(animation: LottieAnimation): Blob;
+/**
+ * Convert a choreography sequence (pose name + duration) to Lottie keyframes.
+ * Utility for bridging the choreography system to Lottie export.
+ */
+export declare function choreoToLottieKeyframes(poses: Array<{
+    pose: RigPose;
+    durationMs: number;
+}>): LottieKeyframe[];
+export {};

package/dist/types/animation/motionPath.d.ts

@@ -0,0 +1,60 @@
+/**
+ * motionPath.ts — Spline-based motion path editor for AnimationEditor.
+ *
+ * Cubic Bézier paths that can be evaluated at any t ∈ [0..1]
+ * to drive bone position or object translation.
+ */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface BezierPoint {
+    /** Anchor position. */
+    pos: Vec2;
+    /** Control point before anchor (incoming tangent). */
+    cpIn: Vec2;
+    /** Control point after anchor (outgoing tangent). */
+    cpOut: Vec2;
+}
+export interface MotionPath {
+    id: string;
+    name: string;
+    points: BezierPoint[];
+    closed: boolean;
+}
+export interface MotionPathKeyframe {
+    /** Time in ms. */
+    time: number;
+    /** Parameter t on the path [0..1]. */
+    t: number;
+    /** Easing to next keyframe. */
+    easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+}
+export interface MotionPathAnimation {
+    pathId: string;
+    keyframes: MotionPathKeyframe[];
+    loop: boolean;
+}
+/** Create a straight-line motion path between two points. */
+export declare function createLinearPath(id: string, from: Vec2, to: Vec2, name?: string): MotionPath;
+/** Create a circular motion path. */
+export declare function createCircularPath(id: string, cx: number, cy: number, radius: number, name?: string): MotionPath;
+/** Create a figure-8 motion path. */
+export declare function createFigure8Path(id: string, cx: number, cy: number, width: number, height: number, name?: string): MotionPath;
+/** Evaluate a position on the motion path at parameter t ∈ [0..1]. */
+export declare function evaluatePath(path: MotionPath, t: number): Vec2;
+/** Get the tangent direction at parameter t. */
+export declare function evaluatePathTangent(path: MotionPath, t: number): Vec2;
+/** Approximate total path length by sampling. */
+export declare function pathLength(path: MotionPath, samples?: number): number;
+/** Compute arc-length parameterization lookup table. */
+export declare function arcLengthTable(path: MotionPath, samples?: number): number[];
+/** Convert distance fraction → parametric t using arc-length table. */
+export declare function distanceToT(arcTable: number[], d: number): number;
+/** Evaluate a motion path animation at a given time (ms). Returns position on path. */
+export declare function evaluateMotionPathAnimation(path: MotionPath, anim: MotionPathAnimation, timeMs: number): Vec2 | null;
+export declare const PRESET_PATHS: {
+    bouncingArc: (cx: number, cy: number, w: number, h: number) => MotionPath;
+    circle: (cx: number, cy: number, r: number) => MotionPath;
+    figure8: (cx: number, cy: number, w: number, h: number) => MotionPath;
+};

package/dist/types/animation/physics.d.ts

@@ -0,0 +1,73 @@
+/**
+ * physics.ts — 2D physics simulation for animation (ragdoll, cloth).
+ *
+ * Verlet integration with constraints for realistic body/cloth simulation.
+ */
+import type { RigPose } from "./rig/rigTypes";
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface PhysicsParticle {
+    pos: Vec2;
+    prev: Vec2;
+    acc: Vec2;
+    mass: number;
+    pinned: boolean;
+}
+export interface DistanceConstraint {
+    a: number;
+    b: number;
+    restLength: number;
+    stiffness: number;
+}
+export interface PhysicsConfig {
+    gravity: Vec2;
+    damping: number;
+    iterations: number;
+    timestep: number;
+}
+export interface RagdollConfig {
+    size: number;
+    gravity?: Vec2;
+    damping?: number;
+}
+export interface ClothConfig {
+    width: number;
+    height: number;
+    cols: number;
+    rows: number;
+    pinTop?: boolean;
+    stiffness?: number;
+    gravity?: Vec2;
+    damping?: number;
+}
+export interface ClothSimulation {
+    particles: PhysicsParticle[];
+    constraints: DistanceConstraint[];
+    cols: number;
+    rows: number;
+}
+export interface RagdollSimulation {
+    particles: PhysicsParticle[];
+    constraints: DistanceConstraint[];
+    boneMap: Record<string, number>;
+}
+/** Create a ragdoll simulation from a rig pose. */
+export declare function createRagdoll(cfg: RagdollConfig): RagdollSimulation;
+/** Step the ragdoll simulation forward by one frame. */
+export declare function stepRagdoll(sim: RagdollSimulation, config?: Partial<PhysicsConfig>): void;
+/** Extract a RigPose from the current ragdoll particle positions. */
+export declare function ragdollToPose(sim: RagdollSimulation): RigPose;
+/** Apply a force impulse to a ragdoll particle. */
+export declare function applyImpulse(sim: RagdollSimulation, boneName: string, force: Vec2): void;
+/** Create a cloth simulation grid. */
+export declare function createCloth(cfg: ClothConfig): ClothSimulation;
+/** Step the cloth simulation forward by one frame. */
+export declare function stepCloth(sim: ClothSimulation, config?: Partial<PhysicsConfig>): void;
+/** Get cloth vertex positions as a flat array [x0,y0, x1,y1, ...]. */
+export declare function clothVertices(sim: ClothSimulation): number[];
+/** Pin or unpin a cloth particle by grid position. */
+export declare function pinClothParticle(sim: ClothSimulation, col: number, row: number, pinned: boolean): void;
+export type Ragdoll = RagdollSimulation;
+export type Cloth = ClothSimulation;

package/dist/types/animation/rig/RigPlayer.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import type { CharacterConfig } from "../characterTypes";
+import { type RigConfig, type RigPose } from "./rigTypes";
+import type { ChoreoStep } from "../animationHelper";
+/** Public methods exposed via ref. */
+export interface RigPlayerHandle {
+    /** Set pose immediately (no tween). */
+    setPose(p: RigPose): void;
+    /** Tween to pose in given duration. */
+    tweenTo(p: RigPose, durationMs?: number): Promise<void>;
+    /** Play DSL choreo mapped to rig angles. */
+    playChoreo(steps: ChoreoStep[], defaultMs?: number): Promise<void>;
+    /** Aim right hand to (x,y) in SVG space. */
+    aimRightHandAt(x: number, y: number): void;
+    /** Raise card using IK and hold optional score. */
+    raiseCardIK(score?: number, durationMs?: number): Promise<void>;
+}
+/** Props for RigPlayer. */
+export type RigPlayerProps = {
+    /** Character visuals. */
+    character: CharacterConfig;
+    /** Rig proportions preset. */
+    rig?: RigConfig;
+    /** Initial pose (optional). */
+    pose?: RigPose;
+    /** Pixel size. */
+    size?: number;
+    /** Show debug joints. */
+    debug?: boolean;
+};
+declare const RigPlayer: React.ForwardRefExoticComponent<RigPlayerProps & React.RefAttributes<RigPlayerHandle>>;
+export default RigPlayer;

package/dist/types/animation/rig/RiggedBody.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import type { CharacterConfig } from "../characterTypes";
+import { type RigConfig, type RigPose } from "./rigTypes";
+/** Props for the rigged body renderer (pure SVG). */
+export type RiggedBodyProps = {
+    /** Character visuals (colors). */
+    character: CharacterConfig;
+    /** Rig proportions; defaults to DEFAULT_RIG. */
+    rig?: RigConfig;
+    /** Angles (deg) for each bone; defaults to DEFAULT_POSE. */
+    pose?: RigPose;
+    /** Pixel size (falls back to character.size or 180). */
+    size?: number;
+    /** Draw joints overlay. */
+    debug?: boolean;
+};
+/** Render a multi-bone body (arms: 3, legs: 3, torso: 3, neck+head). */
+declare const RiggedBody: React.FC<RiggedBodyProps>;
+export default RiggedBody;

package/dist/types/animation/rig/choreoRigBridge.d.ts

@@ -0,0 +1,9 @@
+import type { RigPose } from "./rigTypes";
+import type { PersonPose, ChoreoStep } from "../animationHelper";
+/** Map a high-level PersonPose to a rig pose. */
+export declare function rigPoseFor(pose: PersonPose): RigPose;
+/** Play a DSL choreography program by tweening the provided pose setter. */
+export declare function playRigFromChoreo(steps: ChoreoStep[], setPose: (p: RigPose) => void, opts?: {
+    duration?: number;
+    easing?: (t: number) => number;
+}): Promise<void>;

package/dist/types/animation/rig/ik.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 2-bone planar IK solver (shoulder→elbow→hand).
+ * Returns absolute angles (deg) for upper and forearm.
+ */
+export declare function solveTwoBoneIK(sx: number, sy: number, L1: number, L2: number, tx: number, ty: number): {
+    upper: number;
+    fore: number;
+};

package/dist/types/animation/rig/poseOps.d.ts

@@ -0,0 +1,14 @@
+import type { RigPose } from "./rigTypes";
+/** Easing functions (t in [0..1]). */
+export declare const ease: {
+    /** Smoothstep-like ease in-out. */
+    inOut: (t: number) => number;
+    /** Fast-in, slow-out. */
+    outCubic: (t: number) => number;
+    /** Slow-in, fast-out. */
+    inCubic: (t: number) => number;
+};
+/** Blend two poses by factor t (0..1). */
+export declare function blendPose(a: RigPose, b: RigPose, t: number): RigPose;
+/** Tween helper driven by requestAnimationFrame. */
+export declare function tweenPose(from: RigPose, to: RigPose, durationMs: number, set: (p: RigPose) => void, easing?: (t: number) => number): Promise<void>;

package/dist/types/animation/rig/presets.d.ts

@@ -0,0 +1,13 @@
+import type { RigConfig, RigPose } from "./rigTypes";
+/** Slim proportions preset. */
+export declare const RIG_SLIM: RigConfig;
+/** Broad shoulders preset. */
+export declare const RIG_HERO: RigConfig;
+/** Robot-like short limbs preset. */
+export declare const RIG_ROBOT: RigConfig;
+/** Happy pose. */
+export declare const POSE_HAPPY: RigPose;
+/** Angry pose. */
+export declare const POSE_ANGRY: RigPose;
+/** Dance pose A. */
+export declare const POSE_DANCE_A: RigPose;

package/dist/types/animation/rig/rigMath.d.ts

@@ -0,0 +1,7 @@
+import type { BoneKey, RigConfig, RigPose, SolvedBone } from "./rigTypes";
+/** Convert degrees to radians. */
+export declare const deg2rad: (deg: number) => number;
+/** Linear interpolation of angles with wrap-around. */
+export declare function lerpAngle(a: number, b: number, t: number): number;
+/** Forward kinematics — compute world-space positions for all bones. */
+export declare function solveFK(rig: RigConfig, pose: RigPose, sizePx: number): Record<BoneKey, SolvedBone>;

package/dist/types/animation/rig/rigTypes.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Bone name keys used in the rig system.
+ * Full humanoid skeleton: root → pelvis → spine → neck → head,
+ * shoulders → arms → hands, thighs → shins → feet.
+ */
+export type BoneKey = "root" | "pelvis" | "spineLower" | "spineUpper" | "neck" | "head" | "lShoulder" | "lUpperArm" | "lForearm" | "lHand" | "rShoulder" | "rUpperArm" | "rForearm" | "rHand" | "lThigh" | "lShin" | "lFoot" | "rThigh" | "rShin" | "rFoot";
+/** Bone specification relative to the character size. */
+export type BoneSpec = {
+    /** Parent bone key (undefined for the root). */
+    parent?: BoneKey;
+    /** Length as a fraction of character size (px = length * size). */
+    length?: number;
+    /** Static offset from parent joint, in fractions of size [dx, dy]. */
+    offset?: [number, number];
+};
+/** Complete rig configuration describing all bones. */
+export type RigConfig = Record<BoneKey, BoneSpec>;
+/** Per-bone rotation in degrees (clockwise, 0° = pointing right). */
+export type RigPose = Partial<Record<BoneKey, number>>;
+/** World-space FK result for a single bone. */
+export type SolvedBone = {
+    /** Start x (px). */
+    x: number;
+    /** Start y (px). */
+    y: number;
+    /** End x (px). */
+    x2: number;
+    /** End y (px). */
+    y2: number;
+    /** World rotation (deg). */
+    angle: number;
+};
+/** Ordered list for safe FK traversal. */
+export declare const BONE_ORDER: BoneKey[];
+/** Default humanoid rig (proportions tuned for ~180px height). */
+export declare const DEFAULT_RIG: RigConfig;
+/** Neutral standing pose (deg). */
+export declare const DEFAULT_POSE: RigPose;

package/dist/types/animation/shapes/arms.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export type ArmProps = {
+    colors: string[];
+    side: -1 | 1;
+    variant?: string;
+    scale?: number;
+    transform?: string;
+    strokeWidth?: number;
+};
+export declare const Arm: React.FC<ArmProps>;

package/dist/types/animation/shapes/eyes.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+export type EyesProps = {
+    colors: string[];
+    spread?: number;
+    y?: number;
+    scale?: number;
+    transform?: string;
+    eyebrows?: boolean;
+};
+export declare const EyesClassic: React.FC<EyesProps>;
+export declare const EyesAnime: React.FC<EyesProps>;
+export declare const EyesSleepy: React.FC<EyesProps>;
+export declare const EyesSmile: React.FC<EyesProps>;
+export declare const EYES_RENDERERS: Record<string, React.FC<EyesProps>>;
+export declare const Eyes: React.FC<EyesProps & {
+    variant: string;
+}>;

package/dist/types/animation/shapes/hair.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+export type HairProps = {
+    colors: string[];
+    scale?: number;
+    transform?: string;
+    strokeWidth?: number;
+};
+export declare const HairNone: React.FC<HairProps>;
+export declare const HairShort: React.FC<HairProps>;
+export declare const HairLong: React.FC<HairProps>;
+export declare const HairMohawk: React.FC<HairProps>;
+export declare const HairAfro: React.FC<HairProps>;
+export declare const HairBob: React.FC<HairProps>;
+export declare const HAIR_RENDERERS: Record<string, React.FC<HairProps>>;
+export declare const Hair: React.FC<HairProps & {
+    variant: string;
+}>;