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

package/lib/bloub-heixiu/renderer.d.ts

@@ -0,0 +1,16 @@
+import type { BotFrame } from '../vendor/bloub/engine.js';
+import { type HeixiuReaction } from './character.js';
+/** A hollow eye, not a hole in the body: wallpaper never bleeds through it. */
+export declare function heixiuEyeRadii(width: number, height: number): {
+    rx: number;
+    ry: number;
+};
+/** Filled upstream eyes may touch; hollow rings need a small readable gap. */
+export declare function heixiuEyeSeparation(eyes: BotFrame['eyes']): number;
+/** Persistent SVG nodes: frame updates never replace HTML or retrigger host observers. */
+export declare function createHeixiuRenderer(doc: Document): {
+    svg: SVGSVGElement;
+    render: (frame: BotFrame, reaction?: HeixiuReaction) => void;
+    prepareEffects: () => void;
+};
+//# sourceMappingURL=renderer.d.ts.map

package/lib/bloub-heixiu/renderer.js

@@ -0,0 +1,94 @@
+import { DEMI_VIEWBOX } from '../vendor/bloub/repere.js';
+import { HEIXIU_FOOT, HEIXIU_REST } from './character.js';
+import { createHeixiuEffects } from './effects.js';
+const NS = 'http://www.w3.org/2000/svg';
+let serial = 0;
+/** A hollow eye, not a hole in the body: wallpaper never bleeds through it. */
+export function heixiuEyeRadii(width, height) {
+    // Upstream special poses bring their eyes close together. Keep the large
+    // resting rings, but taper their width in small poses to avoid fused eyes.
+    const roomy = Math.max(0, Math.min(1, (width - 20) / 12));
+    return { rx: Math.max(0.01, Math.min(width, 38) * (1 + .15 * roomy)), ry: Math.max(0.01, Math.min(height, 62) * 0.96) };
+}
+/** Filled upstream eyes may touch; hollow rings need a small readable gap. */
+export function heixiuEyeSeparation(eyes) {
+    if (eyes.length !== 2)
+        return 1;
+    const matrices = eyes.map(eye => eye.openMatrix.slice(7, -1).split(/[ ,]+/).map(Number));
+    const [a, b] = matrices;
+    if (!a || !b || a.length !== 6 || b.length !== 6 || [...a, ...b].some(n => !Number.isFinite(n)))
+        return 1;
+    const dx = b[4] - a[4], dy = b[5] - a[5], distance = Math.hypot(dx, dy);
+    if (distance < 1)
+        return .1;
+    const nx = dx / distance, ny = dy / distance;
+    const support = eyes.reduce((sum, eye, i) => {
+        const m = matrices[i], { rx, ry } = heixiuEyeRadii(eye.width, eye.height);
+        return sum + Math.hypot(rx * (m[0] * nx + m[1] * ny), ry * (m[2] * nx + m[3] * ny));
+    }, 0);
+    return Math.min(1, Math.max(.1, (distance - 10) / Math.max(1, support)));
+}
+/** Persistent SVG nodes: frame updates never replace HTML or retrigger host observers. */
+export function createHeixiuRenderer(doc) {
+    const el = (name) => doc.createElementNS(NS, name);
+    const attrs = (node, values) => {
+        for (const [key, value] of Object.entries(values)) {
+            const text = String(value);
+            if (node.getAttribute(key) !== text)
+                node.setAttribute(key, text);
+        }
+    };
+    const svg = el('svg'), defs = el('defs'), clip = el('clipPath'), clipBody = el('path');
+    const id = `xiaohei-bloub-${++serial}`;
+    attrs(svg, { viewBox: `${-DEMI_VIEWBOX} ${-DEMI_VIEWBOX} ${DEMI_VIEWBOX * 2} ${DEMI_VIEWBOX * 2}`, 'aria-hidden': 'true', focusable: 'false' });
+    attrs(clip, { id: `${id}-body`, clipPathUnits: 'userSpaceOnUse' });
+    clip.append(clipBody);
+    defs.append(clip);
+    const bodyGroup = el('g'), body = el('path'), eyesGroup = el('g');
+    attrs(body, { fill: 'var(--heixiu-ink)', stroke: 'var(--heixiu-outline)', 'stroke-width': 1.2, 'data-heixiu-body': '' });
+    attrs(eyesGroup, { 'clip-path': `url(#${id}-body)`, fill: 'none', stroke: '#f5f3db', 'stroke-width': 10.5 });
+    const eyes = [el('path'), el('path')];
+    for (const eye of eyes)
+        attrs(eye, { 'data-heixiu-eye': '', 'stroke-linecap': 'round', 'stroke-linejoin': 'round' });
+    eyesGroup.append(...eyes);
+    bodyGroup.append(body, eyesGroup);
+    const character = el('g');
+    attrs(character, { 'data-heixiu-character': '' });
+    character.append(bodyGroup);
+    svg.append(defs, character);
+    let effects;
+    function prepareEffects() {
+        if (effects)
+            return;
+        const behind = el('g'), front = el('g');
+        character.insertBefore(behind, bodyGroup);
+        character.append(front);
+        effects = createHeixiuEffects(doc, id, defs, behind, front, bodyGroup);
+    }
+    function render(frame, reaction = HEIXIU_REST) {
+        attrs(character, { transform: `translate(${reaction.x} ${reaction.y + HEIXIU_FOOT}) rotate(${reaction.roll}) scale(${reaction.sx} ${reaction.sy}) translate(0 ${-HEIXIU_FOOT})` });
+        attrs(body, { d: frame.bodyPath });
+        attrs(clipBody, { d: frame.bodyPath });
+        attrs(bodyGroup, { opacity: frame.bodyAlpha });
+        const eyeScale = heixiuEyeSeparation(frame.eyes);
+        for (const [i, node] of eyes.entries()) {
+            const eye = frame.eyes[i];
+            if (!eye) {
+                attrs(node, { opacity: 0 });
+                continue;
+            }
+            const radii = heixiuEyeRadii(eye.width, eye.height);
+            const rx = radii.rx * eyeScale, ry = radii.ry * eyeScale;
+            const lid = Math.max(0, Math.min(eye.lid, reaction.lid));
+            // Both halves meet in a curved, constant-weight lid. No flattened matrix,
+            // double-outline flash, vanished stroke, or full-body opacity swapping.
+            const curve = -rx * .26 * reaction.cheer * (1 - lid);
+            const top = curve - ry * lid * 1.3333, bottom = curve + ry * lid * 1.3333;
+            const d = `M${-rx} 0C${-rx} ${top} ${rx} ${top} ${rx} 0C${rx} ${bottom} ${-rx} ${bottom} ${-rx} 0Z`;
+            attrs(node, { d, transform: eye.openMatrix, opacity: eye.alpha, 'stroke-width': Math.min(10.5, rx * .28) });
+        }
+        effects?.(frame);
+    }
+    return { svg, render, prepareEffects };
+}
+//# sourceMappingURL=renderer.js.map

