@linxin666/dsh-pet 0.1.20 → 0.2.1

package/src/registry.ts

@@ -21,7 +21,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import type { PetAnimation } from './state.ts'
+import type { ActivityPhase, PetAnimation } from './state.ts'
 import { normalizePetRemarks, type PetRemarks, type PetRemarksManifest } from './remarks.ts'
 
 /** Fixed row order of the 9-state animation contract. */
@@ -135,6 +135,8 @@ export interface PetManifest {
   frames?: number[]
   /** Optional per-track rhythm overrides; omitted tracks use the defaults. */
   tracks?: Partial<Record<PetAnimation, PetTrackOverride>>
+  /** Optional per-scene track sequences; every declared sequence has at least 5 items. */
+  sequences?: Partial<Record<ActivityPhase, PetAnimation[]>>
   /**
    * Optional witty-remark overrides the pet speaks on interactions
    * (community contributions use this to give their pet its own voice).
@@ -165,8 +167,12 @@ export interface PetDefinition {
   columns: number
   /** Per-row frame counts (length 9, row order above). */
   rows: number[]
+  /** Total atlas rows (9 for v1, 11 for v2 look-row atlases). */
+  atlasRows: number
   /** Fully resolved animation tracks (frames + durations + loop/fallback). */
   tracks: Record<PetAnimation, PetTrackDef>
+  /** Validated per-scene track sequences; omitted scenes keep single-track playback. */
+  sequences?: Partial<Record<ActivityPhase, PetAnimation[]>>
   /** Browser URL of the atlas (served by the host asset route). */
   atlasUrl: string
   /** Browser URL of the manifest (served by the host asset route). */
@@ -209,6 +215,39 @@ const PET_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/
 /** Safe path-segment charset for atlas files. */
 const PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/
 const PET_NAME_MAX_LENGTH = 80
+const PET_PHASES: readonly ActivityPhase[] = ['idle', 'waiting', 'thinking', 'tool', 'review', 'done', 'failed']
+
+/** Validate optional scene sequences without rejecting an otherwise usable pet. */
+function normalizeSequences(
+  raw: unknown,
+  id: string,
+  warn: (message: string) => void,
+): Partial<Record<ActivityPhase, PetAnimation[]>> | undefined {
+  if (raw === undefined) return undefined
+  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+    warn('manifest ' + id + ': sequences must be an object keyed by activity phase')
+    return undefined
+  }
+  const sequences: Partial<Record<ActivityPhase, PetAnimation[]>> = {}
+  for (const [phase, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (!PET_PHASES.includes(phase as ActivityPhase)) {
+      warn('manifest ' + id + ': unknown sequence phase ' + JSON.stringify(phase))
+      continue
+    }
+    if (!Array.isArray(value) || value.length < 5) {
+      warn('manifest ' + id + ': sequence ' + phase + ' must contain at least 5 animations')
+      continue
+    }
+    const unknownIndex = value.findIndex(animation => typeof animation !== 'string' || !PET_ROW_ORDER.includes(animation as PetAnimation))
+    if (unknownIndex !== -1) {
+      const unknown = value[unknownIndex]
+      warn('manifest ' + id + ': sequence ' + phase + ' contains unknown animation ' + JSON.stringify(unknown))
+      continue
+    }
+    sequences[phase as ActivityPhase] = value as PetAnimation[]
+  }
+  return Object.keys(sequences).length === 0 ? undefined : sequences
+}
 
 /**
  * Normalize one parsed manifest into a renderable pet entry, or undefined
@@ -256,11 +295,14 @@ export function resolvePetManifest(
     height: finiteInt(rawCell.height, DEFAULT_PET_CELL.height, 2048),
   }
   const columns = finiteInt(source.columns, DEFAULT_PET_COLUMNS, 32)
+  // v2 atlases (spriteVersionNumber 2) hold 11 rows: 9 animation rows + 2 look rows.
+  const atlasRowCount = source.spriteVersionNumber === 2 ? 11 : DEFAULT_PET_ROW_COUNT
   const rows = DEFAULT_FRAME_COUNTS.map((fallback, index) => {
     const value = Array.isArray(source.frames) ? source.frames[index] : undefined
     return finiteInt(value, fallback, columns)
   })
   const remarks = normalizePetRemarks(source.remarks, message => warn('manifest ' + id + ': ' + message))
+  const sequences = normalizeSequences(source.sequences, id, warn)
   const trackOverrides = (typeof source.tracks === 'object' && source.tracks !== null ? source.tracks : {}) as Partial<Record<PetAnimation, PetTrackOverride>>
   const tracks = {} as Record<PetAnimation, PetTrackDef>
   for (const [row, animation] of PET_ROW_ORDER.entries()) {
@@ -295,7 +337,9 @@ export function resolvePetManifest(
     cell,
     columns,
     rows,
+    atlasRows: atlasRowCount,
     tracks,
+    ...(sequences === undefined ? {} : { sequences }),
     atlasUrl: assetUrl(assetPrefix, id, spritesheet),
     manifestUrl: assetUrl(assetPrefix, id, 'pet.json'),
     dir,
@@ -366,10 +410,18 @@ export function loadPetRegistry(options: PetRegistryOptions): PetRegistry {
   }
 
   for (const manifest of options.extra ?? []) {
-    const dir = manifest.spritesheetPath === undefined || isAbsolute(manifest.spritesheetPath)
+    const raw = manifest.spritesheetPath
+    const dir = raw === undefined || isAbsolute(raw)
       ? join(packageRoot, 'assets', 'extra')
-      : dirname(resolve(packageRoot, manifest.spritesheetPath))
-    const entry = resolvePetManifest(manifest, dir, { assetPrefix, warnings })
+      : dirname(resolve(packageRoot, raw))
+    // petAtlasFile joins entry.dir (already the spritesheet's parent when the
+    // path is package-relative) with entry.spritesheetPath, so the stored path
+    // must be the basename only — otherwise the directory segment is applied
+    // twice and the atlas 404s.
+    const source = raw === undefined || isAbsolute(raw)
+      ? manifest
+      : { ...manifest, spritesheetPath: basename(raw) }
+    const entry = resolvePetManifest(source, dir, { assetPrefix, warnings })
     if (entry === undefined) continue
     if (byId.has(entry.id)) warnings.push('composed pet ' + entry.id + ' overrides an earlier registration')
     byId.set(entry.id, entry)
@@ -393,7 +445,9 @@ export function petEntryView(entry: PetEntry): PetDefinition {
     cell: entry.cell,
     columns: entry.columns,
     rows: entry.rows,
+    atlasRows: entry.atlasRows,
     tracks: entry.tracks,
+    ...(entry.sequences === undefined ? {} : { sequences: entry.sequences }),
     atlasUrl: entry.atlasUrl,
     manifestUrl: entry.manifestUrl,
   }
@@ -408,5 +462,3 @@ export function petAtlasFile(entry: PetEntry): string {
 export function petDirAlias(entry: PetEntry): string {
   return basename(entry.dir)
 }
-
-

package/src/remarks.ts

@@ -53,6 +53,12 @@ export const BUILTIN_REMARKS: Readonly<Record<RemarkKind, readonly string[]>> =
     '蹭蹭你的手心，这是回礼～',
     '多摸摸我，亲密度会涨哦！',
     '闭眼享受中，请勿打扰～',
+    '头再低一点，够不着了～',
+    '呼噜呼噜，声音都冒出来了',
+    '这手感，比小鱼干还上瘾',
+    '摸到第三下，满意',
+    '耳朵后面，别漏了……啊，舒服',
+    '被摸得尾巴都卷起来了',
   ],
   petCooldown: [
     '摸过头啦，让鲸鱼娘歇口气～',
@@ -65,6 +71,12 @@ export const BUILTIN_REMARKS: Readonly<Record<RemarkKind, readonly string[]>> =
     '歇一歇，摸摸的手感会更好哦～',
     '咕……等我回个蓝～',
     '让我先消化一下刚才的爱！',
+    '痒痒的，先让我缓一下……',
+    '再摸就掉线了，真的',
+    '库存的呼噜声用完了',
+    '手歇会儿，我也要补个蓝',
+    '舒服归舒服，得缓缓呀',
+    '再摸下去，我就要融化了',
   ],
   feed: [
     '呜哇！小鱼干好好吃！',
@@ -77,6 +89,12 @@ export const BUILTIN_REMARKS: Readonly<Record<RemarkKind, readonly string[]>> =
     '饱餐一顿，马上满血复活～',
     '这个味道，是幸福的味道！',
     '吃完了还不忘舔舔爪子～',
+    '这小鱼干，是今天的顶配',
+    '一口下去，精神头全回来了',
+    '脆！香！就是这个味儿',
+    '边吃边摇尾巴，形象不要了',
+    '好吃到眼睛都眯起来了',
+    '这块鱼干我记住了，懂我的',
   ],
   feedCooldown: [
     '吃饱啦，晚点再喂～',
@@ -89,6 +107,12 @@ export const BUILTIN_REMARKS: Readonly<Record<RemarkKind, readonly string[]>> =
     '肚皮已经鼓鼓的啦～',
     '好吃是好吃，可也得节制呀～',
     '等我饿了会告诉你哦～',
+    '胃说它满了，脑子说还能吃',
+    '这条得留着慢慢品',
+    '先消消食，待会儿再战',
+    '塞不下了，真塞不下了',
+    '闻着香，可惜没地方放了',
+    '嗝……这顿值了',
   ],
   noTreats: [
     '没有小鱼干了，多陪我工作一会儿吧～',
@@ -101,6 +125,12 @@ export const BUILTIN_REMARKS: Readonly<Record<RemarkKind, readonly string[]>> =
     '饿着肚子等你完成下一轮任务～',
     '小鱼干藏在你的工作里，去找找看！',
     '先工作后干饭，我们的约定哦～',
+    '粮仓见底，全靠感情撑着了',
+    '饿是真饿，活也是真得干',
+    '画饼充饥……不对，画鱼干充饥',
+    '没鱼干的日子，靠意志力过',
+    '下一轮任务，我闻到了鱼干味',
+    '先记账上，欠我两条，记住啦',
   ],
 }
 
@@ -174,4 +204,10 @@ export class RemarkPicker {
     this.counters.set(kind, index + 1)
     return pool[index]!
   }
+
+  /** Select a line from a stable external counter without changing local picker state. */
+  pickAt(kind: RemarkKind, count: number): string {
+    const pool = this.pools[kind]
+    return pool[Math.max(0, Math.floor(count)) % pool.length]!
+  }
 }

