@lemoncat7/dsh-theme-xiaohei 0.3.0-alpha.23 → 0.3.2

package/lib/scene/character-idle.d.ts

@@ -0,0 +1,17 @@
+export type CharacterIdlePose = 'seated' | 'chin' | 'doze';
+export declare const CHARACTER_CHIN_DELAY = 30000;
+export declare const CHARACTER_DOZE_DELAY = 180000;
+interface IdleClock {
+    now(): number;
+    setTimeout(callback: () => void, delay: number): number;
+    clearTimeout(handle: number): void;
+}
+/** One pending deadline, no polling, no model/session state or persisted user data. */
+export declare function createCharacterIdleController(clock: IdleClock, changed: (pose: CharacterIdlePose) => void): {
+    readonly pose: CharacterIdlePose;
+    activity(): void;
+    setPaused(value: boolean): void;
+    dispose(): void;
+};
+export {};
+//# sourceMappingURL=character-idle.d.ts.map

package/lib/scene/character-idle.js

@@ -0,0 +1,65 @@
+export const CHARACTER_CHIN_DELAY = 30_000;
+export const CHARACTER_DOZE_DELAY = 180_000;
+/** One pending deadline, no polling, no model/session state or persisted user data. */
+export function createCharacterIdleController(clock, changed) {
+    let pose = 'seated';
+    let lastActivity = clock.now();
+    let timer;
+    let paused = true;
+    let disposed = false;
+    const clear = () => {
+        if (timer !== undefined)
+            clock.clearTimeout(timer);
+        timer = undefined;
+    };
+    const update = (next) => {
+        if (next !== pose) {
+            pose = next;
+            changed(next);
+        }
+    };
+    const schedule = () => {
+        clear();
+        if (paused || disposed || pose === 'doze')
+            return;
+        const deadline = pose === 'seated' ? CHARACTER_CHIN_DELAY : CHARACTER_DOZE_DELAY;
+        timer = clock.setTimeout(tick, Math.max(1, lastActivity + deadline - clock.now()));
+    };
+    function tick() {
+        timer = undefined;
+        if (paused || disposed)
+            return;
+        const elapsed = clock.now() - lastActivity;
+        update(elapsed >= CHARACTER_DOZE_DELAY ? 'doze' : elapsed >= CHARACTER_CHIN_DELAY ? 'chin' : 'seated');
+        schedule();
+    }
+    return {
+        get pose() { return pose; },
+        activity() {
+            if (paused || disposed)
+                return;
+            const now = clock.now();
+            // Pointer events can fire at 120 Hz. Update a timestamp at most once per
+            // second; never reset a timeout on each pointer movement or keystroke.
+            if (pose === 'seated' && now - lastActivity < 1000)
+                return;
+            lastActivity = now;
+            if (pose !== 'seated') {
+                update('seated');
+                schedule();
+            }
+        },
+        setPaused(value) {
+            if (disposed || value === paused)
+                return;
+            paused = value;
+            clear();
+            lastActivity = clock.now();
+            update('seated');
+            if (!paused)
+                schedule();
+        },
+        dispose() { disposed = true; clear(); },
+    };
+}
+//# sourceMappingURL=character-idle.js.map

package/lib/scene/character-layout.d.ts