package/lib/bloub-heixiu/runtime.d.ts

@@ -0,0 +1,6 @@
+import type { HeixiuSignals } from './signals.js';
+export declare const HEIXIU_BLOUB_ACTIONS: readonly ["burst", "egg", "orbit", "hexagon", "wink", "wide", "exclaim", "alert", "sleep", "thinking", "notify"];
+export declare const HEIXIU_AMBIENT_ACTIONS: readonly ["burst", "egg", "orbit", "hexagon", "wink", "wide", "sleep"];
+/** One native-composer-owned button; optional read-only state, never send handlers. */
+export declare function installComposerBloub(doc?: Document | undefined, signals?: HeixiuSignals): () => void;
+//# sourceMappingURL=runtime.d.ts.map

package/lib/bloub-heixiu/runtime.js

@@ -0,0 +1,395 @@
+import { BotEngine } from '../vendor/bloub/engine.js';
+import { liveliness } from '../vendor/bloub/face.js';
+import { STATE_BY_ID } from '../vendor/bloub/states.js';
+import { subscribeXiaoheiHostDom } from '../host-dom.js';
+import { XIAOHEI_HOST_SELECTORS } from '../host-contract.js';
+import { createHeixiuRenderer } from './renderer.js';
+import { resolveHeixiuDock, resolveHeixiuWelcome } from './layout.js';
+import { resolveHeixiuFollow, resolveHeixiuGaze } from './follow.js';
+import { createHeixiuFlight } from './flight.js';
+import { heixiuAmbientDelay, heixiuAmbientIndex } from './ambient.js';
+import { HEIXIU_BLOUB_CSS } from './styles.js';
+import { HEIXIU_FACE, HEIXIU_PROFILE, HEIXIU_REACTIONS, HeixiuReactions } from './character.js';
+export const HEIXIU_BLOUB_ACTIONS = ['burst', 'egg', 'orbit', 'hexagon', 'wink', 'wide', 'exclaim', 'alert', 'sleep', 'thinking', 'notify'];
+export const HEIXIU_AMBIENT_ACTIONS = ['burst', 'egg', 'orbit', 'hexagon', 'wink', 'wide', 'sleep'];
+/** One native-composer-owned button; optional read-only state, never send handlers. */
+export function installComposerBloub(doc = typeof document === 'undefined' ? undefined : document, signals) {
+    const win = doc?.defaultView;
+    if (!doc || !win)
+        return () => { };
+    const style = doc.createElement('style');
+    style.textContent = HEIXIU_BLOUB_CSS;
+    doc.head.append(style);
+    const button = doc.createElement('button');
+    button.className = 'xiaohei-bloub';
+    button.type = 'button';
+    button.setAttribute('aria-label', '逗逗嘿咻');
+    button.title = '单击逗逗嘿咻 · 双击轮换变形（键盘 Shift+Enter）';
+    const renderer = createHeixiuRenderer(doc);
+    const drift = doc.createElement('span');
+    drift.className = 'xiaohei-bloub-drift';
+    drift.append(renderer.svg);
+    button.append(drift);
+    const flight = createHeixiuFlight(button);
+    const engine = new BotEngine(100, 'idle', HEIXIU_PROFILE, HEIXIU_FACE);
+    const reactions = new HeixiuReactions();
+    const neutral = { yaw: 0, pitch: -7, mix: 1, spin: 0, wander: .35 };
+    let gaze = neutral;
+    engine.setLook(neutral, 0);
+    renderer.render(engine.sample(0));
+    let disposed = false, visible = false, dirty = true;
+    let composer = null, sidebar = null;
+    let hero = null, heroRow = null;
+    let bounds;
+    let layoutFrame, animationFrame, wake;
+    let time = 0, lastStamp, activeUntil = 2.5, actionUntil = 0, reactionIndex = 0;
+    let pointerSide = 1;
+    let special = false, specialIndex = 0;
+    let followingX = '', followingY = '';
+    let ambientTimer, previousSpecial = -1, lastInput = -Infinity;
+    let signal = signals?.getSnapshot();
+    let dockMode, viewportWidth = win.innerWidth, viewportHeight = win.innerHeight;
+    const motion = win.matchMedia('(prefers-reduced-motion: reduce)');
+    const ro = typeof win.ResizeObserver === 'function' ? new win.ResizeObserver(() => { dirty = true; scheduleLayout(); }) : undefined;
+    const io = typeof win.IntersectionObserver === 'function' ? new win.IntersectionObserver(entries => {
+        const entry = entries.find(e => e.target === button);
+        if (entry) {
+            visible = entry.isIntersecting;
+            syncPlayback();
+        }
+    }) : undefined;
+    function stop() {
+        button.dataset.floating = 'false';
+        follow(0, 0);
+        if (ambientTimer !== undefined)
+            win.clearTimeout(ambientTimer);
+        ambientTimer = undefined;
+        flight.cancel();
+        if (animationFrame !== undefined)
+            win.cancelAnimationFrame(animationFrame);
+        if (wake !== undefined)
+            win.clearTimeout(wake);
+        animationFrame = undefined;
+        wake = undefined;
+        lastStamp = undefined;
+    }
+    function follow(dx, dy) {
+        const offset = resolveHeixiuFollow(dx, dy, win.innerWidth <= 760 || composer?.dataset.heixiuDock === 'compact');
+        const x = `${offset.x.toFixed(3)}px`, y = `${offset.y.toFixed(3)}px`;
+        if (x !== followingX) {
+            button.style.setProperty('--heixiu-follow-x', x);
+            followingX = x;
+        }
+        if (y !== followingY) {
+            button.style.setProperty('--heixiu-follow-y', y);
+            followingY = y;
+        }
+    }
+    function allowed() { return !disposed && visible && !!composer?.isConnected && !doc.hidden && !motion.matches; }
+    function scheduleAmbient(delay = heixiuAmbientDelay()) {
+        if (ambientTimer !== undefined)
+            win.clearTimeout(ambientTimer);
+        ambientTimer = undefined;
+        if (!allowed())
+            return;
+        ambientTimer = win.setTimeout(() => {
+            ambientTimer = undefined;
+            if (!allowed())
+                return;
+            if (actionUntil || signal?.running || flight.active || Date.now() - lastInput < 5000) {
+                scheduleAmbient(5000);
+                return;
+            }
+            playState(HEIXIU_AMBIENT_ACTIONS[heixiuAmbientIndex(HEIXIU_AMBIENT_ACTIONS.length, previousSpecial)], 'ambient');
+        }, delay);
+    }
+    function animateFor(seconds) {
+        activeUntil = Math.max(activeUntil, time + seconds);
+        if (!allowed() || animationFrame !== undefined)
+            return;
+        if (wake !== undefined)
+            win.clearTimeout(wake);
+        wake = undefined;
+        lastStamp = undefined;
+        animationFrame = win.requestAnimationFrame(tick);
+    }
+    function tick(stamp) {
+        animationFrame = undefined;
+        if (!allowed()) {
+            stop();
+            return;
+        }
+        if (lastStamp !== undefined)
+            time += Math.min(.05, Math.max(0, (stamp - lastStamp) / 1000));
+        lastStamp = stamp;
+        if (actionUntil && time >= actionUntil) {
+            special = false;
+            engine.setLook(gaze, time);
+            actionUntil = 0;
+            engine.setState('idle', time);
+            button.dataset.action = 'idle';
+            activeUntil = Math.max(activeUntil, time + .65);
+            if (signal?.running)
+                playState('thinking', 'session', true);
+        }
+        renderer.render(engine.sample(time), reactions.sample(time));
+        // Stop only with open eyes. The next short life window resumes the same
+        // clock, so neither gaze nor a partly completed blink can jump on waking.
+        if (time < activeUntil || actionUntil || liveliness(time).lid < .99) {
+            animationFrame = win.requestAnimationFrame(tick);
+        }
+        else {
+            lastStamp = undefined;
+            wake = win.setTimeout(() => { wake = undefined; animateFor(2); }, 3200);
+        }
+    }
+    function syncPlayback() {
+        if (!allowed()) {
+            stop();
+            if (motion.matches) {
+                engine.reset('idle', time);
+                engine.setLook(neutral, time, .001);
+                actionUntil = 0;
+                special = false;
+                reactions.reset();
+                time += 1;
+                renderer.render(engine.sample(time));
+                button.dataset.action = 'idle';
+            }
+        }
+        else {
+            button.dataset.floating = 'true';
+            animateFor(1);
+            if (signal?.running && !actionUntil)
+                playState('thinking', 'session', true);
+            if (ambientTimer === undefined)
+                scheduleAmbient();
+        }
+    }
+    function reconcile() {
+        layoutFrame = undefined;
+        if (disposed)
+            return;
+        const next = doc.querySelector(XIAOHEI_HOST_SELECTORS.composerCard);
+        const nextSidebar = doc.querySelector(XIAOHEI_HOST_SELECTORS.sidebarShell);
+        const nextHero = doc.querySelector(XIAOHEI_HOST_SELECTORS.composerHeroMark);
+        if (composer !== next || sidebar !== nextSidebar || hero !== nextHero) {
+            composer?.removeAttribute('data-heixiu-dock');
+            ro?.disconnect();
+            heroRow?.removeAttribute('data-heixiu-hero-row');
+            composer = next;
+            sidebar = nextSidebar;
+            hero = nextHero;
+            dirty = true;
+            heroRow = hero?.closest(XIAOHEI_HOST_SELECTORS.composerHeroRow) ?? null;
+            heroRow?.setAttribute('data-heixiu-hero-row', '');
+            if (composer)
+                ro?.observe(composer);
+            if (sidebar)
+                ro?.observe(sidebar);
+            if (hero)
+                ro?.observe(hero);
+            if (heroRow)
+                ro?.observe(heroRow);
+        }
+        if (!composer) {
+            button.remove();
+            visible = false;
+            stop();
+            return;
+        }
+        if (button.parentElement !== composer || composer.lastElementChild === button) {
+            // The native trailing toolbar must stay last: DSH and the existing send
+            // skin use its structural position. The overlay must not replace it.
+            const toolbar = [...composer.children].reverse().find(child => child !== button);
+            composer.insertBefore(button, toolbar ?? null);
+            io?.observe(button);
+            dirty = true;
+        }
+        if (!dirty)
+            return;
+        dirty = false;
+        const wasFlying = flight.active;
+        const viewportChanged = viewportWidth !== win.innerWidth || viewportHeight !== win.innerHeight;
+        const origin = flight.capture(bounds);
+        follow(0, 0);
+        const rect = composer.getBoundingClientRect();
+        const sidebarRight = sidebar?.getBoundingClientRect().right ?? 0;
+        const dock = resolveHeixiuDock(rect.left, sidebarRight, win.innerWidth);
+        const heroRect = hero?.getBoundingClientRect();
+        const welcome = heroRect && resolveHeixiuWelcome(heroRect, rect, sidebarRight, win.innerWidth);
+        if (welcome) {
+            button.style.setProperty('--heixiu-welcome-left', `${welcome.left}px`);
+            button.style.setProperty('--heixiu-welcome-top', `${welcome.top}px`);
+            button.style.setProperty('--heixiu-welcome-size', `${welcome.size}px`);
+        }
+        const mode = welcome ? 'welcome' : dock.mode;
+        const fly = !viewportChanged && (wasFlying || !!dockMode && dockMode !== mode && (dockMode === 'welcome' || mode === 'welcome'));
+        dockMode = mode;
+        viewportWidth = win.innerWidth;
+        viewportHeight = win.innerHeight;
+        if (composer.dataset.heixiuDock !== mode)
+            composer.dataset.heixiuDock = mode;
+        // One read after layout configuration; never inside the animation loop.
+        bounds = flight.target(button.getBoundingClientRect());
+        visible = rect.width > 0 && rect.height > 0 && bounds.top + bounds.height > 0 && bounds.top < win.innerHeight;
+        syncPlayback();
+        if (allowed() && fly)
+            flight.move(origin, bounds, motion.matches);
+        else
+            flight.cancel();
+    }
+    function scheduleLayout() {
+        if (disposed || layoutFrame !== undefined)
+            return;
+        layoutFrame = win.requestAnimationFrame(reconcile);
+    }
+    const move = (event) => {
+        if (!allowed() || flight.active || !bounds?.width)
+            return;
+        if (event.pointerType === 'touch') {
+            leave();
+            return;
+        }
+        const dx = event.clientX - (bounds.left + bounds.width / 2);
+        const dy = event.clientY - (bounds.top + bounds.height / 2);
+        follow(dx, dy);
+        gaze = resolveHeixiuGaze(dx, dy);
+        if (special)
+            return;
+        pointerSide = dx < 0 ? -1 : 1;
+        reactions.aim(Math.abs(dx) < 90 && Math.abs(dy) < 90 ? dx / 60 : 0, time);
+        engine.setLook(gaze, time);
+        animateFor(.8);
+    };
+    const leave = () => {
+        follow(0, 0);
+        gaze = neutral;
+        if (allowed() && !special) {
+            reactions.aim(0, time);
+            engine.setLook(neutral, time);
+            animateFor(.8);
+        }
+    };
+    const click = (event) => {
+        event.stopPropagation();
+        if (!allowed() || event.detail > 1)
+            return;
+        // A follow-up double click must not flash idle between special actions.
+        // A single click during one lets it finish; the next double click can
+        // interrupt it directly, without a delayed single-click timer.
+        if (special && event.detail > 0)
+            return;
+        const index = reactionIndex++ % (HEIXIU_REACTIONS.length + 1);
+        if (index === HEIXIU_REACTIONS.length) {
+            playState('exclaim', 'manual');
+            return;
+        }
+        const kind = HEIXIU_REACTIONS[index];
+        special = false;
+        engine.setState('idle', time);
+        engine.setLook(gaze, time);
+        reactions.play(kind, time, pointerSide);
+        button.dataset.action = kind;
+        button.dataset.actionSource = 'manual';
+        scheduleAmbient();
+        actionUntil = reactions.end;
+        animateFor(actionUntil - time + .65);
+    };
+    function playState(state, source, held = false) {
+        const def = STATE_BY_ID.get(state);
+        renderer.prepareEffects();
+        reactions.settle(time);
+        special = true;
+        engine.setLook(null, time);
+        engine.setState(state, time);
+        button.dataset.action = state;
+        previousSpecial = HEIXIU_AMBIENT_ACTIONS.findIndex(action => action === state);
+        button.dataset.actionSource = source;
+        actionUntil = held ? Infinity : time + Math.max(def.duration, def.minDuration ?? 0);
+        // Do not poison activeUntil with Infinity: normal idle must sleep again.
+        animateFor(Math.max(def.duration, def.minDuration ?? 0) + .65);
+        scheduleAmbient();
+    }
+    const doubleClick = (event) => {
+        event.stopPropagation();
+        if (!allowed())
+            return;
+        playState(HEIXIU_BLOUB_ACTIONS[specialIndex++ % HEIXIU_BLOUB_ACTIONS.length], 'manual');
+    };
+    const keydown = (event) => {
+        if (event.key === 'Enter' && event.shiftKey) {
+            event.preventDefault();
+            if (!event.repeat)
+                doubleClick(event);
+        }
+    };
+    const resized = () => { dirty = true; scheduleLayout(); };
+    const input = (event) => { if (composer?.contains(event.target))
+        lastInput = Date.now(); };
+    const unsubscribeSignals = signals?.subscribe(() => {
+        const next = signals.getSnapshot(), changedSession = next.sessionId !== signal?.sessionId;
+        signal = next;
+        button.dataset.sessionState = next.running ? 'running' : 'idle';
+        // Never replay missed notifications on visibility/reduced-motion changes.
+        if (!allowed()) {
+            if (actionUntil === Infinity || button.dataset.actionSource === 'session' || changedSession) {
+                actionUntil = 0;
+                special = false;
+                engine.setState('idle', time);
+                engine.setLook(gaze, time);
+                button.dataset.action = 'idle';
+            }
+            return;
+        }
+        if (changedSession || actionUntil === Infinity && !next.running) {
+            actionUntil = 0;
+            special = false;
+            engine.setState('idle', time);
+            engine.setLook(gaze, time);
+            button.dataset.action = 'idle';
+            animateFor(.65);
+        }
+        if (!changedSession && next.notice)
+            playState(next.notice, 'session');
+        else if (next.running && (!actionUntil || button.dataset.actionSource !== 'session'))
+            playState('thinking', 'session', true);
+    }) ?? (() => { });
+    const unsubscribe = subscribeXiaoheiHostDom(doc, scheduleLayout);
+    doc.addEventListener('pointermove', move, { passive: true });
+    doc.addEventListener('pointerleave', leave);
+    doc.addEventListener('visibilitychange', syncPlayback);
+    doc.addEventListener('input', input, { passive: true });
+    button.addEventListener('click', click);
+    button.addEventListener('dblclick', doubleClick);
+    button.addEventListener('keydown', keydown);
+    win.addEventListener('resize', resized, { passive: true });
+    win.addEventListener('scroll', resized, { passive: true, capture: true });
+    motion.addEventListener('change', syncPlayback);
+    scheduleLayout();
+    return () => {
+        disposed = true;
+        stop();
+        unsubscribe();
+        unsubscribeSignals();
+        ro?.disconnect();
+        io?.disconnect();
+        if (layoutFrame !== undefined)
+            win.cancelAnimationFrame(layoutFrame);
+        doc.removeEventListener('pointermove', move);
+        doc.removeEventListener('pointerleave', leave);
+        doc.removeEventListener('visibilitychange', syncPlayback);
+        button.removeEventListener('click', click);
+        doc.removeEventListener('input', input);
+        button.removeEventListener('dblclick', doubleClick);
+        button.removeEventListener('keydown', keydown);
+        win.removeEventListener('resize', resized);
+        win.removeEventListener('scroll', resized, true);
+        motion.removeEventListener('change', syncPlayback);
+        heroRow?.removeAttribute('data-heixiu-hero-row');
+        composer?.removeAttribute('data-heixiu-dock');
+        button.remove();
+        style.remove();
+    };
+}
+//# sourceMappingURL=runtime.js.map

