@linxin666/dsh-pet 0.2.3 → 0.2.4

package/src/decoration.ts

@@ -0,0 +1,220 @@
+/**
+ * Status-decoration manifest v1 — fail-closed structure + warn-and-drop
+ * content, mirroring the pet manifest-v2 discipline (issue #623 M5,
+ * protocol #567). Unknown top-level fields, unsafe entry paths, out-of-
+ * range geometry and unknown renderer content reject the descriptor with
+ * human-readable diagnostics; per-phase binding issues drop that binding
+ * only. The JSON Schema twin lives at
+ * contracts/status-decoration-v1.schema.json; this hand-rolled parser is
+ * authoritative. Keep this file erasable-syntax-only (scripts/ import it
+ * under node's strip-only mode).
+ * @module @linxin666/dsh-pet/decoration
+ */
+
+import { isAbsolute } from 'node:path'
+import type { ActivityPhase } from './state.ts'
+import { PET_ACTIVITY_PHASES } from './manifest-v2.ts'
+import type {
+  DecorationDiagnostic,
+  DecorationManifest,
+  DecorationManifestParse,
+  PhaseBindings,
+  PhaseSegment,
+} from './contracts/status-decoration.ts'
+
+/** Geometry and content caps (the adopted PNG/WebP sprite-strip bounds). */
+export const DECORATION_CELL_MAX = 256
+export const DECORATION_COLUMNS_MAX = 16
+export const DECORATION_DURATION_MAX_MS = 2000
+export const DECORATION_ENTRY_EXTENSIONS = ['.webp', '.png'] as const
+export const DECORATION_DISPLAY_NAME_MAX = 64
+
+/** Field allow-list (drift-locked to the schema twin in tests). */
+export const KNOWN_DECORATION_TOP_LEVEL = new Set([
+  '$schema', 'decorationManifestVersion', 'id', 'displayName', 'license',
+  'entry', 'cell', 'columns', 'frameMs', 'durations', 'loop', 'phases',
+])
+
+const PET_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/
+const PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/
+
+class Diagnostics {
+  readonly list: DecorationDiagnostic[] = []
+  private readonly source: string
+  constructor(source: string) { this.source = source }
+  error(message: string): void { this.list.push({ level: 'error', message: this.source + ': ' + message }) }
+  warn(message: string): void { this.list.push({ level: 'warning', message: this.source + ': ' + message }) }
+  get hasErrors(): boolean { return this.list.some(d => d.level === 'error') }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function unknownKeys(source: Record<string, unknown>, known: Set<string>): string[] {
+  return Object.keys(source).filter(key => !known.has(key))
+}
+
+/** Positive integer in [min, max], else undefined. */
+function finiteInt(value: unknown, min: number, max: number): number | undefined {
+  return typeof value === 'number' && Number.isInteger(value) && value >= min && value <= max
+    ? value
+    : undefined
+}
+
+/**
+ * Validate a descriptor-relative entry path: no absolute paths, no
+ * backslashes, no traversal, plain safe segments only, and an exact
+ * lowercase PNG/WebP extension (the adopted entry discipline — SVG/CSS are
+ * not accepted). The extension match is case-sensitive on purpose: the
+ * asset route serves the declared path verbatim, so a case-mismatched
+ * suffix (frames.PNG vs frames.png) would pass a lenient check but 403 on
+ * case-sensitive filesystems.
+ * Returns the normalized path or undefined.
+ */
+export function safeDecorationEntry(raw: unknown): string | undefined {
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  const value = raw.trim()
+  if (value.length > 256) return undefined
+  if (isAbsolute(value) || value.includes('\\') || /^[a-z][a-z0-9+.-]*:/i.test(value)) return undefined
+  const segments = value.split('/').filter(segment => segment !== '')
+  if (segments.length === 0) return undefined
+  if (segments.some(segment => segment === '.' || segment === '..' || !PATH_SEGMENT_PATTERN.test(segment))) return undefined
+  const last = segments[segments.length - 1]!
+  const dot = last.lastIndexOf('.')
+  if (dot <= 0 || !(DECORATION_ENTRY_EXTENSIONS as readonly string[]).includes(last.slice(dot))) return undefined
+  return segments.join('/')
+}
+
+/** Normalize one phase binding value; undefined (warning) on bad content. */
+function normalizeSegment(
+  raw: unknown,
+  columns: number,
+  diag: Diagnostics,
+): PhaseSegment | undefined {
+  if (raw === 'hide') return 'hide'
+  if (!isRecord(raw)) {
+    diag.warn('phase binding must be "hide" or { from, to }; binding dropped')
+    return undefined
+  }
+  const from = finiteInt(raw.from, 0, columns - 1)
+  const to = finiteInt(raw.to, 0, columns - 1)
+  if (from === undefined || to === undefined || from > to) {
+    diag.warn('phase frame segment out of range; binding dropped')
+    return undefined
+  }
+  return { from, to }
+}
+
+/**
+ * Parse and validate one decoration.json document. Fail-closed over the
+ * structure (types, key sets, paths, ranges); phase-binding content issues
+ * drop that binding only (warn-and-drop, the registry never-throw rule).
+ */
+export function parseDecorationManifest(
+  raw: unknown,
+  source: string = 'decoration.json',
+): DecorationManifestParse {
+  const diag = new Diagnostics(source)
+  if (!isRecord(raw)) {
+    diag.error('descriptor must be a JSON object')
+    return { ok: false, diagnostics: diag.list }
+  }
+  for (const key of unknownKeys(raw, KNOWN_DECORATION_TOP_LEVEL)) {
+    diag.error('unknown top-level field ' + JSON.stringify(key))
+  }
+  if (raw.decorationManifestVersion !== 1) {
+    diag.error('decorationManifestVersion must be 1')
+  }
+  const id = typeof raw.id === 'string' ? raw.id.trim() : ''
+  if (!PET_ID_PATTERN.test(id)) {
+    diag.error('id must be a lowercase kebab id')
+  }
+  if (id.length > 64) {
+    diag.error('id must be at most 64 characters')
+  }
+  const license = typeof raw.license === 'string' ? raw.license.trim() : ''
+  if (license === '') diag.error('license is required (asset provenance)')
+  if (license.length > 128) {
+    diag.error('license must be at most 128 characters')
+  }
+  const entry = safeDecorationEntry(raw.entry)
+  if (entry === undefined) {
+    diag.error('entry must be a safe relative PNG/WebP path')
+  }
+  const rawCell = isRecord(raw.cell) ? raw.cell : {}
+  for (const key of Object.keys(rawCell)) {
+    if (key !== 'width' && key !== 'height') diag.warn('unknown cell field ' + JSON.stringify(key) + ' ignored')
+  }
+  const cellWidth = finiteInt(rawCell.width, 1, DECORATION_CELL_MAX)
+  const cellHeight = finiteInt(rawCell.height, 1, DECORATION_CELL_MAX)
+  if (cellWidth === undefined || cellHeight === undefined) {
+    diag.error('cell width/height must be integers in [1, ' + DECORATION_CELL_MAX + ']')
+  }
+  const columns = finiteInt(raw.columns, 1, DECORATION_COLUMNS_MAX)
+  if (columns === undefined) {
+    diag.error('columns must be an integer in [1, ' + DECORATION_COLUMNS_MAX + ']')
+  }
+  if (diag.hasErrors || id === '' || entry === undefined || columns === undefined) {
+    return { ok: false, diagnostics: diag.list }
+  }
+  const displayName = typeof raw.displayName === 'string' && raw.displayName.trim() !== ''
+    ? raw.displayName.trim().slice(0, DECORATION_DISPLAY_NAME_MAX)
+    : id
+  let loop: boolean
+  if (raw.loop === undefined || typeof raw.loop === 'boolean') {
+    loop = raw.loop ?? true
+  } else {
+    diag.warn('loop must be a boolean; defaulting to true')
+    loop = true
+  }
+  const rawDurations = raw.durations
+  let durations: number[]
+  if (Array.isArray(rawDurations)) {
+    const usable = rawDurations.filter((v): v is number => typeof v === 'number' && Number.isInteger(v) && v >= 1 && v <= DECORATION_DURATION_MAX_MS)
+    if (usable.length !== columns) {
+      diag.warn('durations length must equal columns; using the constant frameMs instead')
+      durations = []
+    } else {
+      durations = usable
+    }
+  } else if (rawDurations !== undefined) {
+    diag.warn('durations must be an array; using the constant frameMs instead')
+    durations = []
+  } else {
+    durations = []
+  }
+  if (durations.length === 0) {
+    const frameMs = finiteInt(raw.frameMs, 1, DECORATION_DURATION_MAX_MS) ?? 120
+    durations = Array.from({ length: columns }, () => frameMs)
+  }
+  const phases: PhaseBindings = {}
+  const rawPhases = raw.phases
+  if (isRecord(rawPhases)) {
+    for (const [key, value] of Object.entries(rawPhases)) {
+      if (!(PET_ACTIVITY_PHASES as readonly string[]).includes(key)) {
+        diag.warn('unknown phase ' + JSON.stringify(key) + '; binding ignored')
+        continue
+      }
+      const segment = normalizeSegment(value, columns, diag)
+      if (segment !== undefined) phases[key as ActivityPhase] = segment
+    }
+  } else if (rawPhases !== undefined) {
+    diag.warn('phases must be an object; all phases hide')
+  }
+  const visible = Object.values(phases).some(segment => segment !== 'hide')
+  if (!visible) diag.warn('no phase shows the ornament; the decoration stays hidden')
+  const manifest: DecorationManifest = {
+    decorationManifestVersion: 1,
+    id,
+    displayName,
+    license,
+    entry,
+    cell: { width: cellWidth!, height: cellHeight! },
+    columns,
+    durations,
+    loop,
+    phases,
+  }
+  return { ok: true, manifest, diagnostics: diag.list }
+}

package/src/event-projection.ts

@@ -13,7 +13,7 @@
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { PetStateInput } from './state.ts'
-import { StatusVoice, toolArgHint, WhisperEngine } from './chatter.ts'
+import { StatusVoice, toolArgHint, WhisperEngine, type VoicePoolsProvider } from './chatter.ts'
 
 /** Runtime shape of the optional legacy activity event. */
 export interface ActivityStatusEventLike {
@@ -41,14 +41,19 @@ export interface PetActivityTransition {
   whisper?: string
 }
 
-/** Fresh projection runtime for a newly seen session. */
-export function emptyProjectionRuntime(): ProjectionRuntime {
+/**
+ * Fresh projection runtime for a newly seen session. The optional voice-pack
+ * provider (pet-center M4, issue #677) hands both chatter engines their
+ * pools; engines resolve overrides at draw time, so swapping the provider's
+ * pack re-voices live runtimes without rebuilding them.
+ */
+export function emptyProjectionRuntime(pools?: VoicePoolsProvider): ProjectionRuntime {
   return {
     activeTools: new Set(),
     officialEventsSeen: false,
     stepHadFailure: false,
-    voice: new StatusVoice(),
-    whispers: new WhisperEngine(),
+    voice: new StatusVoice(pools),
+    whispers: new WhisperEngine(pools),
   }
 }
 

package/src/index.ts

@@ -134,6 +134,7 @@ export function makePetSettingsSchema(fallbackPetId: string) {
     bottom: z.number().step(1).min(0).max(DISPLAY_INSET_MAX).default(20),
     petId: z.string().default(fallbackPetId),
     enabled: z.boolean().default(true),
+    decorationEnabled: z.boolean().default(true),
   })
 }
 
@@ -163,6 +164,7 @@ function applyImpl(ctx: Context, config: PetConfig = {}): void {
     bottom: service.display().bottom,
     petId: service.selectedPetId(),
     enabled: config.enabled ?? true,
+    decorationEnabled: config.decorationEnabled ?? true,
   }
   // The browser half talks to the pet through same-origin JSON endpoints and
   // loads each pet's atlas from the registry's own media route (RPC domains

package/src/registry.test.ts

@@ -5,6 +5,7 @@ import { join } from 'node:path'
 import {
   DEFAULT_FRAME_COUNTS,
   DEFAULT_PET_CELL,
+  PET_SCAN_JSON_CAP,
   codexPetsDir,
   loadPetRegistry,
   petAtlasFile,
@@ -465,3 +466,225 @@ describe('loadPetRegistry pet-center v2 (issue #623)', () => {
     }
   })
 })
