@linxin666/dsh-pet 0.3.16 → 0.3.18

package/src/client/gameplay-hud.tsx

@@ -11,7 +11,7 @@
 
 import { useEffect, useLayoutEffect, useRef, useState, useSyncExternalStore, type ReactElement } from 'react'
 import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots'
-import type { PetDefinition } from '../registry.ts'
+import type { PetDefinition, PetSkinDefinition } from '../registry.ts'
 import type { PetGameplayVerbResult } from '../service.ts'
 import { touchZoneAt } from '../gameplay.ts'
 import type { PetStoreInstance } from './pet-store.ts'
@@ -35,6 +35,8 @@ export interface GameplayApi {
  */
 export interface GameplayBus {
   setTrack?: (track?: string) => void
+  /** Swap the pet's base idle track (skin switch); undefined restores default. */
+  setIdleTrack?: (track?: string) => void
   tap?: (fx: number, fy: number) => void
   /**
    * Card open/close request from the chrome (the hover panel's 玩法 action):
@@ -44,7 +46,7 @@ export interface GameplayBus {
   openCard?: (open?: boolean) => void
 }
 
-type HudPage = 'root' | 'shop'
+type HudPage = 'root' | 'shop' | 'skins'
 
 /** One floating toast (prize / insufficient funds). */
 interface HudFloat {
@@ -71,6 +73,10 @@ export function GameplayHud(props: {
 
   const [open, setOpen] = useState(false)
   const [page, setPage] = useState<HudPage>('root')
+  // Currently selected skin id (base idle swap); undefined = default look.
+  const [skinId, setSkinId] = useState<string | undefined>(undefined)
+  const skinIdRef = useRef<string | undefined>(undefined)
+  skinIdRef.current = skinId
   const hudRef = useRef<HTMLDivElement | null>(null)
   const cardRef = useRef<HTMLDivElement | null>(null)
   const [floats, setFloats] = useState<HudFloat[]>([])
@@ -104,8 +110,32 @@ export function GameplayHud(props: {
   // Tap handling (registered on the bus; PetSprite reports sprite-box
   // fractions). Sleep wakes on tap; work blocks taps; a held touch
   // animation turns taps into the plain-click boost.
+  // Skin contract: while a skin is selected, taps only ever play that
+  // skin's own click actions — a miss resolves to the plain click boost,
+  // never the default touch zones (so a skinned pet cannot trigger the
+  // default pet's shy/work reactions).
   useEffect(() => {
     if (def === undefined) return undefined
+    // Play a one-shot override track and lock tap input for its duration so
+    // consecutive taps cannot retrigger mid-play (skin click actions and
+    // default touch-zone reactions share this path).
+    const holdTrack = (track: string, holdMs: number): void => {
+      bus.setTrack?.(track)
+      touchLockUntilRef.current = Date.now() + holdMs
+      window.setTimeout(() => {
+        if (Date.now() >= touchLockUntilRef.current) bus.setTrack?.(undefined)
+      }, holdMs)
+    }
+    const speak = (phrases?: string[]): void => {
+      if (phrases !== undefined && phrases.length > 0) {
+        const phrase = phrases[Math.floor(Math.random() * phrases.length)]!
+        store.actions.setFeedback({ text: phrase, kind: 'none', at: Date.now() })
+      }
+    }
+    // Total play time of a track in ms (its fallback lands back in the skin
+    // base idle, so holding the lock for the full loop is unnecessary).
+    const trackDuration = (track: string): number =>
+      definition.frames2d?.tracks[track]?.durations.reduce((sum, ms) => sum + ms, 0) ?? 0
     bus.tap = (fx, fy) => {
       if (modeRef.current === 'sleep') {
         void api.setMode(null).then(applyResult, () => undefined)
@@ -120,19 +150,34 @@ export function GameplayHud(props: {
         void api.touch().then(applyResult, () => undefined)
         return
       }
+      const activeSkin = definition.frames2d?.skins?.find(skin => skin.id === skinIdRef.current)
+      if (activeSkin !== undefined) {
+        // Skin click actions roll first (declared order, cumulative
+        // probabilities); on a hit play the action's track once. A miss
+        // stays on the plain click boost — never the default touch zones.
+        const actions = activeSkin.clickActions ?? []
+        if (actions.length > 0) {
+          let roll = Math.random()
+          const fired = actions.find(action => {
+            if (roll < action.probability) return true
+            roll -= action.probability
+            return false
+          })
+          if (fired !== undefined) {
+            holdTrack(fired.track, trackDuration(fired.track) || 3000)
+            speak(fired.phrases)
+            return
+          }
+        }
+        void api.touch().then(applyResult, () => undefined)
+        return
+      }
       const zone = def.touch === undefined ? undefined : touchZoneAt(def.touch, hy)
       if (zone === undefined) return
       void api.touch(zone.name).then((result) => {
         applyResult(result)
         if (result.hit !== true) return
-        if (result.state !== undefined) {
-          bus.setTrack?.(result.state)
-          const holdMs = result.stateMs ?? 3000
-          touchLockUntilRef.current = Date.now() + holdMs
-          window.setTimeout(() => {
-            if (Date.now() >= touchLockUntilRef.current) bus.setTrack?.(undefined)
-          }, holdMs)
-        }
+        if (result.state !== undefined) holdTrack(result.state, result.stateMs ?? 3000)
         if (result.phrase !== undefined) {
           store.actions.setFeedback({ text: result.phrase, kind: 'none', at: Date.now() })
         }
@@ -269,13 +314,17 @@ export function GameplayHud(props: {
   }, [definition.id, def, view?.mode])
 
   // Sleep loop: hold the sleep track; restore is host-side (lazy settle).
+  // While a skin with a gameplayTracks.sleep override is selected, the skin's
+  // own track replaces the default sleep track (e.g. a skin-specific doze).
   useEffect(() => {
     const sleep = def?.sleep
     if (def === undefined || sleep === undefined || view?.mode !== 'sleep') return undefined
-    bus.setTrack?.(sleep.state)
+    const skinGameplay = definition.frames2d?.skins?.find(skin => skin.id === skinIdRef.current)?.gameplayTracks
+    const hold = skinGameplay?.['sleep'] ?? sleep.state
+    bus.setTrack?.(hold)
     return () => bus.setTrack?.(undefined)
     // eslint-disable-next-line react-hooks/exhaustive-deps -- the loop keys on the mode value
-  }, [definition.id, def, view?.mode])
+  }, [definition.id, def, view?.mode, skinId])
 
   if (def === undefined || view === undefined) return null
 
@@ -303,6 +352,12 @@ export function GameplayHud(props: {
     void api.setMode(next).then(applyResult, () => undefined)
   }
 
+  const skins = definition.frames2d?.skins
+  const selectSkin = (skin: PetSkinDefinition | undefined): void => {
+    setSkinId(skin?.id)
+    bus.setIdleTrack?.(skin?.idleTrack)
+  }
+
   return (
     <div ref={hudRef} className={styles.gameplayHud} data-dsh-pet-gameplay={definition.id}>
       {floats.map(entry => (
@@ -334,15 +389,6 @@ export function GameplayHud(props: {
                 })}
               </div>
               <div className={styles.gameplayActions}>
-                {def.work !== undefined && (
-                  <button
-                    type="button"
-                    className={styles.action}
-                    onClick={() => setMode(mode === 'work' ? null : 'work')}
-                  >
-                    {tr(mode === 'work' ? 'pet.gameplay.stopWork' : 'pet.gameplay.work')}
-                  </button>
-                )}
                 {def.sleep !== undefined && (
                   <button
                     type="button"
@@ -357,6 +403,20 @@ export function GameplayHud(props: {
                     {tr('pet.gameplay.shop')}
                   </button>
                 )}
+                {skins !== undefined && skins.length > 0 && (
+                  <button type="button" className={styles.action} onClick={() => setPage('skins')}>
+                    {tr('pet.gameplay.skin')}
+                  </button>
+                )}
+                {def.work !== undefined && (
+                  <button
+                    type="button"
+                    className={styles.action}
+                    onClick={() => setMode(mode === 'work' ? null : 'work')}
+                  >
+                    {tr(mode === 'work' ? 'pet.gameplay.stopWork' : 'pet.gameplay.work')}
+                  </button>
+                )}
               </div>
             </>
           )}
@@ -388,6 +448,34 @@ export function GameplayHud(props: {
               </div>
             </>
           )}
+          {page === 'skins' && skins !== undefined && (
+            <>
+              <div className={styles.gameplaySkinItems}>
+                <button
+                  type="button"
+                  className={skinId === undefined ? styles.gameplaySkinItem + ' ' + styles.gameplaySkinItemActive : styles.gameplaySkinItem}
+                  onClick={() => selectSkin(undefined)}
+                >
+                  {tr('pet.gameplay.skinDefault')}
+                </button>
+                {skins.map(skin => (
+                  <button
+                    key={skin.id}
+                    type="button"
+                    className={skinId === skin.id ? styles.gameplaySkinItem + ' ' + styles.gameplaySkinItemActive : styles.gameplaySkinItem}
+                    onClick={() => selectSkin(skin)}
+                  >
+                    {skin.label}
+                  </button>
+                ))}
+              </div>
+              <div className={styles.gameplayActions}>
+                <button type="button" className={styles.action} onClick={() => setPage('root')}>
+                  {tr('pet.gameplay.back')}
+                </button>
+              </div>
+            </>
+          )}
           <button
             type="button"
             className={styles.gameplayClose}

package/src/client/index.ts

@@ -122,6 +122,18 @@ declare module '@deepseek-ai/cordis' {
  * first-level settings section.
  * @param ctx - client root context.
  */
+
+/**
+ * Module-wide work-tick throttle (ms). Hot reloads can leave several
+ * GameplayHud instances alive, each running its own 10s work interval;
+ * without a shared gate every interval would call workTick and each stale
+ * call re-rolls, re-grants treats and re-plays the success/fail track, so
+ * the outcome appears to play several times per window. This shared marker
+ * accepts the first adjudication of a window and silently suppresses the
+ * duplicates that follow. Reset when (re-)entering work mode.
+ */
+let lastWorkTickAt = 0
+
 export function apply(ctx: ClientContext): void {
   // Anonymous install heartbeat (docs/telemetry.md): one beat per browser per
   // UTC day, package name only, silent failure.
@@ -359,8 +371,20 @@ export function apply(ctx: ClientContext): void {
         },
         gameplay: {
           touch: (zone) => petApi.gameplayTouch(zone),
-          setMode: (mode) => petApi.gameplaySetMode(mode),
-          workTick: () => petApi.gameplayWorkTick(),
+          setMode: async (mode) => {
+            if (mode === 'work') lastWorkTickAt = 0
+            return petApi.gameplaySetMode(mode)
+          },
+          workTick: async () => {
+            // One adjudication per tick window, page-wide: suppress stale
+            // duplicate intervals (HMR) re-playing the result track.
+            const now = Date.now()
+            if (now - lastWorkTickAt < 8500) {
+              return { ok: true } as PetGameplayVerbResult
+            }
+            lastWorkTickAt = now
+            return petApi.gameplayWorkTick()
+          },
           buy: (item) => petApi.gameplayBuy(item),
         },
       })

package/src/client/locales.ts

@@ -37,9 +37,11 @@ export const zh = {
   'pet.gameplay.menu': '玩法',
   'pet.gameplay.work': '打工',
   'pet.gameplay.stopWork': '收工',
-  'pet.gameplay.sleep': '睡觉',
+  'pet.gameplay.sleep': '休息',
   'pet.gameplay.wake': '起床',
   'pet.gameplay.shop': '商店',
+  'pet.gameplay.skin': '皮肤',
+  'pet.gameplay.skinDefault': '默认',
   'pet.gameplay.back': '返回',
   'pet.gameplay.buy': '购买',
   'pet.gameplay.insufficient': '{currency}不足',
@@ -66,7 +68,7 @@ export const zh = {
   'settings.visible': '显示宠物',
   'settings.visibleHint': '关闭后宠物隐藏，可从聊天输入区重新召唤。',
   'settings.size': '大小（px）',
-  'settings.sizeHint': '精灵单元高度，范围 32–512。',
+  'settings.sizeHint': '精灵单元高度，范围 32–1024。',
   'settings.right': '距右侧（px）',
   'settings.rightHint': '距视口右边缘的水平内缩距离。',
   'settings.bottom': '距底部（px）',
@@ -122,6 +124,8 @@ export const en = {
   'pet.gameplay.sleep': 'Sleep',
   'pet.gameplay.wake': 'Wake up',
   'pet.gameplay.shop': 'Shop',
+  'pet.gameplay.skin': 'Skin',
+  'pet.gameplay.skinDefault': 'Default',
   'pet.gameplay.back': 'Back',
   'pet.gameplay.buy': 'Buy',
   'pet.gameplay.insufficient': 'Not enough {currency}',
@@ -148,7 +152,7 @@ export const en = {
   'settings.visible': 'Show the pet',
   'settings.visibleHint': 'When off, the pet hides; summon it again from the input row.',
   'settings.size': 'Size (px)',
-  'settings.sizeHint': 'Sprite cell height, 32\u2013512.',
+  'settings.sizeHint': 'Sprite cell height, 32\u20131024.',
   'settings.right': 'Right inset (px)',
   'settings.rightHint': 'Horizontal inset from the viewport right edge.',
   'settings.bottom': 'Bottom inset (px)',

package/src/client/pet.module.css

@@ -46,7 +46,7 @@
   background: rgba(3, 105, 161, 0.95);
 }
 
-/* 状态气泡：虎鲸蓝黑渐变玻璃 + DeepSeek 蓝描边微光 + 进场浮现。
+/* 状态气泡：皮肤底色玻璃 + 皮肤描边微光 + 进场浮现。
    碎碎念不再单独渲染第二只气泡，也不换色调，而是以 .bubbleWhisper
    接管这同一只气泡的文案，气泡栈内所有气泡共用同一片玻璃。 */
 .bubbleStatus {
@@ -546,6 +546,36 @@
   color: #ffd27e;
 }
 
+.gameplaySkinItems {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 8px;
+}
+
+.gameplaySkinItem {
+  display: block;
+  width: 100%;
+  padding: 8px 10px;
+  border: 1px solid rgba(126, 152, 255, 0.25);
+  border-radius: 8px;
+  background: rgba(126, 152, 255, 0.08);
+  color: inherit;
+  cursor: pointer;
+  text-align: left;
+  font-size: 12px;
+}
+
+.gameplaySkinItem:hover {
+  border-color: rgba(126, 152, 255, 0.7);
+  background: rgba(126, 152, 255, 0.16);
+}
+
+.gameplaySkinItemActive {
+  border-color: rgba(126, 152, 255, 0.9);
+  background: rgba(126, 152, 255, 0.28);
+}
+
 .gameplayClose {
   position: absolute;
   top: 4px;

package/src/client/renderers/Frames2dVisualMount.tsx

@@ -67,7 +67,11 @@ export function Frames2dVisualMount(props: {
     if (props.bus !== undefined) {
       const gameplayBus = props.bus
       gameplayBus.setTrack = (track) => { handleRef.current?.setState(track) }
-      cleanups.push(() => { gameplayBus.setTrack = undefined })
+      gameplayBus.setIdleTrack = (track) => { handleRef.current?.setIdleTrack(track) }
+      cleanups.push(() => {
+        gameplayBus.setTrack = undefined
+        gameplayBus.setIdleTrack = undefined
+      })
     }
     // The drag gesture drives the conventional 'drag' track when declared.
     // On release, a declared gameplay.dragEndState (miku: standup) plays

package/src/client/renderers/frames2d.test.ts

@@ -113,6 +113,49 @@ describe('frames2dRenderer', () => {
     handle.dispose()
   })
 
+  it('swaps the base idle target via setIdleTrack (skin semantics)', () => {
+    const skinConfig: PetFrames2dConfig = {
+      tracks: {
+        idle: { frames: ['/pet/miku/idle/1.webp'], durations: [100], loop: true },
+        skin: { frames: ['/pet/miku/skin/1.webp'], durations: [100], loop: true },
+        happy: { frames: ['/pet/miku/happy/1.webp'], durations: [100], loop: false, fallback: 'idle' },
+      },
+      phases: { idle: 'idle' },
+      skins: [{ id: 's1', label: 'S1', idleTrack: 'skin' }],
+    }
+    const { ctx, img } = setup()
+    const handle = frames2dRenderer.mount(ctx, frames2dRenderer.validateConfig(skinConfig)) as Frames2dRendererHandle
+    expect(handle.currentTrack()).toBe('idle')
+    // Selecting the skin swaps the base idle immediately (no override held).
+    handle.setIdleTrack('skin')
+    expect(handle.currentTrack()).toBe('skin')
+    expect(img().getAttribute('src')).toBe('/pet/miku/skin/1.webp')
+    // A gameplay override still plays, then settles into the skin idle.
+    handle.setState('happy')
+    expect(handle.currentTrack()).toBe('happy')
+    vi.advanceTimersByTime(150)
+    expect(handle.currentTrack()).toBe('skin')
+    // Restoring undefined returns to the manifest idle target.
+    handle.setIdleTrack(undefined)
+    expect(handle.currentTrack()).toBe('idle')
+    // Unknown skin tracks are ignored.
+    handle.setIdleTrack('ghost')
+    expect(handle.currentTrack()).toBe('idle')
+    handle.dispose()
+  })
+
+  it('drops skins whose idleTrack is missing or non-looping in validateConfig', () => {
+    const parsed = frames2dRenderer.validateConfig({
+      ...CONFIG,
+      skins: [
+        { id: 'good', label: 'Good', idleTrack: 'idle' },
+        { id: 'loop', label: 'Loop', idleTrack: 'happy' },
+        { id: 'ghost', label: 'Ghost', idleTrack: 'nope' },
+      ],
+    })
+    expect(parsed.skins).toEqual([{ id: 'good', label: 'Good', idleTrack: 'idle' }])
+  })
+
   it('re-kicks a stalled looping track via the watchdog', () => {
     const { ctx, img } = setup()
     const handle = frames2dRenderer.mount(ctx, frames2dRenderer.validateConfig(CONFIG)) as Frames2dRendererHandle

package/src/client/renderers/frames2d.ts

@@ -38,11 +38,38 @@ export interface Frames2dTrackConfig {
 export interface PetFrames2dConfig {
   tracks: Record<string, Frames2dTrackConfig>
   phases: Partial<Record<ActivityPhase, string>> & { idle: string }
+  /** Selectable skins; each swaps the base idle target while selected. */
+  skins?: Frames2dSkinConfig[]
+}
+
+/** One selectable skins entry as served inside the pet definition. */
+export interface Frames2dSkinConfig {
+  id: string
+  label: string
+  /** A declared looping track that becomes the base idle while selected. */
+  idleTrack: string
+  /** Click actions exclusive to this skin (roll by probability; miss → touch zones). */
+  clickActions?: Frames2dSkinClickActionConfig[]
+  /** Gameplay-state overrides (state -> track) swapped in while selected. */
+  gameplayTracks?: Record<string, string>
+}
+
+/** One probability-rolled tap action a skin may declare. */
+export interface Frames2dSkinClickActionConfig {
+  track: string
+  probability: number
+  phrases?: string[]
 }
 
 export interface Frames2dRendererHandle extends PetRendererHandle {
   /** Force a track id (gameplay override); undefined returns to phase mapping. */
   setState(track: string | undefined): void
+  /**
+   * Swap the base idle target (idle phase, unmapped phases and every
+   * fallback back to idle) to a declared looping track — a skin. undefined
+   * restores the manifest idle track.
+   */
+  setIdleTrack(track: string | undefined): void
   /** The track currently playing (diagnostics and tests). */
   currentTrack(): string
 }
@@ -78,7 +105,52 @@ function validateFrames2dConfig(config: unknown): PetFrames2dConfig {
   if (typeof phases.idle !== 'string' || tracks[phases.idle] === undefined) {
     throw new Error('frames2d phases.idle must name an existing track')
   }
-  return { tracks, phases: phases as PetFrames2dConfig['phases'] }
+  // Skins: keep entries whose idleTrack survives validation and loops —
+  // a non-looping base idle would settle into itself forever. Click actions
+  // with an unresolvable track are dropped from that skin.
+  let skins: Frames2dSkinConfig[] | undefined
+  if (Array.isArray(config.skins)) {
+    const resolved: Frames2dSkinConfig[] = []
+    for (const skin of config.skins as unknown[]) {
+      if (!isRecord(skin) || typeof skin.id !== 'string' || typeof skin.label !== 'string'
+        || typeof skin.idleTrack !== 'string' || skin.idleTrack === '') continue
+      const target = tracks[skin.idleTrack]
+      if (target === undefined || !target.loop) continue
+      let clickActions: Frames2dSkinClickActionConfig[] | undefined
+      if (Array.isArray(skin.clickActions)) {
+        const kept: Frames2dSkinClickActionConfig[] = []
+        for (const action of skin.clickActions as unknown[]) {
+          if (!isRecord(action) || typeof action.track !== 'string' || action.track === ''
+            || typeof action.probability !== 'number' || !(action.probability > 0) || action.probability > 1) continue
+          if (tracks[action.track] === undefined) continue
+          kept.push({
+            track: action.track,
+            probability: action.probability,
+            ...(Array.isArray(action.phrases) ? { phrases: action.phrases as string[] } : {}),
+          })
+        }
+        if (kept.length > 0) clickActions = kept
+      }
+      let gameplayTracks: Record<string, string> | undefined
+      if (isRecord(skin.gameplayTracks)) {
+        const kept: Record<string, string> = {}
+        for (const [state, trackName] of Object.entries(skin.gameplayTracks)) {
+          if (typeof trackName !== 'string' || trackName === '' || tracks[trackName] === undefined) continue
+          kept[state] = trackName
+        }
+        if (Object.keys(kept).length > 0) gameplayTracks = kept
+      }
+      resolved.push({
+        id: skin.id,
+        label: skin.label,
+        idleTrack: skin.idleTrack,
+        ...(clickActions === undefined ? {} : { clickActions }),
+        ...(gameplayTracks === undefined ? {} : { gameplayTracks }),
+      })
+    }
+    if (resolved.length > 0) skins = resolved
+  }
+  return { tracks, phases: phases as PetFrames2dConfig['phases'], ...(skins === undefined ? {} : { skins }) }
 }
 
 interface DecodedFrame {
@@ -178,12 +250,18 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
     let frameIndex = 0
     let lastAdvance = Date.now()
     let override: string | undefined
+    // Skin base idle: every "back to idle" target resolves through this
+    // (idle phase, unmapped phases and fallbacks), so a selected skin swaps
+    // the pet's resting look without touching gameplay tracks.
+    let baseIdle: string = config.phases.idle
     let drawToken = 0
     let lastDrawnUrl: string | undefined
 
     const trackForPhase = (phase: ActivityPhase): string => {
       const mapped = config.phases[phase]
-      return mapped !== undefined && config.tracks[mapped] !== undefined ? mapped : config.phases.idle
+      if (mapped === undefined) return baseIdle
+      const target = mapped === config.phases.idle ? baseIdle : mapped
+      return config.tracks[target] !== undefined ? target : baseIdle
     }
 
     /** Canvas path: paints the newest requested frame; stale draws drop out. */
@@ -239,18 +317,21 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
         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.
+      // Non-loop completion: settle into the fallback — an explicit fallback to
+      // a real track wins, except when it points back at the manifest idle
+      // (that resolves through the skin base idle); anything else lands on
+      // the skin base idle. When the settle target is what the phase map
+      // plays anyway, release the gameplay override.
       const target = def.fallback !== undefined && config.tracks[def.fallback] !== undefined
-        ? def.fallback
-        : config.phases.idle
+        ? (def.fallback === config.phases.idle ? baseIdle : def.fallback)
+        : baseIdle
       if (target === trackForPhase(ctx.phase.get())) override = undefined
       play(target)
     }
 
     function play(trackId: string): void {
       if (disposed) return
-      if (config.tracks[trackId] === undefined) trackId = config.phases.idle
+      if (config.tracks[trackId] === undefined) trackId = baseIdle
       if (timer !== undefined) clearTimeout(timer)
       track = trackId
       frameIndex = 0
@@ -328,6 +409,18 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
         override = next
         if (next !== track) play(next)
       },
+      setIdleTrack(next: string | undefined): void {
+        if (disposed) return
+        if (next === undefined || (config.tracks[next] !== undefined && config.tracks[next]!.loop)) {
+          baseIdle = next ?? config.phases.idle
+        }
+        // A skin only owns the resting look: re-resolve only when no
+        // gameplay override is active (active overrides end into baseIdle).
+        if (override === undefined) {
+          const target = trackForPhase(ctx.phase.get())
+          if (target !== track) play(target)
+        }
+      },
       currentTrack(): string {
         return track
       },