@linxin666/dsh-pet 0.2.7 → 0.2.9

package/src/client/ui-teardown.ts

@@ -0,0 +1,47 @@
+/**
+ * Cross-bundle-instance teardown slot for the page-global pet root
+ * (issue #785).
+ *
+ * A client bundle swap (HMR rebuilt frame, plugin update, duplicate
+ * injection) runs a new apply body while the previous instance's fiber
+ * may still be draining. Module state does not survive the swap, so a
+ * closure guard only sees one apply body and the previous instance's
+ * container keeps sitting on document.body: the page shows two pets
+ * until a full refresh. The slot rides globalThis (which does survive)
+ * so a re-apply can find the previous instance and unmount its React
+ * root cleanly before mounting its own; the previous fiber's later
+ * disposal stays a no-op through the idempotent teardowns.
+ */
+
+const SLOT = Symbol.for('dsh-pet.client-ui-teardown')
+
+interface TeardownSlot {
+  [SLOT]?: (() => void) | undefined
+}
+
+/**
+ * Claim the page-global pet UI slot with the current instance's teardown
+ * (React root unmount + container removal + poll stop).
+ * @param teardown - what a later instance runs to take the slot over.
+ * @returns a disposer that clears the slot when the current instance's
+ * UI is torn down (settings toggle, takeover, or fiber disposal).
+ */
+export function registerPetUiTeardown(teardown: () => void): () => void {
+  const slot = globalThis as TeardownSlot
+  slot[SLOT] = teardown
+  return () => {
+    if (slot[SLOT] === teardown) slot[SLOT] = undefined
+  }
+}
+
+/**
+ * Run the previous instance's teardown if one is registered, so the
+ * re-applying instance becomes the sole owner of the page-global pet
+ * root. No-op when the previous fiber already tore down cleanly.
+ */
+export function takeoverPetUiTeardown(): void {
+  const slot = globalThis as TeardownSlot
+  const teardown = slot[SLOT]
+  slot[SLOT] = undefined
+  teardown?.()
+}

package/src/registry.test.ts

