@linxin666/dsh-pet 0.3.19 → 0.3.21

package/src/client/renderers/Frames2dVisualMount.test.tsx

@@ -0,0 +1,73 @@
+// @vitest-environment jsdom
+/**
+ * Frames2dVisualMount registration contract: the mount consumes the base idle
+ * the gameplay HUD latches on the bus. That covers a renderer which mounts
+ * after the HUD restored a skin from the host snapshot, and one that remounts
+ * later (hidden/summoned, StrictMode double mount) — the pet must repaint the
+ * selected skin instead of snapping back to the default look.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/react'
+import type { PetDefinition } from '../../registry.ts'
+import { createDragStream } from '../drag-stream.ts'
+import type { GameplayBus } from '../gameplay-hud.tsx'
+import { t } from '../locales.ts'
+import { Frames2dVisualMount } from './Frames2dVisualMount.tsx'
+import { defaultPetRendererRegistry } from './registry.ts'
+
+function definition(): PetDefinition {
+  return {
+    id: 'miku',
+    displayName: 'Miku',
+    description: '',
+    renderer: 'frames2d',
+    cell: { width: 100, height: 100 },
+    columns: 8,
+    rows: [],
+    atlasUrl: '/pet/miku/atlas.webp',
+    manifestUrl: '/pet/miku/pet.json',
+    tracks: {} as PetDefinition['tracks'],
+    frames2d: {
+      tracks: {
+        idle: { frames: ['/pet/miku/idle_1.webp'], durations: [200], loop: true },
+        skin: { frames: ['/pet/miku/skin_1.webp'], durations: [200], loop: true },
+      },
+      phases: { idle: 'idle' },
+      skins: [{ id: 'skin', label: 'Skin', idleTrack: 'skin' }],
+    },
+  } as unknown as PetDefinition
+}
+
+function mountWith(bus: GameplayBus): { setIdleTrack: ReturnType<typeof vi.fn> } {
+  const handle = { dispose: vi.fn(), setState: vi.fn(), setIdleTrack: vi.fn(), currentTrack: () => 'idle' }
+  vi.spyOn(defaultPetRendererRegistry, 'mount')
+    .mockReturnValue(handle as unknown as ReturnType<typeof defaultPetRendererRegistry.mount>)
+  render(
+    <Frames2dVisualMount
+      definition={definition()}
+      phase="idle"
+      onPet={() => undefined}
+      drag={createDragStream()}
+      bus={bus}
+      t={t}
+    />,
+  )
+  return handle
+}
+
+describe('Frames2dVisualMount', () => {
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+  })
+
+  it('applies the base idle the HUD latched before this mount (restored skin)', () => {
+    const handle = mountWith({ idleTrack: 'skin' })
+    expect(handle.setIdleTrack).toHaveBeenCalledWith('skin')
+  })
+
+  it('leaves the default look alone when no base idle is latched', () => {
+    const handle = mountWith({})
+    expect(handle.setIdleTrack).not.toHaveBeenCalled()
+  })
+})

package/src/client/renderers/Frames2dVisualMount.tsx

@@ -68,6 +68,10 @@ export function Frames2dVisualMount(props: {
       const gameplayBus = props.bus
       gameplayBus.setTrack = (track) => { handleRef.current?.setState(track) }
       gameplayBus.setIdleTrack = (track) => { handleRef.current?.setIdleTrack(track) }
+      // The HUD latches the wanted base idle (skin selection, restored from the
+      // host snapshot): apply it on activation, so a late or repeated mount
+      // never repaints the pet with the default look.
+      if (gameplayBus.idleTrack !== undefined) handle.setIdleTrack(gameplayBus.idleTrack)
       cleanups.push(() => {
         gameplayBus.setTrack = undefined
         gameplayBus.setIdleTrack = undefined

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

@@ -182,10 +182,8 @@ describe('frames2dRenderer', () => {
 describe('frames2dRenderer canvas bitmap path', () => {
   // The canvas branch needs createImageBitmap + fetch + a real 2D context;
   // jsdom has none of them, so each test installs fakes and restores after.
-  const flush = async (): Promise<void> => {
-    await Promise.resolve()
-    await Promise.resolve()
-    await Promise.resolve()
+  const flush = async (rounds = 12): Promise<void> => {
+    for (let i = 0; i < rounds; i += 1) await Promise.resolve()
   }
 
   let draws = 0
@@ -236,9 +234,9 @@ describe('frames2dRenderer canvas bitmap path', () => {
     expect(container.querySelector('canvas')).not.toBeNull()
     expect(container.querySelector('img')).toBeNull()
     await flush()
-    // Warm pass decoded every configured frame exactly once; the first frame
-    // of the idle track painted during mount.
-    expect(bitmaps.length).toBe(6)
+    // Only the playing track's look-ahead window decodes up front; unplayed
+    // tracks stay on demand. The idle track's first frame painted at mount.
+    expect(bitmaps.length).toBe(2)
     const paintsAtMount = draws
     expect(paintsAtMount).toBeGreaterThanOrEqual(1)
     vi.advanceTimersByTime(100)
@@ -278,4 +276,128 @@ describe('frames2dRenderer canvas bitmap path', () => {
     expect(draws).toBeGreaterThanOrEqual(3)
     handle.dispose()
   })
+
+  it('bounds the decode window to the pool plus the look-ahead, not the whole track', async () => {
+    let inFlight = 0
+    let peak = 0
+    const gates: Array<() => void> = []
+    vi.stubGlobal('fetch', vi.fn(async () => {
+      inFlight += 1
+      peak = Math.max(peak, inFlight)
+      await new Promise<void>((resolve) => gates.push(resolve))
+      inFlight -= 1
+      return { ok: true, blob: async () => ({}) }
+    }))
+    const bigConfig: PetFrames2dConfig = {
+      tracks: {
+        idle: { frames: Array.from({ length: 24 }, (_, i) => `/pet/miku/idle/${i}.webp`), durations: Array.from({ length: 24 }, () => 100), loop: true },
+      },
+      phases: { idle: 'idle' },
+    }
+    const { ctx } = canvasSetup()
+    const handle = frames2dRenderer.mount(ctx, frames2dRenderer.validateConfig(bigConfig)) as Frames2dRendererHandle
+    await flush()
+    expect(peak).toBeLessThanOrEqual(8)
+    expect(gates.length).toBe(8)
+    for (let i = 0; i < 64 && gates.length > 0; i += 1) {
+      gates.shift()!()
+      await flush()
+    }
+    expect(peak).toBeLessThanOrEqual(8)
+    // Frame 0 plus the 12-frame look-ahead window; the remaining frames of the
+    // 24-frame track are never decoded up front.
+    expect(bitmaps.length).toBe(13)
+    handle.dispose()
+  })
+
+  it('leaves unplayed tracks and unselected skins to on-demand playback', async () => {
+    const fetched: string[] = []
+    vi.stubGlobal('fetch', vi.fn(async (input: unknown) => {
+      fetched.push(String(input))
+      return { ok: true, blob: async () => ({}) }
+    }))
+    const skinConfig: PetFrames2dConfig = {
+      tracks: {
+        idle: { frames: ['/pet/miku/idle/1.webp'], durations: [100], loop: true },
+        'skin-a-idle': { frames: ['/pet/miku/skin-a/1.webp', '/pet/miku/skin-a/2.webp'], durations: [100, 100], loop: true },
+        'skin-b-idle': { frames: ['/pet/miku/skin-b/1.webp'], durations: [100], loop: true },
+      },
+      phases: { idle: 'idle' },
+      skins: [
+        { id: 'a', label: 'A', idleTrack: 'skin-a-idle' },
+        { id: 'b', label: 'B', idleTrack: 'skin-b-idle' },
+      ],
+    }
+    const { ctx } = canvasSetup()
+    const handle = frames2dRenderer.mount(ctx, frames2dRenderer.validateConfig(skinConfig)) as Frames2dRendererHandle
+    await flush()
+    expect(fetched).toEqual(['/pet/miku/idle/1.webp'])
+    // Selecting a skin pulls only that skin's track.
+    handle.setIdleTrack('skin-a-idle')
+    await flush()
+    expect(fetched).toContain('/pet/miku/skin-a/1.webp')
+    expect(fetched).not.toContain('/pet/miku/skin-b/1.webp')
+    handle.dispose()
+  })
+
+  it('jumps a playback-demand frame ahead of the warm backlog', async () => {
+    const fetched: string[] = []
+    const held = new Map<string, () => void>()
+    vi.stubGlobal('fetch', vi.fn(async (input: unknown) => {
+      const url = String(input)
+      fetched.push(url)
+      if (fetched.length <= 8) {
+        await new Promise<void>((resolve) => { held.set(url, resolve) })
+      }
+      return { ok: true, blob: async () => ({}) }
+    }))
+    const wideConfig: PetFrames2dConfig = {
+      tracks: {
+        idle: { frames: Array.from({ length: 10 }, (_, i) => `/pet/miku/idle/${i}.webp`), durations: Array.from({ length: 10 }, () => 100), loop: true },
+        happy: { frames: ['/pet/miku/happy/1.webp'], durations: [100], loop: false, fallback: 'idle' },
+      },
+      phases: { idle: 'idle', done: 'happy' },
+    }
+    const { ctx } = canvasSetup()
+    const handle = frames2dRenderer.mount(ctx, frames2dRenderer.validateConfig(wideConfig)) as Frames2dRendererHandle
+    await flush()
+    expect(fetched.length).toBe(8)
+    // The happy frame sits behind the idle backlog; playing it must pull its
+    // fetch ahead of the not-yet-started warm frames.
+    handle.setState('happy')
+    await flush()
+    // Free one pool slot: the released idle decode completes and the freed
+    // slot must start the jumped happy frame, not the next warm idle frame.
+    held.get(fetched[0])?.()
+    await flush()
+    expect(fetched[8]).toBe('/pet/miku/happy/1.webp')
+    for (const release of held.values()) release()
+    await flush()
+    handle.dispose()
+  })
+
+  it('retries a failed frame instead of memoizing the failure forever', async () => {
+    let failuresLeft = 1
+    vi.stubGlobal('fetch', vi.fn(async () => {
+      if (failuresLeft > 0) {
+        failuresLeft -= 1
+        throw new Error('transient')
+      }
+      return { ok: true, blob: async () => ({}) }
+    }))
+    class FailingImage {
+      onload: (() => void) | null = null
+      onerror: (() => void) | null = null
+      set src(_value: string) { queueMicrotask(() => this.onerror?.()) }
+    }
+    vi.stubGlobal('Image', FailingImage)
+    const { ctx } = canvasSetup()
+    const handle = frames2dRenderer.mount(ctx, frames2dRenderer.validateConfig(CONFIG)) as Frames2dRendererHandle
+    // Prefetch fetches fail through the pool, resolve undefined and are
+    // dropped from the memo; nothing throws.
+    await flush()
+    const memoFetches = (fetch as ReturnType<typeof vi.fn>).mock.calls.length
+    expect(memoFetches).toBeGreaterThan(0)
+    handle.dispose()
+  })
 })

package/src/client/renderers/frames2d.ts

@@ -12,10 +12,11 @@
  * 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).
+ *   exist): frames are decoded once into an ImageBitmap on demand, with a
+ *   bounded look-ahead window over the playing track, 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.
@@ -213,36 +214,97 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
     // the last painted frame instead of breaking playback).
     const decoding = new Map<string, Promise<DecodedFrame | undefined>>()
     const decodedAll: Promise<void>[] = []
-    const loadFrame = (url: string): Promise<DecodedFrame | undefined> => {
+    // All frame fetches funnel through a small pool. Full-library warm passes
+    // on large pets fire 1100+ requests at once, which trips the browser's
+    // in-flight request limit (net::ERR_INSUFFICIENT_RESOURCES) and fails
+    // whole batches of frames while starving the rest of the page. Playback
+    // demand jumps ahead of the warm backlog.
+    const FRAME_POOL_LIMIT = 8
+    const frameQueue: Array<{ url: string; release: () => void }> = []
+    let activeFrames = 0
+
+    const decodeFrame = async (url: string): Promise<DecodedFrame | undefined> => {
+      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<DecodedFrame | undefined>((resolve) => {
+          try {
+            const pre = new Image()
+            pre.onload = (): void => {
+              resolve(pre.naturalWidth > 0 ? { source: pre, width: pre.naturalWidth, height: pre.naturalHeight } : undefined)
+            }
+            pre.onerror = (): void => resolve(undefined)
+            pre.src = url
+          } catch {
+            resolve(undefined)
+          }
+        })
+      }
+    }
+
+    const pumpFrames = (): void => {
+      while (activeFrames < FRAME_POOL_LIMIT && frameQueue.length > 0) {
+        const queued = frameQueue.shift()!
+        activeFrames += 1
+        queued.release()
+      }
+    }
+
+    const loadFrame = (url: string, jump = false): Promise<DecodedFrame | undefined> => {
+      // Jump first: warm-enqueued frames already carry their memo, so a
+      // playback demand must reorder the unstarted entry before the cache
+      // lookup short-circuits.
+      if (jump) {
+        const index = frameQueue.findIndex((queued) => queued.url === url)
+        if (index > 0) frameQueue.unshift(frameQueue.splice(index, 1)[0]!)
+      }
       const cached = decoding.get(url)
       if (cached !== undefined) return cached
-      const job: Promise<DecodedFrame | undefined> = (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<DecodedFrame | undefined>((resolve) => {
-            try {
-              const pre = new Image()
-              pre.onload = (): void => {
-                resolve(pre.naturalWidth > 0 ? { source: pre, width: pre.naturalWidth, height: pre.naturalHeight } : undefined)
-              }
-              pre.onerror = (): void => resolve(undefined)
-              pre.src = url
-            } catch {
-              resolve(undefined)
-            }
-          })
-        }
-      })()
+      let release!: () => void
+      const gate = new Promise<void>((resolve) => { release = resolve })
+      const job: Promise<DecodedFrame | undefined> = gate.then(() => (disposed ? undefined : decodeFrame(url)))
+      job.then(
+        (frame) => { if (frame === undefined) decoding.delete(url) },
+        () => decoding.delete(url),
+      )
+      void job.finally(() => {
+        activeFrames -= 1
+        pumpFrames()
+      })
       decoding.set(url, job)
       decodedAll.push(job.then(() => undefined, () => undefined))
+      const entry = { url, release }
+      if (jump) frameQueue.unshift(entry)
+      else frameQueue.push(entry)
+      pumpFrames()
       return job
     }
 
+    /**
+     * Bounded look-ahead window: decode only the frames playback is about to
+     * need. The historical warm pass decoded every frame of every track up
+     * front - a shipped pet carries ~1.1k 512x683 frames, so that pass pulls
+     * tens of megabytes and retains every decoded bitmap for the life of the
+     * page. Prefetching the playing track's next frames keeps loops and phase
+     * switches warm while unplayed tracks (and every unselected skin's
+     * frames) stay on demand, where playback jumps the queue anyway.
+     */
+    const PREFETCH_AHEAD = 12
+
+    const prefetchAhead = (trackId: string, index: number): void => {
+      const def = config.tracks[trackId]
+      if (def === undefined) return
+      const end = Math.min(def.frames.length, index + 1 + PREFETCH_AHEAD)
+      for (let ahead = index + 1; ahead < end; ahead += 1) {
+        const url = def.frames[ahead]
+        if (url !== undefined) void loadFrame(url)
+      }
+    }
+
     let disposed = false
     let timer: ReturnType<typeof setTimeout> | undefined
     let watchdog: ReturnType<typeof setInterval> | undefined