@@ -0,0 +1,24 @@
+/** Pure placement policy: decoration may only occupy space outside message bounds. */
+export interface CharacterRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface CharacterLayoutInput {
+    sidebar: CharacterRect;
+    scroll: CharacterRect;
+    flow: CharacterRect;
+    viewportWidth: number;
+    viewportHeight: number;
+    controls: CharacterRect[];
+}
+export interface CharacterPlacement {
+    pose: 'seated' | 'peek' | 'halfpeek' | 'hidden';
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function resolveCharacterPlacement(input: CharacterLayoutInput): CharacterPlacement;
+//# sourceMappingURL=character-layout.d.ts.map

package/lib/scene/character-layout.js

@@ -0,0 +1,51 @@
+const hidden = { pose: 'hidden', left: 0, top: 0, width: 0, height: 0 };
+const SEATED_RATIO = 0.71;
+const PEEK_RATIO = 0.63;
+const HALF_PEEK_RATIO = 0.44;
+export function resolveCharacterPlacement(input) {
+    const { sidebar, scroll, flow, viewportWidth, viewportHeight, controls } = input;
+    // Wallpaper belongs to the viewport, not the welcome/composer dock. Reserve
+    // the same top/bottom chrome space before and after the first message.
+    const bottom = Math.min(sidebar.bottom, viewportHeight) - 148;
+    const top = Math.max(sidebar.top + 24, 96);
+    if (bottom - top < 130 || sidebar.right > flow.left)
+        return hidden;
+    const rightStart = flow.right + 56;
+    const seatedWidth = Math.min(250, scroll.right - rightStart - 20, (bottom - top) * SEATED_RATIO, 340 * SEATED_RATIO);
+    if (seatedWidth >= 190) {
+        const height = seatedWidth / SEATED_RATIO;
+        return { pose: 'seated', left: scroll.right - seatedWidth - 16,
+            top: top + (bottom - top - height) * 0.6, width: seatedWidth, height };
+    }
+    const avatarInset = viewportWidth > 760 ? 52 : 0;
+    const freeGap = flow.left - avatarInset - sidebar.right;
+    if (freeGap >= 66) {
+        const width = Math.min(104, freeGap - 12, (bottom - top) * PEEK_RATIO);
+        const height = width / PEEK_RATIO;
+        return { pose: 'peek', left: sidebar.right - 6,
+            top: top + Math.min(160, (bottom - top - height) * 0.5), width, height };
+    }
+    // A collapsed rail has a large blank region between navigation and Settings.
+    // Use that region only after excluding every real interactive control.
+    if (sidebar.right - sidebar.left > 100)
+        return hidden;
+    const left = sidebar.left + 7;
+    const width = Math.min(60, flow.left - avatarInset - left - 10);
+    if (width < 40)
+        return hidden;
+    const height = width / HALF_PEEK_RATIO;
+    const blocked = controls.filter(r => r.right > left && r.left < left + width)
+        .map(r => ({ start: Math.max(top, r.top - 12), end: Math.min(bottom, r.bottom + 12) }))
+        .filter(r => r.end > r.start).sort((a, b) => a.start - b.start);
+    let cursor = top;
+    let best = { start: top, end: top };
+    for (const block of [...blocked, { start: bottom, end: bottom }]) {
+        if (block.start - cursor > best.end - best.start)
+            best = { start: cursor, end: block.start };
+        cursor = Math.max(cursor, block.end);
+    }
+    if (best.end - best.start < height + 12)
+        return hidden;
+    return { pose: 'halfpeek', left, top: best.start + (best.end - best.start - height) * 0.45, width, height };
+}
+//# sourceMappingURL=character-layout.js.map

package/lib/scene/character-motion-clock.d.ts

@@ -0,0 +1,18 @@
+interface Clock {
+    setTimeout(callback: () => void, delay: number): number;
+    clearTimeout(handle: number): void;
+    performance: {
+        now(): number;
+    };
+}
+export interface CharacterMotionClip {
+    duration: number;
+}
+/** One deadline; elapsed-time continuous sampling, capped at 30 fps. */
+export declare function createCharacterMotionClock(clock: Clock, changed: (action: string | undefined, progress: number) => void, random?: () => number): {
+    setClips(next: Readonly<Record<string, CharacterMotionClip>> | undefined): void;
+    attention(): void;
+    dispose(): void;
+};
+export {};
+//# sourceMappingURL=character-motion-clock.d.ts.map

package/lib/scene/character-motion-clock.js

@@ -0,0 +1,57 @@
+/** One deadline; elapsed-time continuous sampling, capped at 30 fps. */
+export function createCharacterMotionClock(clock, changed, random = Math.random) {
+    let timer, disposed = false, turn = 0, active = '';
+    let clips;
+    const clear = () => { if (timer !== undefined)
+        clock.clearTimeout(timer); timer = undefined; };
+    function rest() {
+        active = '';
+        changed(undefined, 0);
+        if (clips && !disposed)
+            timer = clock.setTimeout(start, 2800 + random() * 2800);
+    }
+    function play(action) {
+        const clip = clips?.[action];
+        if (!clip || disposed)
+            return;
+        clear();
+        active = action;
+        const started = clock.performance.now();
+        const step = () => {
+            timer = undefined;
+            if (!clips || disposed)
+                return;
+            const t = Math.min(1, (clock.performance.now() - started) / clip.duration);
+            changed(active, t);
+            if (t >= 1) {
+                rest();
+                return;
+            }
+            timer = clock.setTimeout(step, 1000 / 30);
+        };
+        step();
+    }
+    function start() {
+        timer = undefined;
+        if (!clips || disposed)
+            return;
+        const gestures = Object.keys(clips).filter(name => name !== 'blink' && name !== 'attention');
+        play((turn++ % 2 === 0 && clips.blink) || !gestures.length ? 'blink' : gestures[Math.floor(random() * gestures.length)]);
+    }
+    return {
+        setClips(next) {
+            if (disposed || next === clips)
+                return;
+            clear();
+            clips = next;
+            active = '';
+            changed(undefined, 0);
+            if (clips)
+                timer = clock.setTimeout(start, 1200 + random() * 800);
+        },
+        attention() { if (!active)
+            play('attention'); },
+        dispose() { disposed = true; clear(); clips = undefined; changed(undefined, 0); },
+    };
+}
+//# sourceMappingURL=character-motion-clock.js.map

package/lib/scene/character-motion-types.d.ts

@@ -0,0 +1,12 @@
+export type Point = readonly [number, number];
+export interface CharacterLayer {
+    readonly src: string;
+    readonly box: readonly [number, number, number, number];
+}
+export interface CharacterRig {
+    readonly layers: Readonly<Record<string, CharacterLayer>>;
+    readonly ears: readonly Point[];
+    readonly size: Point;
+}
+export type CharacterMotionCatalog = Readonly<Record<string, Readonly<Record<'light' | 'dark', CharacterRig>>>>;
+//# sourceMappingURL=character-motion-types.d.ts.map

package/lib/scene/character-motion-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=character-motion-types.js.map

package/lib/scene/character-motion.d.ts

@@ -0,0 +1,6 @@
+/** Owns loading and lifecycle only. Rig math and painting stay independent. */
+export declare function createCharacterMotion(doc: Document): {
+    setPose(nextPart: HTMLElement | undefined, nextPose: string): void;
+    dispose(): void;
+};
+//# sourceMappingURL=character-motion.d.ts.map

package/lib/scene/character-motion.js

@@ -0,0 +1,126 @@
+import { CHARACTER_MOTION } from '../generated-character-motion.js';
+import { createCharacterMotionClock } from './character-motion-clock.js';
+import { createRigRenderer } from './character-rig-renderer.js';
+/** Owns loading and lifecycle only. Rig math and painting stay independent. */
+export function createCharacterMotion(doc) {
+    const win = doc.defaultView, reduced = win.matchMedia('(prefers-reduced-motion: reduce)');
+    const images = new Map(), loading = new Map();
+    let disposed = false, part, rig;
+    let canvas, render;
+    let pose = '', appearance = '', revision = 0, nearby = false, lastPointer = 0;
+    function decode(src) {
+        if (loading.has(src))
+            return loading.get(src);
+        if (images.has(src))
+            return Promise.resolve();
+        const image = new win.Image();
+        image.src = src;
+        const pending = image.decode().then(() => { if (!disposed)
+            images.set(src, image); }, () => { })
+            .finally(() => loading.delete(src));
+        loading.set(src, pending);
+        return pending;
+    }
+    const clock = createCharacterMotionClock(win, (action, progress) => {
+        if (!canvas || !part || !render)
+            return;
+        // Keep the same layered rest drawing after an action: no plate swap/pop.
+        render(action, progress);
+        part.dataset.motion = action ?? 'rig-rest';
+    });
+    function update() {
+        if (disposed)
+            return;
+        const mode = doc.documentElement.dataset.xiaoheiAppearance === 'light' ? 'light' : 'dark';
+        const moving = doc.documentElement.hasAttribute('data-xiaohei-sidebar-resizing');
+        const next = !doc.hidden && !reduced.matches && !moving && part ? CHARACTER_MOTION[pose]?.[mode] : undefined;
+        if (next === rig && appearance === mode)
+            return;
+        clock.setClips(undefined);
+        render = undefined;
+        const current = ++revision;
+        canvas?.remove();
+        canvas = undefined;
+        if (part)
+            part.dataset.motion = 'rest';
+        rig = next;
+        appearance = mode;
+        nearby = false;
+        if (!next || !part)
+            return;
+        const currentPart = part;
+        void Promise.all(Object.values(next.layers).map(layer => decode(layer.src))).then(() => {
+            if (disposed || current !== revision || Object.values(next.layers).some(layer => !images.get(layer.src)))
+                return;
+            canvas = doc.createElement('canvas');
+            canvas.className = 'xiaohei-character-motion';
+            canvas.width = next.size[0];
+            canvas.height = next.size[1];
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                canvas = undefined;
+                return;
+            }
+            currentPart.append(canvas);
+            render = createRigRenderer(ctx, next, images);
+            clock.setClips({
+                blink: { duration: 330 },
+                ...Object.fromEntries(next.ears.map((_, i) => ['ear' + i, { duration: 1050 }])),
+                ...(next.layers.tail ? { tail: { duration: 2400 } } : {}),
+                attention: { duration: 2400 },
+            });
+        });
+    }
+    const pointer = (event) => {
+        if (!part || !render || event.pointerType !== 'mouse')
+            return;
+        const now = win.performance.now();
+        if (now - lastPointer < 100)
+            return;
+        lastPointer = now;
+        const rect = part.getBoundingClientRect();
+        const near = event.clientX >= rect.left - 70 && event.clientX <= rect.right + 70
+            && event.clientY >= rect.top - 50 && event.clientY <= rect.bottom + 50;
+        if (near && !nearby)
+            clock.attention();
+        nearby = near;
+    };
+    reduced.addEventListener('change', update);
+    doc.addEventListener('visibilitychange', update);
+    doc.addEventListener('pointermove', pointer, { passive: true });
+    const observer = new win.MutationObserver(update);
+    observer.observe(doc.documentElement, { attributes: true, attributeFilter: ['data-xiaohei-appearance', 'data-xiaohei-sidebar-resizing'] });
+    return {
+        setPose(nextPart, nextPose) {
+            if (nextPart !== part || pose !== nextPose) {
+                revision++;
+                clock.setClips(undefined);
+                render = undefined;
+                canvas?.remove();
+                canvas = undefined;
+                rig = undefined;
+                if (part)
+                    part.dataset.motion = 'rest';
+            }
+            part = nextPart;
+            pose = nextPose;
+            update();
+        },
+        dispose() {
+            disposed = true;
+            revision++;
+            clock.dispose();
+            canvas?.remove();
+            render = undefined;
+            images.clear();
+            loading.clear();
+            if (part)
+                part.dataset.motion = 'rest';
+            reduced.removeEventListener('change', update);
+            observer.disconnect();
+            doc.removeEventListener('visibilitychange', update);
+            doc.removeEventListener('pointermove', pointer);
+        },
+    };
+}
+//# sourceMappingURL=character-motion.js.map

