@linxin666/dsh-pet 0.3.4 → 0.3.6

package/lib/types/client/PetSprite.js

@@ -360,14 +360,14 @@ export function PetSprite(props) {
     const statusBubble = feedback === null && sessionBubbles.length === 0
         ? snapshot?.bubble
         : undefined;
-    // The display session's inner whisper (碎碎念) — short inner-voice copy
-    // woken by the model's output. Instead of a second bubble of its own, a
-    // fresh whisper takes over the display session's bubble (the stack top, or
-    // the single status bubble) and re-tints it, so the pet never wears two
-    // voices at once. Interaction feedback takes over the whole bubble area
-    // while it plays, so whispers yield to it like status copy.
-    const whisper = feedback === null ? snapshot?.whisper : undefined;
-    const bubblePresent = feedback !== null || sessionBubbles.length > 0 || statusBubble !== undefined || whisper !== undefined;
+    // Each session's inner whisper (碎碎念) rides its own bubble — short
+    // inner-voice copy woken by that session's activity, never the model's or
+    // another session's. Instead of a second bubble of its own, a fresh
+    // whisper takes over its session's bubble and re-tints it, so the pet
+    // never wears two voices at once. Interaction feedback takes over the
+    // whole bubble area while it plays, so whispers yield to it like status
+    // copy.
+    const bubblePresent = feedback !== null || sessionBubbles.length > 0 || statusBubble !== undefined;
     const displayName = snapshot?.name ?? definition.displayName;
     // The host-served status decoration (M5, #567); absent = text-only bubbles.
     const decoration = snapshot?.decoration;
@@ -447,14 +447,13 @@ export function PetSprite(props) {
                             }
                         }
                         props.onPet();