package/src/routes.ts

@@ -17,6 +17,7 @@ import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
 import type { PetService } from './service.ts'
 import type { PetInteraction } from './affinity.ts'
 import { petEntryView, type PetEntry, type PetRegistry } from './registry.ts'
+import { isLoopbackRequest } from './loopback.ts'
 
 /** Browser-facing base path of the pet API. */
 export const PET_API_PREFIX = '/api/pet'
@@ -86,12 +87,20 @@ function readJsonBody(req: IncomingMessage): Promise<unknown> {
   })
 }
 
+/** Shared route fence: the browser UI is a loopback client; LAN hosts stay out. */
+function guard(req: IncomingMessage, res: ServerResponse): boolean {
+  if (isLoopbackRequest(req)) return true
+  json(res, 403, { ok: false, error: 'forbidden: loopback-only' })
+  return false
+}
+
 /** Wrap one async service call as a GET JSON route. */
 function getRoute(path: string, run: () => Promise<unknown>): WebRoute {
   return {
     kind: 'exact',
     path,
     handler: (req: IncomingMessage, res: ServerResponse): void => {
+      if (!guard(req, res)) return
       if (!requireMethod(req, res, 'GET')) return
       run().then((value) => json(res, 200, value), (error) => {
         json(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) })
@@ -106,6 +115,7 @@ function postRoute(path: string, run: (body: Record<string, unknown>) => Promise
     kind: 'exact',
     path,
     handler: (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+      if (!guard(req, res)) return Promise.resolve()
       if (!requireMethod(req, res, 'POST')) return Promise.resolve()
       return readJsonBody(req).then((body) => {
         const record = (typeof body === 'object' && body !== null) ? body as Record<string, unknown> : {}
@@ -141,6 +151,7 @@ function dirAliases(registry: PetRegistry): Map<string, PetEntry> {
 function assetHandler(registry: PetRegistry): WebRoute['handler'] {
   const aliases = dirAliases(registry)
   return (req: IncomingMessage, res: ServerResponse): void => {
+    if (!guard(req, res)) return
     if (req.method !== 'GET' && req.method !== 'HEAD') {
       res.writeHead(405)
       res.end()

package/src/service.ts

@@ -44,6 +44,7 @@ import {
   type PetManifest,
   type PetRegistry,
 } from './registry.ts'
+import { WHISPER_TTL_MS } from './chatter.ts'
 import {
   defaultPetStateConfig,
   PetStateMachine,
@@ -152,6 +153,12 @@ export interface PetStateView {
     /** Stock cap. */
     max: number
   }
+  /**
+   * The display session's fresh inner whisper (碎碎念), when one is within
+   * its TTL — short inner-voice copy woken by the model's own output,
+   * rendered by the client as a distinct whisper bubble.
+   */
+  whisper?: string
 }
 
 /** Result of `pet.interact`. */
@@ -169,6 +176,13 @@ interface SessionActivity {
   machine: PetStateMachine
   /** The session's most recent meaningful input (for display fallback). */
   lastInput?: PetStateInput
+  /** Latest inner whisper woken by this session's model output (碎碎念). */
+  whisper?: {
+    /** Whisper copy. */
+    text: string
+    /** Epoch ms when it appeared (view-side TTL applies). */
+    at: number
+  }
 }
 
 /**
@@ -319,7 +333,7 @@ export class PetService extends Service {
           const transition = projectOfficialEvent(event, runtime)
           if (transition === undefined) return
           runtime.officialEventsSeen = true
-          this.applyActivity(session, transition.input)
+          this.applyActivity(session, transition.input, transition.whisper)
           if (transition.completedTurn !== undefined) {
             this.rewardTurn(String(session.id), transition.completedTurn)
           }
@@ -364,9 +378,10 @@ export class PetService extends Service {
    * the session becomes the host-global display session (most recent
    * meaningful event wins the sprite animation).
    */
-  private applyActivity(session: Session, input: PetStateInput): void {
+  private applyActivity(session: Session, input: PetStateInput, whisper?: string): void {
     const activity = this.activityOf(session)
     activity.lastInput = input
+    if (whisper !== undefined) activity.whisper = { text: whisper, at: Date.now() }
     activity.machine.onActivityStatus(input)
     activity.machine.onSessionActive()
     // Move to the tail so map order reads most-recent-last, then trim the
@@ -495,6 +510,15 @@ export class PetService extends Service {
         phase: perSession.phase,
       })
     }
+    // The display session's inner whisper rides the global view while fresh;
+    // an expired whisper simply stops appearing (the client's 2s poll drops it).
+    const displayActivity = this.displaySession === undefined
+      ? undefined
+      : this.sessionActivity.get(this.displaySession)
+    const whisper = displayActivity?.whisper
+    const freshWhisper = whisper !== undefined && Date.now() - whisper.at < WHISPER_TTL_MS
+      ? whisper.text
+      : undefined
     // Read-only: the ledger settles on economic events only, never on a read,
     // so polling the state cannot trigger pet.json writes.
     return {
@@ -503,6 +527,7 @@ export class PetService extends Service {
       phase: snapshot.phase,
       sessionActive: snapshot.sessionActive,
       sessions,
+      ...(freshWhisper === undefined ? {} : { whisper: freshWhisper }),
       affinity: this.ledger.affinityView(Date.now()),
       display: { ...this.ledger.snapshot.display },
       pet: {

package/src/state.test.ts

@@ -33,6 +33,19 @@ describe('PetStateMachine', () => {
     expect(machine.render().bubble).toBeUndefined()
   })
 
+  it('shows failure briefly, then clears its bubble', () => {
+    let now = 1_000_000
+    const machine = new PetStateMachine({ celebrateMs: 2400, failureMs: 2400 }, () => now)
+    machine.onSessionActive()
+    machine.onActivityStatus({ phase: 'failed', line: '执行失败' })
+    expect(machine.render()).toMatchObject({ animation: 'failed', bubble: '执行失败' })
+    now += 2399
+    expect(machine.render()).toMatchObject({ animation: 'failed', bubble: '执行失败' })
+    now += 1
+    expect(machine.render()).toMatchObject({ animation: 'idle' })
+    expect(machine.render().bubble).toBeUndefined()
+  })
+
   it('shows the phrase bubble when present, else the line', () => {
     const machine = new PetStateMachine(defaultPetStateConfig, () => 1_000)
     machine.onActivityStatus({ phase: 'thinking', phrase: '查资料中', line: 'tool: grep' })

package/src/state.ts

@@ -53,9 +53,11 @@ export interface PetStateSnapshot {
 export interface PetStateConfig {
   /** Celebration window after `done` before settling to idle, ms (default 2400). */
   celebrateMs: number
+  /** Failure display window before settling to idle, ms (default 2400). */
+  failureMs: number
 }
 
-export const defaultPetStateConfig: PetStateConfig = { celebrateMs: 2400 }
+export const defaultPetStateConfig: PetStateConfig = { celebrateMs: 2400, failureMs: 2400 }
 
 /**
  * Map one activity phase onto the animation contract.
@@ -63,7 +65,7 @@ export const defaultPetStateConfig: PetStateConfig = { celebrateMs: 2400 }
  * - review → `review` while answer text is streaming.
  * - waiting → `waiting` (expectant pose, needs user input).
  * - done → `jumping` (celebration), then back to `idle` after the window.
- * - failed → `failed` until another activity event arrives.
+ * - failed → `failed` briefly, then back to `idle`.
  * - idle → `idle` (calm breathing loop).
  */
 export function animationForPhase(phase: ActivityPhase): PetAnimation {
@@ -96,7 +98,7 @@ export function rowOf(animation: PetAnimation): number {
 
 /**
  * PetStateMachine — one instance per host process. Holds only the latest
- * input snapshot and the celebration timing; no storage, no side effects.
+ * input snapshot and terminal-state timing; no storage, no side effects.
  */
 export class PetStateMachine {
   private phase: ActivityPhase = 'idle'
@@ -104,18 +106,23 @@ export class PetStateMachine {
   private phrase: string | undefined
   private sessionActive = false
   private doneAt: number | undefined
+  private failedAt: number | undefined
+  private readonly config: PetStateConfig
 
   constructor(
-    private readonly config: PetStateConfig = defaultPetStateConfig,
+    config: Partial<PetStateConfig> = defaultPetStateConfig,
     private readonly now: () => number = Date.now,
-  ) {}
+  ) {
+    this.config = { ...defaultPetStateConfig, ...config }
+  }
 
   /** Consume one projected activity update. */
   onActivityStatus(input: PetStateInput): void {
     this.phase = input.phase
     this.line = input.line
     this.phrase = input.phrase
-    if (input.phase === 'done') this.doneAt = this.now()
+    this.doneAt = input.phase === 'done' ? this.now() : undefined
+    this.failedAt = input.phase === 'failed' ? this.now() : undefined
   }
 
   /** A session became the active one (or a fresh session started). */
@@ -130,24 +137,23 @@ export class PetStateMachine {
     this.line = undefined
     this.phrase = undefined
     this.doneAt = undefined
+    this.failedAt = undefined
   }
 
   /** Render the current animation decision. */
   render(): PetStateSnapshot {
     const nowMs = this.now()
     let animation = animationForPhase(this.phase)
-    // Celebration window: after `done`, jump for celebrateMs then settle idle.
-    if (this.phase === 'done' && this.doneAt !== undefined) {
-      if (nowMs - this.doneAt < this.config.celebrateMs) {
-        animation = 'jumping'
-      } else {
-        animation = 'idle'
-      }
-    }
-    // Settled sessions never bubble: idle (e.g. an aborted/stopped turn)
-    // and done past its celebration window both fall silent.
-    const settled = this.phase === 'idle'
-      || (this.phase === 'done' && this.doneAt !== undefined && nowMs - this.doneAt >= this.config.celebrateMs)
+    const doneSettled = this.phase === 'done'
+      && this.doneAt !== undefined
+      && nowMs - this.doneAt >= this.config.celebrateMs
+    const failedSettled = this.phase === 'failed'
+      && this.failedAt !== undefined
+      && nowMs - this.failedAt >= this.config.failureMs
+    if (doneSettled || failedSettled) animation = 'idle'
+    // Settled sessions never bubble: idle (e.g. an aborted/stopped turn),
+    // completed celebration expiry, and failed display expiry all fall silent.
+    const settled = this.phase === 'idle' || doneSettled || failedSettled
     const bubble = settled ? undefined : this.phrase ?? this.line
     return {
       animation,