package/lib/scene/character-poses.d.ts

@@ -0,0 +1,26 @@
+/** Shared catalog: runtime preloading and CSS must always use the same assets. */
+export declare const CHARACTER_POSES: {
+    readonly seated: {
+        readonly light: string;
+        readonly dark: string;
+    };
+    readonly chin: {
+        readonly light: string;
+        readonly dark: string;
+    };
+    readonly doze: {
+        readonly light: string;
+        readonly dark: string;
+    };
+    readonly peek: {
+        readonly light: string;
+        readonly dark: string;
+    };
+    readonly halfpeek: {
+        readonly light: string;
+        readonly dark: string;
+    };
+};
+export type CharacterPose = keyof typeof CHARACTER_POSES;
+export declare const CHARACTER_POSE_NAMES: CharacterPose[];
+//# sourceMappingURL=character-poses.d.ts.map

package/lib/scene/character-poses.js

@@ -0,0 +1,11 @@
+import { XIAOHEI_SEATED_LIGHT, XIAOHEI_SEATED_DARK, XIAOHEI_PEEK_LIGHT, XIAOHEI_PEEK_DARK, XIAOHEI_CHIN_LIGHT, XIAOHEI_CHIN_DARK, XIAOHEI_DOZE_LIGHT, XIAOHEI_DOZE_DARK, XIAOHEI_HALFPEEK_LIGHT, XIAOHEI_HALFPEEK_DARK, } from '../generated-backgrounds.js';
+/** Shared catalog: runtime preloading and CSS must always use the same assets. */
+export const CHARACTER_POSES = {
+    seated: { light: XIAOHEI_SEATED_LIGHT, dark: XIAOHEI_SEATED_DARK },
+    chin: { light: XIAOHEI_CHIN_LIGHT, dark: XIAOHEI_CHIN_DARK },
+    doze: { light: XIAOHEI_DOZE_LIGHT, dark: XIAOHEI_DOZE_DARK },
+    peek: { light: XIAOHEI_PEEK_LIGHT, dark: XIAOHEI_PEEK_DARK },
+    halfpeek: { light: XIAOHEI_HALFPEEK_LIGHT, dark: XIAOHEI_HALFPEEK_DARK },
+};
+export const CHARACTER_POSE_NAMES = Object.keys(CHARACTER_POSES);
+//# sourceMappingURL=character-poses.js.map

