wobnimo 0.0.0-stage → 0.1.0

package/dist/status-DVudJbtp.d.ts

@@ -0,0 +1,197 @@
+import { E as Expression, B as BoneSpec, b as Channel, a as Axis, g as Motion, V as Vec3, C as CharacterSpec, H as Hex } from './types-PAZ6PnKv.js';
+
+declare const STATES: readonly ["idle", "thinking", "listening", "speaking", "sleeping", "working", "error", "surprised", "celebrating", "sad"];
+type MascotState = (typeof STATES)[number];
+/** Every expression a face can show: the states plus the reaction to a poke. */
+declare const EXPRESSIONS: readonly Expression[];
+
+interface ResolvedBone extends BoneSpec {
+    index: number;
+    parentIndex: number;
+}
+declare class SpecError extends Error {
+    constructor(character: string, message: string);
+}
+
+type Mat4 = Float32Array;
+
+type Channels = Record<Channel, number> & {
+    /** Scales idle waves: low when asleep, high when excited. */
+    energy: number;
+};
+/** Per bone: per expression, per axis, a motion. */
+type BoneActing = Array<Array<[Expression, Axis, Motion]>>;
+declare class Rig {
+    private readonly bones;
+    private readonly acting;
+    readonly world: Mat4[];
+    /** World → bone, packed for upload: 16 floats per bone. */
+    readonly inverse: Float32Array;
+    private readonly tips;
+    /** Spin accumulated by acting, per bone and axis. */
+    private readonly spun;
+    private readonly scratch;
+    constructor(bones: ResolvedBone[], acting?: BoneActing);
+    /** A point in a bone's space, in world space, as of the last update. */
+    point(bone: number, at: Vec3): Vec3;
+    /**
+     * Poses the skeleton. `root` places the whole character, `weights` blends
+     * each expression's acting, `dt` steps the jiggle springs and spins.
+     */
+    update(root: Mat4, ch: Channels, weights: Record<Expression, number>, time: number, dt: number): void;
+    private jiggle;
+}
+
+interface CompiledCharacter {
+    spec: CharacterSpec;
+    bones: ResolvedBone[];
+    acting: BoneActing;
+    anchors: Record<string, {
+        bone: number;
+        at: Vec3;
+    }>;
+    fragment: string;
+    /** Material names, in the order of their colours in `albedo`. */
+    materials: string[];
+    /** The spec's material colours, linear RGB, three floats each. */
+    albedo: Float32Array;
+    stats: {
+        parts: number;
+        bones: number;
+        materials: number;
+        shaderLines: number;
+    };
+}
+declare function compile(spec: CharacterSpec): CompiledCharacter;
+
+/** New colours for materials, by name. Unknown names are an error, so typos don't fail silently. */
+type Palette = Record<string, Hex>;
+/** A copy of the spec with new material colours (and their shades). */
+declare function recolor(spec: CharacterSpec, palette: Palette): CharacterSpec;
+/**
+ * The compiled character's colours with a palette applied, ready for the
+ * renderer. Colours are uniforms, so this is how a live mascot recolours
+ * without building a new shader.
+ */
+declare function albedo(character: CompiledCharacter, palette: Palette | undefined): Float32Array;
+/**
+ * A new character from an existing one: a different id and name, colours,
+ * temperament, or anything else at the top level of the spec.
+ */
+declare function variant(spec: CharacterSpec, changes: Partial<Omit<CharacterSpec, 'materials'>> & {
+    palette?: Palette;
+}): CharacterSpec;
+/** Identity, typed: write a spec with full autocompletion and checking. */
+declare const defineCharacter: (spec: CharacterSpec) => CharacterSpec;
+
+interface Animated {
+    /** Whether it is worth drawing this frame (on screen, not settled). */
+    readonly active: boolean;
+    tick(dt: number, time: number, quality: number): void;
+}
+
+interface MascotOptions {
+    /** Where it starts. Default `idle`. */
+    state?: MascotState;
+    /** 0–1. Desyncs blinks, glances and hops between mascots on one page. Random by default. */
+    seed?: number;
+    /** Follow the pointer and hop when clicked. Default true. */
+    interactive?: boolean;
+    /** Effects around the character (z's, sparkles, sound waves…). Default true. */
+    effects?: boolean;
+    /** Multiplies the pace of everything. Default 1. */
+    speed?: number;
+    /** Recolour materials by name, e.g. `{ shell: '#e0457b' }`. */
+    palette?: Palette;
+    /** Cap on device pixels per CSS pixel. Default 2. */
+    maxPixelRatio?: number;
+    /** The floor shadow's colour, linear RGB. */
+    shadow?: Vec3;
+    /** Strength of the floor shadow, 0–1. 0 suits a mascot laid over text or a busy background. Default 1. */
+    floor?: number;
+    /** Overall brightness. Default 1. */
+    exposure?: number;
+    /** Room around the character: 1 fits it snugly, larger values make it smaller in its canvas. Default 1. */
+    framing?: number;
+    /** Respect `prefers-reduced-motion`: hold the state's pose instead of animating. Default true. */
+    respectReducedMotion?: boolean;
+}
+interface MascotEvents {
+    /** Clicked or poked. */
+    poke: void;
+    state: MascotState;
+    /** The first frame is on screen: its shader is built. Fade it in from here. */
+    ready: void;
+}
+type Listener<T> = (value: T) => void;
+declare function compileCached(spec: CharacterSpec): CompiledCharacter;
+declare class Mascot implements Animated {
+    readonly canvas: HTMLCanvasElement;
+    private character;
+    private brain;
+    private rig;
+    private fx;
+    private readonly renderer;
+    private readonly options;
+    private readonly seed;
+    private palette;
+    private albedo;
+    private visible;
+    private paused;
+    private time;
+    private readonly reducedMotion;
+    private stillFrames;
+    private drawn;
+    private readonly listeners;
+    private readonly cleanup;
+    private source;
+    constructor(canvas: HTMLCanvasElement, spec: CharacterSpec, options?: MascotOptions);
+    get state(): MascotState;
+    /** The spec as given; a palette doesn't change it. */
+    get spec(): CharacterSpec;
+    get stats(): {
+        parts: number;
+        bones: number;
+        materials: number;
+        shaderLines: number;
+    };
+    setState(state: MascotState): void;
+    /** Swaps the character, keeping the state. Material names differ between characters, so the palette resets unless you pass one. */
+    setSpec(spec: CharacterSpec, palette?: Palette): void;
+    /** Recolours materials by name; `undefined` goes back to the spec's own colours. Cheap enough for a colour picker. */
+    setPalette(palette: Palette | undefined): void;
+    setSpeed(speed: number): void;
+    setEffects(on: boolean): void;
+    /** The happy reaction: a hop with a spin. */
+    poke(): void;
+    pause(): void;
+    play(): void;
+    /** Subscribes to an event; returns the unsubscribe function. */
+    on<K extends keyof MascotEvents>(event: K, listener: Listener<MascotEvents[K]>): () => void;
+    get active(): boolean;
+    tick(dt: number, _time: number, quality: number): void;
+    /** Whether the first frame has been drawn. */
+    get ready(): boolean;
+    dispose(): void;
+    private load;
+    private get still();
+    private emit;
+    private label;
+    private listen;
+}
+/**
+ * The shortest way in: creates a canvas that fills `container` and puts a
+ * mascot on it. `dispose()` removes the canvas again.
+ */
+declare function mount(container: HTMLElement, spec: CharacterSpec, options?: MascotOptions): Mascot;
+
+/** The chat statuses the AI SDK emits, and anything close enough to map. */
+type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error' | 'idle';
+/**
+ * Drives a mascot from a chat `status`. Call it whenever the status changes
+ * (in React, inside an effect on `status`). When a turn finishes (`ready`)
+ * the mascot celebrates for `celebrateMs`, then settles to idle.
+ */
+declare function driveFromStatus(mascot: Mascot, status: ChatStatus, celebrateMs?: number): void;
+
+export { type ChatStatus as C, EXPRESSIONS as E, type MascotOptions as M, type Palette as P, Rig as R, STATES as S, type MascotState as a, type Mat4 as b, type Channels as c, type CompiledCharacter as d, Mascot as e, type MascotEvents as f, SpecError as g, albedo as h, compile as i, compileCached as j, defineCharacter as k, driveFromStatus as l, mount as m, recolor as r, variant as v };

