@linxin666/dsh-pet 0.3.13 → 0.3.15

package/src/client/PetSprite.tsx

@@ -21,7 +21,7 @@ import type { PetDefinition } from '../registry.ts'
 import type { DecorationView } from '../contracts/status-decoration.ts'
 import type { PetFeedback } from './pet-store.ts'
 import { framePosition, rowOfTrack, trimTrack } from './spritesheet.ts'
-import { sequenceFrameAt } from './sequences.ts'
+import { createSequenceTimeline } from './sequences.ts'
 import { animationForPhase, type ActivityPhase, type PetAnimation } from '../state.ts'
 import { NS } from './locales.ts'
 import styles from './pet.module.css'
@@ -339,6 +339,20 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
     const reduceMotion = typeof window !== 'undefined'
       && window.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches === true
     const sequence = animation === animationForPhase(phase) ? sequences?.[phase] : undefined
+    // Sequence state hoisted into the effect scope: the cumulative duration
+    // table and each item's trimmed track would otherwise be recomputed every
+    // tick (map/reduce plus two slices per frame), the same waste the
+    // single-track branch below avoids.
+    const timeline = sequence === undefined ? undefined : createSequenceTimeline(sequence, tracks)
+    const sequenceItems = sequence === undefined ? undefined : new Map(
+      sequence.map(itemAnimation => {
+        const itemRow = rowOfTrack(itemAnimation)
+        return [itemAnimation, {
+          row: itemRow,
+          track: trimTrack(tracks[itemAnimation], rows[itemRow] ?? tracks[itemAnimation].frames.length),
+        }]
+      }),
+    )
     const leadAnimation = sequence?.[0] ?? animation
     const row = rowOfTrack(leadAnimation)
     const track = trimTrack(tracks[leadAnimation], rows[row] ?? tracks[leadAnimation].frames.length)
