@idosgames/characters 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iDos Games
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# @idosgames/characters
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Characters of the iDosGames platform in one standard for games and videos.
+
+| Subpath | What | Peers |
+| --- | --- | --- |
+| `@idosgames/characters` | the actor contract (emotions, mouth visemes, poses, sockets, style families), lip-sync from text, language, seeded random | — |
+| `@idosgames/characters/voxel` | voxel characters: `CharacterSpec` recipes (skeleton template, boxes on bones, palette, pixel faces), the model, animator, emotions, emotes, `VoxelActor` | `three` |
+| `@idosgames/characters/rig2d` | layered 2D characters on a skeleton with the full wardrobe (clothes, hair, weapons, shields, helmets…) in vector art, the canvas renderer, AI recipes (`parseRig2dRecipe`) | — |
+| `@idosgames/characters/rig2d/three` | the 2D character in a three.js scene (`Rig2dView`) | `three` |
+| `@idosgames/characters/rig2d/phaser` | the 2D character on Phaser | `phaser` |
+| `@idosgames/characters/rig2d/editor` | the 2D character editor | `react`, `phaser` |
+| `@idosgames/characters/gltf` | GLB characters on the `humanoid-v1` skeleton: loading, the contract check, the shared clip library, face shape keys | `three` |
+
+Every actor takes the same commands — `setEmotion`, `setViseme`, a pose, a prop on a socket — and
+moves only by `update(dt)`, so a video stepped by its own clock renders the same frame every time.
+
+```ts
+import { layoutSpeech, visemeAt } from "@idosgames/characters";
+import { createCatalog, heroRig, HERO_ANIMATIONS } from "@idosgames/characters/rig2d";
+import { Rig2dView } from "@idosgames/characters/rig2d/three";
+
+const hero = new Rig2dView({ rig: heroRig, catalog: createCatalog(), seed: 7 });
+scene.add(hero.root);
+await hero.ready();
+hero.play(HERO_ANIMATIONS.talk);
+hero.setEmotion("happy");
+
+const speech = layoutSpeech("Ты опять съел мой обед?", 2.1);
+// each frame: hero.setViseme(visemeAt(speech.visemes, t)); hero.update(1 / 30);
+```
+
+Why a package and not a module: it is a data format with its runtime that several catalog modules
+share (voxelcraft, idle-rpg, video-studio). A project extends it with data — its own recipes and part
+packs — never by copying its source. See the "Package or module" rule in the repository's CLAUDE.md.

package/dist/PartsManager-CAVBKvp6.d.ts