package/dist/types-PAZ6PnKv.d.ts

@@ -0,0 +1,308 @@
+type Vec2 = [number, number];
+type Vec3 = [number, number, number];
+/** A colour as `#rrggbb`, in sRGB. */
+type Hex = string;
+/** The channels the behaviour layer drives every frame. Bones map them onto rotations. */
+type Channel = 'yaw' | 'pitch' | 'roll' | 'flap' | 'talk';
+type Axis = 'rx' | 'ry' | 'rz';
+interface CharacterSpec {
+    id: string;
+    name: string;
+    /** One line on what makes this body plan different, for humans and agents. */
+    tagline: string;
+    /** The UI accent that goes with the character. */
+    accent: Hex;
+    /** How the camera frames the character: the height it looks at and the radius it must fit. */
+    frame: {
+        target: number;
+        radius: number;
+    };
+    /** The volume every ray is clipped to, as a sphere above the root: centre height and radius. */
+    bound: {
+        y: number;
+        radius: number;
+    };
+    motion?: Partial<Temperament>;
+    materials: Record<string, MaterialSpec>;
+    bones: BoneSpec[];
+    parts: PartSpec[];
+    paints?: PaintSpec[];
+    eyes?: EyesSpec;
+    face?: FaceSpec;
+    /** Named points on the body that effects come from: `top`, `mouth`, `ear`, `feet`, or your own. */
+    anchors?: Record<string, AnchorSpec>;
+    /** How each state moves each bone, on top of the rig. This is where a character acts. */
+    acting?: Partial<Record<Expression, Record<string, Partial<Record<Axis, Motion>>>>>;
+    /** Effects around the character, added to (or, with `replace`, instead of) the shared defaults. */
+    fx?: FxSpec;
+    /** The state's light spills onto the floor in a soft pool. */
+    glowPool?: number;
+}
+/** Every state a character can be in, plus the short happy reaction to a poke. */
+type Expression = 'idle' | 'thinking' | 'listening' | 'speaking' | 'sleeping' | 'working' | 'error' | 'surprised' | 'celebrating' | 'sad' | 'happy';
+/**
+ * A rotation over time: `base + amp · sin(2π · hz · t + phase)`, plus `spin`
+ * radians per second accumulated for as long as the state lasts.
+ * A bare number is a held angle.
+ */
+type Motion = number | [base: number, amp?: number, hz?: number, phase?: number, spin?: number];
+interface AnchorSpec {
+    bone: string;
+    at: Vec3;
+}
+/** The shapes an effect particle can take. */
+type Glyph = 'z' | 'bubble' | 'sparkle' | 'heart' | 'note' | 'arc' | 'puff' | 'ring' | 'drop' | 'spark' | 'mote' | 'feather' | 'dot' | 'exclaim' | 'warning' | 'confetti' | 'cloud' | 'star' | 'gear';
+/** When an emitter fires: continuously in a state, always, or on a beat of the animation. */
+type FxTrigger = Expression | 'ambient' | 'land' | 'syllable' | `enter:${Expression}`;
+interface EmitterSpec {
+    glyph: Glyph;
+    anchor: string;
+    /** Particles per second while active, or how many at once for an event. */
+    rate: number;
+    /** Where particles start, relative to the anchor, and how far apart. */
+    offset?: Vec3;
+    spread?: number;
+    /** Starting velocity, units per second, with random variation. */
+    velocity: Vec3;
+    jitter?: number;
+    /** Mirror half the particles across x (sound from both sides of a mouth). */
+    mirror?: boolean;
+    gravity?: number;
+    drag?: number;
+    /** Side-to-side drift, like a bubble or a falling feather. */
+    wobble?: number;
+    life: [number, number];
+    /** Size at birth and at death. */
+    size: [number, number];
+    /** Starting angle and spin, radians and radians per second. */
+    rotation?: number;
+    spin?: number;
+    /** Point along the direction of travel: sparks streak, drops trail their tips. */
+    align?: boolean;
+    color: Hex;
+    /** Adds light instead of covering what is behind it. */
+    glow?: boolean;
+}
+type FxSpec = Partial<Record<FxTrigger, EmitterSpec[]>> & {
+    replace?: FxTrigger[];
+};
+/** How a character moves, independent of what it looks like. */
+interface Temperament {
+    /** Resting height above the floor; above zero the character floats. */
+    float: number;
+    /** How high a hop goes. */
+    hop: number;
+    /** Multiplies squash and stretch. */
+    squash: number;
+    /** Multiplies every spring's frequency: higher is snappier. */
+    snap: number;
+    /** How far the head turns toward things. */
+    look: number;
+    /** How the head moves between glances: 0 eases like a person, 1 snaps and holds like a bird. */
+    snapLook: number;
+    /** How much the body squashes on each syllable. */
+    talkSquash: number;
+}
+interface MaterialSpec {
+    color: Hex;
+    /**
+     * This material is a shade of another, by name: recolouring that one
+     * recolours this one too, keeping the same relation (a wing a little
+     * darker than the feathers, the body's fur the same as the head's).
+     */
+    shadeOf?: string;
+    /** Clear-coat reflectance face on; it rises to 1 at grazing angles. */
+    f0?: number;
+    /** Strength and tightness of the key light's highlight. */
+    spec?: number;
+    shininess?: number;
+    /** How much of the reflection takes the albedo's colour (0 plastic, 1 metal). */
+    metal?: number;
+    /** The cool back light rimming the silhouette. */
+    rim?: number;
+    /** How sharp reflections are, 0 (satin) to 1 (wet glass). */
+    gloss?: number;
+    /** Velvet sheen at grazing angles, for feathers and fuzz. */
+    sheen?: number;
+    /** Light scattered under the surface, for jelly, wax and ghosts. */
+    sss?: number;
+    sssColor?: Hex;
+    /** Light the material gives off on its own. */
+    emit?: Hex;
+    emitStrength?: number;
+    /** Takes its light from the state's glow colour: antenna bulbs, chest lamps. */
+    glows?: boolean;
+    /** Fine detail on top of the shape: fur, scales, freckles, a wet ripple. */
+    surface?: SurfaceSpec;
+}
+/**
+ * Procedural surface detail, fixed to a bone so it moves with the body.
+ * `fur`: fine fibres and soft clumps. `scales`: a pebbled hide with darker
+ * seams. `speckle`: scattered spots. `ripple`: a gentle unevenness that
+ * makes a glossy coat read as wet.
+ */
+interface SurfaceSpec {
+    kind: 'fur' | 'scales' | 'speckle' | 'ripple';
+    /** Features per unit; a mascot is about one unit tall. */
+    scale: number;
+    /** 0–1. */
+    strength?: number;
+    /** Seams for scales, spots for speckle. */
+    color?: Hex;
+    /** The bone the pattern is fixed to. Default the root. */
+    bone?: string;
+}
+interface BoneSpec {
+    name: string;
+    /** Defaults to the root, which the behaviour layer moves (hops, floats, squash). */
+    parent?: string;
+    /** Where the bone pivots, in its parent's space. */
+    pivot: Vec3;
+    /** Rotation at rest, applied before everything else. */
+    rest?: Partial<Record<Axis, number>>;
+    /** Channels added to the rotation: `{ ry: [['yaw', 0.8]] }`. */
+    drive?: Partial<Record<Axis, Array<[Channel, number]>>>;
+    /** Idle oscillation, scaled by the state's energy: amplitude, Hz, phase. */
+    wave?: Partial<Record<Axis, [number, number, number]>>;
+    /** Secondary motion: the bone's tip is a mass on a spring that lags behind its parent. */
+    jiggle?: JiggleSpec;
+}
+interface JiggleSpec {
+    /** The direction the bone points at rest, in its own space. */
+    axis: Vec3;
+    length: number;
+    /** Spring frequency in Hz and damping ratio. */
+    freq: number;
+    damping: number;
+    /** The furthest the bone may swing from rest. */
+    maxAngle?: number;
+}
+type Op = {
+    op?: 'add';
+    blend?: number;
+} | {
+    op: 'sub';
+    blend?: number;
+};
+interface PartBase {
+    bone: string;
+    material: string;
+    /** Offset and rotation inside the bone's space. */
+    at?: Vec3;
+    rot?: Vec3;
+    /**
+     * Keeps only the side of a plane that `normal` points away from, in the
+     * part's own space: `{ normal: [0, -1, 0] }` keeps the top half. Halves a
+     * beak, flattens a base.
+     */
+    clip?: {
+        normal: Vec3;
+        offset?: number;
+    };
+}
+type PartSpec = PartBase & Op & ({
+    shape: 'sphere';
+    radius: number;
+} | {
+    shape: 'ellipsoid';
+    radii: Vec3;
+} | {
+    shape: 'roundBox';
+    half: Vec3;
+    round: number;
+} | {
+    shape: 'capsule';
+    from: Vec3;
+    to: Vec3;
+    radius: number;
+} | {
+    shape: 'roundCone';
+    from: Vec3;
+    to: Vec3;
+    r1: number;
+    r2: number;
+} | {
+    shape: 'cylinder';
+    radius: number;
+    half: number;
+    round: number;
+} | {
+    shape: 'frame';
+    half: Vec2;
+    corner: number;
+    width: number;
+    depth: number;
+}
+/** A rounded rectangle extruded along z: screens, panels, plates. */
+ | {
+    shape: 'plate';
+    half: Vec2;
+    corner: number;
+    depth: number;
+}
+/** Cuts everything so far off below a wavy line: a ghost's hem. */
+ | {
+    shape: 'hem';
+    y: number;
+    amplitude: number;
+    waves: number;
+    speed: number;
+    blend: number;
+});
+/** Colour painted onto a surface in a bone's space: bellies, blush, spots. */
+interface PaintSpec {
+    bone: string;
+    on: string[];
+    color: Hex;
+    /** Softness of the edge, as a share of the size. */
+    soft?: number;
+    opacity?: number;
+    /** `sphere`: everything within `radius` of `at`. `ellipse`: projected along +z. */
+    kind: 'sphere' | 'ellipse';
+    at: Vec3;
+    radius?: number;
+    radii?: Vec2;
+}
+type EyesSpec = {
+    kind: 'ball';
+    bone: string;
+    at: [Vec3, Vec3];
+    radius: number;
+    iris: Hex;
+    /** Angular size of the iris and pupil, as the sine of their half-angle. */
+    irisSize: number;
+    pupilSize: number;
+    /** Pupil width over height; above 1 for a goat or an octopus. */
+    pupilAspect?: number;
+    /** What the lids are made of, usually the skin. */
+    lid: string;
+} | {
+    kind: 'bead';
+    bone: string;
+    at: [Vec3, Vec3];
+    radii: Vec3;
+    material: string;
+};
+type FaceSpec = {
+    /** An LED matrix on a flat screen, facing +z. */
+    kind: 'screen';
+    bone: string;
+    material: string;
+    center: Vec2;
+    half: Vec2;
+    corner: number;
+    /** The pitch of the LED grid. */
+    cell: number;
+    color: Hex;
+} | {
+    /** A painted mouth that smiles and talks. */
+    kind: 'mouth';
+    bone: string;
+    on: string[];
+    at: Vec3;
+    width: number;
+    color: Hex;
+    tongue: Hex;
+};
+
+export type { AnchorSpec as A, BoneSpec as B, CharacterSpec as C, Expression as E, FxSpec as F, Glyph as G, Hex as H, JiggleSpec as J, MaterialSpec as M, Op as O, PaintSpec as P, SurfaceSpec as S, Temperament as T, Vec3 as V, Axis as a, Channel as b, EmitterSpec as c, EyesSpec as d, FaceSpec as e, FxTrigger as f, Motion as g, PartSpec as h, Vec2 as i };