+
+describe('voice packs (pet-center M4, issue #677)', () => {
+  function writeVoice(dir: string, name: string, pack: unknown): void {
+    mkdirSync(join(dir, name), { recursive: true })
+    writeFileSync(join(dir, name, 'pet.json'), JSON.stringify({ id: name, displayName: name, spritesheetPath: 'spritesheet.webp' }), 'utf8')
+    writeFileSync(join(dir, name, 'spritesheet.webp'), 'webp', 'utf8')
+    writeFileSync(join(dir, name, 'voice.json'), JSON.stringify(pack), 'utf8')
+  }
+
+  it('loads a pet voice.json and serves its panel slice to the browser view', () => {
+    const root = tempDir()
+    try {
+      const petsDir = join(root, 'pets')
+      writeVoice(petsDir, 'talker', {
+        status: { done: ['自定义完工'] },
+        panel: { labels: { feed: '投喂' }, stats: { rank: '好感 {rank}' }, actions: ['feed'] },
+      })
+      const registry = loadPetRegistry({ packageRoot: join(root, 'none'), petsDir, dshPetsDir: '' })
+      const entry = registry.byId('talker')!
+      expect(entry.voice?.overrides.status?.done).toEqual(['自定义完工'])
+      const view = petEntryView(entry)
+      expect(view.panel).toEqual({
+        labels: { feed: '投喂' },
+        stats: { rank: '好感 {rank}' },
+        actions: ['feed'],
+      })
+      // Host-only voice content never reaches the browser half.
+      expect('voice' in view).toBe(false)
+      // A healthy voice pack records no diagnostics of its own.
+      expect(registry.diagnostics.filter(d => d.message.includes('voice'))).toEqual([])
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('warns and drops a broken voice.json without rejecting the pet', () => {
+    const root = tempDir()
+    try {
+      const petsDir = join(root, 'pets')
+      mkdirSync(join(petsDir, 'mumbler'), { recursive: true })
+      writeFileSync(join(petsDir, 'mumbler', 'pet.json'), JSON.stringify({ id: 'mumbler', displayName: 'Mumbler', spritesheetPath: 'spritesheet.webp' }), 'utf8')
+      writeFileSync(join(petsDir, 'mumbler', 'spritesheet.webp'), 'webp', 'utf8')
+      writeFileSync(join(petsDir, 'mumbler', 'voice.json'), '{ not json', 'utf8')
+      const registry = loadPetRegistry({ packageRoot: join(root, 'none'), petsDir, dshPetsDir: '' })
+      expect(registry.byId('mumbler')).toBeDefined()
+      expect(registry.byId('mumbler')!.voice).toBeUndefined()
+      expect(registry.diagnostics.some(d => d.level === 'warning' && d.message.includes('voice pack is not valid JSON'))).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('loads the global .voice.json override from the DSH_HOME pets dir', () => {
+    const root = tempDir()
+    try {
+      const petsDir = join(root, 'pets')
+      mkdirSync(join(petsDir, 'plain'), { recursive: true })
+      writeFileSync(join(petsDir, 'plain', 'pet.json'), JSON.stringify({ id: 'plain', displayName: 'Plain', spritesheetPath: 'spritesheet.webp' }), 'utf8')
+      writeFileSync(join(petsDir, 'plain', 'spritesheet.webp'), 'webp', 'utf8')
+      writeFileSync(join(petsDir, '.voice.json'), JSON.stringify({
+        status: { done: ['全局完工'] },
+        panel: { labels: { hide: '全局藏' } },
+      }), 'utf8')
+      const registry = loadPetRegistry({ packageRoot: join(root, 'none'), petsDir, dshPetsDir: petsDir })
+      expect(registry.globalVoice?.overrides.status?.done).toEqual(['全局完工'])
+      expect(registry.globalVoice?.panel?.labels).toEqual({ hide: '全局藏' })
+      // The dotfile itself is never scanned as a pet directory.
+      expect(registry.entries.map(e => e.id)).toEqual(['plain'])
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('serves the merged panel chrome (per-pet over global, per slot)', () => {
+    const root = tempDir()
+    try {
+      const petsDir = join(root, 'pets')
+      mkdirSync(join(petsDir, 'plain'), { recursive: true })
+      writeFileSync(join(petsDir, 'plain', 'pet.json'), JSON.stringify({ id: 'plain', displayName: 'Plain', spritesheetPath: 'spritesheet.webp' }), 'utf8')
+      writeFileSync(join(petsDir, 'plain', 'spritesheet.webp'), 'webp', 'utf8')
+      writeFileSync(join(petsDir, 'plain', 'voice.json'), JSON.stringify({
+        panel: { labels: { feed: '宠物投喂' }, stats: { treats: '宠物鱼干 {n}' } },
+      }), 'utf8')
+      writeFileSync(join(petsDir, '.voice.json'), JSON.stringify({
+        panel: { labels: { feed: '全局投喂', hide: '全局藏' } },
+      }), 'utf8')
+      const registry = loadPetRegistry({ packageRoot: join(root, 'none'), petsDir, dshPetsDir: petsDir })
+      const entry = registry.byId('plain')
+      expect(entry).toBeDefined()
+      const view = petEntryView(entry!, registry.globalVoice)
+      // The pet's own slot wins; untouched global slots layer underneath.
+      expect(view.panel?.labels).toEqual({ feed: '宠物投喂', hide: '全局藏' })
+      expect(view.panel?.stats?.treats).toBe('宠物鱼干 {n}')
+      // A pack-less pet would receive the global panel as-is.
+      const bare = resolvePetManifest({ id: 'bare', displayName: 'Bare', spritesheetPath: 'spritesheet.webp' }, join(tmpdir(), 'bare'))
+      expect(petEntryView(bare!, registry.globalVoice).panel?.labels).toEqual({ feed: '全局投喂', hide: '全局藏' })
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('skips an oversized voice.json with a warning instead of reading it', () => {
+    const root = tempDir()
+    try {
+      const petsDir = join(root, 'pets')
+      mkdirSync(join(petsDir, 'loud'), { recursive: true })
+      writeFileSync(join(petsDir, 'loud', 'pet.json'), JSON.stringify({ id: 'loud', displayName: 'Loud', spritesheetPath: 'spritesheet.webp' }), 'utf8')
+      writeFileSync(join(petsDir, 'loud', 'voice.json'), '{ ' + 'x'.repeat(PET_SCAN_JSON_CAP) + ' }', 'utf8')
+      const registry = loadPetRegistry({ packageRoot: join(root, 'none'), petsDir, dshPetsDir: '' })
+      expect(registry.byId('loud')!.voice).toBeUndefined()
+      expect(registry.warnings.some(w => w.includes('scan ceiling'))).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('skips a non-regular voice.json with a warning', () => {
+    const root = tempDir()
+    try {
+      const petsDir = join(root, 'pets')
+      mkdirSync(join(petsDir, 'odd', 'voice.json'), { recursive: true })
+      writeFileSync(join(petsDir, 'odd', 'pet.json'), JSON.stringify({ id: 'odd', displayName: 'Odd', spritesheetPath: 'spritesheet.webp' }), 'utf8')
+      const registry = loadPetRegistry({ packageRoot: join(root, 'none'), petsDir, dshPetsDir: '' })
+      expect(registry.byId('odd')!.voice).toBeUndefined()
+      expect(registry.warnings.some(w => w.includes('not a regular file'))).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})
+describe('status decorations (pet-center M5, #567)', () => {
+  function writeDecoration(dir: string, name: string, manifest: Record<string, unknown>, strip = 'whale-frames.png'): void {
+    mkdirSync(join(dir, name), { recursive: true })
+    writeFileSync(join(dir, name, 'decoration.json'), JSON.stringify(manifest), 'utf8')
+    writeFileSync(join(dir, name, strip), 'png', 'utf8')
+  }
+
+  const baseManifest = () => ({
+    decorationManifestVersion: 1,
+    id: 'whale',
+    displayName: '喷水鲸鱼',
+    license: 'MIT',
+    entry: 'whale-frames.png',
+    cell: { width: 64, height: 48 },
+    columns: 4,
+    phases: { idle: 'hide', thinking: { from: 0, to: 3 } },
+  })
+
+  it('scans built-in decorations and exposes the browser view fields', () => {
+    const root = tempDir()
+    try {
+      const assets = join(root, 'assets')
+      writeDecoration(join(assets, 'decorations'), 'whale', baseManifest())
+      const registry = loadPetRegistry({ packageRoot: root, petsDir: '', dshPetsDir: '' })
+      const entry = registry.decorationById?.('whale')
+      expect(entry).toBeDefined()
+      expect(entry!.entryUrl).toBe('/api/pet/decoration/whale/whale-frames.png')
+      expect(entry!.servable).toEqual(['decoration.json', 'whale-frames.png'])
+      expect(entry!.phases.thinking).toEqual({ from: 0, to: 3 })
+      // The pet entries list is untouched by decorations.
+      expect(registry.entries).toEqual([])
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('lets a user decoration override the built-in by id', () => {
+    const root = tempDir()
+    try {
+      writeDecoration(join(root, 'assets', 'decorations'), 'whale', baseManifest())
+      const dsh = join(root, 'dsh')
+      writeDecoration(join(dsh, 'decorations'), 'whale', { ...baseManifest(), displayName: '家用鲸鱼' })
+      const registry = loadPetRegistry({ packageRoot: root, petsDir: '', dshPetsDir: dsh })
+      expect(registry.decorationById?.('whale')?.id).toBe('whale')
+      expect(registry.warnings.some(w => w.includes('user decoration whale overrides'))).toBe(true)
+      expect(registry.decorationById?.('whale')?.entryUrl).toBe('/api/pet/decoration/whale/whale-frames.png')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('warns and skips a broken descriptor without disturbing pets', () => {
+    const root = tempDir()
+    try {
+      mkdirSync(join(root, 'assets', 'decorations', 'broken'), { recursive: true })
+      writeFileSync(join(root, 'assets', 'decorations', 'broken', 'decoration.json'), '{ not json', 'utf8')
+      const registry = loadPetRegistry({ packageRoot: root, petsDir: '', dshPetsDir: '' })
+      expect(registry.decorations).toEqual([])
+      expect(registry.diagnostics.some(d => d.level === 'error' && d.message.includes('broken'))).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('skips an oversized decoration.json with a warning instead of reading it', () => {
+    const root = tempDir()
+    try {
+      mkdirSync(join(root, 'assets', 'decorations', 'huge'), { recursive: true })
+      writeFileSync(join(root, 'assets', 'decorations', 'huge', 'decoration.json'), '{ ' + 'x'.repeat(PET_SCAN_JSON_CAP) + ' }', 'utf8')
+      const registry = loadPetRegistry({ packageRoot: root, petsDir: '', dshPetsDir: '' })
+      expect(registry.decorations).toEqual([])
+      expect(registry.warnings.some(w => w.includes('scan ceiling'))).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('lists a decoration with a missing strip and warns about the file', () => {
+    const root = tempDir()
+    try {
+      const dir = join(root, 'assets', 'decorations', 'ghost')
+      mkdirSync(dir, { recursive: true })
+      writeFileSync(join(dir, 'decoration.json'), JSON.stringify(baseManifest()), 'utf8')
+      const registry = loadPetRegistry({ packageRoot: root, petsDir: '', dshPetsDir: '' })
+      // The entry id comes from the descriptor (the directory name is free).
+      expect(registry.decorationById?.('whale')).toBeDefined()
+      expect(registry.warnings.some(w => w.includes('strip file missing'))).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})