@@ -357,16 +371,12 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
     const tick = (ts: number): void => {
       const delta = ts - last
       last = ts
-      if (sequence !== undefined) {
+      if (timeline !== undefined && sequenceItems !== undefined) {
         sequenceElapsed += delta
-        const current = sequenceFrameAt(sequence, tracks, sequenceElapsed)
-        const currentRow = rowOfTrack(current.animation)
-        const currentTrack = trimTrack(
-          tracks[current.animation],
-          rows[currentRow] ?? tracks[current.animation].frames.length,
-        )
-        const col = currentTrack.frames[current.frameIndex]!
-        const pos = framePosition(cell, currentRow, col, scaleRef.current)
+        const current = timeline.frameAt(sequenceElapsed)
+        const item = sequenceItems.get(current.animation)!
+        const col = item.track.frames[current.frameIndex]!
+        const pos = framePosition(cell, item.row, col, scaleRef.current)
         const posStr = pos.x + 'px ' + pos.y + 'px'
         if (posStr !== lastPosStr) {
           lastPosStr = posStr

package/src/client/index.test.tsx

@@ -61,6 +61,8 @@ interface FakeClientLifecycle {
   dispose(): void
   settingsListenerCount(): number
   emitSettings(): void
+  sessionsListenerCount(): number
+  setEnabled(enabled: boolean): void
 }
 
 const activeLifecycles: FakeClientLifecycle[] = []
@@ -73,11 +75,13 @@ afterEach(() => {
 function fakeContext(): FakeClientLifecycle {
   const disposers: (() => void)[] = []
   const settingsListeners = new Set<() => void>()
+  const sessionListeners = new Set<() => void>()
+  let settingsValue: { enabled?: boolean } | undefined
   const scope = {
     getSnapshot: () => ({
       status: 'ready',
       writable: true,
-      value: undefined,
+      value: settingsValue,
       base: undefined,
       user: {},
       revision: 1,
@@ -114,8 +118,8 @@ function fakeContext(): FakeClientLifecycle {
       list: {
         getSnapshot: () => ({ current: undefined, byId: {} }),
         subscribe: (listener: () => void) => {
-          const set = new Set<() => void>([listener])
-          return () => { set.delete(listener) }
+          sessionListeners.add(listener)
+          return () => { sessionListeners.delete(listener) }
         },
       },
       open: () => {},
@@ -133,6 +137,8 @@ function fakeContext(): FakeClientLifecycle {
     emitSettings: () => {
       for (const listener of settingsListeners) listener()
     },
+    sessionsListenerCount: () => sessionListeners.size,
+    setEnabled: (enabled: boolean) => { settingsValue = { enabled } },
   }
   activeLifecycles.push(lifecycle)
   return lifecycle
@@ -208,4 +214,26 @@ describe('pet client apply', () => {
     expect(roots).toHaveLength(1)
     expect(stale.isConnected).toBe(false)
   })
+
+  it('unsubscribes the session watch when the pet is disabled from settings', () => {
+    const lifecycle = fakeContext()
+    apply(lifecycle.ctx)
+    // The poll loop and the current-session watch both subscribe through
+    // ctx.effect, so exactly one sessions.list listener is live per mount.
+    expect(lifecycle.sessionsListenerCount()).toBe(1)
+
+    // Toggling the plugin off tears the UI down without disposing the fiber:
+    // the session watch must go with it, or every later session-store
+    // notification keeps polling a dead pet forever.
+    lifecycle.setEnabled(false)
+    lifecycle.emitSettings()
+    expect(lifecycle.sessionsListenerCount()).toBe(0)
+    expect(document.body.querySelectorAll('[data-dsh-pet-root]')).toHaveLength(0)
+
+    // Re-enabling mounts a fresh UI with a fresh watch.
+    lifecycle.setEnabled(true)
+    lifecycle.emitSettings()
+    expect(lifecycle.sessionsListenerCount()).toBe(1)
+    expect(document.body.querySelectorAll('[data-dsh-pet-root]')).toHaveLength(1)
+  })
 })

package/src/client/index.ts

@@ -403,6 +403,7 @@ export function apply(ctx: ClientContext): void {
         petRoot.unmount()
         container.remove()
         disposePoll()
+        disposeSessionWatch()
         disposeUi = undefined
       }
       // The slot teardown is the takeover hook a later apply body runs; it

package/src/client/pet-store.test.ts

@@ -0,0 +1,87 @@
+/**
+ * The pet store's poll-publish contract against the real client-store engine:
+ * an unchanged snapshot must skip the write (immer records no modification,
+ * zustand never notifies), while any transition that matters still publishes.
+ */
+import { describe, expect, it, vi } from 'vitest'
+import type { PetStateView } from '../service.ts'
+import { createPetStore } from './pet-store.ts'
+
+const snapshot = (over: Partial<PetStateView> = {}): PetStateView => ({
+  animation: 'idle',
+  phase: 'idle',
+  sessionActive: false,
+  affinity: {
+    points: 3,
+    rank: '好奇',
+    rankEmoji: '',
+    pets: 1,
+    feeds: 0,
+    turns: 0,
+    petCooldown: false,
+    feedCooldown: false,
+  },
+  display: { visible: true, size: 160, right: 24, bottom: 120 },
+  pet: { id: 'whale-girl', displayName: 'Whale', description: '' },
+  name: 'Whale',
+  treats: { stocked: 2, max: 10 },
+  ...over,
+})
+
+describe('pet store setSnapshot publish skipping', () => {
+  it('does not notify when a poll republishes an unchanged snapshot', () => {
+    const store = createPetStore().create()
+    const listener = vi.fn()
+    store.subscribe(listener)
+
+    const first = snapshot()
+    store.actions.setSnapshot(first)
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(store.getSnapshot().state).toBe('ready')
+
+    // A fresh, deep-equal object is what every poll tick delivers.
+    store.actions.setSnapshot(snapshot())
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(store.getSnapshot().snapshot).toBe(first)
+
+    // Any content change publishes again.
+    store.actions.setSnapshot(snapshot({ phase: 'thinking', animation: 'running' }))
+    expect(listener).toHaveBeenCalledTimes(2)
+  })
+
+  it('publishes after an error state even when the payload is unchanged', () => {
+    const store = createPetStore().create()
+    const listener = vi.fn()
+    store.subscribe(listener)
+    store.actions.setSnapshot(snapshot())
+
+    store.actions.setState('error', 'pet.state transport error')
+    expect(listener).toHaveBeenCalledTimes(2)
+
+    // The success transition (error -> ready) must land despite the equal
+    // payload, or the UI would stay stuck on the transport-error banner.
+    store.actions.setSnapshot(snapshot())
+    expect(listener).toHaveBeenCalledTimes(3)
+    expect(store.getSnapshot().state).toBe('ready')
+    expect(store.getSnapshot().error).toBeNull()
+  })
+
+  it('still patches the gameplay view and feedback on top of a skipped poll', () => {
+    const store = createPetStore().create()
+    store.actions.setSnapshot(snapshot())
+    const base = store.getSnapshot().snapshot!
+
+    store.actions.setGameplayView({ stats: { mood: 70 }, mode: 'work' })
+    expect(store.getSnapshot().snapshot).not.toBe(base)
+    expect(store.getSnapshot().snapshot?.gameplay).toEqual({ stats: { mood: 70 }, mode: 'work' })
+
+    store.actions.setFeedback({ text: '喵', kind: 'pet', at: 1 })
+    expect(store.getSnapshot().feedback).toEqual({ text: '喵', kind: 'pet', at: 1 })
+
+    // The next identical poll (a fresh but deep-equal object) skips the
+    // publish and keeps the exact snapshot reference the UI already holds.
+    const before = store.getSnapshot().snapshot
+    store.actions.setSnapshot(snapshot({ gameplay: { stats: { mood: 70 }, mode: 'work' } }))
+    expect(store.getSnapshot().snapshot).toBe(before)
+  })
+})

package/src/client/pet-store.ts

@@ -66,6 +66,14 @@ export function createPetStore(): EngineStoreHandle<PetUiState, PetUiActions> {
     }),
     actions: {
       setSnapshot: (draft, snapshot) => {
+        // The 2 s poll republishes the full snapshot even while the pet is
+        // idle. Skipping an unchanged payload keeps immer's produce at zero
+        // modifications, so zustand never notifies and the whole sprite tree
+        // skips the re-render. Equality is JSON-based and skip-only: both
+        // sides come from the same host serializer, and any mismatch falls
+        // through to the normal publish — the failure mode is one extra
+        // render, never a stale pet.
+        if (draft.state === 'ready' && draft.error === null && sameSnapshot(draft.snapshot, snapshot)) return
         draft.snapshot = snapshot
         draft.state = 'ready'
         draft.error = null
@@ -89,6 +97,16 @@ export function createPetStore(): EngineStoreHandle<PetUiState, PetUiActions> {
 
 export type { PetInteraction }
 
+/**
+ * Content equality for consecutive poll snapshots. JSON compare, not field
+ * enumeration: an exact string match is the only way to skip the publish, so
+ * a missed field can never freeze the UI — it can only cost the render the
+ * optimization exists to save.
+ */
+function sameSnapshot(previous: PetStateView | null, next: PetStateView): boolean {
+  return previous !== null && JSON.stringify(previous) === JSON.stringify(next)
+}
+
 /**
  * A live pet store instance (one per host, owned by the plugin apply body —
  * the pet itself is host-global, so its UI state must not ride the slot

package/src/client/sequences.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import type { PetTrackDef } from '../registry.ts'
 import type { PetAnimation } from '../state.ts'
-import { sequenceFrameAt } from './sequences.ts'
+import { createSequenceTimeline, sequenceFrameAt } from './sequences.ts'
 
 const track = (durations: number[]): PetTrackDef => ({
   frames: durations.map((_, index) => index),
@@ -31,3 +31,23 @@ describe('sequenceFrameAt', () => {
     expect(sequenceFrameAt(sequence, tracks, 1_420)).toEqual({ animation: 'running', frameIndex: 0 })
   })
 })
+
+describe('createSequenceTimeline', () => {
+  const sequence: PetAnimation[] = ['running', 'waiting']
+
+  it('resolves identically to the per-call helper at animation-sample elapsed values', () => {
+    // The sprite frame loop asks once per rAF tick with accumulated
+    // millisecond offsets; the precomputed table must agree everywhere.
+    const timeline = createSequenceTimeline(sequence, tracks)
+    for (let elapsed = 0; elapsed <= 1_500; elapsed += 7) {
+      expect(timeline.frameAt(elapsed)).toEqual(sequenceFrameAt(sequence, tracks, elapsed))
+    }
+  })
+
+  it('stays deterministic across repeated queries with the same table', () => {
+    const timeline = createSequenceTimeline(sequence, tracks)
+    expect(timeline.frameAt(350)).toEqual(timeline.frameAt(350))
+    expect(timeline.frameAt(0)).toEqual({ animation: 'running', frameIndex: 0 })
+    expect(timeline.frameAt(1_420)).toEqual({ animation: 'running', frameIndex: 0 })
+  })
+})

package/src/client/sequences.ts

@@ -8,26 +8,47 @@ export interface SequenceFrame {
   frameIndex: number
 }
 
+/**
+ * Precomputed timeline for one looping sequence: the per-item duration table
+ * is built once instead of per query. The sprite frame loop asks at
+ * animation rate (~60 Hz), where the per-call map/reduce is pure waste.
+ */
+export interface SequenceTimeline {
+  frameAt(elapsedMs: number): SequenceFrame
+}
+
+/** Build a {@link SequenceTimeline} over one manifest sequence. */
+export function createSequenceTimeline(
+  sequence: readonly PetAnimation[],
+  tracks: Record<PetAnimation, PetTrackDef>,
+): SequenceTimeline {
+  const itemDurations = sequence.map(animation => tracks[animation].durations.reduce((sum, value) => sum + value, 0))
+  const sequenceDuration = itemDurations.reduce((sum, value) => sum + value, 0)
+  return {
+    frameAt(elapsedMs: number): SequenceFrame {
+      let offset = Math.max(0, elapsedMs) % sequenceDuration
+      let itemIndex = 0
+      while (itemIndex < sequence.length - 1 && offset >= itemDurations[itemIndex]!) {
+        offset -= itemDurations[itemIndex]!
+        itemIndex += 1
+      }
+      const animation = sequence[itemIndex]!
+      const track = tracks[animation]
+      let frameIndex = 0
+      while (frameIndex < track.frames.length - 1 && offset >= track.durations[frameIndex]!) {
+        offset -= track.durations[frameIndex]!
+        frameIndex += 1
+      }
+      return { animation, frameIndex }
+    },
+  }
+}
+
 /** Resolve the active track and frame after elapsed milliseconds of a looping sequence. */
 export function sequenceFrameAt(
   sequence: readonly PetAnimation[],
   tracks: Record<PetAnimation, PetTrackDef>,
   elapsedMs: number,
 ): SequenceFrame {
-  const itemDurations = sequence.map(animation => tracks[animation].durations.reduce((sum, value) => sum + value, 0))
-  const sequenceDuration = itemDurations.reduce((sum, value) => sum + value, 0)
-  let offset = Math.max(0, elapsedMs) % sequenceDuration
-  let itemIndex = 0
-  while (itemIndex < sequence.length - 1 && offset >= itemDurations[itemIndex]!) {
-    offset -= itemDurations[itemIndex]!
-    itemIndex += 1
-  }
-  const animation = sequence[itemIndex]!
-  const track = tracks[animation]
-  let frameIndex = 0
-  while (frameIndex < track.frames.length - 1 && offset >= track.durations[frameIndex]!) {
-    offset -= track.durations[frameIndex]!
-    frameIndex += 1
-  }
-  return { animation, frameIndex }
+  return createSequenceTimeline(sequence, tracks).frameAt(elapsedMs)
 }

package/src/index.ts

@@ -190,21 +190,37 @@ function applyImpl(ctx: Context, config: PetConfig = {}): void {
     }
   }
   ctx.inject(['settings'], (settingsCtx) => {
-    settingsCtx.settings.installSection(
-      ctx,
-      PET_SETTINGS_NAMESPACE as SettingsNamespace,
-      makePetSettingsSchema(service.selectedPetId()),
-      base,
-      {
-        setSource: (source) => { current = source },
-        onChange: () => {
+    try {
+      const schema = makePetSettingsSchema(service.selectedPetId())
+      if (typeof settingsCtx.settings?.installSection === 'function') {
+        settingsCtx.settings.installSection(
+          ctx,
+          PET_SETTINGS_NAMESPACE as SettingsNamespace,
+          schema,
+          base,
+          {
+            setSource: (source) => { current = source },
+            onChange: () => {
+              const section = current()
+              service.applySettingsSection(section)
+              service.setEnabled(section.enabled ?? true)
+              syncRoutes()
+            },
+          },
+        )
+      } else if (typeof settingsCtx.settings?.register === 'function') {
+        const scope = settingsCtx.settings.register(PET_SETTINGS_NAMESPACE as SettingsNamespace, schema, { base })
+        current = () => scope?.get?.() ?? base
+        scope?.watch?.(() => {
           const section = current()
           service.applySettingsSection(section)
           service.setEnabled(section.enabled ?? true)
           syncRoutes()
-        },
-      },
-    )
+        })
+      }
+    } catch {
+      // Defensive fallback against settings registration differences
+    }
   })
   syncRoutes()
 }

package/src/routes.ts

@@ -65,14 +65,30 @@ function extensionOf(file: string): string {
   return dot < 0 ? '' : file.slice(dot).toLowerCase()
 }
 
+/**
+ * Realpaths of containment bases, resolved once per base instead of once per
+ * request: every asset/runtime/decoration request used to pay a base
+ * realpathSync on the hot path. Bases are registry entry directories and the
+ * runtime roots — an immutable, registry-bounded set. Only successes are
+ * cached (a missing base keeps failing per request), and a symlinked base
+ * re-pointed mid-process fails containment until restart, which is the
+ * deny-safe direction.
+ */
+const REAL_BASE_CACHE = new Map<string, string>()
+
 /**
  * realpath containment: resolve both sides and require the candidate to stay
  * inside the base directory. A pet directory (or an atlas/preview inside it)
- * that is a symlink escaping its root is rejected, never followed.
+ * that is a symlink escaping its root is rejected, never followed. The
+ * candidate is realpath'ed live on every call; only the base side is cached.
  */
 export function containedRealpath(base: string, candidate: string): string | undefined {
   try {
-    const realBase = realpathSync(base)
+    let realBase = REAL_BASE_CACHE.get(base)
+    if (realBase === undefined) {
+      realBase = realpathSync(base)
+      REAL_BASE_CACHE.set(base, realBase)
+    }
     const realCandidate = realpathSync(candidate)
     return realCandidate === realBase || realCandidate.startsWith(realBase + sep)
       ? realCandidate
@@ -98,6 +114,19 @@ function mimeFor(file: string): string {
   return MIME_BY_EXT[file.slice(dot).toLowerCase()] ?? 'application/octet-stream'
 }
 
+/** Weak validator from size + mtime, shared by the three file routes. */
+function weakEtag(stat: { size: number; mtimeMs: number }): string {
+  return '"' + stat.size.toString(16) + '-' + Math.round(stat.mtimeMs).toString(16) + '"'
+}
+
+/** Answer 304 when If-None-Match matches the etag; true when handled. */
+function revalidated(req: IncomingMessage, res: ServerResponse, etag: string): boolean {
+  if (req.headers['if-none-match'] !== etag) return false
+  res.writeHead(304, { etag, 'cache-control': 'no-cache' })
+  res.end()
+  return true
+}
+
 /** Require the method or answer 405. */
 function requireMethod(req: IncomingMessage, res: ServerResponse, method: string): boolean {
   if (req.method === method) return true
@@ -177,6 +206,13 @@ function dirAliases(registry: PetRegistry): Map<string, PetEntry> {
  */
 function assetHandler(ctx: Context, registry: PetRegistry, caps: PetAssetCaps): WebRoute['handler'] {
   const aliases = dirAliases(registry)
+  // The servable match is a Set probe instead of a linear scan: a full live2d
+  // closure routinely exceeds a hundred files, each fetched through this
+  // handler per mount. The registry is an immutable snapshot, so the sets are
+  // built once per handler.
+  const servableById = new Map<string, ReadonlySet<string>>(
+    registry.entries.map(entry => [entry.id, new Set(entry.servable)]),
+  )
   return ((req: IncomingMessage, res: ServerResponse) => {
     if (!guard(ctx, req, res)) return
     if (req.method !== 'GET' && req.method !== 'HEAD') {
@@ -231,7 +267,7 @@ function assetHandler(ctx: Context, registry: PetRegistry, caps: PetAssetCaps):
       const manifestFile = join(entry.dir, MANIFEST_FILE)
       file = existsSync(manifestFile) ? manifestFile : undefined
       if (file === undefined) synthesized = true
-    } else if (rest.length > 0 && entry.servable.includes(rel)) {
+    } else if (rest.length > 0 && servableById.get(entry.id)?.has(rel)) {
       file = join(entry.dir, rel)
     } else if (rest.length === 2 && rest[0] === PREVIEW_DIR && PREVIEW_PATTERN.test(rest[1]!)) {
       const preview = join(entry.dir, PREVIEW_DIR, rest[1]!)
@@ -267,8 +303,10 @@ function assetHandler(ctx: Context, registry: PetRegistry, caps: PetAssetCaps):
     const cap = rest.length === 1 && rest[0] === MANIFEST_FILE
       ? caps.manifest
       : IMAGE_EXTENSIONS.has(extensionOf(rel)) ? caps.image : caps.model
+    let stat: ReturnType<typeof statSync>
     try {
-      if (statSync(resolved).size > cap) {
+      stat = statSync(resolved)
+      if (stat.size > cap) {
         res.writeHead(413)
         res.end()
         return
@@ -278,11 +316,18 @@ function assetHandler(ctx: Context, registry: PetRegistry, caps: PetAssetCaps):
       res.end()
       return
     }
+    // 'no-cache' forces revalidation before every reuse, and the validator
+    // lets repeat requests settle as 304 — atlases and frames are the largest
+    // payloads the plugin serves (up to the 20 MB image cap), and without a
+    // validator every remount or page load would re-download them in full.
+    const etag = weakEtag(stat)
+    if (revalidated(req, res, etag)) return
     return readFile(resolved).then((body) => {
       res.writeHead(200, {
         'content-type': mimeFor(resolved),
         'content-length': String(body.byteLength),
         'cache-control': 'no-cache',
+        etag,
       })
       if (req.method === 'HEAD') {
         res.end()
@@ -373,8 +418,10 @@ function runtimeHandler(ctx: Context, roots: { runtimeDir: string; vendorDir: st
       res.end()
       return
     }
+    let stat: ReturnType<typeof statSync>
     try {
-      if (statSync(resolved).size > PET_RUNTIME_CAP) {
+      stat = statSync(resolved)
+      if (stat.size > PET_RUNTIME_CAP) {
         res.writeHead(413)
         res.end()
         return
@@ -384,11 +431,17 @@ function runtimeHandler(ctx: Context, roots: { runtimeDir: string; vendorDir: st
       res.end()
       return
     }
+    // Same validator as the asset routes: the Cubism Core and vendor bundle
+    // ride every page load of a live2d pet, so revalidation should settle as
+    // 304 instead of re-downloading the full bodies.
+    const etag = weakEtag(stat)
+    if (revalidated(req, res, etag)) return
     return readFile(resolved).then((body) => {
       res.writeHead(200, {
         'content-type': name.endsWith('.map') ? 'application/json' : 'application/javascript; charset=utf-8',
         'content-length': String(body.byteLength),
         'cache-control': 'no-cache',
+        etag,
       })
       if (req.method === 'HEAD') {
         res.end()
@@ -496,12 +549,8 @@ function decorationHandler(ctx: Context, registry: PetRegistry, caps: PetAssetCa
     // validator lets repeat requests settle as 304 — the ornament remounts
     // on whisper and display-session flips, and without a validator each
     // remount would re-download the full strip body.
-    const etag = '"' + stat.size.toString(16) + '-' + Math.round(stat.mtimeMs).toString(16) + '"'
-    if (req.headers['if-none-match'] === etag) {
-      res.writeHead(304, { etag, 'cache-control': 'no-cache' })
-      res.end()
-      return
-    }
+    const etag = weakEtag(stat)
+    if (revalidated(req, res, etag)) return
     readFile(resolved).then((body) => {
       res.writeHead(200, {
         'content-type': mimeFor(resolved),