@linxin666/dsh-pet 0.1.10 → 0.1.12

package/src/client/WhalePet.test.tsx

@@ -0,0 +1,138 @@
+// @vitest-environment jsdom
+/**
+ * WhalePet rename-box keyboard handling. The rename input must treat
+ * Enter/Escape keydowns that arrive during IME composition (candidate
+ * selection) as composition input, never as submit/cancel (issue #89).
+ */
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { WhalePet, type WhalePetProps } from './WhalePet.tsx'
+import { t } from './locales.ts'
+import type { PetStateView } from '../service.ts'
+
+/** Snapshot fixture: idle whale girl named 泡泡. */
+const snapshot: PetStateView = {
+  animation: 'idle',
+  phase: 'idle',
+  sessionActive: true,
+  affinity: {
+    points: 0,
+    rank: '幼鲸',
+    rankEmoji: '*',
+    pets: 0,
+    feeds: 0,
+    turns: 0,
+    petCooldown: false,
+    feedCooldown: false,
+  },
+  display: { visible: true, size: 160, right: 24, bottom: 20 },
+  name: '泡泡',
+  treats: { stocked: 3, max: 5 },
+}
+
+beforeAll(() => {
+  // Deterministic zh copy for button labels.
+  document.documentElement.lang = 'zh'
+  // Prefer-reduced-motion matches: the sprite loop then never schedules
+  // requestAnimationFrame, keeping the test free of animation timers.
+  Object.defineProperty(window, 'matchMedia', {
+    configurable: true,
+    value: (query: string) => ({
+      matches: query.includes('prefers-reduced-motion'),
+      media: query,
+      onchange: null,
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      addListener: () => {},
+      removeListener: () => {},
+      dispatchEvent: () => false,
+    }),
+  })
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+/** Render the pet with mocked callbacks; returns the rename spy. */
+function renderPet(): { onRename: ReturnType<typeof vi.fn> } {
+  const onRename = vi.fn()
+  const props: WhalePetProps = {
+    snapshot,
+    display: snapshot.display,
+    feedback: null,
+    onPet: vi.fn(),
+    onFeed: vi.fn(),
+    onHide: vi.fn(),
+    onDragEnd: vi.fn(),
+    onRename,
+    onFeedbackDone: vi.fn(),
+    t,
+  }
+  render(<WhalePet {...props} />)
+  return { onRename }
+}
+
+/** Hover the sprite to open the panel, then click the rename button. */
+function openRename(): HTMLInputElement {
+  fireEvent.pointerOver(screen.getByRole('button', { name: 'whale girl' }))
+  fireEvent.click(screen.getByText('改名'))
+  return screen.getByPlaceholderText('输入新名字') as HTMLInputElement
+}
+
+/**
+ * Fire a keydown whose native event reports an active IME composition, the
+ * way Chromium marks Enter/Escape pressed to select or dismiss a candidate.
+ */
+function fireComposingKeydown(target: Element, key: string): void {
+  fireEvent.compositionStart(target)
+  const native = new window.KeyboardEvent('keydown', {
+    key,
+    bubbles: true,
+    cancelable: true,
+    isComposing: true,
+  })
+  // jsdom does not implement KeyboardEvent.isComposing, so pin the flag on
+  // the dispatched native event exactly as the browser would report it.
+  Object.defineProperty(native, 'isComposing', { value: true })
+  fireEvent(target, native)
+  fireEvent.compositionEnd(target)
+}
+
+describe('WhalePet rename input', () => {
+  it('submits the draft on Enter outside composition', () => {
+    const { onRename } = renderPet()
+    const input = openRename()
+    fireEvent.change(input, { target: { value: ' 小鲸 ' } })
+    fireEvent.keyDown(input, { key: 'Enter' })
+    expect(onRename).toHaveBeenCalledTimes(1)
+    expect(onRename).toHaveBeenCalledWith('小鲸')
+    expect(screen.queryByPlaceholderText('输入新名字')).toBeNull()
+  })
+
+  it('ignores Enter while an IME composition is active', () => {
+    const { onRename } = renderPet()
+    const input = openRename()
+    fireEvent.change(input, { target: { value: '泡泡酱' } })
+    fireComposingKeydown(input, 'Enter')
+    expect(onRename).not.toHaveBeenCalled()
+    expect(screen.getByPlaceholderText('输入新名字')).toBe(input)
+    expect(input.value).toBe('泡泡酱')
+    // Once the composition is over, Enter submits normally.
+    fireEvent.keyDown(input, { key: 'Enter' })
+    expect(onRename).toHaveBeenCalledWith('泡泡酱')
+    expect(screen.queryByPlaceholderText('输入新名字')).toBeNull()
+  })
+
+  it('ignores Escape while an IME composition is active', () => {
+    const { onRename } = renderPet()
+    const input = openRename()
+    fireEvent.change(input, { target: { value: 'abc' } })
+    fireComposingKeydown(input, 'Escape')
+    expect(screen.getByPlaceholderText('输入新名字')).toBe(input)
+    // A real Escape outside composition closes the box without renaming.
+    fireEvent.keyDown(input, { key: 'Escape' })
+    expect(onRename).not.toHaveBeenCalled()
+    expect(screen.queryByPlaceholderText('输入新名字')).toBeNull()
+  })
+})

package/src/client/WhalePet.tsx

@@ -301,6 +301,11 @@ export function WhalePet(props: WhalePetProps): ReactPortal {
                 autoFocus
                 onChange={(e) => setNameDraft(e.target.value)}
                 onKeyDown={(e) => {
+                  // While an IME composition is active (e.g. selecting a
+                  // Chinese candidate), Enter/Escape keydowns belong to the
+                  // input method: ignore them so candidate selection can
+                  // neither submit the draft nor close the rename box.
+                  if (e.nativeEvent.isComposing) return
                   if (e.key === 'Enter') {
                     const trimmed = nameDraft.trim()
                     if (trimmed !== '') {

package/src/client/index.ts

@@ -10,7 +10,7 @@
  * @module @linxin666/dsh-pet/client
  */
 
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ClientContext, SettingsScope, SettingsScopeSpec } from '@deepseek-ai/dsh-client-runtime/client'
 // Type-only: pulls the locale plugin's Context merge (ctx.locale).
 import type {} from '@deepseek-ai/dsh-client-locale/client'
 // Type-only: pulls the settings-surface Context merge (ctx.settingsScope).
@@ -92,6 +92,18 @@ export interface SettingsPluginItemOwnerProps {
   children?: never
 }
 
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    /**
+     * Optional rc.6 compatibility binder provided by dsh-web-ui-settings;
+     * absent when that group plugin is not installed, so callers fall back to
+     * the official settings scope.
+     */
+    webUiSettings?: { bind<S>(spec: SettingsScopeSpec<S>): SettingsScope<S> }
+  }
+}
+
+
 /**
  * Client plugin body: register dictionaries, mount the global pet entry and
  * poll loop while the plugin is enabled, and seat the settings card in the
@@ -101,7 +113,8 @@ export interface SettingsPluginItemOwnerProps {
 export function apply(ctx: ClientContext): void {
   ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'pet: dictionaries')
 
-  const settingsScope = ctx.settingsScope.bind<PetSettings>({ namespace: PET_SETTINGS_NS })
+  const binder = ctx.get('webUiSettings') ?? ctx.settingsScope
+  const settingsScope = binder.bind<PetSettings>({ namespace: PET_SETTINGS_NS })
   const enabled = (): boolean => {
     const snapshot = settingsScope.getSnapshot()
     return snapshot.status === 'ready'

package/src/service.ts

@@ -1,14 +1,15 @@
 /**
  * Pet host service — the `pet.*` RPC domain. Owns the state machine wiring
- * (consumes `activity/status` session events and session lifecycle), the
- * affinity ledger, and the persisted display config. The API gateway maps
- * this service's methods onto `pet.state` / `pet.interact` /
- * `pet.setVisible` / `pet.setConfig` for browser consumers.
+ * (maps core rc.6 session events — turn/step/tool boundaries — and the
+ * session lifecycle onto the pet phases), the affinity ledger, and the
+ * persisted display config. The API gateway maps this service's methods onto
+ * `pet.state` / `pet.interact` / `pet.setVisible` / `pet.setConfig`
+ * for browser consumers.
  * @module @linxin666/dsh-pet/service
  */
 
 import { Context, Service } from '@deepseek-ai/cordis'
-import type { Session } from '@deepseek-ai/dsh-session'
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import {
   applyInteraction,
   applyTurnReward,
@@ -127,13 +128,6 @@ declare module '@deepseek-ai/cordis' {
   }
 }
 
-/** One session/event guard: only the latest activity snapshot matters. */
-interface ActivityStatusEventLike {
-  phase?: string
-  line?: string
-  phrase?: string
-}
-
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
  * written until a query or interaction arrives; event listeners update only
@@ -148,7 +142,8 @@ export class PetService extends Service {
   private readonly treatConfig: TreatConfig
   private readonly persistDir: string
   private persist: PetPersist
-  private lastTurnRewardAt = 0
+  /** Completed turns already rewarded, per session (turn numbers are per-session). */
+  private rewardedTurns = new Map<string, number>()
   private enabled: boolean
   private disposeActivity: (() => void) | undefined
 
@@ -201,20 +196,36 @@ export class PetService extends Service {
     if (!this.enabled) return
     this.disposeActivity = (() => {
       const disposers = [
-        this.ctx.on('session/event', (_session: Session, event: { type: string; data?: unknown }) => {
-          if (event.type !== 'activity/status') return
-          const payload = (event.data ?? {}) as ActivityStatusEventLike
-          if (payload.phase === undefined) return
-          const phase = payload.phase as PetStateSnapshot['phase']
-          // Guard against unknown phases from newer activity trackers.
-          if (!['idle', 'waiting', 'thinking', 'tool', 'done'].includes(phase)) return
-          this.machine.onActivityStatus({
-            phase,
-            ...(typeof payload.line === 'string' ? { line: payload.line } : {}),
-            ...(typeof payload.phrase === 'string' ? { phrase: payload.phrase } : {}),
-          })
-          this.machine.onSessionActive()
-          if (phase === 'done') this.rewardTurn()
+        this.ctx.on('session/event', (session: Session, event: SessionEvent) => {
+          // rc.6 publishes no 'activity/status' event (the working-activity
+          // tracker is gone), so the pet derives its phases from the core
+          // session vocabulary instead.
+          switch (event.type) {
+            case 'turn/start':
+              this.machine.onSessionActive()
+              break
+            case 'step/start':
+              this.machine.onSessionActive()
+              this.machine.onActivityStatus({ phase: 'thinking' })
+              break
+            case 'tool/call':
+              this.machine.onSessionActive()
+              this.machine.onActivityStatus({ phase: 'tool', line: 'tool: ' + event.data.name })
+              break
+            case 'turn/end':
+              this.machine.onSessionActive()
+              if (event.data.reason.kind === 'completed') {
+                this.machine.onActivityStatus({ phase: 'done' })
+                this.rewardTurn(String(session.id), event.data.turn)
+              } else {
+                // Aborted / failed turns clear the working pose instead of
+                // freezing the pet on its last phase.
+                this.machine.onActivityStatus({ phase: 'idle' })
+              }
+              break
+            default:
+              break
+          }
         }),
         this.ctx.on('session/disposed', () => {
           this.machine.onSessionDisposed()
@@ -318,19 +329,20 @@ export class PetService extends Service {
     })
   }
 
-  /** Award the turn reward once per done phase (idempotent per transition). */
-  private rewardTurn(): void {
-    const nowMs = Date.now()
-    // A done phase can repeat while celebrating; only reward the first.
-    if (nowMs - this.lastTurnRewardAt < 5_000) return
-    this.lastTurnRewardAt = nowMs
+  /** Award the turn reward once per completed turn (idempotent per session + turn). */
+  private rewardTurn(sessionId: string, turn: number): void {
+    const last = this.rewardedTurns.get(sessionId) ?? 0
+    if (turn <= last) return
+    this.rewardedTurns.set(sessionId, turn)
     this.persist = { ...this.persist, affinity: applyTurnReward(this.persist.affinity, this.affinityConfig) }
     this.flush()
   }
 
   /**
-   * Settle the treat economy (work + time output since the last
-   * settlement); persists only when treats were actually granted.
+   * Settle the treat economy (work + time output since the last settlement)
+   * and persist whenever the ledger changed. A zero-gain first settlement
+   * still starts the time clock (anchor write), which is what lets the
+   * 30-minute time output ever accrue.
    */
   private settleTreats(nowMs: number): void {
     const settlement = settleTreatGrants(
@@ -339,7 +351,7 @@ export class PetService extends Service {
       nowMs,
       this.treatConfig,
     )
-    if (settlement.gained > 0) {
+    if (settlement.ledger !== this.persist.treats) {
       this.persist = { ...this.persist, treats: settlement.ledger }
       this.flush()
     }

package/src/state.ts

@@ -1,8 +1,8 @@
 /**
- * Pet state machine — pure, clock-injected. Maps the DSH `activity/status`
- * phase vocabulary (session events) onto the 9-state Codex pet
- * animation contract, plus the session lifecycle transitions the web UI
- * exposes (turn end celebration, no-session idle).
+ * Pet state machine — pure, clock-injected. Maps the pet's working-phase
+ * vocabulary (the service derives it from core session events) onto the
+ * 9-state Codex pet animation contract, plus the session lifecycle
+ * transitions the web UI exposes (turn end celebration, no-session idle).
  *
  * The machine is deliberately dumb: it holds the last input phase, the
  * animation decision, and a one-shot "celebration" window after `done` so the
@@ -11,7 +11,7 @@
  * @module @linxin666/dsh-pet/state
  */
 
-/** The DSH `activity/status` phase vocabulary (wire contract of session events). */
+/** The pet's working-phase vocabulary (derived from core session events by the service). */
 export type ActivityPhase = 'idle' | 'waiting' | 'thinking' | 'tool' | 'done'
 
 /** The Codex-compatible 9-state animation contract (spritesheet rows). */
@@ -28,7 +28,7 @@ export type PetAnimation =
 
 /** One input snapshot consumed by the machine. */
 export interface PetStateInput {
-  /** Current activity/status phase of the active session. */
+  /** Current working phase of the active session. */
   phase: ActivityPhase
   /** Human-readable status line (plain text). */
   line?: string
@@ -110,7 +110,7 @@ export class PetStateMachine {
     private readonly now: () => number = Date.now,
   ) {}
 
-  /** Consume one `activity/status` session event. */
+  /** Consume one phase snapshot (fed by the service from session events). */
   onActivityStatus(input: PetStateInput): void {
     this.phase = input.phase
     this.line = input.line

package/src/treats.test.ts

@@ -23,11 +23,34 @@ describe('settleTreatGrants', () => {
     expect(s.ledger.lastTreatGrantAt).toBe(1_000 + 90 * 60_000)
   })
 
-  it('does not backfill time output before the first settlement', () => {
+  it('does not backfill time output before the first settlement, but starts the clock', () => {
     const ledger = emptyTreatLedger() // lastTreatGrantAt === 0
     const s = settleTreatGrants(ledger, 0, 1_000 + 10 * 60 * 60_000, defaultTreatConfig)
     expect(s.gained).toBe(0)
-    expect(s.ledger).toBe(ledger)
+    expect(s.ledger.treats).toBe(0)
+    expect(s.ledger.lastTreatGrantAt).toBe(1_000 + 10 * 60 * 60_000)
+  })
+
+  it('starts the time clock on a zero-gain settlement so later time output accrues (anchor deadlock)', () => {
+    // Regression for issue #99: the old code returned the ledger untouched
+    // when nothing was due, so lastTreatGrantAt stayed 0 forever and the
+    // 30-minute time output could never begin.
+    let ledger = emptyTreatLedger()
+    const first = settleTreatGrants(ledger, 0, 1_000, defaultTreatConfig)
+    expect(first.gained).toBe(0)
+    expect(first.ledger.lastTreatGrantAt).toBe(1_000)
+    expect(first.ledger.treats).toBe(0)
+    ledger = first.ledger
+    // Anchored and nothing due: the same object comes back (no persistence
+    // churn) and the anchor must not move.
+    const same = settleTreatGrants(ledger, 0, 1_000 + 10_000, defaultTreatConfig)
+    expect(same.gained).toBe(0)
+    expect(same.ledger).toBe(ledger)
+    // One full period after the anchor: the time treat finally lands.
+    const grant = settleTreatGrants(ledger, 0, 1_000 + defaultTreatConfig.timeTreatMs, defaultTreatConfig)
+    expect(grant.gained).toBe(1)
+    expect(grant.ledger.treats).toBe(1)
+    expect(grant.ledger.lastTreatGrantAt).toBe(1_000 + defaultTreatConfig.timeTreatMs)
   })
 
   it('caps stocked treats at maxTreats', () => {

package/src/treats.ts

@@ -58,8 +58,12 @@ function cap(treats: number, max: number): number {
  * time output counts whole periods since the time anchor
  * (`lastTreatGrantAt`) and advances only the time anchor. The two sources
  * are independent so a continuously working user still earns time treats.
- * 0 time history never backfills — the clock starts at the first settlement.
- * Both sources are clamped by the stock cap.
+ * 0 time history never backfills — the clock starts at the first settlement,
+ * and even a zero-gain first settlement writes the time anchor so the next
+ * elapsed period can accrue (anchor deadlock fix). Both sources are clamped
+ * by the stock cap. When the anchor is already set and nothing is due, the
+ * input ledger is returned unchanged (same object), so callers can skip
+ * persistence cheaply.
  */
 export function settleTreatGrants(
   ledger: TreatLedger,
@@ -74,7 +78,15 @@ export function settleTreatGrants(
   const timeAnchor = ledger.lastTreatGrantAt === 0 ? nowMs : ledger.lastTreatGrantAt
   const timeGrants = Math.floor(Math.max(0, nowMs - timeAnchor) / config.timeTreatMs)
   const gained = workGrants + timeGrants
-  if (gained <= 0) return { ledger, gained: 0 }
+  if (gained <= 0) {
+    if (ledger.lastTreatGrantAt === 0) {
+      // Zero-gain first settlement: persist the clock start anyway, so the
+      // 30-minute time output can begin. Before this fix the anchor stayed 0
+      // forever (the deadlock: no grant means no anchor write means no grant).
+      return { ledger: { ...ledger, lastTreatGrantAt: nowMs }, gained: 0 }
+    }
+    return { ledger, gained: 0 }
+  }
   return {
     ledger: {
       treats: cap(ledger.treats + gained, config.maxTreats),