@linxin666/dsh-pet 0.3.3 → 0.3.5

package/lib/types/client/renderers/Frames2dVisualMount.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Frames2d visual mount — the React bridge between the pet center chrome
+ * and the imperative frames2d renderer, mirroring the live2d mount. The
+ * bridge owns the contract context (asset base, phase stream, interaction
+ * write-back, activation cleanups), feeds the polled phase into the stream,
+ * forwards the chrome's drag gesture onto the conventional 'drag' track
+ * (when the pet declares one), and renders the localized fallback card when
+ * the served config is invalid.
+ * @module @linxin666/dsh-pet/client/renderers/Frames2dVisualMount
+ */
+import { useEffect, useRef, useState } from 'react';
+import { createPhaseStream } from "../phase-stream.js";
+import { defaultPetRendererRegistry } from "./registry.js";
+/** Mount the frames2d renderer as the sprite's visual (inside the chrome). */
+export function Frames2dVisualMount(props) {
+    const containerRef = useRef(null);
+    const streamRef = useRef(null);
+    const handleRef = useRef(null);
+    const [invalid, setInvalid] = useState(false);
+    // One activation per pet definition: build the contract context and mount.
+    useEffect(() => {
+        setInvalid(false);
+        const container = containerRef.current;
+        const frames2d = props.definition.frames2d;
+        if (container === null || frames2d === undefined)
+            return undefined;
+        streamRef.current ??= createPhaseStream(props.phase);
+        const cleanups = [];
+        const ctx = {
+            petId: props.definition.id,
+            assetBase: '/pet/' + encodeURIComponent(props.definition.id),
+            container,
+            phase: streamRef.current,
+            interact: props.onPet,
+            onCleanup: (fn) => { cleanups.push(fn); },
+        };
+        let handle;
+        try {
+            handle = defaultPetRendererRegistry.mount('frames2d', ctx, frames2d);
+        }
+        catch {
+            setInvalid(true);
+            return () => { for (const fn of cleanups.splice(0))
+                fn(); };
+        }
+        handleRef.current = handle;
+        // The gameplay HUD steers one shared override slot through the bus;
+        // mode rules (work blocks drag, sleep wakes on it) keep the two
+        // producers from fighting over the slot.
+        if (props.bus !== undefined) {
+            const gameplayBus = props.bus;
+            gameplayBus.setTrack = (track) => { handleRef.current?.setState(track); };
+            cleanups.push(() => { gameplayBus.setTrack = undefined; });
+        }
+        // The drag gesture drives the conventional 'drag' track when declared.
+        // On release, a declared gameplay.dragEndState (miku: standup) plays
+        // once; its fallback auto-releases the override back to the phase map.
+        const dragTrack = props.definition.gameplay?.dragState ?? (frames2d.tracks.drag === undefined ? undefined : 'drag');
+        const offDrag = props.drag.subscribe((dragging) => {
+            if (dragTrack === undefined)
+                return;
+            if (dragging) {
+                handle.setState(dragTrack);
+                return;
+            }
+            handle.setState(props.definition.gameplay?.dragEndState);
+        });
+        cleanups.push(offDrag);
+        return () => {
+            handleRef.current = null;
+            for (const fn of cleanups.splice(0))
+                fn();
+            handle.dispose();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- one activation per pet identity
+    }, [props.definition]);
+    // Feed the polled phase into the activation's stream (change-only).
+    useEffect(() => {
+        streamRef.current?.push(props.phase);
+    }, [props.phase]);
+    return (_jsx("div", { ref: containerRef, "data-dsh-pet-frames2d": props.definition.id, style: { width: '100%', height: '100%', pointerEvents: 'none' }, children: invalid && (_jsx("span", { "data-dsh-pet-frames2d-error": "invalid-config", children: props.t('pet.renderer.unavailable', { renderer: 'frames2d' }) })) }));
+}

package/lib/types/client/renderers/PetRendererSwitch.d.ts

@@ -11,6 +11,8 @@ import { type ReactElement, type ReactNode } from 'react';
 import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
 import type { PetDefinition } from '../../registry.ts';
 import type { ActivityPhase } from '../../state.ts';
+import { type DragStream } from '../drag-stream.ts';
+import type { GameplayBus } from '../gameplay-hud.tsx';
 import type { NS } from '../locales.ts';
 /** Dispatch one pet definition to its renderer; unknown kinds get a card. */
 export declare function PetRendererSwitch(props: {
@@ -19,6 +21,10 @@ export declare function PetRendererSwitch(props: {
     phase: ActivityPhase;
     /** The chrome's pet interaction (affinity write-back owner). */
     onPet: () => void;
+    /** External drag stream (gameplay HUD shares it); created locally otherwise. */
+    drag?: DragStream;
+    /** Gameplay coordination bus forwarded to the frames2d visual mount. */
+    bus?: GameplayBus;
     t: PropsLocale<typeof NS>['t'];
     children?: ReactNode;
 }): ReactElement;

package/lib/types/client/renderers/PetRendererSwitch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PetRendererSwitch.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/PetRendererSwitch.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAgC,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAInD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAA;AAEvC,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,UAAU,EAAE,aAAa,CAAA;IACzB,wDAAwD;IACxD,KAAK,EAAE,aAAa,CAAA;IACpB,gEAAgE;IAChE,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB,GAAG,YAAY,CAmBf"}
+{"version":3,"file":"PetRendererSwitch.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/PetRendererSwitch.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAwC,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAItD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAA;AAEvC,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,UAAU,EAAE,aAAa,CAAA;IACzB,wDAAwD;IACxD,KAAK,EAAE,aAAa,CAAA;IACpB,gEAAgE;IAChE,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,gFAAgF;IAChF,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,wEAAwE;IACxE,GAAG,CAAC,EAAE,WAAW,CAAA;IACjB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB,GAAG,YAAY,CAuCf"}

package/lib/types/client/renderers/PetRendererSwitch.js

@@ -8,14 +8,27 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
  * diagnostic card instead of blanking.
  * @module @linxin666/dsh-pet/client/renderers/PetRendererSwitch
  */
-import { cloneElement, isValidElement } from 'react';
+import { cloneElement, isValidElement, useRef } from 'react';
+import { createDragStream } from "../drag-stream.js";
 import { defaultPetRendererRegistry } from "./registry.js";
 import { Live2dVisualMount } from "./live2d/Live2dVisualMount.js";
+import { Frames2dVisualMount } from "./Frames2dVisualMount.js";
 /** Dispatch one pet definition to its renderer; unknown kinds get a card. */
 export function PetRendererSwitch(props) {
     const renderer = props.definition.renderer ?? 'sprite2d';
+    // The frames2d drag stream lives one level up: the chrome (PetSprite)
+    // reports the gesture through onDraggingChange, the visual subscribes.
+    const dragRef = useRef(null);
+    if (dragRef.current === null || dragRef.current.id !== props.definition.id) {
+        dragRef.current = { id: props.definition.id, stream: createDragStream() };
+    }
+    const drag = props.drag ?? dragRef.current.stream;
     if (renderer === 'sprite2d')
         return _jsx(_Fragment, { children: props.children });
+    if (renderer === 'frames2d' && defaultPetRendererRegistry.has('frames2d') && isValidElement(props.children)) {
+        const visual = (_jsx(Frames2dVisualMount, { definition: props.definition, phase: props.phase, onPet: props.onPet, drag: drag, ...(props.bus === undefined ? {} : { bus: props.bus }), t: props.t }));
+        return cloneElement(props.children, { visual, onDraggingChange: (dragging) => drag.push(dragging) });
+    }
     if (renderer === 'live2d' && defaultPetRendererRegistry.has('live2d') && isValidElement(props.children)) {
         const visual = (_jsx(Live2dVisualMount, { definition: props.definition, phase: props.phase, onPet: props.onPet, t: props.t }));
         return cloneElement(props.children, { visual });

package/lib/types/client/renderers/frames2d.d.ts

@@ -0,0 +1,36 @@
+/**
+ * frames2d renderer — plays the free-form named frame-sequence tracks of a
+ * frames2d pet (manifest v2 'frames2d' block). The pet center picks the
+ * track from the ActivityPhase stream (phase -> track map, idle fallback);
+ * the gameplay driver may force a track through the handle's setState
+ * override (drag/work/sleep/shop...), and a finished non-loop track settles
+ * into its fallback, releasing the override when the fallback matches the
+ * phase-mapped track. Rendering never throws: a broken track list degrades
+ * to the first decodable frame, and the 1.2 s stall watchdog re-kicks the
+ * playback chain after timer throttling.
+ * @module @linxin666/dsh-pet/client/renderers/frames2d
+ */
+import { type PetRenderer, type PetRendererHandle } from '../../contracts/renderer.ts';
+import type { ActivityPhase } from '../../state.ts';
+/** One track as served inside the pet definition (browser URLs). */
+export interface Frames2dTrackConfig {
+    frames: string[];
+    durations: number[];
+    loop: boolean;
+    fallback?: string;
+}
+/** The frames2d block as served inside the pet definition. */
+export interface PetFrames2dConfig {
+    tracks: Record<string, Frames2dTrackConfig>;
+    phases: Partial<Record<ActivityPhase, string>> & {
+        idle: string;
+    };
+}
+export interface Frames2dRendererHandle extends PetRendererHandle {
+    /** Force a track id (gameplay override); undefined returns to phase mapping. */
+    setState(track: string | undefined): void;
+    /** The track currently playing (diagnostics and tests). */
+    currentTrack(): string;
+}
+export declare const frames2dRenderer: PetRenderer<PetFrames2dConfig>;
+//# sourceMappingURL=frames2d.d.ts.map

package/lib/types/client/renderers/frames2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames2d.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/frames2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA4B,KAAK,WAAW,EAA2B,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACzI,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAC3C,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAClE;AAED,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;IACzC,2DAA2D;IAC3D,YAAY,IAAI,MAAM,CAAA;CACvB;AAoCD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,iBAAiB,CAgJ3D,CAAA"}

package/lib/types/client/renderers/frames2d.js

@@ -0,0 +1,196 @@
+/**
+ * frames2d renderer — plays the free-form named frame-sequence tracks of a
+ * frames2d pet (manifest v2 'frames2d' block). The pet center picks the
+ * track from the ActivityPhase stream (phase -> track map, idle fallback);
+ * the gameplay driver may force a track through the handle's setState
+ * override (drag/work/sleep/shop...), and a finished non-loop track settles
+ * into its fallback, releasing the override when the fallback matches the
+ * phase-mapped track. Rendering never throws: a broken track list degrades
+ * to the first decodable frame, and the 1.2 s stall watchdog re-kicks the
+ * playback chain after timer throttling.
+ * @module @linxin666/dsh-pet/client/renderers/frames2d
+ */
+import { PET_RENDERER_API_VERSION } from "../../contracts/renderer.js";
+/** Stall watchdog period: a looping track stuck longer re-kicks its chain. */
+const WATCHDOG_MS = 1200;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Fail-closed client-side validation of the served frames2d block. */
+function validateFrames2dConfig(config) {
+    if (!isRecord(config) || !isRecord(config.tracks) || !isRecord(config.phases)) {
+        throw new Error('frames2d config requires tracks and phases objects');
+    }
+    const tracks = {};
+    for (const [name, raw] of Object.entries(config.tracks)) {
+        if (!isRecord(raw) || !Array.isArray(raw.frames) || raw.frames.length === 0
+            || raw.frames.some(f => typeof f !== 'string' || f === '')
+            || !Array.isArray(raw.durations) || raw.durations.length !== raw.frames.length
+            || raw.durations.some(d => typeof d !== 'number' || !(d > 0))) {
+            throw new Error('frames2d track ' + JSON.stringify(name) + ' needs same-length frames/durations');
+        }
+        tracks[name] = {
+            frames: raw.frames,
+            durations: raw.durations,
+            loop: raw.loop !== false,
+            ...(typeof raw.fallback === 'string' ? { fallback: raw.fallback } : {}),
+        };
+    }
+    const phases = config.phases;
+    if (typeof phases.idle !== 'string' || tracks[phases.idle] === undefined) {
+        throw new Error('frames2d phases.idle must name an existing track');
+    }
+    return { tracks, phases: phases };
+}
+export const frames2dRenderer = {
+    id: 'frames2d',
+    apiVersion: PET_RENDERER_API_VERSION,
+    validateConfig: validateFrames2dConfig,
+    mount(ctx, config) {
+        const reducedMotion = typeof window !== 'undefined'
+            && typeof window.matchMedia === 'function'
+            && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+        const img = document.createElement('img');
+        img.dataset.dshPetFrames2d = ctx.petId;
+        img.alt = '';
+        img.draggable = false;
+        img.style.width = '100%';
+        img.style.height = '100%';
+        img.style.objectFit = 'contain';
+        img.style.pointerEvents = 'none';
+        ctx.container.appendChild(img);
+        // Warm the browser cache for every frame up front (same-origin, small
+        // webp files); playback itself swaps img.src without React state.
+        for (const track of Object.values(config.tracks)) {
+            for (const url of track.frames) {
+                const pre = new Image();
+                pre.src = url;
+            }
+        }
+        let disposed = false;
+        let timer;
+        let watchdog;
+        let track = config.phases.idle;
+        let frameIndex = 0;
+        let lastAdvance = Date.now();
+        let override;
+        const trackForPhase = (phase) => {
+            const mapped = config.phases[phase];
+            return mapped !== undefined && config.tracks[mapped] !== undefined ? mapped : config.phases.idle;
+        };
+        const show = (trackId, index) => {
+            const def = config.tracks[trackId];
+            const url = def?.frames[index];
+            if (url !== undefined && img.getAttribute('src') !== url)
+                img.src = url;
+        };
+        const schedule = (ms) => {
+            if (disposed)
+                return;
+            timer = setTimeout(tick, ms);
+        };
+        function tick() {
+            if (disposed)
+                return;
+            const def = config.tracks[track];
+            if (def === undefined || def.frames.length === 0)
+                return;
+            lastAdvance = Date.now();
+            const next = frameIndex + 1;
+            if (next < def.frames.length) {
+                frameIndex = next;
+                show(track, frameIndex);
+                schedule(def.durations[frameIndex] ?? 200);
+                return;
+            }
+            if (def.loop) {
+                frameIndex = 0;
+                show(track, frameIndex);
+                schedule(def.durations[frameIndex] ?? 200);
+                return;
+            }
+            // Non-loop completion: settle into the fallback; when the fallback is
+            // what the phase map would play anyway, release the gameplay override.
+            const target = def.fallback !== undefined && config.tracks[def.fallback] !== undefined
+                ? def.fallback
+                : config.phases.idle;
+            if (target === trackForPhase(ctx.phase.get()))
+                override = undefined;
+            play(target);
+        }
+        function play(trackId) {
+            if (disposed)
+                return;
+            if (config.tracks[trackId] === undefined)
+                trackId = config.phases.idle;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            track = trackId;
+            frameIndex = 0;
+            lastAdvance = Date.now();
+            show(track, frameIndex);
+            if (reducedMotion)
+                return;
+            const def = config.tracks[track];
+            schedule(def.durations[0] ?? 200);
+        }
+        const unsubscribe = ctx.phase.subscribe((phase) => {
+            if (override !== undefined)
+                return;
+            const target = trackForPhase(phase);
+            if (target !== track)
+                play(target);
+        });
+        // Watchdog: a throttled-away timer (background tab) leaves the chain
+        // dead; re-kick when a looping track has not advanced on schedule.
+        if (!reducedMotion) {
+            watchdog = setInterval(() => {
+                if (disposed)
+                    return;
+                const def = config.tracks[track];
+                if (def === undefined || !def.loop)
+                    return;
+                const expected = (def.durations[frameIndex] ?? 200) + WATCHDOG_MS;
+                if (Date.now() - lastAdvance > expected)
+                    tick();
+            }, WATCHDOG_MS);
+        }
+        play(track);
+        let disposedOnce = false;
+        const dispose = () => {
+            if (disposedOnce)
+                return;
+            disposedOnce = true;
+            disposed = true;
+            unsubscribe();
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (watchdog !== undefined)
+                clearInterval(watchdog);
+            img.remove();
+        };
+        ctx.onCleanup(dispose);
+        return {
+            dispose,
+            setState(next) {
+                if (disposed)
+                    return;
+                if (next === undefined) {
+                    override = undefined;
+                    const target = trackForPhase(ctx.phase.get());
+                    if (target !== track)
+                        play(target);
+                    return;
+                }
+                if (config.tracks[next] === undefined)
+                    return;
+                override = next;
+                if (next !== track)
+                    play(next);
+            },
+            currentTrack() {
+                return track;
+            },
+        };
+    },
+};

package/lib/types/defaults.d.ts

@@ -0,0 +1,6 @@
+/** Shared defaults used by registry selection and persisted-state migration. */
+/** Pet id that legacy single-pet installs and fresh registries resolve to. */
+export declare const DEFAULT_PET_ID = "whale-girl";
+/** Default pet name used only when a manifest carries no displayName. */
+export declare const DEFAULT_PET_NAME = "\u9CB8\u9C7C\u5A18";
+//# sourceMappingURL=defaults.d.ts.map

package/lib/types/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/defaults.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,8EAA8E;AAC9E,eAAO,MAAM,cAAc,eAAe,CAAA;AAE1C,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,uBAAQ,CAAA"}

package/lib/types/defaults.js

@@ -0,0 +1,5 @@
+/** Shared defaults used by registry selection and persisted-state migration. */
+/** Pet id that legacy single-pet installs and fresh registries resolve to. */
+export const DEFAULT_PET_ID = 'whale-girl';
+/** Default pet name used only when a manifest carries no displayName. */
+export const DEFAULT_PET_NAME = '鲸鱼娘';

package/lib/types/dsh-home.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dsh-home.d.ts","sourceRoot":"","sources":["../../src/dsh-home.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAKH,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAkB,GAAG,MAAM,CAIzE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,EAAE,IAAI,GAAE,MAAkB,GAAG,MAAM,CAOrG;AAED,gEAAgE;AAChE,wBAAgB,OAAO,IAAI,MAAM,CAEhC"}
+{"version":3,"file":"dsh-home.d.ts","sourceRoot":"","sources":["../../src/dsh-home.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAMH,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAkB,GAAG,MAAM,CAMzE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,EAAE,IAAI,GAAE,MAAkB,GAAG,MAAM,CAUrG;AAED,gEAAgE;AAChE,wBAAgB,OAAO,IAAI,MAAM,CAEhC"}

package/lib/types/dsh-home.js

@@ -6,12 +6,15 @@
  */
 import { homedir } from 'node:os';
 import { isAbsolute, join } from 'node:path';
+import { isAbsolute as posixIsAbsolute, join as posixJoin } from 'node:path/posix';
 /** Expand a leading ~ (or ~user) in a path, platform-style. */
 export function expandHome(path, home = homedir()) {
+    const isPosix = home.startsWith('/');
+    const j = isPosix ? posixJoin : join;
     if (path === '~')
         return home;
     if (path.startsWith('~/') || path.startsWith('~\\'))
-        return join(home, path.slice(2));
+        return j(home, path.slice(2));
     return path;
 }
 /**
@@ -21,12 +24,15 @@ export function expandHome(path, home = homedir()) {
  * @returns the absolute DSH home path.
  */
 export function resolveDshHome(env = process.env, home = homedir()) {
+    const isPosix = home.startsWith('/');
+    const j = isPosix ? posixJoin : join;
+    const isAbs = isPosix ? posixIsAbsolute : isAbsolute;
     const raw = env.DSH_HOME;
     if (raw !== undefined && raw.trim() !== '') {
         const expanded = expandHome(raw.trim(), home);
-        return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded);
+        return isAbs(expanded) ? expanded : j(process.cwd(), expanded);
     }
-    return join(home, '.dsh');
+    return j(home, '.dsh');
 }
 /** Resolve the DSH home directory from the live environment. */
 export function dshHome() {

package/lib/types/event-projection.d.ts

@@ -5,8 +5,11 @@
  * {@link ProjectionRuntime} per session and feed events in arrival order.
  *
  * Status copy comes from the chatter voice (big rotating pools, per-tool
- * families, real-argument hints), and streamed model output feeds the murmur
- * engine so the pet can whisper its inner voice (碎碎念). The wall clock is
+ * families, real-argument hints), and the projection feeds the murmur engine
+ * (碎碎念) with the SITUATION — thinking/writing during the stream, the
+ * running tool family on tool calls, and the STRUCTURED outcome on
+ * tool/result and turn/end — so the pet's inner voice always roughly knows
+ * what is going on and never mis-fires on output text. The wall clock is
  * injected by the caller, keeping every projection reproducible.
  * @module @linxin666/dsh-pet/event-projection
  */
@@ -22,18 +25,20 @@ export interface ActivityStatusEventLike {
 /** Per-session facts needed to project the official event stream. */
 export interface ProjectionRuntime {
     activeTools: Set<string>;
+    /** callIds whose tool looked like a test run, marked at tool/call (pet M6). */
+    testCalls: Set<string>;
     officialEventsSeen: boolean;
     stepHadFailure: boolean;
     /** Round-robin status copy voice (scene-stable, cadence-rotated). */
     voice: StatusVoice;
-    /** Inner-whisper engine fed by the model's own streamed output. */
+    /** Inner-whisper engine fed by the projection's situation and outcomes. */
     whispers: WhisperEngine;
 }
 /** One official event projection, optionally carrying a completed turn reward. */
 export interface PetActivityTransition {
     input: PetStateInput;
     completedTurn?: number;
-    /** A fresh inner whisper woken by this event's model output, when any. */
+    /** A fresh inner whisper woken by this event, when any. */
     whisper?: string;
 }
 /**

package/lib/types/event-projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-projection.d.ts","sourceRoot":"","sources":["../../src/event-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAe,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAE/F,2DAA2D;AAC3D,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACxB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,cAAc,EAAE,OAAO,CAAA;IACvB,qEAAqE;IACrE,KAAK,EAAE,WAAW,CAAA;IAClB,mEAAmE;IACnE,QAAQ,EAAE,aAAa,CAAA;CACxB;AAED,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,aAAa,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,CAQpF;AAQD,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,iBAAiB,EAC1B,KAAK,GAAE,MAAmB,GACzB,qBAAqB,GAAG,SAAS,CAwFnC"}
+{"version":3,"file":"event-projection.d.ts","sourceRoot":"","sources":["../../src/event-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EACL,WAAW,EAGX,aAAa,EAGb,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAA;AAErB,2DAA2D;AAC3D,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACxB,+EAA+E;IAC/E,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACtB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,cAAc,EAAE,OAAO,CAAA;IACvB,qEAAqE;IACrE,KAAK,EAAE,WAAW,CAAA;IAClB,2EAA2E;IAC3E,QAAQ,EAAE,aAAa,CAAA;CACxB;AAED,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,aAAa,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,CASpF;AAQD,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,iBAAiB,EAC1B,KAAK,GAAE,MAAmB,GACzB,qBAAqB,GAAG,SAAS,CAmHnC"}

package/lib/types/event-projection.js

@@ -5,12 +5,15 @@
  * {@link ProjectionRuntime} per session and feed events in arrival order.
  *
  * Status copy comes from the chatter voice (big rotating pools, per-tool
- * families, real-argument hints), and streamed model output feeds the murmur
- * engine so the pet can whisper its inner voice (碎碎念). The wall clock is
+ * families, real-argument hints), and the projection feeds the murmur engine
+ * (碎碎念) with the SITUATION — thinking/writing during the stream, the
+ * running tool family on tool calls, and the STRUCTURED outcome on
+ * tool/result and turn/end — so the pet's inner voice always roughly knows
+ * what is going on and never mis-fires on output text. The wall clock is
  * injected by the caller, keeping every projection reproducible.
  * @module @linxin666/dsh-pet/event-projection
  */
-import { StatusVoice, toolArgHint, WhisperEngine } from "./chatter.js";
+import { StatusVoice, toolArgHint, toolCategory, WhisperEngine, whisperCategoryOf, looksLikeTestTool, } from "./chatter.js";
 /**
  * Fresh projection runtime for a newly seen session. The optional voice-pack
  * provider (pet-center M4, issue #677) hands both chatter engines their
@@ -20,6 +23,7 @@ import { StatusVoice, toolArgHint, WhisperEngine } from "./chatter.js";
 export function emptyProjectionRuntime(pools) {
     return {
         activeTools: new Set(),
+        testCalls: new Set(),
         officialEventsSeen: false,
         stepHadFailure: false,
         voice: new StatusVoice(pools),
@@ -44,6 +48,7 @@ export function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
     switch (event.type) {
         case 'turn/start':
             runtime.activeTools.clear();
+            runtime.testCalls.clear();
             runtime.stepHadFailure = false;
             return { input: { phase: 'waiting', line: runtime.voice.scene('prepare', nowMs) } };
         case 'step/start':
@@ -53,14 +58,14 @@ export function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
         case 'assistant/chunk': {
             const { chunk } = event.data;
             if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-                const whisper = runtime.whispers.feed(chunk.text, nowMs);
+                const whisper = runtime.whispers.feed('thinking', nowMs);
                 return {
                     input: { phase: 'thinking', line: runtime.voice.scene('thinking', nowMs) },
                     ...(whisper === undefined ? {} : { whisper }),
                 };
             }
             if (chunk.type === 'text-delta' && chunk.text.length > 0) {
-                const whisper = runtime.whispers.feed(chunk.text, nowMs);
+                const whisper = runtime.whispers.feed('writing', nowMs);
                 return {
                     input: { phase: 'review', line: runtime.voice.scene('review', nowMs) },
                     ...(whisper === undefined ? {} : { whisper }),
@@ -70,40 +75,67 @@ export function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
         }
         case 'assistant/message':
             return { input: { phase: 'review', line: runtime.voice.scene('review', nowMs) } };
-        case 'tool/call':
-            runtime.activeTools.add(String(event.data.callId));
+        case 'tool/call': {
+            const callId = String(event.data.callId);
+            runtime.activeTools.add(callId);
+            // A test-looking call is remembered so its result (the only place the
+            // outcome is known) can wake the test-green mood later.
+            if (looksLikeTestTool(event.data.name, event.data.arguments))
+                runtime.testCalls.add(callId);
+            const whisper = runtime.whispers.feed(whisperCategoryOf(toolCategory(event.data.name)), nowMs);
             return {
                 input: {
                     phase: 'tool',
                     line: runtime.voice.tool(event.data.name, displayToolName(event.data.name), toolArgHint(event.data.name, event.data.arguments), nowMs),
                 },
+                ...(whisper === undefined ? {} : { whisper }),
             };
+        }
         case 'tool/result': {
             const block = event.data.message.content[0];
-            runtime.activeTools.delete(String(event.data.message.source.callId));
-            runtime.stepHadFailure ||= event.data.error !== undefined || block.isError === true;
+            const callId = String(event.data.message.source.callId);
+            const failed = event.data.error !== undefined || block.isError === true;
+            const wasTest = runtime.testCalls.delete(callId);
+            runtime.activeTools.delete(callId);
+            runtime.stepHadFailure ||= failed;
+            const whisper = failed
+                ? runtime.whispers.result('fail', nowMs)
+                : wasTest
+                    ? runtime.whispers.result('pass', nowMs)
+                    : undefined;
+            const whisperSpread = whisper === undefined ? {} : { whisper };
             if (runtime.activeTools.size > 0) {
                 return {
                     input: {
                         phase: 'tool',
                         line: runtime.voice.toolRemaining(runtime.activeTools.size, nowMs),
                     },
+                    ...whisperSpread,
                 };
             }
             return runtime.stepHadFailure
-                ? { input: { phase: 'failed', line: runtime.voice.scene('toolFailed', nowMs) } }
-                : { input: { phase: 'thinking', line: runtime.voice.scene('toolResult', nowMs) } };
+                ? { input: { phase: 'failed', line: runtime.voice.scene('toolFailed', nowMs) }, ...whisperSpread }
+                : { input: { phase: 'thinking', line: runtime.voice.scene('toolResult', nowMs) }, ...whisperSpread };
         }
         case 'turn/end': {
             runtime.activeTools.clear();
+            runtime.testCalls.clear();
             switch (event.data.reason.kind) {
-                case 'completed':
+                case 'completed': {
+                    const whisper = runtime.whispers.result('done', nowMs);
                     return {
                         input: { phase: 'done', line: runtime.voice.scene('done', nowMs) },
                         completedTurn: event.data.turn,
+                        ...(whisper === undefined ? {} : { whisper }),
+                    };
+                }
+                case 'error': {
+                    const whisper = runtime.whispers.result('fail', nowMs);
+                    return {
+                        input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) },
+                        ...(whisper === undefined ? {} : { whisper }),
                     };
-                case 'error':
-                    return { input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) } };
+                }
                 case 'max-tokens':
                     return { input: { phase: 'failed', line: runtime.voice.scene('maxTokens', nowMs) } };
                 case 'interrupted':