package/lib/bloub-heixiu/signals.d.ts

@@ -0,0 +1,17 @@
+import type { ISessions } from '@deepseek-ai/dsh-api-session-controller/client';
+export interface HeixiuSignal {
+    sessionId?: string;
+    running: boolean;
+    notice: 'notify' | 'alert' | null;
+    revision: number;
+}
+/** Small local read model. No messages, RPCs, history scans or persisted state. */
+export declare function createHeixiuSignals(): {
+    getSnapshot: () => HeixiuSignal;
+    subscribe(fn: () => void): () => void;
+    publish(next: Omit<HeixiuSignal, "revision">): void;
+};
+export type HeixiuSignals = ReturnType<typeof createHeixiuSignals>;
+/** Optional official service adapter, subscribed only to the selected session. */
+export declare function bindHeixiuSessions(sessions: ISessions, signals: HeixiuSignals): () => void;
+//# sourceMappingURL=signals.d.ts.map

package/lib/bloub-heixiu/signals.js

@@ -0,0 +1,53 @@
+/** Small local read model. No messages, RPCs, history scans or persisted state. */
+export function createHeixiuSignals() {
+    let value = { running: false, notice: null, revision: 0 };
+    const listeners = new Set();
+    return {
+        getSnapshot: () => value,
+        subscribe(fn) { listeners.add(fn); return () => { listeners.delete(fn); }; },
+        publish(next) {
+            if (next.sessionId === value.sessionId && next.running === value.running && next.notice === value.notice)
+                return;
+            value = { ...next, revision: value.revision + 1 };
+            for (const fn of listeners)
+                fn();
+        },
+    };
+}
+/** Optional official service adapter, subscribed only to the selected session. */
+export function bindHeixiuSessions(sessions, signals) {
+    let face;
+    let removeSession = () => { };
+    let previous;
+    const read = () => {
+        const next = face?.getSnapshot();
+        const live = next?.openState === 'open' && !next.removed;
+        const wasLive = previous?.openState === 'open' && !previous.removed;
+        const same = previous?.sessionId === next?.sessionId;
+        const failed = !!next && !!previous && (next.lastAgentError && next.lastAgentError !== previous.lastAgentError
+            || next.promptError && next.promptError !== previous.promptError);
+        const ended = wasLive && same && previous?.running && !next?.running;
+        const notice = live && wasLive && same ? failed ? 'alert' : ended ? 'notify' : null : null;
+        signals.publish({ sessionId: next?.sessionId, running: !!live && !!next?.running, notice });
+        previous = next;
+    };
+    const select = () => {
+        const id = sessions.list.getSnapshot().current;
+        const next = id ? sessions.binding(id)?.session : undefined;
+        if (next === face)
+            return;
+        removeSession();
+        previous = undefined;
+        face = next;
+        removeSession = face?.subscribe(read) ?? (() => { });
+        read();
+    };
+    const removeList = sessions.list.subscribe(select);
+    select();
+    return () => {
+        removeList();
+        removeSession();
+        signals.publish({ running: false, notice: null });
+    };
+}
+//# sourceMappingURL=signals.js.map