@@ -0,0 +1,589 @@
+import { E as Emotion, V as Viseme } from './contract-DhZuKNIf.js';
+
+/** A kind of part — "Hair", "Hat", "Weapon". Declared by a rig (rigs/{rig}/parts.ts). */
+type PartTypeId = string;
+/** A bone or slot by its name in the skeleton data ("head", "hand_far"). */
+type BoneId = string;
+/** What a colour paints — "Skin", "Hair", "Beard", "Brow". Declared by a rig. */
+type ColorTargetId = string;
+/** An image of the art, by the path attachments name it ("top/top_12", "arm_l"). */
+type ArtId = string;
+/** A colour as "#rrggbb". */
+type Hex = string;
+declare const WHITE: Hex;
+/** "#rrggbb" → 0xrrggbb (what Phaser's tint takes). Anything unreadable is white. */
+declare function hexToNumber(hex: Hex): number;
+declare function numberToHex(color: number): Hex;
+/** An RGBA colour, 0..1 per channel (slot and attachment colours). */
+interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** "rrggbbaa" (or "rrggbb") → Color. */
+declare function colorOf(hex: string | undefined): Color;
+
+interface ArtDef {
+    /** SVG markup (no <svg> wrapper), in the image's px: 0..width × 0..height, y down. */
+    svg: string;
+    /** The art paints part of itself with `currentColor` (an iris): this is its colour unless a colour
+     *  target drawn into the art (ColorTargetDef.into "art") gives another. */
+    paint?: string;
+}
+/** How an image is drawn this time: the colour of its painted part, the light on it. */
+interface ArtStyle {
+    /** The colour of its `currentColor` part (an iris); omitted — art.paint. */
+    paint?: string | null;
+    /** Towards the light in its pixels (core/shading); omitted — not shaded. */
+    light?: {
+        x: number;
+        y: number;
+    } | null;
+}
+interface ArtPack {
+    id: string;
+    art: Readonly<Record<ArtId, ArtDef>>;
+}
+declare class ArtCatalog {
+    private readonly art;
+    constructor(packs?: readonly ArtPack[]);
+    /** Adds a pack; an image already present is replaced (a later pack overrides). */
+    register(pack: ArtPack): this;
+    get(path: ArtId): ArtDef | undefined;
+    has(path: ArtId): boolean;
+    ids(): ArtId[];
+}
+
+declare const LOOK_VERSION = 1;
+interface CharacterLook {
+    v: typeof LOOK_VERSION;
+    /** Type → part id; null — taken off. A missing type is left as it is. */
+    parts?: Partial<Record<PartTypeId, string | null>>;
+    colors?: Partial<Record<ColorTargetId, Hex>>;
+}
+/** Later looks win, type by type and colour by colour (a sword over a class's default weapon). */
+declare function mergeLooks(...looks: ReadonlyArray<CharacterLook | null | undefined>): CharacterLook;
+/** A look from untrusted JSON (custom data, a pasted preset); null when it is not one. */
+declare function parseLook(value: unknown): CharacterLook | null;
+
+interface Constraint {
+    readonly data: ConstraintData;
+    setupPose(): void;
+    sort(sk: Skeleton): void;
+    update(sk: Skeleton): void;
+}
+
+declare class BonePose {
+    readonly bone: Bone;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    shearX: number;
+    shearY: number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    worldX: number;
+    worldY: number;
+    /** == the skeleton's update counter: the world is current / the local must be re-derived. */
+    world: number;
+    local: number;
+    constructor(bone: Bone);
+    copyLocal(from: BonePose): void;
+    update(sk: Skeleton): void;
+    updateWorldTransform(sk: Skeleton): void;
+    /** World → local (after a constraint moved the world matrix). */
+    updateLocalTransform(sk: Skeleton): void;
+    private set5;
+    /** The local pose is about to be edited (IK): the world becomes stale. */
+    modifyLocal(sk: Skeleton): void;
+    /** The world is about to be edited (a transform constraint): the local is re-derived on demand. */
+    modifyWorld(sk: Skeleton): void;
+    private resetWorld;
+}
+declare class Bone {
+    readonly data: BoneData;
+    readonly pose: BonePose;
+    readonly applied: BonePose;
+    parent: Bone | null;
+    readonly children: Bone[];
+    sorted: boolean;
+    constructor(data: BoneData);
+    setupPose(): void;
+}
+declare class Slot {
+    readonly data: SlotData;
+    readonly bone: Bone;
+    readonly color: Color;
+    /** The key of the shown attachment (what timelines switch), null — none. */
+    attachmentKey: string | null;
+    attachment: Attachment | null;
+    constructor(data: SlotData, bone: Bone);
+}
+declare class Skeleton {
+    readonly data: SkeletonData;
+    readonly bones: Bone[];
+    readonly slots: Slot[];
+    readonly constraints: Constraint[];
+    /** The skins worn, combined: a later skin's attachment wins for the same slot and key. */
+    private skins;
+    scaleX: number;
+    scaleY: number;
+    x: number;
+    y: number;
+    updateId: number;
+    private cache;
+    constructor(data: SkeletonData);
+    bone(name: string): Bone;
+    slot(name: string): Slot;
+    setSkins(skins: readonly Skin[]): void;
+    getAttachment(slotIndex: number, key: string): Attachment | null;
+    /** Re-reads every slot's attachment from its key (after a skin or key change). */
+    resolveAttachments(): void;
+    /** Bones, constraints and slots back to the setup pose (what animation then writes over). */
+    setupPose(): void;
+    updateWorldTransform(): void;
+    /** The update order: parents before children, constraints where they read and write. */
+    private updateCache;
+    sortBone(bone: Bone): void;
+    sortReset(bones: readonly Bone[]): void;
+    pushConstraint(c: Constraint): void;
+}
+
+interface AnimationEventKey {
+    time: number;
+    name: string;
+}
+interface Timeline {
+    /** The bone or slot it writes (for overlays that take only some timelines). */
+    readonly bone?: number;
+    readonly slot?: number;
+    apply(sk: Skeleton, time: number): void;
+}
+/** Which bones and slots (by index) an overlay takes from an animation. */
+interface TimelineFilter {
+    bones: ReadonlySet<number>;
+    slots: ReadonlySet<number>;
+}
+declare class Animation {
+    readonly name: string;
+    readonly duration: number;
+    private readonly timelines;
+    readonly events: AnimationEventKey[];
+    constructor(name: string, duration: number, timelines: Timeline[], events: AnimationEventKey[]);
+    /** Writes the animation at `time` into the skeleton's pose (call after skeleton.setupPose()). */
+    apply(sk: Skeleton, time: number): void;
+    /** Only the timelines of the filter's bones and slots (an overlay, e.g. the blink). */
+    applyOnly(sk: Skeleton, time: number, filter: TimelineFilter): void;
+    /** Does it animate any of the filter's bones or slots. */
+    touches(filter: TimelineFilter): boolean;
+}
+
+interface BoneData {
+    index: number;
+    name: string;
+    parent: BoneData | null;
+    children: BoneData[];
+    length: number;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+}
+interface SlotData {
+    index: number;
+    name: string;
+    bone: BoneData;
+    /** The attachment key shown in the setup pose, null — none. */
+    attachment: string | null;
+    color: Color;
+}
+type TransformProp = "rotate" | "x" | "y" | "scaleX" | "scaleY" | "shearY";
+interface ToProperty {
+    prop: TransformProp;
+    offset: number;
+    max: number;
+    scale: number;
+}
+interface FromProperty {
+    prop: TransformProp;
+    offset: number;
+    to: ToProperty[];
+}
+interface IkData {
+    type: "ik";
+    index: number;
+    name: string;
+    bones: BoneData[];
+    target: BoneData;
+    mix: number;
+    bendDirection: 1 | -1;
+}
+interface TransformData {
+    type: "transform";
+    index: number;
+    name: string;
+    source: BoneData;
+    bones: BoneData[];
+    offsets: Record<TransformProp, number>;
+    mix: Record<TransformProp, number>;
+    properties: FromProperty[];
+}
+type ConstraintData = IkData | TransformData;
+interface RegionAttachment {
+    type: "region";
+    /** The key slots and timelines use ("top", "weapon_shot"). */
+    key: string;
+    /** The image it draws ("top/top_12") — the art is looked up by it. */
+    path: string;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    width: number;
+    height: number;
+    color: Color;
+}
+interface MeshAttachment {
+    type: "mesh";
+    key: string;
+    path: string;
+    /** u, v per vertex, 0..1 over the image, v down. */
+    uvs: Float32Array;
+    triangles: Uint16Array;
+    /** Plain: x, y per vertex in the slot bone's space. Weighted: per vertex n, then n × (bone, x, y, weight). */
+    vertices: Float32Array;
+    weighted: boolean;
+    vertexCount: number;
+    width: number;
+    height: number;
+    color: Color;
+}
+type Attachment = RegionAttachment | MeshAttachment;
+interface Skin {
+    name: string;
+    /** Per slot index: attachment key → attachment. */
+    attachments: Map<number, Map<string, Attachment>>;
+}
+interface SkeletonData {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    bones: BoneData[];
+    slots: SlotData[];
+    constraints: ConstraintData[];
+    skins: Map<string, Skin>;
+    /** Skin names in the order they were given (the order ‹ › lists them). */
+    skinOrder: string[];
+    animations: Map<string, Animation>;
+    events: string[];
+    bone(name: string): BoneData;
+    slot(name: string): SlotData;
+}
+type Json = any;
+declare function readSkeletonData(json: Json): SkeletonData;
+/** Every image the skins use, with its size (the attachment's width × height) — what art is drawn on. */
+declare function imageSizes(data: SkeletonData): ReadonlyMap<string, {
+    w: number;
+    h: number;
+}>;
+/** The images a skin draws. */
+declare function skinImages(data: SkeletonData, skinName: string): string[];
+
+interface PlayOptions {
+    /** Default true (loops). */
+    loop?: boolean;
+    speed?: number;
+    /** Cross-fade seconds; default the rig's mix. 0 — cut. */
+    mix?: number;
+    /** Start this many seconds in. */
+    from?: number;
+}
+interface AnimationEvent {
+    /** An event of the animation ("Attack", "Step", "Hit", "Die") or "end" when a non-looping one finishes. */
+    name: string;
+    animation: string;
+}
+type Listener$1 = (e: AnimationEvent) => void;
+interface BlinkOptions {
+    /** The animation the blink is cut from, and the window of it. */
+    animation: string;
+    from: number;
+    to: number;
+    /** The bones and slots it takes (by name): the eyes. */
+    bones: readonly string[];
+    slots: readonly string[];
+    /** Seconds between blinks, a random pick in [min, max]. */
+    every: readonly [number, number];
+}
+declare class Animator {
+    private readonly skeleton;
+    private readonly data;
+    readonly defaultMix: number;
+    private track;
+    private previous;
+    private mixTime;
+    private mixDuration;
+    private readonly listeners;
+    private readonly snapshot;
+    private readonly slotSnapshot;
+    private readonly ikSnapshot;
+    private blink;
+    constructor(skeleton: Skeleton, data: SkeletonData, defaultMix?: number);
+    /** Turns the blink overlay on (null — off). */
+    setBlink(options: BlinkOptions | null): void;
+    /** Blink now (the overlay must be on). */
+    blinkNow(): void;
+    /** Is the overlay mid-blink. */
+    blinking(): boolean;
+    /** The source of chance for the blink (default Math.random); a video passes a seeded one so a
+     *  frame is the same on every render. */
+    setRandom(random: () => number): void;
+    private random;
+    private nextBlink;
+    names(): string[];
+    has(name: string): boolean;
+    play(name: string, options?: PlayOptions): boolean;
+    current(): string | null;
+    /** Seconds into the current animation. */
+    time(): number;
+    duration(): number;
+    finished(): boolean;
+    setSpeed(speed: number): void;
+    /** An event by name, "end", or "*" for all. Returns the unsubscribe. */
+    on(name: string, listener: Listener$1): () => void;
+    /** Advances by dt seconds, fires the events passed, and writes the pose into the skeleton. */
+    update(dt: number): void;
+    /** Rebuilds the pose for the current times (no time passes). */
+    pose(): void;
+    private advanceBlink;
+    private local;
+    /** Events in [from, to) of the track's time, unrolled over loops. */
+    private collect;
+    private save;
+    /** current = saved + (current − saved) × alpha; rotation the short way round. */
+    private blendFromSaved;
+}
+
+interface RuleView {
+    /** The worn skin of a type (null — none), after the player's choice and the hidden flag. */
+    worn(type: PartTypeId): string | null;
+    /** Replaces what a type contributes to the character (null — nothing). */
+    setWorn(type: PartTypeId, skin: string | null): void;
+    /** Does the data have this skin. */
+    exists(skin: string): boolean;
+}
+interface PartsRule {
+    id: string;
+    apply(view: RuleView): void;
+}
+/**
+ * Under a covering part a part is replaced by its variant of the same number: hair under a
+ * hat becomes its tucked-in twin. The variant is found by name — "hair/5" → "hair_under/5".
+ */
+declare function swapUnder(options: {
+    type: PartTypeId;
+    under: PartTypeId;
+    variant: PartTypeId;
+    /** Turns the type's skin name into the variant's. */
+    rename: (skin: string) => string;
+}): PartsRule;
+/** A part that takes both hands puts the other hand's part away while it is worn (a bow, a musket:
+ *  no shield). The other part stays chosen — it is back as soon as a one-handed part is. */
+declare function bothHands(options: {
+    type: PartTypeId;
+    other: PartTypeId;
+    skins: ReadonlySet<string>;
+}): PartsRule;
+
+interface ShadingDef {
+    /** Towards the light, in the character's world (y up) — (-0.5, 1) is from the upper left. */
+    light: readonly [number, number];
+    /** Images whose path starts with one of these are not shaded (the face). */
+    skip?: readonly string[];
+}
+
+interface PartTypeDef {
+    id: PartTypeId;
+    label: string;
+    /** Its skins are the data's skins whose name starts with this ("hair/"). */
+    skinPrefix: string;
+    /** Can be taken off — ‹ › then pass through "none". */
+    canHide: boolean;
+    /** The colour that paints it (multiplied over its slots), when it takes one. */
+    colorTarget?: ColorTargetId;
+    /** Owned by the rules (hat hair): never chosen directly, not part of a look. */
+    auto?: boolean;
+}
+interface ColorTargetDef {
+    id: ColorTargetId;
+    label: string;
+    /** Slots whose name starts with one of these take the colour. */
+    slotPrefixes: readonly string[];
+    /** How it paints: "tint" (default) multiplies over the whole slot; "art" is drawn into the image
+     *  where the art says `currentColor` — an iris takes the eye colour, the whites stay white. */
+    into?: "tint" | "art";
+}
+/** Faces a character makes by itself: an animation puts one on, its
+ *  skins replace the chosen ones of those types while it plays. */
+interface ExpressionsDef {
+    /** Expression → skin per part type ("Angry": brows down, teeth bared). */
+    faces: Readonly<Record<string, Readonly<Record<PartTypeId, string>>>>;
+    /** Animation → expression; an animation not listed shows the chosen face. */
+    byAnimation: Readonly<Record<string, string>>;
+    /** An emotion of the actor contract → expression (`setEmotion`); under the animation's own face. */
+    emotions?: Readonly<Partial<Record<Emotion, string>>>;
+    /** Speech: the mouth part type and the skin each viseme puts on it (`setSpeech`); "rest" — the
+     *  chosen mouth. Over every other face: a talking hero talks even while angry. */
+    speech?: {
+        type: PartTypeId;
+        visemes: Readonly<Partial<Record<Viseme, string>>>;
+    };
+}
+/** A group of part types in a character editor (the demo's FACE and BODY panels). */
+interface EditorGroup {
+    id: string;
+    label: string;
+    /** Its tiles, in order. */
+    types: readonly PartTypeId[];
+    /** How its tiles picture a part. */
+    thumbnail?: {
+        /** Only these slots are drawn (the face, not the whole body the skin part also covers). */
+        slots?: readonly string[];
+        /** Drawn behind as a dark silhouette, and the picture framed on it (a head under the eyes). */
+        backdrop?: {
+            skin: string;
+            slots: readonly string[];
+        };
+    };
+}
+interface RigDef {
+    id: string;
+    data: SkeletonData;
+    partTypes: readonly PartTypeDef[];
+    colorTargets: readonly ColorTargetDef[];
+    rules: readonly PartsRule[];
+    /** The animation played when nothing else is asked. */
+    defaultAnimation: string;
+    /** Cross-fade between animations, seconds. */
+    mix: number;
+    /** Bones a game reads by role — where a shot leaves, what a bar sits over. */
+    anchors: Readonly<Record<string, BoneId>>;
+    /** The blink played over animations that do not move the eyes (none — no overlay). */
+    blink?: BlinkOptions;
+    /** The animation actually played for one asked while these parts are worn — a stance of its own
+     *  for what is held (an idle with a rifle in both hands); omitted — always the one asked. */
+    stance?: (animation: string, worn: (type: PartTypeId) => string | null) => string;
+    /** Shading over the art (a dark side, a light rim); omitted — flat colours. */
+    shading?: ShadingDef;
+    /** Faces put on by animations; omitted — the chosen face always. */
+    expressions?: ExpressionsDef;
+    /** How an editor lays the parts out; omitted — one group of every type. */
+    editor?: {
+        groups: readonly EditorGroup[];
+    };
+}
+/** Checks a rig's references once, at load: a typo fails loudly here. */
+declare function defineRig(rig: RigDef): RigDef;
+
+type Rng = () => number;
+declare function seededRandom(seed: number): Rng;
+/** A seed from a string (an id). */
+declare function seedOf(text: string): number;
+declare function pick<T>(rng: Rng, list: readonly T[]): T | undefined;
+
+type PartsChange = {
+    kind: "part";
+    type: PartTypeId;
+    skin: string | null;
+} | {
+    kind: "hidden";
+    type: PartTypeId;
+    hidden: boolean;
+} | {
+    kind: "color";
+    target: ColorTargetId;
+    color: Hex | null;
+} | {
+    kind: "expression";
+    name: string | null;
+} | {
+    kind: "speech";
+    viseme: Viseme;
+};
+type Listener = (change: PartsChange) => void;
+declare class PartsManager {
+    readonly rig: RigDef;
+    private drawable;
+    private readonly chosen;
+    private readonly hidden;
+    private readonly colors;
+    private readonly lists;
+    private readonly listeners;
+    private readonly slotTarget;
+    private readonly slotArt;
+    private face;
+    private emotionFace;
+    private speech;
+    constructor(rig: RigDef, drawable?: (skin: string) => boolean);
+    /** The art changed (a pack added, another art source): recompute what each type offers. */
+    setDrawable(drawable: (skin: string) => boolean): void;
+    on(listener: Listener): () => void;
+    private emit;
+    typeDef(type: PartTypeId): PartTypeDef | undefined;
+    /** The skins a type offers, in the data's order. */
+    list(type: PartTypeId): readonly string[];
+    count(type: PartTypeId): number;
+    /** The chosen skin (null — none), whether hidden or not. */
+    part(type: PartTypeId): string | null;
+    /** Its index in `list`, -1 — none. */
+    index(type: PartTypeId): number;
+    isHidden(type: PartTypeId): boolean;
+    /** Chosen and not hidden — what a game asks ("is a weapon in hand?"). */
+    isWorn(type: PartTypeId): boolean;
+    color(target: ColorTargetId): Hex | null;
+    /** The skins to combine, in the rig's type order (a later one wins on the same attachment). */
+    wornSkins(): string[];
+    /** The colour a slot is painted with (replacing its animated colour), null — its own. */
+    slotColor(slotIndex: number): Hex | null;
+    /** The colour drawn into a slot's art (its `currentColor`), null — the art's own. */
+    artColor(slotIndex: number): Hex | null;
+    /** The expression on now (null — the chosen face). */
+    expression(): string | null;
+    /** Puts on a skin by index in `list` or by name; -1 / null — none. Unknown names are ignored. */
+    equip(type: PartTypeId, part: number | string | null): void;
+    unequip(type: PartTypeId): void;
+    /** Hides or shows a part, keeping which one. */
+    setHidden(type: PartTypeId, hidden: boolean): void;
+    /** The next part: a type that can be taken off goes … → last → none → first → … */
+    next(type: PartTypeId): void;
+    prev(type: PartTypeId): void;
+    /** Paints a target (null — back to the art's own colours). */
+    setColor(target: ColorTargetId, color: Hex | null): void;
+    /** Puts on an expression of the rig (null — back to the chosen face). Not part of a look. */
+    setExpression(name: string | null): void;
+    /** Puts on the face of an emotion (the rig's `expressions.emotions`); "neutral" — the chosen face.
+     *  An animation's own face still wins while it plays. Not part of a look. */
+    setEmotion(emotion: Emotion): void;
+    /** The mouth's shape while speaking (lip-sync); "rest" — the chosen mouth. Not part of a look. */
+    setSpeech(viseme: Viseme): void;
+    /** Every type a random part, one that can be taken off — none 30% of the time. */
+    randomize(rng?: Rng): void;
+    /** The first skin of every type, nothing hidden, the art's own colours. */
+    reset(): void;
+    toLook(): CharacterLook;
+    /** Puts a look on. A skin the art cannot draw is skipped (what is worn stays). */
+    applyLook(look: CharacterLook): void;
+    private rebuildLists;
+    private first;
+    private init;
+}
+
+export { ArtCatalog as A, type BlinkOptions as B, type CharacterLook as C, defineRig as D, type EditorGroup as E, hexToNumber as F, imageSizes as G, type Hex as H, mergeLooks as I, numberToHex as J, parseLook as K, LOOK_VERSION as L, pick as M, readSkeletonData as N, seedOf as O, PartsManager as P, seededRandom as Q, type RigDef as R, Skeleton as S, skinImages as T, swapUnder as U, WHITE as W, Animator as a, type PlayOptions as b, type AnimationEvent as c, Slot as d, type Attachment as e, type ArtPack as f, type ArtDef as g, type ArtStyle as h, Animation as i, type ArtId as j, Bone as k, type BoneId as l, type Color as m, type ColorTargetDef as n, type ColorTargetId as o, type ExpressionsDef as p, type PartTypeDef as q, type PartTypeId as r, type PartsChange as s, type PartsRule as t, type Rng as u, type RuleView as v, type SkeletonData as w, type Skin as x, bothHands as y, colorOf as z };