@linxin666/dsh-pet 0.3.3 → 0.3.5

package/src/client/renderers/frames2d.ts

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

package/src/client/settings-card.module.css

@@ -24,6 +24,10 @@
 .header {
   appearance: none;
   width: 100%;
+  /* The suite does not force a global border-box, so width:100% + padding
+     would stretch the row 32px past the card and push the trailing pending
+     badge (last flex item) outside the card border. */
+  box-sizing: border-box;
   font: inherit;
   color: inherit;
   text-align: left;
@@ -44,6 +48,7 @@
 
 .headerStatic {
   width: 100%;
+  box-sizing: border-box;
   border-radius: 12px;
   align-items: center;
   gap: 12px;

package/src/defaults.ts

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

package/src/dsh-home.ts

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

package/src/event-projection.ts

@@ -5,15 +5,26 @@
  * {@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 type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { PetStateInput } from './state.ts'
-import { StatusVoice, toolArgHint, WhisperEngine, type VoicePoolsProvider } from './chatter.ts'
+import {
+  StatusVoice,
+  toolArgHint,
+  toolCategory,
+  WhisperEngine,
+  whisperCategoryOf,
+  looksLikeTestTool,
+  type VoicePoolsProvider,
+} from './chatter.ts'
 
 /** Runtime shape of the optional legacy activity event. */
 export interface ActivityStatusEventLike {
@@ -25,11 +36,13 @@ 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
 }
 
@@ -37,7 +50,7 @@ export interface ProjectionRuntime {
 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
 }
 
@@ -50,6 +63,7 @@ export interface PetActivityTransition {
 export function emptyProjectionRuntime(pools?: VoicePoolsProvider): ProjectionRuntime {
   return {
     activeTools: new Set(),
+    testCalls: new Set(),
     officialEventsSeen: false,
     stepHadFailure: false,
     voice: new StatusVoice(pools),
@@ -81,6 +95,7 @@ export function projectOfficialEvent(
   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':
@@ -90,14 +105,14 @@ export function projectOfficialEvent(
     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 }),
@@ -107,8 +122,13 @@ export function projectOfficialEvent(
     }
     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',
@@ -119,33 +139,54 @@ export function projectOfficialEvent(
             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':
-          return { input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) } }
+        }
+        case 'error': {
+          const whisper = runtime.whispers.result('fail', nowMs)
+          return {
+            input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) },
+            ...(whisper === undefined ? {} : { whisper }),
+          }
+        }
         case 'max-tokens':
           return { input: { phase: 'failed', line: runtime.voice.scene('maxTokens', nowMs) } }
         case 'interrupted':

package/src/gameplay.test.ts

@@ -0,0 +1,239 @@
+/**
+ * Gameplay tests — the manifest block (fail-closed structure, parsed through
+ * parsePetManifest) and the host engine (lazy settle, effects, rolls) with
+ * injected clock/rng for determinism.
+ */
+import { describe, expect, it } from 'vitest'
+import { parsePetManifest } from './manifest-v2.ts'
+import {
+  applyGameplayEffects,
+  clampGameplay,
+  drawLotteryTier,
+  initialGameplayState,
+  rollTouchBranch,
+  rollWorkOutcome,
+  settleGameplay,
+  touchZoneAt,
+  type PetGameplayManifest,
+} from './gameplay.ts'
+
+/** A miku-shaped frames2d manifest carrying the full gameplay block. */
+function mikuManifest(gameplay: Record<string, unknown>): Record<string, unknown> {
+  return {
+    petManifestVersion: 2,
+    id: 'miku',
+    displayName: 'Miku',
+    license: 'MIT',
+    renderer: 'frames2d',
+    frames2d: {
+      dir: 'thumb',
+      tracks: {
+        idle: {}, drag: {}, standup: {}, sleep: {}, work: {}, success: {}, fail: {},
+        happy: {}, shy: {}, flirty: {}, angry: {}, scratch: {}, blink1: {}, blink2: {}, eat: {}, shop: {},
+      },
+      phases: { idle: 'idle', done: 'success', failed: 'fail' },
+    },
+    gameplay,
+  }
+}
+
+const FULL_GAMEPLAY: Record<string, unknown> = {
+  idleDirector: {
+    intervalMs: 5000,
+    maxMiss: 2,
+    idleWeight: 40,
+    acts: [
+      { track: 'scratch', weight: 18 },
+      { track: 'blink1', weight: 9 },
+      { track: 'blink2', weight: 9 },
+      { track: 'eat', weight: 24 },
+    ],
+  },
+  stats: {
+    hunger: { max: 100, initial: 100, decayPerMinute: 1, workingDecayPerMinute: 5 },
+    mood: { max: 100, initial: 100, decayPerMinute: 0.5 },
+    energy: { max: 100, initial: 100, decayPerMinute: 0.25 },
+    affection: { max: 500, initial: 100, idleDecayPerMinute: 0.2 },
+  },
+  hitBox: { x0: 0.2, y0: 0.05, x1: 0.42, y1: 0.56 },
+  touch: {
+    zones: [
+      { name: 'head', y0: 0, y1: 0.55, branches: [{ probability: 0.05, effects: [{ stat: 'affection', amount: 5 }], state: 'happy', stateMs: 3000, phrases: ['hi'] }] },
+      { name: 'body', y0: 0.55, y1: 0.75, branches: [{ probability: 0.1, effects: [{ stat: 'affection', amount: 10 }], state: 'shy', stateMs: 3000 }] },
+      {
+        name: 'legs', y0: 0.75, y1: 1, branches: [
+          { probability: 0.1, effects: [{ stat: 'affection', amount: 30 }], state: 'flirty', stateMs: 3000 },
+          { probability: 0.9, effects: [{ stat: 'affection', amount: -5 }], state: 'angry', stateMs: 3000 },
+        ],
+      },
+    ],
+  },
+  work: {
+    state: 'work',
+    successState: 'success',
+    failState: 'fail',
+    tickMs: 10_000,
+    resultMs: { success: 1300, fail: 1900 },
+    successProbability: 0.5,
+    success: { effects: [{ currency: 'coins', amount: 3 }] },
+    fail: { effects: [{ currency: 'coins', amount: -1 }] },
+  },
+  sleep: { state: 'sleep', wakeState: 'standup', restore: { stat: 'energy', amount: 4, intervalMs: 30_000 } },
+  passiveIncome: { currency: 'coins', amount: 1, intervalMs: 60_000 },
+  shop: {
+    state: 'shop',
+    items: [
+      { id: 'food1', label: 'bread', price: 5, currency: 'coins', effects: [{ stat: 'hunger', amount: 40 }] },
+      { id: 'gamecoin', label: 'coin', price: 10, currency: 'coins', effects: [{ currency: 'gamecoins', amount: 1 }] },
+      {
+        id: 'lottery', label: 'ticket', price: 10, currency: 'gamecoins',
+        lottery: {
+          effects: [{ stat: 'hunger', amount: 10 }, { stat: 'mood', amount: 10 }, { stat: 'energy', amount: 10 }, { stat: 'affection', amount: 10 }],
+          tiers: [
+            { probability: 0.0001, prize: 1_000_000 },
+            { probability: 0.9836, prize: 50 },
+          ],
+        },
+      },
+    ],
+  },
+  dragState: 'drag',
+}
+
+describe('gameplay manifest', () => {
+  it('accepts the full miku-shaped block', () => {
+    const result = parsePetManifest(mikuManifest(FULL_GAMEPLAY), 'mem')
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const gameplay = result.manifest.gameplay!
+    expect(gameplay.idleDirector?.acts).toHaveLength(4)
+    expect(gameplay.stats?.affection?.max).toBe(500)
+    expect(gameplay.touch?.zones).toHaveLength(3)
+    expect(gameplay.work?.tickMs).toBe(10_000)
+    expect(gameplay.sleep?.restore).toEqual({ stat: 'energy', amount: 4, intervalMs: 30_000 })
+    expect(gameplay.shop?.items).toHaveLength(3)
+    expect(gameplay.dragState).toBe('drag')
+  })
+
+  it('rejects gameplay on non-frames2d renderers', () => {
+    const sprite = {
+      petManifestVersion: 2, id: 'cat', displayName: 'Cat', license: 'CC0-1.0',
+      renderer: 'sprite2d', sprite2d: { spritesheetPath: 'spritesheet.webp' },
+      gameplay: {},
+    }
+    const result = parsePetManifest(sprite, 'mem')
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects unknown fields and dangling references', () => {
+    expect(parsePetManifest(mikuManifest({ ...FULL_GAMEPLAY, casino: {} }), 'mem').ok).toBe(false)
+    const badStatRef = mikuManifest({ stats: { hunger: { max: 100 } }, shop: { items: [{ id: 'x', label: 'x', price: 1, currency: 'coins', effects: [{ stat: 'ghost', amount: 1 }] }] } })
+    expect(parsePetManifest(badStatRef, 'mem').ok).toBe(false)
+    const badTrackRef = mikuManifest({ work: { state: 'ghost', successState: 'success', failState: 'fail', tickMs: 1000, successProbability: 0.5 } })
+    expect(parsePetManifest(badTrackRef, 'mem').ok).toBe(false)
+  })
+
+  it('rejects probability sums above 1 and duplicate shop ids', () => {
+    const overTouch = mikuManifest({ touch: { zones: [{ name: 'z', y0: 0, y1: 1, branches: [{ probability: 0.6 }, { probability: 0.6 }] }] } })
+    expect(parsePetManifest(overTouch, 'mem').ok).toBe(false)
+    const dupShop = mikuManifest({ shop: { items: [
+      { id: 'a', label: 'a', price: 1, currency: 'c', effects: [{ currency: 'c', amount: 1 }] },
+      { id: 'a', label: 'b', price: 1, currency: 'c', effects: [{ currency: 'c', amount: 1 }] },
+    ] } })
+    expect(parsePetManifest(dupShop, 'mem').ok).toBe(false)
+  })
+
+  it('rejects a shop item with neither effects nor lottery', () => {
+    const bare = mikuManifest({ shop: { items: [{ id: 'a', label: 'a', price: 1, currency: 'coins' }] } })
+    expect(parsePetManifest(bare, 'mem').ok).toBe(false)
+  })
+
+  it('rejects bad ranges (tickMs, decay, zone slices, stateMs)', () => {
+    const badTick = mikuManifest({ work: { state: 'work', successState: 'success', failState: 'fail', tickMs: 50, successProbability: 0.5 } })
+    expect(parsePetManifest(badTick, 'mem').ok).toBe(false)
+    const badDecay = mikuManifest({ stats: { hunger: { max: 100, decayPerMinute: -1 } } })
+    expect(parsePetManifest(badDecay, 'mem').ok).toBe(false)
+    const badZone = mikuManifest({ touch: { zones: [{ name: 'z', y0: 0.8, y1: 0.2, branches: [{ probability: 1 }] }] } })
+    expect(parsePetManifest(badZone, 'mem').ok).toBe(false)
+  })
+})
+
+describe('gameplay engine', () => {
+  const manifest = parsePetManifest(mikuManifest(FULL_GAMEPLAY), 'mem')
+  if (!manifest.ok) throw new Error('fixture must parse')
+  const def = manifest.manifest.gameplay!
+
+  it('initializes stats at their declared initial (default max)', () => {
+    const state = initialGameplayState(def, 1000)
+    expect(state.stats).toEqual({ hunger: 100, mood: 100, energy: 100, affection: 100 })
+    expect(state.currencies).toEqual({})
+    expect(state.mode).toBeNull()
+  })
+
+  it('lazy-settles decay, passive income and sleep restore', () => {
+    const state = initialGameplayState(def, 0)
+    state.stats.hunger = 50
+    state.mode = 'sleep'
+    // 10 minutes pass with an active session: hunger -10 (1/min), mood -5,
+    // energy -2.5 then +20 sleep restore (10 x 30s ticks x 4), coins +10.
+    const changed = settleGameplay(state, def, 600_000, { sessionActive: true })
+    expect(changed).toBe(true)
+    expect(state.stats.hunger).toBe(40)
+    expect(state.stats.mood).toBe(95)
+    expect(state.stats.energy).toBe(100) // 97.5 + 20 clamped to max
+    expect(state.currencies.coins).toBe(10)
+    expect(state.settledAt).toBe(600_000)
+  })
+
+  it('applies the working decay variant while working and idle decay without a session', () => {
+    const state = initialGameplayState(def, 0)
+    state.mode = 'work'
+    settleGameplay(state, def, 60_000, { sessionActive: true })
+    expect(state.stats.hunger).toBe(95) // working: 5/min
+    const idle = initialGameplayState(def, 0)
+    settleGameplay(idle, def, 300_000, { sessionActive: false })
+    expect(idle.stats.affection).toBe(99) // idle decay 0.2/min over 5 min
+  })
+
+  it('clamps effects into stat max and currency floors', () => {
+    const state = initialGameplayState(def, 0)
+    applyGameplayEffects(state, def, [{ stat: 'affection', amount: 10_000 }, { currency: 'coins', amount: -5 }])
+    expect(state.stats.affection).toBe(500)
+    expect(state.currencies.coins).toBe(0)
+  })
+
+  it('rolls touch branches by cumulative probability with no-op mass', () => {
+    const zone = def.touch!.zones[0]! // head: 5% hit
+    expect(rollTouchBranch(zone, () => 0.04)?.state).toBe('happy')
+    expect(rollTouchBranch(zone, () => 0.5)).toBeUndefined()
+    const legs = def.touch!.zones[2]!
+    expect(rollTouchBranch(legs, () => 0.05)?.state).toBe('flirty')
+    expect(rollTouchBranch(legs, () => 0.5)?.state).toBe('angry')
+  })
+
+  it('rolls work outcomes and draws lottery tiers with fallthrough', () => {
+    expect(rollWorkOutcome(def.work!, () => 0.4)).toBe('success')
+    expect(rollWorkOutcome(def.work!, () => 0.6)).toBe('fail')
+    const lottery = def.shop!.items[2]!.lottery!
+    expect(drawLotteryTier(lottery, () => 0.00005).prize).toBe(1_000_000)
+    expect(drawLotteryTier(lottery, () => 0.5).prize).toBe(50)
+    // Sum < 1: the uncovered roll mass falls through to the last tier.
+    expect(drawLotteryTier(lottery, () => 0.9999).prize).toBe(50)
+  })
+
+  it('locates the touch zone for a hit-box fraction', () => {
+    expect(touchZoneAt(def.touch!, 0.3)?.name).toBe('head')
+    expect(touchZoneAt(def.touch!, 0.6)?.name).toBe('body')
+    expect(touchZoneAt(def.touch!, 0.9)?.name).toBe('legs')
+    expect(touchZoneAt(def.touch!, 0.55)?.name).toBe('body')
+  })
+
+  it('clamps gameplay state into declared maxima', () => {
+    const state = initialGameplayState(def, 0)
+    state.stats.hunger = 10_000
+    state.currencies.coins = 100_000_000
+    clampGameplay(state, def)
+    expect(state.stats.hunger).toBe(100)
+    expect(state.currencies.coins).toBe(9_999_999)
+  })
+})