package/lib/scene/character-rig-renderer.d.ts

@@ -0,0 +1,4 @@
+import type { CharacterRig } from './character-motion-types.js';
+/** Small CPU-skinned tail only; body and ears use normal image draws. */
+export declare function createRigRenderer(ctx: CanvasRenderingContext2D, rig: CharacterRig, images: ReadonlyMap<string, HTMLImageElement | null>): (action: string | undefined, progress: number) => void;
+//# sourceMappingURL=character-rig-renderer.d.ts.map

package/lib/scene/character-rig-renderer.js

@@ -0,0 +1,85 @@
+import { bindVertex, rigAngles, skinVertex, solveBones, TAIL_JOINTS } from './character-rig.js';
+/** Small CPU-skinned tail only; body and ears use normal image draws. */
+export function createRigRenderer(ctx, rig, images) {
+    const tail = rig.layers.tail;
+    const vertices = [], triangles = [];
+    if (tail) {
+        const [x, y, r, b] = tail.box, cols = Math.ceil((r - x) / 10), rows = Math.ceil((b - y) / 10);
+        for (let row = 0; row <= rows; row++)
+            for (let col = 0; col <= cols; col++)
+                vertices.push(bindVertex(x + (r - x) * col / cols, y + (b - y) * row / rows));
+        for (let row = 0; row < rows; row++)
+            for (let col = 0; col < cols; col++) {
+                const i = row * (cols + 1) + col;
+                triangles.push([i, i + 1, i + cols + 1], [i + 1, i + cols + 2, i + cols + 1]);
+            }
+    }
+    function layer(name) {
+        const layer = rig.layers[name], image = layer && images.get(layer.src);
+        if (layer && image) {
+            const [x, y, r, b] = layer.box;
+            ctx.drawImage(image, x, y, r - x, b - y);
+        }
+    }
+    function drawTail(progress) {
+        if (!tail)
+            return;
+        const image = images.get(tail.src);
+        if (!image)
+            return;
+        if (progress <= 0 || progress >= 1) {
+            layer('tail');
+            return;
+        }
+        const joints = solveBones(TAIL_JOINTS, rigAngles(progress, TAIL_JOINTS.length, true));
+        const posed = vertices.map(v => skinVertex(v, joints));
+        const [left, top] = tail.box;
+        for (const indices of triangles) {
+            const [ia, ib, ic] = indices;
+            const a = vertices[ia], b = vertices[ib], c = vertices[ic];
+            const p = posed[ia], q = posed[ib], r = posed[ic];
+            const ux = b.x - a.x, uy = b.y - a.y, vx = c.x - a.x, vy = c.y - a.y, det = ux * vy - uy * vx;
+            const aa = ((q[0] - p[0]) * vy - (r[0] - p[0]) * uy) / det;
+            const bb = ((q[1] - p[1]) * vy - (r[1] - p[1]) * uy) / det;
+            const cc = ((r[0] - p[0]) * ux - (q[0] - p[0]) * vx) / det;
+            const dd = ((r[1] - p[1]) * ux - (q[1] - p[1]) * vx) / det;
+            ctx.save();
+            ctx.beginPath();
+            // Slightly overlap the interior triangles to avoid antialias hairlines.
+            const cx = (p[0] + q[0] + r[0]) / 3, cy = (p[1] + q[1] + r[1]) / 3;
+            [p, q, r].forEach((v, i) => {
+                const dx = v[0] - cx, dy = v[1] - cy, scale = 1 + 1.2 / Math.max(1, Math.hypot(dx, dy));
+                if (i)
+                    ctx.lineTo(cx + dx * scale, cy + dy * scale);
+                else
+                    ctx.moveTo(cx + dx * scale, cy + dy * scale);
+            });
+            ctx.closePath();
+            ctx.clip();
+            ctx.transform(aa, bb, cc, dd, p[0] - aa * (a.x - left) - cc * (a.y - top), p[1] - bb * (a.x - left) - dd * (a.y - top));
+            ctx.drawImage(image, 0, 0);
+            ctx.restore();
+        }
+    }
+    return (action, progress) => {
+        ctx.clearRect(0, 0, rig.size[0], rig.size[1]);
+        const ears = rigAngles(progress, rig.ears.length, false);
+        rig.ears.forEach(([x, y], i) => {
+            ctx.save();
+            ctx.translate(x, y);
+            ctx.rotate(action === 'attention' || action === 'ear' + i ? ears[i] : 0);
+            ctx.translate(-x, -y);
+            layer('ear' + i);
+            ctx.restore();
+        });
+        layer('body');
+        drawTail(action === 'tail' || action === 'attention' ? progress : 0);
+        if (action === 'blink') {
+            ctx.save();
+            ctx.globalAlpha = Math.min(1, Math.sin(Math.PI * progress) * 2);
+            layer('blink');
+            ctx.restore();
+        }
+    };
+}
+//# sourceMappingURL=character-rig-renderer.js.map

