@linxin666/dsh-pet 0.2.3 → 0.2.4

package/src/chatter.ts

@@ -17,6 +17,11 @@
  * plugin has always shown, so existing installs keep their wording until the
  * scene cycles. No emoji anywhere (repository rule); ～ is the whale-girl's
  * signature.
+ *
+ * Since pet-center M4 (issue #677) every pool is overridable through a
+ * {@link VoicePoolsProvider}: the built-in pools are the fallback layer, and
+ * voice packs (per-pet voice.json / the global .voice.json) layer their
+ * pools on top at draw time.
  * @module @linxin666/dsh-pet/chatter
  */
 
@@ -193,6 +198,18 @@ export type ToolCategory =
   | 'ask'
   | 'generic'
 
+/** Every status scene key, in declaration order (voice-pack key allow-list). */
+export const STATUS_SCENES: readonly StatusScene[] = [
+  'prepare', 'waiting', 'thinking', 'review', 'toolResult', 'done',
+  'failed', 'toolFailed', 'maxTokens', 'interrupted', 'blocked',
+]
+
+/** Every tool-family key, in declaration order (voice-pack key allow-list). */
+export const TOOL_CATEGORIES: readonly ToolCategory[] = [
+  'read', 'write', 'edit', 'shell', 'grep', 'find', 'ls', 'webSearch',
+  'webFetch', 'mcp', 'memory', 'subagent', 'todo', 'browser', 'git', 'ask', 'generic',
+]
+
 /** Map a raw tool name onto its copy family (working-activity style regexes). */
 export function toolCategory(toolName: string): ToolCategory {
   const name = toolName.toLowerCase()
@@ -433,12 +450,19 @@ export function toolArgHint(toolName: string, argumentsJson: string): string | u
  * stretch keeps changing its wording.
  */
 export class StatusVoice {
+  private readonly pools: VoicePoolsProvider
+  private readonly rotateMs: number
   private readonly counters = new Map<string, number>()
   private lastScene = ''
   private lastLine = ''
   private lastLineAt = Number.NEGATIVE_INFINITY
 
-  constructor(private readonly rotateMs: number = STATUS_ROTATE_MS) {}
+  constructor(pools: VoicePoolsProvider = () => BUILTIN_VOICE_PACK, rotateMs: number = STATUS_ROTATE_MS) {
+    // Plain property assignment, not parameter properties: this module is
+    // imported by scripts/ under node's strip-only mode (pet-center M4).
+    this.pools = pools
+    this.rotateMs = rotateMs
+  }
 
   /** Draw the next line of one pool, advancing its round-robin cursor. */
   private draw(poolKey: string, pool: readonly string[]): string {
@@ -456,24 +480,38 @@ export class StatusVoice {
     return this.lastLine
   }
 
+  /**
+   * A scene's effective pool: the voice-pack override when it carries lines,
+   * else the built-in pool. Empty overrides fall back rather than blank the
+   * bubble — a scene line always renders.
+   */
+  private scenePool(scene: StatusScene): readonly string[] {
+    const override = this.pools().status?.[scene]
+    return override !== undefined && override.length > 0 ? override : STATUS_POOLS[scene]
+  }
+
   /** Status line for a phase scene. */
   scene(scene: StatusScene, nowMs: number): string {
-    return this.voice('scene:' + scene, 'pool:' + scene, STATUS_POOLS[scene], nowMs)
+    return this.voice('scene:' + scene, 'pool:' + scene, this.scenePool(scene), nowMs)
   }
 
   /** Status line for a tool call, with the real-argument hint when known. */
   tool(toolName: string, displayName: string, hint: string | undefined, nowMs: number): string {
     const category = toolCategory(toolName)
-    const line = this.voice('tool:' + category, 'tool:' + category, TOOL_POOLS[category], nowMs)
+    const override = this.pools().tools?.[category]
+    const pool = override !== undefined && override.length > 0 ? override : TOOL_POOLS[category]
+    const line = this.voice('tool:' + category, 'tool:' + category, pool, nowMs)
     return line
-      .replace('{tool}', displayName)
-      .replace('{hint}', hint ?? displayName)
+      .replaceAll('{tool}', displayName)
+      .replaceAll('{hint}', hint ?? displayName)
   }
 
   /** Status line while sibling tools still run (always reflects the count). */
   toolRemaining(count: number, nowMs: number): string {
-    return this.voice('toolRemaining', 'toolRemaining', TOOL_REMAINING_POOL, nowMs)
-      .replace('{n}', String(count))
+    const override = this.pools().toolRemaining
+    const pool = override !== undefined && override.length > 0 ? override : TOOL_REMAINING_POOL
+    return this.voice('toolRemaining', 'toolRemaining', pool, nowMs)
+      .replaceAll('{n}', String(count))
   }
 }
 
@@ -734,24 +772,89 @@ export const WHISPER_RULES: readonly WhisperRule[] = [
   },
 ]
 
+/**
+ * Voice-pack overrides (pet-center M4, issue #677): the content a voice
+ * pack can replace, one pool at a time. Every field is optional — missing
+ * keys inherit the built-in pools. Resolution happens at draw time through
+ * a provider function, so swapping pets (or editing the global file) re-
+ * voices live engines without rebuilding them.
+ *
+ * Override semantics:
+ *  - status/tools/toolRemaining: a non-empty override replaces the built-in
+ *    pool for that key; an empty override falls back to the built-in pool
+ *    (a scene line always renders, so it can never be blanked).
+ *  - whispers.generic / whispers.rules: the override REPLACES the built-in
+ *    section; an empty array mutes that channel (ambient or keyword).
+ */
+export interface VoicePackOverrides {
+  /** Status copy pools by scene; each key replaces that scene's pool. */
+  status?: Partial<Record<StatusScene, readonly string[]>>
+  /** Tool copy pools by family; each key replaces that family's pool. */
+  tools?: Partial<Record<ToolCategory, readonly string[]>>
+  /** The parallel-tools count line pool ({n} interpolates the count). */
+  toolRemaining?: readonly string[]
+  /** Murmur pools; each section replaces the built-in one as a whole. */
+  whispers?: {
+    /** Ambient inner-whisper pool (empty mutes ambient whispers). */
+    generic?: readonly string[]
+    /** Ordered keyword rules (empty disables keyword-triggered whispers). */
+    rules?: readonly WhisperRule[]
+  }
+}
+
+/** Read the current effective voice-pack overrides (draw-time resolution). */
+export type VoicePoolsProvider = () => VoicePackOverrides
+
+/** The built-in voice pack: the plugin's default copy, unchanged since v1. */
+export const BUILTIN_VOICE_PACK: VoicePackOverrides = {
+  status: STATUS_POOLS,
+  tools: TOOL_POOLS,
+  toolRemaining: TOOL_REMAINING_POOL,
+  whispers: { generic: WHISPER_GENERIC_POOL, rules: WHISPER_RULES },
+}
+
 /**
  * The murmur engine (碎碎念): watches the model's own output and lets the pet
  * whisper its inner voice. Two ways to earn a whisper:
  *  - a keyword rule matches the fresh chunk text (themed whisper);
  *  - enough output volume flowed by without one (ambient whisper).
  * A cooldown keeps whispers occasional; all picks are round-robin so tests
- * reproduce exact lines.
+ * reproduce exact lines. The voice-pack provider (pet-center M4) swaps the
+ * pools at draw time, so a pet switch re-voices live engines in place.
  */
 export class WhisperEngine {
+  private readonly pools: VoicePoolsProvider
+  private readonly cooldownMs: number
+  private readonly charBudget: number
   private readonly counters = new Map<number, number>()
   private genericCursor = 0
   private lastWhisperAt = Number.NEGATIVE_INFINITY
   private charsSinceWhisper = 0
 
   constructor(
-    private readonly cooldownMs: number = WHISPER_COOLDOWN_MS,
-    private readonly charBudget: number = WHISPER_CHAR_BUDGET,
-  ) {}
+    pools: VoicePoolsProvider = () => BUILTIN_VOICE_PACK,
+    cooldownMs: number = WHISPER_COOLDOWN_MS,
+    charBudget: number = WHISPER_CHAR_BUDGET,
+  ) {
+    this.pools = pools
+    this.cooldownMs = cooldownMs
+    this.charBudget = charBudget
+  }
+
+  /**
+   * Effective keyword rules: an override replaces the built-in rules as a
+   * whole; an explicit empty array disables keyword-triggered whispers.
+   */
+  private rules(): readonly WhisperRule[] {
+    const override = this.pools().whispers?.rules
+    return override === undefined ? WHISPER_RULES : override
+  }
+
+  /** Effective ambient pool (an explicit empty array mutes ambient whispers). */
+  private generic(): readonly string[] {
+    const override = this.pools().whispers?.generic
+    return override === undefined ? WHISPER_GENERIC_POOL : override
+  }
 
   /**
    * Feed one model-output chunk (reasoning or text). Returns the whisper to
@@ -765,8 +868,9 @@ export class WhisperEngine {
       return undefined
     }
     const haystack = text.toLowerCase()
-    for (let ruleIndex = 0; ruleIndex < WHISPER_RULES.length; ruleIndex += 1) {
-      const rule = WHISPER_RULES[ruleIndex]!
+    const rules = this.rules()
+    for (let ruleIndex = 0; ruleIndex < rules.length; ruleIndex += 1) {
+      const rule = rules[ruleIndex]!
       if (!rule.keywords.some(keyword => haystack.includes(keyword))) continue
       const index = (this.counters.get(ruleIndex) ?? 0) % rule.pool.length
       this.counters.set(ruleIndex, index + 1)
@@ -774,7 +878,9 @@ export class WhisperEngine {
     }
     this.charsSinceWhisper += text.length
     if (this.charsSinceWhisper < this.charBudget) return undefined
-    const line = WHISPER_GENERIC_POOL[this.genericCursor % WHISPER_GENERIC_POOL.length]!
+    const generic = this.generic()
+    if (generic.length === 0) return undefined
+    const line = generic[this.genericCursor % generic.length]!
     this.genericCursor += 1
     return this.speak(line, nowMs)
   }

package/src/client/PetSettingsCard.tsx

@@ -30,6 +30,8 @@ export interface PetSettings {
   bottom?: number
   /** Selected pet id (a registry entry). */
   petId?: string
+  /** Status-decoration master switch (pet-center M5, #567). */
+  decorationEnabled?: boolean
 }
 
 /** What the pet settings card renders. */
@@ -46,6 +48,8 @@ export interface PetSettingsCardState extends CardShell {
   bottom: CardFieldState
   /** Selected pet. */
   petId: CardFieldState
+  /** Status-decoration master switch. */
+  decorationEnabled: CardFieldState
   /** Pet choices (registry ids + display names), loaded from the host. */
   petChoices: readonly { value: string; label: string }[]
   /** Registry diagnostics (v1 migration hints, invalid entries), host-served. */
@@ -104,6 +108,7 @@ export class PetSettingsCardController {
   constructor(scope: SettingsScope<PetSettings>) {
     this.form = new CardForm(scope, [
       booleanField('enabled'),
+      booleanField('decorationEnabled'),
       booleanField('visible'),
       numberField('size'),
       numberField('right'),
@@ -146,6 +151,7 @@ export class PetSettingsCardController {
     return {
       ...this.form.shell(),
       enabled: this.form.field('enabled'),
+      decorationEnabled: this.form.field('decorationEnabled'),
       visible: this.form.field('visible'),
       size: this.form.field('size'),
       right: this.form.field('right'),
@@ -215,6 +221,18 @@ export function PetSettingsCard(props: PetSettingsCardProps) {
         onEdit={(text) => { props.edit('enabled', text) }}
         onReset={() => { props.resetField('enabled') }}
       />
+      <BooleanField
+        id="settings-pet-decoration"
+        label={t('settings.decoration')}
+        hint={t('settings.decorationHint')}
+        inheritLabel={t('settings.inherit')}
+        onLabel={t('settings.on')}
+        offLabel={t('settings.off')}
+        {...fieldProps}
+        {...state.decorationEnabled}
+        onEdit={(text) => { props.edit('decorationEnabled', text) }}
+        onReset={() => { props.resetField('decorationEnabled') }}
+      />
       <ChoiceField
         id="settings-pet-pet"
         label={t('settings.pet')}

package/src/client/PetSprite.test.tsx

@@ -11,6 +11,7 @@ import { t } from './locales.ts'
 import type { PetStateView } from '../service.ts'
 import type { PetDefinition, PetTrackDef } from '../registry.ts'
 import type { PetAnimation } from '../state.ts'
+import type { DecorationView } from '../contracts/status-decoration.ts'
 
 /** A minimal pet definition (geometry + tracks) as served by the host. */
 function petDefinition(): PetDefinition {
@@ -91,14 +92,9 @@ afterEach(() => {
   vi.restoreAllMocks()
 })
 
-/** Render the pet with mocked callbacks; returns the rename and open spys. */
-function renderPet(overrides: Partial<PetSpriteProps> = {}): {
-  onRename: ReturnType<typeof vi.fn>
-  onOpenSession: ReturnType<typeof vi.fn>
-} {
-  const onRename = vi.fn()
-  const onOpenSession = vi.fn()
-  const props: PetSpriteProps = {
+/** Build the mocked props for one render. */
+function petProps(overrides: Partial<PetSpriteProps> = {}): PetSpriteProps {
+  return {
     snapshot,
     definition: petDefinition(),
     display: snapshot.display,
@@ -107,14 +103,24 @@ function renderPet(overrides: Partial<PetSpriteProps> = {}): {
     onFeed: vi.fn(),
     onHide: vi.fn(),
     onDragEnd: vi.fn(),
-    onRename,
-    onOpenSession,
+    onRename: vi.fn(),
+    onOpenSession: vi.fn(),
     onFeedbackDone: vi.fn(),
     t,
     ...overrides,
   }
-  render(<PetSprite {...props} />)
-  return { onRename, onOpenSession }
+}
+
+/** Render the pet with mocked callbacks; returns the rename/open spys + the RTL result. */
+function renderPet(overrides: Partial<PetSpriteProps> = {}): {
+  onRename: ReturnType<typeof vi.fn>
+  onOpenSession: ReturnType<typeof vi.fn>
+  result: ReturnType<typeof render>
+} {
+  const onRename = vi.fn()
+  const onOpenSession = vi.fn()
+  const result = render(<PetSprite {...petProps({ onRename, onOpenSession, ...overrides })} />)
+  return { onRename, onOpenSession, result }
 }
 
 /** Hover the sprite to open the panel, then click the rename button. */
@@ -555,3 +561,239 @@ describe('PetSprite definition-driven render', () => {
     expect(sprite.style.backgroundPosition).toBe('0px -960px')
   })
 })
+
+describe('PetSprite panel chrome from the voice pack (pet-center M4)', () => {
+  const voicedDefinition = (): PetDefinition => ({
+    ...petDefinition(),
+    panel: {
+      labels: { feed: '投喂', rename: '起名字', hide: '藏起来', confirm: '好的' },
+      stats: { rank: '好感 {rank}', treats: '鱼干 {n}', points: '{points} 分' },
+    },
+  })
+
+  it('renders pack labels and stat formats, falling back per slot', () => {
+    renderPet({ definition: voicedDefinition() })
+    fireEvent.pointerOver(screen.getByRole('button', { name: '鲸鱼娘' }))
+    expect(screen.getByText('投喂')).toBeDefined()
+    expect(screen.getByText('起名字')).toBeDefined()
+    expect(screen.getByText('藏起来')).toBeDefined()
+    expect(screen.getByText('好感 幼鲸')).toBeDefined()
+    expect(screen.getByText('鱼干 3')).toBeDefined()
+    expect(screen.getByText('0 分')).toBeDefined()
+  })
+
+  it('uses the pack confirm label inside the rename row', () => {
+    renderPet({ definition: voicedDefinition() })
+    fireEvent.pointerOver(screen.getByRole('button', { name: '鲸鱼娘' }))
+    fireEvent.click(screen.getByText('起名字'))
+    expect(screen.getByText('好的')).toBeDefined()
+  })
+
+  it('hides actions the pack omits', () => {
+    renderPet({
+      definition: {
+        ...petDefinition(),
+        panel: { labels: { feed: '投喂' }, actions: ['feed'] },
+      },
+    })
+    fireEvent.pointerOver(screen.getByRole('button', { name: '鲸鱼娘' }))
+    expect(screen.getByText('投喂')).toBeDefined()
+    expect(screen.queryByText('改名')).toBeNull()
+    expect(screen.queryByText('隐藏')).toBeNull()
+  })
+
+  it('renders no action buttons when the pack hides them all', () => {
+    renderPet({ definition: { ...petDefinition(), panel: { actions: [] } } })
+    fireEvent.pointerOver(screen.getByRole('button', { name: '鲸鱼娘' }))
+    expect(screen.queryByText('喂食')).toBeNull()
+    expect(screen.queryByText('改名')).toBeNull()
+    expect(screen.queryByText('隐藏')).toBeNull()
+    // The stat rows keep rendering.
+    expect(screen.getByText('亲密度 幼鲸')).toBeDefined()
+    expect(screen.getByText('小鱼干 ×3')).toBeDefined()
+  })
+
+  it('keeps the i18n copy when the pet carries no panel', () => {
+    renderPet()
+    fireEvent.pointerOver(screen.getByRole('button', { name: '鲸鱼娘' }))
+    expect(screen.getByText('喂食')).toBeDefined()
+    expect(screen.getByText('改名')).toBeDefined()
+    expect(screen.getByText('隐藏')).toBeDefined()
+    expect(screen.getByText('亲密度 幼鲸')).toBeDefined()
+  })
+
+  it('substitutes cross-slot placeholders in pack stat formats', () => {
+    renderPet({ definition: { ...petDefinition(), panel: { stats: { treats: '鱼干 {n}（{points} 分，{rank}）' } } } })
+    fireEvent.pointerOver(screen.getByRole('button', { name: '鲸鱼娘' }))
+    // The host whitelists {rank}/{n}/{points} in every stat slot, so a pack
+    // format may reference any of them; all three live values substitute.
+    expect(screen.getByText('鱼干 3（0 分，幼鲸）')).toBeDefined()
+  })
+})
+describe('PetSprite status decoration (pet-center M5, #567)', () => {
+  const decoration: DecorationView = {
+    apiVersion: 'x-org.linxin666.pet-center/status-decoration-v1',
+    id: 'whale',
+    assetBase: '/api/pet/decoration/whale',
+    entryUrl: '/api/pet/decoration/whale/whale-frames.png',
+    cell: { width: 64, height: 48 },
+    columns: 4,
+    durations: [160, 160, 160, 160],
+    loop: true,
+    phases: {
+      idle: 'hide',
+      waiting: { from: 0, to: 1 },
+      thinking: { from: 0, to: 3 },
+      done: { from: 2, to: 3 },
+    },
+  }
+
+  const ornament = (): HTMLElement | null => document.body.querySelector('[data-dsh-pet-decoration="whale"]')
+
+  it('renders an aria-hidden ornament inside the status bubble for a bound phase', () => {
+    renderPet({ snapshot: { ...snapshot, bubble: '正在思考', phase: 'thinking', decoration } })
+    const el = ornament()
+    expect(el).not.toBeNull()
+    expect(el!.getAttribute('aria-hidden')).toBe('true')
+    expect(el!.style.backgroundImage).toContain('whale-frames.png')
+    // The bubble keeps its semantics beside the ornament.
+    const bubble = document.body.querySelector('[role="status"][aria-live="polite"]')
+    expect(bubble).not.toBeNull()
+    expect(bubble!.textContent).toContain('正在思考')
+  })
+
+  it('hides the ornament for phases bound to hide and for the idle default', () => {
+    renderPet({ snapshot: { ...snapshot, bubble: '等待', phase: 'idle', decoration } })
+    expect(ornament()).toBeNull()
+  })
+
+  it('holds the segment first frame under prefers-reduced-motion', () => {
+    renderPet({ snapshot: { ...snapshot, bubble: '完成', phase: 'done', decoration } })
+    const el = ornament()
+    expect(el).not.toBeNull()
+    // The harness matchMedia mock reports reduced motion, so the ornament
+    // rests on the segment's first frame (column 2 of a 24px-wide frame).
+    expect(el!.style.backgroundPosition).toBe('-48px 0px')
+  })
+
+  it('yields the bubble to the whisper (voice moment hides the ornament)', () => {
+    renderPet({ snapshot: { ...snapshot, phase: 'thinking', whisper: '冲了冲了', decoration } })
+    expect(ornament()).toBeNull()
+    expect(document.body.textContent).toContain('冲了冲了')
+  })
+
+  it('renders no ornament when the host serves no decoration', () => {
+    renderPet({ snapshot: { ...snapshot, bubble: '正在思考', phase: 'thinking' } })
+    expect(ornament()).toBeNull()
+  })
+
+  it('advances the ornament frames on the rAF loop and wraps when looping', () => {
+    vi.spyOn(window, 'matchMedia').mockReturnValue({
+      matches: false,
+      media: '(prefers-reduced-motion: reduce)',
+      onchange: null,
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      addListener: () => {},
+      removeListener: () => {},
+      dispatchEvent: () => false,
+    })
+    vi.spyOn(performance, 'now').mockReturnValue(0)
+    const frames: FrameRequestCallback[] = []
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation(callback => {
+      frames.push(callback)
+      return frames.length
+    })
+    vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {})
+    renderPet({ snapshot: { ...snapshot, bubble: '正在思考', phase: 'thinking', decoration } })
+    const el = ornament()!
+    // Both the sprite loop and the ornament loop schedule frames; step every
+    // pending callback together (the sprite's idle track never moves).
+    const step = (ts: number): void => { for (const callback of frames.splice(0)) callback(ts) }
+    // frameWidth = round(64 * 18 / 48) = 24 px; thinking binds frames 0..3.
+    expect(el.style.backgroundPosition).toBe('0px 0px')
+    act(() => { step(161) })
+    expect(el.style.backgroundPosition).toBe('-24px 0px')
+    act(() => { step(322) })
+    expect(el.style.backgroundPosition).toBe('-48px 0px')
+    act(() => { step(483) })
+    expect(el.style.backgroundPosition).toBe('-72px 0px')
+    act(() => { step(644) })
+    // The looping segment wraps back to its first frame.
+    expect(el.style.backgroundPosition).toBe('0px 0px')
+  })
+
+  it('holds the segment last frame when the loop is off and stops scheduling', () => {
+    vi.spyOn(window, 'matchMedia').mockReturnValue({
+      matches: false,
+      media: '(prefers-reduced-motion: reduce)',
+      onchange: null,
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      addListener: () => {},
+      removeListener: () => {},
+      dispatchEvent: () => false,
+    })
+    vi.spyOn(performance, 'now').mockReturnValue(0)
+    const frames: FrameRequestCallback[] = []
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation(callback => {
+      frames.push(callback)
+      return frames.length
+    })
+    vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {})
+    renderPet({ snapshot: { ...snapshot, bubble: '完成', phase: 'done', decoration: { ...decoration, loop: false } } })
+    const el = ornament()!
+    const step = (ts: number): void => { for (const callback of frames.splice(0)) callback(ts) }
+    // done binds frames 2..3; the segment starts on frame 2.
+    expect(el.style.backgroundPosition).toBe('-48px 0px')
+    act(() => { step(161) })
+    expect(el.style.backgroundPosition).toBe('-72px 0px')
+    // The ornament stopped scheduling (only the sprite loop remains pending).
+    expect(frames).toHaveLength(1)
+    act(() => { step(161) })
+    // The last frame holds.
+    expect(el.style.backgroundPosition).toBe('-72px 0px')
+  })
+
+  it('does not restart the frame loop when an equal-content decoration re-renders', () => {
+    vi.spyOn(window, 'matchMedia').mockReturnValue({
+      matches: false,
+      media: '(prefers-reduced-motion: reduce)',
+      onchange: null,
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      addListener: () => {},
+      removeListener: () => {},
+      dispatchEvent: () => false,
+    })
+    vi.spyOn(performance, 'now').mockReturnValue(0)
+    const frames: FrameRequestCallback[] = []
+    const rafSpy = vi.spyOn(window, 'requestAnimationFrame').mockImplementation(callback => {
+      frames.push(callback)
+      return frames.length
+    })
+    const cancelSpy = vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {})
+    // The definition comes from '/api/pet/pets', fetched once — a state
+    // poll never replaces it, so both renders share one definition object.
+    const definition = petDefinition()
+    const { result } = renderPet({ definition, snapshot: { ...snapshot, bubble: '正在思考', phase: 'thinking', decoration } })
+    const step = (ts: number): void => { for (const callback of frames.splice(0)) callback(ts) }
+    act(() => { step(161) })
+    expect(ornament()!.style.backgroundPosition).toBe('-24px 0px')
+    const schedulesBefore = rafSpy.mock.calls.length
+    // The 2 s poll delivers a fresh JSON round-trip: identical content, new
+    // object identities everywhere. The loop must not cancel/restart.
+    const repolled: DecorationView = {
+      ...decoration,
+      cell: { ...decoration.cell },
+      durations: [...decoration.durations],
+      phases: { ...decoration.phases },
+    }
+    result.rerender(<PetSprite {...petProps({ definition, snapshot: { ...snapshot, bubble: '正在思考', phase: 'thinking', decoration: repolled } })} />)
+    act(() => { step(322) })
+    expect(ornament()!.style.backgroundPosition).toBe('-48px 0px')
+    expect(cancelSpy).not.toHaveBeenCalled()
+    // One reschedule per loop tick; no effect restart added new schedules.
+    expect(rafSpy.mock.calls.length).toBe(schedulesBefore + 2)
+  })
+})