@@ -268,7 +330,7 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
     const paintCanvas = (url: string): void => {
       if (context2d === null || canvas === null) return
       const myToken = ++drawToken
-      void loadFrame(url).then((frame) => {
+      void loadFrame(url, true).then((frame) => {
         if (disposed || frame === undefined || myToken !== drawToken) return
         if (lastDrawnUrl === url) return
         lastDrawnUrl = url
@@ -287,6 +349,7 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
       const def = config.tracks[trackId]
       const url = def?.frames[index]
       if (url === undefined) return
+      prefetchAhead(trackId, index)
       if (img !== null) {
         if (img.getAttribute('src') !== url) img.src = url
         return
@@ -360,13 +423,6 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
       }, 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
@@ -378,7 +434,9 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
       if (timer !== undefined) clearTimeout(timer)
       if (watchdog !== undefined) clearInterval(watchdog)
       // Release decoded bitmaps after pending decodes settle; close() is
-      // browser-only, so guard it for exotic hosts.
+      // browser-only, so guard it for exotic hosts. Queued-but-unstarted
+      // frames release immediately as no-ops so the settle barrier drains.
+      for (const queued of frameQueue.splice(0)) queued.release()
       void Promise.allSettled(decodedAll).then(() => {
         for (const job of decoding.values()) {
           void job.then((frame) => {

package/src/client/work-tick-gate.test.ts

@@ -0,0 +1,53 @@
+/**
+ * Work-tick gate tests: the window follows the configured cadence (clamped to
+ * the manifest bounds), one adjudication is admitted per window, and entering
+ * work mode re-arms the gate.
+ */
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_WORK_TICK_MS, createWorkTickGate, workTickWindowMs } from './work-tick-gate.ts'
+
+describe('workTickWindowMs', () => {
+  it('follows the configured cadence', () => {
+    expect(workTickWindowMs(2_000)).toBe(2_000)
+    expect(workTickWindowMs(10_000)).toBe(10_000)
+    expect(workTickWindowMs(60_000)).toBe(60_000)
+  })
+
+  it('clamps to the manifest bounds and defaults when absent', () => {
+    expect(workTickWindowMs(500)).toBe(1_000)
+    expect(workTickWindowMs(120_000)).toBe(60_000)
+    expect(workTickWindowMs(undefined)).toBe(DEFAULT_WORK_TICK_MS)
+    expect(workTickWindowMs(Number.NaN)).toBe(DEFAULT_WORK_TICK_MS)
+  })
+})
+
+describe('createWorkTickGate', () => {
+  it('admits one adjudication per configured window', () => {
+    let now = 1_000_000
+    const gate = createWorkTickGate(() => now)
+    expect(gate.allow(2_000)).toBe(true)
+    now += 1_999
+    expect(gate.allow(2_000)).toBe(false)
+    now += 1
+    expect(gate.allow(2_000)).toBe(true)
+  })
+
+  it('does not downgrade a pet whose cadence is shorter than the default', () => {
+    let now = 1_000_000
+    const gate = createWorkTickGate(() => now)
+    expect(gate.allow(2_000)).toBe(true)
+    for (let tick = 0; tick < 5; tick++) {
+      now += 2_000
+      expect(gate.allow(2_000)).toBe(true)
+    }
+  })
+
+  it('arms immediately after a reset (work mode entry)', () => {
+    let now = 1_000_000
+    const gate = createWorkTickGate(() => now)
+    expect(gate.allow(10_000)).toBe(true)
+    expect(gate.allow(10_000)).toBe(false)
+    gate.reset()
+    expect(gate.allow(10_000)).toBe(true)
+  })
+})

package/src/client/work-tick-gate.ts

@@ -0,0 +1,63 @@
+/**
+ * Page-wide work-tick gate for the pet's work mode. Hot reloads can leave
+ * several GameplayHud instances alive, each running its own 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. The gate accepts the first
+ * adjudication of a window and silently suppresses the duplicates that follow.
+ *
+ * The window is the active pet's own `gameplay.work.tickMs`, not a constant: a
+ * pet configured with a shorter cadence must actually adjudicate that often,
+ * while a fixed window would downgrade it without saying so (#1494).
+ * @module @linxin666/dsh-pet/client/work-tick-gate
+ */
+
+/** Window used when the active pet declares no work cadence. */
+export const DEFAULT_WORK_TICK_MS = 10_000
+
+/** Manifest bounds for `gameplay.work.tickMs` (src/gameplay.ts). */
+const MIN_WORK_TICK_MS = 1_000
+const MAX_WORK_TICK_MS = 60_000
+
+/**
+ * The gate window for one pet: its configured cadence, clamped to the manifest's
+ * own bounds so a malformed registry entry cannot disable or flood the gate.
+ * @param tickMs - the active definition's `gameplay.work.tickMs`, when it has one.
+ * @returns the window in milliseconds.
+ */
+export function workTickWindowMs(tickMs: number | undefined): number {
+  if (typeof tickMs !== 'number' || !Number.isFinite(tickMs)) return DEFAULT_WORK_TICK_MS
+  return Math.min(MAX_WORK_TICK_MS, Math.max(MIN_WORK_TICK_MS, tickMs))
+}
+
+/** The shared work-tick gate. */
+export interface WorkTickGate {
+  /**
+   * Admit one adjudication for the current window.
+   * @param tickMs - the active pet's configured work cadence.
+   * @returns true when this call may adjudicate, false for a duplicate.
+   */
+  allow: (tickMs: number | undefined) => boolean
+  /** Forget the last adjudication (used when work mode is entered). */
+  reset: () => void
+}
+
+/**
+ * Create a gate.
+ * @param now - the clock, injectable so tests control the window.
+ * @returns the gate over that clock.
+ */
+export function createWorkTickGate(now: () => number = Date.now): WorkTickGate {
+  let lastAdjudicatedAt = 0
+  return {
+    allow: (tickMs) => {
+      const at = now()
+      if (at - lastAdjudicatedAt < workTickWindowMs(tickMs)) return false
+      lastAdjudicatedAt = at
+      return true
+    },
+    reset: () => {
+      lastAdjudicatedAt = 0
+    },
+  }
+}

package/src/event-projection.ts

@@ -11,9 +11,16 @@
  * 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.
+ *
+ * Since the 0.1.5-alpha.2 cohort the stream itself is no longer durable
+ * vocabulary: per-chunk phase input arrives through the process-local
+ * `agent/assistant-stream` publication ({@link projectAssistantStreamFrame}),
+ * while the durable log settles one `assistant/message` (or `assistant/attempt`)
+ * per attempt.
  * @module @linxin666/dsh-pet/event-projection
  */
 
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { PetStateInput } from './state.ts'
 import {
@@ -102,24 +109,6 @@ export function projectOfficialEvent(
       runtime.activeTools.clear()
       runtime.stepHadFailure = false
       return { input: { phase: 'waiting', line: runtime.voice.scene('waiting', nowMs) } }
-    case 'assistant/chunk': {
-      const { chunk } = event.data
-      if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-        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('writing', nowMs)
-        return {
-          input: { phase: 'review', line: runtime.voice.scene('review', nowMs) },
-          ...(whisper === undefined ? {} : { whisper }),
-        }
-      }
-      return undefined
-    }
     case 'assistant/message':
       return { input: { phase: 'review', line: runtime.voice.scene('review', nowMs) } }
     case 'tool/call': {
@@ -207,3 +196,33 @@ export function projectOfficialEvent(
       return undefined
   }
 }
+
+/**
+ * Project one live `agent/assistant-stream` publication into the pet's visual
+ * phases. Chunk frames are the alpha.2 replacement for the retired durable
+ * `assistant/chunk` event: a reasoning delta keeps the pet thinking, a text
+ * delta moves it to review; start, end, and non-delta chunks change nothing.
+ */
+export function projectAssistantStreamFrame(
+  frame: AssistantStreamFrame,
+  runtime: ProjectionRuntime,
+  nowMs: number = Date.now(),
+): PetActivityTransition | undefined {
+  if (frame.type !== 'chunk') return undefined
+  const { chunk } = frame
+  if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
+    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('writing', nowMs)
+    return {
+      input: { phase: 'review', line: runtime.voice.scene('review', nowMs) },
+      ...(whisper === undefined ? {} : { whisper }),
+    }
+  }
+  return undefined
+}

package/src/gameplay.test.ts

@@ -185,6 +185,42 @@ describe('gameplay engine', () => {
     expect(state.settledAt).toBe(600_000)
   })
 
+  it('preserves remainder carry across frequent polling intervals for passive income and sleep restore (#1478)', () => {
+    const state = initialGameplayState(def, 0)
+    state.stats.energy = 20
+    state.mode = 'sleep'
+    // Simulate 30 frequent settles every 2,000 ms (total 60,000 ms = 1 min).
+    // Passive income interval: 60,000 ms -> should grant 1 coin on 30th settle.
+    // Sleep restore interval: 30,000 ms (+4 energy each) -> should grant on 15th and 30th settle.
+    let now = 0
+    for (let i = 1; i <= 30; i++) {
+      now += 2_000
+      settleGameplay(state, def, now, { sessionActive: true })
+      if (i < 15) {
+        expect(state.stats.energy).toBeCloseTo(20 - (i * 2 / 60) * 0.25, 4)
+        expect(state.currencies.coins ?? 0).toBe(0)
+      } else if (i === 15) {
+        // At 30,000 ms: first sleep tick hits (+4 energy)
+        expect(state.stats.energy).toBeCloseTo(20 - 0.125 + 4, 4)
+        expect(state.currencies.coins ?? 0).toBe(0)
+      } else if (i < 30) {
+        expect(state.stats.energy).toBeCloseTo(20 - (i * 2 / 60) * 0.25 + 4, 4)
+        expect(state.currencies.coins ?? 0).toBe(0)
+      }
+    }
+    // At 60,000 ms (30th tick): second sleep tick hits (+4 energy = +8 total), passive income hits (+1 coin)
+    expect(state.stats.energy).toBeCloseTo(20 - 0.25 + 8, 4)
+    expect(state.currencies.coins).toBe(1)
+    expect(state.incomeCarryMs).toBe(0)
+    expect(state.restoreCarryMs).toBe(0)
+
+    // Leaving sleep mode clears restoreCarryMs
+    state.restoreCarryMs = 10_000
+    state.mode = null
+    settleGameplay(state, def, now + 1_000, { sessionActive: true })
+    expect(state.restoreCarryMs).toBe(0)
+  })
+
   it('applies the working decay variant while working and idle decay without a session', () => {
     const state = initialGameplayState(def, 0)
     state.mode = 'work'