package/lib/scene/character-rig.d.ts

@@ -0,0 +1,20 @@
+import type { Point } from './character-motion-types.js';
+/** Bind-space joint positions. Each child inherits its parent's rotation. */
+export declare const TAIL_JOINTS: readonly Point[];
+export interface Joint {
+    x: number;
+    y: number;
+    angle: number;
+}
+export interface Vertex {
+    x: number;
+    y: number;
+    bone: number;
+    weight: number;
+}
+export declare function solveBones(rest: readonly Point[], angles: readonly number[]): Joint[];
+export declare function bindVertex(x: number, y: number, rest?: readonly Point[]): Vertex;
+/** Linear blend skinning, inverse bind translation followed by posed rotation. */
+export declare function skinVertex(v: Vertex, joints: readonly Joint[], rest?: readonly Point[]): Point;
+export declare function rigAngles(progress: number, count: number, tail: boolean): number[];
+//# sourceMappingURL=character-rig.d.ts.map

package/lib/scene/character-rig.js

@@ -0,0 +1,53 @@
+/** Bind-space joint positions. Each child inherits its parent's rotation. */
+export const TAIL_JOINTS = [
+    [284, 328], [310, 347], [324, 373], [319, 398],
+    [307, 423], [307, 448], [319, 464],
+];
+export function solveBones(rest, angles) {
+    return rest.reduce((out, p, i) => {
+        const parent = out[i - 1];
+        const angle = (parent?.angle ?? 0) + (angles[i] ?? 0);
+        if (!parent)
+            out.push({ x: p[0], y: p[1], angle });
+        else {
+            const prev = rest[i - 1], dx = p[0] - prev[0], dy = p[1] - prev[1];
+            const c = Math.cos(parent.angle), s = Math.sin(parent.angle);
+            out.push({ x: parent.x + dx * c - dy * s, y: parent.y + dx * s + dy * c, angle });
+        }
+        return out;
+    }, []);
+}
+export function bindVertex(x, y, rest = TAIL_JOINTS) {
+    let distance = Infinity, bone = 0, weight = 0;
+    for (let i = 0; i < rest.length - 1; i++) {
+        const a = rest[i], b = rest[i + 1], dx = b[0] - a[0], dy = b[1] - a[1];
+        const t = Math.max(0, Math.min(1, ((x - a[0]) * dx + (y - a[1]) * dy) / (dx * dx + dy * dy)));
+        const d = (x - a[0] - dx * t) ** 2 + (y - a[1] - dy * t) ** 2;
+        if (d < distance) {
+            distance = d;
+            bone = i;
+            weight = t;
+        }
+    }
+    return { x, y, bone, weight };
+}
+/** Linear blend skinning, inverse bind translation followed by posed rotation. */
+export function skinVertex(v, joints, rest = TAIL_JOINTS) {
+    let x = 0, y = 0;
+    for (let k = 0; k < 2; k++) {
+        const i = v.bone + k, p = rest[i], j = joints[i], w = k ? v.weight : 1 - v.weight;
+        const dx = v.x - p[0], dy = v.y - p[1], c = Math.cos(j.angle), s = Math.sin(j.angle);
+        x += w * (j.x + dx * c - dy * s);
+        y += w * (j.y + dx * s + dy * c);
+    }
+    return [x, y];
+}
+export function rigAngles(progress, count, tail) {
+    const t = Math.max(0, Math.min(1, progress));
+    const envelope = Math.sin(Math.PI * t) ** 2;
+    // Delayed distal joints create follow-through, with zero displacement/velocity
+    // at both ends; no discrete frame lookup and no idle simulation.
+    return Array.from({ length: count }, (_, i) => envelope * (tail ? (i ? .12 : 0) : .22)
+        * Math.sin(t * Math.PI * (tail ? 3 : 4) - i * (tail ? .65 : 1.1)));
+}
+//# sourceMappingURL=character-rig.js.map

