@linxin666/dsh-pet 0.3.5 → 0.3.6

package/src/client/renderers/frames2d.ts

@@ -8,6 +8,18 @@
  * 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.
+ *
+ * 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).
+ * - 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.
+ *
  * @module @linxin666/dsh-pet/client/renderers/frames2d
  */
 
@@ -69,6 +81,12 @@ function validateFrames2dConfig(config: unknown): PetFrames2dConfig {
   return { tracks, phases: phases as PetFrames2dConfig['phases'] }
 }
 
+interface DecodedFrame {
+  source: ImageBitmap | HTMLImageElement
+  width: number
+  height: number
+}
+
 export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
   id: 'frames2d',
   apiVersion: PET_RENDERER_API_VERSION,
@@ -79,23 +97,78 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
       && 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
+    // Capability probe: the canvas path needs decode-to-bitmap, same-origin
+    // fetch, and a real 2D context (jsdom returns null and falls back below).
+    let canvas: HTMLCanvasElement | null = null
+    let context2d: CanvasRenderingContext2D | null = null
+    let img: HTMLImageElement | null = null
+    try {
+      if (typeof createImageBitmap === 'function' && typeof fetch === 'function') {
+        const probe = document.createElement('canvas')
+        const c2d = probe.getContext('2d')
+        if (c2d !== null) {
+          canvas = probe
+          context2d = c2d
+        }
       }
+    } catch {
+      canvas = null
+      context2d = null
+    }
+
+    if (canvas !== null && context2d !== null) {
+      canvas.dataset.dshPetFrames2d = ctx.petId
+      canvas.draggable = false
+      canvas.style.width = '100%'
+      canvas.style.height = '100%'
+      canvas.style.objectFit = 'contain'
+      canvas.style.pointerEvents = 'none'
+      ctx.container.appendChild(canvas)
+    } else {
+      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)
+    }
+
+    // Decode cache: one concurrent decode per URL, memoized forever (frames
+    // are tiny same-origin webp files; failures resolve undefined and keep
+    // 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> => {
+      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)
+            }
+          })
+        }
+      })()
+      decoding.set(url, job)
+      decodedAll.push(job.then(() => undefined, () => undefined))
+      return job
     }
 
     let disposed = false
@@ -105,16 +178,42 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
     let frameIndex = 0
     let lastAdvance = Date.now()
     let override: string | undefined
+    let drawToken = 0
+    let lastDrawnUrl: string | undefined
 
     const trackForPhase = (phase: ActivityPhase): string => {
       const mapped = config.phases[phase]
       return mapped !== undefined && config.tracks[mapped] !== undefined ? mapped : config.phases.idle
     }
 
+    /** Canvas path: paints the newest requested frame; stale draws drop out. */
+    const paintCanvas = (url: string): void => {
+      if (context2d === null || canvas === null) return
+      const myToken = ++drawToken
+      void loadFrame(url).then((frame) => {
+        if (disposed || frame === undefined || myToken !== drawToken) return
+        if (lastDrawnUrl === url) return
+        lastDrawnUrl = url
+        // Resizing clears the canvas, so size only when it actually differs.
+        if (canvas.width !== frame.width || canvas.height !== frame.height) {
+          canvas.width = frame.width
+          canvas.height = frame.height
+        } else {
+          context2d.clearRect(0, 0, canvas.width, canvas.height)
+        }
+        context2d.drawImage(frame.source as CanvasImageSource, 0, 0)
+      }).catch(() => { /* keep last frame */ })
+    }
+
     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