package/lib/bloub-heixiu/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const HEIXIU_BLOUB_CSS = "\n#root [data-composer-card] > button.xiaohei-bloub {\n  all: unset;\n  --heixiu-ink: #111214;\n  --heixiu-outline: rgba(245,243,215,.16);\n  position: absolute;\n  box-sizing: border-box;\n  display: block;\n  width: 96px;\n  height: 96px;\n  min-width: 44px;\n  min-height: 44px;\n  right: calc(100% + 18px);\n  top: calc(50% - 48px);\n  margin: 0 !important;\n  padding: 0 !important;\n  border: 0 !important;\n  border-radius: 50%;\n  background: none !important;\n  box-shadow: none !important;\n  color: inherit;\n  cursor: pointer;\n  touch-action: manipulation;\n  user-select: none;\n  -webkit-tap-highlight-color: transparent;\n  /* Flight owns this transform. A CSS transition would replay cancelled\n     WAAPI transforms and corrupt the next target measurement. */\n  transition: none;\n  z-index: 3;\n}\n#root [data-composer-card] > button.xiaohei-bloub:focus-visible {\n  outline: 2px solid var(--dsw-alias-label-secondary);\n  outline-offset: -7px;\n}\n#root [data-composer-card] > button.xiaohei-bloub > .xiaohei-bloub-drift {\n  display: block;\n  width: 100%; height: 100%;\n  pointer-events: none;\n  --heixiu-drift-x: 7px;\n  --heixiu-drift-y: 10px;\n  animation: xiaohei-bloub-float 14s cubic-bezier(.45,0,.55,1) infinite;\n  animation-play-state: paused;\n}\n#root [data-composer-card] > button.xiaohei-bloub[data-floating='true'] > .xiaohei-bloub-drift {\n  animation-play-state: running;\n}\n@keyframes xiaohei-bloub-float {\n  0%, 100% { transform: translate(calc(-1 * var(--heixiu-drift-x)), var(--heixiu-drift-y)); }\n  50% { transform: translate(var(--heixiu-drift-x), calc(-1 * var(--heixiu-drift-y))); }\n}\n#root [data-composer-card] > button.xiaohei-bloub > .xiaohei-bloub-drift > svg {\n  display: block;\n  width: 100%; height: 100%;\n  overflow: hidden;\n  pointer-events: none;\n  transform: translate(var(--heixiu-follow-x, 0px), var(--heixiu-follow-y, 0px));\n  transition: transform 480ms cubic-bezier(.2,.75,.25,1);\n}\n#root [data-composer-card] > button.xiaohei-bloub:active > .xiaohei-bloub-drift > svg {\n  transform: translate(var(--heixiu-follow-x, 0px), var(--heixiu-follow-y, 0px)) scale(.98);\n}\n#root [data-composer-card][data-heixiu-dock='compact'] {\n  padding-inline-start: 64px !important;\n}\n#root [data-composer-card][data-heixiu-dock='compact'] > button.xiaohei-bloub {\n  width: 52px; height: 52px;\n  right: auto; left: 4px; top: 6px;\n}\n#root [data-composer-card][data-heixiu-dock='compact'] .xiaohei-bloub-drift {\n  --heixiu-drift-x: 2px;\n  --heixiu-drift-y: 3px;\n}\n#root [data-composer-card][data-heixiu-dock='welcome'] > button.xiaohei-bloub {\n  right: auto;\n  left: var(--heixiu-welcome-left);\n  top: var(--heixiu-welcome-top);\n  width: var(--heixiu-welcome-size);\n  height: var(--heixiu-welcome-size);\n}\n@media (max-width: 760px) {\n  #root [data-heixiu-hero-row] { box-sizing: border-box; padding-inline-start: 64px; max-width: 100%; }\n  #root [data-composer-card][data-heixiu-dock='welcome'] .xiaohei-bloub-drift {\n    --heixiu-drift-x: 2px;\n    --heixiu-drift-y: 4px;\n  }\n}\n#root [data-composer-card] > button.xiaohei-bloub[hidden] { display: none; }\n@media (prefers-reduced-motion: reduce) {\n  #root [data-composer-card] > button.xiaohei-bloub { transition: none; transform: none; }\n  #root [data-composer-card] > button.xiaohei-bloub > .xiaohei-bloub-drift { animation: none; transform: none; }\n  #root [data-composer-card] > button.xiaohei-bloub > .xiaohei-bloub-drift > svg { transition: none; transform: none; }\n}\n@media print {\n  #root [data-composer-card] > button.xiaohei-bloub { display: none; }\n  #root [data-composer-card][data-heixiu-dock='compact'] { padding-inline-start: 12px !important; }\n}\n";
+//# sourceMappingURL=styles.d.ts.map