@@ -5,6 +5,8 @@ import { join } from 'node:path'
 import {
   DEFAULT_FRAME_COUNTS,
   DEFAULT_PET_CELL,
+  DEFAULT_TRACK_PATTERNS,
+  PET_ROW_ORDER,
   PET_SCAN_JSON_CAP,
   codexPetsDir,
   loadPetRegistry,
@@ -168,6 +170,18 @@ describe('loadPetRegistry', () => {
       readFileSync(petAtlasFile(registry.byId('whale-girl-refined')!)),
     )).toBe(false)
     expect(registry.defaultEntry().id).toBe('whale-girl')
+    // Both built-in whales and every override-free pet share the one slow
+    // global rhythm (user request: all pets were too fast at the legacy
+    // hatch-pet contract pace).
+    for (const track of PET_ROW_ORDER) {
+      expect(registry.byId('whale-girl')!.tracks[track].durations)
+        .toEqual(DEFAULT_TRACK_PATTERNS[track].durations)
+      expect(registry.byId('whale-girl-refined')!.tracks[track].durations)
+        .toEqual(DEFAULT_TRACK_PATTERNS[track].durations)
+    }
+    expect(DEFAULT_TRACK_PATTERNS.idle.durations[0]!).toBeGreaterThanOrEqual(500)
+    expect(DEFAULT_TRACK_PATTERNS['running-right'].durations[0]!).toBeGreaterThanOrEqual(300)
+    expect(DEFAULT_TRACK_PATTERNS.waving.durations[0]!).toBeGreaterThanOrEqual(450)
   })
 
   it('scans built-in assets, the custom pets dir, and composed extras with precedence', () => {

package/src/registry.ts

@@ -114,21 +114,25 @@ export interface PetTrackDef {
   fallback?: PetAnimation
 }
 
-/** Default per-track rhythm (hatch-pet contract table). */
+/**
+ * Default per-track rhythm — the shared slow baseline every sprite2d pet
+ * plays unless its manifest overrides a track (user request: all pets were
+ * too fast at the legacy hatch-pet contract pace).
+ */
 export const DEFAULT_TRACK_PATTERNS: Record<PetAnimation, {
   durations: number[]
   loop: boolean
   fallback?: PetAnimation
 }> = {
-  idle: { durations: [280, 110, 110, 140, 140, 320], loop: true },
-  'running-right': { durations: [120, 120, 120, 120, 120, 120, 120, 220], loop: true },
-  'running-left': { durations: [120, 120, 120, 120, 120, 120, 120, 220], loop: true },
-  waving: { durations: [140, 140, 140, 280], loop: true },
-  jumping: { durations: [140, 140, 140, 140, 280], loop: false, fallback: 'idle' },
-  failed: { durations: [140, 140, 140, 140, 140, 140, 140, 240], loop: false, fallback: 'idle' },
-  waiting: { durations: [150, 150, 150, 150, 150, 260], loop: true },
-  running: { durations: [120, 120, 120, 120, 120, 220], loop: true },
-  review: { durations: [150, 150, 150, 150, 150, 280], loop: true },
+  idle: { durations: [500, 500, 600, 500, 500, 600], loop: true },
+  'running-right': { durations: [300, 300, 300, 300, 300, 300, 300, 400], loop: true },
+  'running-left': { durations: [300, 300, 300, 300, 300, 300, 300, 400], loop: true },
+  waving: { durations: [450, 450, 450, 450], loop: true },
+  jumping: { durations: [400, 400, 400, 450, 450], loop: false, fallback: 'idle' },
+  failed: { durations: [550, 550, 550, 600, 650, 700, 550, 550], loop: false, fallback: 'idle' },
+  waiting: { durations: [550, 550, 600, 550, 550, 600], loop: true },
+  running: { durations: [330, 330, 330, 330, 330, 400], loop: true },
+  review: { durations: [650, 650, 650, 650, 650, 650], loop: true },
 }
 
 /** Manifest shape a pet directory (or 'PetConfig.pets' entry) declares. */

package/src/service.ts

@@ -234,6 +234,12 @@ export class PetService extends Service {
    * disposed sessions are removed by the 'session/disposed' listener.
    */
   private readonly sessionActivity = new Map<Session, SessionActivity>()
+  /**
+   * Sessions whose reward source is the official event stream. This metadata
+   * outlives transient visual resets so a derived legacy `done` cannot reward
+   * the same turn again after the pet is disabled and re-enabled.
+   */
+  private readonly officialEventSessions = new WeakSet<Session>()
 
   constructor(ctx: Context, config: PetConfig = {}) {
     super(ctx, 'pet')
@@ -356,6 +362,7 @@ export class PetService extends Service {
   setEnabled(enabled: boolean): void {
     this.enabled = enabled
     this.syncActivity()
+    if (!enabled) this.resetActivity()
   }
 
   private syncActivity(): void {
@@ -391,6 +398,7 @@ export class PetService extends Service {
           const transition = projectOfficialEvent(event, runtime)
           if (transition === undefined) return
           runtime.officialEventsSeen = true
+          this.officialEventSessions.add(session)
           this.applyActivity(session, transition.input, transition.whisper)
           if (transition.completedTurn !== undefined) {
             this.rewardTurn(String(session.id), transition.completedTurn)
@@ -398,6 +406,7 @@ export class PetService extends Service {
         }),
         this.ctx.on('session/disposed', (session: Session) => {
           this.ledger.forgetSession(String(session.id))
+          this.officialEventSessions.delete(session)
           this.sessionActivity.delete(session)
           if (session !== this.displaySession) return
           // The display session is gone: fall back to the most recent
@@ -418,12 +427,21 @@ export class PetService extends Service {
     })()
   }
 
+  /** Drop transient activity because terminal events missed while disabled cannot be replayed safely. */
+  private resetActivity(): void {
+    this.displaySession = undefined
+    this.sessionActivity.clear()
+    this.machine.onSessionDisposed()
+  }
+
   /** Return the per-session activity record, creating it on first sight. */
   private activityOf(session: Session): SessionActivity {
     let activity = this.sessionActivity.get(session)
     if (activity === undefined) {
+      const runtime = emptyProjectionRuntime(this.voicePools())
+      runtime.officialEventsSeen = this.officialEventSessions.has(session)
       activity = {
-        runtime: emptyProjectionRuntime(this.voicePools()),
+        runtime,
         machine: new PetStateMachine(this.stateConfig),
       }
       this.sessionActivity.set(session, activity)