+      if (url === undefined) return
+      if (img !== null) {
+        if (img.getAttribute('src') !== url) img.src = url
+        return
+      }
+      paintCanvas(url)
     }
 
     const schedule = (ms: number): void => {
@@ -180,6 +279,13 @@ 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
@@ -190,7 +296,21 @@ export const frames2dRenderer: PetRenderer<PetFrames2dConfig> = {
       unsubscribe()
       if (timer !== undefined) clearTimeout(timer)
       if (watchdog !== undefined) clearInterval(watchdog)
-      img.remove()
+      // Release decoded bitmaps after pending decodes settle; close() is
+      // browser-only, so guard it for exotic hosts.
+      void Promise.allSettled(decodedAll).then(() => {
+        for (const job of decoding.values()) {
+          void job.then((frame) => {
+            try {
+              const maybeClose = (frame?.source as { close?: () => void } | undefined)?.close
+              if (typeof maybeClose === 'function' && frame !== undefined) maybeClose.call(frame.source)
+            } catch { /* already released */ }
+          }).catch(() => { /* never rejects anyway */ })
+        }
+        decoding.clear()
+      })
+      canvas?.remove()
+      img?.remove()
     }
     ctx.onCleanup(dispose)
 

package/src/ledger.ts

@@ -32,6 +32,8 @@ export interface LedgerConfig {
   treats?: Partial<TreatConfig>
   /** Per-pet remark pools for the selected pet (custom slots override built-ins). */
   remarks?: PetRemarks
+  /** Voice-pack fallback remark pools (global or pet voice pack). */
+  voiceRemarks?: PetRemarks
 }
 
 /** Result of one ledger interaction (the shape the pet RPC returns). */
@@ -63,7 +65,7 @@ export class PetLedger {
   constructor(persist: PetPersist, config: LedgerConfig = {}) {
     this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
     this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
-    this.picker = new RemarkPicker(config.remarks)
+    this.picker = new RemarkPicker(config.remarks, config.voiceRemarks)
     this.current = persist
   }
 
@@ -124,10 +126,10 @@ export class PetLedger {
 
   /**
    * Swap the reaction pools to another pet's custom remarks (called on pet
-   * selection). Slots the pet does not declare fall back to built-ins.
+   * selection). Slots the pet does not declare fall back to voice packs or built-ins.
    */
-  setRemarks(remarks?: PetRemarks): void {
-    this.picker = new RemarkPicker(remarks)
+  setRemarks(remarks?: PetRemarks, voiceRemarks?: PetRemarks): void {
+    this.picker = new RemarkPicker(remarks, voiceRemarks)
   }
 
   /**

package/src/pair-access.ts

@@ -0,0 +1,49 @@
+// Generated by scripts/sync-shared.mjs from shared/host/pair-access.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Pairing trust fence shared by plugins that expose host routes: loopback
+ * (the desktop) always passes; a live paired-device cookie is an additional
+ * allow path when remote-web-ui is loaded. The consuming plugin never
+ * depends on that plugin — without the service the fence stays
+ * loopback-only.
+ *
+ * Per-package wrappers (access.ts) call this with their own name so each
+ * plugin keeps a self-describing export; the security decision lives only
+ * here.
+ */
+import type { IncomingMessage } from 'node:http'
+import { isLoopbackRequest } from './loopback.ts'
+
+/** Structural pairing lookup (no package dependency on remote-web-ui). */
+interface PairingAccess {
+  isPairedDevice(request: IncomingMessage): boolean
+}
+
+/**
+ * Structural host-context shape: shared sources carry no @deepseek-ai
+ * dependency (the shared package must typecheck standalone), so the fence
+ * reads only the two members it needs; cordis Context satisfies this.
+ * ctx.get is optional on the test harness; production Context always has it.
+ */
+interface LookupCtx {
+  get?(name: string, strict?: boolean): unknown
+  remoteWebUiPairing?: PairingAccess
+}
+
+/**
+ * Whether this request may enter the plugin's host routes.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param request - the incoming HTTP request.
+ * @returns true for loopback, or a live paired-device cookie.
+ */
+export function isPairedOrLoopbackAllowed(ctx: LookupCtx, request: IncomingMessage): boolean {
+  if (isLoopbackRequest(request)) return true
+  const fromGet = typeof ctx.get === 'function' ? ctx.get('remoteWebUiPairing', false) : undefined
+  const pairing = (isPairingAccess(fromGet) ? fromGet : ctx.remoteWebUiPairing)
+  return pairing?.isPairedDevice(request) === true
+}
+
+function isPairingAccess(value: unknown): value is PairingAccess {
+  return value !== undefined
+    && value !== null
+    && typeof (value as PairingAccess).isPairedDevice === 'function'
+}

package/src/remarks.test.ts

@@ -54,6 +54,16 @@ describe('RemarkPicker', () => {
     expect(picker.pick('pet')).toBe('专属摸头台词')
     expect(picker.pick('feed')).toBe(BUILTIN_REMARKS.feed[0])
   })
+
+  it('layers pet custom lines over voice pack lines, falling back to built-ins (#1226)', () => {
+    const picker = new RemarkPicker(
+      { pet: ['Pet-level line'] },
+      { pet: ['Voice-level pet line'], feed: ['Voice-level feed line'] },
+    )
+    expect(picker.pick('pet')).toBe('Pet-level line')
+    expect(picker.pick('feed')).toBe('Voice-level feed line')
+    expect(picker.pick('noTreats')).toBe(BUILTIN_REMARKS.noTreats[0])
+  })
 })
 
 describe('normalizePetRemarks', () => {

package/src/remarks.ts

@@ -184,11 +184,18 @@ export class RemarkPicker {
   private readonly counters = new Map<RemarkKind, number>()
   private readonly pools: Record<RemarkKind, readonly string[]>
 
-  constructor(overrides?: PetRemarks) {
+  constructor(overrides?: PetRemarks, voiceOverrides?: PetRemarks) {
     this.pools = {} as Record<RemarkKind, readonly string[]>
     for (const kind of REMARK_KINDS) {
       const custom = overrides?.[kind]
-      this.pools[kind] = custom !== undefined && custom.length > 0 ? custom : BUILTIN_REMARKS[kind]
+      const voice = voiceOverrides?.[kind]
+      if (custom !== undefined && custom.length > 0) {
+        this.pools[kind] = custom
+      } else if (voice !== undefined && voice.length > 0) {
+        this.pools[kind] = voice
+      } else {
+        this.pools[kind] = BUILTIN_REMARKS[kind]
+      }
     }
   }
 

package/src/service.ts

@@ -297,10 +297,12 @@ export class PetService extends Service {
       persist = { ...persist, petId: this.registry.defaultEntry().id }
     }
     const selected = this.registry.byId(persist.petId) ?? this.registry.defaultEntry()
+    const voiceRemarks = mergeVoicePacks(this.registry.globalVoice, selected.voice)?.remarks
     const ledgerConfig: LedgerConfig = {
       affinity: config.affinity,
       treats: config.treats,
       remarks: selected.remarks,
+      voiceRemarks,
     }
     this.ledger = new PetLedger(persist, ledgerConfig)
     this.stateConfig = { ...defaultPetStateConfig, ...(config.state ?? {}) }
@@ -390,7 +392,8 @@ export class PetService extends Service {
     const entry = this.registry.byId(petId)
     if (entry === undefined) return { ok: false, error: 'unknown-pet' }
     this.ledger.setPetId(entry.id)
-    this.ledger.setRemarks(entry.remarks)
+    const voiceRemarks = mergeVoicePacks(this.registry.globalVoice, entry.voice)?.remarks
+    this.ledger.setRemarks(entry.remarks, voiceRemarks)
     this.flush()
     this.syncSettingsFromPet()
     return { ok: true, petId: entry.id }

package/src/voice-pack.test.ts

@@ -53,6 +53,45 @@ describe('normalizeVoicePack structure', () => {
     expect(warnings.join('\n')).toContain('mystery')
     expect(warnings.join('\n')).toContain('voicePackVersion')
   })
+
+  it('normalizes top-level remarks and ranks (#1226)', () => {
+    const { pack, warnings } = collectWarnings({
+      remarks: {
+        pet: ['Purr~ So comfortable!'],
+        feed: 'Yummy fish!',
+      },
+      ranks: {
+        '0': 'Baby Whale',
+        '幼鲸': 'Little Whale',
+      },
+    })
+    expect(pack).toBeDefined()
+    expect(pack?.remarks?.pet).toEqual(['Purr~ So comfortable!'])
+    expect(pack?.remarks?.feed).toEqual(['Yummy fish!'])
+    expect(pack?.ranks).toEqual({
+      '0': 'Baby Whale',
+      '幼鲸': 'Little Whale',
+    })
+    expect(warnings).toHaveLength(0)
+  })
+
+  it('merges remarks and ranks across layers (#1226)', () => {
+    const base = normalizeVoicePack({
+      remarks: { pet: ['Base pet'], feed: ['Base feed'] },
+      ranks: { '0': 'Base 0', '25': 'Base 25' },
+    })
+    const layer = normalizeVoicePack({
+      remarks: { pet: ['Layer pet'] },
+      ranks: { '0': 'Layer 0' },
+    })
+    const merged = mergeVoicePacks(base, layer)
+    expect(merged?.remarks?.pet).toEqual(['Layer pet'])
+    expect(merged?.remarks?.feed).toEqual(['Base feed'])
+    expect(merged?.ranks).toEqual({
+      '0': 'Layer 0',
+      '25': 'Base 25',
+    })
+  })
 })
 
 describe('normalizePool', () => {

package/src/voice-pack.ts

@@ -37,6 +37,7 @@ import {
   type WhisperCategory,
   type WhisperResult,
 } from './chatter.ts'
+import { normalizePetRemarks, type PetRemarks } from './remarks.ts'
 
 /** Schema version this module normalizes (optional field; missing = 1). */
 export const VOICE_PACK_V1 = 1 as const
@@ -69,6 +70,10 @@ export interface VoicePack {
   overrides: VoicePackOverrides
   /** Hover-panel chrome, when the pack declares any. */
   panel?: PetPanelView
+  /** Pat/feed interaction remark pools (issue #1226). */
+  remarks?: PetRemarks
+  /** Affinity rank name overrides (issue #1226). */
+  ranks?: Record<string, string>
 }
 
 /** Hard caps shared by every pool slot (mirrors the remarks discipline). */
@@ -265,7 +270,7 @@ export function normalizePanel(
 }
 
 /** Voice-pack top-level fields ('$schema' mirrors the schema twin; drift-locked in tests). */
-export const VOICE_PACK_KEYS = new Set(['$schema', 'voicePackVersion', 'status', 'tools', 'toolRemaining', 'whispers', 'panel'])
+export const VOICE_PACK_KEYS = new Set(['$schema', 'voicePackVersion', 'status', 'tools', 'toolRemaining', 'whispers', 'panel', 'remarks', 'ranks'])
 
 /** Allowed whisper-section fields (drift-locked in tests). */
 export const WHISPER_KEYS = new Set(['categories', 'results'])
@@ -356,16 +361,36 @@ export function normalizeVoicePack(
     }
   }
   const panel = raw.panel === undefined ? undefined : normalizePanel(raw.panel, onWarning)
+  const remarks = raw.remarks === undefined ? undefined : normalizePetRemarks(raw.remarks, onWarning)
+  const ranksRaw = raw.ranks
+  let ranks: Record<string, string> | undefined
+  if (ranksRaw !== undefined) {
+    if (!isRecord(ranksRaw)) {
+      onWarning('ranks must be an object')
+    } else {
+      const out: Record<string, string> = {}
+      for (const [key, value] of Object.entries(ranksRaw)) {
+        if (typeof value === 'string' && value.trim() !== '') {
+          out[key] = value.trim().slice(0, VOICE_STAT_MAX)
+        } else {
+          onWarning('invalid rank name for ' + key)
+        }
+      }
+      if (Object.keys(out).length > 0) ranks = out
+    }
+  }
   if (
     overrides.status === undefined && overrides.tools === undefined
     && overrides.toolRemaining === undefined && overrides.whispers === undefined
-    && panel === undefined
+    && panel === undefined && remarks === undefined && ranks === undefined
   ) {
     return undefined
   }
   return {
     overrides,
     ...(panel === undefined ? {} : { panel }),
+    ...(remarks === undefined ? {} : { remarks }),
+    ...(ranks === undefined ? {} : { ranks }),
   }
 }
 
@@ -379,6 +404,8 @@ export function mergeVoicePacks(...layers: (VoicePack | undefined)[]): VoicePack
   const overrides: VoicePackOverrides = {}
   const labels: NonNullable<PetPanelView['labels']> = {}
   const stats: NonNullable<PetPanelView['stats']> = {}
+  let remarks: PetRemarks | undefined
+  let ranks: Record<string, string> | undefined
   let actions: PanelAction[] | undefined
   let panelSeen = false
   let any = false
@@ -401,6 +428,12 @@ export function mergeVoicePacks(...layers: (VoicePack | undefined)[]): VoicePack
       if (layer.panel.stats !== undefined) Object.assign(stats, layer.panel.stats)
       if (layer.panel.actions !== undefined) actions = layer.panel.actions
     }
+    if (layer.remarks !== undefined) {
+      remarks = { ...(remarks ?? {}), ...layer.remarks }
+    }
+    if (layer.ranks !== undefined) {
+      ranks = { ...(ranks ?? {}), ...layer.ranks }
+    }
   }
   if (!any) return undefined
   const panel: PetPanelView = {
@@ -412,5 +445,7 @@ export function mergeVoicePacks(...layers: (VoicePack | undefined)[]): VoicePack
   return {
     overrides,
     ...(panelSeen && !panelEmpty ? { panel } : {}),
+    ...(remarks !== undefined ? { remarks } : {}),
+    ...(ranks !== undefined ? { ranks } : {}),
   }
 }