-                    }, role: "button", "aria-label": definition.displayName, children: props.visual }) }), props.hud, feedback !== null && (_jsx("div", { ref: bubbleRef, className: clsx(styles.bubble, feedback.kind === 'feed' ? styles.bubbleFeed : styles.bubblePet), children: feedback.text }, feedback.at)), feedback === null && (sessionBubbles.length > 0 || statusBubble !== undefined || whisper !== undefined) && (_jsxs("div", { ref: bubbleRef, className: styles.bubbleStack, onPointerEnter: () => setStackPeek(true), onPointerLeave: () => setStackPeek(false), children: [visibleSessions.map((session, index) => {
-                        // The whisper rides the display session's bubble — the stack's
-                        // primary entry (DOM-first, rendered bottom-most by the reversed
-                        // column so it stays glued to the sprite when extras open above).
-                        // The key swap restarts the entrance animation so the mood change
-                        // reads as the bubble re-speaking.
-                        const speaksWhisper = index === 0 && whisper !== undefined;
-                        const bubble = (_jsxs("button", { type: "button", className: clsx(styles.bubble, styles.bubbleStatus, styles.bubbleClickable, speaksWhisper && styles.bubbleWhisper), title: props.t('pet.openSessionHint'), onClick: () => { props.onOpenSession(session.sessionId); }, children: [index === 0 && !speaksWhisper && decoration !== undefined && (_jsx(StatusOrnament, { decoration: decoration, phase: phase })), speaksWhisper ? whisper : session.bubble] }, speaksWhisper ? 'whisper:' + whisper : session.sessionId));
+                    }, role: "button", "aria-label": definition.displayName, children: props.visual }) }), props.hud, feedback !== null && (_jsx("div", { ref: bubbleRef, className: clsx(styles.bubble, feedback.kind === 'feed' ? styles.bubbleFeed : styles.bubblePet), children: feedback.text }, feedback.at)), feedback === null && (sessionBubbles.length > 0 || statusBubble !== undefined) && (_jsxs("div", { ref: bubbleRef, className: styles.bubbleStack, onPointerEnter: () => setStackPeek(true), onPointerLeave: () => setStackPeek(false), children: [visibleSessions.map((session, index) => {
+                        // A session's whisper rides ITS OWN bubble (the stack lead when
+                        // the current session has one, any bubble when the stack is
+                        // expanded). The key swap restarts the entrance animation so the
+                        // mood change reads as the bubble re-speaking.
+                        const speaksWhisper = session.whisper !== undefined;
+                        const bubble = (_jsxs("button", { type: "button", className: clsx(styles.bubble, styles.bubbleStatus, styles.bubbleClickable, speaksWhisper && styles.bubbleWhisper), title: props.t('pet.openSessionHint'), onClick: () => { props.onOpenSession(session.sessionId); }, children: [index === 0 && !speaksWhisper && decoration !== undefined && (_jsx(StatusOrnament, { decoration: decoration, phase: phase })), session.whisper ?? session.bubble] }, speaksWhisper ? 'whisper:' + session.whisper : session.sessionId));
                         // The primary bubble carries the '+N' badge while other sessions
                         // hide behind it; the badge toggles the pinned (touch) expansion.
                         if (index !== 0 || sessionBubbles.length <= 1)
@@ -467,7 +466,7 @@ export function PetSprite(props) {
                                         e.stopPropagation();
                                         setStackPinned(open => !open);
                                     }, children: stackOpen ? '×' : '+' + String(sessionBubbles.length - 1) })] }, "primary"));
-                    }), sessionBubbles.length === 0 && (statusBubble !== undefined || whisper !== undefined) && (_jsxs("div", { className: clsx(styles.bubble, styles.bubbleStatus, whisper !== undefined && styles.bubbleWhisper), role: "status", "aria-live": "polite", children: [whisper === undefined && decoration !== undefined && (_jsx(StatusOrnament, { decoration: decoration, phase: phase })), whisper ?? statusBubble] }, whisper === undefined ? 'status' : 'whisper:' + whisper))] })), hovered && dragRef.current === null && (_jsx("div", { ref: panelRef, className: clsx(styles.panel, panelAbove && styles.panelAbove), "data-placement": panelAbove ? 'above' : 'below', style: panelAbove && panelLift > 0
+                    }), sessionBubbles.length === 0 && statusBubble !== undefined && (_jsxs("div", { className: clsx(styles.bubble, styles.bubbleStatus), role: "status", "aria-live": "polite", children: [decoration !== undefined && (_jsx(StatusOrnament, { decoration: decoration, phase: phase })), statusBubble] }, "status"))] })), hovered && dragRef.current === null && (_jsx("div", { ref: panelRef, className: clsx(styles.panel, panelAbove && styles.panelAbove), "data-placement": panelAbove ? 'above' : 'below', style: panelAbove && panelLift > 0
                     ? { marginBottom: panelLift }
                     : undefined, onPointerEnter: () => {
                     // Reaching the panel (or its bridge) must cancel any hide timer
@@ -499,7 +498,13 @@ export function PetSprite(props) {
                                     props.onRename(trimmed);
                                     setRenaming(false);
                                 }
-                            }, children: panelLabel('confirm', props.t('pet.confirm')) })] })) : (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.rankRow, children: [_jsx("span", { className: styles.nameCell, children: displayName }), _jsx("span", { className: styles.statRank, children: panelStat('rank', 'pet.rank', { rank: snapshot?.affinity.rank ?? '?' }) })] }), _jsxs("div", { className: styles.rankRow, children: [_jsx("span", { className: styles.statTreats, children: panelStat('treats', 'pet.treats', { n: snapshot?.treats.stocked ?? 0 }) }), _jsx("span", { className: styles.statPoints, children: panelStat('points', 'pet.points', { points: snapshot?.affinity.points ?? 0 }) })] }), _jsxs("div", { className: styles.actions, children: [panelShows('feed') && (_jsx("button", { type: "button", className: styles.action, onClick: props.onFeed, children: panelLabel('feed', props.t('pet.feed')) })), panelShows('rename') && (_jsx("button", { type: "button", className: styles.action, onClick: () => {
+                            }, children: panelLabel('confirm', props.t('pet.confirm')) })] })) : (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.rankRow, children: [_jsx("span", { className: styles.nameCell, children: displayName }), _jsx("span", { className: styles.statRank, children: (() => {
+                                        const rawRank = snapshot?.affinity.rank ?? '?';
+                                        const rankKey = `pet.rank.name.${rawRank}`;
+                                        const localized = props.t(rankKey);
+                                        const rankName = localized !== rankKey ? localized : rawRank;
+                                        return panelStat('rank', 'pet.rank', { rank: rankName });
+                                    })() })] }), _jsxs("div", { className: styles.rankRow, children: [_jsx("span", { className: styles.statTreats, children: panelStat('treats', 'pet.treats', { n: snapshot?.treats.stocked ?? 0 }) }), _jsx("span", { className: styles.statPoints, children: panelStat('points', 'pet.points', { points: snapshot?.affinity.points ?? 0 }) })] }), _jsxs("div", { className: styles.actions, children: [panelShows('feed') && (_jsx("button", { type: "button", className: styles.action, onClick: props.onFeed, children: panelLabel('feed', props.t('pet.feed')) })), panelShows('rename') && (_jsx("button", { type: "button", className: styles.action, onClick: () => {
                                         // Cancel any pending hide so the rename box cannot
                                         // unmount right as the user starts typing (#303).
                                         clearHideTimer();

package/lib/types/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAwB,aAAa,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAA;AA0EnI,wEAAwE;AACxE,eAAO,MAAM,MAAM,UAA2E,CAAA;AAE9F,qEAAqE;AACrE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACxE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC7D,YAAY,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACtF,YAAY,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf;;;;WAIG;QACH,aAAa,CAAC,EAAE;YAAE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;SAAE,CAAA;KAC1E;CACF;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CA+R9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAwB,aAAa,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAA;AA4EnI,wEAAwE;AACxE,eAAO,MAAM,MAAM,UAA2E,CAAA;AAE9F,qEAAqE;AACrE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACxE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC7D,YAAY,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACtF,YAAY,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf;;;;WAIG;QACH,aAAa,CAAC,EAAE;YAAE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;SAAE,CAAA;KAC1E;CACF;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAgT9C"}

package/lib/types/client/index.js

@@ -37,7 +37,8 @@ async function petFetch(path, body) {
 }
 /** The live host API instance (always defined; failures surface per call). */
 const petApi = {
-    state: () => petFetch('/api/pet/state'),
+    state: (currentSessionId) => petFetch('/api/pet/state'
+        + (currentSessionId === undefined ? '' : '?current=' + encodeURIComponent(currentSessionId))),
     pets: () => petFetch('/api/pet/pets'),
     interact: (kind) => petFetch('/api/pet/interact', { kind }),
     setVisible: (visible) => petFetch('/api/pet/set-visible', { visible }),
@@ -142,6 +143,19 @@ export function apply(ctx) {
             const setPets = petStore.actions.setPets;
             const setState = petStore.actions.setState;
             const setFeedback = petStore.actions.setFeedback;
+            // Clicking a session bubble jumps the GUI to that session; the same
+            // sessions face reports which session the user is currently on, so the
+            // host can lead the bubble stack with it. A bubble can outlive its
+            // disposed session by one poll tick, and the sessions service fails
+            // loud on unknown ids, so consult the live list first. The pet's type
+            // program also loads the host-side dsh-session package through the
+            // service types, whose Context merge declares a different 'sessions'
+            // face; pin the browser runtime's outward face here.
+            const sessions = ctx.sessions;
+            const currentSessionId = () => {
+                const current = sessions.list.getSnapshot().current;
+                return current === undefined ? undefined : String(current);
+            };
             // The registry list is fetched lazily with retries baked into the poll
             // cycle: until it lands, the dock entry renders nothing and every 2s
             // tick tries again. After it lands, one list feeds both the sprite and
@@ -163,7 +177,7 @@ export function apply(ctx) {
                 }
                 const seq = stateSeq + 1;
                 stateSeq = seq;
-                petApi.state().then((snapshot) => {
+                petApi.state(currentSessionId()).then((snapshot) => {
                     if (seq !== stateSeq)
                         return;
                     setSnapshot(snapshot);
@@ -207,13 +221,16 @@ export function apply(ctx) {
                     document.removeEventListener('visibilitychange', onVisibility);
                 };
             }, 'pet: poll');
-            // Clicking a session bubble jumps the GUI to that session. A bubble
-            // can outlive its disposed session by one poll tick, and the sessions
-            // service fails loud on unknown ids, so consult the live list first.
-            // The pet's type program also loads the host-side dsh-session package
-            // through the service types, whose Context merge declares a different
-            // 'sessions' face; pin the browser runtime's outward face here.
-            const sessions = ctx.sessions;
+            // A current-session switch should re-order the bubble stack right away,
+            // not on the next 2s tick. Poll only while the tab is visible, as the
+            // poll loop itself does.
+            const disposeSessionWatch = ctx.effect(() => {
+                const unsubscribe = sessions.list.subscribe(() => {
+                    if (document.visibilityState === 'visible')
+                        pollNow();
+                });
+                return unsubscribe;
+            }, 'pet: current-session watch');
             const openSession = (sessionId) => {
                 const list = sessions.list.getSnapshot();
                 if (list.byId[sessionId] === undefined)

package/lib/types/client/locales.d.ts

@@ -13,6 +13,15 @@ export declare const zh: {
     readonly 'pet.namePlaceholder': "输入新名字";
     readonly 'pet.summon': "召唤{name}";
     readonly 'pet.rank': "亲密度 {rank}";
+    readonly 'pet.rank.name.\u5E7C\u9CB8': "幼鲸";
+    readonly 'pet.rank.name.\u4F19\u4F34': "伙伴";
+    readonly 'pet.rank.name.\u631A\u53CB': "挚友";
+    readonly 'pet.rank.name.\u6DF1\u6D77\u7F81\u7ECA': "深海羁绊";
+    readonly 'pet.rank.name.\u5FC3\u6709\u7075\u7280': "心有灵犀";
+    readonly 'pet.rank.name.\u4F20\u8BF4\u7F81\u7ECA': "传说羁绊";
+    readonly 'pet.rank.name.\u795E\u8BDD\u7F81\u7ECA': "神话羁绊";
+    readonly 'pet.rank.name.\u6C38\u6052\u4E4B\u5951': "永恒之契";
+    readonly 'pet.rank.name.\u9CB8\u751F\u5171\u6E21': "鲸生共渡";
     readonly 'pet.points': "{points} 点";
     readonly 'pet.treats': "小鱼干 ×{n}";
     readonly 'pet.state.loading': "宠物正在赶来…";
@@ -83,6 +92,15 @@ export declare const en: {
     readonly 'pet.namePlaceholder': "Enter a new name";
     readonly 'pet.summon': "Summon {name}";
     readonly 'pet.rank': "Affinity {rank}";
+    readonly 'pet.rank.name.\u5E7C\u9CB8': "Baby Whale";
+    readonly 'pet.rank.name.\u4F19\u4F34': "Companion";
+    readonly 'pet.rank.name.\u631A\u53CB': "Close Friend";
+    readonly 'pet.rank.name.\u6DF1\u6D77\u7F81\u7ECA': "Deep Sea Bond";
+    readonly 'pet.rank.name.\u5FC3\u6709\u7075\u7280': "Kindred Spirit";
+    readonly 'pet.rank.name.\u4F20\u8BF4\u7F81\u7ECA': "Legendary Bond";
+    readonly 'pet.rank.name.\u795E\u8BDD\u7F81\u7ECA': "Mythic Bond";
+    readonly 'pet.rank.name.\u6C38\u6052\u4E4B\u5951': "Eternal Covenant";
+    readonly 'pet.rank.name.\u9CB8\u751F\u5171\u6E21': "Lifelong Companion";
     readonly 'pet.points': "{points} pts";
     readonly 'pet.treats': "Treats ×{n}";
     readonly 'pet.state.loading': "The pet is on its way…";

package/lib/types/client/locales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,mDAAmD;AACnD,eAAO,MAAM,EAAE,QAAQ,CAAA;AAEvB,oBAAoB;AACpB,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEL,CAAA;AAEV,oBAAoB;AACpB,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEL,CAAA;AAEV,oCAAoC;AACpC,MAAM,MAAM,MAAM,GAAG,MAAM,OAAO,EAAE,CAAA;AAEpC,qDAAqD;AACrD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA;AAEpC;;;;;GAKG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAGnD;AAED;;;;;;;GAOG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAQvE;AAED,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,uBAAuB;QACvB,GAAG,EAAE,MAAM,CAAA;KACZ;CACF"}
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,mDAAmD;AACnD,eAAO,MAAM,EAAE,QAAQ,CAAA;AAEvB,oBAAoB;AACpB,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+EL,CAAA;AAEV,oBAAoB;AACpB,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+EL,CAAA;AAEV,oCAAoC;AACpC,MAAM,MAAM,MAAM,GAAG,MAAM,OAAO,EAAE,CAAA;AAEpC,qDAAqD;AACrD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA;AAEpC;;;;;GAKG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAGnD;AAED;;;;;;;GAOG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAQvE;AAED,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,uBAAuB;QACvB,GAAG,EAAE,MAAM,CAAA;KACZ;CACF"}

package/lib/types/client/locales.js

@@ -13,6 +13,15 @@ export const zh = {
     'pet.namePlaceholder': '输入新名字',
     'pet.summon': '召唤{name}',
     'pet.rank': '亲密度 {rank}',
+    'pet.rank.name.幼鲸': '幼鲸',
+    'pet.rank.name.伙伴': '伙伴',
+    'pet.rank.name.挚友': '挚友',
+    'pet.rank.name.深海羁绊': '深海羁绊',
+    'pet.rank.name.心有灵犀': '心有灵犀',
+    'pet.rank.name.传说羁绊': '传说羁绊',
+    'pet.rank.name.神话羁绊': '神话羁绊',
+    'pet.rank.name.永恒之契': '永恒之契',
+    'pet.rank.name.鲸生共渡': '鲸生共渡',
     'pet.points': '{points} 点',
     'pet.treats': '小鱼干 ×{n}',
     'pet.state.loading': '宠物正在赶来…',
@@ -85,6 +94,15 @@ export const en = {
     'pet.namePlaceholder': 'Enter a new name',
     'pet.summon': 'Summon {name}',
     'pet.rank': 'Affinity {rank}',
+    'pet.rank.name.幼鲸': 'Baby Whale',
+    'pet.rank.name.伙伴': 'Companion',
+    'pet.rank.name.挚友': 'Close Friend',
+    'pet.rank.name.深海羁绊': 'Deep Sea Bond',
+    'pet.rank.name.心有灵犀': 'Kindred Spirit',
+    'pet.rank.name.传说羁绊': 'Legendary Bond',
+    'pet.rank.name.神话羁绊': 'Mythic Bond',
+    'pet.rank.name.永恒之契': 'Eternal Covenant',
+    'pet.rank.name.鲸生共渡': 'Lifelong Companion',
     'pet.points': '{points} pts',
     'pet.treats': 'Treats ×{n}',
     'pet.state.loading': 'The pet is on its way…',

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

@@ -8,6 +8,18 @@
  * 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.
+ *
+ * Frame presentation has two modes picked once at mount by capability
+ * probing:
+ * - Canvas bitmap buffer (default where createImageBitmap/fetch/2D context
+ *   exist): every frame is decoded exactly once into an ImageBitmap during
+ *   the warm pass and drawn onto one <canvas> - steady-state playback issues
+ *   zero DOM mutations and zero re-decodes (measured hotspot: swapping
+ *   <img>.src per frame drove image decode + invalidation every tick).
+ * - Classic <img> fallback (jsdom/tests or missing APIs): identical to the
+ *   historical behavior - cache-warm Image elements plus guarded src swaps,
+ *   so environments without modern decoding keep working unchanged.
+ *
  * @module @linxin666/dsh-pet/client/renderers/frames2d
  */
 import { type PetRenderer, type PetRendererHandle } from '../../contracts/renderer.ts';

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

@@ -1 +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"}
+{"version":3,"file":"frames2d.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/frames2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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;AA0CD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,iBAAiB,CAsP3D,CAAA"}

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

@@ -8,6 +8,18 @@
  * 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.
+ *
+ * Frame presentation has two modes picked once at mount by capability
+ * probing:
+ * - Canvas bitmap buffer (default where createImageBitmap/fetch/2D context
+ *   exist): every frame is decoded exactly once into an ImageBitmap during
+ *   the warm pass and drawn onto one <canvas> - steady-state playback issues
+ *   zero DOM mutations and zero re-decodes (measured hotspot: swapping
+ *   <img>.src per frame drove image decode + invalidation every tick).
+ * - Classic <img> fallback (jsdom/tests or missing APIs): identical to the
+ *   historical behavior - cache-warm Image elements plus guarded src swaps,
+ *   so environments without modern decoding keep working unchanged.
+ *
  * @module @linxin666/dsh-pet/client/renderers/frames2d
  */
 import { PET_RENDERER_API_VERSION } from "../../contracts/renderer.js";
@@ -50,23 +62,83 @@ export const frames2dRenderer = {
         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;
+        // Capability probe: the canvas path needs decode-to-bitmap, same-origin
+        // fetch, and a real 2D context (jsdom returns null and falls back below).
+        let canvas = null;
+        let context2d = null;
+        let img = null;
+        try {
+            if (typeof createImageBitmap === 'function' && typeof fetch === 'function') {
+                const probe = document.createElement('canvas');
+                const c2d = probe.getContext('2d');
+                if (c2d !== null) {
+                    canvas = probe;
+                    context2d = c2d;
+                }
             }
         }
+        catch {
+            canvas = null;
+            context2d = null;
+        }
+        if (canvas !== null && context2d !== null) {
+            canvas.dataset.dshPetFrames2d = ctx.petId;
+            canvas.draggable = false;
+            canvas.style.width = '100%';
+            canvas.style.height = '100%';
+            canvas.style.objectFit = 'contain';
+            canvas.style.pointerEvents = 'none';
+            ctx.container.appendChild(canvas);
+        }
+        else {
+            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);
+        }
+        // Decode cache: one concurrent decode per URL, memoized forever (frames
+        // are tiny same-origin webp files; failures resolve undefined and keep
+        // the last painted frame instead of breaking playback).
+        const decoding = new Map();
+        const decodedAll = [];
+        const loadFrame = (url) => {
+            const cached = decoding.get(url);
+            if (cached !== undefined)
+                return cached;
+            const job = (async () => {
+                try {
+                    const response = await fetch(url);
+                    if (!response.ok)
+                        throw new Error('http ' + response.status);
+                    const bitmap = await createImageBitmap(await response.blob());
+                    return { source: bitmap, width: bitmap.width, height: bitmap.height };
+                }
+                catch {
+                    // Fail-open: classic Image decode keeps non-modern runtimes alive.
+                    return await new Promise((resolve) => {
+                        try {
+                            const pre = new Image();
+                            pre.onload = () => {
+                                resolve(pre.naturalWidth > 0 ? { source: pre, width: pre.naturalWidth, height: pre.naturalHeight } : undefined);
+                            };
+                            pre.onerror = () => resolve(undefined);
+                            pre.src = url;
+                        }
+                        catch {
+                            resolve(undefined);
+                        }
+                    });
+                }
+            })();
+            decoding.set(url, job);
+            decodedAll.push(job.then(() => undefined, () => undefined));
+            return job;
+        };
         let disposed = false;
         let timer;
         let watchdog;
@@ -74,15 +146,45 @@ export const frames2dRenderer = {
         let frameIndex = 0;
         let lastAdvance = Date.now();
         let override;
+        let drawToken = 0;
+        let lastDrawnUrl;
         const trackForPhase = (phase) => {
             const mapped = config.phases[phase];
             return mapped !== undefined && config.tracks[mapped] !== undefined ? mapped : config.phases.idle;
         };
+        /** Canvas path: paints the newest requested frame; stale draws drop out. */
+        const paintCanvas = (url) => {
+            if (context2d === null || canvas === null)
+                return;
+            const myToken = ++drawToken;
+            void loadFrame(url).then((frame) => {
+                if (disposed || frame === undefined || myToken !== drawToken)
+                    return;
+                if (lastDrawnUrl === url)
+                    return;
+                lastDrawnUrl = url;
+                // Resizing clears the canvas, so size only when it actually differs.
+                if (canvas.width !== frame.width || canvas.height !== frame.height) {
+                    canvas.width = frame.width;
+                    canvas.height = frame.height;
+                }
+                else {
+                    context2d.clearRect(0, 0, canvas.width, canvas.height);
+                }
+                context2d.drawImage(frame.source, 0, 0);
+            }).catch(() => { });
+        };
         const show = (trackId, index) => {
             const def = config.tracks[trackId];
             const url = def?.frames[index];
-            if (url !== undefined && img.getAttribute('src') !== url)
-                img.src = url;
+            if (url === undefined)
+                return;
+            if (img !== null) {
+                if (img.getAttribute('src') !== url)
+                    img.src = url;
+                return;
+            }
+            paintCanvas(url);
         };
         const schedule = (ms) => {
             if (disposed)
@@ -155,6 +257,13 @@ export const frames2dRenderer = {
                     tick();
             }, WATCHDOG_MS);
         }
+        // Warm pass: decode every frame up front (tiny same-origin webp files)
+        // so loops and phase switches never wait on a first decode - same intent
+        // as the historical Image-cache warm loop, now feeding the decode cache.
+        for (const warmTrack of Object.values(config.tracks)) {
+            for (const warmUrl of warmTrack.frames)
+                void loadFrame(warmUrl);
+        }
         play(track);
         let disposedOnce = false;
         const dispose = () => {
@@ -167,7 +276,23 @@ export const frames2dRenderer = {
                 clearTimeout(timer);
             if (watchdog !== undefined)
                 clearInterval(watchdog);
-            img.remove();
+            // Release decoded bitmaps after pending decodes settle; close() is
+            // browser-only, so guard it for exotic hosts.
+            void Promise.allSettled(decodedAll).then(() => {
+                for (const job of decoding.values()) {
+                    void job.then((frame) => {
+                        try {
+                            const maybeClose = frame?.source?.close;
+                            if (typeof maybeClose === 'function' && frame !== undefined)
+                                maybeClose.call(frame.source);
+                        }
+                        catch { /* already released */ }
+                    }).catch(() => { });
+                }
+                decoding.clear();
+            });
+            canvas?.remove();
+            img?.remove();
         };
         ctx.onCleanup(dispose);
         return {

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':