package/lib/scene/heixiu-feedback.d.ts

@@ -1,3 +1,3 @@
 /** Session feedback runs on an inner plane so ambient drifting stays untouched. */
-export declare const XIAOHEI_HEIXIU_FEEDBACK_CSS = "\n.xiaohei-scene__heixiu-body {\n  position: absolute;\n  inset: 0;\n  display: block;\n  transform: translate3d(0, 0, 0);\n  opacity: 1;\n}\n\nhtml[data-xiaohei-state='thinking'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-body {\n  animation: xiaohei-heixiu-feedback-send 620ms cubic-bezier(0.22, 0.72, 0.24, 1) both;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--mascot .xiaohei-scene__heixiu-body,\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-body,\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--sidebar .xiaohei-scene__heixiu-body {\n  animation: xiaohei-heixiu-feedback-complete 760ms cubic-bezier(0.16, 1, 0.3, 1) both;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-body {\n  animation-delay: 70ms;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--sidebar .xiaohei-scene__heixiu-body {\n  animation-delay: 140ms;\n}\n\nhtml[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-body {\n  animation: xiaohei-heixiu-feedback-error 880ms cubic-bezier(0.22, 0.72, 0.24, 1) both;\n}\n\nhtml[data-xiaohei-state='thinking'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-open,\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open,\nhtml[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open {\n  animation: xiaohei-heixiu-feedback-eyes-open 620ms step-end both;\n}\n\nhtml[data-xiaohei-state='thinking'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-blink,\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink,\nhtml[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink {\n  animation: xiaohei-heixiu-feedback-eyes-blink 620ms step-end both;\n}\n\n@keyframes xiaohei-heixiu-feedback-send {\n  0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }\n  34% { transform: translate3d(0, -0.28rem, 0); opacity: 1; }\n  68% { transform: translate3d(0, 0.08rem, 0); opacity: 0.94; }\n}\n\n@keyframes xiaohei-heixiu-feedback-complete {\n  0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }\n  38% { transform: translate3d(0, -0.42rem, 0); opacity: 1; }\n  68% { transform: translate3d(0, -0.12rem, 0); opacity: 0.96; }\n}\n\n@keyframes xiaohei-heixiu-feedback-error {\n  0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }\n  30% { transform: translate3d(0, 0.2rem, 0); opacity: 0.52; }\n  62% { transform: translate3d(0, 0.08rem, 0); opacity: 0.72; }\n}\n\n@keyframes xiaohei-heixiu-feedback-eyes-open {\n  0%, 24%, 48%, 100% { opacity: 1; }\n  25%, 47% { opacity: 0; }\n}\n\n@keyframes xiaohei-heixiu-feedback-eyes-blink {\n  0%, 24%, 48%, 100% { opacity: 0; }\n  25%, 47% { opacity: 1; }\n}\n\n@media (prefers-reduced-motion: reduce) {\n  html[data-xiaohei-state] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-body,\n  html[data-xiaohei-state] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open,\n  html[data-xiaohei-state] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink {\n    animation: none;\n  }\n}\n";
+export declare const XIAOHEI_HEIXIU_FEEDBACK_CSS = "\n.xiaohei-scene__heixiu-body {\n  position: absolute;\n  inset: 0;\n  display: block;\n  transform: translate3d(0, 0, 0);\n  opacity: 1;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--mascot .xiaohei-scene__heixiu-body,\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--sidebar .xiaohei-scene__heixiu-body {\n  animation: xiaohei-heixiu-feedback-complete 760ms cubic-bezier(0.16, 1, 0.3, 1) both;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--sidebar .xiaohei-scene__heixiu-body {\n  animation-delay: 140ms;\n}\n\nhtml[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-body {\n  animation: xiaohei-heixiu-feedback-error 880ms cubic-bezier(0.22, 0.72, 0.24, 1) both;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open,\nhtml[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open {\n  animation: xiaohei-heixiu-feedback-eyes-open 620ms step-end both;\n}\n\nhtml[data-xiaohei-state='complete'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink,\nhtml[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink {\n  animation: xiaohei-heixiu-feedback-eyes-blink 620ms step-end both;\n}\n\n@keyframes xiaohei-heixiu-feedback-complete {\n  0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }\n  38% { transform: translate3d(0, -0.42rem, 0); opacity: 1; }\n  68% { transform: translate3d(0, -0.12rem, 0); opacity: 0.96; }\n}\n\n@keyframes xiaohei-heixiu-feedback-error {\n  0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }\n  30% { transform: translate3d(0, 0.2rem, 0); opacity: 0.52; }\n  62% { transform: translate3d(0, 0.08rem, 0); opacity: 0.72; }\n}\n\n@keyframes xiaohei-heixiu-feedback-eyes-open {\n  0%, 24%, 48%, 100% { opacity: 1; }\n  25%, 47% { opacity: 0; }\n}\n\n@keyframes xiaohei-heixiu-feedback-eyes-blink {\n  0%, 24%, 48%, 100% { opacity: 0; }\n  25%, 47% { opacity: 1; }\n}\n\n@media (prefers-reduced-motion: reduce) {\n  html[data-xiaohei-state] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-body,\n  html[data-xiaohei-state] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open,\n  html[data-xiaohei-state] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink {\n    animation: none;\n  }\n}\n";
 //# sourceMappingURL=heixiu-feedback.d.ts.map

package/lib/scene/heixiu-feedback.js

@@ -8,20 +8,11 @@ export const XIAOHEI_HEIXIU_FEEDBACK_CSS = `
   opacity: 1;
 }
 
-html[data-xiaohei-state='thinking'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-body {
-  animation: xiaohei-heixiu-feedback-send 620ms cubic-bezier(0.22, 0.72, 0.24, 1) both;
-}
-
 html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--mascot .xiaohei-scene__heixiu-body,
-html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-body,
 html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--sidebar .xiaohei-scene__heixiu-body {
   animation: xiaohei-heixiu-feedback-complete 760ms cubic-bezier(0.16, 1, 0.3, 1) both;
 }
 
-html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-body {
-  animation-delay: 70ms;
-}
-
 html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu--sidebar .xiaohei-scene__heixiu-body {
   animation-delay: 140ms;
 }
@@ -30,24 +21,16 @@ html[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-b
   animation: xiaohei-heixiu-feedback-error 880ms cubic-bezier(0.22, 0.72, 0.24, 1) both;
 }
 
-html[data-xiaohei-state='thinking'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-open,
 html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open,
 html[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-open {
   animation: xiaohei-heixiu-feedback-eyes-open 620ms step-end both;
 }
 
-html[data-xiaohei-state='thinking'] .xiaohei-scene__heixiu--composer .xiaohei-scene__heixiu-blink,
 html[data-xiaohei-state='complete'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink,
 html[data-xiaohei-state='error'] .xiaohei-scene__heixiu .xiaohei-scene__heixiu-blink {
   animation: xiaohei-heixiu-feedback-eyes-blink 620ms step-end both;
 }
 
-@keyframes xiaohei-heixiu-feedback-send {
-  0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }
-  34% { transform: translate3d(0, -0.28rem, 0); opacity: 1; }
-  68% { transform: translate3d(0, 0.08rem, 0); opacity: 0.94; }
-}
-
 @keyframes xiaohei-heixiu-feedback-complete {
   0%, 100% { transform: translate3d(0, 0, 0); opacity: 1; }
   38% { transform: translate3d(0, -0.42rem, 0); opacity: 1; }